@net-mesh/browser 0.41.0 → 0.41.1

package/dist/leader/session.d.ts

@@ -90,7 +90,7 @@ 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}. */
+    /** One attempt per peer at a time, and one offerer per pair: see {@link PeerAttempts}. */
     private readonly attempts;
     /**
      * The generation the streams in that set were opened under.
@@ -228,6 +228,13 @@ export declare class MeshSession {
      * 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}.
+     *
+     * **And between two nodes, the lower id offers.** When this node's id
+     * is the higher of the pair, an offer the peer sent in the last
+     * `PEER_OFFER_FRESH_MS` (10 s) — or one that crosses this call's own —
+     * is answered instead of offered over, so two pages reaching each
+     * other at once (glare) converge rather than cancel. 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, PeerAttempts, } from '../peer-driver.js';
+import { acceptPeer as driveAccept, answerWaitingOffer, connectPeer as driveConnect, noteOffer, PeerAttempts, } from '../peer-driver.js';
 import { LeafStream } from '../stream.js';
 import { idArg, loadLeafWasm } from '../wasm.js';
 import { isLifecycleEvent, parseSessionEvent, } from './events.js';
@@ -60,8 +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();
+    /** One attempt per peer at a time, and one offerer per pair: see {@link PeerAttempts}. */
+    attempts = new PeerAttempts(() => this.inner.node_id_hex() ?? null);
     /**
      * The generation the streams in that set were opened under.
      *
@@ -89,6 +89,7 @@ export class MeshSession {
         this.inner = inner;
         this.streamGeneration = inner.generation();
         inner.on_event((json) => this.hub.deliver(json, parseSessionEvent));
+        this.hub.onAny((event) => noteOffer(this.attempts, event));
         this.hub.onAny((event) => {
             // `leader_lost` is this tab losing the leader it was talking
             // to; `not_leader` is this tab discovering it *was* the leader
@@ -265,6 +266,13 @@ export class MeshSession {
      * 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}.
+     *
+     * **And between two nodes, the lower id offers.** When this node's id
+     * is the higher of the pair, an offer the peer sent in the last
+     * `PEER_OFFER_FRESH_MS` (10 s) — or one that crosses this call's own —
+     * is answered instead of offered over, so two pages reaching each
+     * other at once (glare) converge rather than cancel. See
+     * {@link PeerAttempts}.
      */
     async connectPeer(nodeIdHex) {
         return this.attempts.connect(nodeIdHex, async () => {
@@ -276,7 +284,7 @@ export class MeshSession {
                 // older leader simply has no such reading.
                 return undefined;
             }
-        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
+        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus), () => answerWaitingOffer(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * Answer the offer `nodeIdHex` filed — {@link connectPeer}'s

package/dist/lobby.js

@@ -435,19 +435,32 @@ export async function joinLobby(options) {
     const node = options.node;
     const keep = [...(options.tags ?? [])];
     const seeking = [...keep, seekTag(options.game, host)];
-    let stopped = false;
+    let stopped = null;
+    // The seeking announcements not yet settled: the withdrawal waits for
+    // them, or one landing after it would put the seek tag back — over a
+    // lobby this node created meanwhile.
+    const seekingInFlight = new Set();
     const announce = () => {
-        if (!stopped)
-            node.announce(seeking).catch(() => { });
+        if (stopped !== null)
+            return;
+        const sent = node.announce(seeking).catch(() => { });
+        seekingInFlight.add(sent);
+        void sent.finally(() => seekingInFlight.delete(sent));
     };
     announce();
     const timer = setInterval(announce, LOBBY_ANNOUNCE_MS);
+    // Withdraws the seek tag, after any seeking announcement still in
+    // flight. Settles once the withdrawal has been attempted (a failure is
+    // swallowed, as every announcement here is), so a `close()` that awaits
+    // it is an ordering barrier: an announcement replaces the node's whole
+    // tag set, and one still in flight when the page goes on to
+    // `createLobby` would land after the new listing and erase it.
     const stop = () => {
-        if (stopped)
-            return;
-        stopped = true;
+        if (stopped !== null)
+            return stopped;
         clearInterval(timer);
-        node.announce(keep).catch(() => { });
+        stopped = Promise.all(seekingInFlight).then(() => node.announce(keep)).catch(() => { });
+        return stopped;
     };
     // Reach the host before joining. Until this player's announcement has
     // reached the host, the host refuses the handshake — so a refusal here
@@ -462,7 +475,7 @@ export async function joinLobby(options) {
             }
             catch (error) {
                 if (Date.now() >= deadline) {
-                    stop();
+                    void stop();
                     throw new LobbyError('not-found', `could not reach the lobby's host ${host}: ${String(error?.message ?? error)}`);
                 }
                 await new Promise(resolve => setTimeout(resolve, 500));
@@ -482,13 +495,14 @@ export async function joinLobby(options) {
         });
     }
     catch (error) {
-        stop();
+        void stop();
         throw error;
     }
     const close = joined.close.bind(joined);
     joined.close = async () => {
-        stop();
+        const withdrawn = stop();
         await close();
+        await withdrawn;
     };
     return joined;
 }

package/dist/net_leaf.js

@@ -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_4c50581549efd2db: 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);
@@ -3275,7 +3275,7 @@ 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: 868, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // 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_6504);
             return addHeapObject(ret);
         },

