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

package/dist/browser/index.js

@@ -5057,7 +5057,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.5-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -8739,10 +8739,13 @@ class PeerExchange {
  * to Space membership. The sender (`from`) is server-stamped and can't be
  * spoofed; the payload is opaque to the server.
  *
- * Envelopes carry a `to` (a member id, or `"*"` for discovery) so the
- * accelerator can optionally unicast peer-pair signaling instead of broadcasting
- * (a small, backward-compatible `pub` enhancement); the client filters by `to`
- * regardless.
+ * Peers are identified by a unique **peer id** (per device/connection), carried
+ * in the envelope's `from`/`to` — NOT by the server-stamped member id. This is
+ * essential: one user's own devices share a member id, so the server's `from`
+ * can't tell them apart (and would make each treat the others' signals as its
+ * own echo). We therefore route entirely on the envelope peer ids and broadcast
+ * to the whole Space, filtering client-side. The server `from` still guarantees
+ * the sender is an authenticated Space member.
  */
 const P2P_SUBJECT = "__p2p__";
 class SpaceSignaler {
@@ -8754,11 +8757,11 @@ class SpaceSignaler {
     }
     /** Send a signal to one peer (or `"*"`). */
     send(to, kind, data) {
-        const env = { to, kind, data };
-        // Ask the server to unicast for a directed target; broadcast for "*".
-        // `to` also stays in the envelope so a broadcast-only server still works
-        // (the client filters by it).
-        this.space.sendEphemeral(P2P_SUBJECT, env, to !== "*" ? to : undefined);
+        const env = { from: this.myId, to, kind, data };
+        // Always broadcast to the Space: the server can't unicast to a specific
+        // DEVICE (a user's devices share a member id), so we route client-side on
+        // the envelope peer id. Signaling frames are tiny.
+        this.space.sendEphemeral(P2P_SUBJECT, env);
     }
     /** Announce/withdraw P2P availability to all Space members. */
     broadcast(kind, data) {
@@ -8766,18 +8769,22 @@ class SpaceSignaler {
     }
     /**
      * Subscribe to inbound signals addressed to us (or broadcast). Skips our own
-     * echoes. Returns an unsubscribe function.
+     * echoes. Returns an unsubscribe function. Routing is entirely by the envelope
+     * peer id (`env.from`/`env.to`), so a user's own devices — which share the
+     * server-stamped `e.from` — are correctly distinguished.
      */
     onSignal(cb) {
         return this.space.onEphemeral((e) => {
-            if (e.subject !== P2P_SUBJECT || e.from === this.myId)
+            if (e.subject !== P2P_SUBJECT)
                 return;
             const env = e.data;
-            if (!env || typeof env.kind !== "string")
+            if (!env || typeof env.kind !== "string" || typeof env.from !== "string")
                 return;
+            if (env.from === this.myId)
+                return; // our own device's echo
             if (env.to !== this.myId && env.to !== "*")
                 return;
-            cb(e.from, env.kind, env.data);
+            cb(env.from, env.kind, env.data);
         });
     }
 }
@@ -8812,14 +8819,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);
     }
@@ -8870,19 +8883,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");
@@ -8904,22 +8940,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") {
@@ -9388,6 +9434,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).
@@ -9514,6 +9561,10 @@ class SpaceNamespace {
     spaceCache;
     /** Spaces built this session, by id — used to route offline send replays. */
     openSpaces = new Map();
+    /** Unique id for THIS device/session — the P2P peer identity. A user's own
+     *  devices share a member id, so the mesh MUST distinguish them by this or a
+     *  device treats its siblings' signals as its own echo and never connects. */
+    deviceId = `peer-${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2)}`;
     constructor(deps) {
         this.deps = deps;
         if (deps.offline?.enabled) {
@@ -9712,7 +9763,7 @@ class SpaceNamespace {
         if (this.deps.p2p?.enabled && isP2pCapable()) {
             space.attachPeerNetwork(new PeerNetwork({
                 space,
-                myId: memberId,
+                myId: this.deviceId, // per-device peer id, NOT the shared member id
                 workerFactory: this.deps.p2p.workerFactory,
                 iceServers: this.deps.p2p.iceServers,
                 maxPeers: this.deps.p2p.maxPeers,