@dxos/messaging 0.9.1-staging.ee54ba693a → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/messaging",
-  "version": "0.9.1-staging.ee54ba693a",
+  "version": "0.11.0",
   "description": "Messaging",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,12 +16,12 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "default": "./dist/lib/neutral/index.mjs"
+      "import": "./dist/lib/index.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "default": "./dist/lib/neutral/testing/index.mjs"
+      "import": "./dist/lib/testing.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -31,26 +31,26 @@
     "README.md"
   ],
   "dependencies": {
+    "effect": "3.21.4",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.17.1",
-    "@dxos/async": "0.9.1-staging.ee54ba693a",
-    "@dxos/codec-protobuf": "0.9.1-staging.ee54ba693a",
-    "@dxos/edge-client": "0.9.1-staging.ee54ba693a",
-    "@dxos/invariant": "0.9.1-staging.ee54ba693a",
-    "@dxos/keys": "0.9.1-staging.ee54ba693a",
-    "@dxos/credentials": "0.9.1-staging.ee54ba693a",
-    "@dxos/context": "0.9.1-staging.ee54ba693a",
-    "@dxos/log": "0.9.1-staging.ee54ba693a",
-    "@dxos/node-std": "0.9.1-staging.ee54ba693a",
-    "@dxos/protocols": "0.9.1-staging.ee54ba693a",
-    "@dxos/rpc": "0.9.1-staging.ee54ba693a",
-    "@dxos/util": "0.9.1-staging.ee54ba693a",
-    "@dxos/tracing": "0.9.1-staging.ee54ba693a"
+    "@dxos/async": "0.11.0",
+    "@dxos/codec-protobuf": "0.11.0",
+    "@dxos/context": "0.11.0",
+    "@dxos/credentials": "0.11.0",
+    "@dxos/edge-client": "0.11.0",
+    "@dxos/invariant": "0.11.0",
+    "@dxos/keys": "0.11.0",
+    "@dxos/log": "0.11.0",
+    "@dxos/node-std": "0.11.0",
+    "@dxos/protocols": "0.11.0",
+    "@dxos/rpc": "0.11.0",
+    "@dxos/tracing": "0.11.0",
+    "@dxos/util": "0.11.0"
   },
   "devDependencies": {
-    "@dxos/signal": "0.9.1-staging.ee54ba693a",
-    "@dxos/keyring": "0.9.1-staging.ee54ba693a",
-    "@dxos/test-utils": "0.9.1-staging.ee54ba693a"
+    "@dxos/keyring": "0.11.0",
+    "@dxos/test-utils": "0.11.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -3,6 +3,5 @@
 //
 
 export * from './messenger';
-export * from './signal-client';
 export * from './signal-manager';
 export * from './signal-methods';

package/src/messenger.blueprint-test.ts

@@ -6,9 +6,7 @@ import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { asyncTimeout, latch, sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { range } from '@dxos/util';
 
-import { WebsocketSignalManager } from './signal-manager';
 import { type Message } from './signal-methods';
 import { PAYLOAD_1, PAYLOAD_2, PAYLOAD_3, TestBuilder, messageEqual } from './testing';
 
@@ -313,27 +311,4 @@ export const messengerTests = (signalManagerFactory: TestBuilder['createSignalMa
       expect(count).toEqual(1);
     });
   });
-
-  describe.skip('load', () => {
-    test('many connections to KUBE', { timeout: 5_000 }, async () => {
-      const builder = new TestBuilder({
-        signalManagerFactory: async () =>
-          new WebsocketSignalManager([{ server: 'wss://dev.kube.dxos.org/.well-known/dx/signal' }]),
-      });
-      void range(100).map(async () => {
-        const peer = await builder.createPeer();
-
-        void peer.messenger.sendMessage(Context.default(), {
-          author: peer.peerInfo,
-          recipient: peer.peerInfo,
-          payload: {
-            type_url: 'dxos.test',
-            value: Buffer.from('TEST'),
-          },
-        });
-      });
-
-      await sleep(1000000);
-    });
-  });
 };

package/src/messenger.node.test.ts

@@ -8,7 +8,7 @@ import { messengerTests } from './messenger.blueprint-test';
 import { MemorySignalManager, MemorySignalManagerContext } from './signal-manager';
 
 // TODO(mykola): Use EDGE signal server.
