@dxos/messaging 0.10.0 → 0.11.1

package/src/testing/test-edge-mesh.ts

@@ -0,0 +1,196 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { type Context } from '@dxos/context';
+import { type EdgeConnection, protocol } from '@dxos/edge-client';
+import { EdgeService } from '@dxos/protocols';
+import {
+  type Message,
+  SwarmRequest_Action as SwarmRequestAction,
+  SwarmRequestSchema,
+} from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+
+/**
+ * In-memory stand-in for the EDGE router + swarm, feature-complete for the messaging paths
+ * {@link EdgeSignalManager} exercises: swarm membership (JOIN/LEAVE), tag subscriptions (SUBSCRIBE),
+ * point-to-point relay, and tag broadcast fan-out (DX-1125). Multiple {@link TestEdgeConnection}s
+ * attach to one mesh, so a broadcast from one client is delivered to the matching subscribers of
+ * another — mirroring the real edge without a WebSocket or Durable Object.
+ */
+export class TestEdgeMesh {
+  /** peerKey -> connection. */
+  private readonly _connections = new Map<string, TestEdgeConnection>();
+  /** swarmKey -> (peerKey -> subscription tags). */
+  private readonly _subscriptions = new Map<string, Map<string, string[]>>();
+  /** swarmKey -> set of member peerKeys. */
+  private readonly _members = new Map<string, Set<string>>();
+
+  createConnection({ peerKey, identityDid }: { peerKey: string; identityDid: string }): TestEdgeConnection {
+    const connection = new TestEdgeConnection({ peerKey, identityDid, mesh: this });
+    this._connections.set(peerKey, connection);
+    return connection;
+  }
+
+  removeConnection(peerKey: string): void {
+    this._connections.delete(peerKey);
+    for (const members of this._members.values()) {
+      members.delete(peerKey);
+    }
+    for (const subs of this._subscriptions.values()) {
+      subs.delete(peerKey);
+    }
+  }
+
+  /** Handle a message sent by a client connection. */
+  receive(fromPeerKey: string, message: Message): void {
+    switch (message.serviceId) {
+      case EdgeService.SWARM:
+        this._handleSwarmRequest(fromPeerKey, message);
+        break;
+      case EdgeService.SIGNAL:
+        this._handleSignal(fromPeerKey, message);
+        break;
+    }
+  }
+
+  private _handleSwarmRequest(fromPeerKey: string, message: Message): void {
+    const request = protocol.getPayload(message, SwarmRequestSchema);
+    const swarmKeys = request.swarmKeys ?? [];
+    switch (request.action) {
+      case SwarmRequestAction.JOIN:
+        for (const swarmKey of swarmKeys) {
+          this._memberSet(swarmKey).add(fromPeerKey);
+        }
+        break;
+      case SwarmRequestAction.LEAVE:
+        for (const swarmKey of swarmKeys) {
+          this._memberSet(swarmKey).delete(fromPeerKey);
+          this._subscriptionMap(swarmKey).delete(fromPeerKey);
+        }
+        break;
+      case SwarmRequestAction.SUBSCRIBE:
+        // Set/replace this peer's broadcast subscription on each named swarm (DX-1125).
+        for (const swarmKey of swarmKeys) {
+          this._subscriptionMap(swarmKey).set(fromPeerKey, request.subscribeTags ?? []);
+        }
+        break;
+    }
+  }
+
+  private _handleSignal(fromPeerKey: string, message: Message): void {
+    const tags = message.tags ?? [];
+    const targets = message.target ?? [];
+
+    // Broadcast (DX-1125): tags present, no target -> fan out to matching subscribers on the swarm.
+    if (tags.length > 0 && targets.length === 0) {
+      const swarmKey = message.source?.swarmKey;
+      if (!swarmKey) {
+        return;
+      }
+      for (const [peerKey, subscriptionTags] of this._subscriptionMap(swarmKey)) {
+        if (peerKey === fromPeerKey) {
+          continue; // No self-delivery.
+        }
+        if (subscriptionTags.some((tag) => tags.includes(tag))) {
+          this._connections.get(peerKey)?.deliver(message);
+        }
+      }
+      return;
+    }
+
+    // Point-to-point relay.
+    for (const target of targets) {
+      if (target.peerKey) {
+        this._connections.get(target.peerKey)?.deliver(message);
+      }
+    }
+  }
+
+  private _memberSet(swarmKey: string): Set<string> {
+    let set = this._members.get(swarmKey);
+    if (!set) {
+      set = new Set();
+      this._members.set(swarmKey, set);
+    }
+    return set;
+  }
+
+  private _subscriptionMap(swarmKey: string): Map<string, string[]> {
+    let map = this._subscriptions.get(swarmKey);
+    if (!map) {
+      map = new Map();
+      this._subscriptions.set(swarmKey, map);
+    }
+    return map;
+  }
+}
+
+/**
+ * In-memory {@link EdgeConnection} bound to a {@link TestEdgeMesh}. Only the members
+ * {@link EdgeSignalManager} uses are functional; the rest are inert stubs.
+ */
+export class TestEdgeConnection implements EdgeConnection {
+  public readonly statusChanged: EdgeConnection['statusChanged'] = new Event<any>();
+  private readonly _messageListeners = new Set<(message: Message) => void>();
+  private readonly _peerKey: string;
+  private readonly _identityDid: string;
+  private readonly _mesh: TestEdgeMesh;
+
+  constructor({ peerKey, identityDid, mesh }: { peerKey: string; identityDid: string; mesh: TestEdgeMesh }) {
+    this._peerKey = peerKey;
+    this._identityDid = identityDid;
+    this._mesh = mesh;
+  }
+
+  get info(): any {
+    return { peerKey: this._peerKey, identityDid: this._identityDid };
+  }
+
+  get identityDid(): string {
+    return this._identityDid;
+  }
+
+  get peerKey(): string {
+    return this._peerKey;
+  }
+
+  get isOpen(): boolean {
+    return true;
+  }
+
+  get status(): EdgeConnection['status'] {
+    return {} as EdgeConnection['status'];
+  }
+
+  setIdentity(): void {}
+
+  async send(_ctx: Context, message: Message): Promise<void> {
+    this._mesh.receive(this._peerKey, message);
+  }
+
+  onMessage(listener: (message: Message) => void): () => void {
+    this._messageListeners.add(listener);
+    return () => this._messageListeners.delete(listener);
+  }
+
+  onReconnected(listener: () => void, opts?: { emitCurrentState?: boolean }): () => void {
+    if (opts?.emitCurrentState !== false) {
+      listener();
+    }
+    return () => {};
+  }
+
+  /** Deliver a message from the mesh to this connection's listeners. */
+  deliver(message: Message): void {
+    for (const listener of this._messageListeners) {
+      listener(message);
+    }
+  }
+
+  async open(): Promise<void> {}
+  async close(): Promise<void> {
+    this._mesh.removeConnection(this._peerKey);
+  }
+}

