@net-mesh/browser 0.38.2 → 0.39.0

package/dist/leader/session.d.ts

@@ -90,6 +90,8 @@ export declare class MeshSession {
      * iteration a page is already written to handle.
      */
     private readonly streams;
+    /** One attempt per peer at a time: see {@link PeerAttempts}. */
+    private readonly attempts;
     /**
      * The generation the streams in that set were opened under.
      *
@@ -218,6 +220,14 @@ export declare class MeshSession {
      * nothing is offered — a second offer would replace the working link
      * and close it under the peer. A leader too old to answer that reading
      * is asked for an offer, as before.
+     *
+     * **And on a pair still connecting**, as `BrowserNode.connectPeer` is:
+     * a call while this session's own `connectPeer` or `acceptPeer` for the
+     * peer is under way is answered by it rather than by a second offer.
+     * The healthy-pair reading runs inside that gate, just before any
+     * offer: it is a proxy round trip here, and read ahead of the gate it
+     * could be stale by the time the offer went out. See
+     * {@link PeerAttempts}.
      */
     connectPeer(nodeIdHex: string): Promise<PeerConnectOutcome>;
     /**

package/dist/leader/session.js

@@ -29,7 +29,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 { acceptPeer as driveAccept, connectPeer as driveConnect, } from '../peer-driver.js';
+import { acceptPeer as driveAccept, connectPeer as driveConnect, PeerAttempts, } from '../peer-driver.js';
 import { LeafStream } from '../stream.js';
 import { idArg, loadLeafWasm } from '../wasm.js';
 import { isLifecycleEvent, parseSessionEvent, } from './events.js';
@@ -60,6 +60,8 @@ export class MeshSession {
      * iteration a page is already written to handle.
      */
     streams = new Set();
+    /** One attempt per peer at a time: see {@link PeerAttempts}. */
+    attempts = new PeerAttempts();
     /**
      * The generation the streams in that set were opened under.
      *
@@ -255,27 +257,33 @@ export class MeshSession {
      * nothing is offered — a second offer would replace the working link
      * and close it under the peer. A leader too old to answer that reading
      * is asked for an offer, as before.
+     *
+     * **And on a pair still connecting**, as `BrowserNode.connectPeer` is:
+     * a call while this session's own `connectPeer` or `acceptPeer` for the
+     * peer is under way is answered by it rather than by a second offer.
+     * The healthy-pair reading runs inside that gate, just before any
+     * offer: it is a proxy round trip here, and read ahead of the gate it
+     * could be stale by the time the offer went out. See
+     * {@link PeerAttempts}.
      */
     async connectPeer(nodeIdHex) {
-        let settled;
-        try {
-            settled = (await this.inner.peer_direct_dialog(nodeIdHex)) ?? undefined;
-        }
-        catch {
-            // A closed session is refused by the offer below, typed; an older
-            // leader simply has no such reading.
-            settled = undefined;
-        }
-        if (settled !== undefined)
-            return { type: 'direct', peer: nodeIdHex, dialog: settled };
-        return driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus);
+        return this.attempts.connect(nodeIdHex, async () => {
+            try {
+                return (await this.inner.peer_direct_dialog(nodeIdHex)) ?? undefined;
+            }
+            catch {
+                // A closed session is refused by the offer below, typed; an
+                // older leader simply has no such reading.
+                return undefined;
+            }
+        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * Answer the offer `nodeIdHex` filed — {@link connectPeer}'s
      * counterpart, on whichever tab holds the lock.
      */
     async acceptPeer(nodeIdHex) {
-        return driveAccept(nodeIdHex, this.peerPrimitives(), parseAttemptStatus);
+        return this.attempts.accept(nodeIdHex, () => driveAccept(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * The proxied primitives, each re-typed by the same mapper every

package/dist/local.js

@@ -61,11 +61,16 @@ export function createLocalMesh(options = {}) {
         const targets = listeners.get(to);
         if (targets === undefined)
             throw new Error(`no local node ${to} on this mesh`);
+        // Exact decimal, as the real node's `stream_data` carries it. Hex
+        // here was wrong in a way that hid itself: a hex id with no letters
+        // in it (one random id in ~1,800) reads as a DIFFERENT node's
+        // decimal, so the store answered a joiner at an id not on the mesh.
+        const peerNode = BigInt(`0x${from}`).toString(10);
         for (const handler of [...targets]) {
             // A copy per receiver, as a network would hand each its own
             // bytes: a receiver that mutates its payload must not change
             // what another receiver — or the sender — holds.
-            handler({ type: 'stream_data', streamId, peerNode: from, payload: payload.slice() });
+            handler({ type: 'stream_data', streamId, peerNode, payload: payload.slice() });
         }
     }
     function node(requested) {

package/dist/net_leaf.d.ts

@@ -72,6 +72,13 @@ 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.
      *
@@ -90,13 +97,6 @@ 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,6 +521,13 @@ 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.
@@ -541,13 +548,6 @@ 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,6 +786,11 @@ 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.
      *
@@ -800,11 +805,6 @@ 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,6 +942,12 @@ 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
@@ -962,12 +968,6 @@ 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,16 +1453,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_6603: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_6605: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2410: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_2411: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_112: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_113: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_114: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_115: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_116: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2411_117: (a: number, b: number, c: number) => 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_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 __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

@@ -146,6 +146,21 @@ 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.
      *
@@ -173,21 +188,6 @@ 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,37 +915,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);
@@ -958,24 +945,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);
@@ -1434,6 +1434,19 @@ 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.
      *
@@ -1457,19 +1470,6 @@ 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,37 +1799,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);
@@ -1842,23 +1828,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);
@@ -2718,13 +2718,13 @@ function __wbg_get_imports() {
             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);
         }, arguments); },
-        __wbg_error_6ac7db6e17cac0a2: 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 +2914,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6605(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6511(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_6605(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6511(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3266,47 +3266,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_2410);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2365);
             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_2411);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 906, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6603);
+            // 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);
             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_2411_112);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_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_2411_113);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_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_2411_114);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_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_2411_115);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_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_2411_116);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_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_2411_117);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2366_117);
             return addHeapObject(ret);
         },
         __wbindgen_generic_000000000000000a: function(arg0) {
@@ -3333,47 +3333,47 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_2411(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2366(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2366(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_2411_112(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_112(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_2411_113(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_113(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_2411_114(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_114(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_2411_115(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_115(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_2411_116(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_116(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_2411_117(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2411_117(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_2410(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_2410(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));
     return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_6605(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_6605(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+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_6603(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_6509(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6603(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_6509(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {