Run a future to completion on the current WASM thread. This uses `futures::executor::block_on` which polls the future in a loop. ## Important On si

* Receive and deserialise the next message. * Returns `null` when the connection has been closed by the peer.

Look up the provider for a namespace.

Close the transport gracefully.

Spawn a future on the JS/WASM executor.

Return an iterator over all tokens in the set.

Add a function schema.

* Register a function under the given local `name` within this provider's * namespace. The full qualified name becomes `"<namespace>.<name>"`.

Create a connected pair of in-memory transports.

Add a token to the set.

<summary> Register a synchronous or async function. The <paramref name="handler"/> receives the args list and must return the result as <c>object?</c>

Return the number of tokens in the set.

Return `true` if no tokens are held.

<summary>Gracefully close the client and its transport.</summary>

<summary> Receive the next message. Returns <c>null</c> on clean EOF (peer closed). </summary>

<summary>Send a message to the provider side of the channel.</summary>

Register a function handler. The closure receives a `Vec<Value>` (JSON values) and must return a `Future<Output = Result<Value>>`. ```no_run # use s

Construct the most specific subclass for a wire error payload.

Construct the most specific subclass for a wire error payload.

* Return the namespace schema as a plain {@link SaikuroSchema} object * suitable for schema announcement. * * When a handler was registered w

<summary>Construct the most specific subclass for a wire error payload.</summary>

Forward a structured log record to the runtime log sink. This is fire-and-forget and does not wait for a response.

Construct a successful response carrying a result value.

Imperative variant of `register`.

Block on a future using the single-threaded wasm executor.

Produce a cheap [`RuntimeHandle`] that can be cloned and shared across tasks.

Receive the next item from the stream. Returns `None` when the stream is closed.

Register a handler invoked for every received message.

<summary>Deserialise from a raw MessagePack map.</summary>

Wire the "simulated adapter" side: returns `(sender, receiver)` for the test to drive, while the runtime's `ConnectionHandler` is spawned in the backg

* Wire a SaikuroClient and SaikuroProvider together over an InMemoryTransport * pair, bypassing the announce handshake (not needed for unit tests).

Connect the transport and start the receive loop.

Handle one inbound invocation envelope.

Build the runtime. This does not start any listener loops; use [`RuntimeHandle`] methods to attach transports.

Decode a raw MessagePack frame into a [`ResponseEnvelope`].

Time utilities

Spawn blocking I/O, converting [`JoinError`] to [`StorageError`].

* Perform a request/response call and return the result value. * * @throws {SaikuroError} (or a specific subclass) on a wire-level error. * @

Encode an [`Envelope`] to raw MessagePack bytes (as any adapter would).

<summary>Add two integers.</summary>

<summary>Connect the transport and start the receive loop.</summary>

Invocation API Perform a request/response call and return the result.

Construct a client from a transport without connecting immediately.

Wire a SaikuroClient and SaikuroProvider together without the announce handshake so tests are instant.

<summary>Serialise to the canonical MessagePack-ready dictionary.</summary>

<summary>Construct a client from a transport without connecting.</summary>

* Dispatch a single inbound invocation envelope. * * Called by the serve loop and also usable in testing.

Deserialise from a plain dict (as decoded from MessagePack). Raises :class:`ValueError` if ``d`` is not a mapping or is missing the r

Construct a client from an already-instantiated transport without connecting.

Return the schema announcement dict for this namespace.

Perform a request/response call and return the result. Raises: SaikuroError (or a specific subclass) on failure. asyn