-describe('Messenger with WebsocketSignalManager', () => {
+describe('Messenger with MemorySignalManager', () => {
   let context: MemorySignalManagerContext;
   beforeEach(async () => {
     context = new MemorySignalManagerContext();

package/src/messenger.ts

@@ -72,12 +72,6 @@ export class Messenger {
     this._ctx = new Context({
       onError: (err) => log.catch(err),
     });
-    this._ctx.onDispose(
-      this._signalManager.onMessage.on(async (message) => {
-        log('received message', { from: message.author });
-        await this._handleMessage(message);
-      }),
-    );
 
     // Clear the map periodically.
     scheduleTaskInterval(
@@ -97,11 +91,18 @@ export class Messenger {
       return;
     }
     this._closed = true;
+    // Disposing the context tears down every still-active subscription — each `listen` registers its
+    // transport unsubscribe via `onDispose`, and a handle unsubscribed manually has already cleared
+    // its registration. The offline/online cycle keeps the messenger open (only signaling toggles),
+    // so subscriptions are torn down only on a real close.
     await this._ctx.dispose();
   }
 
-  async sendMessage(ctx: Context, { author, recipient, payload }: Message): Promise<void> {
+  async sendMessage(ctx: Context, message: Message): Promise<void> {
     invariant(!this._closed, 'Closed');
+    const { author, recipient, payload } = message;
+    // Messenger provides reliable point-to-point delivery; broadcasts are not routed here.
+    invariant(recipient, 'Recipient is required');
     const messageContext = this._ctx.derive();
 
     const reliablePayload: ReliablePayload = {
@@ -175,22 +176,39 @@ export class Messenger {
     onMessage: OnMessage;
   }): Promise<ListeningHandle> {
     invariant(!this._closed, 'Closed');
-
-    await this._signalManager.subscribeMessages(peer);
-    let listeners: Set<OnMessage> | undefined;
     invariant(peer.peerKey, 'Peer key is required');
+    const peerKey = peer.peerKey;
+
+    // Multiplexing is owned by the signal manager. The messenger keeps only reliable delivery
+    // (ACK/dedup) and payloadType routing, and passes the transport unsubscribe back through the
+    // handle. The unsubscribe is also registered on the messenger context so `close` tears every
+    // subscription down; a handle unsubscribed manually clears that registration first.
+    const unsubscribe = await this._signalManager.subscribeMessages({
+      peer,
+      onMessage: (message) => {
+        // Subscriptions can outlive a close (they are torn down on dispose, and survive offline/online
+        // cycles), so ignore late deliveries and never let a handler rejection escape as unhandled.
+        if (this._closed) {
+          return;
+        }
+        log('received message', { from: message.author });
+        void this._handleMessage(message).catch((err) => log.catch(err));
+      },
+    });
+    const clearDispose = this._ctx.onDispose(unsubscribe);
 
+    let listeners: Set<OnMessage> | undefined;
     if (!payloadType) {
-      listeners = this._defaultListeners.get(peer.peerKey);
+      listeners = this._defaultListeners.get(peerKey);
       if (!listeners) {
         listeners = new Set();
-        this._defaultListeners.set(peer.peerKey, listeners);
+        this._defaultListeners.set(peerKey, listeners);
       }
     } else {
-      listeners = this._listeners.get({ peerId: peer.peerKey, payloadType });
+      listeners = this._listeners.get({ peerId: peerKey, payloadType });
       if (!listeners) {
         listeners = new Set();
-        this._listeners.set({ peerId: peer.peerKey, payloadType }, listeners);
+        this._listeners.set({ peerId: peerKey, payloadType }, listeners);
       }
     }
 
@@ -198,7 +216,9 @@ export class Messenger {
 
     return {
       unsubscribe: async () => {
+        clearDispose();
         listeners!.delete(onMessage);
+        await unsubscribe();
       },
     };
   }
@@ -238,8 +258,10 @@ export class Messenger {
     }
   }
 
-  private async _handleReliablePayload({ author, recipient, payload }: Message): Promise<void> {
+  private async _handleReliablePayload(message: Message): Promise<void> {
+    const { author, recipient, payload } = message;
     invariant(payload.type_url === 'dxos.mesh.messaging.ReliablePayload');
+    invariant(recipient, 'Recipient is required');
     const reliablePayload: ReliablePayload = ReliablePayload.decode(payload.value, { preserveAny: true });
 
     log('handling message', { messageId: reliablePayload.messageId });
@@ -299,9 +321,11 @@ export class Messenger {
   }
 
   private async _callListeners(message: Message): Promise<void> {
+    const { recipient } = message;
+    invariant(recipient?.peerKey, 'Peer key is required');
+    const peerKey = recipient.peerKey;
     {
-      invariant(message.recipient.peerKey, 'Peer key is required');
-      const defaultListenerMap = this._defaultListeners.get(message.recipient.peerKey);
+      const defaultListenerMap = this._defaultListeners.get(peerKey);
       if (defaultListenerMap) {
         for (const listener of defaultListenerMap) {
           await listener(message);
@@ -311,7 +335,7 @@ export class Messenger {
 
     {
       const listenerMap = this._listeners.get({
-        peerId: message.recipient.peerKey,
+        peerId: peerKey,
         payloadType: message.payload.type_url,
       });
       if (listenerMap) {

package/src/signal-manager/edge-signal-manager.test.ts

@@ -0,0 +1,193 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Context } from '@dxos/context';
+import { PublicKey } from '@dxos/keys';
+
+import { type Message, type PeerInfo } from '../signal-methods';
+import { TestEdgeMesh } from '../testing';
+import { EdgeSignalManager } from './edge-signal-manager';
+
+// DX-1125: exercise the broadcast pub/sub paths of EdgeSignalManager against an in-memory edge.
+
+const TRACE_TAG = 'type:status.update';
+
+const payload = (value: number[]) => ({ type_url: 'dxos.compute.TraceMessage', value: new Uint8Array(value) });
+
+/**
+ * A capture sink for a single subscription. Delivered messages are classified by shape: a broadcast
+ * carries `tags` and no `recipient`; a point-to-point message carries a `recipient` (DX-1125).
+ */
+const capture = () => {
+  const messages: Message[] = [];
+  const broadcasts: Message[] = [];
+  const onMessage = (message: Message) => {
+    if (message.recipient != null) {
+      messages.push(message);
+    } else {
+      broadcasts.push(message);
+    }
+  };
+  return { messages, broadcasts, onMessage };
+};
+
+/**
+ * Wire an EdgeSignalManager to a mesh connection and join `topic`. Returns the manager and its peer
+ * info; subscriptions (with their capture sinks) are created per-test.
+ */
+const setupPeer = async (mesh: TestEdgeMesh, topic: PublicKey, name: string) => {
+  const peer: PeerInfo = { peerKey: PublicKey.random().toHex(), identityDid: `did:test:${name}` };
+  const connection = mesh.createConnection({ peerKey: peer.peerKey!, identityDid: peer.identityDid! });
+  const manager = new EdgeSignalManager({ edgeConnection: connection as any });
+  await manager.open();
+  await manager.join(Context.default(), { topic, peer });
+  return { manager, peer };
+};
+
+// A broadcast addresses its target swarm via `author.swarmKey` (DX-1125).
+const broadcast = (peer: PeerInfo, topic: PublicKey, tags: string[], value: number[]) => ({
+  author: { ...peer, swarmKey: topic.toHex() },
+  tags,
+  payload: payload(value),
+});
+
+describe('EdgeSignalManager broadcast (DX-1125)', () => {
+  test('delivers a tag broadcast to a subscriber whose tags intersect', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+    const subscriber = await setupPeer(mesh, topic, 'subscriber');
+
+    const sink = capture();
+    await subscriber.manager.subscribeMessages({ peer: subscriber.peer, tags: [TRACE_TAG], onMessage: sink.onMessage });
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [1, 2, 3]));
+
+    expect(sink.broadcasts).toHaveLength(1);
+    expect(sink.broadcasts[0].tags).toContain(TRACE_TAG);
+    expect(sink.broadcasts[0].author.peerKey).toBe(publisher.peer.peerKey);
+    expect([...sink.broadcasts[0].payload.value]).toEqual([1, 2, 3]);
+    // Broadcasts are not point-to-point messages.
+    expect(sink.messages).toHaveLength(0);
+  });
+
+  test('does not deliver broadcasts whose tags do not intersect the subscription', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+    const subscriber = await setupPeer(mesh, topic, 'subscriber');
+
+    const sink = capture();
+    await subscriber.manager.subscribeMessages({
+      peer: subscriber.peer,
+      tags: ['type:operation.input'],
+      onMessage: sink.onMessage,
+    });
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [9]));
+
+    expect(sink.broadcasts).toHaveLength(0);
+  });
+
+  test('excludes the author from its own broadcast', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+
+    // The publisher is also a subscriber for the same tag.
+    const sink = capture();
+    await publisher.manager.subscribeMessages({ peer: publisher.peer, tags: [TRACE_TAG], onMessage: sink.onMessage });
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [1]));
+
+    expect(sink.broadcasts).toHaveLength(0);
+  });
+
+  test('re-establishes the subscription across reconnect', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+    const subscriber = await setupPeer(mesh, topic, 'subscriber');
+
+    const sink = capture();
+    await subscriber.manager.subscribeMessages({ peer: subscriber.peer, tags: [TRACE_TAG], onMessage: sink.onMessage });
+    // Simulate a reconnect: the manager re-joins swarms and re-sends its subscription.
+    await (subscriber.manager as any)._rejoinAllSwarms();
+
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [7]));
+
+    expect(sink.broadcasts).toHaveLength(1);
+  });
+
+  test('one consumer unsubscribing does not clobber another consumer of the same tag', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+    const subscriber = await setupPeer(mesh, topic, 'subscriber');
+
+    // Two consumers on the same client share the manager's tag subscription (e.g. trace-progress and
+    // a story module both watching status updates). The bug (DX-1125): one consumer's teardown
+    // wholesale-cleared the shared tag set, so the other went silent. The refcounted per-subscription
+    // teardown releases only the tags that subscription added.
+    const first = capture();
+    const second = capture();
+    await subscriber.manager.subscribeMessages({
+      peer: subscriber.peer,
+      tags: [TRACE_TAG],
+      onMessage: first.onMessage,
+    });
+    const unsubscribeSecond = await subscriber.manager.subscribeMessages({
+      peer: subscriber.peer,
+      tags: [TRACE_TAG, 'space:test-space'],
+      onMessage: second.onMessage,
+    });
+    await unsubscribeSecond();
+
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [5]));
+
+    // The first consumer's registration of TRACE_TAG survives; the released space tag does not.
+    expect(first.broadcasts).toHaveLength(1);
+    expect([...first.broadcasts[0].payload.value]).toEqual([5]);
+
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, ['space:test-space'], [6]));
+    expect(first.broadcasts).toHaveLength(1);
+  });
+
+  test('releasing the last registration of a tag stops delivery', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const publisher = await setupPeer(mesh, topic, 'publisher');
+    const subscriber = await setupPeer(mesh, topic, 'subscriber');
+
+    const sink = capture();
+    const unsubscribe = await subscriber.manager.subscribeMessages({
+      peer: subscriber.peer,
+      tags: [TRACE_TAG],
+      onMessage: sink.onMessage,
+    });
+    await unsubscribe();
+
+    await publisher.manager.sendMessage(Context.default(), broadcast(publisher.peer, topic, [TRACE_TAG], [8]));
+
+    expect(sink.broadcasts).toHaveLength(0);
+  });
+
+  test('still delivers point-to-point messages', async ({ expect }) => {
+    const mesh = new TestEdgeMesh();
+    const topic = PublicKey.random();
+    const sender = await setupPeer(mesh, topic, 'sender');
+    const recipient = await setupPeer(mesh, topic, 'recipient');
+
+    const sink = capture();
+    await recipient.manager.subscribeMessages({ peer: recipient.peer, onMessage: sink.onMessage });
+    await sender.manager.sendMessage(Context.default(), {
+      author: sender.peer,
+      recipient: recipient.peer,
+      payload: payload([4, 2]),
+    });
+
+    expect(sink.messages).toHaveLength(1);
+    expect(sink.messages[0].author.peerKey).toBe(sender.peer.peerKey);
+    expect(sink.broadcasts).toHaveLength(0);
+  });
+});

