@net-mesh/browser 0.37.0 → 0.38.0

package/dist/index.d.ts

@@ -24,8 +24,8 @@ export { EventHub, fromBase64, parseEvent, parseJsonPreservingU64, toBase64, U64
 export type { AnnouncementEvent, ChannelMessageEvent, ConnectedEvent, DisconnectedEvent, DroppedEvent, LeafEvent, LeafEventOf, RpcResponseEvent, RtcFailureEvent, SignalEvent, StreamDataEvent, UnknownEvent, Unsubscribe, } from './events.js';
 export { ControlPlaneError, IceServerConflictError, IdentityError, isUdpBlocked, LeafError, NotLeaderError, OrgAdmissionDeniedError, OrgCancelledError, OrgIndeterminateError, OrgInternalError, OrgLeaderLostError, OrgMalformedError, OrgRefusedError, OrgRevokedError, OrgSessionLostError, OrgStreamError, OrgTimeoutError, ORG_SINK_CLOSED_REFUSAL, coarseAdmissionReason, orgRetireError, orgRetireReason, orgTerminalError, parseLeafError, parseOrgError, parseRpcFailure, parseRtcFailure, RpcError, RtcError, SessionError, udpBlockedEvidence, UnknownLeafError, WireError, fromWasmError, } from './errors.js';
 export type { CoarseAdmissionReason, LeafErrorKind, OrgErrorKind, OrgRetireReason, RpcErrorFailure, RtcErrorFailure, UdpBlockedEvidence, } from './errors.js';
-export { classifyRtcError, classifyRtcFailure, diagnosticStunUrl, probeBootstrapReachable, probeStunBinding, reflexiveAddress, } from './udp-probe.js';
-export type { BootstrapProbeOptions, IceFailureClassification, RtcFailureObservations, StunProbeOptions, StunProbeOutcome, } from './udp-probe.js';
+export { candidateLineIsReflexive, classifyRtcError, classifyRtcFailure, classifyRtcFailureAll, diagnosticStunUrl, probeBootstrapReachable, probeEventAnswers, probeStunBinding, probeStunBindings, reflexiveAddress, stunProbeAnswered, stunProbeVerdict, } from './udp-probe.js';
+export type { BootstrapProbeOptions, EndpointProbe, IceFailureClassification, ProbeEvent, RtcFailureObservations, StunProbeOptions, StunProbeOutcome, } from './udp-probe.js';
 export { loadLeafWasm } from './wasm.js';
 export type { LeafWasmConnectOptions, LeafWasmModule, LeafWasmNode, LeafWasmProxyStream, LeafWasmStream, LeafWasmStreamLike, LeafWasmStreamOptions, StreamCallbackPayload, StreamReliability, WasmSource, } from './wasm.js';
 export { AsyncQueue } from './async-queue.js';

package/dist/index.js

@@ -23,7 +23,7 @@ export { LeafStream } from './stream.js';
 export { OrgDuplex, OrgHandleRegistry, OrgRequests, OrgServe, OrgSink, OrgStream, OrgUpload, parseOrgCaller, toWasmOrgCallOptions, toWasmOrgServeOptions, } from './org.js';
 export { EventHub, fromBase64, parseEvent, parseJsonPreservingU64, toBase64, U64_EVENT_KEYS, } from './events.js';
 export { ControlPlaneError, IceServerConflictError, IdentityError, isUdpBlocked, LeafError, NotLeaderError, OrgAdmissionDeniedError, OrgCancelledError, OrgIndeterminateError, OrgInternalError, OrgLeaderLostError, OrgMalformedError, OrgRefusedError, OrgRevokedError, OrgSessionLostError, OrgStreamError, OrgTimeoutError, ORG_SINK_CLOSED_REFUSAL, coarseAdmissionReason, orgRetireError, orgRetireReason, orgTerminalError, parseLeafError, parseOrgError, parseRpcFailure, parseRtcFailure, RpcError, RtcError, SessionError, udpBlockedEvidence, UnknownLeafError, WireError, fromWasmError, } from './errors.js';
-export { classifyRtcError, classifyRtcFailure, diagnosticStunUrl, probeBootstrapReachable, probeStunBinding, reflexiveAddress, } from './udp-probe.js';
+export { candidateLineIsReflexive, classifyRtcError, classifyRtcFailure, classifyRtcFailureAll, diagnosticStunUrl, probeBootstrapReachable, probeEventAnswers, probeStunBinding, probeStunBindings, reflexiveAddress, stunProbeAnswered, stunProbeVerdict, } from './udp-probe.js';
 export { loadLeafWasm } from './wasm.js';
 export { AsyncQueue } from './async-queue.js';
 // §8's leader/follower surface: `openSession`, `MeshSession`, the five

package/dist/net_leaf.d.ts

@@ -1453,15 +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_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_2355: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_2356: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2356_112: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2356_113: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2356_114: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2356_115: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_2356_116: (a: number, b: number, c: number) => 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 __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

@@ -2710,11 +2710,15 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).encrypt(getObject(arg1), getObject(arg2), getArrayU8FromWasm0(arg3, arg4));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_errorCode_708483a8c58cdc74: function(arg0) {
+            const ret = getObject(arg0).errorCode;
+            return ret;
+        },
         __wbg_error_3da0c81bd4184d52: function(arg0) {
             const ret = getObject(arg0).error;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
-        __wbg_error_6600aa1ee85a35e4: function(arg0, arg1) {
+        __wbg_error_454d6c106cd708a7: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
         __wbg_error_6a23b57453026a47: function() { return handleError(function (arg0) {
@@ -2910,7 +2914,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6605(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2952,7 +2956,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_6506(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_6605(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -3261,51 +3265,56 @@ function __wbg_get_imports() {
             console.warn(getObject(arg0));
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 33, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2355);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 896, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6504);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 907, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6603);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_112);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_113);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_114);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000007: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCDataChannelEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_115);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000008: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("RTCPeerConnectionIceEvent")], shim_idx: 34, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2356_116);
+            // 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);
+            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);
             return addHeapObject(ret);
         },
