@muhkoo/connect 0.10.3-alpha.0 → 0.10.4-alpha.0

package/dist/connect.d.ts

@@ -5591,6 +5591,8 @@ interface WebRtcTransportOptions {
     iceServers?: RTCIceServer[];
     /** Cap on simultaneous peer connections (mesh size). Default 8. */
     maxPeers?: number;
+    /** Log ICE/connection state transitions for diagnosing peer connectivity. */
+    debug?: boolean;
 }
 declare class WebRtcTransport implements PeerTransport {
     private readonly signaler;
@@ -5601,8 +5603,10 @@ declare class WebRtcTransport implements PeerTransport {
     private readonly offSignal;
     private readonly iceServers;
     private readonly maxPeers;
+    private readonly debug;
     private nextMsgId;
     constructor(signaler: SpaceSignaler, myId: PeerId, opts?: WebRtcTransportOptions);
+    private log;
     peers(): PeerId[];
     /** Dial a peer (no-op unless we're the deterministic initiator for the pair). */
     connectTo(peerId: PeerId): void;
@@ -5612,6 +5616,9 @@ declare class WebRtcTransport implements PeerTransport {
     onPeerChange(cb: (peers: PeerId[]) => void): () => void;
     close(): void;
     private newPc;
+    /** Mark a peer's remote description as set and apply any ICE candidates that
+     *  arrived before it (dropping them, the old behavior, breaks LAN dials). */
+    private markRemoteSet;
     private initiate;
     private bindChannel;
     private onSignal;

package/dist/server/index.js

@@ -2976,7 +2976,7 @@ function base64UrlDecode(s) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.10.3-alpha.0";
+const VERSION = "0.10.4-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -8543,14 +8543,20 @@ class WebRtcTransport {
     offSignal;
     iceServers;
     maxPeers;
+    debug;
     nextMsgId = 1;
     constructor(signaler, myId, opts = {}) {
         this.signaler = signaler;
         this.myId = myId;
         this.iceServers = opts.iceServers ?? DEFAULT_ICE;
         this.maxPeers = opts.maxPeers ?? 8;
+        this.debug = opts.debug ?? false;
         this.offSignal = this.signaler.onSignal((from, kind, data) => this.onSignal(from, kind, data));
     }
+    log(...a) {
+        if (this.debug)
+            console.info("[muhkoo:p2p]", ...a);
+    }
     peers() {
         return [...this.conns].filter(([, c]) => c.dc?.readyState === "open").map(([id]) => id);
     }
@@ -8601,19 +8607,42 @@ class WebRtcTransport {
     // -- internals -----------------------------------------------------------
     newPc(peerId) {
         const pc = new RTCPeerConnection({ iceServers: this.iceServers });
-        const conn = { pc, reasm: new Map() };
+        const conn = { pc, reasm: new Map(), remoteSet: false, pendingIce: [] };
         this.conns.set(peerId, conn);
+        const short = String(peerId).slice(0, 8);
         pc.onicecandidate = (e) => {
-            if (e.candidate)
+            if (e.candidate) {
+                this.log(`${short} local candidate ${e.candidate.type ?? "?"} ${(e.candidate.address ?? e.candidate.candidate).toString().slice(0, 40)}`);
                 this.signaler.send(peerId, "ice", e.candidate.toJSON());
+            }
         };
         pc.onconnectionstatechange = () => {
+            this.log(`${short} connection=${pc.connectionState}`);
             if (["failed", "closed", "disconnected"].includes(pc.connectionState))
                 this.drop(peerId);
         };
+        if (this.debug) {
+            pc.oniceconnectionstatechange = () => this.log(`${short} ice=${pc.iceConnectionState}`);
+            pc.onicegatheringstatechange = () => this.log(`${short} gathering=${pc.iceGatheringState}`);
+        }
         pc.ondatachannel = (e) => this.bindChannel(peerId, conn, e.channel);
         return conn;
     }
+    /** Mark a peer's remote description as set and apply any ICE candidates that
+     *  arrived before it (dropping them, the old behavior, breaks LAN dials). */
+    async markRemoteSet(conn) {
+        conn.remoteSet = true;
+        const pending = conn.pendingIce;
+        conn.pendingIce = [];
+        for (const cand of pending) {
+            try {
+                await conn.pc.addIceCandidate(cand);
+            }
+            catch { /* stale/duplicate */ }
+        }
+        if (pending.length)
+            this.log(`flushed ${pending.length} queued ICE candidate(s)`);
+    }
     async initiate(peerId) {
         const conn = this.newPc(peerId);
         const dc = conn.pc.createDataChannel("blocks");
@@ -8635,22 +8664,32 @@ class WebRtcTransport {
                 return; // mesh cap
             const conn = this.conns.get(from) ?? this.newPc(from);
             await conn.pc.setRemoteDescription(data);
+            await this.markRemoteSet(conn);
             const answer = await conn.pc.createAnswer();
             await conn.pc.setLocalDescription(answer);
             this.signaler.send(from, "answer", answer);
         }
         else if (kind === "answer") {
             const conn = this.conns.get(from);
-            if (conn)
+            if (conn) {
                 await conn.pc.setRemoteDescription(data);
+                await this.markRemoteSet(conn);
+            }
         }
         else if (kind === "ice") {
             const conn = this.conns.get(from);
             if (conn && data) {
+                // Queue candidates that arrive before setRemoteDescription — adding
+                // them early throws and (previously) dropped them, which killed the
+                // connection on fast LANs where ICE beats the SDP answer.
+                if (!conn.remoteSet) {
+                    conn.pendingIce.push(data);
+                    return;
+                }
                 try {
                     await conn.pc.addIceCandidate(data);
                 }
-                catch { /* pre-SRD race */ }
+                catch { /* stale */ }
             }
         }
         else if (kind === "bye") {
@@ -9119,6 +9158,7 @@ class PeerNetwork {
                 new WebRtcTransport(this.signaler, opts.myId, {
                     iceServers: opts.iceServers,
                     maxPeers: opts.maxPeers,
+                    debug: opts.debug,
                 });
         this.host = buildEngineHost(opts);
         // Wire transport ⇄ engine, demuxing block (engine) from gossip (app).