@net-mesh/browser 0.37.0

package/dist/net_leaf.d.ts

@@ -0,0 +1,1494 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A browser node.
+ */
+export class LeafNode {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The anchor's node id, as 16 lowercase hex digits.
+     */
+    anchor_id_hex(): string;
+    /**
+     * 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.
+     */
+    announce(capabilities: string[]): Promise<void>;
+    /**
+     * 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.
+     */
+    apply_org_revocation_bundle(bundle_hex: string): number;
+    /**
+     * 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(): void;
+    /**
+     * Call `service` on the anchor.
+     *
+     * Resolves to the reply body, or rejects with the typed
+     * failure — `Timeout`, `SessionLost`, `Refused(status)`. Never
+     * a silent retry.
+     */
+    call(service: string, payload: Uint8Array, timeout_ms?: number | null): Promise<Uint8Array>;
+    /**
+     * 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.
+     */
+    call_org(service: string, payload: Uint8Array, opts: any): Promise<Uint8Array>;
+    /**
+     * 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.
+     */
+    call_org_client_stream(service: string, opts: any): Promise<OrgUploadCallHandle>;
+    /**
+     * One org-scoped duplex call. See [`Self::call_org`] for the
+     * deadline, suspension and closure contract.
+     */
+    call_org_duplex(service: string, opts: any): Promise<OrgDuplexCallHandle>;
+    /**
+     * 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.
+     */
+    call_org_streaming(service: string, payload: Uint8Array, opts: any): Promise<OrgByteStreamHandle>;
+    /**
+     * Close the node: every session, every channel, every pending
+     * call.
+     *
+     * Pending calls fail `RpcError::SessionLost` — typed, and not
+     * re-issued by anybody.
+     */
+    close(): void;
+    /**
+     * 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`].
+     */
+    static connect(opts: any): Promise<LeafNode>;
+    /**
+     * Every counter, as JSON. u64s are decimal strings.
+     */
+    counters_json(): string;
+    /**
+     * 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.
+     */
+    static effective_ice_servers(opts: any): string;
+    /**
+     * 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.
+     */
+    static effective_stream_options(opts: any): string;
+    /**
+     * 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.
+     */
+    enroll(): Promise<void>;
+    /**
+     * 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.
+     */
+    is_enrolled(): boolean;
+    /**
+     * 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.
+     */
+    listener_count(): number;
+    /**
+     * 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.
+     */
+    static maxEventBytes(): number;
+    /**
+     * This node's id, as 16 lowercase hex digits.
+     */
+    node_id_hex(): string;
+    /**
+     * 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.
+     */
+    on_event(callback: Function): string;
+    /**
+     * 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.
+     */
+    open_stream(opts: any): LeafStream;
+    /**
+     * 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.
+     */
+    origin_hash_hex(): string;
+    /**
+     * 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.
+     */
+    peer_accept_offer(peer_hex: string): Promise<string>;
+    /**
+     * 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".
+     */
+    peer_candidate(peer_hex: string): Promise<string>;
+    /**
+     * [`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.
+     */
+    peer_candidate_in(peer_hex: string, dialog_hex: string): Promise<string>;
+    /**
+     * 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.
+     */
+    peer_direct_dialog(peer_hex: string): string | undefined;
+    /**
+     * 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.
+     */
+    peer_handshake(peer_hex: string): Promise<string>;
+    /**
+     * [`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.
+     */
+    peer_handshake_in(peer_hex: string, dialog_hex: string): Promise<string>;
+    /**
+     * 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.
+     */
+    peer_offer(peer_hex: string): Promise<string>;
+    /**
+     * Publish `payload` on `channel`.
+     */
+    publish(channel: string, payload: Uint8Array): Promise<void>;
+    /**
+     * Answer a capability query from the announcements this leaf
+     * verified. A JSON array of
+     * `{ node_id, entity_id, capabilities, rtc_addr, noise_pubkey, version }`.
+     */
+    query(capability: string): Promise<string>;
+    /**
+     * 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.
+     */
+    remove_listener(token: string): boolean;
+    /**
+     * 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.
+     */
+    retire(generation: bigint): number;
+    /**
+     * 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.
+     */
+    retry_report(): string;
+    /**
+     * `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.
+     */
+    rtc_stats_json(): string;
+    /**
+     * 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).
+     */
+    serve_org(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * 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.
+     */
+    serve_org_client_stream(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * 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.
+     */
+    serve_org_duplex(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * 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.
+     */
+    serve_org_streaming(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * 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.
+     */
+    signal(peer_hex: string, dialog_hex: string, kind: string, payload: Uint8Array): Promise<void>;
+    /**
+     * Subscribe to `channel` on the anchor.
+     */
+    subscribe(channel: string): Promise<void>;
+    /**
+     * 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.
+     */
+    unsubscribe(channel: string): Promise<void>;
+}
+
+/**
+ * One application stream.
+ */
+export class LeafStream {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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(): void;
+    /**
+     * 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`].
+     */
+    incarnation(): string;
+    /**
+     * Whether this stream retransmits.
+     */
+    is_reliable(): boolean;
+    /**
+     * 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.
+     */
+    on_message(callback: Function): string;
+    /**
+     * 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.
+     */
+    peer_node_hex(): string;
+    /**
+     * 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.
+     */
+    remove_listener(token: string): boolean;
+    /**
+     * 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.
+     */
+    send(payload: Uint8Array): void;
+    /**
+     * The stream id, 16 lowercase hex digits.
+     */
+    stream_id_hex(): string;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    announce(capabilities: string[]): Promise<void>;
+    /**
+     * Call an nRPC service.
+     */
+    call(service: string, payload: Uint8Array, timeout_ms?: number | null): Promise<Uint8Array>;
+    /**
+     * 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.
+     */
+    call_org(service: string, payload: Uint8Array, opts: any): Promise<Uint8Array>;
+    /**
+     * One org-scoped client-streaming call through the shared
+     * session. See [`Self::call_org`] for the contract.
+     */
+    call_org_client_stream(service: string, opts: any): Promise<OrgUploadCallHandle>;
+    /**
+     * One org-scoped duplex call through the shared session. See
+     * [`Self::call_org`] for the contract.
+     */
+    call_org_duplex(service: string, opts: any): Promise<OrgDuplexCallHandle>;
+    /**
+     * 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.
+     */
+    call_org_streaming(service: string, payload: Uint8Array, opts: any): Promise<OrgByteStreamHandle>;
+    /**
+     * Stand down and release the lock.
+     */
+    close(): void;
+    /**
+     * Every leaf counter as JSON; `u64`s are decimal strings.
+     */
+    counters_json(): Promise<string>;
+    /**
+     * 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.
+     */
+    enroll(): Promise<void>;
+    /**
+     * The identity fingerprint the lock is named after.
+     */
+    fingerprint(): string;
+    /**
+     * The generation in force, as a decimal string.
+     */
+    generation(): string;
+    /**
+     * The measured interruption, in milliseconds, for a tab that was
+     * promoted. `undefined` on the first leader.
+     */
+    interruption_ms(): number | undefined;
+    /**
+     * 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.
+     */
+    is_enrolled(): Promise<boolean>;
+    /**
+     * The node's id, 16 lowercase hex digits, once one is known.
+     */
+    node_id_hex(): string | undefined;
+    /**
+     * 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).
+     */
+    on_event(callback: Function): void;
+    /**
+     * 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.
+     */
+    static open(opts: any): Promise<MeshSession>;
+    /**
+     * Open an application stream, wherever the node is.
+     */
+    open_stream(opts: any): Promise<ProxyStream>;
+    /**
+     * Answer the offer `peer_hex` filed.
+     */
+    peer_accept_offer(peer_hex: string): Promise<string>;
+    /**
+     * 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.
+     */
+    peer_candidate(peer_hex: string, dialog_hex: string): Promise<string>;
+    /**
+     * 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.
+     */
+    peer_direct_dialog(peer_hex: string): Promise<string | undefined>;
+    /**
+     * Run the Noise handshake for the attempt `dialog_hex`.
+     */
+    peer_handshake(peer_hex: string, dialog_hex: string): Promise<string>;
+    /**
+     * 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.
+     */
+    peer_offer(peer_hex: string): Promise<string>;
+    /**
+     * Publish one payload to a channel.
+     */
+    publish(channel: string, payload: Uint8Array): Promise<void>;
+    /**
+     * Find the nodes offering a capability.
+     */
+    query(capability: string): Promise<string>;
+    /**
+     * `"leader"` or `"follower"`.
+     */
+    role(): string;
+    /**
+     * The lock and channel name.
+     */
+    scope(): string;
+    /**
+     * 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).
+     */
+    serve_org(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * Serve one org-scoped client-streaming service through the
+     * shared session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     */
+    serve_org_client_stream(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * Serve one org-scoped duplex service through the shared
+     * session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     */
+    serve_org_duplex(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * Serve one org-scoped server-streaming service through the
+     * shared session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
+     */
+    serve_org_streaming(service: string, access: string, handler: Function, opts: any): OrgServeHandle;
+    /**
+     * Sign and send a session-independent signalling envelope.
+     */
+    signal(peer_hex: string, dialog_hex: string, kind: string, payload: Uint8Array): Promise<void>;
+    /**
+     * 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.
+     */
+    subscribe(channel: string): Promise<void>;
+    /**
+     * 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.
+     */
+    unsubscribe(channel: string): Promise<void>;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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(): void;
+    /**
+     * The next item, the end of the stream, or the typed terminal
+     * error item.
+     */
+    next(): Promise<any>;
+}
+
+/**
+ * One org-scoped duplex call as JavaScript sees it: an inline
+ * upload sink and a response stream over the same call.
+ */
+export class OrgDuplexCallHandle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Cancel the call (one CANCEL, terminal latched).
+     */
+    cancel(): void;
+    /**
+     * Half-close the upload direction. The response side stays
+     * open — this is `finishSending`, not a completion.
+     */
+    finish_sending(): Promise<void>;
+    /**
+     * Push one upload item.
+     */
+    send(payload: Uint8Array): Promise<void>;
+    /**
+     * 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.
+     */
+    stream(): OrgByteStreamHandle;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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).
+     */
+    next(): Promise<any>;
+    /**
+     * The retirement signal — same contract and vocabulary as
+     * [`OrgResponseSinkHandle::retired`].
+     */
+    retired(): Promise<any>;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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).
+     */
+    close(): Promise<void>;
+    /**
+     * 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.
+     */
+    retired(): Promise<any>;
+    /**
+     * 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.
+     */
+    send(payload: Uint8Array): Promise<void>;
+}
+
+/**
+ * A registration of one org service.
+ */
+export class OrgServeHandle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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(): void;
+    /**
+     * The service name.
+     */
+    service(): string;
+}
+
+/**
+ * One org-scoped client-streaming call as JavaScript sees it.
+ */
+export class OrgUploadCallHandle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Cancel the call (one CANCEL, terminal latched).
+     */
+    cancel(): void;
+    /**
+     * 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>`).
+     */
+    finish(): Promise<Uint8Array>;
+    /**
+     * Push one upload item.
+     */
+    send(payload: Uint8Array): Promise<void>;
+}
+
+/**
+ * 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 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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(): void;
+    /**
+     * The generation that opened this stream, as a decimal string.
+     */
+    generation(): string;
+    /**
+     * The incarnation of the session this stream was opened on,
+     * decimal — the spelling the event carries.
+     */
+    incarnation(): string;
+    /**
+     * Whether this stream retransmits.
+     */
+    is_reliable(): boolean;
+    /**
+     * 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.
+     */
+    on_message(callback: Function): void;
+    /**
+     * 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`.
+     */
+    peer_node_hex(): string;
+    /**
+     * 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.
+     */
+    send(payload: Uint8Array): Promise<void>;
+    /**
+     * The stream id, 16 lowercase hex digits.
+     */
+    stream_id_hex(): string;
+}
+
+/**
+ * Route panics to `console.error`, so a wasm surprise is legible in
+ * the browser log instead of an opaque `unreachable`.
+ */
+export function start(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_leafnode_free: (a: number, b: number) => void;
+    readonly __wbg_leafstream_free: (a: number, b: number) => void;
+    readonly __wbg_meshsession_free: (a: number, b: number) => void;
+    readonly __wbg_orgbytestreamhandle_free: (a: number, b: number) => void;
+    readonly __wbg_orgduplexcallhandle_free: (a: number, b: number) => void;
+    readonly __wbg_orgrequeststreamhandle_free: (a: number, b: number) => void;
+    readonly __wbg_orgresponsesinkhandle_free: (a: number, b: number) => void;
+    readonly __wbg_orgservehandle_free: (a: number, b: number) => void;
+    readonly __wbg_orguploadcallhandle_free: (a: number, b: number) => void;
+    readonly __wbg_proxystream_free: (a: number, b: number) => void;
+    readonly leafnode_anchor_id_hex: (a: number, b: number) => void;
+    readonly leafnode_announce: (a: number, b: number, c: number) => number;
+    readonly leafnode_apply_org_revocation_bundle: (a: number, b: number, c: number, d: number) => void;
+    readonly leafnode_arm_network_retry: (a: number, b: number) => void;
+    readonly leafnode_call: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly leafnode_call_org: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly leafnode_call_org_client_stream: (a: number, b: number, c: number, d: number) => number;
+    readonly leafnode_call_org_duplex: (a: number, b: number, c: number, d: number) => number;
+    readonly leafnode_call_org_streaming: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly leafnode_close: (a: number) => void;
+    readonly leafnode_connect: (a: number) => number;
+    readonly leafnode_counters_json: (a: number, b: number) => void;
+    readonly leafnode_effective_ice_servers: (a: number, b: number) => void;
+    readonly leafnode_effective_stream_options: (a: number, b: number) => void;
+    readonly leafnode_enroll: (a: number) => number;
+    readonly leafnode_is_enrolled: (a: number) => number;
+    readonly leafnode_listener_count: (a: number) => number;
+    readonly leafnode_maxEventBytes: () => number;
+    readonly leafnode_node_id_hex: (a: number, b: number) => void;
+    readonly leafnode_on_event: (a: number, b: number, c: number) => void;
+    readonly leafnode_open_stream: (a: number, b: number, c: number) => void;
+    readonly leafnode_origin_hash_hex: (a: number, b: number) => void;
+    readonly leafnode_peer_accept_offer: (a: number, b: number, c: number) => number;
+    readonly leafnode_peer_candidate: (a: number, b: number, c: number) => number;
+    readonly leafnode_peer_candidate_in: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly leafnode_peer_direct_dialog: (a: number, b: number, c: number, d: number) => void;
+    readonly leafnode_peer_handshake: (a: number, b: number, c: number) => number;
+    readonly leafnode_peer_handshake_in: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly leafnode_peer_offer: (a: number, b: number, c: number) => number;
+    readonly leafnode_publish: (a: number, b: number, c: number, d: number) => number;
+    readonly leafnode_query: (a: number, b: number, c: number) => number;
+    readonly leafnode_remove_listener: (a: number, b: number, c: number) => number;
+    readonly leafnode_retire: (a: number, b: bigint) => number;
+    readonly leafnode_retry_report: (a: number, b: number) => void;
+    readonly leafnode_rtc_stats_json: (a: number, b: number) => void;
+    readonly leafnode_serve_org: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly leafnode_serve_org_client_stream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly leafnode_serve_org_duplex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly leafnode_serve_org_streaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly leafnode_signal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly leafnode_subscribe: (a: number, b: number, c: number) => number;
+    readonly leafnode_unsubscribe: (a: number, b: number, c: number) => number;
+    readonly leafstream_close: (a: number) => void;
+    readonly leafstream_incarnation: (a: number, b: number) => void;
+    readonly leafstream_is_reliable: (a: number) => number;
+    readonly leafstream_on_message: (a: number, b: number, c: number) => void;
+    readonly leafstream_peer_node_hex: (a: number, b: number) => void;
+    readonly leafstream_remove_listener: (a: number, b: number, c: number) => number;
+    readonly leafstream_send: (a: number, b: number, c: number) => void;
+    readonly leafstream_stream_id_hex: (a: number, b: number) => void;
+    readonly meshsession_announce: (a: number, b: number, c: number) => number;
+    readonly meshsession_call: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly meshsession_call_org: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly meshsession_call_org_client_stream: (a: number, b: number, c: number, d: number) => number;
+    readonly meshsession_call_org_duplex: (a: number, b: number, c: number, d: number) => number;
+    readonly meshsession_call_org_streaming: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly meshsession_close: (a: number) => void;
+    readonly meshsession_counters_json: (a: number) => number;
+    readonly meshsession_enroll: (a: number) => number;
+    readonly meshsession_fingerprint: (a: number, b: number) => void;
+    readonly meshsession_generation: (a: number, b: number) => void;
+    readonly meshsession_interruption_ms: (a: number, b: number) => void;
+    readonly meshsession_is_enrolled: (a: number) => number;
+    readonly meshsession_node_id_hex: (a: number, b: number) => void;
+    readonly meshsession_on_event: (a: number, b: number) => void;
+    readonly meshsession_open: (a: number) => number;
+    readonly meshsession_open_stream: (a: number, b: number) => number;
+    readonly meshsession_peer_accept_offer: (a: number, b: number, c: number) => number;
+    readonly meshsession_peer_candidate: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly meshsession_peer_direct_dialog: (a: number, b: number, c: number) => number;
+    readonly meshsession_peer_handshake: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly meshsession_peer_offer: (a: number, b: number, c: number) => number;
+    readonly meshsession_publish: (a: number, b: number, c: number, d: number) => number;
+    readonly meshsession_query: (a: number, b: number, c: number) => number;
+    readonly meshsession_role: (a: number, b: number) => void;
+    readonly meshsession_scope: (a: number, b: number) => void;
+    readonly meshsession_serve_org: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly meshsession_serve_org_client_stream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly meshsession_serve_org_duplex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly meshsession_serve_org_streaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly meshsession_signal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly meshsession_subscribe: (a: number, b: number, c: number) => number;
+    readonly meshsession_unsubscribe: (a: number, b: number, c: number) => number;
+    readonly orgbytestreamhandle_cancel: (a: number) => void;
+    readonly orgbytestreamhandle_next: (a: number) => number;
+    readonly orgduplexcallhandle_cancel: (a: number) => void;
+    readonly orgduplexcallhandle_finish_sending: (a: number) => number;
+    readonly orgduplexcallhandle_send: (a: number, b: number) => number;
+    readonly orgduplexcallhandle_stream: (a: number) => number;
+    readonly orgrequeststreamhandle_next: (a: number) => number;
+    readonly orgrequeststreamhandle_retired: (a: number) => number;
+    readonly orgresponsesinkhandle_close: (a: number) => number;
+    readonly orgresponsesinkhandle_retired: (a: number) => number;
+    readonly orgresponsesinkhandle_send: (a: number, b: number) => number;
+    readonly orgservehandle_close: (a: number) => void;
+    readonly orgservehandle_service: (a: number, b: number) => void;
+    readonly orguploadcallhandle_cancel: (a: number) => void;
+    readonly orguploadcallhandle_finish: (a: number) => number;
+    readonly orguploadcallhandle_send: (a: number, b: number) => number;
+    readonly proxystream_close: (a: number) => void;
+    readonly proxystream_generation: (a: number, b: number) => void;
+    readonly proxystream_incarnation: (a: number, b: number) => void;
+    readonly proxystream_is_reliable: (a: number) => number;
+    readonly proxystream_on_message: (a: number, b: number) => void;
+    readonly proxystream_peer_node_hex: (a: number, b: number) => void;
+    readonly proxystream_send: (a: number, b: number) => number;
+    readonly proxystream_stream_id_hex: (a: number, b: number) => void;
+    readonly start: () => void;
+    readonly __wasm_bindgen_func_elem_6504: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_6506: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2355: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_2356: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2356_112: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2356_113: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2356_114: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2356_115: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2356_116: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export5: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;