@dxos/network-manager 0.1.13 → 0.1.16

package/dist/lib/node/testing/index.cjs

@@ -0,0 +1,2225 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/mesh/network-manager/src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  TEST_SIGNAL_URL: () => TEST_SIGNAL_URL,
+  TestBuilder: () => TestBuilder,
+  TestPeer: () => TestPeer,
+  TestProtocolPlugin: () => TestProtocolPlugin,
+  TestSwarmConnection: () => TestSwarmConnection,
+  getPeerId: () => getPeerId,
+  testProtocolProvider: () => testProtocolProvider
+});
+module.exports = __toCommonJS(testing_exports);
+
+// packages/core/mesh/network-manager/src/testing/test-builder.ts
+var import_keys12 = require("@dxos/keys");
+var import_messaging2 = require("@dxos/messaging");
+var import_protocols2 = require("@dxos/protocols");
+var import_rpc = require("@dxos/rpc");
+var import_util8 = require("@dxos/util");
+
+// packages/core/mesh/network-manager/src/network-manager.ts
+var import_node_assert5 = __toESM(require("node:assert"));
+var import_async6 = require("@dxos/async");
+var import_keys6 = require("@dxos/keys");
+var import_log6 = require("@dxos/log");
+var import_messaging = require("@dxos/messaging");
+var import_util5 = require("@dxos/util");
+
+// packages/core/mesh/network-manager/src/connection-log.ts
+var import_async5 = require("@dxos/async");
+var import_debug3 = require("@dxos/debug");
+var import_keys5 = require("@dxos/keys");
+var import_util4 = require("@dxos/util");
+
+// packages/core/mesh/network-manager/src/swarm/connection.ts
+var import_node_assert = __toESM(require("node:assert"));
+var import_async = require("@dxos/async");
+var import_debug = require("@dxos/debug");
+var import_log = require("@dxos/log");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ConnectionState;
+(function(ConnectionState4) {
+  ConnectionState4["INITIAL"] = "INITIAL";
+  ConnectionState4["CONNECTING"] = "CONNECTING";
+  ConnectionState4["CONNECTED"] = "CONNECTED";
+  ConnectionState4["CLOSED"] = "CLOSED";
+})(ConnectionState || (ConnectionState = {}));
+var Connection = class {
+  constructor(topic, ownId, remoteId, sessionId, initiator, _signalMessaging, _protocol, _transportFactory) {
+    this.topic = topic;
+    this.ownId = ownId;
+    this.remoteId = remoteId;
+    this.sessionId = sessionId;
+    this.initiator = initiator;
+    this._signalMessaging = _signalMessaging;
+    this._protocol = _protocol;
+    this._transportFactory = _transportFactory;
+    this._state = ConnectionState.INITIAL;
+    this._bufferedSignals = [];
+    this.stateChanged = new import_async.Event();
+    this.errors = new import_debug.ErrorStream();
+  }
+  get state() {
+    return this._state;
+  }
+  get transport() {
+    return this._transport;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  openConnection() {
+    (0, import_node_assert.default)(this._state === ConnectionState.INITIAL, "Invalid state.");
+    this._changeState(ConnectionState.CONNECTING);
+    this._protocol.initialize().catch((err) => {
+      this.errors.raise(err);
+    });
+    (0, import_node_assert.default)(!this._transport);
+    this._transport = this._transportFactory.createTransport({
+      initiator: this.initiator,
+      stream: this._protocol.stream,
+      sendSignal: async (signal) => {
+        await this._signalMessaging.signal({
+          author: this.ownId,
+          recipient: this.remoteId,
+          sessionId: this.sessionId,
+          topic: this.topic,
+          data: {
+            signal
+          }
+        });
+      }
+    });
+    this._transport.connected.once(() => {
+      this._changeState(ConnectionState.CONNECTED);
+    });
+    this._transport.closed.once(() => {
+      this._transport = void 0;
+      this.close().catch((err) => this.errors.raise(err));
+    });
+    this._transport.errors.pipeTo(this.errors);
+    for (const signal of this._bufferedSignals) {
+      void this._transport.signal(signal);
+    }
+    this._bufferedSignals = [];
+  }
+  async close() {
+    var _a;
+    if (this._state === ConnectionState.CLOSED) {
+      return;
+    }
+    (0, import_log.log)("closing...", {
+      peerId: this.ownId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+      line: 131,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      await this._protocol.destroy();
+    } catch (err) {
+      import_log.log.catch(err, {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+        line: 137,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    try {
+      await ((_a = this._transport) == null ? void 0 : _a.destroy());
+    } catch (err1) {
+      import_log.log.catch(err1, {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+        line: 144,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    (0, import_log.log)("closed", {
+      peerId: this.ownId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+      line: 147,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._changeState(ConnectionState.CLOSED);
+  }
+  async signal(msg) {
+    var _a, _b;
+    (0, import_node_assert.default)(msg.sessionId);
+    if (!msg.sessionId.equals(this.sessionId)) {
+      (0, import_log.log)("dropping signal for incorrect session id", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+        line: 154,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    (0, import_node_assert.default)(msg.data.signal);
+    (0, import_node_assert.default)((_a = msg.author) == null ? void 0 : _a.equals(this.remoteId));
+    (0, import_node_assert.default)((_b = msg.recipient) == null ? void 0 : _b.equals(this.ownId));
+    if (this._state === ConnectionState.INITIAL) {
+      (0, import_log.log)("buffered signal", {
+        peerId: this.ownId,
+        remoteId: this.remoteId,
+        msg: msg.data
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+        line: 162,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._bufferedSignals.push(msg.data.signal);
+      return;
+    }
+    (0, import_node_assert.default)(this._transport, "Connection not ready to accept signals.");
+    (0, import_log.log)("received signal", {
+      peerId: this.ownId,
+      remoteId: this.remoteId,
+      msg: msg.data
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts",
+      line: 168,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._transport.signal(msg.data.signal);
+  }
+  _changeState(state) {
+    (0, import_node_assert.default)(state !== this._state, "Already in this state.");
+    this._state = state;
+    this.stateChanged.emit(state);
+  }
+};
+__decorate([
+  import_async.synchronized
+], Connection.prototype, "close", null);
+
+// packages/core/mesh/network-manager/src/swarm/swarm.ts
+var import_node_assert4 = __toESM(require("node:assert"));
+var import_async3 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_debug2 = require("@dxos/debug");
+var import_keys3 = require("@dxos/keys");
+var import_log4 = require("@dxos/log");
+var import_util2 = require("@dxos/util");
+
+// packages/core/mesh/network-manager/src/signal/message-router.ts
+var import_node_assert2 = __toESM(require("node:assert"));
+var import_keys = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
+var import_protocols = require("@dxos/protocols");
+var import_util = require("@dxos/util");
+var MessageRouter = class {
+  constructor({ sendMessage, onSignal, onOffer, topic }) {
+    this._offerRecords = new import_util.ComplexMap((key) => key.toHex());
+    this._sendMessage = sendMessage;
+    this._onSignal = onSignal;
+    this._onOffer = onOffer;
+    this._topic = topic;
+  }
+  async receiveMessage({ author, recipient, payload }) {
+    var _a, _b, _c;
+    if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
+      return;
+    }
+    const message = import_protocols.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage").decode(payload.value);
+    if (!this._topic.equals(message.topic)) {
+      return;
+    }
+    (0, import_log2.log)("received", {
+      from: author,
+      to: recipient,
+      msg: message
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/message-router.ts",
+      line: 67,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if ((_a = message.data) == null ? void 0 : _a.offer) {
+      await this._handleOffer({
+        author,
+        recipient,
+        message
+      });
+    } else if ((_b = message.data) == null ? void 0 : _b.answer) {
+      await this._resolveAnswers(message);
+    } else if ((_c = message.data) == null ? void 0 : _c.signal) {
+      await this._handleSignal({
+        author,
+        recipient,
+        message
+      });
+    }
+  }
+  async signal(message) {
+    var _a;
+    (0, import_node_assert2.default)((_a = message.data) == null ? void 0 : _a.signal);
+    await this._sendReliableMessage({
+      author: message.author,
+      recipient: message.recipient,
+      message
+    });
+  }
+  async offer(message) {
+    const networkMessage = {
+      ...message,
+      messageId: import_keys.PublicKey.random()
+    };
+    return new Promise((resolve, reject) => {
+      this._offerRecords.set(networkMessage.messageId, {
+        resolve,
+        reject
+      });
+      return this._sendReliableMessage({
+        author: message.author,
+        recipient: message.recipient,
+        message: networkMessage
+      });
+    });
+  }
+  async _sendReliableMessage({ author, recipient, message }) {
+    var _a;
+    const networkMessage = {
+      ...message,
+      messageId: (_a = message.messageId) != null ? _a : import_keys.PublicKey.random()
+    };
+    (0, import_log2.log)("sending", {
+      from: author,
+      to: recipient,
+      msg: networkMessage
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/message-router.ts",
+      line: 117,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._encodeAndSend({
+      author,
+      recipient,
+      message: networkMessage
+    });
+  }
+  async _encodeAndSend({ author, recipient, message }) {
+    await this._sendMessage({
+      author,
+      recipient,
+      payload: {
+        type_url: "dxos.mesh.swarm.SwarmMessage",
+        value: import_protocols.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage").encode(message)
+      }
+    });
+  }
+  async _resolveAnswers(message) {
+    var _a, _b, _c;
+    (0, import_node_assert2.default)((_b = (_a = message.data) == null ? void 0 : _a.answer) == null ? void 0 : _b.offerMessageId, "No offerMessageId");
+    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
+    if (offerRecord) {
+      this._offerRecords.delete(message.data.answer.offerMessageId);
+      (0, import_node_assert2.default)((_c = message.data) == null ? void 0 : _c.answer, "No answer");
+      (0, import_log2.log)("resolving", {
+        answer: message.data.answer
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/message-router.ts",
+        line: 146,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+  async _handleOffer({ author, recipient, message }) {
+    (0, import_node_assert2.default)(message.data.offer, "No offer");
+    const offerMessage = {
+      author,
+      recipient,
+      ...message,
+      data: {
+        offer: message.data.offer
+      }
+    };
+    const answer = await this._onOffer(offerMessage);
+    answer.offerMessageId = message.messageId;
+    await this._sendReliableMessage({
+      author: recipient,
+      recipient: author,
+      message: {
+        topic: message.topic,
+        sessionId: message.sessionId,
+        data: {
+          answer
+        }
+      }
+    });
+  }
+  async _handleSignal({ author, recipient, message }) {
+    (0, import_node_assert2.default)(message.messageId);
+    (0, import_node_assert2.default)(message.data.signal, "No Signal");
+    const signalMessage = {
+      author,
+      recipient,
+      ...message,
+      data: {
+        signal: message.data.signal
+      }
+    };
+    await this._onSignal(signalMessage);
+  }
+};
+
+// packages/core/mesh/network-manager/src/swarm/peer.ts
+var import_node_assert3 = __toESM(require("node:assert"));
+var import_async2 = require("@dxos/async");
+var import_keys2 = require("@dxos/keys");
+var import_log3 = require("@dxos/log");
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Peer = class {
+  constructor(id, topic, localPeerId, _signalMessaging, _protocolProvider, _transportFactory, _callbacks) {
+    this.id = id;
+    this.topic = topic;
+    this.localPeerId = localPeerId;
+    this._signalMessaging = _signalMessaging;
+    this._protocolProvider = _protocolProvider;
+    this._transportFactory = _transportFactory;
+    this._callbacks = _callbacks;
+    this.advertizing = false;
+    this.initiating = false;
+  }
+  async onOffer(message) {
+    const remoteId = message.author;
+    if (this.connection || this.initiating) {
+      if (remoteId.toHex() < this.localPeerId.toHex()) {
+        import_log3.log.info("closing local connection and accepting remote peer's offer", {
+          id: this.id,
+          topic: this.topic,
+          peerId: this.localPeerId
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+          line: 83,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        if (this.connection) {
+          await this.closeConnection();
+        }
+      } else {
+        return {
+          accept: false
+        };
+      }
+    }
+    if (await this._callbacks.onOffer(remoteId)) {
+      if (!this.connection) {
+        (0, import_node_assert3.default)(message.sessionId);
+        const connection = this._createConnection(false, message.sessionId);
+        try {
+          connection.openConnection();
+        } catch (err) {
+          import_log3.log.warn("connection error", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            err
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+            line: 107,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          await this.closeConnection();
+        }
+        return {
+          accept: true
+        };
+      }
+    }
+    return {
+      accept: false
+    };
+  }
+  async initiateConnection() {
+    (0, import_node_assert3.default)(!this.initiating, "Initiation in progress.");
+    (0, import_node_assert3.default)(!this.connection, "Already connected.");
+    const sessionId = import_keys2.PublicKey.random();
+    (0, import_log3.log)("initiating...", {
+      id: this.id,
+      topic: this.topic,
+      peerId: this.id,
+      sessionId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+      line: 125,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const connection = this._createConnection(true, sessionId);
+    this.initiating = true;
+    try {
+      const answer = await this._signalMessaging.offer({
+        author: this.localPeerId,
+        recipient: this.id,
+        sessionId,
+        topic: this.topic,
+        data: {
+          offer: {}
+        }
+      });
+      (0, import_log3.log)("received", {
+        answer,
+        topic: this.topic,
+        ownId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+        line: 137,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      if (connection.state !== ConnectionState.INITIAL) {
+        (0, import_log3.log)("ignoring response", {}, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+          line: 139,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (!answer.accept) {
+        this._callbacks.onRejected();
+        return;
+      }
+      connection.openConnection();
+      this._callbacks.onAccepted();
+    } catch (err) {
+      import_log3.log.warn("initiation error", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        err
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+        line: 150,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this.closeConnection();
+      throw err;
+    } finally {
+      this.initiating = false;
+    }
+  }
+  _createConnection(initiator, sessionId) {
+    (0, import_log3.log)("creating connection", {
+      topic: this.topic,
+      peerId: this.localPeerId,
+      remoteId: this.id,
+      initiator,
+      sessionId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+      line: 164,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    (0, import_node_assert3.default)(!this.connection, "Already connected.");
+    const connection = new Connection(
+      this.topic,
+      this.localPeerId,
+      this.id,
+      sessionId,
+      initiator,
+      this._signalMessaging,
+      this._protocolProvider({
+        initiator,
+        localPeerId: this.localPeerId,
+        remotePeerId: this.id,
+        topic: this.topic
+      }),
+      this._transportFactory
+    );
+    this._callbacks.onInitiated(connection);
+    connection.stateChanged.on((state) => {
+      switch (state) {
+        case ConnectionState.CONNECTED: {
+          this._callbacks.onConnected();
+          break;
+        }
+        case ConnectionState.CLOSED: {
+          (0, import_log3.log)("connection closed", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            initiator
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+            line: 193,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          (0, import_node_assert3.default)(this.connection === connection, "Connection mismatch (race condition).");
+          this.connection = void 0;
+          this._callbacks.onDisconnected();
+          break;
+        }
+      }
+    });
+    connection.errors.handle((err) => {
+      import_log3.log.warn("connection error", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        initiator,
+        err
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+        line: 203,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      void this.closeConnection().catch(() => {
+        import_log3.log.catch(err, {}, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+          line: 207,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      });
+    });
+    this.connection = connection;
+    return connection;
+  }
+  async closeConnection() {
+    if (!this.connection) {
+      return;
+    }
+    const connection = this.connection;
+    (0, import_log3.log)("closing...", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+      line: 221,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await connection.close();
+    (0, import_log3.log)("closed", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+      line: 227,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async onSignal(message) {
+    if (!this.connection) {
+      (0, import_log3.log)("dropping signal message for non-existent connection", {
+        message
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+        line: 232,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    await this.connection.signal(message);
+  }
+  async destroy() {
+    var _a;
+    (0, import_log3.log)("Destroying peer", {
+      peerId: this.id,
+      topic: this.topic
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts",
+      line: 240,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await ((_a = this == null ? void 0 : this.connection) == null ? void 0 : _a.close());
+  }
+};
+__decorate2([
+  import_async2.synchronized
+], Peer.prototype, "destroy", null);
+
+// packages/core/mesh/network-manager/src/swarm/swarm.ts
+var __decorate3 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var INITIATION_DELAY = 100;
+var getClassName = (obj) => Object.getPrototypeOf(obj).constructor.name;
+var Swarm = class {
+  constructor(_topic, _ownPeerId, _topology, _protocolProvider, _messenger, _transportFactory, _label) {
+    this._topic = _topic;
+    this._ownPeerId = _ownPeerId;
+    this._topology = _topology;
+    this._protocolProvider = _protocolProvider;
+    this._messenger = _messenger;
+    this._transportFactory = _transportFactory;
+    this._label = _label;
+    this._peers = new import_util2.ComplexMap(import_keys3.PublicKey.hash);
+    this._ctx = new import_context.Context();
+    this.connectionAdded = new import_async3.Event();
+    this.disconnected = new import_async3.Event();
+    this.connected = new import_async3.Event();
+    this.errors = new import_debug2.ErrorStream();
+    this.instanceId = import_keys3.PublicKey.random();
+    (0, import_log4.log)("creating swarm", {
+      peerId: _ownPeerId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 80,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    _topology.init(this._getSwarmController());
+    this._swarmMessenger = new MessageRouter({
+      sendMessage: async (msg) => await this._messenger.sendMessage(msg),
+      onSignal: async (msg) => await this.onSignal(msg),
+      onOffer: async (msg) => await this.onOffer(msg),
+      topic: this._topic
+    });
+    this._messenger.listen({
+      peerId: this._ownPeerId,
+      payloadType: "dxos.mesh.swarm.SwarmMessage",
+      onMessage: async (message) => await this._swarmMessenger.receiveMessage(message)
+    }).catch((error) => import_log4.log.catch(error, {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 96,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+  }
+  get connections() {
+    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(import_util2.isNotNullOrUndefined);
+  }
+  get ownPeerId() {
+    return this._ownPeerId;
+  }
+  get label() {
+    return this._label;
+  }
+  get topic() {
+    return this._topic;
+  }
+  async destroy() {
+    (0, import_log4.log)("destroying...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 124,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._ctx.dispose();
+    await this._topology.destroy();
+    await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key)));
+    (0, import_log4.log)("destroyed", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 128,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async setTopology(topology) {
+    if (topology === this._topology) {
+      return;
+    }
+    (0, import_log4.log)("setting topology", {
+      previous: getClassName(this._topology),
+      topology: getClassName(topology)
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 135,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._topology.destroy();
+    this._topology = topology;
+    this._topology.init(this._getSwarmController());
+    this._topology.update();
+  }
+  _getOrCreatePeer(peerId) {
+    let peer = this._peers.get(peerId);
+    if (!peer) {
+      peer = new Peer(peerId, this._topic, this._ownPeerId, this._swarmMessenger, this._protocolProvider, this._transportFactory, {
+        onInitiated: (connection) => {
+          this.connectionAdded.emit(connection);
+        },
+        onConnected: () => {
+          this.connected.emit(peerId);
+        },
+        onDisconnected: async () => {
+          if (!peer.advertizing) {
+            await this._destroyPeer(peer.id);
+          }
+          this.disconnected.emit(peerId);
+          this._topology.update();
+        },
+        onRejected: () => {
+          if (this._peers.has(peerId)) {
+            void this._destroyPeer(peerId);
+          }
+        },
+        onAccepted: () => {
+          this._topology.update();
+        },
+        onOffer: (remoteId) => {
+          return this._topology.onOffer(remoteId);
+        }
+      });
+      this._peers.set(peerId, peer);
+    }
+    return peer;
+  }
+  async _destroyPeer(peerId) {
+    (0, import_node_assert4.default)(this._peers.has(peerId));
+    await this._peers.get(peerId).destroy();
+    this._peers.delete(peerId);
+  }
+  onSwarmEvent(swarmEvent) {
+    (0, import_log4.log)("swarm event", {
+      swarmEvent
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 199,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      import_log4.log.warn("ignored for destroyed swarm", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 201,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (swarmEvent.peerAvailable) {
+      const peerId = import_keys3.PublicKey.from(swarmEvent.peerAvailable.peer);
+      (0, import_log4.log)("new peer", {
+        peerId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 207,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      if (!peerId.equals(this._ownPeerId)) {
+        const peer = this._getOrCreatePeer(peerId);
+        peer.advertizing = true;
+      }
+    } else if (swarmEvent.peerLeft) {
+      const peer1 = this._peers.get(import_keys3.PublicKey.from(swarmEvent.peerLeft.peer));
+      if (peer1) {
+        peer1.advertizing = false;
+        if (!peer1.connection) {
+          void this._destroyPeer(peer1.id);
+        }
+      }
+    }
+    this._topology.update();
+  }
+  async onOffer(message) {
+    var _a, _b;
+    (0, import_log4.log)("offer", {
+      message
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 226,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      import_log4.log.info("ignored for destroyed swarm", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 228,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    (0, import_node_assert4.default)(message.author);
+    if (!((_a = message.recipient) == null ? void 0 : _a.equals(this._ownPeerId))) {
+      (0, import_log4.log)("rejecting offer with incorrect peerId", {
+        message
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 235,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    if (!((_b = message.topic) == null ? void 0 : _b.equals(this._topic))) {
+      (0, import_log4.log)("rejecting offer with incorrect topic", {
+        message
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 239,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    const peer = this._getOrCreatePeer(message.author);
+    const answer = await peer.onOffer(message);
+    this._topology.update();
+    return answer;
+  }
+  async onSignal(message) {
+    var _a, _b;
+    (0, import_log4.log)("signal", {
+      message
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 250,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      import_log4.log.info("ignored for destroyed swarm", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 252,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    (0, import_node_assert4.default)((_a = message.recipient) == null ? void 0 : _a.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`);
+    (0, import_node_assert4.default)((_b = message.topic) == null ? void 0 : _b.equals(this._topic));
+    (0, import_node_assert4.default)(message.author);
+    const peer = this._getOrCreatePeer(message.author);
+    await peer.onSignal(message);
+  }
+  _getSwarmController() {
+    return {
+      getState: () => ({
+        ownPeerId: this._ownPeerId,
+        connected: Array.from(this._peers.values()).filter((peer) => peer.connection).map((peer) => peer.id),
+        candidates: Array.from(this._peers.values()).filter((peer) => !peer.connection && peer.advertizing).map((peer) => peer.id)
+      }),
+      connect: (peer) => {
+        if (this._ctx.disposed) {
+          return;
+        }
+        (0, import_async3.scheduleTask)(this._ctx, async () => {
+          try {
+            await this._initiateConnection(peer);
+          } catch (err) {
+            import_log4.log.warn("initiation error", err, {
+              file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+              line: 287,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+          }
+        });
+      },
+      disconnect: async (peer) => {
+        if (this._ctx.disposed) {
+          return;
+        }
+        (0, import_async3.scheduleTask)(this._ctx, async () => {
+          await this._closeConnection(peer);
+          this._topology.update();
+        });
+      }
+    };
+  }
+  async _initiateConnection(remoteId) {
+    if (remoteId.toHex() < this._ownPeerId.toHex()) {
+      (0, import_log4.log)("initiation delay", {
+        remoteId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+        line: 312,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await (0, import_async3.sleep)(INITIATION_DELAY);
+    }
+    if (this._ctx.disposed) {
+      return;
+    }
+    const peer = this._getOrCreatePeer(remoteId);
+    if (peer.connection) {
+      return;
+    }
+    (0, import_log4.log)("initiating connection...", {
+      remoteId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 326,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await peer.initiateConnection();
+    this._topology.update();
+    (0, import_log4.log)("initiated", {
+      remoteId
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts",
+      line: 329,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async _closeConnection(peerId) {
+    const peer = this._peers.get(peerId);
+    if (!peer) {
+      return;
+    }
+    await peer.closeConnection();
+  }
+};
+__decorate3([
+  import_log4.logInfo
+], Swarm.prototype, "instanceId", void 0);
+__decorate3([
+  import_log4.logInfo
+], Swarm.prototype, "ownPeerId", null);
+__decorate3([
+  import_log4.logInfo
+], Swarm.prototype, "topic", null);
+
+// packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts
+var import_async4 = require("@dxos/async");
+var import_keys4 = require("@dxos/keys");
+var import_log5 = require("@dxos/log");
+var import_util3 = require("@dxos/util");
+var SwarmMapper = class {
+  get peers() {
+    return Array.from(this._peers.values());
+  }
+  constructor(_swarm, _presence) {
+    this._swarm = _swarm;
+    this._presence = _presence;
+    this._subscriptions = new import_async4.EventSubscriptions();
+    this._connectionSubscriptions = new import_util3.ComplexMap(import_keys4.PublicKey.hash);
+    this._peers = new import_util3.ComplexMap(import_keys4.PublicKey.hash);
+    this.mapUpdated = new import_async4.Event();
+    this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
+      this._update();
+      this._connectionSubscriptions.set(connection.remoteId, connection.stateChanged.on(() => {
+        this._update();
+      }));
+    }));
+    this._subscriptions.add(_swarm.disconnected.on((peerId) => {
+      var _a;
+      (_a = this._connectionSubscriptions.get(peerId)) == null ? void 0 : _a();
+      this._connectionSubscriptions.delete(peerId);
+      this._update();
+    }));
+    if (_presence) {
+      this._subscriptions.add(_presence.graphUpdated.on(() => {
+        this._update();
+      }));
+    }
+    this._update();
+  }
+  _update() {
+    (0, import_log5.log)("updating swarm", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts",
+      line: 77,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._peers.clear();
+    this._peers.set(this._swarm.ownPeerId, {
+      id: this._swarm.ownPeerId,
+      state: "ME",
+      connections: []
+    });
+    for (const connection of this._swarm.connections) {
+      this._peers.set(connection.remoteId, {
+        id: connection.remoteId,
+        state: connection.state,
+        connections: [
+          this._swarm.ownPeerId
+        ]
+      });
+    }
+    if (this._presence) {
+      this._presence.graph.forEachNode((node) => {
+        const id = import_keys4.PublicKey.fromHex(node.id);
+        if (this._peers.has(id)) {
+          return;
+        }
+        this._peers.set(id, {
+          id,
+          state: "INDIRECTLY_CONNECTED",
+          connections: []
+        });
+      });
+      this._presence.graph.forEachLink((link) => {
+        const from = import_keys4.PublicKey.from(link.fromId);
+        const to = import_keys4.PublicKey.from(link.toId);
+        if (!from.equals(this._swarm.ownPeerId) && !to.equals(this._swarm.ownPeerId)) {
+          this._peers.get(from).connections.push(to);
+        }
+      });
+    }
+    (0, import_log5.log)("graph changed", {
+      directConnections: this._swarm.connections.length,
+      totalPeersInSwarm: this._peers.size
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts",
+      line: 118,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this.mapUpdated.emit(Array.from(this._peers.values()));
+  }
+  destroy() {
+    Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
+    this._subscriptions.clear();
+  }
+};
+
+// packages/core/mesh/network-manager/src/connection-log.ts
+var EventType;
+(function(EventType2) {
+  EventType2["CONNECTION_STATE_CHANGED"] = "CONNECTION_STATE_CHANGED";
+  EventType2["PROTOCOL_ERROR"] = "PROTOCOL_ERROR";
+  EventType2["PROTOCOL_EXTENSIONS_INITIALIZED"] = "PROTOCOL_EXTENSIONS_INITIALIZED";
+  EventType2["PROTOCOL_EXTENSIONS_HANDSHAKE"] = "PROTOCOL_EXTENSIONS_HANDSHAKE";
+  EventType2["PROTOCOL_HANDSHAKE"] = "PROTOCOL_HANDSHAKE";
+})(EventType || (EventType = {}));
+var ConnectionLog = class {
+  constructor() {
+    this._swarms = new import_util4.ComplexMap(import_keys5.PublicKey.hash);
+    this.update = new import_async5.Event();
+  }
+  getSwarmInfo(swarmId) {
+    var _a;
+    return (_a = this._swarms.get(swarmId)) != null ? _a : (0, import_debug3.raise)(new Error(`Swarm not found: ${swarmId}`));
+  }
+  get swarms() {
+    return Array.from(this._swarms.values());
+  }
+  swarmJoined(swarm) {
+    const info = {
+      id: swarm.instanceId,
+      topic: swarm.topic,
+      isActive: true,
+      label: swarm.label,
+      connections: []
+    };
+    this._swarms.set(swarm.instanceId, info);
+    this.update.emit();
+    swarm.connectionAdded.on((connection) => {
+      var _a, _b, _c, _d, _e;
+      const connectionInfo = {
+        state: ConnectionState.INITIAL,
+        remotePeerId: connection.remoteId,
+        sessionId: connection.sessionId,
+        transport: connection.transport && Object.getPrototypeOf(connection.transport).constructor.name,
+        protocolExtensions: (_a = connection.protocol.protocol) == null ? void 0 : _a.extensionNames,
+        events: []
+      };
+      info.connections.push(connectionInfo);
+      this.update.emit();
+      connection.stateChanged.on((state) => {
+        connectionInfo.state = state;
+        connectionInfo.events.push({
+          type: EventType.CONNECTION_STATE_CHANGED,
+          newState: state
+        });
+        this.update.emit();
+      });
+      (_b = connection.protocol.protocol) == null ? void 0 : _b.error.on((error) => {
+        var _a2;
+        connectionInfo.events.push({
+          type: EventType.PROTOCOL_ERROR,
+          error: (_a2 = error.stack) != null ? _a2 : error.message
+        });
+        this.update.emit();
+      });
+      (_c = connection.protocol.protocol) == null ? void 0 : _c.extensionsInitialized.on(() => {
+        connectionInfo.events.push({
+          type: EventType.PROTOCOL_EXTENSIONS_INITIALIZED
+        });
+        this.update.emit();
+      });
+      (_d = connection.protocol.protocol) == null ? void 0 : _d.extensionsHandshake.on(() => {
+        connectionInfo.events.push({
+          type: EventType.PROTOCOL_EXTENSIONS_HANDSHAKE
+        });
+        this.update.emit();
+      });
+      (_e = connection.protocol.protocol) == null ? void 0 : _e.handshake.on(() => {
+        connectionInfo.events.push({
+          type: EventType.PROTOCOL_HANDSHAKE
+        });
+        this.update.emit();
+      });
+    });
+  }
+  swarmLeft(swarm) {
+    this.getSwarmInfo(swarm.instanceId).isActive = false;
+    this.update.emit();
+  }
+};
+
+// packages/core/mesh/network-manager/src/network-manager.ts
+var NetworkManager = class {
+  constructor({ transportFactory, signalManager, log: log15 }) {
+    this._swarms = new import_util5.ComplexMap(import_keys6.PublicKey.hash);
+    this._mappers = new import_util5.ComplexMap(import_keys6.PublicKey.hash);
+    this.topicsUpdated = new import_async6.Event();
+    this._transportFactory = transportFactory;
+    this._signalManager = signalManager;
+    this._signalManager.swarmEvent.on(({ topic, swarmEvent: event }) => {
+      var _a;
+      return (_a = this._swarms.get(topic)) == null ? void 0 : _a.onSwarmEvent(event);
+    });
+    this._messenger = new import_messaging.Messenger({
+      signalManager: this._signalManager
+    });
+    this._signalConnection = {
+      join: (opts) => this._signalManager.join(opts),
+      leave: (opts) => this._signalManager.leave(opts)
+    };
+    if (log15) {
+      this._connectionLog = new ConnectionLog();
+    }
+  }
+  get connectionLog() {
+    return this._connectionLog;
+  }
+  get signalManager() {
+    return this._signalManager;
+  }
+  get topics() {
+    return Array.from(this._swarms.keys());
+  }
+  getSwarmMap(topic) {
+    return this._mappers.get(topic);
+  }
+  getSwarm(topic) {
+    return this._swarms.get(topic);
+  }
+  async close() {
+    for (const topic of this._swarms.keys()) {
+      await this.leaveSwarm(topic).catch((err) => {
+        (0, import_log6.log)(err, {}, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+          line: 128,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      });
+    }
+    await this._signalManager.destroy();
+  }
+  async joinSwarm({ topic, peerId, topology, protocolProvider: protocol, presence, label }) {
+    var _a;
+    (0, import_node_assert5.default)(import_keys6.PublicKey.isPublicKey(topic));
+    (0, import_node_assert5.default)(import_keys6.PublicKey.isPublicKey(peerId));
+    (0, import_node_assert5.default)(topology);
+    (0, import_node_assert5.default)(typeof protocol === "function");
+    if (this._swarms.has(topic)) {
+      throw new Error(`Already connected to swarm: ${import_keys6.PublicKey.from(topic)}`);
+    }
+    (0, import_log6.log)("joining", {
+      topic: import_keys6.PublicKey.from(topic),
+      peerId,
+      topology: topology.toString()
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+      line: 155,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const swarm = new Swarm(topic, peerId, topology, protocol, this._messenger, this._transportFactory, label);
+    swarm.errors.handle((error) => {
+      (0, import_log6.log)("swarm error", {
+        error
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+        line: 158,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    });
+    this._swarms.set(topic, swarm);
+    this._signalConnection.join({
+      topic,
+      peerId
+    }).catch((error) => import_log6.log.catch(error, {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+      line: 162,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+    this._mappers.set(topic, new SwarmMapper(swarm, presence));
+    this.topicsUpdated.emit();
+    (_a = this._connectionLog) == null ? void 0 : _a.swarmJoined(swarm);
+    (0, import_log6.log)("joined", {
+      topic: import_keys6.PublicKey.from(topic),
+      count: this._swarms.size
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+      line: 167,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return {
+      close: () => this.leaveSwarm(topic)
+    };
+  }
+  async leaveSwarm(topic) {
+    var _a;
+    if (!this._swarms.has(topic)) {
+      import_log6.log.warn("swarm not open", {
+        topic: import_keys6.PublicKey.from(topic)
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+        line: 179,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    (0, import_log6.log)("leaving", {
+      topic: import_keys6.PublicKey.from(topic)
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+      line: 183,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const swarm = this._swarms.get(topic);
+    await this._signalConnection.leave({
+      topic,
+      peerId: swarm.ownPeerId
+    });
+    const map = this._mappers.get(topic);
+    map.destroy();
+    this._mappers.delete(topic);
+    (_a = this._connectionLog) == null ? void 0 : _a.swarmLeft(swarm);
+    await swarm.destroy();
+    this._swarms.delete(topic);
+    await this.topicsUpdated.emit();
+    (0, import_log6.log)("left", {
+      topic: import_keys6.PublicKey.from(topic),
+      count: this._swarms.size
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts",
+      line: 197,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+
+// packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts
+var import_node_assert6 = __toESM(require("node:assert"));
+var FullyConnectedTopology = class {
+  toString() {
+    return "FullyConnectedTopology";
+  }
+  init(controller) {
+    (0, import_node_assert6.default)(!this._controller, "Already initialized");
+    this._controller = controller;
+  }
+  update() {
+    (0, import_node_assert6.default)(this._controller, "Not initialized");
+    const { candidates: discovered } = this._controller.getState();
+    for (const peer of discovered) {
+      this._controller.connect(peer);
+    }
+  }
+  async onOffer(peer) {
+    return true;
+  }
+  async destroy() {
+  }
+};
+
+// packages/core/mesh/network-manager/src/topology/mmst-topology.ts
+var import_xor_distance = __toESM(require("xor-distance"));
+var import_log7 = require("@dxos/log");
+
+// packages/core/mesh/network-manager/src/topology/star-topology.ts
+var import_log8 = require("@dxos/log");
+
+// packages/core/mesh/network-manager/src/transport/memory-transport.ts
+var import_node_assert7 = __toESM(require("node:assert"));
+var import_node_stream = require("node:stream");
+var import_async7 = require("@dxos/async");
+var import_debug4 = require("@dxos/debug");
+var import_keys7 = require("@dxos/keys");
+var import_log9 = require("@dxos/log");
+var import_util6 = require("@dxos/util");
+var MEMORY_TRANSPORT_DELAY = 1;
+var createStreamDelay = (delay) => {
+  return new import_node_stream.Transform({
+    objectMode: true,
+    transform: (chunk, _, cb) => {
+      setTimeout(() => cb(null, chunk), delay);
+    }
+  });
+};
+var MemoryTransportFactory = {
+  createTransport: (params) => new MemoryTransport(params)
+};
+var _MemoryTransport = class {
+  constructor(options) {
+    var _a;
+    this.options = options;
+    this.closed = new import_async7.Event();
+    this.connected = new import_async7.Event();
+    this.errors = new import_debug4.ErrorStream();
+    this._id = import_keys7.PublicKey.random();
+    this._remote = new import_async7.Trigger();
+    this._outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+    this._incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+    this._destroyed = false;
+    (0, import_log9.log)("creating", {
+      id: this._id
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+      line: 59,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    (0, import_node_assert7.default)(!_MemoryTransport._connections.has(this._id), "Duplicate memory connection");
+    _MemoryTransport._connections.set(this._id, this);
+    if (this.options.initiator) {
+      setTimeout(async () => {
+        (0, import_log9.log)("sending signal", {
+          transportId: this._id
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+          line: 68,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        void this.options.sendSignal({
+          payload: {
+            transportId: this._id.toHex()
+          }
+        });
+      });
+    } else {
+      this._remote.wait({
+        timeout: (_a = this.options.timeout) != null ? _a : 1e3
+      }).then((remoteId) => {
+        if (this._destroyed) {
+          return;
+        }
+        this._remoteId = remoteId;
+        this._remoteConnection = _MemoryTransport._connections.get(this._remoteId);
+        if (!this._remoteConnection) {
+          this._destroyed = true;
+          this.closed.emit();
+          return;
+        }
+        (0, import_node_assert7.default)(!this._remoteConnection._remoteConnection, new Error(`Remote already connected: ${this._remoteId}`));
+        this._remoteConnection._remoteConnection = this;
+        this._remoteConnection._remoteId = this._id;
+        (0, import_log9.log)("connected", {
+          id: this._id,
+          remote: this._remoteId
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+          line: 94,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this.options.stream.pipe(this._outgoingDelay).pipe(this._remoteConnection.options.stream).pipe(this._incomingDelay).pipe(this.options.stream);
+        this.connected.emit();
+        this._remoteConnection.connected.emit();
+      }).catch((err) => {
+        if (this._destroyed) {
+          return;
+        }
+        this.errors.raise(err);
+      });
+    }
+  }
+  async destroy() {
+    (0, import_log9.log)("closing", {
+      id: this._id
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+      line: 115,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._destroyed = true;
+    _MemoryTransport._connections.delete(this._id);
+    if (this._remoteConnection) {
+      (0, import_log9.log)("closing", {
+        id: this._remoteId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+        line: 120,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._remoteConnection._destroyed = true;
+      _MemoryTransport._connections.delete(this._remoteId);
+      this._outgoingDelay.unpipe();
+      this._incomingDelay.unpipe();
+      this._remoteConnection.closed.emit();
+      this._remoteConnection._remoteConnection = void 0;
+      this._remoteConnection = void 0;
+      (0, import_log9.log)("closed", {
+        id: this._remoteId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+        line: 138,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    this.closed.emit();
+    (0, import_log9.log)("closed", {
+      id: this._id
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+      line: 142,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  signal(signal) {
+    const { payload: json } = signal;
+    if (json && json.transportId) {
+      const transportId = json.transportId;
+      if (transportId) {
+        const remoteId = import_keys7.PublicKey.fromHex(transportId);
+        (0, import_log9.log)("received signal", {
+          id: this._id,
+          remoteId
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts",
+          line: 152,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this._remote.wake(remoteId);
+      }
+    }
+  }
+};
+var MemoryTransport = _MemoryTransport;
+MemoryTransport._connections = new import_util6.ComplexMap(import_keys7.PublicKey.hash);
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport.ts
+var import_node_assert8 = __toESM(require("node:assert"));
+var import_simple_peer = __toESM(require("simple-peer"));
+var import_async8 = require("@dxos/async");
+var import_debug5 = require("@dxos/debug");
+var import_log10 = require("@dxos/log");
+
+// packages/core/mesh/network-manager/src/transport/webrtc.ts
+var wrtc = null;
+try {
+  wrtc = require("@koush/wrtc");
+} catch (e) {
+}
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport.ts
+var WebRTCTransport = class {
+  constructor(params) {
+    var _a;
+    this.params = params;
+    this.closed = new import_async8.Event();
+    this.connected = new import_async8.Event();
+    this.errors = new import_debug5.ErrorStream();
+    (0, import_log10.log)("created connection", params, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+      line: 34,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._peer = new import_simple_peer.default({
+      initiator: this.params.initiator,
+      wrtc: import_simple_peer.default.WEBRTC_SUPPORT ? void 0 : (_a = wrtc) != null ? _a : (0, import_debug5.raise)(new Error("wrtc not available")),
+      config: this.params.webrtcConfig
+    });
+    this._peer.on("signal", async (data) => {
+      (0, import_log10.log)("signal", data, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+        line: 42,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this.params.sendSignal({
+        payload: {
+          data
+        }
+      });
+    });
+    this._peer.on("connect", () => {
+      (0, import_log10.log)("connected", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+        line: 47,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this.params.stream.pipe(this._peer).pipe(this.params.stream);
+      this.connected.emit();
+    });
+    this._peer.on("close", async () => {
+      (0, import_log10.log)("closed", {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+        line: 53,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this._disconnectStreams();
+      this.closed.emit();
+    });
+    this._peer.on("error", async (err) => {
+      this.errors.raise(err);
+      await this.destroy();
+    });
+  }
+  async destroy() {
+    (0, import_log10.log)("closing...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+      line: 65,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._disconnectStreams();
+    this._peer.destroy();
+    this.closed.emit();
+    (0, import_log10.log)("closed", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport.ts",
+      line: 69,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  signal(signal) {
+    (0, import_node_assert8.default)(this._peer, "Connection not ready to accept signals.");
+    (0, import_node_assert8.default)(signal.payload.data, "Signal message must contain signal data.");
+    this._peer.signal(signal.payload.data);
+  }
+  async _disconnectStreams() {
+    var _a, _b, _c, _d;
+    (_d = (_c = (_b = (_a = this.params.stream).unpipe) == null ? void 0 : _b.call(_a, this._peer)) == null ? void 0 : _c.unpipe) == null ? void 0 : _d.call(_c, this.params.stream);
+  }
+};
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport-service.ts
+var import_node_assert9 = __toESM(require("node:assert"));
+var import_node_stream2 = require("node:stream");
+var import_codec_protobuf = require("@dxos/codec-protobuf");
+var import_keys8 = require("@dxos/keys");
+var import_log11 = require("@dxos/log");
+var import_bridge = require("@dxos/protocols/proto/dxos/mesh/bridge");
+var import_util7 = require("@dxos/util");
+var WebRTCTransportService = class {
+  constructor(_webrtcConfig) {
+    this._webrtcConfig = _webrtcConfig;
+    this.transports = new import_util7.ComplexMap(import_keys8.PublicKey.hash);
+  }
+  open(request) {
+    const rpcStream = new import_codec_protobuf.Stream(({ ready, next, close }) => {
+      const duplex = new import_node_stream2.Duplex({
+        read: () => {
+        },
+        write: function(chunk, _, callback) {
+          next({
+            data: {
+              payload: chunk
+            }
+          });
+          callback();
+        }
+      });
+      const transport = new WebRTCTransport({
+        initiator: request.initiator,
+        stream: duplex,
+        sendSignal: async (signal) => {
+          next({
+            signal: {
+              payload: signal
+            }
+          });
+        }
+      });
+      next({
+        connection: {
+          state: import_bridge.ConnectionState.CONNECTING
+        }
+      });
+      transport.connected.on(() => {
+        next({
+          connection: {
+            state: import_bridge.ConnectionState.CONNECTED
+          }
+        });
+      });
+      transport.errors.handle((err) => {
+        next({
+          connection: {
+            state: import_bridge.ConnectionState.CLOSED,
+            error: err.toString()
+          }
+        });
+        close(err);
+      });
+      transport.closed.on(() => {
+        next({
+          connection: {
+            state: import_bridge.ConnectionState.CLOSED
+          }
+        });
+        close();
+      });
+      ready();
+      this.transports.set(request.proxyId, {
+        transport,
+        stream: duplex
+      });
+    });
+    return rpcStream;
+  }
+  async sendSignal({ proxyId, signal }) {
+    (0, import_node_assert9.default)(this.transports.has(proxyId));
+    await this.transports.get(proxyId).transport.signal(signal);
+  }
+  async sendData({ proxyId, payload }) {
+    (0, import_node_assert9.default)(this.transports.has(proxyId));
+    await this.transports.get(proxyId).stream.push(payload);
+  }
+  async close({ proxyId }) {
+    var _a, _b;
+    await ((_a = this.transports.get(proxyId)) == null ? void 0 : _a.transport.destroy());
+    await ((_b = this.transports.get(proxyId)) == null ? void 0 : _b.stream.end());
+    this.transports.delete(proxyId);
+    (0, import_log11.log)("Closed.", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport-service.ts",
+      line: 108,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts
+var import_node_assert10 = __toESM(require("node:assert"));
+var import_async9 = require("@dxos/async");
+var import_debug6 = require("@dxos/debug");
+var import_keys9 = require("@dxos/keys");
+var import_log12 = require("@dxos/log");
+var import_bridge2 = require("@dxos/protocols/proto/dxos/mesh/bridge");
+var WebRTCTransportProxy = class {
+  constructor(_params) {
+    this._params = _params;
+    this.closed = new import_async9.Event();
+    this._closed = false;
+    this.connected = new import_async9.Event();
+    this.errors = new import_debug6.ErrorStream();
+    this._proxyId = import_keys9.PublicKey.random();
+    this._serviceStream = this._params.bridgeService.open({
+      proxyId: this._proxyId,
+      initiator: this._params.initiator
+    });
+    this._serviceStream.waitUntilReady().then(() => {
+      this._serviceStream.subscribe(async (event) => {
+        (0, import_log12.log)("WebRTCTransportProxy: event", event, {
+          file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts",
+          line: 46,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        if (event.connection) {
+          await this._handleConnection(event.connection);
+        } else if (event.data) {
+          this._handleData(event.data);
+        } else if (event.signal) {
+          await this._handleSignal(event.signal);
+        }
+      });
+      this._params.stream.on("data", async (data) => {
+        try {
+          await this._params.bridgeService.sendData({
+            proxyId: this._proxyId,
+            payload: data
+          });
+        } catch (err) {
+          import_log12.log.catch(err, {}, {
+            file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts",
+            line: 63,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      });
+    }, (error) => import_log12.log.catch(error, {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts",
+      line: 67,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+  }
+  async _handleConnection(connectionEvent) {
+    if (connectionEvent.error) {
+      this.errors.raise(new Error(connectionEvent.error));
+    }
+    switch (connectionEvent.state) {
+      case import_bridge2.ConnectionState.CONNECTED: {
+        this.connected.emit();
+        break;
+      }
+      case import_bridge2.ConnectionState.CLOSED: {
+        await this.destroy();
+        break;
+      }
+    }
+  }
+  _handleData(dataEvent) {
+    this._params.stream.write(Buffer.from(dataEvent.payload));
+  }
+  async _handleSignal(signalEvent) {
+    await this._params.sendSignal(signalEvent.payload);
+  }
+  signal(signal) {
+    this._params.bridgeService.sendSignal({
+      proxyId: this._proxyId,
+      signal
+    }).catch((err) => this.errors.raise(err));
+  }
+  async destroy() {
+    if (this._closed) {
+      return;
+    }
+    this._serviceStream.close();
+    try {
+      await this._params.bridgeService.close({
+        proxyId: this._proxyId
+      });
+    } catch (err) {
+      import_log12.log.catch(err, {}, {
+        file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts",
+        line: 117,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    this.closed.emit();
+    this._closed = true;
+  }
+  forceClose() {
+    this._serviceStream.close();
+    this.closed.emit();
+    this._closed = true;
+  }
+};
+var WebRTCTransportProxyFactory = class {
+  constructor() {
+    this._connections = /* @__PURE__ */ new Set();
+  }
+  setBridgeService(bridgeService) {
+    this._bridgeService = bridgeService;
+    for (const connection of this._connections) {
+      connection.forceClose();
+    }
+    return this;
+  }
+  createTransport(options) {
+    (0, import_node_assert10.default)(this._bridgeService, "WebRTCTransportProxyFactory is not ready to open connections");
+    const transport = new WebRTCTransportProxy({
+      ...options,
+      bridgeService: this._bridgeService
+    });
+    this._connections.add(transport);
+    transport.closed.on(() => this._connections.delete(transport));
+    return transport;
+  }
+};
+
+// packages/core/mesh/network-manager/src/wire-protocol.ts
+var import_crypto = require("@dxos/crypto");
+var import_teleport = require("@dxos/teleport");
+var adaptProtocolProvider = (factory) => ({ initiator, localPeerId, remotePeerId, topic }) => {
+  const protocol = factory({
+    channel: (0, import_crypto.discoveryKey)(topic),
+    initiator
+  });
+  return {
+    initialize: () => protocol.open(),
+    destroy: () => protocol.close(),
+    stream: protocol.stream,
+    protocol
+  };
+};
+
+// packages/core/mesh/network-manager/src/testing/test-protocol.ts
+var import_node_assert12 = __toESM(require("node:assert"));
+var import_node_events = require("node:events");
+var import_keys11 = require("@dxos/keys");
+var import_log14 = require("@dxos/log");
+var import_mesh_protocol2 = require("@dxos/mesh-protocol");
+
+// packages/core/mesh/network-manager/src/protocol-factory.ts
+var import_node_assert11 = __toESM(require("node:assert"));
+var import_crypto2 = require("@dxos/crypto");
+var import_keys10 = require("@dxos/keys");
+var import_log13 = require("@dxos/log");
+var import_mesh_protocol = require("@dxos/mesh-protocol");
+var protocolFactory = ({ session = {}, plugins = [], getTopics }) => {
+  (0, import_node_assert11.default)(getTopics);
+  return ({ channel, initiator }) => {
+    (0, import_log13.log)("creating protocol", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/protocol-factory.ts",
+      line: 41,
+      scope: void 0,
+      callSite: (f, a) => f(...a)
+    });
+    const protocol = new import_mesh_protocol.Protocol({
+      streamOptions: {
+        live: true
+      },
+      discoveryToPublicKey: (dk) => {
+        const publicKey = getTopics().find((topic) => (0, import_crypto2.discoveryKey)(topic).equals(dk));
+        if (publicKey) {
+          protocol.setContext({
+            topic: import_keys10.PublicKey.stringify(publicKey)
+          });
+        }
+        (0, import_node_assert11.default)(publicKey, "PublicKey not found in discovery.");
+        return publicKey;
+      },
+      initiator,
+      userSession: session,
+      discoveryKey: channel
+    });
+    protocol.setExtensions(plugins.map((plugin) => plugin.createExtension())).init();
+    return protocol;
+  };
+};
+
+// packages/core/mesh/network-manager/src/testing/test-protocol.ts
+var EXTENSION_NAME = "test";
+var getPeerId = (protocol) => {
+  var _a;
+  const { peerId } = (_a = protocol.getSession()) != null ? _a : {};
+  if (!peerId) {
+    return void 0;
+  }
+  return import_keys11.PublicKey.bufferize(peerId);
+};
+var testProtocolProvider = (topic, peerId, protocolPlugin) => {
+  (0, import_log14.log)("creating protocol-factory", {
+    topic: import_keys11.PublicKey.from(topic),
+    peerId
+  }, {
+    file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+    line: 34,
+    scope: void 0,
+    callSite: (f, a) => f(...a)
+  });
+  return protocolFactory({
+    getTopics: () => [
+      topic
+    ],
+    session: {
+      peerId: peerId.toHex()
+    },
+    plugins: [
+      protocolPlugin
+    ]
+  });
+};
+var TestProtocolPlugin = class extends import_node_events.EventEmitter {
+  constructor(peerId, uppercase = false) {
+    super();
+    this._peers = /* @__PURE__ */ new Map();
+    this.initCalled = false;
+    (0, import_node_assert12.default)(Buffer.isBuffer(peerId));
+    this._peerId = peerId;
+    this._uppercase = uppercase;
+  }
+  get peerId() {
+    return this._peerId;
+  }
+  get peers() {
+    return Array.from(this._peers.values());
+  }
+  createExtension() {
+    (0, import_log14.log)("creating extension", {
+      peerId: import_keys11.PublicKey.from(this.peerId)
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+      line: 92,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return new import_mesh_protocol2.Extension(EXTENSION_NAME, {
+      binary: true
+    }).setInitHandler(this._init.bind(this)).setMessageHandler(this._receive.bind(this)).setHandshakeHandler(this._onPeerConnect.bind(this)).setCloseHandler(this._onPeerDisconnect.bind(this));
+  }
+  async _init(protocol) {
+    this.initCalled = true;
+  }
+  async send(peerId, payload) {
+    (0, import_node_assert12.default)(Buffer.isBuffer(peerId));
+    const peerIdStr = import_keys11.PublicKey.stringify(peerId);
+    const peer = this._peers.get(peerIdStr);
+    if (!peer) {
+      throw new Error(`peer not found: ${import_keys11.PublicKey.from(peerId).truncate()}`);
+    }
+    const extension = peer.getExtension(EXTENSION_NAME);
+    const encoded = Buffer.from(payload);
+    (0, import_log14.log)("sending", {
+      peerId: import_keys11.PublicKey.from(peerId),
+      payload
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+      line: 124,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return await extension.send(encoded, {
+      oneway: true
+    });
+  }
+  async _receive(protocol, data) {
+    const peerId = getPeerId(protocol);
+    (0, import_node_assert12.default)(peerId !== void 0);
+    let payload = data.data.toString();
+    if (this._uppercase) {
+      payload = payload.toUpperCase();
+    }
+    (0, import_log14.log)("received", {
+      peerId: import_keys11.PublicKey.from(peerId),
+      payload
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+      line: 136,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this.emit("receive", protocol, payload);
+  }
+  async _onPeerConnect(protocol) {
+    (0, import_log14.log)("connecting", {
+      id: import_keys11.PublicKey.from(protocol.id)
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+      line: 141,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const peerId = getPeerId(protocol);
+    if (peerId === void 0) {
+      return;
+    }
+    const peerIdStr = import_keys11.PublicKey.stringify(peerId);
+    if (this._peers.has(peerIdStr)) {
+      return;
+    }
+    this._peers.set(peerIdStr, protocol);
+    this.emit("connect", protocol);
+  }
+  async _onPeerDisconnect(protocol) {
+    (0, import_log14.log)("disconnecting", {
+      id: import_keys11.PublicKey.from(protocol.id)
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-protocol.ts",
+      line: 157,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const peerId = getPeerId(protocol);
+    if (peerId === void 0) {
+      return;
+    }
+    this._peers.delete(import_keys11.PublicKey.stringify(peerId));
+    this.emit("disconnect", peerId);
+  }
+};
+
+// packages/core/mesh/network-manager/src/testing/test-builder.ts
+var TEST_SIGNAL_URL = "ws://localhost:4000/.well-known/dx/signal";
+var TestBuilder = class {
+  constructor(options = {}) {
+    this.options = options;
+    this._signalContext = new import_messaging2.MemorySignalManagerContext();
+  }
+  createSignalManager() {
+    if (this.options.signalHosts) {
+      return new import_messaging2.WebsocketSignalManager(this.options.signalHosts);
+    }
+    return new import_messaging2.MemorySignalManager(this._signalContext);
+  }
+  createPeer() {
+    return new TestPeer(this);
+  }
+};
+var TestPeer = class {
+  constructor(testBuilder) {
+    this.testBuilder = testBuilder;
+    this.peerId = import_keys12.PublicKey.random();
+    this._swarms = new import_util8.ComplexMap(import_keys12.PublicKey.hash);
+    this._networkManager = this.createNetworkManager();
+  }
+  createNetworkManager() {
+    let transportFactory = MemoryTransportFactory;
+    if (this.testBuilder.options.signalHosts) {
+      if (this.testBuilder.options.bridge) {
+        const [proxyPort, servicePort] = (0, import_rpc.createLinkedPorts)();
+        this._proxy = (0, import_rpc.createProtoRpcPeer)({
+          port: proxyPort,
+          requested: {
+            BridgeService: import_protocols2.schema.getService("dxos.mesh.bridge.BridgeService")
+          },
+          noHandshake: true,
+          encodingOptions: {
+            preserveAny: true
+          }
+        });
+        this._service = (0, import_rpc.createProtoRpcPeer)({
+          port: servicePort,
+          exposed: {
+            BridgeService: import_protocols2.schema.getService("dxos.mesh.bridge.BridgeService")
+          },
+          handlers: {
+            BridgeService: new WebRTCTransportService()
+          },
+          noHandshake: true,
+          encodingOptions: {
+            preserveAny: true
+          }
+        });
+        transportFactory = new WebRTCTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
+      } else {
+        transportFactory = {
+          createTransport: (params) => new WebRTCTransport(params)
+        };
+      }
+    }
+    return new NetworkManager({
+      signalManager: this.testBuilder.createSignalManager(),
+      transportFactory
+    });
+  }
+  async open() {
+    var _a, _b;
+    await ((_a = this._proxy) == null ? void 0 : _a.open());
+    await ((_b = this._service) == null ? void 0 : _b.open());
+  }
+  async close() {
+    var _a, _b;
+    await Promise.all(Array.from(this._swarms.values()).map((swarm) => swarm.leave()));
+    this._swarms.clear();
+    await ((_a = this._proxy) == null ? void 0 : _a.close());
+    await ((_b = this._service) == null ? void 0 : _b.close());
+    await this._networkManager.close();
+  }
+  getSwarm(topic) {
+    const swarm = this._swarms.get(topic);
+    if (!swarm) {
+      throw new Error(`Swarm not found for topic: ${topic}`);
+    }
+    return swarm;
+  }
+  createSwarm(topic) {
+    const swarm = new TestSwarmConnection(this, topic);
+    this._swarms.set(topic, swarm);
+    return swarm;
+  }
+};
+var TestSwarmConnection = class {
+  constructor(peer, topic) {
+    this.peer = peer;
+    this.topic = topic;
+    this.plugin = new TestProtocolPlugin(this.peer.peerId.asBuffer());
+  }
+  async join(topology = new FullyConnectedTopology()) {
+    await this.peer._networkManager.joinSwarm({
+      topic: this.topic,
+      peerId: this.peer.peerId,
+      protocolProvider: adaptProtocolProvider(testProtocolProvider(this.topic.asBuffer(), this.peer.peerId, this.plugin)),
+      topology
+    });
+    return this;
+  }
+  async leave() {
+    await this.peer._networkManager.leaveSwarm(this.topic);
+    return this;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TEST_SIGNAL_URL,
+  TestBuilder,
+  TestPeer,
+  TestProtocolPlugin,
+  TestSwarmConnection,
+  getPeerId,
+  testProtocolProvider
+});
+//# sourceMappingURL=index.cjs.map