package/dist/node.d.ts

@@ -294,7 +294,7 @@ export declare class BrowserNode {
      * handle.
      */
     private readonly streams;
-    /** One attempt per peer at a time: see {@link PeerAttempts}. */
+    /** One attempt per peer at a time, and one offerer per pair: see {@link PeerAttempts}. */
     private readonly attempts;
     /**
      * The live org handles (plan §4.5), so {@link BrowserNode.close}
@@ -598,6 +598,13 @@ export declare class BrowserNode {
      * attempt), offering only after an inconclusive one. See
      * {@link PeerAttempts}.
      *
+     * **And between two nodes, the lower id offers.** When this node's id
+     * is the higher of the pair, an offer the peer sent in the last
+     * `PEER_OFFER_FRESH_MS` (10 s) — or one that crosses this call's own —
+     * is answered instead of offered over, so two pages reaching each
+     * other at once (glare) converge rather than cancel. 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.
@@ -814,6 +821,11 @@ export declare function buildConnectRequest(options: ConnectOptions): LeafWasmCo
  * are `u64` on the Rust side and a JS number would round the large
  * ones. Exported for the session surface, whose `counters_json` is a
  * promise but whose payload is identical.
+ *
+ * A nested group is flattened into dotted keys: the leaf's per-reason
+ * `drops` object becomes `drops.<reason>`, one counter each. Stringified
+ * whole, it read `"[object Object]"` — every drop reason lost behind
+ * the doc comment's promise of "each drop reason".
  */
 export declare function parseCounters(json: string): Record<string, string>;
 /**

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, PeerAttempts, } from './peer-driver.js';
+import { acceptPeer as driveAccept, answerWaitingOffer, connectPeer as driveConnect, handshakePeer as driveHandshake, noteOffer, PeerAttempts, } from './peer-driver.js';
 import { classifyRtcFailureAll, probeBootstrapReachable, probeStunBindings, } from './udp-probe.js';
 import { idArg, loadLeafWasm, } from './wasm.js';
 /**
@@ -65,8 +65,8 @@ export class BrowserNode {
      * handle.
      */
     streams = new Set();
-    /** One attempt per peer at a time: see {@link PeerAttempts}. */
-    attempts = new PeerAttempts();
+    /** One attempt per peer at a time, and one offerer per pair: see {@link PeerAttempts}. */
+    attempts = new PeerAttempts(() => this.nodeId);
     /**
      * The live org handles (plan §4.5), so {@link BrowserNode.close}
      * can retire ownership: pending calls fail typed and each dropped
@@ -514,6 +514,13 @@ export class BrowserNode {
      * attempt), offering only after an inconclusive one. See
      * {@link PeerAttempts}.
      *
+     * **And between two nodes, the lower id offers.** When this node's id
+     * is the higher of the pair, an offer the peer sent in the last
+     * `PEER_OFFER_FRESH_MS` (10 s) — or one that crosses this call's own —
+     * is answered instead of offered over, so two pages reaching each
+     * other at once (glare) converge rather than cancel. 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.
@@ -536,7 +543,7 @@ export class BrowserNode {
             catch (error) {
                 throw fromWasmError(error);
             }
-        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
+        }, () => driveConnect(nodeIdHex, this.peerPrimitives(), parseAttemptStatus), () => answerWaitingOffer(nodeIdHex, this.peerPrimitives(), parseAttemptStatus));
     }
     /**
      * The four primitives the shared drive loop calls, bound to this
@@ -828,6 +835,7 @@ export class BrowserNode {
             if (event.rtcAddrs.length > 0)
                 this.anchorRtcAddrs = event.rtcAddrs;
         }
+        noteOffer(this.attempts, event);
         this.hub.dispatch(event);
     }
 }
@@ -880,15 +888,28 @@ export function buildConnectRequest(options) {
  * are `u64` on the Rust side and a JS number would round the large
  * ones. Exported for the session surface, whose `counters_json` is a
  * promise but whose payload is identical.
+ *
+ * A nested group is flattened into dotted keys: the leaf's per-reason
+ * `drops` object becomes `drops.<reason>`, one counter each. Stringified
+ * whole, it read `"[object Object]"` — every drop reason lost behind
+ * the doc comment's promise of "each drop reason".
  */
 export function parseCounters(json) {
     const parsed = JSON.parse(json);
     if (parsed === null || typeof parsed !== 'object')
         return {};
     const out = {};
-    for (const [key, value] of Object.entries(parsed)) {
-        out[key] = typeof value === 'string' ? value : String(value);
-    }
+    const flatten = (group, prefix) => {
+        for (const [key, value] of Object.entries(group)) {
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                flatten(value, `${prefix}${key}.`);
+            }
+            else {
+                out[`${prefix}${key}`] = typeof value === 'string' ? value : String(value);
+            }
+        }
+    };
+    flatten(parsed, '');
     return out;
 }
 /**

package/dist/peer-driver.d.ts

@@ -77,6 +77,16 @@ 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;
+/**
+ * How long an offer that arrived stays worth answering in place of
+ * offering back: the offerer's own ICE deadline (`wasm.rs`'s
+ * `PEER_ICE_DEADLINE_MS`). An older offer's attempt has ended at its
+ * sender, so answering it would only retire this side's own offer for
+ * nothing — and the leaf holds an unanswered offer until something
+ * takes it, so without a bound a stale one would hijack every later
+ * `connectPeer`.
+ */
+export declare const PEER_OFFER_FRESH_MS = 10000;
 /**
  * The pair's live dialog when it is already direct and open, `undefined`
  * (or `null`) otherwise: the healthy-pair reading a surface's
@@ -108,9 +118,44 @@ export type HealthyDialog = () => Promise<string | null | undefined> | string |
  *
  * Settled attempts are forgotten: the next call starts fresh. Another
  * tab's node is outside this gate, as it is outside this surface.
+ *
+ * **Between two nodes, the lower id offers (glare).** The gate above
+ * cannot stop the *peer's* offer cancelling this node's: when both
+ * ends call `connectPeer` at once — two pages reaching each other, or
+ * both re-trying after an attempt ended — each answer retires the
+ * answerer's own offer, both run out their ICE deadline, and the pair
+ * stays relayed. So when this node's id is the higher of the pair:
+ *
+ * - its `connectPeer` answers an offer from the peer that arrived
+ *   within {@link PEER_OFFER_FRESH_MS}, instead of offering back;
+ * - while its own offer is under way, an offer arriving from the peer
+ *   is answered, and the answer's outcome is the call's.
+ *
+ * And on either side, an `acceptPeer` while this surface's own
+ * `connectPeer` for the peer is under way takes that call's outcome:
+ * on the lower id the crossing offer is the one to ignore, and on the
+ * higher id the `connectPeer` already answers it.
+ *
+ * Offers are learned from the surface's `signal` events
+ * ({@link noteOffer}); with none noted, or this node's id unknown,
+ * `connectPeer` offers exactly as before.
  */
 export declare class PeerAttempts {
     #private;
+    private readonly self;
+    private readonly now;
+    /**
+     * @param self This node's id, 16 hex, or `null` while unknown (no
+     *   tie-break then).
+     * @param now The clock offer arrivals are stamped with.
+     */
+    constructor(self?: () => string | null, now?: () => number);
+    /**
+     * A verified offer from `peer` (16 hex) arrived. Arrivals past
+     * {@link PEER_OFFER_FRESH_MS} are dropped here, so the map holds only
+     * peers heard from lately rather than every sender for the node's life.
+     */
+    noteOffer(peer: string): void;
     /**
      * 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.
@@ -120,11 +165,34 @@ export declare class PeerAttempts {
      * 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.
+     *
+     * `answer` answers the offer the peer filed, if one is waiting
+     * (`null` when none is): how the higher id of a pair yields to the
+     * lower id's offer rather than crossing it.
+     */
+    connect(peer: string, healthy: HealthyDialog, drive: () => Promise<PeerConnectOutcome>, answer?: () => Promise<PeerConnectOutcome | null>): Promise<PeerConnectOutcome>;
+    /**
+     * Run `drive` as this peer's answer, unless one is already under way,
+     * or this surface's own `connectPeer` for the peer is (see the class
+     * comment).
      */
-    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>;
 }
