@net-mesh/browser 0.39.0 → 0.41.0

package/dist/index.d.ts

@@ -36,3 +36,12 @@ export { rememberedIdentity, DEFAULT_IDENTITY_KEY } from './identity.js';
 export type { IdentitySecrets } from './identity.js';
 export { requestCredential, CredentialRequestError } from './credential.js';
 export type { AnchorCredential, CredentialRequestErrorKind, RequestCredentialOptions, } from './credential.js';
+export { ORG_SINK_BUDGET_REFUSAL, ORG_UPLOAD_SINK_BUDGET_REFUSAL, ORG_UPLOAD_SINK_CLOSED_REFUSAL, } from './errors.js';
+export { clientStreamOrgTrampoline, duplexOrgTrampoline, streamingOrgTrampoline, unaryOrgTrampoline, } from './org.js';
+export { acceptPeer, connectPeer, driveAttempt, handshakePeer, NO_ANNOUNCEMENT_PREFIX, NO_LIVE_ATTEMPT_PREFIX, NO_OFFER_PREFIX, PEER_OFFER_WAIT_MS, PEER_TICK_MS, PeerAttempts, REPLACED_ATTEMPT_MARKER, } from './peer-driver.js';
+export type { HealthyDialog, PeerPrimitives, } from './peer-driver.js';
+export { StreamIdentityError, } from './stream.js';
+export type { StreamIdentity, } from './stream.js';
+export { STUN_NO_RESPONSE_CODE, } from './udp-probe.js';
+export { idArg, } from './wasm.js';
+export type { LeafWasmOrgAccess, LeafWasmOrgByteItem, LeafWasmOrgByteStreamHandle, LeafWasmOrgCaller, LeafWasmOrgCallOptions, LeafWasmOrgClientStreamHandler, LeafWasmOrgCredentials, LeafWasmOrgDuplexCallHandle, LeafWasmOrgDuplexHandler, LeafWasmOrgRequestItem, LeafWasmOrgRequestStreamHandle, LeafWasmOrgResponseSinkHandle, LeafWasmOrgServeHandle, LeafWasmOrgServeOptions, LeafWasmOrgStreamingHandler, LeafWasmOrgTerminalError, LeafWasmOrgUnaryHandler, LeafWasmOrgUploadCallHandle, } from './wasm.js';

package/dist/index.js

@@ -44,3 +44,12 @@ export * from './lobby.js';
 export { rememberedIdentity, DEFAULT_IDENTITY_KEY } from './identity.js';
 // Anonymous visitor credentials from a game anchor.
 export { requestCredential, CredentialRequestError } from './credential.js';
+// The rest of the public module surface: lower-level building blocks
+// the high-level verbs above are made of, exported so callers can
+// compose their own.
+export { ORG_SINK_BUDGET_REFUSAL, ORG_UPLOAD_SINK_BUDGET_REFUSAL, ORG_UPLOAD_SINK_CLOSED_REFUSAL, } from './errors.js';
+export { clientStreamOrgTrampoline, duplexOrgTrampoline, streamingOrgTrampoline, unaryOrgTrampoline, } from './org.js';
+export { acceptPeer, connectPeer, driveAttempt, handshakePeer, NO_ANNOUNCEMENT_PREFIX, NO_LIVE_ATTEMPT_PREFIX, NO_OFFER_PREFIX, PEER_OFFER_WAIT_MS, PEER_TICK_MS, PeerAttempts, REPLACED_ATTEMPT_MARKER, } from './peer-driver.js';
+export { StreamIdentityError, } from './stream.js';
+export { STUN_NO_RESPONSE_CODE, } from './udp-probe.js';
+export { idArg, } from './wasm.js';

package/dist/leader/index.d.ts

@@ -9,6 +9,6 @@
 export { MeshSession, openSession } from './session.js';
 export type { SessionOptions, SessionRole } from './session.js';
 export { isLifecycleEvent, parseSessionEvent } from './events.js';
-export type { GenerationFencedEvent, LeaderChangedEvent, LeaderLostEvent, NotLeaderEvent, SessionEvent, SessionEventOf, SessionLifecycleEvent, SubscriptionRestoredEvent, } from './events.js';
+export type { GenerationFencedEvent, LeaderChangedEvent, LeaderLostEvent, NotLeaderEvent, PromotionFailedEvent, SessionEvent, SessionEventOf, SessionLifecycleEvent, SubscriptionRestoredEvent, } from './events.js';
 export { asSessionModule } from './wasm.js';
 export type { LeafWasmSession, LeafWasmSessionModule, LeafWasmSessionOptions, } from './wasm.js';