package/src/testing/utils.ts

@@ -31,7 +31,7 @@ export const expectReceivedMessage = (event: Event<Message>, expectedMessage: Me
     event.waitFor(
       (msg) =>
         msg.author.peerKey === expectedMessage.author.peerKey &&
-        msg.recipient.peerKey === expectedMessage.recipient.peerKey &&
+        msg.recipient?.peerKey === expectedMessage.recipient?.peerKey &&
         PublicKey.from(msg.payload.value).equals(expectedMessage.payload.value),
     ),
     5000,
@@ -46,5 +46,5 @@ export const createMessage = (author: PeerInfo, recipient: PeerInfo, payload: An
 
 export const messageEqual = (msg1: Message, msg2: Message) =>
   msg1.author.peerKey === msg2.author.peerKey &&
-  msg1.recipient.peerKey === msg2.recipient.peerKey &&
+  msg1.recipient?.peerKey === msg2.recipient?.peerKey &&
   PublicKey.from(msg1.payload.value).equals(msg2.payload.value);

package/dist/lib/neutral/chunk-EC4H56J5.mjs

@@ -1,497 +0,0 @@
-import "@dxos/node-std/globals";
-
-// src/messenger.ts
-import { TimeoutError, scheduleExponentialBackoffTaskInterval, scheduleTask, scheduleTaskInterval } from "@dxos/async";
-import { Context } from "@dxos/context";
-import { invariant } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { TimeoutError as ProtocolTimeoutError } from "@dxos/protocols";
-import { schema } from "@dxos/protocols/proto";
-import { ComplexMap, ComplexSet } from "@dxos/util";
-
-// src/messenger-monitor.ts
-import { trace } from "@dxos/tracing";
-var MessengerMonitor = class {
-  recordMessageAckFailed() {
-    trace.metrics.increment("dxos.mesh.signal.messenger.failed-ack", 1);
-  }
-  recordReliableMessage(params) {
-    trace.metrics.increment("dxos.mesh.signal.messenger.reliable-send", 1, {
-      tags: {
-        success: params.sent,
-        attempts: params.sendAttempts
-      }
-    });
-  }
-};
-
-// src/timeouts.ts
-var MESSAGE_TIMEOUT = 1e4;
-
-// src/messenger.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/messaging/src/messenger.ts";
-var ReliablePayload = schema.getCodecForType("dxos.mesh.messaging.ReliablePayload");
-var Acknowledgement = schema.getCodecForType("dxos.mesh.messaging.Acknowledgement");
-var RECEIVED_MESSAGES_GC_INTERVAL = 12e4;
-var Messenger = class {
-  _monitor = new MessengerMonitor();
-  _signalManager;
-  // { peerId, payloadType } => listeners set
-  _listeners = new ComplexMap(({ peerId, payloadType }) => peerId + payloadType);
-  // peerId => listeners set
-  _defaultListeners = /* @__PURE__ */ new Map();
-  _onAckCallbacks = new ComplexMap(PublicKey.hash);
-  _receivedMessages = new ComplexSet(PublicKey.hash);
-  /**
-  * Keys scheduled to be cleared from _receivedMessages on the next iteration.
-  */
-  _toClear = new ComplexSet(PublicKey.hash);
-  _ctx;
-  _closed = true;
-  _retryDelay;
-  constructor({ signalManager, retryDelay = 1e3 }) {
-    this._signalManager = signalManager;
-    this._retryDelay = retryDelay;
-    this.open();
-  }
-  open() {
-    if (!this._closed) {
-      return;
-    }
-    log("opening messenger", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 43, S: this });
-    this._ctx = new Context({
-      onError: (err) => log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 45, S: this })
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 44 });
-    this._ctx.onDispose(this._signalManager.onMessage.on(async (message) => {
-      log("received message", {
-        from: message.author
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 48, S: this });
-      await this._handleMessage(message);
-    }));
-    scheduleTaskInterval(this._ctx, async () => {
-      this._performGc();
-    }, RECEIVED_MESSAGES_GC_INTERVAL);
-    this._closed = false;
-    log("opened messenger", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 58, S: this });
-  }
-  async close() {
-    if (this._closed) {
-      return;
-    }
-    this._closed = true;
-    await this._ctx.dispose();
-  }
-  async sendMessage(ctx, { author, recipient, payload }) {
-    invariant(!this._closed, "Closed", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 68, S: this, A: ["!this._closed", "'Closed'"] });
-    const messageContext = this._ctx.derive();
-    const reliablePayload = {
-      messageId: PublicKey.random(),
-      payload
-    };
-    invariant(!this._onAckCallbacks.has(reliablePayload.messageId), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 74, S: this, A: ["!this._onAckCallbacks.has(reliablePayload.messageId)", ""] });
-    log("send message", {
-      messageId: reliablePayload.messageId,
-      author,
-      recipient
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 75, S: this });
-    let messageReceived;
-    let timeoutHit;
-    let sendAttempts = 0;
-    const promise = new Promise((resolve, reject) => {
-      messageReceived = resolve;
-      timeoutHit = reject;
-    });
-    scheduleExponentialBackoffTaskInterval(messageContext, async () => {
-      log("retrying message", {
-        messageId: reliablePayload.messageId
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 89, S: this });
-      sendAttempts++;
-      await this._encodeAndSend(ctx, {
-        author,
-        recipient,
-        reliablePayload
-      }).catch((err) => log("failed to send message", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 97, S: this }));
-    }, this._retryDelay);
-    scheduleTask(messageContext, () => {
-      log("message not delivered", {
-        messageId: reliablePayload.messageId
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 102, S: this });
-      this._onAckCallbacks.delete(reliablePayload.messageId);
-      timeoutHit(new ProtocolTimeoutError({
-        message: "signaling message not delivered",
-        cause: new TimeoutError(MESSAGE_TIMEOUT, "Message not delivered")
-      }));
-      void messageContext.dispose();
-      this._monitor.recordReliableMessage({
-        sendAttempts,
-        sent: false
-      });
-    }, MESSAGE_TIMEOUT);
-    this._onAckCallbacks.set(reliablePayload.messageId, () => {
-      messageReceived();
-      this._onAckCallbacks.delete(reliablePayload.messageId);
-      void messageContext.dispose();
-      this._monitor.recordReliableMessage({
-        sendAttempts,
-        sent: true
-      });
-    });
-    await this._encodeAndSend(ctx, {
-      author,
-      recipient,
-      reliablePayload
-    });
-    return promise;
-  }
-  /**
-  * Subscribes onMessage function to messages that contains payload with payloadType.
-  * @param payloadType if not specified, onMessage will be subscribed to all types of messages.
-  */
-  async listen({ peer, payloadType, onMessage }) {
-    invariant(!this._closed, "Closed", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 136, S: this, A: ["!this._closed", "'Closed'"] });
-    await this._signalManager.subscribeMessages(peer);
-    let listeners;
-    invariant(peer.peerKey, "Peer key is required", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 139, S: this, A: ["peer.peerKey", "'Peer key is required'"] });
-    if (!payloadType) {
-      listeners = this._defaultListeners.get(peer.peerKey);
-      if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
-        this._defaultListeners.set(peer.peerKey, listeners);
-      }
-    } else {
-      listeners = this._listeners.get({
-        peerId: peer.peerKey,
-        payloadType
-      });
-      if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
-        this._listeners.set({
-          peerId: peer.peerKey,
-          payloadType
-        }, listeners);
-      }
-    }
-    listeners.add(onMessage);
-    return {
-      unsubscribe: async () => {
-        listeners.delete(onMessage);
-      }
-    };
-  }
-  async _encodeAndSend(ctx, { author, recipient, reliablePayload }) {
-    await this._signalManager.sendMessage(ctx, {
-      author,
-      recipient,
-      payload: {
-        type_url: "dxos.mesh.messaging.ReliablePayload",
-        value: ReliablePayload.encode(reliablePayload, {
-          preserveAny: true
-        })
-      }
-    });
-  }
-  async _handleMessage(message) {
-    switch (message.payload.type_url) {
-      case "dxos.mesh.messaging.ReliablePayload": {
-        await this._handleReliablePayload(message);
-        break;
-      }
-      case "dxos.mesh.messaging.Acknowledgement": {
-        await this._handleAcknowledgement({
-          payload: message.payload
-        });
-        break;
-      }
-    }
-  }
-  async _handleReliablePayload({ author, recipient, payload }) {
-    invariant(payload.type_url === "dxos.mesh.messaging.ReliablePayload", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 195, S: this, A: ["payload.type_url === 'dxos.mesh.messaging.ReliablePayload'", ""] });
-    const reliablePayload = ReliablePayload.decode(payload.value, {
-      preserveAny: true
-    });
-    log("handling message", {
-      messageId: reliablePayload.messageId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 199, S: this });
-    try {
-      await this._sendAcknowledgement(this._ctx, {
-        author,
-        recipient,
-        messageId: reliablePayload.messageId
-      });
-    } catch (err) {
-      this._monitor.recordMessageAckFailed();
-      throw err;
-    }
-    if (this._receivedMessages.has(reliablePayload.messageId)) {
-      return;
-    }
-    this._receivedMessages.add(reliablePayload.messageId);
-    await this._callListeners({
-      author,
-      recipient,
-      payload: reliablePayload.payload
-    });
-  }
-  async _handleAcknowledgement({ payload }) {
-    invariant(payload.type_url === "dxos.mesh.messaging.Acknowledgement", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 224, S: this, A: ["payload.type_url === 'dxos.mesh.messaging.Acknowledgement'", ""] });
-    this._onAckCallbacks.get(Acknowledgement.decode(payload.value).messageId)?.();
-  }
-  async _sendAcknowledgement(ctx, { author, recipient, messageId }) {
-    log("sending ACK", {
-      messageId,
-      from: recipient,
-      to: author
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 228, S: this });
-    await this._signalManager.sendMessage(ctx, {
-      author: recipient,
-      recipient: author,
-      payload: {
-        type_url: "dxos.mesh.messaging.Acknowledgement",
-        value: Acknowledgement.encode({
-          messageId
-        })
-      }
-    });
-  }
-  async _callListeners(message) {
-    {
-      invariant(message.recipient.peerKey, "Peer key is required", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 246, S: this, A: ["message.recipient.peerKey", "'Peer key is required'"] });
-      const defaultListenerMap = this._defaultListeners.get(message.recipient.peerKey);
-      if (defaultListenerMap) {
-        for (const listener of defaultListenerMap) {
-          await listener(message);
-        }
-      }
-    }
-    {
-      const listenerMap = this._listeners.get({
-        peerId: message.recipient.peerKey,
-        payloadType: message.payload.type_url
-      });
-      if (listenerMap) {
-        for (const listener of listenerMap) {
-          await listener(message);
-        }
-      }
-    }
-  }
-  _performGc() {
-    const start = performance.now();
-    for (const key of this._toClear.keys()) {
-      this._receivedMessages.delete(key);
-    }
-    this._toClear.clear();
-    for (const key of this._receivedMessages.keys()) {
-      this._toClear.add(key);
-    }
-    const elapsed = performance.now() - start;
-    if (elapsed > 100) {
-      log.warn("GC took too long", {
-        elapsed
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, S: this });
-    }
-  }
-};
-
-// src/signal-methods.ts
-var PeerInfoHash = ({ peerKey }) => peerKey;
-
-// src/signal-manager/memory-signal-manager.ts
-import { Event, Trigger } from "@dxos/async";
-import { Context as Context2 } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { schema as schema2 } from "@dxos/protocols/proto";
-import { ComplexMap as ComplexMap2, ComplexSet as ComplexSet2 } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/messaging/src/signal-manager/memory-signal-manager.ts";
-var MemorySignalManagerContext = class {
-  // Swarm messages.
-  swarmEvent = new Event();
-  // Mapping from topic to set of peers.
-  swarms = new ComplexMap2(PublicKey2.hash);
-  // Map of connections for each peer for signaling.
-  connections = new ComplexMap2(PeerInfoHash);
-};
-var MemorySignalManager = class {
-  _context;
-  statusChanged = new Event();
-  swarmEvent = new Event();
-  onMessage = new Event();
-  /**  Will be used to emit SwarmEvents on .open() and .close() */
-  _joinedSwarms = new ComplexSet2(({ topic, peer }) => topic.toHex() + peer.peerKey);
-  _ctx;
-  // TODO(dmaretskyi): Replace with callback.
-  _freezeTrigger = new Trigger().wake();
-  constructor(_context) {
-    this._context = _context;
-    this._ctx = new Context2(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 35 });
-    this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
-  }
-  async open() {
-    if (!this._ctx.disposed) {
-      return;
-    }
-    this._ctx = new Context2(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 42 });
-    this._ctx.onDispose(this._context.swarmEvent.on((data) => this.swarmEvent.emit(data)));
-    await Promise.all([
-      ...this._joinedSwarms.values()
-    ].map((value) => this.join(this._ctx, value)));
-  }
-  async close() {
-    if (this._ctx.disposed) {
-      return;
-    }
-    const joinedSwarmsCopy = new ComplexSet2(({ topic, peer }) => topic.toHex() + peer.peerKey, [
-      ...this._joinedSwarms.values()
-    ]);
-    await Promise.all([
-      ...this._joinedSwarms.values()
-    ].map((value) => this.leave(this._ctx, value)));
-    this._joinedSwarms = joinedSwarmsCopy;
-    await this._ctx.dispose();
-  }
-  getStatus() {
-    return [];
-  }
-  async join(_ctx, { topic, peer }) {
-    invariant2(!this._ctx.disposed, "Closed", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 67, S: this, A: ["!this._ctx.disposed", "'Closed'"] });
-    this._joinedSwarms.add({
-      topic,
-      peer
-    });
-    if (!this._context.swarms.has(topic)) {
-      this._context.swarms.set(topic, new ComplexSet2(PeerInfoHash));
-    }
-    this._context.swarms.get(topic).add(peer);
-    this._context.swarmEvent.emit({
-      topic,
-      peerAvailable: {
-        peer,
-        since: /* @__PURE__ */ new Date()
-      }
-    });
-    for (const [topic2, peers] of this._context.swarms) {
-      Array.from(peers).forEach((peer2) => {
-        this.swarmEvent.emit({
-          topic: topic2,
-          peerAvailable: {
-            peer: peer2,
-            since: /* @__PURE__ */ new Date()
-          }
-        });
-      });
-    }
-  }
-  async leave(_ctx, { topic, peer }) {
-    invariant2(!this._ctx.disposed, "Closed", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 97, S: this, A: ["!this._ctx.disposed", "'Closed'"] });
-    this._joinedSwarms.delete({
-      topic,
-      peer
-    });
-    if (!this._context.swarms.has(topic)) {
-      this._context.swarms.set(topic, new ComplexSet2(PeerInfoHash));
-    }
-    this._context.swarms.get(topic).delete(peer);
-    const swarmEvent = {
-      topic,
-      peerLeft: {
-        peer
-      }
-    };
-    this._context.swarmEvent.emit(swarmEvent);
-  }
-  async query(_ctx, request) {
-    throw new Error("Not implemented");
-  }
-  async sendMessage(_ctx, { author, recipient, payload }) {
-    log2("send message", {
-      author,
-      recipient,
-      ...dec(payload)
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 118, S: this });
-    invariant2(recipient, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 123, S: this, A: ["recipient", ""] });
-    invariant2(!this._ctx.disposed, "Closed", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 124, S: this, A: ["!this._ctx.disposed", "'Closed'"] });
-    await this._freezeTrigger.wait();
-    const remote = this._context.connections.get(recipient);
-    if (!remote) {
-      log2.warn("recipient is not subscribed for messages", {
-        author,
-        recipient
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 128, S: this });
-      return;
-    }
-    if (remote._ctx.disposed) {
-      log2.warn("recipient is disposed", {
-        author,
-        recipient
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 135, S: this });
-      return;
-    }
-    remote._freezeTrigger.wait().then(() => {
-      if (remote._ctx.disposed) {
-        log2.warn("recipient is disposed", {
-          author,
-          recipient
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 143, S: this });
-        return;
-      }
-      log2("receive message", {
-        author,
-        recipient,
-        ...dec(payload)
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 149, S: this });
-      remote.onMessage.emit({
-        author,
-        recipient,
-        payload
-      });
-    }).catch((err) => {
-      log2.error("error while waiting for freeze", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 160, S: this });
-    });
-  }
-  async subscribeMessages(peerInfo) {
-    log2("subscribing", {
-      peerInfo
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 166, S: this });
-    this._context.connections.set(peerInfo, this);
-  }
-  async unsubscribeMessages(peerInfo) {
-    log2("unsubscribing", {
-      peerInfo
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 172, S: this });
-    this._context.connections.delete(peerInfo);
-  }
-  freeze() {
-    this._freezeTrigger.reset();
-  }
-  unfreeze() {
-    this._freezeTrigger.wake();
-  }
-};
-var dec = (payload) => {
-  if (!payload.type_url.endsWith("ReliablePayload")) {
-    return {};
-  }
-  const relPayload = schema2.getCodecForType("dxos.mesh.messaging.ReliablePayload").decode(payload.value);
-  if (typeof relPayload?.payload?.data === "object") {
-    return {
-      payload: Object.keys(relPayload?.payload?.data)[0],
-      sessionId: relPayload?.payload?.sessionId
-    };
-  }
-  return {};
-};
-
-export {
-  Messenger,
-  PeerInfoHash,
-  MemorySignalManagerContext,
-  MemorySignalManager
-};
-//# sourceMappingURL=chunk-EC4H56J5.mjs.map