@net-mesh/browser 0.38.2 → 0.40.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

@@ -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

@@ -2722,7 +2722,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         }, arguments); },
-        __wbg_error_6ac7db6e17cac0a2: function(arg0, arg1) {
+        __wbg_error_c7a46bea9bd49ca0: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_fetch_4178962c570137ca: function(arg0, arg1, arg2) {
@@ -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: 868, 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) {

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_6603: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_6605: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2410: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2411: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_112: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_113: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_114: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_115: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_116: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2411_117: (a: number, b: number, c: number) => 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_2365: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_112: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_113: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_114: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_115: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_116: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_2366_117: (a: number, b: number, c: number) => void;
 export const __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;

package/dist/node.d.ts

@@ -294,6 +294,8 @@ export declare class BrowserNode {
      * handle.
      */
     private readonly streams;
+    /** One attempt per peer at a time: see {@link PeerAttempts}. */
+    private readonly attempts;
     /**
      * The live org handles (plan §4.5), so {@link BrowserNode.close}
      * can retire ownership: pending calls fail typed and each dropped
@@ -587,6 +589,15 @@ export declare class BrowserNode {
      * and close it under the other side. So a library may call it "to be
      * sure" before opening a stream.
      *
+     * **And on a pair that is still connecting.** A call while another
+     * `connectPeer` for the same peer is under way resolves with that
+     * attempt's outcome instead of offering again (a new offer would cancel
+     * it), and a call while an {@link acceptPeer} for the peer is under way
+     * waits for it and takes its outcome when that settles the pair
+     * (`direct`, `iceTimeout`, `udpBlocked`, or `superseded` by a newer
+     * attempt), offering only after an inconclusive one. See
+     * {@link PeerAttempts}.
+     *
      * Returns a {@link PeerConnectOutcome}. It **rejects** only for
      * something that is not a disposition of the attempt — a closed
      * node, a peer that answered `Reject`, a malformed peer id.

package/dist/node.js

@@ -11,7 +11,7 @@ import { EventHub, parseEvent, parseJsonPreservingU64, toBase64, } from './event
 import { fromWasmError, IdentityError, OrgCancelledError, RtcError } from './errors.js';
 import { clientStreamOrgTrampoline, duplexOrgTrampoline, OrgDuplex, OrgHandleRegistry, OrgServe, OrgStream, OrgUpload, streamingOrgTrampoline, toWasmOrgCallOptions, toWasmOrgServeOptions, unaryOrgTrampoline, } from './org.js';
 import { LeafStream } from './stream.js';
-import { acceptPeer as driveAccept, connectPeer as driveConnect, handshakePeer as driveHandshake, } from './peer-driver.js';
+import { acceptPeer as driveAccept, connectPeer as driveConnect, handshakePeer as driveHandshake, PeerAttempts, } from './peer-driver.js';
 import { classifyRtcFailureAll, probeBootstrapReachable, probeStunBindings, } from './udp-probe.js';
 import { idArg, loadLeafWasm, } from './wasm.js';
 /**
@@ -65,6 +65,8 @@ export class BrowserNode {
      * handle.
      */
     streams = new Set();
+    /** One attempt per peer at a time: see {@link PeerAttempts}. */
+    attempts = new PeerAttempts();
     /**
      * The live org handles (plan §4.5), so {@link BrowserNode.close}
      * can retire ownership: pending calls fail typed and each dropped
@@ -503,23 +505,38 @@ export class BrowserNode {
      * and close it under the other side. So a library may call it "to be
      * sure" before opening a stream.
      *
+     * **And on a pair that is still connecting.** A call while another
+     * `connectPeer` for the same peer is under way resolves with that
+     * attempt's outcome instead of offering again (a new offer would cancel
+     * it), and a call while an {@link acceptPeer} for the peer is under way
+     * waits for it and takes its outcome when that settles the pair
+     * (`direct`, `iceTimeout`, `udpBlocked`, or `superseded` by a newer
+     * attempt), offering only after an inconclusive one. See
+     * {@link PeerAttempts}.
+     *
      * Returns a {@link PeerConnectOutcome}. It **rejects** only for
      * something that is not a disposition of the attempt — a closed
      * node, a peer that answered `Reject`, a malformed peer id.
      */
     async connectPeer(nodeIdHex) {
-        // Already direct and open: the pair it has. A new offer would
-        // replace the working link and close it under the other side.
-        let settled;
+        let peer;
         try {
-            settled = this.inner.peer_direct_dialog(idArg(nodeIdHex, 'peer'));
+            peer = idArg(nodeIdHex, 'peer');
         }
         catch (error) {
             throw fromWasmError(error);
         }
-        if (settled !== undefined && settled !== null)
-            return { type: 'direct', peer: nodeIdHex, dialog: settled };
-        return driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus);
+        return this.attempts.connect(nodeIdHex, 
+        // Already direct and open: the pair it has. A new offer would
+        // replace the working link and close it under the other side.
+        () => {
+            try {
+                return this.inner.peer_direct_dialog(peer);
+            }
+            catch (error) {
+                throw fromWasmError(error);
+            }
+        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * The four primitives the shared drive loop calls, bound to this
@@ -577,7 +594,7 @@ export class BrowserNode {
      * {@link PeerConnectOutcome}, same meanings.
      */
     async acceptPeer(nodeIdHex) {
-        return driveAccept(nodeIdHex, this.peerPrimitives(), parseAttemptStatus);
+        return this.attempts.accept(nodeIdHex, () => driveAccept(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * Read one `peer_candidate` status for a live attempt.

package/dist/peer-driver.d.ts

@@ -77,6 +77,54 @@ export declare const PEER_TICK_MS = 50;
  * Two anchor hops and one pump, so it is generous rather than tight.
  */
 export declare const PEER_OFFER_WAIT_MS = 5000;
+/**
+ * The pair's live dialog when it is already direct and open, `undefined`
+ * (or `null`) otherwise: the healthy-pair reading a surface's
+ * `connectPeer` must not offer over.
+ */
+export type HealthyDialog = () => Promise<string | null | undefined> | string | null | undefined;
+/**
+ * One attempt per peer at a time, per surface.
+ *
+ * **Every offer replaces the pair's link.** The leaf retires whatever
+ * attempt is live for the peer and replaces its DataChannel, so a
+ * second `connectPeer` while the first is still under way cancels it,
+ * and both callers end on the relay or in `iceTimeout`. Nothing about
+ * that is exotic: `joinLobby` reaches the host and then the store it
+ * joins reaches it again before its first stream, and netcode beside a
+ * store does the same. The healthy-direct check in
+ * `BrowserNode.connectPeer` covers a pair that has already arrived; this
+ * covers one that is still arriving.
+ *
+ * So, on one surface:
+ *
+ * - a `connectPeer` while another for the same peer is in flight is
+ *   answered by that one's outcome, not by a second offer;
+ * - a `connectPeer` while an `acceptPeer` for the peer is in flight
+ *   waits for it (offering over it would cancel the attempt it is
+ *   answering), and takes its outcome when that settles the pair
+ *   ({@link answerSettles}): it offers only after an inconclusive one;
+ * - concurrent `acceptPeer`s share one answer.
+ *
+ * Settled attempts are forgotten: the next call starts fresh. Another
+ * tab's node is outside this gate, as it is outside this surface.
+ */
+export declare class PeerAttempts {
+    #private;
+    /**
+     * Run `drive` as this peer's offer, unless one is already under way,
+     * the pair is already direct, or an answer under way settles it.
+     *
+     * `healthy` is read HERE, inside the gate and just before the offer,
+     * never by the caller ahead of it: on a proxied surface the reading is
+     * a round trip, and an `acceptPeer` could take the pair direct and
+     * leave the gate between a caller's early reading and its offer, which
+     * would then replace the healthy link.
+     */
+    connect(peer: string, healthy: HealthyDialog, drive: () => Promise<PeerConnectOutcome>): Promise<PeerConnectOutcome>;
+    /** Run `drive` as this peer's answer, unless one is already under way. */
+    accept(peer: string, drive: () => Promise<PeerConnectOutcome>): Promise<PeerConnectOutcome>;
+}
 /** Offer, drive to an open channel, then handshake (§9 steps 3-4). */
 export declare function connectPeer(peer: string, primitives: PeerPrimitives, parse: (json: string) => PeerAttemptStatus): Promise<PeerConnectOutcome>;
 /**

package/dist/peer-driver.js

@@ -58,6 +58,110 @@ export const PEER_TICK_MS = 50;
  * Two anchor hops and one pump, so it is generous rather than tight.
  */
 export const PEER_OFFER_WAIT_MS = 5_000;
+/**
+ * Whether an answer's outcome settles the pair for a `connectPeer` that
+ * waited on it, rather than calling for an offer of its own.
+ *
+ * - `direct`: the pair has its link.
+ * - `iceTimeout`, `udpBlocked`: this network could not go direct just
+ *   now, and the routed session the answer ran over is still in place.
+ *   An offer straight after would almost surely end the same way, a whole
+ *   ICE deadline later, so the caller gets the answer's verdict instead.
+ * - `superseded` naming a successor: a newer attempt is live, and an
+ *   offer would cancel it.
+ *
+ * Anything else (`handshakeFailed`, `noAnnouncement`, a `superseded`
+ * with no successor) says nothing about the pair, so the waiter offers.
+ */
+function answerSettles(outcome) {
+    switch (outcome.type) {
+        case 'direct':
+        case 'iceTimeout':
+        case 'udpBlocked':
+            return true;
+        case 'superseded':
+            return outcome.liveDialog !== null;
+        default:
+            return false;
+    }
+}
+/**
+ * One attempt per peer at a time, per surface.
+ *
+ * **Every offer replaces the pair's link.** The leaf retires whatever
+ * attempt is live for the peer and replaces its DataChannel, so a
+ * second `connectPeer` while the first is still under way cancels it,
+ * and both callers end on the relay or in `iceTimeout`. Nothing about
+ * that is exotic: `joinLobby` reaches the host and then the store it
+ * joins reaches it again before its first stream, and netcode beside a
+ * store does the same. The healthy-direct check in
+ * `BrowserNode.connectPeer` covers a pair that has already arrived; this
+ * covers one that is still arriving.
+ *
+ * So, on one surface:
+ *
+ * - a `connectPeer` while another for the same peer is in flight is
+ *   answered by that one's outcome, not by a second offer;
+ * - a `connectPeer` while an `acceptPeer` for the peer is in flight
+ *   waits for it (offering over it would cancel the attempt it is
+ *   answering), and takes its outcome when that settles the pair
+ *   ({@link answerSettles}): it offers only after an inconclusive one;
+ * - concurrent `acceptPeer`s share one answer.
+ *
+ * Settled attempts are forgotten: the next call starts fresh. Another
+ * tab's node is outside this gate, as it is outside this surface.
+ */
+export class PeerAttempts {
+    #connecting = new Map();
+    #accepting = new Map();
+    /**
+     * Run `drive` as this peer's offer, unless one is already under way,
+     * the pair is already direct, or an answer under way settles it.
+     *
+     * `healthy` is read HERE, inside the gate and just before the offer,
+     * never by the caller ahead of it: on a proxied surface the reading is
+     * a round trip, and an `acceptPeer` could take the pair direct and
+     * leave the gate between a caller's early reading and its offer, which
+     * would then replace the healthy link.
+     */
+    connect(peer, healthy, drive) {
+        const key = peer.toLowerCase();
+        const joining = this.#connecting.get(key);
+        if (joining !== undefined)
+            return joining;
+        const answering = this.#accepting.get(key);
+        const started = (async () => {
+            if (answering !== undefined) {
+                const answered = await answering.catch(() => null);
+                if (answered !== null && answerSettles(answered))
+                    return answered;
+            }
+            const dialog = await healthy();
+            if (dialog !== undefined && dialog !== null)
+                return { type: 'direct', peer, dialog };
+            return drive();
+        })();
+        return PeerAttempts.#track(this.#connecting, key, started);
+    }
+    /** Run `drive` as this peer's answer, unless one is already under way. */
+    accept(peer, drive) {
+        const key = peer.toLowerCase();
+        const joining = this.#accepting.get(key);
+        if (joining !== undefined)
+            return joining;
+        return PeerAttempts.#track(this.#accepting, key, drive());
+    }
+    static #track(map, key, started) {
+        map.set(key, started);
+        // Forget it once settled, and only if no newer one took its place.
+        const forget = () => {
+            if (map.get(key) === started)
+                map.delete(key);
+        };
+        started.then(forget, forget);
+        return started;
+    }
+}
 /** Offer, drive to an open channel, then handshake (§9 steps 3-4). */
 export async function connectPeer(peer, primitives, parse) {
     let dialog;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@net-mesh/browser",
-  "version": "0.38.2",
+  "version": "0.40.0",
   "description": "Browser-native Net mesh leaf \u2014 idiomatic TypeScript over the net-mesh-leaf wasm node",
   "type": "module",
   "main": "dist/index.js",