@net-mesh/browser 0.42.0 → 0.44.0

package/dist/leader/session.d.ts

@@ -57,7 +57,10 @@ export interface SessionOptions extends ConnectOptions {
     dbName?: string;
     /**
      * Override the Web Lock and `BroadcastChannel` name. Defaults to
-     * `net-mesh/<origin>/<identity-fingerprint>`.
+     * `net-mesh/<origin>/<identity-fingerprint>`, or — with a custodial
+     * `entitySecretHex` — to the identity lock `connect()` takes for that
+     * secret, so a `connect()` tab and an `openSession()` tab cannot both run
+     * the identity. Setting it opts out of that contention.
      *
      * For tests that need two independent elections inside one origin.
      * A page should not set it: two scopes on one identity is two nodes
@@ -65,7 +68,6 @@ export interface SessionOptions extends ConnectOptions {
      */
     lockScope?: string;
 }
-/** The origin's Net node, as this tab sees it. */
 export declare class MeshSession {
     private readonly inner;
     /**

package/dist/leader/session.js

@@ -28,7 +28,7 @@
  */
 import { fromWasmError, OrgCancelledError, OrgLeaderLostError, } from '../errors.js';
 import { clientStreamOrgTrampoline, duplexOrgTrampoline, OrgDuplex, OrgHandleRegistry, OrgServe, OrgStream, OrgUpload, streamingOrgTrampoline, toWasmOrgCallOptions, toWasmOrgServeOptions, unaryOrgTrampoline, } from '../org.js';
-import { buildConnectRequest, parseAttemptStatus, parseCounters, parseDescriptors, } from '../node.js';
+import { buildConnectRequest, identityLockName, parseAttemptStatus, parseCounters, parseDescriptors, } from '../node.js';
 import { acceptPeer as driveAccept, answerWaitingOffer, connectPeer as driveConnect, noteOffer, PeerAttempts, } from '../peer-driver.js';
 import { LeafStream } from '../stream.js';
 import { idArg, loadLeafWasm } from '../wasm.js';
@@ -36,6 +36,13 @@ import { isLifecycleEvent, parseSessionEvent, } from './events.js';
 import { asSessionModule } from './wasm.js';
 import { EventHub } from '../events.js';
 /** The origin's Net node, as this tab sees it. */
+/**
+ * What a send on a stream ended by a leader change fails with. Worded
+ * the way the leaf words a stale handle, because `isStaleStream` (the
+ * store's reopen test) matches exactly that: a store over a session
+ * reopens on the new leader rather than counting `send-failed` forever.
+ */
+const STALE_AFTER_HANDOFF = 'stale stream handle: the leader changed; reopen the stream';
 export class MeshSession {
     inner;
     /**
@@ -100,7 +107,7 @@ export class MeshSession {
                 // The generation that owned the calls is the one they were
                 // issued under — typed `LeaderLost`, never resumed.
                 this.orgHandles.retireAll(new OrgLeaderLostError(this.streamGeneration));
-                this.endStreams();
+                this.endStreams(STALE_AFTER_HANDOFF);
                 return;
             }
             // And the abrupt case: a generation that moved under us. Read
@@ -114,7 +121,7 @@ export class MeshSession {
             const previous = this.streamGeneration;
             this.streamGeneration = current;
             this.orgHandles.retireAll(new OrgLeaderLostError(previous));
-            this.endStreams();
+            this.endStreams(STALE_AFTER_HANDOFF);
         });
     }
     /** `'leader'` if this tab runs the node, `'follower'` if another does. */
@@ -725,11 +732,17 @@ export class MeshSession {
      * on close; idempotent, because a page may have closed a stream
      * itself.
      */
-    endStreams() {
+    endStreams(staleReason) {
         const open = [...this.streams];
         this.streams.clear();
-        for (const stream of open)
-            stream.close();
+        for (const stream of open) {
+            // A leader change retires with the reopenable wording; closing the
+            // session is permanent.
+            if (staleReason === undefined)
+                stream.close();
+            else
+                stream.retire(staleReason);
+        }
     }
     /**
      * Re-type whatever the boundary threw.
@@ -777,6 +790,17 @@ export async function openSession(options) {
         ...(options.dbName === undefined ? {} : { dbName: options.dbName }),
         ...(options.lockScope === undefined ? {} : { lockScope: options.lockScope }),
     };
+    // A custodial identity elects under the same lock name `connect()` takes
+    // for it, so mixed connect()/openSession() tabs with one secret cannot
+    // both run a node (cubic review of PR #1228). The scope also names the
+    // `BroadcastChannel`, and every session tab with that secret derives the
+    // same name, so the leader and its followers still meet.
+    // `lockIdentity: false` keeps the leaf's own default scope.
+    if (request.lockScope === undefined && request.entitySecretHex !== undefined && options.lockIdentity !== false) {
+        const shared = await identityLockName(request.entitySecretHex);
+        if (shared !== null)
+            request.lockScope = shared;
+    }
     try {
         return new MeshSession(await module.MeshSession.open(request));
     }

package/dist/lobby.d.ts

@@ -89,8 +89,33 @@ export declare const MAX_LOBBY_CAPACITY = 256;
 /** Characters a code is made of: no 0/O, 1/I/L, so a code survives being read aloud. */
 export declare const LOBBY_CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
 export declare const LOBBY_CODE_LENGTH = 6;
-/** How often a lobby re-announces itself. */
-export declare const LOBBY_ANNOUNCE_MS = 2000;
+/**
+ * How often a lobby (and a joiner's seek tag) refreshes its announcement.
+ * A change of players is announced at once; this is only the lease
+ * refresh, well inside the leaf's 300 s announcement TTL.
+ *
+ * It was 2 s. Every node's re-announcement is flooded through the anchor
+ * to every peer, each of which answers every packet with a credit grant,
+ * so the load grows with the square of the players: at 64 players on one
+ * anchor (sharded-match plan, S0b) a 2 s refresh pinned the host's anchor
+ * link at its SCTP advisory (84,667 refused sends), starving every
+ * relayed pair and timing out handshakes. At 30 s the same run joined all
+ * 64, every pair direct, with no refusals.
+ *
+ * A node that connects later does not wait for this refresh: the anchor
+ * replays the announcements it holds to each session that enrolls, within
+ * its game, so an existing lobby is listed at once.
+ *
+ * A FAILED announcement is not left to this cadence: it is retried after
+ * {@link ANNOUNCE_RETRY_MS}, doubling up to {@link ANNOUNCE_RETRY_MAX_MS},
+ * until one succeeds. A joiner gives up after 20 s, and a lobby whose
+ * first announcement failed must not stay unfindable for 30.
+ */
+export declare const LOBBY_ANNOUNCE_MS = 30000;
+/** The first retry after a failed announcement, ms (lobbies, seek tags, region hosts). */
+export declare const ANNOUNCE_RETRY_MS = 1000;
+/** The longest wait between retries of a failing announcement, ms. */
+export declare const ANNOUNCE_RETRY_MAX_MS = 8000;
 /** A code as typed: case, spaces and dashes forgiven. */
 export declare function normalizeLobbyCode(code: string): string;
 /** What `createLobby` takes: a store's host options, minus the transport, plus the lobby. */
@@ -173,6 +198,8 @@ export interface JoinLobbyOptions<S extends object, A extends ActionSpec, I exte
      * announces goes here. The same option as `createLobby`'s.
      */
     readonly tags?: readonly string[];
+    /** How often the seek tag is refreshed while joined. Default {@link LOBBY_ANNOUNCE_MS}. */
+    readonly announceEveryMs?: number;
 }
 /**
  * Join a lobby by code or by listing. Resolves once the host is found

package/dist/lobby.js

@@ -46,7 +46,7 @@
  * tags the node should keep announcing as `tags`.
  */
 import { StoreError } from './store/errors.js';
-import { hostInternals, hostStore, } from './store/host.js';
+import { hostInternals, hostStore, nodeHexOf, } from './store/host.js';
 import { joinStore } from './store/join.js';
 import { hostPlayer } from './store/player.js';
 export class LobbyError extends Error {
@@ -65,8 +65,33 @@ export const MAX_LOBBY_CAPACITY = 256;
 /** Characters a code is made of: no 0/O, 1/I/L, so a code survives being read aloud. */
 export const LOBBY_CODE_ALPHABET = 'ABCDEFGHJKMNPQRSTUVWXYZ23456789';
 export const LOBBY_CODE_LENGTH = 6;
-/** How often a lobby re-announces itself. */
-export const LOBBY_ANNOUNCE_MS = 2_000;
+/**
+ * How often a lobby (and a joiner's seek tag) refreshes its announcement.
+ * A change of players is announced at once; this is only the lease
+ * refresh, well inside the leaf's 300 s announcement TTL.
+ *
+ * It was 2 s. Every node's re-announcement is flooded through the anchor
+ * to every peer, each of which answers every packet with a credit grant,
+ * so the load grows with the square of the players: at 64 players on one
+ * anchor (sharded-match plan, S0b) a 2 s refresh pinned the host's anchor
+ * link at its SCTP advisory (84,667 refused sends), starving every
+ * relayed pair and timing out handshakes. At 30 s the same run joined all
+ * 64, every pair direct, with no refusals.
+ *
+ * A node that connects later does not wait for this refresh: the anchor
+ * replays the announcements it holds to each session that enrolls, within
+ * its game, so an existing lobby is listed at once.
+ *
+ * A FAILED announcement is not left to this cadence: it is retried after
+ * {@link ANNOUNCE_RETRY_MS}, doubling up to {@link ANNOUNCE_RETRY_MAX_MS},
+ * until one succeeds. A joiner gives up after 20 s, and a lobby whose
+ * first announcement failed must not stay unfindable for 30.
+ */
+export const LOBBY_ANNOUNCE_MS = 30_000;
+/** The first retry after a failed announcement, ms (lobbies, seek tags, region hosts). */
+export const ANNOUNCE_RETRY_MS = 1_000;
+/** The longest wait between retries of a failing announcement, ms. */
+export const ANNOUNCE_RETRY_MAX_MS = 8_000;
 /** The frame bound the package's own tests and demo use. */
 const DEFAULT_MAX_EVENT_BYTES = 8104;
 const GAME = /^[a-z0-9][a-z0-9._-]{0,63}$/;
@@ -215,10 +240,14 @@ function decodeRecord(game, tag) {
         return null;
     }
 }
+// Read the id the way every other caller-held id is read (`nodeHexOf`):
+// sixteen hex digits are hex, and anything shorter may be the exact-decimal
+// `peerNode` an event handed the page. Reading every digit run as hex kicked
+// a DIFFERENT id and removed nobody (SDK audit 2026-10-11).
 function hexPeer(peer) {
-    const raw = peer.startsWith('0x') ? peer.slice(2) : peer;
-    if (/^[0-9a-fA-F]{1,16}$/.test(raw))
-        return raw.toLowerCase().padStart(16, '0');
+    const hex = nodeHexOf(peer);
+    if (hex !== null)
+        return hex;
     throw new LobbyError('invalid', `not a peer id: ${JSON.stringify(peer)}`);
 }
 /**
@@ -279,6 +308,10 @@ export async function createLobby(options) {
     let closed = false;
     let announcing = null;
     let again = false;
+    // A failed announcement is retried on its own short backoff, not at the
+    // next lease refresh.
+    let retry = null;
+    let retryMs = ANNOUNCE_RETRY_MS;
     function currentTags() {
         const list = [...(tags ?? []), lookup];
         if (visibility === 'public') {
@@ -294,11 +327,25 @@ export async function createLobby(options) {
             again = true;
             return;
         }
+        if (retry !== null) {
+            clearTimeout(retry);
+            retry = null;
+        }
         announcing = node
             .announce(currentTags())
+            .then(() => {
+            retryMs = ANNOUNCE_RETRY_MS;
+        })
             .catch(() => {
-            // The next tick tries again; a lobby that cannot announce is
-            // simply not found, which the joiner reports as `not-found`.
+            // Retried shortly; until one lands the lobby is simply not found,
+            // which a joiner reports as `not-found`.
+            if (closed || retry !== null)
+                return;
+            retry = setTimeout(() => {
+                retry = null;
+                announce();
+            }, retryMs);
+            retryMs = Math.min(retryMs * 2, ANNOUNCE_RETRY_MAX_MS);
         })
             .finally(() => {
             announcing = null;
@@ -362,6 +409,8 @@ export async function createLobby(options) {
                 return;
             closed = true;
             clearInterval(timer);
+            if (retry !== null)
+                clearTimeout(retry);
             stopMembership();
             listeners.clear();
             await me.close();
@@ -440,15 +489,34 @@ export async function joinLobby(options) {
     // them, or one landing after it would put the seek tag back — over a
     // lobby this node created meanwhile.
     const seekingInFlight = new Set();
+    // A failed seek announcement is retried on a short backoff: the host
+    // cannot let this player in until it holds one, and the reach below
+    // gives up at `timeoutMs` — long before the next lease refresh.
+    let retry = null;
+    let retryMs = ANNOUNCE_RETRY_MS;
     const announce = () => {
         if (stopped !== null)
             return;
-        const sent = node.announce(seeking).catch(() => { });
+        if (retry !== null) {
+            clearTimeout(retry);
+            retry = null;
+        }
+        const sent = node.announce(seeking).then(() => {
+            retryMs = ANNOUNCE_RETRY_MS;
+        }, () => {
+            if (stopped !== null || retry !== null)
+                return;
+            retry = setTimeout(() => {
+                retry = null;
+                announce();
+            }, retryMs);
+            retryMs = Math.min(retryMs * 2, ANNOUNCE_RETRY_MAX_MS);
+        });
         seekingInFlight.add(sent);
         void sent.finally(() => seekingInFlight.delete(sent));
     };
     announce();
-    const timer = setInterval(announce, LOBBY_ANNOUNCE_MS);
+    const timer = setInterval(announce, options.announceEveryMs ?? LOBBY_ANNOUNCE_MS);
     // Withdraws the seek tag, after any seeking announcement still in
     // flight. Settles once the withdrawal has been attempted (a failure is
     // swallowed, as every announcement here is), so a `close()` that awaits
@@ -459,6 +527,8 @@ export async function joinLobby(options) {
         if (stopped !== null)
             return stopped;
         clearInterval(timer);
+        if (retry !== null)
+            clearTimeout(retry);
         stopped = Promise.all(seekingInFlight).then(() => node.announce(keep)).catch(() => { });
         return stopped;
     };

package/dist/net_leaf.d.ts

@@ -487,7 +487,7 @@ export class LeafNode {
      * The re-attempt owner's ledger, as JSON.
      *
      * `{"armed":<bool>,"online":"<n>","iceFailed":"<n>",
-     * "triggers":"<n>","started":"<n>","coalesced":"<n>",
+     * "channelClosed":"<n>","triggers":"<n>","started":"<n>","coalesced":"<n>",
      * "notEligible":"<n>","openEpisodes":<n>,"owned":<n>,
      * "last":"<disposition>"|null}`.
      *
@@ -623,11 +623,10 @@ export class LeafStream {
      * **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.
+     * the node, not on this object — so a close that removed only
+     * the node's stream state left it attached, still invoked 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
@@ -675,7 +674,7 @@ export class LeafStream {
      * 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
+     * node's events 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
@@ -689,10 +688,9 @@ export class LeafStream {
      * 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
+     * The callback is registered on the node, so a registration
+     * nothing names is retained for the node's whole life and keeps
+     * being invoked for its stream's data — 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`]
@@ -1453,16 +1451,16 @@ export interface InitOutput {
     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_2365: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_112: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_113: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_114: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_115: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_116: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2366_117: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_6529: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_6531: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2373: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_2374: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_112: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_113: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_114: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_115: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_116: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_2374_117: (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;

package/dist/net_leaf.js

@@ -848,7 +848,7 @@ export class LeafNode {
      * The re-attempt owner's ledger, as JSON.
      *
      * `{"armed":<bool>,"online":"<n>","iceFailed":"<n>",
-     * "triggers":"<n>","started":"<n>","coalesced":"<n>",
+     * "channelClosed":"<n>","triggers":"<n>","started":"<n>","coalesced":"<n>",
      * "notEligible":"<n>","openEpisodes":<n>,"owned":<n>,
      * "last":"<disposition>"|null}`.
      *
@@ -1150,11 +1150,10 @@ export class LeafStream {
      * **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.
+     * the node, not on this object — so a close that removed only
+     * the node's stream state left it attached, still invoked 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
@@ -1224,7 +1223,7 @@ export class LeafStream {
      * 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
+     * node's events 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
@@ -1238,10 +1237,9 @@ export class LeafStream {
      * 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
+     * The callback is registered on the node, so a registration
+     * nothing names is retained for the node's whole life and keeps
+     * being invoked for its stream's data — 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`]
@@ -2722,7 +2720,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         }, arguments); },
-        __wbg_error_917fe43c4c53b37c: function(arg0, arg1) {
+        __wbg_error_def25afd803510fb: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_fetch_4178962c570137ca: function(arg0, arg1, arg2) {
@@ -2914,7 +2912,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6531(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2956,7 +2954,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6531(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3266,47 +3264,47 @@ function __wbg_get_imports() {
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 34, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2365);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2373);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 868, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6504);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 866, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6529);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_112);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_112);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_113);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_113);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_114);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_114);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCDataChannelEvent")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_115);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_115);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000008: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCPeerConnectionIceErrorEvent")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_116);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_116);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000009: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCPeerConnectionIceEvent")], shim_idx: 35, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_117);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2374_117);
             return addHeapObject(ret);
         },
         __wbindgen_generic_000000000000000a: function(arg0) {
@@ -3333,47 +3331,47 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_2366(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_112(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_112(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_112(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_112(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_113(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_113(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_113(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_113(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_114(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_114(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_114(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_114(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_115(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_115(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_115(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_115(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_116(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_116(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_116(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_116(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2366_117(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2366_117(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2374_117(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2374_117(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2365(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_2365(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2373(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_2373(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_6531(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_6531(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_6504(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_6529(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6504(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_6529(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {

package/dist/net_leaf_bg.wasm.d.ts

@@ -119,16 +119,16 @@ export const proxystream_peer_node_hex: (a: number, b: number) => void;
 export const proxystream_send: (a: number, b: number) => number;
 export const proxystream_stream_id_hex: (a: number, b: number) => void;
 export const start: () => void;
-export const __wasm_bindgen_func_elem_6504: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_6506: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2365: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_112: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_113: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_114: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_115: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_116: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2366_117: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_6529: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_6531: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2373: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_2374: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_112: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_113: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_114: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_115: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_116: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2374_117: (a: number, b: number, c: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;