@dxos/network-manager 0.1.23 → 0.1.24

package/dist/lib/browser/chunk-2TROGP2W.mjs

@@ -0,0 +1,2155 @@
+import "@dxos/node-std/globals"
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// packages/core/mesh/network-manager/src/swarm/connection.ts
+import assert from "@dxos/node-std/assert";
+import { Event, synchronized } from "@dxos/async";
+import { ErrorStream } from "@dxos/debug";
+import { log } from "@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(ConnectionState5) {
+  ConnectionState5[
+    /**
+    * Initial state. Connection is registered but no attempt to connect to the remote peer has been performed.
+    * Might mean that we are waiting for the answer signal from the remote peer.
+    */
+    "INITIAL"
+  ] = "INITIAL";
+  ConnectionState5[
+    /**
+    * Trying to establish connection.
+    */
+    "CONNECTING"
+  ] = "CONNECTING";
+  ConnectionState5[
+    /**
+    * Connection is established.
+    */
+    "CONNECTED"
+  ] = "CONNECTED";
+  ConnectionState5[
+    /**
+    * Connection is being closed.
+    */
+    "CLOSING"
+  ] = "CLOSING";
+  ConnectionState5[
+    /**
+    * Connection closed.
+    */
+    "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 Event();
+    this.errors = new ErrorStream();
+  }
+  get state() {
+    return this._state;
+  }
+  get transport() {
+    return this._transport;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  /**
+  * Create an underlying transport and prepares it for the connection.
+  */
+  // TODO(burdon): Make async?
+  openConnection() {
+    assert(this._state === ConnectionState.INITIAL, "Invalid state.");
+    this._changeState(ConnectionState.CONNECTING);
+    this._protocol.initialize().catch((err) => {
+      this.errors.raise(err);
+    });
+    assert(!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.handle((err) => {
+      if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
+        this.errors.raise(err);
+      }
+    });
+    for (const signal of this._bufferedSignals) {
+      void this._transport.signal(signal);
+    }
+    this._bufferedSignals = [];
+  }
+  async close() {
+    var _a;
+    if (this._state === ConnectionState.CLOSED) {
+      return;
+    }
+    this._changeState(ConnectionState.CLOSING);
+    log("closing...", {
+      peerId: this.ownId
+    }, {
+      file: "connection.ts",
+      line: 142,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      await this._protocol.destroy();
+    } catch (err) {
+      log.catch(err, {}, {
+        file: "connection.ts",
+        line: 148,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    try {
+      await ((_a = this._transport) == null ? void 0 : _a.destroy());
+    } catch (err1) {
+      log.catch(err1, {}, {
+        file: "connection.ts",
+        line: 155,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    log("closed", {
+      peerId: this.ownId
+    }, {
+      file: "connection.ts",
+      line: 158,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._changeState(ConnectionState.CLOSED);
+  }
+  async signal(msg) {
+    var _a, _b;
+    assert(msg.sessionId);
+    if (!msg.sessionId.equals(this.sessionId)) {
+      log("dropping signal for incorrect session id", {}, {
+        file: "connection.ts",
+        line: 165,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    assert(msg.data.signal);
+    assert((_a = msg.author) == null ? void 0 : _a.equals(this.remoteId));
+    assert((_b = msg.recipient) == null ? void 0 : _b.equals(this.ownId));
+    if (this._state === ConnectionState.INITIAL) {
+      log("buffered signal", {
+        peerId: this.ownId,
+        remoteId: this.remoteId,
+        msg: msg.data
+      }, {
+        file: "connection.ts",
+        line: 173,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._bufferedSignals.push(msg.data.signal);
+      return;
+    }
+    assert(this._transport, "Connection not ready to accept signals.");
+    log("received signal", {
+      peerId: this.ownId,
+      remoteId: this.remoteId,
+      msg: msg.data
+    }, {
+      file: "connection.ts",
+      line: 179,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._transport.signal(msg.data.signal);
+  }
+  _changeState(state) {
+    assert(state !== this._state, "Already in this state.");
+    this._state = state;
+    this.stateChanged.emit(state);
+  }
+};
+__decorate([
+  synchronized
+], Connection.prototype, "close", null);
+
+// packages/core/mesh/network-manager/src/signal/message-router.ts
+import assert2 from "@dxos/node-std/assert";
+import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { schema } from "@dxos/protocols";
+import { ComplexMap } from "@dxos/util";
+var MessageRouter = class {
+  constructor({ sendMessage, onSignal, onOffer, topic }) {
+    this._offerRecords = new 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 = schema.getCodecForType("dxos.mesh.swarm.SwarmMessage").decode(payload.value);
+    if (!this._topic.equals(message.topic)) {
+      return;
+    }
+    log2("received", {
+      from: author,
+      to: recipient,
+      msg: message
+    }, {
+      file: "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;
+    assert2((_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: 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,
+      // Setting unique message_id if it not specified yet.
+      messageId: (_a = message.messageId) != null ? _a : PublicKey.random()
+    };
+    log2("sending", {
+      from: author,
+      to: recipient,
+      msg: networkMessage
+    }, {
+      file: "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: schema.getCodecForType("dxos.mesh.swarm.SwarmMessage").encode(message)
+      }
+    });
+  }
+  async _resolveAnswers(message) {
+    var _a, _b, _c;
+    assert2((_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);
+      assert2((_c = message.data) == null ? void 0 : _c.answer, "No answer");
+      log2("resolving", {
+        answer: message.data.answer
+      }, {
+        file: "message-router.ts",
+        line: 146,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+  async _handleOffer({ author, recipient, message }) {
+    assert2(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 }) {
+    assert2(message.messageId);
+    assert2(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/swarm.ts
+import assert4 from "@dxos/node-std/assert";
+import { Event as Event2, scheduleTask, sleep, synchronized as synchronized3 } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { ErrorStream as ErrorStream2 } from "@dxos/debug";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
+import { log as log4, logInfo } from "@dxos/log";
+import { ComplexMap as ComplexMap2, isNotNullOrUndefined } from "@dxos/util";
+
+// packages/core/mesh/network-manager/src/swarm/peer.ts
+import assert3 from "@dxos/node-std/assert";
+import { synchronized as synchronized2 } from "@dxos/async";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log3 } from "@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;
+  }
+  /**
+  * Respond to remote offer.
+  */
+  async onOffer(message) {
+    const remoteId = message.author;
+    if (this.connection || this.initiating) {
+      if (remoteId.toHex() < this.localPeerId.toHex()) {
+        log3("closing local connection and accepting remote peer's offer", {
+          id: this.id,
+          topic: this.topic,
+          peerId: this.localPeerId
+        }, {
+          file: "peer.ts",
+          line: 84,
+          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) {
+        assert3(message.sessionId);
+        const connection = this._createConnection(false, message.sessionId);
+        try {
+          connection.openConnection();
+        } catch (err) {
+          log3.warn("connection error", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            err
+          }, {
+            file: "peer.ts",
+            line: 108,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          await this.closeConnection();
+        }
+        return {
+          accept: true
+        };
+      }
+    }
+    return {
+      accept: false
+    };
+  }
+  /**
+  * Initiate a connection to the remote peer.
+  */
+  async initiateConnection() {
+    assert3(!this.initiating, "Initiation in progress.");
+    assert3(!this.connection, "Already connected.");
+    const sessionId = PublicKey2.random();
+    log3("initiating...", {
+      id: this.id,
+      topic: this.topic,
+      peerId: this.id,
+      sessionId
+    }, {
+      file: "peer.ts",
+      line: 126,
+      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: {}
+        }
+      });
+      log3("received", {
+        answer,
+        topic: this.topic,
+        ownId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        file: "peer.ts",
+        line: 138,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      if (connection.state !== ConnectionState.INITIAL) {
+        log3("ignoring response", {}, {
+          file: "peer.ts",
+          line: 140,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (!answer.accept) {
+        this._callbacks.onRejected();
+        return;
+      }
+      connection.openConnection();
+      this._callbacks.onAccepted();
+    } catch (err) {
+      log3.warn("initiation error", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        err
+      }, {
+        file: "peer.ts",
+        line: 151,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this.closeConnection();
+      throw err;
+    } finally {
+      this.initiating = false;
+    }
+  }
+  /**
+  * Create new connection.
+  * Either we're initiating a connection or creating one in response to an offer from the other peer.
+  */
+  _createConnection(initiator, sessionId) {
+    log3("creating connection", {
+      topic: this.topic,
+      peerId: this.localPeerId,
+      remoteId: this.id,
+      initiator,
+      sessionId
+    }, {
+      file: "peer.ts",
+      line: 165,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert3(!this.connection, "Already connected.");
+    const connection = new Connection(
+      this.topic,
+      this.localPeerId,
+      this.id,
+      sessionId,
+      initiator,
+      this._signalMessaging,
+      // TODO(dmaretskyi): Init only when connection is established.
+      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: {
+          log3("connection closed", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            initiator
+          }, {
+            file: "peer.ts",
+            line: 194,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          assert3(this.connection === connection, "Connection mismatch (race condition).");
+          this.connection = void 0;
+          this._callbacks.onDisconnected();
+          break;
+        }
+      }
+    });
+    connection.errors.handle((err) => {
+      log3.warn("connection error", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        initiator,
+        err
+      }, {
+        file: "peer.ts",
+        line: 204,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      void this.closeConnection();
+    });
+    this.connection = connection;
+    return connection;
+  }
+  async closeConnection() {
+    if (!this.connection) {
+      return;
+    }
+    const connection = this.connection;
+    log3("closing...", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      file: "peer.ts",
+      line: 220,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await connection.close();
+    log3("closed", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      file: "peer.ts",
+      line: 226,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async onSignal(message) {
+    if (!this.connection) {
+      log3("dropping signal message for non-existent connection", {
+        message
+      }, {
+        file: "peer.ts",
+        line: 231,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    await this.connection.signal(message);
+  }
+  async destroy() {
+    var _a;
+    log3("Destroying peer", {
+      peerId: this.id,
+      topic: this.topic
+    }, {
+      file: "peer.ts",
+      line: 239,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await ((_a = this == null ? void 0 : this.connection) == null ? void 0 : _a.close());
+  }
+};
+__decorate2([
+  synchronized2
+], 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 {
+  // TODO(burdon): Swarm => Peer.create/destroy =< Connection.open/close
+  // TODO(burdon): Split up properties.
+  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 ComplexMap2(PublicKey3.hash);
+    this._ctx = new Context();
+    this.connectionAdded = new Event2();
+    this.disconnected = new Event2();
+    this.connected = new Event2();
+    this.errors = new ErrorStream2();
+    this.instanceId = PublicKey3.random();
+    log4("creating swarm", {
+      peerId: _ownPeerId
+    }, {
+      file: "swarm.ts",
+      line: 83,
+      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) => log4.catch(error, {}, {
+      file: "swarm.ts",
+      line: 99,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+  }
+  get connections() {
+    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(isNotNullOrUndefined);
+  }
+  get ownPeerId() {
+    return this._ownPeerId;
+  }
+  /**
+  * Custom label assigned to this swarm. Used in devtools to display human-readable names for swarms.
+  */
+  get label() {
+    return this._label;
+  }
+  get topic() {
+    return this._topic;
+  }
+  // TODO(burdon): async open?
+  async destroy() {
+    log4("destroying...", {}, {
+      file: "swarm.ts",
+      line: 127,
+      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)));
+    log4("destroyed", {}, {
+      file: "swarm.ts",
+      line: 131,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async setTopology(topology) {
+    assert4(!this._ctx.disposed, "Swarm is offline");
+    if (topology === this._topology) {
+      return;
+    }
+    log4("setting topology", {
+      previous: getClassName(this._topology),
+      topology: getClassName(topology)
+    }, {
+      file: "swarm.ts",
+      line: 139,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._topology.destroy();
+    this._topology = topology;
+    this._topology.init(this._getSwarmController());
+    this._topology.update();
+  }
+  onSwarmEvent(swarmEvent) {
+    var _a;
+    log4("swarm event", {
+      swarmEvent
+    }, {
+      file: "swarm.ts",
+      line: 152,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      log4("swarm event ignored for disposed swarm", {}, {
+        file: "swarm.ts",
+        line: 155,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (swarmEvent.peerAvailable) {
+      const peerId = PublicKey3.from(swarmEvent.peerAvailable.peer);
+      log4("new peer", {
+        peerId
+      }, {
+        file: "swarm.ts",
+        line: 161,
+        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(PublicKey3.from(swarmEvent.peerLeft.peer));
+      if (peer1) {
+        peer1.advertizing = false;
+        if (((_a = peer1.connection) == null ? void 0 : _a.state) !== ConnectionState.CONNECTED) {
+          void this._destroyPeer(peer1.id).catch((err) => log4.catch(err, {}, {
+            file: "swarm.ts",
+            line: 172,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          }));
+        }
+      }
+    }
+    this._topology.update();
+  }
+  async onOffer(message) {
+    var _a, _b;
+    log4("offer", {
+      message
+    }, {
+      file: "swarm.ts",
+      line: 182,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      log4("ignored for disposed swarm", {}, {
+        file: "swarm.ts",
+        line: 184,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    assert4(message.author);
+    if (!((_a = message.recipient) == null ? void 0 : _a.equals(this._ownPeerId))) {
+      log4("rejecting offer with incorrect peerId", {
+        message
+      }, {
+        file: "swarm.ts",
+        line: 191,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    if (!((_b = message.topic) == null ? void 0 : _b.equals(this._topic))) {
+      log4("rejecting offer with incorrect topic", {
+        message
+      }, {
+        file: "swarm.ts",
+        line: 195,
+        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;
+    log4("signal", {
+      message
+    }, {
+      file: "swarm.ts",
+      line: 207,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      log4.info("ignored for offline swarm", {}, {
+        file: "swarm.ts",
+        line: 209,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    assert4((_a = message.recipient) == null ? void 0 : _a.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`);
+    assert4((_b = message.topic) == null ? void 0 : _b.equals(this._topic));
+    assert4(message.author);
+    const peer = this._getOrCreatePeer(message.author);
+    await peer.onSignal(message);
+  }
+  // For debug purposes
+  async goOffline() {
+    await this._ctx.dispose();
+    await Promise.all([
+      ...this._peers.keys()
+    ].map((peerId) => this._destroyPeer(peerId)));
+  }
+  // For debug purposes
+  async goOnline() {
+    this._ctx = new Context();
+  }
+  _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) {
+    assert4(this._peers.has(peerId));
+    await this._peers.get(peerId).destroy();
+    this._peers.delete(peerId);
+  }
+  _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;
+        }
+        scheduleTask(this._ctx, async () => {
+          try {
+            await this._initiateConnection(peer);
+          } catch (err) {
+            log4.warn("initiation error", err, {
+              file: "swarm.ts",
+              line: 309,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+          }
+        });
+      },
+      disconnect: async (peer) => {
+        if (this._ctx.disposed) {
+          return;
+        }
+        scheduleTask(this._ctx, async () => {
+          await this._closeConnection(peer);
+          this._topology.update();
+        });
+      }
+    };
+  }
+  /**
+  * Creates a connection then sends message over signal network.
+  */
+  async _initiateConnection(remoteId) {
+    const ctx = this._ctx;
+    if (remoteId.toHex() < this._ownPeerId.toHex()) {
+      log4("initiation delay", {
+        remoteId
+      }, {
+        file: "swarm.ts",
+        line: 336,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await sleep(INITIATION_DELAY);
+    }
+    if (ctx.disposed) {
+      return;
+    }
+    const peer = this._getOrCreatePeer(remoteId);
+    if (peer.connection) {
+      return;
+    }
+    log4("initiating connection...", {
+      remoteId
+    }, {
+      file: "swarm.ts",
+      line: 350,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await peer.initiateConnection();
+    this._topology.update();
+    log4("initiated", {
+      remoteId
+    }, {
+      file: "swarm.ts",
+      line: 353,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async _closeConnection(peerId) {
+    const peer = this._peers.get(peerId);
+    if (!peer) {
+      return;
+    }
+    await peer.closeConnection();
+  }
+};
+__decorate3([
+  logInfo
+], Swarm.prototype, "instanceId", void 0);
+__decorate3([
+  logInfo
+], Swarm.prototype, "ownPeerId", null);
+__decorate3([
+  logInfo
+], Swarm.prototype, "topic", null);
+__decorate3([
+  synchronized3
+], Swarm.prototype, "onSwarmEvent", null);
+__decorate3([
+  synchronized3
+], Swarm.prototype, "onOffer", null);
+__decorate3([
+  synchronized3
+], Swarm.prototype, "onSignal", null);
+__decorate3([
+  synchronized3
+], Swarm.prototype, "goOffline", null);
+__decorate3([
+  synchronized3
+], Swarm.prototype, "goOnline", null);
+
+// packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts
+import { Event as Event3, EventSubscriptions } from "@dxos/async";
+import { PublicKey as PublicKey4 } from "@dxos/keys";
+import { log as log5 } from "@dxos/log";
+import { ComplexMap as ComplexMap3 } from "@dxos/util";
+var SwarmMapper = class {
+  get peers() {
+    return Array.from(this._peers.values());
+  }
+  // prettier-ignore
+  constructor(_swarm) {
+    this._swarm = _swarm;
+    this._subscriptions = new EventSubscriptions();
+    this._connectionSubscriptions = new ComplexMap3(PublicKey4.hash);
+    this._peers = new ComplexMap3(PublicKey4.hash);
+    this.mapUpdated = new Event3();
+    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();
+    }));
+    this._update();
+  }
+  _update() {
+    log5("updating swarm", {}, {
+      file: "swarm-mapper.ts",
+      line: 75,
+      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
+        ]
+      });
+    }
+    log5("graph changed", {
+      directConnections: this._swarm.connections.length,
+      totalPeersInSwarm: this._peers.size
+    }, {
+      file: "swarm-mapper.ts",
+      line: 116,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this.mapUpdated.emit(Array.from(this._peers.values()));
+  }
+  // TODO(burdon): Async open/close.
+  destroy() {
+    Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
+    this._subscriptions.clear();
+  }
+};
+
+// packages/core/mesh/network-manager/src/connection-log.ts
+import { Event as Event4 } from "@dxos/async";
+import { raise } from "@dxos/debug";
+import { PublicKey as PublicKey5 } from "@dxos/keys";
+import { ComplexMap as ComplexMap4 } from "@dxos/util";
+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() {
+    /**
+    * SwarmId => info
+    */
+    this._swarms = new ComplexMap4(PublicKey5.hash);
+    this.update = new Event4();
+  }
+  getSwarmInfo(swarmId) {
+    var _a;
+    return (_a = this._swarms.get(swarmId)) != null ? _a : raise(new Error(`Swarm not found: ${swarmId}`));
+  }
+  get swarms() {
+    return Array.from(this._swarms.values());
+  }
+  joinedSwarm(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) => {
+      const connectionInfo = {
+        state: ConnectionState.INITIAL,
+        remotePeerId: connection.remoteId,
+        sessionId: connection.sessionId,
+        transport: connection.transport && Object.getPrototypeOf(connection.transport).constructor.name,
+        protocolExtensions: [],
+        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();
+      });
+    });
+  }
+  leftSwarm(swarm) {
+    this.getSwarmInfo(swarm.instanceId).isActive = false;
+    this.update.emit();
+  }
+};
+
+// packages/core/mesh/network-manager/src/network-manager.ts
+import assert5 from "@dxos/node-std/assert";
+import { Event as Event5 } from "@dxos/async";
+import { PublicKey as PublicKey6 } from "@dxos/keys";
+import { log as log6 } from "@dxos/log";
+import { Messenger } from "@dxos/messaging";
+import { ConnectionState as ConnectionState2 } from "@dxos/protocols/proto/dxos/client/services";
+import { ComplexMap as ComplexMap5 } from "@dxos/util";
+var NetworkManager = class {
+  constructor({ transportFactory, signalManager, log: log13 }) {
+    this._swarms = new ComplexMap5(PublicKey6.hash);
+    this._mappers = new ComplexMap5(PublicKey6.hash);
+    this._connectionState = ConnectionState2.ONLINE;
+    this.connectionStateChanged = new Event5();
+    this.topicsUpdated = new Event5();
+    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 Messenger({
+      signalManager: this._signalManager
+    });
+    this._signalConnection = {
+      join: (opts) => this._signalManager.join(opts),
+      leave: (opts) => this._signalManager.leave(opts)
+    };
+    if (log13) {
+      this._connectionLog = new ConnectionLog();
+    }
+  }
+  // TODO(burdon): Remove access (Devtools only).
+  get connectionLog() {
+    return this._connectionLog;
+  }
+  // TODO(burdon): Remove access (Devtools only).
+  get signalManager() {
+    return this._signalManager;
+  }
+  get connectionState() {
+    return this._connectionState;
+  }
+  // TODO(burdon): Reconcile with "discovery_key".
+  get topics() {
+    return Array.from(this._swarms.keys());
+  }
+  getSwarmMap(topic) {
+    return this._mappers.get(topic);
+  }
+  getSwarm(topic) {
+    return this._swarms.get(topic);
+  }
+  async open() {
+    await this._messenger.open();
+    await this._signalManager.open();
+  }
+  async close() {
+    for (const topic of this._swarms.keys()) {
+      await this.leaveSwarm(topic).catch((err) => {
+        log6(err, {}, {
+          file: "network-manager.ts",
+          line: 136,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      });
+    }
+    await this._messenger.close();
+    await this._signalManager.close();
+  }
+  /**
+  * Join the swarm.
+  */
+  async joinSwarm({ topic, peerId, topology, protocolProvider: protocol, label }) {
+    var _a;
+    assert5(PublicKey6.isPublicKey(topic));
+    assert5(PublicKey6.isPublicKey(peerId));
+    assert5(topology);
+    assert5(typeof protocol === "function");
+    if (this._swarms.has(topic)) {
+      throw new Error(`Already connected to swarm: ${PublicKey6.from(topic)}`);
+    }
+    log6("joining", {
+      topic: PublicKey6.from(topic),
+      peerId,
+      topology: topology.toString()
+    }, {
+      file: "network-manager.ts",
+      line: 162,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const swarm = new Swarm(topic, peerId, topology, protocol, this._messenger, this._transportFactory, label);
+    swarm.errors.handle((error) => {
+      log6("swarm error", {
+        error
+      }, {
+        file: "network-manager.ts",
+        line: 165,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    });
+    this._swarms.set(topic, swarm);
+    this._signalConnection.join({
+      topic,
+      peerId
+    }).catch((error) => log6.catch(error, {}, {
+      file: "network-manager.ts",
+      line: 169,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+    this._mappers.set(topic, new SwarmMapper(swarm));
+    this.topicsUpdated.emit();
+    (_a = this._connectionLog) == null ? void 0 : _a.joinedSwarm(swarm);
+    log6("joined", {
+      topic: PublicKey6.from(topic),
+      count: this._swarms.size
+    }, {
+      file: "network-manager.ts",
+      line: 174,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return {
+      close: () => this.leaveSwarm(topic)
+    };
+  }
+  /**
+  * Close the connection.
+  */
+  async leaveSwarm(topic) {
+    var _a;
+    if (!this._swarms.has(topic)) {
+      log6.warn("swarm not open", {
+        topic: PublicKey6.from(topic).truncate()
+      }, {
+        file: "network-manager.ts",
+        line: 186,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return;
+    }
+    log6("leaving", {
+      topic: PublicKey6.from(topic)
+    }, {
+      file: "network-manager.ts",
+      line: 190,
+      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.leftSwarm(swarm);
+    await swarm.destroy();
+    this._swarms.delete(topic);
+    await this.topicsUpdated.emit();
+    log6("left", {
+      topic: PublicKey6.from(topic),
+      count: this._swarms.size
+    }, {
+      file: "network-manager.ts",
+      line: 204,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async setConnectionState(state) {
+    if (state === this._connectionState) {
+      return;
+    }
+    switch (state) {
+      case ConnectionState2.OFFLINE: {
+        this._connectionState = state;
+        await Promise.all([
+          ...this._swarms.values()
+        ].map((swarm) => swarm.goOffline()));
+        await this._messenger.close();
+        await this._signalManager.close();
+        break;
+      }
+      case ConnectionState2.ONLINE: {
+        this._connectionState = state;
+        this._messenger.open();
+        await Promise.all([
+          ...this._swarms.values()
+        ].map((swarm) => swarm.goOnline()));
+        await this._signalManager.open();
+        break;
+      }
+    }
+    this.connectionStateChanged.emit(this._connectionState);
+  }
+};
+
+// packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts
+import assert6 from "@dxos/node-std/assert";
+var FullyConnectedTopology = class {
+  toString() {
+    return "FullyConnectedTopology";
+  }
+  init(controller) {
+    assert6(!this._controller, "Already initialized");
+    this._controller = controller;
+  }
+  update() {
+    assert6(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
+import assert7 from "@dxos/node-std/assert";
+import distance from "xor-distance";
+import { log as log7 } from "@dxos/log";
+var MMSTTopology = class {
+  constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 } = {}) {
+    this._sampleCollected = false;
+    this._originateConnections = originateConnections;
+    this._maxPeers = maxPeers;
+    this._sampleSize = sampleSize;
+  }
+  init(controller) {
+    assert7(!this._controller, "Already initialized");
+    this._controller = controller;
+  }
+  update() {
+    assert7(this._controller, "Not initialized");
+    const { connected, candidates } = this._controller.getState();
+    if (this._sampleCollected || connected.length > this._maxPeers || candidates.length > 0) {
+      log7("Running the algorithm.", {}, {
+        file: "mmst-topology.ts",
+        line: 55,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._sampleCollected = true;
+      this._runAlgorithm();
+    }
+  }
+  async onOffer(peer) {
+    assert7(this._controller, "Not initialized");
+    const { connected } = this._controller.getState();
+    const accept = connected.length < this._maxPeers;
+    log7(`Offer ${peer} accept=${accept}`, {}, {
+      file: "mmst-topology.ts",
+      line: 65,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return accept;
+  }
+  async destroy() {
+  }
+  _runAlgorithm() {
+    assert7(this._controller, "Not initialized");
+    const { connected, candidates, ownPeerId } = this._controller.getState();
+    if (connected.length > this._maxPeers) {
+      const sorted = sortByXorDistance(connected, ownPeerId).reverse().slice(0, this._maxPeers - connected.length);
+      for (const peer of sorted) {
+        log7(`Disconnect ${peer}.`, {}, {
+          file: "mmst-topology.ts",
+          line: 83,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this._controller.disconnect(peer);
+      }
+    } else if (connected.length < this._originateConnections) {
+      const sample = candidates.sort(() => Math.random() - 0.5).slice(0, this._sampleSize);
+      const sorted1 = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);
+      for (const peer1 of sorted1) {
+        log7(`Connect ${peer1}.`, {}, {
+          file: "mmst-topology.ts",
+          line: 91,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this._controller.connect(peer1);
+      }
+    }
+  }
+  toString() {
+    return "MMSTTopology";
+  }
+};
+var sortByXorDistance = (keys, reference) => keys.sort((a, b) => distance.gt(distance(a.asBuffer(), reference.asBuffer()), distance(b.asBuffer(), reference.asBuffer())));
+
+// packages/core/mesh/network-manager/src/topology/star-topology.ts
+import assert8 from "@dxos/node-std/assert";
+import { log as log8 } from "@dxos/log";
+var StarTopology = class {
+  // prettier-ignore
+  constructor(_centralPeer) {
+    this._centralPeer = _centralPeer;
+  }
+  toString() {
+    return `StarTopology(${this._centralPeer.truncate()})`;
+  }
+  init(controller) {
+    assert8(!this._controller, "Already initialized.");
+    this._controller = controller;
+  }
+  update() {
+    assert8(this._controller, "Not initialized.");
+    const { candidates, connected, ownPeerId } = this._controller.getState();
+    if (!ownPeerId.equals(this._centralPeer)) {
+      log8("leaf peer dropping all connections apart from central peer.", {}, {
+        file: "star-topology.ts",
+        line: 33,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      for (const peer of connected) {
+        if (!peer.equals(this._centralPeer)) {
+          log8("dropping connection", {
+            peer
+          }, {
+            file: "star-topology.ts",
+            line: 38,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          this._controller.disconnect(peer);
+        }
+      }
+    }
+    for (const peer1 of candidates) {
+      if (peer1.equals(this._centralPeer) || ownPeerId.equals(this._centralPeer)) {
+        log8("connecting to peer", {
+          peer: peer1
+        }, {
+          file: "star-topology.ts",
+          line: 47,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this._controller.connect(peer1);
+      }
+    }
+  }
+  async onOffer(peer) {
+    assert8(this._controller, "Not initialized.");
+    const { ownPeerId } = this._controller.getState();
+    log8("offer", {
+      peer,
+      isCentral: peer.equals(this._centralPeer),
+      isSelfCentral: ownPeerId.equals(this._centralPeer)
+    }, {
+      file: "star-topology.ts",
+      line: 56,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);
+  }
+  async destroy() {
+  }
+};
+
+// packages/core/mesh/network-manager/src/transport/memory-transport.ts
+import assert9 from "@dxos/node-std/assert";
+import { Transform } from "@dxos/node-std/stream";
+import { Event as Event6, Trigger } from "@dxos/async";
+import { ErrorStream as ErrorStream3 } from "@dxos/debug";
+import { PublicKey as PublicKey7 } from "@dxos/keys";
+import { log as log9, logInfo as logInfo2 } from "@dxos/log";
+import { ComplexMap as ComplexMap6 } from "@dxos/util";
+var __decorate4 = 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 MEMORY_TRANSPORT_DELAY = 1;
+var createStreamDelay = (delay) => {
+  return new 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 Event6();
+    this.connected = new Event6();
+    this.errors = new ErrorStream3();
+    this._remote = new Trigger();
+    this._outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+    this._incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+    this._destroyed = false;
+    this._instanceId = PublicKey7.random();
+    log9("creating", {}, {
+      file: "memory-transport.ts",
+      line: 64,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert9(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection");
+    _MemoryTransport._connections.set(this._instanceId, this);
+    if (this.options.initiator) {
+      setTimeout(async () => {
+        log9("sending signal", {}, {
+          file: "memory-transport.ts",
+          line: 73,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        void this.options.sendSignal({
+          payload: {
+            transportId: this._instanceId.toHex()
+          }
+        });
+      });
+    } else {
+      this._remote.wait({
+        timeout: (_a = this.options.timeout) != null ? _a : 1e3
+      }).then((remoteId) => {
+        if (this._destroyed) {
+          return;
+        }
+        this._remoteInstanceId = remoteId;
+        this._remoteConnection = _MemoryTransport._connections.get(this._remoteInstanceId);
+        if (!this._remoteConnection) {
+          this._destroyed = true;
+          this.closed.emit();
+          return;
+        }
+        assert9(!this._remoteConnection._remoteConnection, new Error(`Remote already connected: ${this._remoteInstanceId}`));
+        this._remoteConnection._remoteConnection = this;
+        this._remoteConnection._remoteInstanceId = this._instanceId;
+        log9("connected", {}, {
+          file: "memory-transport.ts",
+          line: 102,
+          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() {
+    log9("closing", {}, {
+      file: "memory-transport.ts",
+      line: 123,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._destroyed = true;
+    _MemoryTransport._connections.delete(this._instanceId);
+    if (this._remoteConnection) {
+      log9("closing", {}, {
+        file: "memory-transport.ts",
+        line: 128,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._remoteConnection._destroyed = true;
+      _MemoryTransport._connections.delete(this._remoteInstanceId);
+      this._outgoingDelay.unpipe();
+      this._incomingDelay.unpipe();
+      this._remoteConnection.closed.emit();
+      this._remoteConnection._remoteConnection = void 0;
+      this._remoteConnection = void 0;
+      log9("closed", {}, {
+        file: "memory-transport.ts",
+        line: 146,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    this.closed.emit();
+    log9("closed", {}, {
+      file: "memory-transport.ts",
+      line: 150,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  signal({ payload }) {
+    log9("received signal", {
+      payload
+    }, {
+      file: "memory-transport.ts",
+      line: 154,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (!(payload == null ? void 0 : payload.transportId)) {
+      return;
+    }
+    const transportId = payload.transportId;
+    if (transportId) {
+      const remoteId = PublicKey7.fromHex(transportId);
+      this._remote.wake(remoteId);
+    }
+  }
+};
+var MemoryTransport = _MemoryTransport;
+// TODO(burdon): Remove static properties (inject context into constructor).
+MemoryTransport._connections = new ComplexMap6(PublicKey7.hash);
+__decorate4([
+  logInfo2
+], MemoryTransport.prototype, "_instanceId", void 0);
+__decorate4([
+  logInfo2
+], MemoryTransport.prototype, "_remoteInstanceId", void 0);
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport.ts
+import assert10 from "@dxos/node-std/assert";
+import SimplePeerConstructor from "simple-peer";
+import { Event as Event7 } from "@dxos/async";
+import { ErrorStream as ErrorStream4, raise as raise2 } from "@dxos/debug";
+import { log as log10 } from "@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 = false;
+    this.closed = new Event7();
+    this.connected = new Event7();
+    this.errors = new ErrorStream4();
+    log10("created connection", params, {
+      file: "webrtc-transport.ts",
+      line: 35,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._peer = new SimplePeerConstructor({
+      initiator: this.params.initiator,
+      wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? void 0 : (_a = wrtc) != null ? _a : raise2(new Error("wrtc not available")),
+      config: this.params.webrtcConfig
+    });
+    this._peer.on("signal", async (data) => {
+      log10("signal", data, {
+        file: "webrtc-transport.ts",
+        line: 43,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this.params.sendSignal({
+        payload: {
+          data
+        }
+      });
+    });
+    this._peer.on("connect", () => {
+      log10("connected", {}, {
+        file: "webrtc-transport.ts",
+        line: 48,
+        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 () => {
+      log10("closed", {}, {
+        file: "webrtc-transport.ts",
+        line: 54,
+        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() {
+    log10("closing...", {}, {
+      file: "webrtc-transport.ts",
+      line: 66,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._closed = true;
+    await this._disconnectStreams();
+    this._peer.destroy();
+    this.closed.emit();
+    log10("closed", {}, {
+      file: "webrtc-transport.ts",
+      line: 71,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  signal(signal) {
+    if (this._closed) {
+      return;
+    }
+    assert10(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);
+  }
+};
+var createWebRTCTransportFactory = (webrtcConfig) => ({
+  createTransport: (params) => new WebRTCTransport({
+    ...params,
+    webrtcConfig
+  })
+});
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport-service.ts
+import assert11 from "@dxos/node-std/assert";
+import { Duplex } from "@dxos/node-std/stream";
+import { Stream } from "@dxos/codec-protobuf";
+import { PublicKey as PublicKey8 } from "@dxos/keys";
+import { log as log11 } from "@dxos/log";
+import { ConnectionState as ConnectionState3 } from "@dxos/protocols/proto/dxos/mesh/bridge";
+import { ComplexMap as ComplexMap7 } from "@dxos/util";
+var WebRTCTransportService = class {
+  // prettier-ignore
+  constructor(_webrtcConfig) {
+    this._webrtcConfig = _webrtcConfig;
+    this.transports = new ComplexMap7(PublicKey8.hash);
+  }
+  open(request) {
+    const rpcStream = new Stream(({ ready, next, close }) => {
+      const duplex = new 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: ConnectionState3.CONNECTING
+        }
+      });
+      transport.connected.on(() => {
+        next({
+          connection: {
+            state: ConnectionState3.CONNECTED
+          }
+        });
+      });
+      transport.errors.handle((err) => {
+        next({
+          connection: {
+            state: ConnectionState3.CLOSED,
+            error: err.toString()
+          }
+        });
+        close(err);
+      });
+      transport.closed.on(() => {
+        next({
+          connection: {
+            state: ConnectionState3.CLOSED
+          }
+        });
+        close();
+      });
+      ready();
+      this.transports.set(request.proxyId, {
+        transport,
+        stream: duplex
+      });
+    });
+    return rpcStream;
+  }
+  async sendSignal({ proxyId, signal }) {
+    assert11(this.transports.has(proxyId));
+    await this.transports.get(proxyId).transport.signal(signal);
+  }
+  async sendData({ proxyId, payload }) {
+    assert11(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);
+    log11("Closed.", {}, {
+      file: "webrtc-transport-service.ts",
+      line: 108,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+
+// packages/core/mesh/network-manager/src/transport/webrtc-transport-proxy.ts
+import assert12 from "@dxos/node-std/assert";
+import { Event as Event8 } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { ErrorStream as ErrorStream5 } from "@dxos/debug";
+import { PublicKey as PublicKey9 } from "@dxos/keys";
+import { log as log12 } from "@dxos/log";
+import { ConnectionState as ConnectionState4 } from "@dxos/protocols/proto/dxos/mesh/bridge";
+var WebRTCTransportProxy = class {
+  // prettier-ignore
+  constructor(_params) {
+    this._params = _params;
+    this._proxyId = PublicKey9.random();
+    this._ctx = new Context2();
+    this.closed = new Event8();
+    this._closed = false;
+    this.connected = new Event8();
+    this.errors = new ErrorStream5();
+    this._serviceStream = this._params.bridgeService.open({
+      proxyId: this._proxyId,
+      initiator: this._params.initiator
+    });
+    this._serviceStream.waitUntilReady().then(() => {
+      this._serviceStream.subscribe(async (event) => {
+        log12("WebRTCTransportProxy: event", event, {
+          file: "webrtc-transport-proxy.ts",
+          line: 49,
+          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);
+        }
+      });
+      const dataListener = async (data) => {
+        try {
+          await this._params.bridgeService.sendData({
+            proxyId: this._proxyId,
+            payload: data
+          });
+        } catch (err) {
+          log12.catch(err, {}, {
+            file: "webrtc-transport-proxy.ts",
+            line: 66,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      };
+      this._params.stream.on("data", dataListener);
+      this._ctx.onDispose(() => {
+        this._params.stream.off("data", dataListener);
+      });
+    }, (error) => log12.catch(error, {}, {
+      file: "webrtc-transport-proxy.ts",
+      line: 72,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    }));
+  }
+  async _handleConnection(connectionEvent) {
+    if (connectionEvent.error) {
+      this.errors.raise(new Error(connectionEvent.error));
+    }
+    switch (connectionEvent.state) {
+      case ConnectionState4.CONNECTED: {
+        this.connected.emit();
+        break;
+      }
+      case ConnectionState4.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));
+  }
+  // TODO(burdon): Move open from constructor.
+  async destroy() {
+    await this._ctx.dispose();
+    if (this._closed) {
+      return;
+    }
+    this._serviceStream.close();
+    try {
+      await this._params.bridgeService.close({
+        proxyId: this._proxyId
+      });
+    } catch (err) {
+      log12.catch(err, {}, {
+        file: "webrtc-transport-proxy.ts",
+        line: 123,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    this.closed.emit();
+    this._closed = true;
+  }
+  /**
+  * Called when underlying proxy service becomes unavailable.
+  */
+  // TODO(burdon): Option on close method.
+  forceClose() {
+    this._serviceStream.close();
+    this.closed.emit();
+    this._closed = true;
+  }
+};
+var WebRTCTransportProxyFactory = class {
+  constructor() {
+    this._connections = /* @__PURE__ */ new Set();
+  }
+  /**
+  * Sets the current BridgeService to be used to open connections.
+  * Calling this method will close any existing connections.
+  */
+  setBridgeService(bridgeService) {
+    this._bridgeService = bridgeService;
+    for (const connection of this._connections) {
+      connection.forceClose();
+    }
+    return this;
+  }
+  createTransport(options) {
+    assert12(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
+import { Teleport } from "@dxos/teleport";
+var createTeleportProtocolFactory = (onConnection) => {
+  return (params) => {
+    const teleport = new Teleport(params);
+    return {
+      stream: teleport.stream,
+      initialize: async () => {
+        await teleport.open();
+        await onConnection(teleport);
+      },
+      destroy: async () => {
+        await teleport.close();
+      }
+    };
+  };
+};
+
+export {
+  ConnectionState,
+  Connection,
+  MessageRouter,
+  Swarm,
+  SwarmMapper,
+  EventType,
+  ConnectionLog,
+  NetworkManager,
+  FullyConnectedTopology,
+  MMSTTopology,
+  StarTopology,
+  MemoryTransportFactory,
+  MemoryTransport,
+  WebRTCTransport,
+  createWebRTCTransportFactory,
+  WebRTCTransportService,
+  WebRTCTransportProxy,
+  WebRTCTransportProxyFactory,
+  createTeleportProtocolFactory
+};
+//# sourceMappingURL=chunk-2TROGP2W.mjs.map