@net-mesh/browser 0.43.0 → 0.44.0

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

@@ -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}$/;
@@ -283,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') {
@@ -298,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;
@@ -366,6 +409,8 @@ export async function createLobby(options) {
                 return;
             closed = true;
             clearInterval(timer);
+            if (retry !== null)
+                clearTimeout(retry);
             stopMembership();
             listeners.clear();
             await me.close();
@@ -444,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
@@ -463,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_6508: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_6510: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_2367: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_112: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_113: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_114: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_115: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_116: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2367_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`]
@@ -2718,13 +2716,13 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_error_5b007554bf198f44: function(arg0, arg1) {
-            console.error(getStringFromWasm0(arg0, arg1));
-        },
         __wbg_error_6a23b57453026a47: function() { return handleError(function (arg0) {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         }, arguments); },
+        __wbg_error_def25afd803510fb: function(arg0, arg1) {
+            console.error(getStringFromWasm0(arg0, arg1));
+        },
         __wbg_fetch_4178962c570137ca: function(arg0, arg1, arg2) {
             const ret = getObject(arg0).fetch(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
@@ -2914,7 +2912,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6510(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_6510(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_2366);
+            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_2367);
+            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: 867, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6508);
+            // 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_2367_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_2367_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_2367_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_2367_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_2367_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_2367_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_2367(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367(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_2367_112(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2367_113(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2367_114(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2367_115(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2367_116(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2367_117(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2367_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_2366(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_2366(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_6510(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_6510(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_6508(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_6508(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_6508: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_6510: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2367: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_112: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_113: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_114: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_115: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_116: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2367_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;