<summary>Execute multiple calls in a single round-trip.</summary>

<summary>Write a length-prefixed frame to <paramref name="stream"/>.</summary>

Accept a connected transport and spawn a connection handler task. `peer_id` is a stable identifier for the peer (used in logs and for provider deregi

Decode a raw MessagePack frame into an outbound [`Envelope`] (used to receive frames pushed by the runtime, e.g. provider calls).

Encode a serializable value as MessagePack `Bytes`.

Build a `Value` that encodes a given `ResourceHandle` (same as the wire format).

Spawn a minimal provider task that automatically echoes every Call. Returns the [`ProviderRegistry`] with the provider registered, plus a join handle

Helpers

Spin up a provider on one side of an in-memory pair and return a connected client on the other side. The provider task is detached; it will stop when

Build a `ProviderRegistry` with a single provider subscribed to `namespace`.

Build a minimal one-function schema with no required arguments.

Merge an entire [`Schema`] document into the registry. Types are added to the shared type library; namespaces are registered under `provider_id`.

Register an error / close handler.

Run a shell command with error handling and logging.

# Safety `stream` must be a valid handle returned by `saikuro_client_stream_json`. `out_item_json` and `out_done` must be non-null writable pointers

Serialise a [`Schema`] into a [`Value`] suitable for `Envelope::announce`.

Spawn a background task that answers every work item with `result_value`.

Take the inbound receiver (client -> provider) for a channel.

Serialise to a plain dict for embedding in an Envelope ``args`` list.

Normalize `-`, `/`, `\` to `_`, collapse consecutive separators, trim leading/trailing separators, then convert to PascalCase.

Convert this handle into a [`Value`] map suitable for embedding in an envelope `result` field.

Set the MIME type.

Set a namespace prefix.

Set the byte size.

* Send a schema-announcement envelope and wait for the runtime's ack. * Any failure is logged but does not abort the serve loop.

Execute multiple calls in a single batch envelope and return all results. Results are returned in the same order as `calls`. Individual item failure

Build a Rust component using wasm-pack.

Fire-and-forget invocation. No response is expected.

Check whether `caller_caps` satisfies the requirements declared in `function_schema`. In sandbox mode, [`Visibility::Internal`] functions are always

Format a number with thousands separators.

Try to extract a string field from a JS object-typed JsValue.

Look up a function descriptor given a fully-qualified target string. Returns `None` if either the namespace or the function does not exist.

Construct a schema-announcement envelope. ``schema_dict`` is the plain-dict representation of a Schema produced by :py:meth:`saikuro.

Construct a `Log`-type envelope carrying a [`LogRecord`].

Register a provider handle for the given namespaces. If a namespace already has a provider, the old one is replaced and a warning is emitted.

Register a function handler with schema metadata.

* Invoke a provider function that manages an external resource and return * the resulting {@link ResourceHandle}. * * Throws a `SaikuroError`

Route an outbound channel item (provider -> client direction) to the appropriate open channel's outbound queue. Called by the provider adapter when i

# Safety `channel` must be a valid handle returned by `saikuro_client_channel_json`. `out_item_json` and `out_done` must be non-null writable pointer

Serve on an already-connected transport.

Serialise to a plain dict for embedding in a response ``result``.

Set the direct-access URI.