package/src/signal-manager/edge-signal-manager.ts

@@ -24,16 +24,38 @@ import {
 import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
-import { type Message, type PeerInfo, PeerInfoHash, type SwarmEvent } from '../signal-methods';
+import {
+  type Message,
+  type PeerInfo,
+  PeerInfoHash,
+  type SubscribeMessagesParams,
+  type SwarmEvent,
+  type UnsubscribeCallback,
+} from '../signal-methods';
 import { type SignalManager } from './signal-manager';
 
+/**
+ * A single message subscription registered on an {@link EdgeSignalManager} (DX-1125). Point-to-point
+ * delivery matches `peerKey`; broadcast delivery matches any intersection with `tags`.
+ */
+type MessageSubscription = {
+  peerKey: string;
+  tags: Set<string>;
+  onMessage: (message: Message) => void;
+};
+
 export class EdgeSignalManager extends Resource implements SignalManager {
   /**
    * @deprecated
    */
   public swarmEvent = new Event<SwarmEvent>();
   public swarmState = new Event<SwarmResponse>();
-  public onMessage = new Event<Message>();
+
+  /**
+   * Active message subscriptions. Routing is encapsulated here (DX-1125): each incoming message is
+   * dispatched to every subscription it matches, and each subscription owns its own teardown.
+   */
+  private readonly _subscriptions = new Set<MessageSubscription>();
 
   /**
    * Swarm key -> { peer: <own state payload>, joinedPeers: <state of swarm> }.
@@ -44,6 +66,15 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     { lastState?: Uint8Array; joinedPeers: ComplexSet<PeerInfo> }
   >(PublicKey.hash);
 
+  /**
+   * OR-subscription tag refcounts for broadcast messages (DX-1125). One count per distinct tag across
+   * all subscribers, so one consumer's unsubscribe releases only its own registration rather than
+   * clobbering another consumer's identical subscription. The effective tag set (the keys) is shared
+   * across all joined swarms; the edge fans out any broadcast whose tags intersect it. Re-sent on
+   * reconnect and whenever a swarm is (re-)joined.
+   */
+  private readonly _subscribedTags = new Map<string, number>();
+
   private readonly _edgeConnection: EdgeConnection;
 
   constructor({ edgeConnection }: { edgeConnection: EdgeConnection }) {
@@ -89,6 +120,11 @@ export class EdgeSignalManager extends Resource implements SignalManager {
         payload: { action: SwarmRequestAction.JOIN, swarmKeys: [topic.toHex()] },
       }),
     );
+
+    // Re-establish any broadcast subscription on the newly-joined swarm (DX-1125).
+    if (this._subscribedTags.size > 0) {
+      await this._sendSubscription(ctx);
+    }
   }
 
   async leave(ctx: Context, { topic, peer }: { topic: PublicKey; peer: PeerInfo }): Promise<void> {
@@ -134,10 +170,16 @@ export class EdgeSignalManager extends Resource implements SignalManager {
   }
 
   async sendMessage(ctx: Context, message: Message): Promise<void> {
-    if (!this._matchSelfPeerInfo(message.author)) {
+    const { author, recipient, tags, payload } = message;
+    // Exactly one of point-to-point (`recipient`) or broadcast (`tags`) delivery (DX-1125). A broadcast
+    // carries its target swarm in `author.swarmKey` and is published with no `target`; the edge fans it
+    // out to every peer whose subscription tags intersect.
+    invariant((recipient == null) !== !tags?.length, 'Exactly one of `recipient` or `tags` must be set');
+
+    if (!this._matchSelfPeerInfo(author)) {
       // NOTE: Could only join swarm with the same peer info as the edge connection.
       log.warn('ignoring author on send request', {
-        author: message.author,
+        author,
         expected: { peerKey: this._edgeConnection.peerKey, identityDid: this._edgeConnection.identityDid },
       });
     }
@@ -146,19 +188,79 @@ export class EdgeSignalManager extends Resource implements SignalManager {
       ctx,
       protocol.createMessage(bufWkt.AnySchema, {
         serviceId: EdgeService.SIGNAL,
-        source: message.author,
-        target: [message.recipient],
-        payload: { typeUrl: message.payload.type_url, value: message.payload.value },
+        source: author,
+        target: recipient != null ? [recipient] : undefined,
+        tags,
+        payload: { typeUrl: payload.type_url, value: payload.value },
       }),
     );
   }
 
-  async subscribeMessages(peerInfo: PeerInfo): Promise<void> {
-    // No-op.
+  async subscribeMessages({ peer, tags = [], onMessage }: SubscribeMessagesParams): Promise<UnsubscribeCallback> {
+    const subscription: MessageSubscription = { peerKey: peer.peerKey, tags: new Set(tags), onMessage };
+    this._subscriptions.add(subscription);
+
+    // Point-to-point delivery needs no edge registration (the edge relays targeted messages to this
+    // peer's socket). Only tag broadcasts require an OR-subscription registered on the swarm (DX-1125),
+    // refcounted so one subscriber's teardown does not clobber another's identical tags.
+    let changed = false;
+    for (const tag of subscription.tags) {
+      const count = this._subscribedTags.get(tag) ?? 0;
+      this._subscribedTags.set(tag, count + 1);
+      if (count === 0) {
+        changed = true;
+      }
+    }
+    if (changed) {
+      await this._sendSubscription(this._ctx);
+    }
+
+    return async () => {
+      this._subscriptions.delete(subscription);
+      // Release only this subscription's tag registrations; a tag stays live while another holds it.
+      let released = false;
+      for (const tag of subscription.tags) {
+        const count = this._subscribedTags.get(tag);
+        if (count === undefined) {
+          continue;
+        }
+        if (count > 1) {
+          this._subscribedTags.set(tag, count - 1);
+        } else {
+          this._subscribedTags.delete(tag);
+          released = true;
+        }
+      }
+      if (released) {
+        await this._sendSubscription(this._ctx);
+      }
+    };
   }
 
-  async unsubscribeMessages(peerInfo: PeerInfo): Promise<void> {
-    // No-op.
+  /**
+   * Send the current broadcast tag subscription to every joined swarm (DX-1125). An empty tag set
+   * clears the subscription on the edge.
+   */
+  private async _sendSubscription(ctx: Context): Promise<void> {
+    const swarmKeys = Array.from(this._swarmPeers.keys()).map((topic) => topic.toHex());
+    if (swarmKeys.length === 0) {
+      return;
+    }
+    await this._edgeConnection.send(
+      ctx,
+      protocol.createMessage(SwarmRequestSchema, {
+        serviceId: EdgeService.SWARM,
+        source: {
+          peerKey: this._edgeConnection.peerKey,
+          identityDid: this._edgeConnection.identityDid,
+        },
+        payload: {
+          action: SwarmRequestAction.SUBSCRIBE,
+          swarmKeys,
+          subscribeTags: Array.from(this._subscribedTags.keys()),
+        },
+      }),
+    );
   }
 
   private _onMessage(message: EdgeMessage): void {
@@ -215,10 +317,21 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     invariant(protocol.getPayloadType(message) === bufWkt.AnySchema.typeName, 'Wrong payload type');
     const payload = protocol.getPayload(message, bufWkt.AnySchema);
     invariant(message.source, 'source is missing');
+
+    // Broadcasts (DX-1125) carry tags and no target; point-to-point messages carry exactly one target.
+    if ((message.tags?.length ?? 0) > 0 && (message.target?.length ?? 0) === 0) {
+      this._deliver({
+        author: message.source,
+        tags: message.tags ?? [],
+        payload: { type_url: payload.typeUrl, value: payload.value },
+      });
+      return;
+    }
+
     invariant(message.target, 'target is missing');
     invariant(message.target.length === 1, 'target should have exactly one item');
 
-    this.onMessage.emit({
+    this._deliver({
       author: message.source,
       recipient: message.target[0],
       payload: {
@@ -228,6 +341,22 @@ export class EdgeSignalManager extends Resource implements SignalManager {
     });
   }
 
+  /**
+   * Route an incoming message to matching subscriptions (DX-1125): point-to-point by recipient
+   * `peerKey`, broadcasts by tag intersection.
+   */
+  private _deliver(message: Message): void {
+    for (const subscription of this._subscriptions) {
+      if (message.recipient != null) {
+        if (subscription.peerKey === message.recipient.peerKey) {
+          subscription.onMessage(message);
+        }
+      } else if (message.tags?.some((tag) => subscription.tags.has(tag))) {
+        subscription.onMessage(message);
+      }
+    }
+  }
+
   private _matchSelfPeerInfo(peer: PeerInfo): boolean {
     return Boolean(
       peer && (peer.peerKey === this._edgeConnection.peerKey || peer.identityDid === this._edgeConnection.identityDid),
@@ -246,6 +375,10 @@ export class EdgeSignalManager extends Resource implements SignalManager {
         },
       });
     }
+    // Re-establish the broadcast subscription across the rejoined swarms (DX-1125).
+    if (this._subscribedTags.size > 0) {
+      await this._sendSubscription(this._ctx);
+    }
   }
 }
 

package/src/signal-manager/index.ts

@@ -3,7 +3,6 @@
 //
 
 export * from './memory-signal-manager';
-export type * from './signal-manager';
-export * from './websocket-signal-manager';
+export * from './signal-manager';
 export * from './edge-signal-manager';
 export * from './utils';