+/**
+ * The `kind` a `signal` event carries for an offer: `SignalKind::tag`
+ * in `control_plane.rs`, which the leaf writes as a bare number.
+ */
+export declare const SIGNAL_KIND_OFFER = "1";
+/**
+ * Tell `attempts` about an offer, when `event` is a verified one (a
+ * `signal` event of kind {@link SIGNAL_KIND_OFFER}). Every other event
+ * is ignored, as is a sender id that is not an exact decimal u64.
+ */
+export declare function noteOffer(attempts: PeerAttempts, event: {
+    readonly type: string;
+    readonly kind?: string;
+    readonly from?: string;
+}): void;
 /** 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>;
 /**
@@ -137,6 +205,13 @@ export declare function connectPeer(peer: string, primitives: PeerPrimitives, pa
  * thrown at once, because retrying those would only hide them.
  */
 export declare function acceptPeer(peer: string, primitives: PeerPrimitives, parse: (json: string) => PeerAttemptStatus): Promise<PeerConnectOutcome>;
+/**
+ * Answer the offer `peer` filed if one is waiting now, without waiting
+ * for one: `null` when none is, or when the leaf refuses the answer —
+ * the caller ({@link PeerAttempts.connect}, yielding to the lower id)
+ * then offers as it would have.
+ */
+export declare function answerWaitingOffer(peer: string, primitives: PeerPrimitives, parse: (json: string) => PeerAttemptStatus): Promise<PeerConnectOutcome | null>;
 /**
  * Run the offerer's handshake on an attempt whose channel is open.
  *

package/dist/peer-driver.js

@@ -58,6 +58,16 @@ 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;
+/**
+ * How long an offer that arrived stays worth answering in place of
+ * offering back: the offerer's own ICE deadline (`wasm.rs`'s
+ * `PEER_ICE_DEADLINE_MS`). An older offer's attempt has ended at its
+ * sender, so answering it would only retire this side's own offer for
+ * nothing — and the leaf holds an unanswered offer until something
+ * takes it, so without a bound a stale one would hijack every later
+ * `connectPeer`.
+ */
+export const PEER_OFFER_FRESH_MS = 10_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.
@@ -110,10 +120,57 @@ function answerSettles(outcome) {
  *
  * Settled attempts are forgotten: the next call starts fresh. Another
  * tab's node is outside this gate, as it is outside this surface.
+ *
+ * **Between two nodes, the lower id offers (glare).** The gate above
+ * cannot stop the *peer's* offer cancelling this node's: when both
+ * ends call `connectPeer` at once — two pages reaching each other, or
+ * both re-trying after an attempt ended — each answer retires the
+ * answerer's own offer, both run out their ICE deadline, and the pair
+ * stays relayed. So when this node's id is the higher of the pair:
+ *
+ * - its `connectPeer` answers an offer from the peer that arrived
+ *   within {@link PEER_OFFER_FRESH_MS}, instead of offering back;
+ * - while its own offer is under way, an offer arriving from the peer
+ *   is answered, and the answer's outcome is the call's.
+ *
+ * And on either side, an `acceptPeer` while this surface's own
+ * `connectPeer` for the peer is under way takes that call's outcome:
+ * on the lower id the crossing offer is the one to ignore, and on the
+ * higher id the `connectPeer` already answers it.
+ *
+ * Offers are learned from the surface's `signal` events
+ * ({@link noteOffer}); with none noted, or this node's id unknown,
+ * `connectPeer` offers exactly as before.
  */
 export class PeerAttempts {
+    self;
+    now;
     #connecting = new Map();
     #accepting = new Map();
+    /** When an offer from each peer last arrived, by {@link now}. */
+    #offers = new Map();
+    /**
+     * @param self This node's id, 16 hex, or `null` while unknown (no
+     *   tie-break then).
+     * @param now The clock offer arrivals are stamped with.
+     */
+    constructor(self = () => null, now = () => Date.now()) {
+        this.self = self;
+        this.now = now;
+    }
+    /**
+     * A verified offer from `peer` (16 hex) arrived. Arrivals past
+     * {@link PEER_OFFER_FRESH_MS} are dropped here, so the map holds only
+     * peers heard from lately rather than every sender for the node's life.
+     */
+    noteOffer(peer) {
+        const now = this.now();
+        for (const [key, at] of this.#offers) {
+            if (at <= now - PEER_OFFER_FRESH_MS)
+                this.#offers.delete(key);
+        }
+        this.#offers.set(peer.toLowerCase(), now);
+    }
     /**
      * 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.
@@ -123,8 +180,12 @@ export class PeerAttempts {
      * 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.
+     *
+     * `answer` answers the offer the peer filed, if one is waiting
+     * (`null` when none is): how the higher id of a pair yields to the
+     * lower id's offer rather than crossing it.
      */
-    connect(peer, healthy, drive) {
+    connect(peer, healthy, drive, answer) {
         const key = peer.toLowerCase();
         const joining = this.#connecting.get(key);
         if (joining !== undefined)
@@ -139,18 +200,81 @@ export class PeerAttempts {
             const dialog = await healthy();
             if (dialog !== undefined && dialog !== null)
                 return { type: 'direct', peer, dialog };
-            return drive();
+            if (answer === undefined || !this.#yields(key))
+                return drive();
+            // The lower id already offered: answer it rather than cross it.
+            if (this.#takeOffer(key, this.now() - PEER_OFFER_FRESH_MS)) {
+                const answered = await answer();
+                // Only an answer that settles the pair stands in for the offer.
+                if (answered !== null && answerSettles(answered))
+                    return answered;
+            }
+            return this.#offerYielding(key, drive, answer);
         })();
         return PeerAttempts.#track(this.#connecting, key, started);
     }
-    /** Run `drive` as this peer's answer, unless one is already under way. */
+    /**
+     * Run `drive` as this peer's answer, unless one is already under way,
+     * or this surface's own `connectPeer` for the peer is (see the class
+     * comment).
+     */
     accept(peer, drive) {
         const key = peer.toLowerCase();
         const joining = this.#accepting.get(key);
         if (joining !== undefined)
             return joining;
+        const connecting = this.#connecting.get(key);
+        if (connecting !== undefined && this.self() !== null)
+            return connecting;
         return PeerAttempts.#track(this.#accepting, key, drive());
     }
+    /** Whether this node is the higher id of the pair, and so answers. */
+    #yields(key) {
+        const self = this.self()?.toLowerCase();
+        // 16 hex each, so the strings order as the ids do.
+        return self !== undefined && self.length === key.length && self > key;
+    }
+    /** Consume a noted offer that arrived after `since`, if there is one. */
+    #takeOffer(key, since) {
+        const at = this.#offers.get(key);
+        if (at === undefined || at <= since)
+            return false;
+        this.#offers.delete(key);
+        return true;
+    }
+    /**
+     * Offer, but answer an offer from the peer that crosses it: this
+     * node is the higher id, so the crossing offer is the one the pair
+     * keeps. The offer's own drive then ends `superseded` by the answer,
+     * and is not the call's outcome.
+     *
+     * The answer, once started, is always awaited: answering retires this
+     * node's offer, so the offer's drive can settle `superseded` while the
+     * answer is still running, and racing the two returned that instead of
+     * the answer's result. With no answer started, the call's outcome is
+     * the offer's, within one tick of its settling.
+     */
+    async #offerYielding(key, drive, answer) {
+        const since = this.now();
+        const offering = drive();
+        let settled = false;
+        const done = () => {
+            settled = true;
+        };
+        offering.then(done, done);
+        const crossed = (async () => {
+            while (!settled) {
+                await tick();
+                if (settled || !this.#takeOffer(key, since))
+                    continue;
+                const answered = await answer();
+                if (answered !== null)
+                    return answered;
+            }
+            return null;
+        })();
+        return crossed.then((answered) => answered ?? offering);
+    }
     static #track(map, key, started) {
         map.set(key, started);
         // Forget it once settled, and only if no newer one took its place.
@@ -162,6 +286,26 @@ export class PeerAttempts {
         return started;
     }
 }
+/**
+ * The `kind` a `signal` event carries for an offer: `SignalKind::tag`
+ * in `control_plane.rs`, which the leaf writes as a bare number.
+ */
+export const SIGNAL_KIND_OFFER = '1';
+/**
+ * Tell `attempts` about an offer, when `event` is a verified one (a
+ * `signal` event of kind {@link SIGNAL_KIND_OFFER}). Every other event
+ * is ignored, as is a sender id that is not an exact decimal u64.
+ */
+export function noteOffer(attempts, event) {
+    if (event.type !== 'signal' || event.kind !== SIGNAL_KIND_OFFER)
+        return;
+    if (event.from === undefined || !/^\d{1,20}$/.test(event.from))
+        return;
+    const id = BigInt(event.from);
+    if (id > 0xffffffffffffffffn)
+        return;
+    attempts.noteOffer(id.toString(16).padStart(16, '0'));
+}
 /** Offer, drive to an open channel, then handshake (§9 steps 3-4). */
 export async function connectPeer(peer, primitives, parse) {
     let dialog;
@@ -210,6 +354,22 @@ export async function acceptPeer(peer, primitives, parse) {
     }
     return driveAttempt(peer, dialog, (status) => status.direct, primitives, parse);
 }
+/**
+ * Answer the offer `peer` filed if one is waiting now, without waiting
+ * for one: `null` when none is, or when the leaf refuses the answer —
+ * the caller ({@link PeerAttempts.connect}, yielding to the lower id)
+ * then offers as it would have.
+ */
+export async function answerWaitingOffer(peer, primitives, parse) {
+    let dialog;
+    try {
+        dialog = await primitives.acceptOffer(peer);
+    }
+    catch {
+        return null;
+    }
+    return driveAttempt(peer, dialog, (status) => status.direct, primitives, parse);
+}
 /**
  * Run the offerer's handshake on an attempt whose channel is open.
  *

package/package.json

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