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

package/dist/connect.d.ts

@@ -4379,6 +4379,10 @@ declare class SpaceNamespace {
     private spaceCache?;
     /** Spaces built this session, by id — used to route offline send replays. */
     private readonly openSpaces;
+    /** 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. */
+    private readonly deviceId;
     constructor(deps: SpaceNamespaceDeps);
     /**
      * Create a new space: generate its keypair (public key = id), register
@@ -5392,15 +5396,20 @@ declare class PeerExchange implements PeerBlockSource {
  * 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.
  */
 declare const P2P_SUBJECT = "__p2p__";
 type SignalKind = "hello" | "bye" | "offer" | "answer" | "ice";
 interface SignalEnvelope {
-    /** Target member id, or `"*"` to broadcast (discovery / departure). */
+    /** Sender's unique PEER id (per device/connection). */
+    from: string;
+    /** Target peer id, or `"*"` to broadcast (discovery / departure). */
     to: string;
     kind: SignalKind;
     data?: unknown;
@@ -5424,7 +5433,9 @@ declare class SpaceSignaler {
     broadcast(kind: SignalKind, data?: unknown): void;
     /**
      * 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: (from: string, kind: SignalKind, data: unknown) => void): () => void;
 }

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.4-alpha.0";
+const VERSION = "0.10.5-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -8470,10 +8470,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 {
@@ -8485,11 +8488,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) {
@@ -8497,18 +8500,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);
         });
     }
 }
@@ -9285,6 +9292,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) {
@@ -9483,7 +9494,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,