-        __wbindgen_generic_0000000000000009: function(arg0) {
+        __wbindgen_generic_000000000000000a: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_generic_000000000000000a: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000b: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
@@ -3324,43 +3333,47 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_2356(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2411(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2411(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_2356_112(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356_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_2356_113(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356_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_2356_114(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356_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_2356_115(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356_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_2356_116(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2356_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_2355(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_2355(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));
     return takeObject(ret);
 }
 
-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_6605(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_6605(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_6504(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_6603(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_6504(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_6603(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,15 +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_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_2355: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_2356: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2356_112: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2356_113: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2356_114: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2356_115: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_2356_116: (a: number, b: number, c: number) => 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 __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

@@ -302,6 +302,12 @@ export declare class BrowserNode {
     private readonly orgHandles;
     /** The last `rtc_addr` an anchor told us about; the probe's subject. */
     private anchorRtcAddr;
+    /**
+     * Every endpoint that anchor published (one per family on a
+     * dual-stack anchor). Empty until a `connected` event names them;
+     * the probe then aims at all of them.
+     */
+    private anchorRtcAddrs;
     /** Set once the leaf reports a session — a bootstrap that demonstrably worked. */
     private bootstrapObserved;
     /** This node's mesh id, hex. */
@@ -719,7 +725,7 @@ export declare class BrowserNode {
      * `ice-timeout` it gathers the two observations the correction
      * requires — the anchor answering over HTTPS, and a STUN binding to
      * the address that anchor published going unanswered — and returns
-     * the classification {@link classifyRtcError} makes of them. With no
+     * the classification {@link classifyRtcFailureAll} makes of them. With no
      * address to probe there is no evidence, and the error comes back
      * unchanged.
      *
@@ -884,6 +890,11 @@ interface RefineContext {
     /** The leaf already demonstrated a working bootstrap this session. */
     readonly bootstrapObserved: boolean;
     readonly anchorRtcAddr: string | null;
+    /**
+     * Every endpoint the anchor published, when known. Absent or empty
+     * falls back to `[anchorRtcAddr]`.
+     */
+    readonly anchorRtcAddrs?: readonly string[];
     readonly failureTyping: FailureTypingOptions;
 }
 /**

package/dist/node.js

@@ -12,7 +12,7 @@ import { fromWasmError, IdentityError, OrgCancelledError, RtcError } from './err
 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 { classifyRtcError, probeBootstrapReachable, probeStunBinding, } from './udp-probe.js';
+import { classifyRtcFailureAll, probeBootstrapReachable, probeStunBindings, } from './udp-probe.js';
 import { idArg, loadLeafWasm, } from './wasm.js';
 /**
  * Convert a decimal `u64` node id — {@link NodeDescriptor.nodeId},
@@ -73,6 +73,12 @@ export class BrowserNode {
     orgHandles = new OrgHandleRegistry();
     /** The last `rtc_addr` an anchor told us about; the probe's subject. */
     anchorRtcAddr;
+    /**
+     * Every endpoint that anchor published (one per family on a
+     * dual-stack anchor). Empty until a `connected` event names them;
+     * the probe then aims at all of them.
+     */
+    anchorRtcAddrs = [];
     /** Set once the leaf reports a session — a bootstrap that demonstrably worked. */
     bootstrapObserved = false;
     /** @internal — use {@link connect}. */
@@ -701,7 +707,7 @@ export class BrowserNode {
      * `ice-timeout` it gathers the two observations the correction
      * requires — the anchor answering over HTTPS, and a STUN binding to
      * the address that anchor published going unanswered — and returns
-     * the classification {@link classifyRtcError} makes of them. With no
+     * the classification {@link classifyRtcFailureAll} makes of them. With no
      * address to probe there is no evidence, and the error comes back
      * unchanged.
      *
@@ -714,6 +720,7 @@ export class BrowserNode {
             bootstrapUrl: this.bootstrapUrl,
             bootstrapObserved: this.bootstrapObserved,
             anchorRtcAddr: this.anchorRtcAddr,
+            anchorRtcAddrs: this.anchorRtcAddrs,
             failureTyping: this.failureTyping,
         });
     }
@@ -801,6 +808,8 @@ export class BrowserNode {
             this.bootstrapObserved = true;
             if (event.rtcAddr !== null)
                 this.anchorRtcAddr = event.rtcAddr;
+            if (event.rtcAddrs.length > 0)
+                this.anchorRtcAddrs = event.rtcAddrs;
         }
         this.hub.dispatch(event);
     }
@@ -973,19 +982,26 @@ export async function refineIceFailure(error, context) {
         return error;
     if (context.failureTyping.probeOnIceTimeout === false)
         return error;
-    const probed = context.anchorRtcAddr;
-    if (probed === null) {
+    const endpoints = context.anchorRtcAddrs !== undefined && context.anchorRtcAddrs.length > 0
+        ? context.anchorRtcAddrs
+        : context.anchorRtcAddr !== null
+            ? [context.anchorRtcAddr]
+            : [];
+    if (endpoints.length === 0) {
         // No subject, no claim. The plan's whole point: an ICE timeout
         // alone is never promoted.
         return error;
     }
-    const stunProbe = await probeStunBinding(probed, context.failureTyping.stun);
-    if (stunProbe.type !== 'unanswered')
+    // Every published endpoint, under one deadline (dual-stack plan,
+    // slice 3): one answered family means UDP works, so the failure
+    // stays an ICE timeout without even asking HTTPS.
+    const probes = await probeStunBindings(endpoints, context.failureTyping.stun);
+    if (probes.some((probe) => probe.stunProbe.type !== 'unanswered'))
         return error;
     const bootstrapOk = context.bootstrapObserved ||
         (context.bootstrapUrl !== null &&
             (await probeBootstrapReachable(context.bootstrapUrl, context.failureTyping.bootstrap)));
-    return classifyRtcError({ bootstrapOk, stunProbe, probed });
+    return new RtcError(classifyRtcFailureAll({ bootstrapOk, probes }));
 }
 /**
  * Parse `query`'s JSON array — `{ node_id, entity_id, capabilities,

package/dist/udp-probe.d.ts

@@ -63,6 +63,52 @@ export type StunProbeOutcome =
     readonly type: 'unsupported';
     readonly detail: string;
 };
+/**
+ * One thing a diagnostic probe connection reported: a candidate's SDP
+ * line, or an `icecandidateerror`'s STUN error code. The shape of the
+ * shared vector file both probes are tested against.
+ */
+export type ProbeEvent = {
+    readonly candidate: string;
+} | {
+    readonly error: number;
+}
+/** The probe connection's ICE state became `failed`. */
+ | {
+    readonly ice: 'failed';
+};
+/**
+ * Is this candidate line server-reflexive? The `typ` token followed by
+ * the `srflx` token, as SDP defines the field, never a substring a
+ * foreign attribute could contain. The Rust probe's rule, the same
+ * tokens.
+ */
+export declare function candidateLineIsReflexive(line: string): boolean;
+/**
+ * **The rule both probes share** (`ANCHOR_DUAL_STACK_PLAN.md`, defect 3):
+ * does this one event prove a STUN response came back? A reflexive
+ * candidate does, and so does a STUN error *response* (code below 700).
+ * Host and relay candidates prove nothing. The Rust (WASM) probe applies
+ * the same rule; `test/fixtures/stun-probe-verdicts.json` holds both to
+ * it.
+ */
+export declare function probeEventAnswers(event: ProbeEvent): boolean;
+/**
+ * The verdict over everything one probe reported: `answered` when any
+ * event answers, `notRun` when the engine failed the connection before
+ * gathering a single candidate (nothing was sent, so silence is not
+ * evidence — measured: Firefox without a media permission on an
+ * IPv6-only network with no IPv4 route), `unanswered` otherwise. The
+ * Rust probe's `probe_verdict`, the same three answers.
+ */
+export declare function stunProbeVerdict(events: readonly ProbeEvent[]): 'answered' | 'unanswered' | 'notRun';
+/** {@link probeEventAnswers} over everything one probe reported. */
+export declare function stunProbeAnswered(events: readonly ProbeEvent[]): boolean;
+/** One endpoint and what probing it established. */
+export interface EndpointProbe {
+    readonly probed: string;
+    readonly stunProbe: StunProbeOutcome;
+}
 /** Everything the classification is allowed to look at. */
 export interface RtcFailureObservations {
     /** Did the HTTPS bootstrap to this anchor succeed? */
@@ -88,6 +134,19 @@ export type IceFailureClassification = {
  * response came back" — stays `iceTimeout`.
  */
 export declare function classifyRtcFailure(observations: RtcFailureObservations): IceFailureClassification;
+/**
+ * The rule over **every** endpoint the anchor published (dual-stack
+ * plan, slice 3). `udpBlocked` only when the bootstrap answered and
+ * every endpoint's probe ran and came back `unanswered`. Everything
+ * else stays `iceTimeout`: one answered family (UDP works there), any
+ * probe `notRun` or `unsupported` (an unrun probe observed nothing),
+ * or no endpoints at all. Even then the claim is the observation, no
+ * UDP response from the advertised endpoints, not a proven cause.
+ */
+export declare function classifyRtcFailureAll(observations: {
+    readonly bootstrapOk: boolean;
+    readonly probes: readonly EndpointProbe[];
+}): IceFailureClassification;
 /** {@link classifyRtcFailure}, as the error a caller will be rejected with. */
 export declare function classifyRtcError(observations: RtcFailureObservations): RtcError;
 /** Injection seam for the probe, so tests never need a real engine. */
@@ -100,6 +159,8 @@ export interface StunProbeOptions {
      */
     readonly peerConnectionFactory?: (config: RTCConfiguration) => RTCPeerConnection;
 }
+/** Anything at or above this `errorCode` means "no response arrived". */
+export declare const STUN_NO_RESPONSE_CODE = 700;
 /**
  * Aim a STUN binding at `rtcAddr` and report what came back.
  *
@@ -110,6 +171,13 @@ export interface StunProbeOptions {
  * media and is always closed.
  */
 export declare function probeStunBinding(rtcAddr: string, options?: StunProbeOptions): Promise<StunProbeOutcome>;
+/**
+ * Probe **every** endpoint at once, under **one** deadline: the probes
+ * run concurrently, so a dual-stack anchor's diagnosis costs what a
+ * single-stack one's does. Each result is {@link probeStunBinding}'s,
+ * in the order given.
+ */
+export declare function probeStunBindings(rtcAddrs: readonly string[], options?: StunProbeOptions): Promise<EndpointProbe[]>;
 /** Injection seam for the bootstrap observation. */
 export interface BootstrapProbeOptions {
     /** How long to wait for the anchor to answer. Default 3000 ms. */

package/dist/udp-probe.js

@@ -31,6 +31,50 @@
  *   no reflexive candidate at all — nothing came back.
  */
 import { RtcError, udpBlockedEvidence } from './errors.js';
+/**
+ * Is this candidate line server-reflexive? The `typ` token followed by
+ * the `srflx` token, as SDP defines the field, never a substring a
+ * foreign attribute could contain. The Rust probe's rule, the same
+ * tokens.
+ */
+export function candidateLineIsReflexive(line) {
+    const tokens = line.trim().split(/\s+/);
+    return tokens.some((token, index) => token === 'typ' && tokens[index + 1] === 'srflx');
+}
+/**
+ * **The rule both probes share** (`ANCHOR_DUAL_STACK_PLAN.md`, defect 3):
+ * does this one event prove a STUN response came back? A reflexive
+ * candidate does, and so does a STUN error *response* (code below 700).
+ * Host and relay candidates prove nothing. The Rust (WASM) probe applies
+ * the same rule; `test/fixtures/stun-probe-verdicts.json` holds both to
+ * it.
+ */
+export function probeEventAnswers(event) {
+    if ('candidate' in event)
+        return candidateLineIsReflexive(event.candidate);
+    if ('error' in event)
+        return event.error < STUN_NO_RESPONSE_CODE;
+    return false;
+}
+/**
+ * The verdict over everything one probe reported: `answered` when any
+ * event answers, `notRun` when the engine failed the connection before
+ * gathering a single candidate (nothing was sent, so silence is not
+ * evidence — measured: Firefox without a media permission on an
+ * IPv6-only network with no IPv4 route), `unanswered` otherwise. The
+ * Rust probe's `probe_verdict`, the same three answers.
+ */
+export function stunProbeVerdict(events) {
+    if (events.some(probeEventAnswers))
+        return 'answered';
+    const gathered = events.some((event) => 'candidate' in event);
+    const failed = events.some((event) => 'ice' in event && event.ice === 'failed');
+    return failed && !gathered ? 'notRun' : 'unanswered';
+}
+/** {@link probeEventAnswers} over everything one probe reported. */
+export function stunProbeAnswered(events) {
+    return stunProbeVerdict(events) === 'answered';
+}
 /**
  * The rule, pure.
  *
@@ -41,9 +85,26 @@ import { RtcError, udpBlockedEvidence } from './errors.js';
  */
 export function classifyRtcFailure(observations) {
     const { bootstrapOk, stunProbe, probed } = observations;
-    if (stunProbe.type !== 'unanswered')
+    if (probed === null)
         return { type: 'iceTimeout' };
-    const evidence = udpBlockedEvidence(bootstrapOk, true, probed ?? '');
+    return classifyRtcFailureAll({ bootstrapOk, probes: [{ probed, stunProbe }] });
+}
+/**
+ * The rule over **every** endpoint the anchor published (dual-stack
+ * plan, slice 3). `udpBlocked` only when the bootstrap answered and
+ * every endpoint's probe ran and came back `unanswered`. Everything
+ * else stays `iceTimeout`: one answered family (UDP works there), any
+ * probe `notRun` or `unsupported` (an unrun probe observed nothing),
+ * or no endpoints at all. Even then the claim is the observation, no
+ * UDP response from the advertised endpoints, not a proven cause.
+ */
+export function classifyRtcFailureAll(observations) {
+    const { bootstrapOk, probes } = observations;
+    if (probes.length === 0 || probes.some((probe) => probe.stunProbe.type !== 'unanswered')) {
+        return { type: 'iceTimeout' };
+    }
+    const probedAll = probes.map((probe) => probe.probed);
+    const evidence = udpBlockedEvidence(bootstrapOk, true, probedAll[0] ?? '', probedAll);
     return evidence === null ? { type: 'iceTimeout' } : { type: 'udpBlocked', evidence };
 }
 /** {@link classifyRtcFailure}, as the error a caller will be rejected with. */
@@ -52,7 +113,7 @@ export function classifyRtcError(observations) {
 }
 const DEFAULT_PROBE_TIMEOUT_MS = 2500;
 /** Anything at or above this `errorCode` means "no response arrived". */
-const STUN_NO_RESPONSE_CODE = 700;
+export const STUN_NO_RESPONSE_CODE = 700;
 const DEFAULT_STUN_PORT = 3478;
 /**
  * Aim a STUN binding at `rtcAddr` and report what came back.
@@ -99,12 +160,25 @@ export async function probeStunBinding(rtcAddr, options = {}) {
             detail: noResponse ?? 'gathering completed with no reflexive candidate',
         });
     };
+    // Did the engine gather anything at all? A connection it fails
+    // before the first candidate is one it could not gather for, and
+    // such a probe did not run (see `stunProbeVerdict`).
+    let gathered = false;
+    pc.oniceconnectionstatechange = () => {
+        if (pc.iceConnectionState === 'failed' && !gathered) {
+            settle({
+                type: 'notRun',
+                reason: 'the engine failed the probe connection before gathering any candidate',
+            });
+        }
+    };
     pc.onicecandidate = (event) => {
         const candidate = event.candidate;
         if (candidate === null) {
             gatheringDone();
             return;
         }
+        gathered = true;
         // Host candidates are gathered regardless of what the network does
         // to UDP — Chromium even hides them behind an mDNS `.local` name —
         // so only a reflexive one is evidence.
@@ -119,7 +193,7 @@ export async function probeStunBinding(rtcAddr, options = {}) {
         // the anchor and the reply got home, so UDP is not blocked. (An
         // anchor's ICE agent refusing an unauthenticated binding lands
         // here; Chromium reports the STUN error number, e.g. `1` for a 401.)
-        if (code < STUN_NO_RESPONSE_CODE) {
+        if (probeEventAnswers({ error: code })) {
             settle({ type: 'stunError', code, detail });
             return;
         }
@@ -144,10 +218,20 @@ export async function probeStunBinding(rtcAddr, options = {}) {
         clearTimeout(timer);
         pc.onicecandidate = null;
         pc.onicecandidateerror = null;
+        pc.oniceconnectionstatechange = null;
         pc.onicegatheringstatechange = null;
         pc.close();
     }
 }
+/**
+ * Probe **every** endpoint at once, under **one** deadline: the probes
+ * run concurrently, so a dual-stack anchor's diagnosis costs what a
+ * single-stack one's does. Each result is {@link probeStunBinding}'s,
+ * in the order given.
+ */
+export async function probeStunBindings(rtcAddrs, options = {}) {
+    return Promise.all(rtcAddrs.map(async (probed) => ({ probed, stunProbe: await probeStunBinding(probed, options) })));
+}
 const DEFAULT_BOOTSTRAP_TIMEOUT_MS = 3000;
 /**
  * Did the anchor answer over HTTPS?
@@ -229,7 +313,7 @@ export function reflexiveAddress(candidate) {
         return candidate.address ?? sdpAddress(candidate.candidate);
     if (candidate.type !== null)
         return null;
-    return / typ srflx /.test(candidate.candidate) ? sdpAddress(candidate.candidate) : null;
+    return candidateLineIsReflexive(candidate.candidate) ? sdpAddress(candidate.candidate) : null;
 }
 function sdpAddress(line) {
     // candidate:<foundation> <component> <transport> <priority> <ip> <port> typ …

package/package.json

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