package/dist/net_leaf.d.ts

@@ -72,13 +72,6 @@ export class LeafNode {
      * a silent retry.
      */
     call(service: string, payload: Uint8Array, timeout_ms?: number | null): 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 unary call.
      *
@@ -97,6 +90,13 @@ export class LeafNode {
      * 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.
@@ -521,13 +521,6 @@ export class LeafNode {
      * zeros.
      */
     rtc_stats_json(): string;
-    /**
-     * 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 unary service: `handler(caller, request)`
      * resolves the response body.
@@ -548,6 +541,13 @@ export class LeafNode {
      * 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
@@ -786,11 +786,6 @@ export class MeshSession {
      * Call an nRPC service.
      */
     call(service: string, payload: Uint8Array, timeout_ms?: number | null): 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 unary call through the shared session.
      *
@@ -805,6 +800,11 @@ export class MeshSession {
      * 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.
@@ -942,12 +942,6 @@ export class MeshSession {
      * The lock and channel name.
      */
     scope(): string;
-    /**
-     * 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 unary service through the shared
      * session: `handler(caller, request)` resolves the response
@@ -968,6 +962,12 @@ export class MeshSession {
      * 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
@@ -1453,8 +1453,8 @@ 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_6509: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_6511: (a: number, b: number, c: number, d: number) => 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;

package/dist/net_leaf.js

@@ -146,21 +146,6 @@ export class LeafNode {
         const ret = wasm.leafnode_call(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
         return takeObject(ret);
     }
-    /**
-     * One org-scoped client-streaming call. `send` pushes items,
-     * `finish` half-closes and resolves the response body. See
-     * [`Self::call_org`] for the deadline, suspension and closure
-     * contract.
-     * @param {string} service
-     * @param {any} opts
-     * @returns {Promise<OrgUploadCallHandle>}
-     */
-    call_org_client_stream(service, opts) {
-        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.leafnode_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
-        return takeObject(ret);
-    }
     /**
      * One org-scoped unary call.
      *
@@ -188,6 +173,21 @@ export class LeafNode {
         const ret = wasm.leafnode_call_org(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
         return takeObject(ret);
     }
+    /**
+     * One org-scoped client-streaming call. `send` pushes items,
+     * `finish` half-closes and resolves the response body. See
+     * [`Self::call_org`] for the deadline, suspension and closure
+     * contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgUploadCallHandle>}
+     */
+    call_org_client_stream(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.leafnode_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
     /**
      * One org-scoped duplex call. See [`Self::call_org`] for the
      * deadline, suspension and closure contract.
@@ -915,24 +915,37 @@ export class LeafNode {
         }
     }
     /**
-     * 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 one org-scoped unary service: `handler(caller, request)`
+     * resolves the response body.
+     *
+     * # The handler-drop contract (F-S3.1-2)
+     *
+     * The retire supervisor may drop the handler future without a
+     * final poll — cancellation is observed through the retirement
+     * observables (the terminal item, the sink's typed closed
+     * refusal, and `retired`), never assumed as a handler-side
+     * event; a detached observer holding `retired` observes the
+     * signal. After retirement the handler sees typed refusals and
+     * its return value is discarded — the terminal was already
+     * sent.
+     *
+     * Closing the returned handle retires this registration's live
+     * protected calls with their exact terminals and refuses new
+     * openings (C9's protected split).
      * @param {string} service
      * @param {string} access
      * @param {Function} handler
      * @param {any} opts
      * @returns {OrgServeHandle}
      */
-    serve_org_client_stream(service, access, handler, opts) {
+    serve_org(service, access, handler, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.leafnode_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            wasm.leafnode_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -945,37 +958,24 @@ export class LeafNode {
         }
     }
     /**
-     * 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 one org-scoped client-streaming service:
+     * `handler(caller, requests)` resolves the response body. See
+     * [`Self::serve_org`] for the handler-drop contract and the
+     * close semantics.
      * @param {string} service
      * @param {string} access
      * @param {Function} handler
      * @param {any} opts
      * @returns {OrgServeHandle}
      */
-    serve_org(service, access, handler, opts) {
+    serve_org_client_stream(service, access, handler, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.leafnode_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            wasm.leafnode_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1434,19 +1434,6 @@ export class MeshSession {
         const ret = wasm.meshsession_call(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), !isLikeNone(timeout_ms), isLikeNone(timeout_ms) ? 0 : timeout_ms);
         return takeObject(ret);
     }
-    /**
-     * One org-scoped client-streaming call through the shared
-     * session. See [`Self::call_org`] for the contract.
-     * @param {string} service
-     * @param {any} opts
-     * @returns {Promise<OrgUploadCallHandle>}
-     */
-    call_org_client_stream(service, opts) {
-        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.meshsession_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
-        return takeObject(ret);
-    }
     /**
      * One org-scoped unary call through the shared session.
      *
@@ -1470,6 +1457,19 @@ export class MeshSession {
         const ret = wasm.meshsession_call_org(this.__wbg_ptr, ptr0, len0, addHeapObject(payload), addHeapObject(opts));
         return takeObject(ret);
     }
+    /**
+     * One org-scoped client-streaming call through the shared
+     * session. See [`Self::call_org`] for the contract.
+     * @param {string} service
+     * @param {any} opts
+     * @returns {Promise<OrgUploadCallHandle>}
+     */
+    call_org_client_stream(service, opts) {
+        const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.meshsession_call_org_client_stream(this.__wbg_ptr, ptr0, len0, addHeapObject(opts));
+        return takeObject(ret);
+    }
     /**
      * One org-scoped duplex call through the shared session. See
      * [`Self::call_org`] for the contract.
@@ -1799,23 +1799,37 @@ export class MeshSession {
         }
     }
     /**
-     * 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 one org-scoped unary service through the shared
+     * session: `handler(caller, request)` resolves the response
+     * body. The registration rides the proxy registry and its
+     * inbound calls dispatch to THIS follower's handle and no other.
+     *
+     * # The handler-drop contract (F-S3.1-2)
+     *
+     * The retire supervisor may drop the handler future without a
+     * final poll — cancellation is observed through the retirement
+     * observables (the terminal item, the sink's typed closed
+     * refusal, and `retired`), never assumed as a handler-side
+     * event; a detached observer holding `retired` observes the
+     * signal. After retirement the handler sees typed refusals and
+     * its return value is discarded — the terminal was already
+     * sent. Closing the returned handle retires this registration's
+     * live protected calls with their exact terminals and refuses
+     * new openings (C9's protected split).
      * @param {string} service
      * @param {string} access
      * @param {Function} handler
      * @param {any} opts
      * @returns {OrgServeHandle}
      */
-    serve_org_client_stream(service, access, handler, opts) {
+    serve_org(service, access, handler, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.meshsession_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            wasm.meshsession_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1828,37 +1842,23 @@ export class MeshSession {
         }
     }
     /**
-     * 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 one org-scoped client-streaming service through the
+     * shared session. See [`Self::serve_org`] for the handler-drop
+     * contract and the close semantics.
      * @param {string} service
      * @param {string} access
      * @param {Function} handler
      * @param {any} opts
      * @returns {OrgServeHandle}
      */
-    serve_org(service, access, handler, opts) {
+    serve_org_client_stream(service, access, handler, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(service, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(access, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.meshsession_serve_org(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
+            wasm.meshsession_serve_org_client_stream(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(handler), addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2714,13 +2714,13 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).errorCode;
             return ret;
         },
+        __wbg_error_25ec685a8c675bef: function(arg0, arg1) {
+            console.error(getStringFromWasm0(arg0, arg1));
+        },
         __wbg_error_3da0c81bd4184d52: function(arg0) {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_error_68609ef5ca157ced: 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);
@@ -2914,7 +2914,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6511(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2956,7 +2956,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6511(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3275,8 +3275,8 @@ function __wbg_get_imports() {
             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_6509);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
@@ -3366,14 +3366,14 @@ function __wasm_bindgen_func_elem_2365(arg0, arg1, arg2) {
     return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_6511(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_6511(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+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_6509(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_6504(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6509(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_6504(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {

package/dist/net_leaf_bg.wasm.d.ts

@@ -119,8 +119,8 @@ 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_6509: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_6511: (a: number, b: number, c: number, d: number) => 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;

package/dist/netcode/index.d.ts

@@ -17,3 +17,6 @@ export type { ClockEstimate, Millis } from './clock.js';
 export { SnapshotBuffer, lerpNumbers, SNAPSHOT_BUFFER } from './interpolate.js';
 export type { Interpolator, TimedSnapshot } from './interpolate.js';
 export type { NetcodeStream, NetcodeTransport } from './wire.js';
+export { snapshotFrames, } from './host.js';
+export { chunkOf, decodeFrame, defaultNow, encodeFrame, eventPeer, MAX_NETCODE_INTEREST_KEY_LENGTH, MAX_NETCODE_INTEREST_KEYS, MAX_SNAPSHOT_CHUNKS, peerHex, } from './wire.js';
+export type { Frame, Now, WireInput, } from './wire.js';

package/dist/netcode/index.js

@@ -12,3 +12,7 @@ export { hostNetcode } from './host.js';
 export { joinNetcode } from './client.js';
 export { ClockEstimator, CLOCK_WINDOW } from './clock.js';
 export { SnapshotBuffer, lerpNumbers, SNAPSHOT_BUFFER } from './interpolate.js';
+// The netcode wire format and its helpers, exported so callers can
+// build their own transports and tooling on the same frames.
+export { snapshotFrames, } from './host.js';
+export { chunkOf, decodeFrame, defaultNow, encodeFrame, eventPeer, MAX_NETCODE_INTEREST_KEY_LENGTH, MAX_NETCODE_INTEREST_KEYS, MAX_SNAPSHOT_CHUNKS, peerHex, } from './wire.js';

package/dist/store/host.d.ts

@@ -115,7 +115,8 @@ export interface StoreTransport {
     connectPeer?(peerHex: string): Promise<unknown>;
 }
 /**
- * A peer id in the spelling `openStream` takes: 16 lowercase hex.
+ * The peer ON AN EVENT, in the spelling `openStream` takes: 16
+ * lowercase hex. For an id the caller holds, see {@link nodeHexOf}.
  *
  * Events carry the authenticated peer as an EXACT DECIMAL string, and
  * `openStream({ peer })` requires 16 hex digits. Handing the decimal
@@ -126,8 +127,23 @@ export interface StoreTransport {
  * reconciliation for the store's own seam.
  */
 export declare function peerHexOf(peer: string): string | null;
-/** Whether two peer spellings name the same node. */
-export declare function samePeer(left: string, right: string): boolean;
+/**
+ * A node id the CALLER holds, in the same spelling: 16 lowercase hex.
+ *
+ * Not {@link peerHexOf}, which reads an event's peer and takes digits
+ * to mean decimal. An id a caller holds is nearly always one this
+ * package printed — `nodeIdHex()`, a descriptor's `peerIdHex`, a
+ * lobby's `host` — and one such id in ~1,800 has no letter in it. Read
+ * as decimal it names a DIFFERENT node: a joiner addressed its host
+ * 4798628394172323 as 00110c53bcd7ffa3, and nothing was there. So
+ * sixteen hex digits are hex, whatever they are made of.
+ *
+ * Any other length is read as {@link peerHexOf} reads it, so an app
+ * may still hand back the decimal `peerNode` an event gave it. A
+ * decimal exactly sixteen digits long is the one spelling that cannot
+ * be told from the canonical hex, and it is read as hex.
+ */
+export declare function nodeHexOf(id: string): string | null;
 /**
  * How a host decides what each replica sees: exactly one of these.
  *

package/dist/store/host.js

@@ -50,7 +50,8 @@ export const HOST_SWEEP_MS = 5_000;
  */
 export const FAREWELL_DEADLINE_MS = 500;
 /**
- * A peer id in the spelling `openStream` takes: 16 lowercase hex.
+ * The peer ON AN EVENT, in the spelling `openStream` takes: 16
+ * lowercase hex. For an id the caller holds, see {@link nodeHexOf}.
  *
  * Events carry the authenticated peer as an EXACT DECIMAL string, and
  * `openStream({ peer })` requires 16 hex digits. Handing the decimal
@@ -74,11 +75,24 @@ export function peerHexOf(peer) {
     }
     return null;
 }
-/** Whether two peer spellings name the same node. */
-export function samePeer(left, right) {
-    const a = peerHexOf(left);
-    const b = peerHexOf(right);
-    return a !== null && a === b;
+/**
+ * A node id the CALLER holds, in the same spelling: 16 lowercase hex.
+ *
+ * Not {@link peerHexOf}, which reads an event's peer and takes digits
+ * to mean decimal. An id a caller holds is nearly always one this
+ * package printed — `nodeIdHex()`, a descriptor's `peerIdHex`, a
+ * lobby's `host` — and one such id in ~1,800 has no letter in it. Read
+ * as decimal it names a DIFFERENT node: a joiner addressed its host
+ * 4798628394172323 as 00110c53bcd7ffa3, and nothing was there. So
+ * sixteen hex digits are hex, whatever they are made of.
+ *
+ * Any other length is read as {@link peerHexOf} reads it, so an app
+ * may still hand back the decimal `peerNode` an event gave it. A
+ * decimal exactly sixteen digits long is the one spelling that cannot
+ * be told from the canonical hex, and it is read as hex.
+ */
+export function nodeHexOf(id) {
+    return /^[0-9a-f]{16}$/i.test(id) ? id.toLowerCase() : peerHexOf(id);
 }
 /**
  * The store addresses live on each transport.
@@ -663,7 +677,7 @@ export function hostStore(options) {
         owner: owner,
         // The spelling `AccessRequest.peer` and `ActionContext.peer`
         // promise: 16 lowercase hex, as a replica's frames are handed.
-        peer: peerHexOf(authority) ?? authority,
+        peer: nodeHexOf(authority) ?? authority,
         maxEventBytes: options.maxEventBytes,
         dispatched,
         isClosed: () => closed,

package/dist/store/index.d.ts

@@ -48,3 +48,26 @@ export type { Hidden, Visibility, VisibilityPreset, VisibilityRule, VisibilityRu
 export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
 export type { CellOptions } from './interest.js';
 export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';
+export { Assembly, ASSEMBLY_DEADLINE_MS, AssemblyTable, MAX_ASSEMBLY_BYTES_TOTAL, } from './assembly.js';
+export type { AssemblyChunk, AssemblyManifest, AssemblyRefusal, AssemblyRejected, ChunkOutcome, } from './assembly.js';
+export { assertChunkingFits, base64, chunkBytesFor, chunkSnapshot, fromBase64, jsonByteLength, LARGEST_FROZEN_ENVELOPE, MIN_CHUNK_BYTES, SNAP_ENVELOPE_RESERVE, } from './chunker.js';
+export type { Chunked, } from './chunker.js';
+export { isEntityMap, } from './definition.js';
+export { isStaleStream, STORE_ERROR_CODES, } from './errors.js';
+export { FAREWELL_DEADLINE_MS, hostInternals, nodeHexOf, peerHexOf, } from './host.js';
+export type { HostInternals, } from './host.js';
+export { TICK_INTERVAL_MS, TRANSITION_DEADLINE_MS, } from './join.js';
+export { MAX_JSON_DEPTH, parseStoreJson, } from './json.js';
+export type { JsonFailure, JsonObject, JsonRefusal, JsonResult, JsonValue, } from './json.js';
+export { BINDING_INLINE_MAX_BYTES, canonicalBytes, canonicalRequest, digestBinding, HandleLedger, inlineBinding, InputSequences, LEDGER_MAX_AGE_MS, LEDGER_MAX_BYTES, LEDGER_MAX_ENTRIES, LedgerTable, MAX_SEQUENCE, needsDigest, } from './ledger.js';
+export type { Disposition, Outcome, RequestBinding, } from './ledger.js';
+export { HANDLE_LEASE_MS, MAX_HANDLES, MAX_PENDING_ACTIONS, StoreOwner, } from './owner.js';
+export type { ActionHandlers, Dispatched, InputHandlers, Outbound, OwnerDeps, OwnerHandle, } from './owner.js';
+export { applyPatch, FORBIDDEN_SEGMENTS, } from './patch.js';
+export type { PatchApplied, PatchOutcome, PatchRefusal, PatchRejected, } from './patch.js';
+export { MAX_JOIN_REASKS, StoreReplica, } from './replica.js';
+export type { Received, ReplicaDeps, ReplicaState, Request, } from './replica.js';
+export { applyVisibility, compileVisibility, } from './visibility.js';
+export type { CompiledVisibility, } from './visibility.js';
+export { CALLER_KINDS, decimalValue, decodeMessage, encodeMessage, HANDLE_HEX_LENGTH, inadmissibleValue, INCARNATION_HEX_LENGTH, isCanonicalBase64, isCanonicalDecimal, isCanonicalHex, MAX_AUDIENCE_LABEL_BYTES, MAX_AUDIENCE_LABELS, MAX_DECIMAL, MAX_DETAIL_BYTES, MAX_PATCH_OPS, MAX_PATH_SEGMENT_BYTES, MAX_PATH_SEGMENTS, MAX_SNAPSHOT_BYTES, MAX_SNAPSHOT_CHUNKS, OWNER_KINDS, REQUEST_HEX_LENGTH, utf8Length, WIRE_VERSION, } from './wire.js';
+export type { ActMessage, AliveMessage, AudienceMessage, CallerKind, CallerMessage, Decimal, DecodeOptions, DecodeRefusal, DecodeResult, DecodeStage, DeltaMessage, Hex, InputMessage, InterestMessage, JoinMessage, LeaveMessage, ManifestMessage, MessageFor, MessageKind, NoMessage, OkMessage, OwnerKind, OwnerMessage, ResultMessage, ResumeMessage, ResyncMessage, Side, SnapMessage, StoreMessage, WireOp, } from './wire.js';

package/dist/store/index.js

@@ -38,3 +38,19 @@ export { addItems, countItems, emptyInventory, hasItems, InventoryError, invento
 export { assertHidden, HIDDEN, hiddenOr, isHidden, projectVisible, } from './visibility.js';
 export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
 export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';
+// The store's lower-level building blocks — wire codec, ledgers,
+// chunking, owner/replica cores — exported so callers can compose
+// their own transports and tooling.
+export { Assembly, ASSEMBLY_DEADLINE_MS, AssemblyTable, MAX_ASSEMBLY_BYTES_TOTAL, } from './assembly.js';
+export { assertChunkingFits, base64, chunkBytesFor, chunkSnapshot, fromBase64, jsonByteLength, LARGEST_FROZEN_ENVELOPE, MIN_CHUNK_BYTES, SNAP_ENVELOPE_RESERVE, } from './chunker.js';
+export { isEntityMap, } from './definition.js';
+export { isStaleStream, STORE_ERROR_CODES, } from './errors.js';
+export { FAREWELL_DEADLINE_MS, hostInternals, nodeHexOf, peerHexOf, } from './host.js';
+export { TICK_INTERVAL_MS, TRANSITION_DEADLINE_MS, } from './join.js';
+export { MAX_JSON_DEPTH, parseStoreJson, } from './json.js';
+export { BINDING_INLINE_MAX_BYTES, canonicalBytes, canonicalRequest, digestBinding, HandleLedger, inlineBinding, InputSequences, LEDGER_MAX_AGE_MS, LEDGER_MAX_BYTES, LEDGER_MAX_ENTRIES, LedgerTable, MAX_SEQUENCE, needsDigest, } from './ledger.js';
+export { HANDLE_LEASE_MS, MAX_HANDLES, MAX_PENDING_ACTIONS, StoreOwner, } from './owner.js';
+export { applyPatch, FORBIDDEN_SEGMENTS, } from './patch.js';
+export { MAX_JOIN_REASKS, StoreReplica, } from './replica.js';
+export { applyVisibility, compileVisibility, } from './visibility.js';
+export { CALLER_KINDS, decimalValue, decodeMessage, encodeMessage, HANDLE_HEX_LENGTH, inadmissibleValue, INCARNATION_HEX_LENGTH, isCanonicalBase64, isCanonicalDecimal, isCanonicalHex, MAX_AUDIENCE_LABEL_BYTES, MAX_AUDIENCE_LABELS, MAX_DECIMAL, MAX_DETAIL_BYTES, MAX_PATCH_OPS, MAX_PATH_SEGMENT_BYTES, MAX_PATH_SEGMENTS, MAX_SNAPSHOT_BYTES, MAX_SNAPSHOT_CHUNKS, OWNER_KINDS, REQUEST_HEX_LENGTH, utf8Length, WIRE_VERSION, } from './wire.js';