By default, SCUA I/O blocks. That is the right default for scripts and tools: simple, predictable, done. But a server or a host with its own event loop wants calls in flight to overlap, and most languages charge a steep price for that: the async keyword spreads through your call stack, coloring every function it touches.
SCUA now does it without the coloring. Run with
--io=async (or install the I/O platform from an embedding
host) and a capability call inside an actor handler parks the handler
instead of blocking the thread. The host performs the operation however
it likes, completes it by token, and the handler resumes with an
ordinary Ok or Error value. The function you
wrote does not know any of this happened. There is no
async, no await, and no second dialect of the
language for concurrent code.
On top of the same machinery, wait_all runs a list of
jobs together and gives every result back in order, and
map_all maps a function over a list under a concurrency
cap. One job failing never cancels the rest; its Error just
sits in its slot.
The design carries one rule we consider load-bearing: if a partition
is snapshotted while a call is in flight, that call resumes as
Error("interrupted") and the runtime never re-issues it.
You cannot know from the outside whether the request landed before the
freeze, so SCUA refuses to guess, and a half-finished POST can never
fire twice behind your back. Your handler gets a value and decides. That
rule looked like a crash-safety footnote when we wrote it down. It
turned out to be the foundation for something much bigger, which August
will show.