@net-mesh/browser 0.37.0

package/dist/net_leaf.js

@@ -0,0 +1,3753 @@
+/* @ts-self-types="./net_leaf.d.ts" */
+
+/**
+ * A browser node.
+ */
+export class LeafNode {
+    static __wrap(ptr) {
+        const obj = Object.create(LeafNode.prototype);
+        obj.__wbg_ptr = ptr;
+        LeafNodeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LeafNodeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_leafnode_free(ptr, 0);
+    }
+    /**
+     * The anchor's node id, as 16 lowercase hex digits.
+     * @returns {string}
+     */
+    anchor_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_anchor_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Build, sign and publish this leaf's announcement.
+     *
+     * `capabilities` become tags alongside the mandatory `leaf` and
+     * `transport:rtc`; `reflex_addr` and `rtc_addr` stay absent.
+     * @param {string[]} capabilities
+     * @returns {Promise<void>}
+     */
+    announce(capabilities) {
+        const ptr0 = passArrayJsValueToWasm0(capabilities, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_announce(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Apply one signed revocation bundle from the control-plane
+     * feed, and say how many floors it raised.
+     *
+     * The landing point of the revocation feed: signed
+     * `OrgRevocationBundle` wire bytes, verified **in-leaf** by the
+     * node's own org authority before any floor moves. This is
+     * never a trust-the-JS setter — a forged bundle is refused here
+     * exactly as it is refused on the carrier's other paths — and
+     * the raise-only merge means an old but validly signed bundle
+     * can never roll floors back.
+     * @param {string} bundle_hex
+     * @returns {number}
+     */
+    apply_org_revocation_bundle(bundle_hex) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(bundle_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.leafnode_apply_org_revocation_bundle(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return r0 >>> 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Arm the network-change re-attempt trigger.
+     *
+     * Installs the window's `online` listener; the ICE
+     * `disconnected` → `failed` watcher is already on every peer
+     * connection this transport owns. From here, either
+     * observation files a trigger and
+     * [`crate::retry::RetryPolicy`] decides — once per network
+     * change, per peer.
+     *
+     * # Why a page has to ask
+     *
+     * Re-dialling is policy, and policy is the application's. A
+     * library that re-offered on its own would take that decision
+     * away from a page that has a reason not to: one that is
+     * deliberately holding a pair on the routed path, one tearing
+     * down, one whose user is on a metered link. §9 step 6 makes
+     * the routed session a supported disposition rather than a
+     * degraded one, so "the pair is relayed" is not a fault this
+     * leaf may assume it should fix.
+     *
+     * **Idempotent.** A second call adds no second listener,
+     * because two listeners for one `online` event are two triggers
+     * for one network change — and while the owner would coalesce
+     * them, a page that armed twice should not be relying on that.
+     *
+     * Only pairs this leaf took direct **as the offerer** are
+     * re-attempted: §9 step 4 gives the offerer the initiating
+     * role, and both sides re-offering one network change is two
+     * attempts per pair plus a supersession race.
+     */
+    arm_network_retry() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_arm_network_retry(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Call `service` on the anchor.
+     *
+     * Resolves to the reply body, or rejects with the typed
+     * failure — `Timeout`, `SessionLost`, `Refused(status)`. Never
+     * a silent retry.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {number | null} [timeout_ms]
+     * @returns {Promise<Uint8Array>}
+     */
+    call(service, payload, timeout_ms) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped unary call.
+     *
+     * The call runs the full admission (the org proof kinds and the
+     * session fence included) and resolves the response body.
+     * Opening refusal rejects `admission-denied` with its coarse
+     * reason (`rpc: refused (9): <coarse>`); a midstream revocation
+     * is the same denial as the terminal.
+     *
+     * The deadline is **absolute** and defaults to 300 s (`deadlineMs`
+     * absent is never "no deadline"); a frozen tab gets no lease
+     * extension and on wake an overdue call retires with its
+     * deadline terminal. Nothing here ever resumes a retired call —
+     * re-opening is a fresh call with a fresh proof and MAY repeat
+     * effects. Node or tab close retires ownership: pending calls
+     * fail typed.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {any} opts
+     * @returns {Promise<Uint8Array>}
+     */
+    call_org(service, payload, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call_org(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped client-streaming call. `send` pushes items,
+     * `finish` half-closes and resolves the response body. See
+     * [`Self::call_org`] for the deadline, suspension and closure
+     * contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgUploadCallHandle>}
+     */
+    call_org_client_stream(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped duplex call. See [`Self::call_org`] for the
+     * deadline, suspension and closure contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgDuplexCallHandle>}
+     */
+    call_org_duplex(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call_org_duplex(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped server-streaming call. See [`Self::call_org`]
+     * for the deadline, suspension and closure contract — it holds
+     * for every shape. The typed terminal error arrives as the
+     * stream's final `next()` item, and dropping/cancelling the
+     * handle emits exactly one CANCEL.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {any} opts
+     * @returns {Promise<OrgByteStreamHandle>}
+     */
+    call_org_streaming(service, payload, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call_org_streaming(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * Close the node: every session, every channel, every pending
+     * call.
+     *
+     * Pending calls fail `RpcError::SessionLost` — typed, and not
+     * re-issued by anybody.
+     */
+    close() {
+        wasm.leafnode_close(this.__wbg_ptr);
+    }
+    /**
+     * Bootstrap against an anchor and return a connected node.
+     *
+     * `opts`: `{ credentialB64, bootstrapUrl?, origin, iceServers? }`.
+     * `bootstrapUrl` overrides the credential's when present;
+     * everything else Layer 0 needs — the pinned anchor key, the
+     * PSK, the listener URL — comes from the credential itself.
+     *
+     * `iceServers` is optional and **defaults to the anchor's
+     * separately announced STUN endpoint** (the `stun_addr` field
+     * of `GET /rtc/anchor`), so the advertised configuration works
+     * without the page choosing a STUN service. An anchor that
+     * announced none leaves the connection with no ICE servers.
+     *
+     * A supplied `iceServers` is honoured verbatim, with one
+     * refusal: an entry naming this connection's peer RTC endpoint
+     * as its STUN server is
+     * [`LeafError::IceServerConflictsWithPeer`], returned before
+     * any ICE work. Detection is endpoint equality only; see
+     * [`crate::bootstrap::check_ice_servers_against_peer`].
+     * @param {any} opts
+     * @returns {Promise<LeafNode>}
+     */
+    static connect(opts) {
+        const ret = wasm.leafnode_connect(addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * Every counter, as JSON. u64s are decimal strings.
+     * @returns {string}
+     */
+    counters_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_counters_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The ICE servers a `connect(opts)` with this options object
+     * would configure its `RTCPeerConnection` with, as JSON.
+     *
+     * Not a convenience: it is the only way for a caller — or a
+     * test — to see what the leaf made of the `RTCIceServer[]` it
+     * was handed *before* a connection attempt consumes it. Stage 5
+     * read those objects with `as_string`, so every one of them
+     * dropped and a page's STUN/TURN configuration was silently
+     * absent from the offer. Reads through exactly the parser
+     * [`Self::connect`] uses.
+     *
+     * Shape: `[{"urls":["stun:host:3478"],"username":"u",
+     * "credential":"c"}]`, `username`/`credential` present only
+     * when the entry carried them.
+     *
+     * It reports what the **caller** configured, so an options
+     * object with no `iceServers` reads `[]` here even though
+     * [`Self::connect`] will substitute the anchor's announced
+     * STUN endpoint: the substitute is not knowable without an
+     * anchor to ask, and inventing one would make this method lie
+     * about the only thing it can see.
+     * @param {any} opts
+     * @returns {string}
+     */
+    static effective_ice_servers(opts) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_effective_ice_servers(retptr, addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * What an `open_stream(opts)` with this options object would
+     * actually ask the node for, as JSON — the same read, without
+     * the stream.
+     *
+     * Shape: `{"reliability":"reliable","label":"app",
+     * "streamId":"0000000000000009","channelHash":7,
+     * "peer":"00366d403ce19dac"}`, with `streamId` `null` when the
+     * caller did not pin one (the node allocates), `channelHash`
+     * `null` when absent, and `peer` `null` when the stream
+     * addresses the anchor.
+     * @param {any} opts
+     * @returns {string}
+     */
+    static effective_stream_options(opts) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_effective_stream_options(retptr, addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Run the enrollment exchange against the anchor.
+     *
+     * [`Self::connect`] awaits this already, so a page never needs
+     * it; it is here because "still provisional" and "the anchor
+     * was slow" are the same symptom from the outside — an nRPC
+     * timeout — and a harness needs to be able to drive and
+     * observe the step that distinguishes them.
+     *
+     * A refusal is typed and final: the invite is single-use, so
+     * nothing here retries. Retrying would burn it and turn a
+     * legible refusal into an illegible replay.
+     * @returns {Promise<void>}
+     */
+    enroll() {
+        const ret = wasm.leafnode_enroll(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Whether the anchor has admitted this leaf.
+     *
+     * `false` after a successful handshake means the session is
+     * still provisional, which is the discriminator a harness needs
+     * when a call times out: §12 refused it, rather than the
+     * service being slow.
+     * @returns {boolean}
+     */
+    is_enrolled() {
+        const ret = wasm.leafnode_is_enrolled(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * How many callbacks are registered on this node right now.
+     *
+     * **Observable so the bound can be asserted rather than
+     * inferred**, exactly as `Reassembler::outstanding` is. The
+     * property that matters is that repeated stream open/close
+     * leaves this flat: a registration that close does not remove
+     * is retained for the life of the node, keeps being invoked
+     * for every event, and keeps its captured consumer wrapper
+     * alive. A number nobody can read is a bound nobody can test.
+     * @returns {number}
+     */
+    listener_count() {
+        const ret = wasm.leafnode_listener_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The largest payload one packet carries, as the wire defines
+     * it: `MAX_PAYLOAD_SIZE` minus the event frame's length prefix.
+     *
+     * Published because an application that must keep a message
+     * inside one packet has no other way to learn the number, and
+     * the two wrong ways are both reachable: hardcoding 8 108
+     * treats the packet cap as available data bytes and overruns by
+     * the prefix, and hardcoding any figure freezes a wire constant
+     * into application code.
+     *
+     * A **static**, not a node method: it is a property of the wire,
+     * identical for every node, so reading it must not require a
+     * connection.
+     * @returns {number}
+     */
+    static maxEventBytes() {
+        const ret = wasm.leafnode_maxEventBytes();
+        return ret >>> 0;
+    }
+    /**
+     * This node's id, as 16 lowercase hex digits.
+     * @returns {string}
+     */
+    node_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_node_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Register an event listener. Each receives one JSON string per
+     * event.
+     *
+     * Returns the token that cancels it, the same currency
+     * [`LeafStream::on_message`] hands back. A node-wide listener
+     * lives as long as the node by default, which is what a page
+     * registering one at startup wants; a harness or a component
+     * that registers per episode needs to be able to give it back.
+     * @param {Function} callback
+     * @returns {string}
+     */
+    on_event(callback) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_on_event(retptr, this.__wbg_ptr, addHeapObject(callback));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Open an application stream.
+     *
+     * `opts`: `{ reliability: "reliable" | "fireAndForget",
+     * reliable?: boolean, label?, streamId?, channelHash?, peer? }`.
+     * `streamId` (a decimal or `0x`-hex **string**, because a `u64`
+     * never crosses as a JS number) and `channelHash` (a **number**
+     * in `0..=65535`) are used verbatim when present, so a stream
+     * can match a publish contract a native handler dispatches on.
+     *
+     * `peer` is **16 hex digits** — the spelling `node_id_hex()`
+     * hands out and the four §9 peer methods take — and names the
+     * node the stream addresses; absent, it is the anchor, which is
+     * what every caller before this option got and still gets. It
+     * is the page-facing half of §9: `connectPeer` installs a
+     * direct leaf ↔ leaf session and this is what puts application
+     * bytes on it. Nothing below it changes —
+     * `crate::node::LeafNode::open_stream` has always taken a peer
+     * and `route_outbound` has always decided routed vs direct, so
+     * a stream to a peer whose session is still ROUTED rides the
+     * anchor and needs no second call to start riding the
+     * DataChannel.
+     *
+     * **But the HANDLE does not survive the upgrade.** §9 step 4
+     * installs a *replacement* session, so the peer's incarnation
+     * changes, and a `StreamHandle` is fenced to the incarnation it
+     * was opened on
+     * (`LeafNode::check_handle` — the alias the
+     * native R12 fix closed): a handle opened while the pair was
+     * routed refuses with "stale stream handle … reopen the
+     * stream" once the direct session lands. The addressing is
+     * unchanged — same peer, same `streamId` if one was pinned —
+     * so reopening is one call and the far end sees the same
+     * stream; what is not true is that the old handle keeps
+     * working. A page driving a peer across the upgrade should
+     * reopen on that refusal.
+     *
+     * A peer with no session at all refuses typed from `send`,
+     * unchanged.
+     *
+     * Both are read by `stream_options`, which
+     * [`crate::leader_session::MeshSession::open_stream`] also
+     * calls: the direct and the proxied surface cannot read the
+     * same option object two ways. That surface now **carries**
+     * `peer` in its request rather than refusing it, so a follower
+     * addresses a peer exactly as this surface does.
+     * @param {any} opts
+     * @returns {LeafStream}
+     */
+    open_stream(opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_open_stream(retptr, this.__wbg_ptr, addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return LeafStream.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * This node's **origin hash**, as 16 lowercase hex digits.
+     *
+     * Not the node id, and not interchangeable with it: the origin
+     * hash is derived from the entity key and is what rides every
+     * packet header this node seals, what names its nRPC reply
+     * channels (`<service>.replies.<origin>`), and what a receiver
+     * compares an event's `EventMeta.origin_hash` against — a
+     * direct peer whose packet origin and payload origin disagree
+     * has its frame dropped before admission, so anything that
+     * builds an event payload for this node to send MUST name this
+     * value.
+     * @returns {string}
+     */
+    origin_hash_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_origin_hash_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Answer the offer `peer` sent — the other half of §9 step 3.
+     *
+     * Resolves to the dialog id the offerer minted, which the page
+     * uses exactly as `peer_offer`'s caller does.
+     *
+     * The offer applied here is the one that arrived as a
+     * **verified** envelope: signature checked against the sender's
+     * signed announcement, inside its `not_after`, and unreplayed.
+     * The page passes no SDP, which is why an offer it never
+     * received cannot be answered and an offer it did receive
+     * cannot be altered.
+     *
+     * A second offer from the same peer supersedes the first: the
+     * old dialog is counted `ice_failed` and its id stops being the
+     * live one, which is what the page's next call sees.
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_accept_offer(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_accept_offer(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Service `peer`'s attempt once, and say where it stands.
+     *
+     * This is the trickle pump the page's drive loop calls. It does
+     * four things, all of them for one attempt:
+     *
+     * - applies the peer's `Answer` if one has arrived (an offerer
+     *   only: an answerer already has the offer's description);
+     * - sends every candidate this browser has gathered for `peer`
+     *   as a signed `Candidate` envelope;
+     * - applies every candidate the peer trickled;
+     * - evaluates the attempt's ICE deadline, and settles
+     *   `udp_blocked` or `ice_relayed` when it has passed.
+     *
+     * Resolves to JSON: `{"dialog":"<16 hex>","state":"gathering"
+     * |"open"|"iceTimeout"|"udpBlocked","sent":<n>,"applied":<n>,
+     * "answered":<bool>,"remainingMs":"<decimal>"}`. `dialog` is
+     * the attempt that is CURRENTLY live for this peer, so a page
+     * whose dialog id no longer matches has been superseded — the
+     * one disposition this call cannot report for itself, because
+     * the attempt it would report about is gone.
+     *
+     * A candidate the browser rejects is not fatal to the attempt —
+     * the channel opening is what matters — but it is no longer
+     * SILENT. The engine's own error text rides back as
+     * `candidateError` (first one only, JSON-escaped) and is warned
+     * to the console. It was previously swallowed entirely: the
+     * success count rose or it did not, and nothing anywhere said
+     * why, which is the difference between "ICE is working on it"
+     * and "ICE has nothing to work with".
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_candidate(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_candidate(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * [`Self::peer_candidate`], for a caller that names the dialog
+     * it is driving.
+     *
+     * The proxied form. A follower's request is served by another
+     * tab after crossing a channel, so the attempt it was issued for
+     * may already have been replaced — and servicing a *replacement*
+     * under a stale request is a mutation, not a misclassification.
+     * `attempt_for` refuses first.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @returns {Promise<string>}
+     */
+    peer_candidate_in(peer_hex, dialog_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_candidate_in(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+     * The live attempt's dialog, 16 hex digits, when `peer` is
+     * **already a healthy direct pair** — session installed, no
+     * relay entry, transport open — and `null` otherwise.
+     *
+     * What makes `connectPeer` idempotent. A second offer to a
+     * healthy pair is not a no-op: its connection replaces the
+     * transport's link, which closes the working one under the other
+     * side, and the answerer never asked for a new attempt — so the
+     * pair ends up reading direct with a closed channel. A page (or a
+     * library, like netcode or a lobby) that calls `connectPeer` "to
+     * be sure" must get the pair it already has.
+     * @param {string} peer_hex
+     * @returns {string | undefined}
+     */
+    peer_direct_dialog(peer_hex) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.leafnode_peer_direct_dialog(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            let v2;
+            if (r0 !== 0) {
+                v2 = getStringFromWasm0(r0, r1);
+                wasm.__wbindgen_export5(r0, r1 * 1, 1);
+            }
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Run the Noise handshake with `peer` over the direct
+     * DataChannel — §9 step 4.
+     *
+     * **Takes a peer id and nothing else.** A page that could
+     * supply a Noise key could supply *any* key, so the responder
+     * static this handshake authenticates comes from `peer`'s
+     * signature-verified announcement and the PSK from the
+     * credential `connect` was given. There is no parameter through
+     * which either can be substituted, which is the point.
+     *
+     * The offerer's role, per §9 step 4: the leaf that created the
+     * offer is the NKpsk0 initiator. The answerer never calls this
+     * — its half runs from the inbound packet, in
+     * `Inner::on_handshake`.
+     *
+     * On success the direct session is installed on this side and
+     * the relay entry for `peer` is gone, so the pair's traffic
+     * leaves on its own channel. The session replacement itself is
+     * the node's — `LeafNode::install_session`, the
+     * Stage 3/4a fence, unchanged and unreached from here.
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_handshake(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_handshake(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * [`Self::peer_handshake`], for a caller that names the dialog
+     * it is driving.
+     *
+     * The proxied form, and the one where a stale request costs most:
+     * the Noise wait is the longest await on this surface, and the
+     * session it installs must belong to the attempt that negotiated
+     * the channel. A peer-only resolution would run a superseded
+     * request's handshake on the replacement.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @returns {Promise<string>}
+     */
+    peer_handshake_in(peer_hex, dialog_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_handshake_in(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+     * Offer a direct connection to `peer` — §9 steps 2 and 3.
+     *
+     * Resolves to the dialog id, 16 hex digits, which is what the
+     * page correlates every later call on this attempt against.
+     *
+     * Three things happen, in this order:
+     *
+     * 1. **Discovery is required.** With no verified announcement
+     *    for `peer` this refuses before anything is allocated:
+     *    there is no key to handshake against and no authority to
+     *    verify the peer's envelopes with, and guessing either is
+     *    the failure mode this whole surface exists to prevent.
+     * 2. **The relayed session comes up** if there is not one
+     *    already (§9 step 2): NKpsk0 over the anchor's blind
+     *    forwarding, keys from the announcement. Failing here
+     *    counts nothing — no offer was created, so there is no
+     *    attempt to charge.
+     * 3. **The offer goes out** as a signed `Offer` envelope inside
+     *    that session, and `ice_attempted` moves.
+     *
+     * The deadline the attempt runs under is
+     * [`PEER_ICE_DEADLINE_MS`] from now. The re-attempt owner calls
+     * `offer_peer` directly with the episode's deadline
+     * instead, which is how a repair and the window that absorbs
+     * its duplicate triggers end up being one absolute instant
+     * rather than two that nearly agree.
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_offer(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_peer_offer(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Publish `payload` on `channel`.
+     * @param {string} channel
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    publish(channel, payload) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_publish(this.__wbg_ptr, ptr0, len0, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * Answer a capability query from the announcements this leaf
+     * verified. A JSON array of
+     * `{ node_id, entity_id, capabilities, rtc_addr, noise_pubkey, version }`.
+     * @param {string} capability
+     * @returns {Promise<string>}
+     */
+    query(capability) {
+        const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_query(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Cancel the registration `token` names.
+     *
+     * `false` when it is already gone, which is the outcome a
+     * second cancellation wanted. An unparseable token is also
+     * `false`: it names no registration, and throwing for it would
+     * make a double-close harder to write than a leak.
+     * @param {string} token
+     * @returns {boolean}
+     */
+    remove_listener(token) {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_remove_listener(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Retire the node because leadership moved off this tab, and say
+     * how many pending calls that failed.
+     *
+     * [`Self::close`] is the page saying "I am done with this node";
+     * this is the lifecycle saying "this node no longer holds the
+     * identity". The difference is the disposition of the pending
+     * calls, and it matters to the caller: a close is a
+     * `SessionLost`, and a stand-down is a `LeaderLost` naming the
+     * generation that owned the call, because "which leader did I
+     * lose" is the question a page asks next and this is the only
+     * place that knows the answer.
+     *
+     * `closed` is set **first**, so the pump the failure path runs
+     * through emits nothing, and everything after it is teardown.
+     * @param {bigint} generation
+     * @returns {number}
+     */
+    retire(generation) {
+        const ret = wasm.leafnode_retire(this.__wbg_ptr, generation);
+        return ret >>> 0;
+    }
+    /**
+     * The re-attempt owner's ledger, as JSON.
+     *
+     * `{"armed":<bool>,"online":"<n>","iceFailed":"<n>",
+     * "triggers":"<n>","started":"<n>","coalesced":"<n>",
+     * "notEligible":"<n>","openEpisodes":<n>,"owned":<n>,
+     * "last":"<disposition>"|null}`.
+     *
+     * `started` is the number the witness asserts: one network
+     * change, one re-attempt, however many observations of it
+     * arrived. `triggers` is how many arrived, and `coalesced` is
+     * the difference the owner absorbed — reported rather than
+     * hidden, because "the trigger never fired" and "it fired and
+     * was absorbed" are different facts and only one of them is a
+     * defect.
+     *
+     * `owned` is how many pairs this leaf took direct as the
+     * offerer, i.e. the set a network change is evaluated against.
+     * @returns {string}
+     */
+    retry_report() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_retry_report(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * `RtcStats` on the leaf — plan §10's telemetry surface, in the
+     * field names the NATIVE `RtcStats` uses.
+     *
+     * Page-facing as `node.rtcStats()` through
+     * `@net-mesh/browser`. `u64`s are decimal strings, the rule
+     * [`Self::counters_json`] follows.
+     *
+     * Two halves, one reading: the transport's own ledger
+     * (admission, writes, the buffered-amount high water) and the
+     * ICE attempt ledger the conformance matrix asserts on. Plus
+     * `not_applicable`, which names the 24 native fields a leaf has
+     * no meaning for **and says why** — see
+     * [`crate::counters::LeafCounters::rtc_stats_json`] for the
+     * reason that is a list of reasons rather than a wall of
+     * zeros.
+     * @returns {string}
+     */
+    rtc_stats_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafnode_rtc_stats_json(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Serve one org-scoped unary service: `handler(caller, request)`
+     * resolves the response body.
+     *
+     * # The handler-drop contract (F-S3.1-2)
+     *
+     * The retire supervisor may drop the handler future without a
+     * final poll — cancellation is observed through the retirement
+     * observables (the terminal item, the sink's typed closed
+     * refusal, and `retired`), never assumed as a handler-side
+     * event; a detached observer holding `retired` observes the
+     * signal. After retirement the handler sees typed refusals and
+     * its return value is discarded — the terminal was already
+     * sent.
+     *
+     * Closing the returned handle retires this registration's live
+     * protected calls with their exact terminals and refuses new
+     * openings (C9's protected split).
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.leafnode_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped client-streaming service:
+     * `handler(caller, requests)` resolves the response body. See
+     * [`Self::serve_org`] for the handler-drop contract and the
+     * close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_client_stream(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.leafnode_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped duplex service:
+     * `handler(caller, requests, sink)` pulls requests and pushes
+     * responses. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_duplex(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.leafnode_serve_org_duplex(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped server-streaming service:
+     * `handler(caller, request, sink)` pushes through `sink` and
+     * ends with `sink.close()` or by returning. See
+     * [`Self::serve_org`] for the handler-drop contract and the
+     * close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_streaming(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.leafnode_serve_org_streaming(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign a `0x0D02` signalling envelope for `peer` and hand it to
+     * the control plane — no session with `peer` needed.
+     *
+     * Through the boundary, not the data path. An envelope
+     * authenticates itself, so the carrier is untrusted and can be
+     * anything.
+     *
+     * **The v1 anchor carrier refuses** (R14). `AnchorControlPlane`
+     * does not carry envelopes: the Stage 4b listener reads one
+     * trickle frame type, `candidate`, and forwards nothing to a
+     * third party, so `signal` on a node connected to a real anchor
+     * returns `LeafError::ControlPlane` naming the peer it could not
+     * reach. That is deliberate — the first cut reported the local
+     * send as a delivery the anchor discarded. The carrier that does
+     * deliver today is the anchorless `MockControlPlane`; a
+     * forwarding anchor route is Stage 6's, and the trait's shape
+     * already admits it, which is why this takes a peer id and an
+     * envelope rather than a session.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @param {string} kind
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    signal(peer_hex, dialog_hex, kind, payload) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * Subscribe to `channel` on the anchor.
+     * @param {string} channel
+     * @returns {Promise<void>}
+     */
+    subscribe(channel) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_subscribe(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Release membership of `channel` on the anchor.
+     *
+     * The direct surface's release is unconditional — this node is
+     * the only consumer it knows about. The last-consumer arithmetic
+     * belongs to the session surface, where several tabs share one
+     * node and one of them stopping is not all of them stopping.
+     * @param {string} channel
+     * @returns {Promise<void>}
+     */
+    unsubscribe(channel) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_unsubscribe(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) LeafNode.prototype[Symbol.dispose] = LeafNode.prototype.free;
+
+/**
+ * One application stream.
+ */
+export class LeafStream {
+    static __wrap(ptr) {
+        const obj = Object.create(LeafStream.prototype);
+        obj.__wbg_ptr = ptr;
+        LeafStreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LeafStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_leafstream_free(ptr, 0);
+    }
+    /**
+     * Stop using the stream. The session stays; a stream is
+     * per-stream state, not a connection.
+     *
+     * Nothing leaves the wire: one DataChannel carries every stream
+     * and there is no per-stream teardown frame. What it does do is
+     * release the node's own per-stream state — the receive cursor
+     * and the stream's classification — through the same fenced
+     * entry point a stale handle is refused by. It used to do
+     * literally nothing, which meant a proxied `StreamClose`
+     * removed the leader's handle and left the node holding the
+     * stream: a page that closed and reopened the same id got the
+     * old cursor.
+     *
+     * **Every registration this stream took is given back**, so
+     * repeated open/close leaves [`LeafNode::listener_count`] flat.
+     * A callback registered through [`Self::on_message`] lives on
+     * the node, not on this object, and it captures the consumer's
+     * own callback — so a close that removed only the node's stream
+     * state left the closure attached, still invoked for every
+     * event the node produced and still holding its consumer
+     * alive, for as long as the node lived.
+     *
+     * A refusal here is reported rather than returned: the handle is
+     * being discarded either way, and `close` is the one operation
+     * for which "it was already gone" is the outcome the caller
+     * wanted.
+     */
+    close() {
+        wasm.leafstream_close(this.__wbg_ptr);
+    }
+    /**
+     * The incarnation of the session this stream was opened on,
+     * decimal — the spelling the event carries, so there is no
+     * conversion to get wrong.
+     *
+     * Provenance, not part of the filter key: see
+     * [`crate::node::LeafEvent::StreamData`].
+     * @returns {string}
+     */
+    incarnation() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafstream_incarnation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether this stream retransmits.
+     * @returns {boolean}
+     */
+    is_reliable() {
+        const ret = wasm.leafstream_is_reliable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Listen for this stream's inbound payloads.
+     *
+     * **The callback receives the node's `stream_data` event JSON
+     * string**, not bytes — the same string
+     * [`LeafNode::on_event`] delivers, filtered to this stream's
+     * **peer and** id:
+     *
+     * ```text
+     * {"type":"stream_data","peer_node":"200","incarnation":"1","stream_id":"9","seq":"1","payload":"AQI="}
+     * ```
+     *
+     * Every `u64` is a decimal string and `payload` is standard
+     * padded base64. One contract, one direction: the leaf emits
+     * its canonical event JSON and the consumer decodes it.
+     * Emitting bytes here instead would mean a second encoding of
+     * an event that already exists, and would throw away `seq` and
+     * the rest of the event's provenance at the boundary.
+     * `@net-mesh/browser`'s `LeafStream` does that decode, which is
+     * why its `onMessage` and its async iterator yield
+     * `Uint8Array`; a host wiring this callback itself must parse
+     * the same way.
+     *
+     * **The peer is half of the key, not decoration.** A stream id
+     * comes from a label or from a publish contract and neither
+     * involves the peer, so one label opened to two peers is one id
+     * on two sessions — a supported composition. Filtering the
+     * node-wide event stream by the id alone made both wrappers
+     * accept whichever peer's payload arrived, delivering one
+     * peer's bytes into the other peer's inbox; a page that echoes
+     * then amplifies it. The incarnation rides the event as
+     * provenance and is deliberately **not** part of this key: see
+     * [`crate::node::LeafEvent::StreamData`].
+     *
+     * The callback runs with **no** borrow of the node held, so it
+     * may call straight back in: [`Self::send`], [`LeafNode::close`]
+     * and the rest are all reachable from here. That was not true
+     * before — the event was emitted from inside `flush`'s `&mut
+     * self` — so the advertised echo trapped instead of sending.
+     *
+     * **Returns the token that cancels the registration**, decimal.
+     * The closure is registered on the node and captures the
+     * consumer's callback, so a registration nothing names is
+     * retained for the node's whole life and keeps being invoked
+     * for every event it produces — which is what repeated
+     * open/close accumulated before the token existed.
+     * [`Self::close`] gives back every token this stream took, so
+     * an ordinary consumer never has to; [`Self::remove_listener`]
+     * is for one that wants to stop listening without closing.
+     * @param {Function} callback
+     * @returns {string}
+     */
+    on_message(callback) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafstream_on_message(retptr, this.__wbg_ptr, addHeapObject(callback));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The peer this stream is with, 16 lowercase hex digits.
+     *
+     * **Spelled exactly like [`Self::stream_id_hex`], deliberately.**
+     * A stream is addressed by `(peer, stream_id)` and both halves
+     * of that key are read through the same accessor shape and
+     * reconciled against the event's decimal field by the same
+     * `BigInt` conversion, so a consumer has one idiom to get right
+     * rather than two. A peer-blind filter is the R4-10 defect: one
+     * label opened to two peers is one id on two sessions, and
+     * filtering the node-wide event stream by the id alone hands
+     * each wrapper whichever peer's payload arrived.
+     * @returns {string}
+     */
+    peer_node_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafstream_peer_node_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Cancel one registration [`Self::on_message`] returned.
+     *
+     * `false` when the token names no live registration of this
+     * stream — already cancelled, already closed, or never ours.
+     * Scoped to this stream on purpose: a token is the right to
+     * remove one subscription, and one stream must not be able to
+     * silence another's consumer by guessing a number.
+     * @param {string} token
+     * @returns {boolean}
+     */
+    remove_listener(token) {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafstream_remove_listener(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Send one payload. The bytes ride verbatim as one event in one
+     * packet — no leaf-added framing.
+     *
+     * Callable from [`Self::on_message`]: the borrow this takes is
+     * released before any listener runs, which is what makes
+     * `stream.onMessage(p => stream.send(p))` — the echo shape the
+     * TypeScript surface advertises — a supported operation rather
+     * than a `RefCell` trap.
+     * @param {Uint8Array} payload
+     */
+    send(payload) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafstream_send(retptr, this.__wbg_ptr, addHeapObject(payload));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The stream id, 16 lowercase hex digits.
+     * @returns {string}
+     */
+    stream_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leafstream_stream_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) LeafStream.prototype[Symbol.dispose] = LeafStream.prototype.free;
+
+/**
+ * A Net node as a tab sees it, whether or not this tab runs it.
+ *
+ * ```text
+ * class MeshSession {
+ *   static open(opts): Promise<MeshSession>
+ *   role(): "leader" | "follower"
+ *   generation(): string
+ *   node_id_hex(): string | undefined
+ *   fingerprint(): string
+ *   scope(): string
+ *   interruption_ms(): number | undefined
+ *   call(service, payload, timeout_ms?): Promise<Uint8Array>
+ *   subscribe(channel): Promise<void>
+ *   publish(channel, payload): Promise<void>
+ *   announce(capabilities): Promise<void>
+ *   query(capability): Promise<string>
+ *   counters_json(): Promise<string>
+ *   signal(peer_hex, dialog, kind, payload): Promise<void>
+ *   open_stream(opts): Promise<ProxyStream>
+ *   on_event(cb): void
+ *   close(): void
+ * }
+ * ```
+ *
+ * One honest difference from `crate::wasm::LeafNode`: `open_stream`
+ * returns a promise, because on a follower the stream is opened by
+ * another tab. Everything else has the same shape, and every
+ * operation carries the generation.
+ */
+export class MeshSession {
+    static __wrap(ptr) {
+        const obj = Object.create(MeshSession.prototype);
+        obj.__wbg_ptr = ptr;
+        MeshSessionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeshSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshsession_free(ptr, 0);
+    }
+    /**
+     * Publish this node's capability announcement.
+     *
+     * Also records it as this tab's current intent, so a takeover
+     * re-publishes what the page last announced rather than what it
+     * opened with.
+     * @param {string[]} capabilities
+     * @returns {Promise<void>}
+     */
+    announce(capabilities) {
+        const ptr0 = passArrayJsValueToWasm0(capabilities, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_announce(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Call an nRPC service.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {number | null} [timeout_ms]
+     * @returns {Promise<Uint8Array>}
+     */
+    call(service, payload, timeout_ms) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped unary call through the shared session.
+     *
+     * Identical contract to [`crate::wasm::LeafNode::call_org`] —
+     * the deadline is absolute, a frozen tab gets no lease
+     * extension, and nothing here ever resumes a retired call. On a
+     * follower the request crosses the proxy with the caller's
+     * proofs as opaque credential bytes (the leader's node mints the
+     * signed opening — the entity key never leaves a node); a
+     * generation move mid-call fails typed `LeaderLost` and is never
+     * resumed, and a retained handle from an older generation
+     * refuses rather than addressing a successor's call.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {any} opts
+     * @returns {Promise<Uint8Array>}
+     */
+    call_org(service, payload, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call_org(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped client-streaming call through the shared
+     * session. See [`Self::call_org`] for the contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgUploadCallHandle>}
+     */
+    call_org_client_stream(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped duplex call through the shared session. See
+     * [`Self::call_org`] for the contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgDuplexCallHandle>}
+     */
+    call_org_duplex(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call_org_duplex(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * One org-scoped server-streaming call through the shared
+     * session. See [`Self::call_org`] for the deadline, suspension
+     * and closure contract. An opening denial REJECTS this promise;
+     * the typed terminal error arrives as the stream's final
+     * `next()` item.
+     * @param {string} service
+     * @param {Uint8Array} payload
+     * @param {any} opts
+     * @returns {Promise<OrgByteStreamHandle>}
+     */
+    call_org_streaming(service, payload, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call_org_streaming(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * Stand down and release the lock.
+     */
+    close() {
+        wasm.meshsession_close(this.__wbg_ptr);
+    }
+    /**
+     * Every leaf counter as JSON; `u64`s are decimal strings.
+     * @returns {Promise<string>}
+     */
+    counters_json() {
+        const ret = wasm.meshsession_counters_json(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Run the enrollment exchange if the node is not enrolled.
+     *
+     * Proxied, so a follower's `enroll()` works: one node per origin
+     * means one enrollment per origin, and the follower is asking
+     * the only session there is. Idempotent on the leader's side —
+     * an already-enrolled node answers immediately.
+     * @returns {Promise<void>}
+     */
+    enroll() {
+        const ret = wasm.meshsession_enroll(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The identity fingerprint the lock is named after.
+     * @returns {string}
+     */
+    fingerprint() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_fingerprint(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The generation in force, as a decimal string.
+     * @returns {string}
+     */
+    generation() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_generation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The measured interruption, in milliseconds, for a tab that was
+     * promoted. `undefined` on the first leader.
+     * @returns {number | undefined}
+     */
+    interruption_ms() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_interruption_ms(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Whether the node has completed enrollment.
+     *
+     * A promise, where [`crate::wasm::LeafNode::is_enrolled`] is
+     * synchronous: on a follower the answer lives in another tab.
+     * @returns {Promise<boolean>}
+     */
+    is_enrolled() {
+        const ret = wasm.meshsession_is_enrolled(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The node's id, 16 lowercase hex digits, once one is known.
+     * @returns {string | undefined}
+     */
+    node_id_hex() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_node_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1);
+                wasm.__wbindgen_export5(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Register an event listener. One JSON string per event.
+     *
+     * Beyond [`crate::node::LeafEvent`]'s tags, a session emits
+     * `leader_changed`, `subscription_restored`, `leader_lost`,
+     * `generation_fenced`, `not_leader` and
+     * `serve_registration_refused` — the lifecycle made observable,
+     * because a page that cannot see a leader change cannot explain
+     * one, and a page that cannot see a permanent serve-registration
+     * refusal cannot explain why its service never dispatches
+     * (LEAF-14: the typed message a local `org_serve` would have
+     * thrown, exactly once, with no retry storm behind it).
+     * @param {Function} callback
+     */
+    on_event(callback) {
+        wasm.meshsession_on_event(this.__wbg_ptr, addHeapObject(callback));
+    }
+    /**
+     * Resolve the identity, contend for the origin's lock, and return
+     * this tab's session.
+     *
+     * `opts` is everything `LeafNode.connect` takes — `credentialB64`,
+     * `origin`, `bootstrapUrl?`, `iceServers?`, `entitySecretHex?`,
+     * `noiseSecretHex?` — plus `capabilities?`, `subscriptions?`,
+     * `dbName?` and `lockScope?`.
+     *
+     * With no `entitySecretHex` the identity comes from IndexedDB
+     * under a non-extractable AES-GCM key, generated there on first
+     * run. With one, the host holds custody and nothing is stored.
+     * Both paths produce the same value and take the same route in.
+     * @param {any} opts
+     * @returns {Promise<MeshSession>}
+     */
+    static open(opts) {
+        const ret = wasm.meshsession_open(addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * Open an application stream, wherever the node is.
+     * @param {any} opts
+     * @returns {Promise<ProxyStream>}
+     */
+    open_stream(opts) {
+        const ret = wasm.meshsession_open_stream(this.__wbg_ptr, addHeapObject(opts));
+        return takeObject(ret);
+    }
+    /**
+     * Answer the offer `peer_hex` filed.
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_accept_offer(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_peer_accept_offer(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Service one polling step of the attempt `dialog_hex`.
+     *
+     * The dialog is required, not optional. A proxied poll that
+     * named only the peer would be applied to whatever attempt is
+     * live when the leader gets to it, which is how a superseded
+     * request drives its replacement.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @returns {Promise<string>}
+     */
+    peer_candidate(peer_hex, dialog_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_peer_candidate(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+     * The live attempt's dialog when `peer_hex` is already a healthy
+     * direct pair on the leader, or `undefined` — what makes a follower's
+     * `connectPeer` idempotent, as `LeafNode::peer_direct_dialog` makes
+     * the leader's.
+     * @param {string} peer_hex
+     * @returns {Promise<string | undefined>}
+     */
+    peer_direct_dialog(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_peer_direct_dialog(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Run the Noise handshake for the attempt `dialog_hex`.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @returns {Promise<string>}
+     */
+    peer_handshake(peer_hex, dialog_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_peer_handshake(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+     * Mint an offer and start an attempt with `peer_hex` (§9).
+     *
+     * The four peer methods below are the primitives a **shared**
+     * TypeScript driver calls. The drive loop and its classification
+     * live once, in the package, and are used by `BrowserNode` and
+     * by this session alike — a second implementation of that loop
+     * here would be two spellings of one contract.
+     * @param {string} peer_hex
+     * @returns {Promise<string>}
+     */
+    peer_offer(peer_hex) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_peer_offer(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Publish one payload to a channel.
+     * @param {string} channel
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    publish(channel, payload) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_publish(this.__wbg_ptr, ptr0, len0, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * Find the nodes offering a capability.
+     * @param {string} capability
+     * @returns {Promise<string>}
+     */
+    query(capability) {
+        const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_query(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * `"leader"` or `"follower"`.
+     * @returns {string}
+     */
+    role() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_role(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The lock and channel name.
+     * @returns {string}
+     */
+    scope() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshsession_scope(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Serve one org-scoped unary service through the shared
+     * session: `handler(caller, request)` resolves the response
+     * body. The registration rides the proxy registry and its
+     * inbound calls dispatch to THIS follower's handle and no other.
+     *
+     * # The handler-drop contract (F-S3.1-2)
+     *
+     * The retire supervisor may drop the handler future without a
+     * final poll — cancellation is observed through the retirement
+     * observables (the terminal item, the sink's typed closed
+     * refusal, and `retired`), never assumed as a handler-side
+     * event; a detached observer holding `retired` observes the
+     * signal. After retirement the handler sees typed refusals and
+     * its return value is discarded — the terminal was already
+     * sent. Closing the returned handle retires this registration's
+     * live protected calls with their exact terminals and refuses
+     * new openings (C9's protected split).
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.meshsession_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped client-streaming service through the
+     * shared session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_client_stream(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.meshsession_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped duplex service through the shared
+     * session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_duplex(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.meshsession_serve_org_duplex(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serve one org-scoped server-streaming service through the
+     * shared session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     * @param {string} service
+     * @param {string} access
+     * @param {Function} handler
+     * @param {any} opts
+     * @returns {OrgServeHandle}
+     */
+    serve_org_streaming(service, access, handler, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.meshsession_serve_org_streaming(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OrgServeHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sign and send a session-independent signalling envelope.
+     * @param {string} peer_hex
+     * @param {string} dialog_hex
+     * @param {string} kind
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    signal(peer_hex, dialog_hex, kind, payload) {
+        const ptr0 = passStringToWasm0(peer_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialog_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_signal(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * Subscribe to a channel.
+     *
+     * Recorded as this tab's own declaration, which is what a
+     * successor restores and what an attach carries to a new leader.
+     * @param {string} channel
+     * @returns {Promise<void>}
+     */
+    subscribe(channel) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_subscribe(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Release this tab's claim on a channel.
+     *
+     * The membership itself is given up only when no other tab still
+     * declares the channel: the origin runs one node, and one tab
+     * closing a subscription is not every tab closing it.
+     * @param {string} channel
+     * @returns {Promise<void>}
+     */
+    unsubscribe(channel) {
+        const ptr0 = passStringToWasm0(channel, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_unsubscribe(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) MeshSession.prototype[Symbol.dispose] = MeshSession.prototype.free;
+
+/**
+ * One org-scoped response stream as JavaScript sees it.
+ *
+ * `next()` resolves `{ done: false, value }`, `{ done: true }` (or
+ * `{ done: true, value }` when the terminal carries a final body),
+ * or `{ done: true, error }` with the typed terminal error — which
+ * the TypeScript wrapper throws at the terminal item, so `for
+ * await` sees a typed rejection. `cancel()` emits exactly one
+ * CANCEL. Deadlines are absolute: a frozen tab gets no lease
+ * extension and an overdue call retires with its deadline terminal;
+ * nothing here ever resumes a retired call.
+ */
+export class OrgByteStreamHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgByteStreamHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgByteStreamHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgByteStreamHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orgbytestreamhandle_free(ptr, 0);
+    }
+    /**
+     * Cancel the call. Exactly one CANCEL reaches the provider, and
+     * the terminal is latched locally — dropping this handle later
+     * emits nothing (the exactly-once guard already fired).
+     */
+    cancel() {
+        wasm.orgbytestreamhandle_cancel(this.__wbg_ptr);
+    }
+    /**
+     * The next item, the end of the stream, or the typed terminal
+     * error item.
+     * @returns {Promise<any>}
+     */
+    next() {
+        const ret = wasm.orgbytestreamhandle_next(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) OrgByteStreamHandle.prototype[Symbol.dispose] = OrgByteStreamHandle.prototype.free;
+
+/**
+ * One org-scoped duplex call as JavaScript sees it: an inline
+ * upload sink and a response stream over the same call.
+ */
+export class OrgDuplexCallHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgDuplexCallHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgDuplexCallHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgDuplexCallHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orgduplexcallhandle_free(ptr, 0);
+    }
+    /**
+     * Cancel the call (one CANCEL, terminal latched).
+     */
+    cancel() {
+        wasm.orgduplexcallhandle_cancel(this.__wbg_ptr);
+    }
+    /**
+     * Half-close the upload direction. The response side stays
+     * open — this is `finishSending`, not a completion.
+     * @returns {Promise<void>}
+     */
+    finish_sending() {
+        const ret = wasm.orgduplexcallhandle_finish_sending(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Push one upload item.
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    send(payload) {
+        const ret = wasm.orgduplexcallhandle_send(this.__wbg_ptr, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * The response half of this call.
+     *
+     * Every handle this mints shares the call's latched terminal:
+     * each consumer observes the real typed terminal (a
+     * `Retired { Revoked }`, an `AdmissionDenied`, a refusal), never
+     * a fabricated clean completion left for whoever polls second.
+     * @returns {OrgByteStreamHandle}
+     */
+    stream() {
+        const ret = wasm.orgduplexcallhandle_stream(this.__wbg_ptr);
+        return OrgByteStreamHandle.__wrap(ret);
+    }
+}
+if (Symbol.dispose) OrgDuplexCallHandle.prototype[Symbol.dispose] = OrgDuplexCallHandle.prototype.free;
+
+/**
+ * The handler-facing request stream of a client-streaming or duplex
+ * serve.
+ *
+ * # The handler-drop contract (F-S3.1-2)
+ *
+ * The retire supervisor may drop the handler future without a final
+ * poll — cancellation is observed through the retirement
+ * observables (the terminal item, the sink's typed closed refusal,
+ * and `retired`), never assumed as a handler-side event; a detached
+ * observer holding `retired` observes the signal. After retirement
+ * `next` yields nothing more and the handler's return value is
+ * discarded — the terminal was already sent.
+ */
+export class OrgRequestStreamHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgRequestStreamHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgRequestStreamHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgRequestStreamHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orgrequeststreamhandle_free(ptr, 0);
+    }
+    /**
+     * The next request item, or `{ done: true }` at the end of the
+     * upload. There is no error arm: a terminated call is observed
+     * through `retired`, and an ended upload is a clean `done`. A
+     * retired call reports `done` — the pull never hangs the
+     * handler (the F-S3.1-2 level).
+     * @returns {Promise<any>}
+     */
+    next() {
+        const ret = wasm.orgrequeststreamhandle_next(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The retirement signal — same contract and vocabulary as
+     * [`OrgResponseSinkHandle::retired`].
+     * @returns {Promise<any>}
+     */
+    retired() {
+        const ret = wasm.orgrequeststreamhandle_retired(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) OrgRequestStreamHandle.prototype[Symbol.dispose] = OrgRequestStreamHandle.prototype.free;
+
+/**
+ * The handler-facing response sink of a streaming or duplex serve.
+ *
+ * # The handler-drop contract (F-S3.1-2)
+ *
+ * The retire supervisor may drop the handler future without a final
+ * poll — cancellation is observed through the retirement
+ * observables (the terminal item, the sink's typed closed refusal
+ * below, and `retired`), never assumed as a handler-side event; a
+ * detached observer holding `retired` observes the signal. After
+ * retirement `send` and `close` refuse with the typed closed text
+ * and the handler's return value is discarded — the terminal was
+ * already sent.
+ */
+export class OrgResponseSinkHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgResponseSinkHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgResponseSinkHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgResponseSinkHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orgresponsesinkhandle_free(ptr, 0);
+    }
+    /**
+     * End the response side successfully. Idempotent: the terminal
+     * frame is sent exactly once whether the handler closed the sink
+     * or simply returned. After retirement this SETTLES with the
+     * typed closed refusal (the F-S3.1-2 level: the promise never
+     * hangs the handler — the terminal was already sent and the
+     * handler's return is discarded).
+     * @returns {Promise<void>}
+     */
+    close() {
+        const ret = wasm.orgresponsesinkhandle_close(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The retirement signal: resolves with one of `timeout`,
+     * `cancelled`, `revoked`, `session-lost`, `leader-lost`,
+     * `node-closed`, `replaced` exactly when the call retires. A
+     * call that completes normally never retires, so this promise
+     * stays pending — it is the retirement observable, not a
+     * completion signal.
+     * @returns {Promise<any>}
+     */
+    retired() {
+        const ret = wasm.orgresponsesinkhandle_retired(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Push one response item. Refuses (typed) after retirement, and
+     * parks (retries) while the response window has no credit — the
+     * same permit semantics as the caller-side sinks.
+     *
+     * # Settling (the F-S3.1-2 level)
+     *
+     * Once `retired` resolves this promise SETTLES with the typed
+     * closed refusal — a post-retirement `send` never hangs the
+     * handler: it refuses, the handler resolves (or rejects), and
+     * its return value is discarded because the terminal was
+     * already sent.
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    send(payload) {
+        const ret = wasm.orgresponsesinkhandle_send(this.__wbg_ptr, addHeapObject(payload));
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) OrgResponseSinkHandle.prototype[Symbol.dispose] = OrgResponseSinkHandle.prototype.free;
+
+/**
+ * A registration of one org service.
+ */
+export class OrgServeHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgServeHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgServeHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgServeHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orgservehandle_free(ptr, 0);
+    }
+    /**
+     * Close the registration.
+     *
+     * **The protected-path split (C9):** closing an ORG serve
+     * handle retires its live protected calls — each with its exact
+     * retirement terminal — and refuses new openings. This is NOT
+     * the public-path "let existing calls finish" behaviour.
+     */
+    close() {
+        wasm.orgservehandle_close(this.__wbg_ptr);
+    }
+    /**
+     * The service name.
+     * @returns {string}
+     */
+    service() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.orgservehandle_service(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) OrgServeHandle.prototype[Symbol.dispose] = OrgServeHandle.prototype.free;
+
+/**
+ * One org-scoped client-streaming call as JavaScript sees it.
+ */
+export class OrgUploadCallHandle {
+    static __wrap(ptr) {
+        const obj = Object.create(OrgUploadCallHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        OrgUploadCallHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrgUploadCallHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orguploadcallhandle_free(ptr, 0);
+    }
+    /**
+     * Cancel the call (one CANCEL, terminal latched).
+     */
+    cancel() {
+        wasm.orguploadcallhandle_cancel(this.__wbg_ptr);
+    }
+    /**
+     * Half-close the upload and await the response body.
+     *
+     * Resolves the terminal body; rejects with the typed terminal
+     * error's `Display` text (an admission denial is
+     * `rpc: refused (9): <coarse>`).
+     * @returns {Promise<Uint8Array>}
+     */
+    finish() {
+        const ret = wasm.orguploadcallhandle_finish(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Push one upload item.
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    send(payload) {
+        const ret = wasm.orguploadcallhandle_send(this.__wbg_ptr, addHeapObject(payload));
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) OrgUploadCallHandle.prototype[Symbol.dispose] = OrgUploadCallHandle.prototype.free;
+
+/**
+ * One application stream, on whichever tab runs the node.
+ *
+ * # Why it remembers its generation
+ *
+ * A stream id names per-session state, and leadership moving means a
+ * new node with a new and independently allocated stream table. A
+ * handle that carried only the id would therefore address *whatever*
+ * stream the successor happened to open with that id — so a retained
+ * object's `send` could push a payload into a stranger's stream and
+ * its `close` could tear that stream down. Carrying the opening
+ * generation makes the handle refuse instead, and the refusal is
+ * typed, because "the leader changed" is an answer a page can act on
+ * and silence is not.
+ *
+ * # Why it remembers a handle *and* an id
+ *
+ * The same argument one level down. Two opens to two peers under one
+ * label share a wire stream id, so the id does not name an open
+ * either: addressing the backend by it let one handle's `send` reach
+ * another peer's stream. The `handle` names the open; the
+ * `stream_id` is what the application filters on; and
+ * [`Self::peer_node_hex`] is what makes that filter a peer filter
+ * rather than a peer-blind one.
+ */
+export class ProxyStream {
+    static __wrap(ptr) {
+        const obj = Object.create(ProxyStream.prototype);
+        obj.__wbg_ptr = ptr;
+        ProxyStreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProxyStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_proxystream_free(ptr, 0);
+    }
+    /**
+     * Stop using the stream.
+     *
+     * Not a resurrection point: D2 is explicit that a stream is
+     * session-scoped and is **not** restored across a leader change.
+     * A page whose leader went away opens a new stream — and this
+     * handle refuses to close anything on a successor, because the
+     * stream it named is already gone with the node that owned it.
+     *
+     * The generation is checked twice, and the second one is the one
+     * that matters. This method is synchronous and the request is
+     * not, so the admission check below happens in the caller's turn
+     * while the request is dispatched in a later one: a handoff in
+     * between would have stamped the close as *current* and torn
+     * down whatever stream the successor had opened with this id.
+     * The check at admission stays because it is the one that makes a
+     * stale close cost no task at all.
+     */
+    close() {
+        wasm.proxystream_close(this.__wbg_ptr);
+    }
+    /**
+     * The generation that opened this stream, as a decimal string.
+     * @returns {string}
+     */
+    generation() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proxystream_generation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The incarnation of the session this stream was opened on,
+     * decimal — the spelling the event carries.
+     * @returns {string}
+     */
+    incarnation() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proxystream_incarnation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether this stream retransmits.
+     * @returns {boolean}
+     */
+    is_reliable() {
+        const ret = wasm.proxystream_is_reliable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Listen for inbound payloads on this stream.
+     *
+     * Filtered from the session's event stream by **both halves of
+     * the key** — the peer and the stream id — which is the same
+     * mechanism and the same event spelling a leader-local stream
+     * uses ([`crate::wasm::LeafStream::on_message`]), so a
+     * follower's stream and a leader's deliver through one path;
+     * **and** by the generation that opened it, so a stale handle's
+     * consumer stops receiving rather than starts receiving a
+     * successor's bytes.
+     *
+     * The peer half was missing here, and the id alone is not the
+     * identity of a stream: two peers under one label share it, so a
+     * proxied consumer received whichever peer's payload arrived.
+     * That is R4-10, on the proxied path.
+     * @param {Function} callback
+     */
+    on_message(callback) {
+        wasm.proxystream_on_message(this.__wbg_ptr, addHeapObject(callback));
+    }
+    /**
+     * The peer this stream is with, 16 lowercase hex digits.
+     *
+     * **Spelled exactly like [`crate::wasm::LeafStream::peer_node_hex`]**
+     * because a consumer must not need to know whether its stream is
+     * direct or proxied to filter by peer. Its absence here was the
+     * R4-10 cross-peer admixture, still open on every proxied handle
+     * — including the leader tab's own `MeshSession`, which wraps the
+     * same `ProxyStream`.
+     * @returns {string}
+     */
+    peer_node_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proxystream_peer_node_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Send one payload.
+     *
+     * Refused, typed, once leadership has moved: see the type's own
+     * documentation for why this is not merely an optimisation.
+     *
+     * # What resolving means, and what it does not
+     *
+     * Three dispositions are distinct and only the first is this
+     * promise's:
+     *
+     * 1. **Admission.** Resolving says the node that owns the stream
+     *    accepted the bytes and enqueued them — a reliable stream has
+     *    taken ownership of them for retransmission, a
+     *    fire-and-forget one has queued one packet. That is the
+     *    contract, and it is the same one `LeafStream.send` has on
+     *    the direct surface.
+     * 2. **Transport refusal.** A DataChannel that refuses the
+     *    packet at the flush boundary is reported there
+     *    (`crate::wasm::Inner::flush`) and does *not* reject this
+     *    promise: the flush happens after admission, on the node's
+     *    own pump, and a reliable stream's retransmission is what
+     *    answers for it.
+     * 3. **Acknowledgement.** Nothing here waits for one. A reliable
+     *    stream's delivery is observable through its peer, not
+     *    through the resolution of this call; an unacknowledged
+     *    payload is retransmitted, and a stream that exhausts its
+     *    retries fails the stream rather than this send.
+     *
+     * A page that needs end-to-end confirmation asks for one in its
+     * own protocol — an nRPC call, or a reply on the stream. Making
+     * this promise wait for an ACK would turn every send into a round
+     * trip and still could not speak for a fire-and-forget stream.
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    send(payload) {
+        const ret = wasm.proxystream_send(this.__wbg_ptr, addHeapObject(payload));
+        return takeObject(ret);
+    }
+    /**
+     * The stream id, 16 lowercase hex digits.
+     * @returns {string}
+     */
+    stream_id_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.proxystream_stream_id_hex(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ProxyStream.prototype[Symbol.dispose] = ProxyStream.prototype.free;
+
+/**
+ * Route panics to `console.error`, so a wasm surprise is legible in
+ * the browser log instead of an opaque `unreachable`.
+ */
+export function start() {
+    wasm.start();
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg___wbindgen_typeof_e777a26e115d416b: function(arg0) {
+            const ret = typeof getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_addEventListener_4d0db17c671ea324: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_addIceCandidate_1a39ed3c2726f129: function(arg0, arg1) {
+            const ret = getObject(arg0).addIceCandidate(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_assign_e39d243f5fbe1e2d: function(arg0, arg1) {
+            const ret = Object.assign(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_bufferedAmount_ffae037ee3ccb36c: function(arg0) {
+            const ret = getObject(arg0).bufferedAmount;
+            return ret;
+        },
+        __wbg_call_1875a20c43a36133: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_939a2607c4484b0b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_candidate_1b46fc7e7e09ff36: function(arg0) {
+            const ret = getObject(arg0).candidate;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_candidate_4706058d90edd65c: function(arg0, arg1) {
+            const ret = getObject(arg1).candidate;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_channel_10306b5f88617a95: function(arg0) {
+            const ret = getObject(arg0).channel;
+            return addHeapObject(ret);
+        },
+        __wbg_close_35c28c04c6854ad8: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_close_3dbb67f6997e08f5: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_close_d3ed56b5763be5ae: function() { return handleError(function (arg0) {
+            getObject(arg0).close();
+        }, arguments); },
+        __wbg_close_de72eca08cf70e9c: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_code_4cb6dbcfceec1eac: function(arg0) {
+            const ret = getObject(arg0).code;
+            return ret;
+        },
+        __wbg_createAnswer_4565390027b78031: function(arg0) {
+            const ret = getObject(arg0).createAnswer();
+            return addHeapObject(ret);
+        },
+        __wbg_createDataChannel_83caaab3b3db15e4: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).createDataChannel(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return addHeapObject(ret);
+        },
+        __wbg_createObjectStore_84e0f5101158c82d: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_createOffer_419e0ee0d8a14451: function(arg0) {
+            const ret = getObject(arg0).createOffer();
+            return addHeapObject(ret);
+        },
+        __wbg_crypto_d3d085052e9d631f: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).crypto;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_data_522f7abc70721269: function(arg0) {
+            const ret = getObject(arg0).data;
+            return addHeapObject(ret);
+        },
+        __wbg_decrypt_0e9566ce8284c64c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).decrypt(getObject(arg1), getObject(arg2), getArrayU8FromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_encrypt_59d97b75fa4a14ef: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).encrypt(getObject(arg1), getObject(arg2), getArrayU8FromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_error_3da0c81bd4184d52: function(arg0) {
+            const ret = getObject(arg0).error;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_error_6600aa1ee85a35e4: function(arg0, arg1) {
+            console.error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_error_6a23b57453026a47: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).error;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_fetch_4178962c570137ca: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).fetch(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_fetch_6835957cc060fb0e: function(arg0, arg1) {
+            const ret = getObject(arg0).fetch(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_generateKey_33ce40dff5d452da: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).generateKey(getObject(arg1), arg2 !== 0, getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getRandomValues_a608c4436c19407a: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_e06b8725897cb193: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).get(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_iceConnectionState_dbc63bbbe69109ce: function(arg0) {
+            const ret = getObject(arg0).iceConnectionState;
+            return (__wbindgen_enum_RtcIceConnectionState.indexOf(ret) + 1 || 8) - 1;
+        },
+        __wbg_indexedDB_53d75531b7daa0cd: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).indexedDB;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_CryptoKey_744e9d2b2b74d8a0: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof CryptoKey;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_IdbDatabase_ee9e122a32a24d91: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IDBDatabase;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Object_67a83cdc00c5d141: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Promise_e1dc6893aa1ece28: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Response_b8758567269c30b2: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Response;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Window;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_is_4b278c0bd3caba97: function(arg0, arg1) {
+            const ret = Object.is(getObject(arg0), getObject(arg1));
+            return ret;
+        },
+        __wbg_label_53448c0e5b75bad8: function(arg0, arg1) {
+            const ret = getObject(arg1).label;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_leafnode_new: function(arg0) {
+            const ret = LeafNode.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_meshsession_new: function(arg0) {
+            const ret = MeshSession.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = getObject(arg0).message;
+            return addHeapObject(ret);
+        },
+        __wbg_message_d988ea596c5f5c9a: function(arg0, arg1) {
+            const ret = getObject(arg1).message;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_navigator_2156486643462a87: function(arg0) {
+            const ret = getObject(arg0).navigator;
+            return addHeapObject(ret);
+        },
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_4059fb0406225e04: function() { return handleError(function (arg0, arg1) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_5502aad30c185fc8: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_83ca405eae412a62: function() { return handleError(function () {
+            const ret = new Headers();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_abaf2d49bbf44a41: function() { return handleError(function (arg0, arg1) {
+            const ret = new BroadcastChannel(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_b751d7581190b8c6: function() { return handleError(function (arg0) {
+            const ret = new RTCIceCandidate(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_typed_b01cb72a8af741a3: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_with_configuration_c6d3ab433d0adb73: function() { return handleError(function (arg0) {
+            const ret = new RTCPeerConnection(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_with_str_and_init_4618dee4e950224f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_with_str_d969ab40df6f3773: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = new WebSocket(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_now_aa4ccb83129e9e55: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_d0b7f4bea9f38490: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_objectStore_43178e7a3459e234: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_ok_125878a7db256ecb: function(arg0) {
+            const ret = getObject(arg0).ok;
+            return ret;
+        },
+        __wbg_open_dbf85f9611885c1b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_orgbytestreamhandle_new: function(arg0) {
+            const ret = OrgByteStreamHandle.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_orgduplexcallhandle_new: function(arg0) {
+            const ret = OrgDuplexCallHandle.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_orgrequeststreamhandle_new: function(arg0) {
+            const ret = OrgRequestStreamHandle.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_orgresponsesinkhandle_new: function(arg0) {
+            const ret = OrgResponseSinkHandle.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_orguploadcallhandle_new: function(arg0) {
+            const ret = OrgUploadCallHandle.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = getObject(arg0).performance;
+            return addHeapObject(ret);
+        },
+        __wbg_performance_d0d7b03fc649b694: function(arg0) {
+            const ret = getObject(arg0).performance;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_postMessage_1e2d73aba527c147: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).postMessage(getObject(arg1));
+        }, arguments); },
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_proxystream_new: function(arg0) {
+            const ret = ProxyStream.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_put_378af428b16ba8f2: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_readyState_418637f3ca14e818: function(arg0) {
+            const ret = getObject(arg0).readyState;
+            return (__wbindgen_enum_RtcDataChannelState.indexOf(ret) + 1 || 5) - 1;
+        },
+        __wbg_readyState_d8514376867e415b: function(arg0) {
+            const ret = getObject(arg0).readyState;
+            return ret;
+        },
+        __wbg_reason_832acaf5f4083b7b: function(arg0, arg1) {
+            const ret = getObject(arg1).reason;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_removeEventListener_6e68185345978771: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_resolve_0076e10020304ede: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_result_ea60156c5cd4726f: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).result;
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_sdpMid_d5987403d70d0bb8: function(arg0, arg1) {
+            const ret = getObject(arg1).sdpMid;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_send_1e2ed35a61efd7fd: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).send(getArrayU8FromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_send_b5bdd806efe4baf6: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).send(getStringFromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_setLocalDescription_c44231625d771b55: function(arg0, arg1) {
+            const ret = getObject(arg0).setLocalDescription(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_setRemoteDescription_a8fe607f1eef503d: function(arg0, arg1) {
+            const ret = getObject(arg0).setRemoteDescription(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_setTimeout_db7bbc18a17e152a: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_additional_data_u8_array_7749cb01b56105fc: function(arg0, arg1) {
+            getObject(arg0).additionalData = getObject(arg1);
+        },
+        __wbg_set_af5932e3f78b5648: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_binaryType_9a9ed83755a2cba4: function(arg0, arg1) {
+            getObject(arg0).binaryType = __wbindgen_enum_RtcDataChannelType[arg1];
+        },
+        __wbg_set_body_1fb0f1008bfc7df6: function(arg0, arg1) {
+            getObject(arg0).body = getObject(arg1);
+        },
+        __wbg_set_bufferedAmountLowThreshold_86c29a4759e98eb4: function(arg0, arg1) {
+            getObject(arg0).bufferedAmountLowThreshold = arg1 >>> 0;
+        },
+        __wbg_set_candidate_74317261cf6d6fef: function(arg0, arg1, arg2) {
+            getObject(arg0).candidate = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_headers_40ad33dcf016613f: function(arg0, arg1) {
+            getObject(arg0).headers = getObject(arg1);
+        },
+        __wbg_set_ice_servers_0e993347b54c4c75: function(arg0, arg1) {
+            getObject(arg0).iceServers = getObject(arg1);
+        },
+        __wbg_set_iv_u8_array_6eba816b5eed19f2: function(arg0, arg1) {
+            getObject(arg0).iv = getObject(arg1);
+        },
+        __wbg_set_length_8339027b398747a6: function(arg0, arg1) {
+            getObject(arg0).length = arg1;
+        },
+        __wbg_set_max_retransmits_8c9e61eaf9d25b82: function(arg0, arg1) {
+            getObject(arg0).maxRetransmits = arg1;
+        },
+        __wbg_set_method_dcb32343247ec427: function(arg0, arg1, arg2) {
+            getObject(arg0).method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_name_3de0dd856e76461a: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_name_d3391bc1a7f05c87: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_onabort_ce1ccad84ebb2dbd: function(arg0, arg1) {
+            getObject(arg0).onabort = getObject(arg1);
+        },
+        __wbg_set_onbufferedamountlow_66c387e3fa0467ad: function(arg0, arg1) {
+            getObject(arg0).onbufferedamountlow = getObject(arg1);
+        },
+        __wbg_set_onclose_a84370531f3d2948: function(arg0, arg1) {
+            getObject(arg0).onclose = getObject(arg1);
+        },
+        __wbg_set_oncomplete_14cd563f5d15546c: function(arg0, arg1) {
+            getObject(arg0).oncomplete = getObject(arg1);
+        },
+        __wbg_set_ondatachannel_790664cc7b5b1a77: function(arg0, arg1) {
+            getObject(arg0).ondatachannel = getObject(arg1);
+        },
+        __wbg_set_onerror_00facdd255f06ed6: function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        },
+        __wbg_set_onerror_24dddc0e8dc54601: function(arg0, arg1) {
+            getObject(arg0).onerror = getObject(arg1);
+        },
+        __wbg_set_onicecandidate_d5e1ae20949a49ef: function(arg0, arg1) {
+            getObject(arg0).onicecandidate = getObject(arg1);
+        },
+        __wbg_set_oniceconnectionstatechange_2b99e504c1f51e83: function(arg0, arg1) {
+            getObject(arg0).oniceconnectionstatechange = getObject(arg1);
+        },
+        __wbg_set_onmessage_b1a84cbc1fe48890: function(arg0, arg1) {
+            getObject(arg0).onmessage = getObject(arg1);
+        },
+        __wbg_set_onmessage_cb6f77d2d8e0402a: function(arg0, arg1) {
+            getObject(arg0).onmessage = getObject(arg1);
+        },
+        __wbg_set_onmessage_d83a0d6439238156: function(arg0, arg1) {
+            getObject(arg0).onmessage = getObject(arg1);
+        },
+        __wbg_set_onopen_c914147e8a2db4b0: function(arg0, arg1) {
+            getObject(arg0).onopen = getObject(arg1);
+        },
+        __wbg_set_onsuccess_e970bffc8d0e7520: function(arg0, arg1) {
+            getObject(arg0).onsuccess = getObject(arg1);
+        },
+        __wbg_set_onupgradeneeded_f9d42df70899331b: function(arg0, arg1) {
+            getObject(arg0).onupgradeneeded = getObject(arg1);
+        },
+        __wbg_set_ordered_c53f7b89fc9fb3b8: function(arg0, arg1) {
+            getObject(arg0).ordered = arg1 !== 0;
+        },
+        __wbg_set_sdp_efdff02bfd21fa09: function(arg0, arg1, arg2) {
+            getObject(arg0).sdp = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_sdp_m_line_index_90d020b194b40483: function(arg0, arg1) {
+            getObject(arg0).sdpMLineIndex = arg1 === 0xFFFFFF ? undefined : arg1;
+        },
+        __wbg_set_sdp_mid_629236bd379fcb1e: function(arg0, arg1, arg2) {
+            getObject(arg0).sdpMid = arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_type_6507077b45f3a9a5: function(arg0, arg1) {
+            getObject(arg0).type = __wbindgen_enum_RtcSdpType[arg1];
+        },
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_status_ce0a98d3c57125f3: function(arg0) {
+            const ret = getObject(arg0).status;
+            return ret;
+        },
+        __wbg_subtle_fd9b8e4f931c4961: function(arg0) {
+            const ret = getObject(arg0).subtle;
+            return addHeapObject(ret);
+        },
+        __wbg_text_ff3f476b3d6b1246: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).text();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_then_c949d5a25a4e78f8: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_e71170d78fcf8954: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_transaction_397c4619233ad8f5: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_transaction_55a3a4e0134a0fd6: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2), __wbindgen_enum_IdbTransactionMode[arg3]);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_warn_13abc63e0d4b3527: function(arg0) {
+            console.warn(getObject(arg0));
+        },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 33, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2355);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 896, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6504);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_112);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_113);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000006: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_114);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000007: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCDataChannelEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_115);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000008: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCPeerConnectionIceEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_116);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000009: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000a: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./net_leaf_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_2356(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2356_112(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356_112(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2356_113(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356_113(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2356_114(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356_114(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2356_115(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356_115(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2356_116(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2356_116(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_2355(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_2355(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_6506(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_6506(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+function __wasm_bindgen_func_elem_6504(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_6504(retptr, arg0, arg1, addHeapObject(arg2));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+
+const __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
+
+
+const __wbindgen_enum_RtcDataChannelState = ["connecting", "open", "closing", "closed"];
+
+
+const __wbindgen_enum_RtcDataChannelType = ["arraybuffer", "blob"];
+
+
+const __wbindgen_enum_RtcIceConnectionState = ["new", "checking", "connected", "completed", "failed", "disconnected", "closed"];
+
+
+const __wbindgen_enum_RtcSdpType = ["offer", "pranswer", "answer", "rollback"];
+const LeafNodeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_leafnode_free(ptr, 1));
+const LeafStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_leafstream_free(ptr, 1));
+const MeshSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshsession_free(ptr, 1));
+const OrgByteStreamHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orgbytestreamhandle_free(ptr, 1));
+const OrgDuplexCallHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orgduplexcallhandle_free(ptr, 1));
+const OrgRequestStreamHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orgrequeststreamhandle_free(ptr, 1));
+const OrgResponseSinkHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orgresponsesinkhandle_free(ptr, 1));
+const OrgServeHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orgservehandle_free(ptr, 1));
+const OrgUploadCallHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orguploadcallhandle_free(ptr, 1));
+const ProxyStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_proxystream_free(ptr, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_export4(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_export4(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('net_leaf_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };