@net-mesh/browser 0.40.0 → 0.41.1

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/leader/index.d.ts

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

package/dist/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.d.ts

@@ -1453,8 +1453,8 @@ export interface InitOutput {
     readonly proxystream_send: (a: number, b: number) => number;
     readonly proxystream_stream_id_hex: (a: number, b: number) => void;
     readonly start: () => void;
-    readonly __wasm_bindgen_func_elem_6509: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_6511: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_6504: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_6506: (a: number, b: number, c: number, d: number) => void;
     readonly __wasm_bindgen_func_elem_2365: (a: number, b: number, c: number) => number;
     readonly __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => void;
     readonly __wasm_bindgen_func_elem_2366_112: (a: number, b: number, c: number) => void;

package/dist/net_leaf.js

@@ -2718,13 +2718,13 @@ function __wbg_get_imports() {
             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);
         }, arguments); },
-        __wbg_error_c7a46bea9bd49ca0: 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_6511(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2956,7 +2956,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6511(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3275,8 +3275,8 @@ function __wbg_get_imports() {
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 868, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6509);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 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);
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
@@ -3366,14 +3366,14 @@ function __wasm_bindgen_func_elem_2365(arg0, arg1, arg2) {
     return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_6511(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_6511(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_6506(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_6506(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_6509(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_6504(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6509(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_6504(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {

package/dist/net_leaf_bg.wasm.d.ts

@@ -119,8 +119,8 @@ export const proxystream_peer_node_hex: (a: number, b: number) => void;
 export const proxystream_send: (a: number, b: number) => number;
 export const proxystream_stream_id_hex: (a: number, b: number) => void;
 export const start: () => void;
-export const __wasm_bindgen_func_elem_6509: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_6511: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_6504: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_6506: (a: number, b: number, c: number, d: number) => void;
 export const __wasm_bindgen_func_elem_2365: (a: number, b: number, c: number) => number;
 export const __wasm_bindgen_func_elem_2366: (a: number, b: number, c: number) => void;
 export const __wasm_bindgen_func_elem_2366_112: (a: number, b: number, c: number) => void;

package/dist/netcode/index.d.ts

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

package/dist/netcode/index.js

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

package/dist/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.
  *