@net-mesh/browser 0.38.1 → 0.39.0

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.1",
+  "version": "0.39.0",
   "description": "Browser-native Net mesh leaf \u2014 idiomatic TypeScript over the net-mesh-leaf wasm node",
   "type": "module",
   "main": "dist/index.js",