@dxos/network-manager 0.1.23 → 0.1.24

package/dist/lib/browser/testing/index.mjs

@@ -1,2017 +1,35 @@
 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');
-});
+import {
+  FullyConnectedTopology,
+  MemoryTransportFactory,
+  NetworkManager,
+  WebRTCTransport,
+  WebRTCTransportProxyFactory,
+  WebRTCTransportService,
+  createTeleportProtocolFactory
+} from "../chunk-2TROGP2W.mjs";
 
 // packages/core/mesh/network-manager/src/testing/test-builder.ts
-import { PublicKey as PublicKey11 } from "@dxos/keys";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
 import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from "@dxos/messaging";
-import { schema as schema2 } from "@dxos/protocols";
-import { ConnectionState as ConnectionState5 } from "@dxos/protocols/proto/dxos/client/services";
+import { schema } from "@dxos/protocols";
+import { ConnectionState } from "@dxos/protocols/proto/dxos/client/services";
 import { createLinkedPorts, createProtoRpcPeer } from "@dxos/rpc";
-import { ComplexMap as ComplexMap9 } from "@dxos/util";
-
-// 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";
-
-// 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";
-
-// 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(ConnectionState6) {
-  ConnectionState6[
-    /**
-    * 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";
-  ConnectionState6[
-    /**
-    * Trying to establish connection.
-    */
-    "CONNECTING"
-  ] = "CONNECTING";
-  ConnectionState6[
-    /**
-    * Connection is established.
-    */
-    "CONNECTED"
-  ] = "CONNECTED";
-  ConnectionState6[
-    /**
-    * Connection is being closed.
-    */
-    "CLOSING"
-  ] = "CLOSING";
-  ConnectionState6[
-    /**
-    * 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/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";
+import { ComplexMap as ComplexMap2 } from "@dxos/util";
 
-// packages/core/mesh/network-manager/src/signal/message-router.ts
-import assert2 from "@dxos/node-std/assert";
+// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
+import { asyncTimeout, Event } from "@dxos/async";
 import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { schema } from "@dxos/protocols";
+import { log } from "@dxos/log";
+import { TestExtension } from "@dxos/teleport";
 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/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.warn("ignored for offline 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.info("ignored for offline 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
-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());
-  }
-  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) => {
-      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();
-      });
-    });
-  }
-  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: log14 }) {
-    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 (log14) {
-      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.swarmJoined(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.swarmLeft(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;
-        await Promise.all([
-          ...this._swarms.values()
-        ].map((swarm) => swarm.goOnline()));
-        this._messenger.open();
-        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";
-
-// packages/core/mesh/network-manager/src/topology/star-topology.ts
-import assert8 from "@dxos/node-std/assert";
-import { log as log8 } from "@dxos/log";
-
-// 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);
-  }
-};
-
-// 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/testing/test-wire-protocol.ts
-import { asyncTimeout, Event as Event9 } from "@dxos/async";
-import { PublicKey as PublicKey10 } from "@dxos/keys";
-import { log as log13 } from "@dxos/log";
-import { TestExtension } from "@dxos/teleport";
-import { ComplexMap as ComplexMap8 } from "@dxos/util";
-
-// 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();
-      }
-    };
-  };
-};
-
-// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
 var TestWireProtocol = class {
   constructor(peerId) {
     this.peerId = peerId;
-    this.connections = new ComplexMap8(PublicKey10.hash);
-    this.connected = new Event9();
+    this.connections = new ComplexMap(PublicKey.hash);
+    this.connected = new Event();
     this.factory = createTeleportProtocolFactory(async (teleport) => {
-      log13("create", {
+      log("create", {
         remotePeerId: teleport.remotePeerId
       }, {
         file: "test-wire-protocol.ts",
@@ -2033,7 +51,7 @@ var TestWireProtocol = class {
     if (this.connections.has(peerId)) {
       return this.connections.get(peerId);
     }
-    log13("waitForConnection", {
+    log("waitForConnection", {
       peerId
     }, {
       file: "test-wire-protocol.ts",
@@ -2070,8 +88,8 @@ var TestBuilder = class {
 var TestPeer = class {
   constructor(testBuilder) {
     this.testBuilder = testBuilder;
-    this.peerId = PublicKey11.random();
-    this._swarms = new ComplexMap9(PublicKey11.hash);
+    this.peerId = PublicKey2.random();
+    this._swarms = new ComplexMap2(PublicKey2.hash);
     this._networkManager = this.createNetworkManager();
   }
   // TODO(burdon): Move to TestBuilder.
@@ -2083,7 +101,7 @@ var TestPeer = class {
         this._proxy = createProtoRpcPeer({
           port: proxyPort,
           requested: {
-            BridgeService: schema2.getService("dxos.mesh.bridge.BridgeService")
+            BridgeService: schema.getService("dxos.mesh.bridge.BridgeService")
           },
           noHandshake: true,
           encodingOptions: {
@@ -2093,7 +111,7 @@ var TestPeer = class {
         this._service = createProtoRpcPeer({
           port: servicePort,
           exposed: {
-            BridgeService: schema2.getService("dxos.mesh.bridge.BridgeService")
+            BridgeService: schema.getService("dxos.mesh.bridge.BridgeService")
           },
           handlers: {
             BridgeService: new WebRTCTransportService()
@@ -2141,10 +159,10 @@ var TestPeer = class {
     return swarm;
   }
   async goOffline() {
-    await this._networkManager.setConnectionState(ConnectionState5.OFFLINE);
+    await this._networkManager.setConnectionState(ConnectionState.OFFLINE);
   }
   async goOnline() {
-    await this._networkManager.setConnectionState(ConnectionState5.ONLINE);
+    await this._networkManager.setConnectionState(ConnectionState.ONLINE);
   }
 };
 var TestSwarmConnection = class {