@dxos/network-manager 0.3.7 → 0.3.8-main.0ae9c21

package/dist/lib/node/index.cjs

@@ -1,13 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,4253 +15,43 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/core/mesh/network-manager/src/transport/datachannel/rtc-ice-candidate.ts
-var IceCandidate;
-var init_rtc_ice_candidate = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/rtc-ice-candidate.ts"() {
-    "use strict";
-    IceCandidate = class {
-      constructor(init) {
-        if (init.candidate == null) {
-          throw new DOMException("candidate must be specified");
-        }
-        this.candidate = init.candidate;
-        this.sdpMLineIndex = init.sdpMLineIndex ?? null;
-        this.sdpMid = init.sdpMid ?? null;
-        this.usernameFragment = init.usernameFragment ?? null;
-        this.address = null;
-        this.component = null;
-        this.foundation = null;
-        this.port = null;
-        this.priority = null;
-        this.protocol = null;
-        this.relatedAddress = null;
-        this.relatedPort = null;
-        this.tcpType = null;
-        this.type = null;
-      }
-      toJSON() {
-        return {
-          candidate: this.candidate,
-          sdpMLineIndex: this.sdpMLineIndex,
-          sdpMid: this.sdpMid,
-          usernameFragment: this.usernameFragment
-        };
-      }
-    };
-  }
-});
-
-// packages/core/mesh/network-manager/src/transport/datachannel/rtc-data-channel.ts
-var DataChannel;
-var init_rtc_data_channel = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/rtc-data-channel.ts"() {
-    "use strict";
-    DataChannel = class extends EventTarget {
-      constructor(dataChannel, dataChannelDict = {}) {
-        super();
-        this.#dataChannel = dataChannel;
-        this.#readyState = "connecting";
-        this.#bufferedAmountLowThreshold = 0;
-        this.binaryType = "arraybuffer";
-        this.#dataChannel.onOpen(() => {
-          this.#readyState = "open";
-          this.dispatchEvent(new Event("open"));
-        });
-        this.#dataChannel.onClosed(() => {
-          this.#readyState = "closed";
-          this.dispatchEvent(new Event("close"));
-        });
-        this.#dataChannel.onError((msg) => {
-          this.#readyState = "closed";
-          this.dispatchEvent(new RTCErrorEvent("error", {
-            error: new RTCError({
-              errorDetail: "data-channel-failure"
-            }, msg)
-          }));
-        });
-        this.#dataChannel.onBufferedAmountLow(() => {
-          this.dispatchEvent(new Event("bufferedamountlow"));
-        });
-        this.#dataChannel.onMessage((data) => {
-          if (typeof data === "string") {
-            data = Buffer.from(data);
-          }
-          this.dispatchEvent(new MessageEvent("message", {
-            data
-          }));
-        });
-        this.addEventListener("message", (event) => {
-          this.onmessage?.(event);
-        });
-        this.addEventListener("bufferedamountlow", (event) => {
-          this.onbufferedamountlow?.(event);
-        });
-        this.addEventListener("error", (event) => {
-          this.onerror?.(event);
-        });
-        this.addEventListener("close", (event) => {
-          this.onclose?.(event);
-        });
-        this.addEventListener("closing", (event) => {
-          this.onclosing?.(event);
-        });
-        this.addEventListener("open", (event) => {
-          this.onopen?.(event);
-        });
-        this.onbufferedamountlow = null;
-        this.onclose = null;
-        this.onclosing = null;
-        this.onerror = null;
-        this.onmessage = null;
-        this.onopen = null;
-        this.maxPacketLifeTime = dataChannelDict.maxPacketLifeTime ?? null;
-        this.maxRetransmits = dataChannelDict.maxRetransmits ?? null;
-        this.negotiated = dataChannelDict.negotiated ?? false;
-        this.ordered = dataChannelDict.ordered ?? true;
-      }
-      #dataChannel;
-      #bufferedAmountLowThreshold;
-      #readyState;
-      get id() {
-        return this.#dataChannel.getId();
-      }
-      get label() {
-        return this.#dataChannel.getLabel();
-      }
-      get protocol() {
-        return this.#dataChannel.getProtocol();
-      }
-      get bufferedAmount() {
-        return this.#dataChannel.bufferedAmount();
-      }
-      set bufferedAmountLowThreshold(threshold) {
-        this.#bufferedAmountLowThreshold = threshold;
-        this.#dataChannel.setBufferedAmountLowThreshold(threshold);
-      }
-      get bufferedAmountLowThreshold() {
-        return this.#bufferedAmountLowThreshold;
-      }
-      get readyState() {
-        return this.#readyState;
-      }
-      close() {
-        this.#readyState = "closing";
-        this.dispatchEvent(new Event("closing"));
-        this.#dataChannel.close();
-      }
-      send(data) {
-        if (typeof data === "string") {
-          this.#dataChannel.sendMessage(data);
-        } else {
-          this.#dataChannel.sendMessageBinary(data);
-        }
-      }
-    };
-  }
-});
-
-// packages/core/mesh/network-manager/src/transport/datachannel/rtc-events.ts
-var PeerConnectionIceEvent, DataChannelEvent;
-var init_rtc_events = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/rtc-events.ts"() {
-    "use strict";
-    PeerConnectionIceEvent = class extends Event {
-      constructor(candidate) {
-        super("icecandidate");
-        this.candidate = candidate;
-      }
-    };
-    DataChannelEvent = class extends Event {
-      constructor(channel) {
-        super("datachannel");
-        this.channel = channel;
-      }
-    };
-  }
-});
-
-// packages/core/mesh/network-manager/src/transport/datachannel/rtc-session-description.ts
-var SessionDescription;
-var init_rtc_session_description = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/rtc-session-description.ts"() {
-    "use strict";
-    SessionDescription = class {
-      constructor(init) {
-        this.sdp = init.sdp ?? "";
-        this.type = init.type;
-      }
-      toJSON() {
-        return {
-          sdp: this.sdp,
-          type: this.type
-        };
-      }
-    };
-  }
-});
-
-// packages/core/mesh/network-manager/src/transport/datachannel/rtc-peer-connection.ts
-var import_node_datachannel, import_p_defer, PeerConnection, assertState, toSessionDescription, RTCPeerConnectionStates, RTCSdpTypes, RTCIceConnectionStates, RTCIceGatheringStates, RTCSignalingStates;
-var init_rtc_peer_connection = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/rtc-peer-connection.ts"() {
-    "use strict";
-    import_node_datachannel = __toESM(require("node-datachannel"));
-    import_p_defer = __toESM(require("p-defer"));
-    init_rtc_data_channel();
-    init_rtc_events();
-    init_rtc_ice_candidate();
-    init_rtc_session_description();
-    PeerConnection = class extends EventTarget {
-      constructor(init = {}) {
-        super();
-        this.#config = init;
-        this.#localOffer = (0, import_p_defer.default)();
-        this.#localAnswer = (0, import_p_defer.default)();
-        this.#dataChannels = /* @__PURE__ */ new Set();
-        const iceServers = init.iceServers ?? [];
-        this.#peerConnection = new import_node_datachannel.default.PeerConnection(`peer-${Math.random()}`, {
-          iceServers: iceServers.map((server) => {
-            const urls = (Array.isArray(server.urls) ? server.urls : [
-              server.urls
-            ]).map((str) => new URL(str));
-            return urls.map((url) => {
-              const iceServer = {
-                hostname: url.hostname,
-                port: parseInt(url.port, 10),
-                username: server.username,
-                password: server.credential
-              };
-              return iceServer;
-            });
-          }).flat(),
-          iceTransportPolicy: init?.iceTransportPolicy
-        });
-        this.#peerConnection.onStateChange(() => {
-          this.dispatchEvent(new Event("connectionstatechange"));
-        });
-        this.#peerConnection.onGatheringStateChange(() => {
-          this.dispatchEvent(new Event("icegatheringstatechange"));
-        });
-        this.#peerConnection.onDataChannel((channel) => {
-          this.dispatchEvent(new DataChannelEvent(new DataChannel(channel)));
-        });
-        this.addEventListener("connectionstatechange", (event) => {
-          this.onconnectionstatechange?.(event);
-        });
-        this.addEventListener("signalingstatechange", (event) => {
-          this.onsignalingstatechange?.(event);
-        });
-        this.addEventListener("icegatheringstatechange", (event) => {
-          this.onicegatheringstatechange?.(event);
-        });
-        this.addEventListener("datachannel", (event) => {
-          this.ondatachannel?.(event);
-        });
-        this.#peerConnection.onLocalDescription((sdp, type) => {
-          if (type === "offer") {
-            this.#localOffer.resolve({
-              sdp,
-              type
-            });
-          }
-          if (type === "answer") {
-            this.#localAnswer.resolve({
-              sdp,
-              type
-            });
-          }
-        });
-        this.#peerConnection.onLocalCandidate((candidate, mid) => {
-          if (mid === "unspec") {
-            this.#localAnswer.reject(new Error(`Invalid description type ${mid}`));
-            return;
-          }
-          const event = new PeerConnectionIceEvent(new IceCandidate({
-            candidate
-          }));
-          this.onicecandidate?.(event);
-        });
-        this.canTrickleIceCandidates = null;
-        this.sctp = null;
-        this.onconnectionstatechange = null;
-        this.ondatachannel = null;
-        this.onicecandidate = null;
-        this.onicecandidateerror = null;
-        this.oniceconnectionstatechange = null;
-        this.onicegatheringstatechange = null;
-        this.onnegotiationneeded = null;
-        this.onsignalingstatechange = null;
-        this.ontrack = null;
-      }
-      static async generateCertificate(keygenAlgorithm) {
-        throw new Error("Not implemented");
-      }
-      #peerConnection;
-      #config;
-      #localOffer;
-      #localAnswer;
-      #dataChannels;
-      get connectionState() {
-        return assertState(this.#peerConnection.state(), RTCPeerConnectionStates);
-      }
-      get iceConnectionState() {
-        return assertState(this.#peerConnection.state(), RTCIceConnectionStates);
-      }
-      get iceGatheringState() {
-        return assertState(this.#peerConnection.gatheringState(), RTCIceGatheringStates);
-      }
-      get signalingState() {
-        return assertState(this.#peerConnection.signalingState(), RTCSignalingStates);
-      }
-      get currentLocalDescription() {
-        return toSessionDescription(this.#peerConnection.localDescription());
-      }
-      get localDescription() {
-        return toSessionDescription(this.#peerConnection.localDescription());
-      }
-      get pendingLocalDescription() {
-        return toSessionDescription(this.#peerConnection.localDescription());
-      }
-      get currentRemoteDescription() {
-        console.log("node-datachannel doesn't expose currentRemoteDescription");
-        return toSessionDescription(null);
-      }
-      get pendingRemoteDescription() {
-        console.log("node-datachannel doesn't expose pendingRemoteDescription");
-        return toSessionDescription(null);
-      }
-      get remoteDescription() {
-        console.log("node-datachannel doesn't expose remoteDescription");
-        return toSessionDescription(null);
-      }
-      async addIceCandidate(candidate) {
-        if (candidate == null || candidate.candidate == null) {
-          throw new Error("Candidate invalid");
-        }
-        this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid ?? "0");
-      }
-      addTrack(track, ...streams) {
-        throw new Error("addTrack Not implemented");
-      }
-      addTransceiver(trackOrKind, init) {
-        throw new Error("addTransciever Not implemented");
-      }
-      close() {
-        this.#dataChannels.forEach((channel) => {
-          channel.close();
-        });
-        this.#peerConnection.close();
-        this.#peerConnection.destroy();
-      }
-      createDataChannel(label, dataChannelDict = {}) {
-        const channel = this.#peerConnection.createDataChannel(label, dataChannelDict);
-        const dataChannel = new DataChannel(channel, dataChannelDict);
-        this.#dataChannels.add(dataChannel);
-        dataChannel.addEventListener("close", () => {
-          this.#dataChannels.delete(dataChannel);
-        });
-        return dataChannel;
-      }
-      async createOffer(...args) {
-        return this.#localOffer.promise;
-      }
-      async createAnswer(...args) {
-        return this.#localAnswer.promise;
-      }
-      getConfiguration() {
-        return this.#config;
-      }
-      getReceivers() {
-        throw new Error("getReceivers Not implemented");
-      }
-      getSenders() {
-        throw new Error("getSenders Not implemented");
-      }
-      async getStats(selector) {
-        throw new Error("getStats Not implemented");
-      }
-      getTransceivers() {
-        throw new Error("getTranscievers Not implemented");
-      }
-      removeTrack(sender) {
-        throw new Error("removeTrack Not implemented");
-      }
-      restartIce() {
-        throw new Error("restartIce Not implemented");
-      }
-      setConfiguration(configuration = {}) {
-        this.#config = configuration;
-      }
-      async setLocalDescription(description) {
-        if (description == null || description.type == null) {
-          throw new Error("Local description type must be set");
-        }
-        if (description.type !== "offer") {
-          console.log(`node-datachannel: setLocalDescription: only offer is supported, not ${description.type}`);
-          return;
-        }
-        this.#peerConnection.setLocalDescription(description.type);
-      }
-      async setRemoteDescription(description) {
-        if (description.sdp == null) {
-          throw new Error("Remote SDP must be set");
-        }
-        this.#peerConnection.setRemoteDescription(description.sdp, description.type);
-      }
-    };
-    assertState = (state, states) => {
-      if (state != null && !states.includes(state)) {
-        throw new Error(`Invalid value encountered - "${state}" must be one of ${states}`);
-      }
-      return state;
-    };
-    toSessionDescription = (description) => {
-      if (description == null) {
-        return null;
-      }
-      return new SessionDescription({
-        sdp: description.sdp,
-        type: assertState(description.type, RTCSdpTypes)
-      });
-    };
-    RTCPeerConnectionStates = [
-      "closed",
-      "connected",
-      "connecting",
-      "disconnected",
-      "failed",
-      "new"
-    ];
-    RTCSdpTypes = [
-      "answer",
-      "offer",
-      "pranswer",
-      "rollback"
-    ];
-    RTCIceConnectionStates = [
-      "checking",
-      "closed",
-      "completed",
-      "connected",
-      "disconnected",
-      "failed",
-      "new"
-    ];
-    RTCIceGatheringStates = [
-      "complete",
-      "gathering",
-      "new"
-    ];
-    RTCSignalingStates = [
-      "closed",
-      "have-local-offer",
-      "have-local-pranswer",
-      "have-remote-offer",
-      "have-remote-pranswer",
-      "stable"
-    ];
-  }
-});
-
-// packages/core/mesh/network-manager/src/transport/datachannel/index.ts
-var datachannel_exports = {};
-__export(datachannel_exports, {
-  RTCIceCandidate: () => IceCandidate,
-  RTCPeerConnection: () => PeerConnection,
-  RTCSessionDescription: () => SessionDescription,
-  cleanup: () => cleanup
+var node_exports = {};
+__export(node_exports, {
+  Connection: () => import_chunk_PWHTYBOL.Connection,
+  ConnectionLimiter: () => import_chunk_PWHTYBOL.ConnectionLimiter,
+  ConnectionLog: () => import_chunk_PWHTYBOL.ConnectionLog,
+  ConnectionState: () => import_chunk_PWHTYBOL.ConnectionState,
+  EventType: () => import_chunk_PWHTYBOL.EventType,
+  FullyConnectedTopology: () => import_chunk_PWHTYBOL.FullyConnectedTopology,
+  LibDataChannelTransport: () => import_chunk_PWHTYBOL.LibDataChannelTransport,
+  MAX_CONCURRENT_INITIATING_CONNECTIONS: () => import_chunk_PWHTYBOL.MAX_CONCURRENT_INITIATING_CONNECTIONS,
+  MMSTTopology: () => import_chunk_PWHTYBOL.MMSTTopology,
+  MemoryTransport: () => import_chunk_PWHTYBOL.MemoryTransport,
+  MemoryTransportFactory: () => import_chunk_PWHTYBOL.MemoryTransportFactory,
+  NetworkManager: () => import_chunk_PWHTYBOL.NetworkManager,
+  RTCIceCandidate: () => import_chunk_XE5JOIGD.IceCandidate,
+  RTCPeerConnection: () => import_chunk_XE5JOIGD.PeerConnection,
+  RTCSessionDescription: () => import_chunk_XE5JOIGD.SessionDescription,
+  SimplePeerTransport: () => import_chunk_PWHTYBOL.SimplePeerTransport,
+  SimplePeerTransportProxy: () => import_chunk_PWHTYBOL.SimplePeerTransportProxy,
+  SimplePeerTransportProxyFactory: () => import_chunk_PWHTYBOL.SimplePeerTransportProxyFactory,
+  SimplePeerTransportService: () => import_chunk_PWHTYBOL.SimplePeerTransportService,
+  StarTopology: () => import_chunk_PWHTYBOL.StarTopology,
+  Swarm: () => import_chunk_PWHTYBOL.Swarm,
+  SwarmMapper: () => import_chunk_PWHTYBOL.SwarmMapper,
+  SwarmMessenger: () => import_chunk_PWHTYBOL.SwarmMessenger,
+  TcpTransport: () => import_chunk_PWHTYBOL.TcpTransport,
+  TcpTransportFactory: () => import_chunk_PWHTYBOL.TcpTransportFactory,
+  TransportKind: () => import_chunk_PWHTYBOL.TransportKind,
+  cleanup: () => import_chunk_XE5JOIGD.cleanup,
+  createLibDataChannelTransportFactory: () => import_chunk_PWHTYBOL.createLibDataChannelTransportFactory,
+  createSimplePeerTransportFactory: () => import_chunk_PWHTYBOL.createSimplePeerTransportFactory,
+  createTeleportProtocolFactory: () => import_chunk_PWHTYBOL.createTeleportProtocolFactory
 });
-var import_node_datachannel2, cleanup;
-var init_datachannel = __esm({
-  "packages/core/mesh/network-manager/src/transport/datachannel/index.ts"() {
-    "use strict";
-    import_node_datachannel2 = __toESM(require("node-datachannel"));
-    init_rtc_ice_candidate();
-    init_rtc_peer_connection();
-    init_rtc_session_description();
-    cleanup = () => {
-      import_node_datachannel2.default.cleanup();
-    };
-  }
-});
-
-// packages/core/mesh/network-manager/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Connection: () => Connection,
-  ConnectionLimiter: () => ConnectionLimiter,
-  ConnectionLog: () => ConnectionLog,
-  ConnectionState: () => ConnectionState,
-  EventType: () => EventType,
-  FullyConnectedTopology: () => FullyConnectedTopology,
-  LibDataChannelTransport: () => LibDataChannelTransport,
-  MAX_CONCURRENT_INITIATING_CONNECTIONS: () => MAX_CONCURRENT_INITIATING_CONNECTIONS,
-  MMSTTopology: () => MMSTTopology,
-  MemoryTransport: () => MemoryTransport,
-  MemoryTransportFactory: () => MemoryTransportFactory,
-  NetworkManager: () => NetworkManager,
-  RTCIceCandidate: () => IceCandidate,
-  RTCPeerConnection: () => PeerConnection,
-  RTCSessionDescription: () => SessionDescription,
-  SimplePeerTransport: () => SimplePeerTransport,
-  SimplePeerTransportProxy: () => SimplePeerTransportProxy,
-  SimplePeerTransportProxyFactory: () => SimplePeerTransportProxyFactory,
-  SimplePeerTransportService: () => SimplePeerTransportService,
-  StarTopology: () => StarTopology,
-  Swarm: () => Swarm,
-  SwarmMapper: () => SwarmMapper,
-  SwarmMessenger: () => SwarmMessenger,
-  TcpTransport: () => TcpTransport,
-  TcpTransportFactory: () => TcpTransportFactory,
-  TransportKind: () => TransportKind,
-  cleanup: () => cleanup,
-  createLibDataChannelTransportFactory: () => createLibDataChannelTransportFactory,
-  createSimplePeerTransportFactory: () => createSimplePeerTransportFactory,
-  createTeleportProtocolFactory: () => createTeleportProtocolFactory
-});
-module.exports = __toCommonJS(src_exports);
-
-// packages/core/mesh/network-manager/src/connection-log.ts
-var import_async6 = require("@dxos/async");
-var import_debug3 = require("@dxos/debug");
-var import_keys7 = require("@dxos/keys");
-var import_util5 = require("@dxos/util");
-
-// packages/core/mesh/network-manager/src/swarm/connection.ts
-var import_async = require("@dxos/async");
-var import_context = require("@dxos/context");
-var import_debug = require("@dxos/debug");
-var import_invariant = require("@dxos/invariant");
-var import_keys = require("@dxos/keys");
-var import_log = require("@dxos/log");
-var import_protocols = require("@dxos/protocols");
-function _ts_decorate(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 __dxlog_file = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/swarm/connection.ts";
-var STARTING_SIGNALLING_DELAY = 10;
-var TRANSPORT_CONNECTION_TIMEOUT = 1e4;
-var MAX_SIGNALLING_DELAY = 300;
-var ConnectionState;
-(function(ConnectionState5) {
-  ConnectionState5[
-    /**
-    *  Connection is created, but not yet passed through the connection limiter.
-    */
-    "CREATED"
-  ] = "CREATED";
-  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";
-  ConnectionState5["ABORTING"] = "ABORTING";
-  ConnectionState5["ABORTED"] = "ABORTED";
-})(ConnectionState || (ConnectionState = {}));
-var Connection = class {
-  constructor(topic, ownId, remoteId, sessionId, initiator, _signalMessaging, _protocol, _transportFactory, _callbacks) {
-    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._callbacks = _callbacks;
-    this._ctx = new import_context.Context();
-    this.connectedTimeoutContext = new import_context.Context();
-    this._state = ConnectionState.CREATED;
-    this._incomingSignalBuffer = [];
-    this._outgoingSignalBuffer = [];
-    this.stateChanged = new import_async.Event();
-    this.errors = new import_debug.ErrorStream();
-    this._instanceId = import_keys.PublicKey.random().toHex();
-    this._signalSendTask = new import_async.DeferredTask(this._ctx, async () => {
-      await this._flushSignalBuffer();
-    });
-    this._signallingDelay = STARTING_SIGNALLING_DELAY;
-    import_log.log.trace("dxos.mesh.connection.construct", {
-      sessionId: this.sessionId,
-      topic: this.topic,
-      localPeerId: this.ownId,
-      remotePeerId: this.remoteId,
-      initiator: this.initiator
-    }, {
-      F: __dxlog_file,
-      L: 129,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  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.
-  */
-  async openConnection() {
-    (0, import_invariant.invariant)(this._state === ConnectionState.INITIAL, "Invalid state.", {
-      F: __dxlog_file,
-      L: 154,
-      S: this,
-      A: [
-        "this._state === ConnectionState.INITIAL",
-        "'Invalid state.'"
-      ]
-    });
-    import_log.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file,
-      L: 155,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    import_log.log.trace("dxos.mesh.connection.open", {
-      sessionId: this.sessionId,
-      topic: this.topic,
-      localPeerId: this.ownId,
-      remotePeerId: this.remoteId,
-      initiator: this.initiator
-    }, {
-      F: __dxlog_file,
-      L: 156,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._changeState(ConnectionState.CONNECTING);
-    this._protocol.open().catch((err) => {
-      this.errors.raise(err);
-    });
-    this._protocol.stream.on("close", () => {
-      (0, import_log.log)("protocol stream closed", void 0, {
-        F: __dxlog_file,
-        L: 173,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.close(new import_protocols.ProtocolError("protocol stream closed")).catch((err) => this.errors.raise(err));
-    });
-    (0, import_async.scheduleTask)(this.connectedTimeoutContext, async () => {
-      import_log.log.info("timeout waiting for transport to connect, aborting", void 0, {
-        F: __dxlog_file,
-        L: 180,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.abort().catch((err) => this.errors.raise(err));
-    }, TRANSPORT_CONNECTION_TIMEOUT);
-    (0, import_invariant.invariant)(!this._transport, void 0, {
-      F: __dxlog_file,
-      L: 186,
-      S: this,
-      A: [
-        "!this._transport",
-        ""
-      ]
-    });
-    this._transport = this._transportFactory.createTransport({
-      initiator: this.initiator,
-      stream: this._protocol.stream,
-      sendSignal: async (signal) => this._sendSignal(signal)
-    });
-    this._transport.connected.once(async () => {
-      this._changeState(ConnectionState.CONNECTED);
-      await this.connectedTimeoutContext.dispose();
-      this._callbacks?.onConnected?.();
-    });
-    this._transport.closed.once(() => {
-      this._transport = void 0;
-      (0, import_log.log)("abort triggered by transport close", void 0, {
-        F: __dxlog_file,
-        L: 201,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.abort().catch((err) => this.errors.raise(err));
-    });
-    this._transport.errors.handle(async (err) => {
-      (0, import_log.log)("transport error:", {
-        err
-      }, {
-        F: __dxlog_file,
-        L: 206,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (!this.closeReason) {
-        this.closeReason = err?.message;
-      }
-      if (err instanceof import_protocols.ConnectionResetError) {
-        import_log.log.info("aborting due to transport ConnectionResetError", void 0, {
-          F: __dxlog_file,
-          L: 213,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.abort().catch((err2) => this.errors.raise(err2));
-      } else if (err instanceof import_protocols.ConnectivityError) {
-        import_log.log.info("aborting due to transport ConnectivityError", void 0, {
-          F: __dxlog_file,
-          L: 216,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.abort().catch((err2) => this.errors.raise(err2));
-      } else if (err instanceof import_protocols.UnknownProtocolError) {
-        import_log.log.warn("unsure what to do with UnknownProtocolError, will keep on truckin", {
-          err
-        }, {
-          F: __dxlog_file,
-          L: 219,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
-        await this.connectedTimeoutContext.dispose();
-        this.errors.raise(err);
-      }
-    });
-    for (const signal of this._incomingSignalBuffer) {
-      void this._transport.signal(signal);
-    }
-    this._incomingSignalBuffer = [];
-    import_log.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file,
-      L: 235,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async abort(err) {
-    (0, import_log.log)("aborting...", {
-      err
-    }, {
-      F: __dxlog_file,
-      L: 242,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this._state === ConnectionState.CLOSED || this._state === ConnectionState.ABORTED) {
-      (0, import_log.log)(`abort ignored: already ${this._state}`, this.closeReason, {
-        F: __dxlog_file,
-        L: 244,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    await this.connectedTimeoutContext.dispose();
-    this._changeState(ConnectionState.ABORTING);
-    if (!this.closeReason) {
-      this.closeReason = err?.message;
-    }
-    await this._ctx.dispose();
-    try {
-      (0, import_log.log)("aborting protocol... ", void 0, {
-        F: __dxlog_file,
-        L: 258,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this._protocol.abort();
-    } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 261,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    try {
-      await this._transport?.destroy();
-    } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 268,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    try {
-      this._callbacks?.onClosed?.(err);
-    } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 274,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    this._changeState(ConnectionState.ABORTED);
-  }
-  async close(err) {
-    if (!this.closeReason) {
-      this.closeReason = err?.message;
-    } else {
-      this.closeReason += `; ${err?.message}`;
-    }
-    if (this._state === ConnectionState.CLOSED || this._state === ConnectionState.ABORTING || this._state === ConnectionState.ABORTED) {
-      return;
-    }
-    const lastState = this._state;
-    this._changeState(ConnectionState.CLOSING);
-    await this.connectedTimeoutContext.dispose();
-    await this._ctx.dispose();
-    (0, import_log.log)("closing...", {
-      peerId: this.ownId
-    }, {
-      F: __dxlog_file,
-      L: 299,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (lastState === ConnectionState.CONNECTED) {
-      try {
-        await this._protocol.close();
-      } catch (err2) {
-        import_log.log.catch(err2, void 0, {
-          F: __dxlog_file,
-          L: 306,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      try {
-        await this._transport?.destroy();
-      } catch (err2) {
-        import_log.log.catch(err2, void 0, {
-          F: __dxlog_file,
-          L: 313,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-    (0, import_log.log)("closed", {
-      peerId: this.ownId
-    }, {
-      F: __dxlog_file,
-      L: 317,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._changeState(ConnectionState.CLOSED);
-    this._callbacks?.onClosed?.(err);
-  }
-  _sendSignal(signal) {
-    this._outgoingSignalBuffer.push(signal);
-    this._signalSendTask.schedule();
-  }
-  async _flushSignalBuffer() {
-    if (this._outgoingSignalBuffer.length === 0) {
-      return;
-    }
-    try {
-      if (process.env.NODE_ENV !== "test") {
-        await (0, import_context.cancelWithContext)(this._ctx, (0, import_async.sleep)(this._signallingDelay));
-        this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
-      }
-      const signals = [
-        ...this._outgoingSignalBuffer
-      ];
-      this._outgoingSignalBuffer.length = 0;
-      await this._signalMessaging.signal({
-        author: this.ownId,
-        recipient: this.remoteId,
-        sessionId: this.sessionId,
-        topic: this.topic,
-        data: {
-          signalBatch: {
-            signals
-          }
-        }
-      });
-    } catch (err) {
-      if (err instanceof import_protocols.CancelledError || err instanceof Error && err.message?.includes("CANCELLED")) {
-        return;
-      }
-      import_log.log.info("signal message failed to deliver", {
-        err
-      }, {
-        F: __dxlog_file,
-        L: 355,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.close(new import_protocols.ConnectivityError("signal message failed to deliver", err));
-    }
-  }
-  /**
-  * Receive a signal from the remote peer.
-  */
-  async signal(msg) {
-    (0, import_invariant.invariant)(msg.sessionId, void 0, {
-      F: __dxlog_file,
-      L: 364,
-      S: this,
-      A: [
-        "msg.sessionId",
-        ""
-      ]
-    });
-    if (!msg.sessionId.equals(this.sessionId)) {
-      (0, import_log.log)("dropping signal for incorrect session id", void 0, {
-        F: __dxlog_file,
-        L: 366,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    (0, import_invariant.invariant)(msg.data.signal || msg.data.signalBatch, void 0, {
-      F: __dxlog_file,
-      L: 369,
-      S: this,
-      A: [
-        "msg.data.signal || msg.data.signalBatch",
-        ""
-      ]
-    });
-    (0, import_invariant.invariant)(msg.author?.equals(this.remoteId), void 0, {
-      F: __dxlog_file,
-      L: 370,
-      S: this,
-      A: [
-        "msg.author?.equals(this.remoteId)",
-        ""
-      ]
-    });
-    (0, import_invariant.invariant)(msg.recipient?.equals(this.ownId), void 0, {
-      F: __dxlog_file,
-      L: 371,
-      S: this,
-      A: [
-        "msg.recipient?.equals(this.ownId)",
-        ""
-      ]
-    });
-    const signals = msg.data.signalBatch ? msg.data.signalBatch.signals ?? [] : [
-      msg.data.signal
-    ];
-    for (const signal of signals) {
-      if (!signal) {
-        continue;
-      }
-      if ([
-        ConnectionState.CREATED,
-        ConnectionState.INITIAL
-      ].includes(this.state)) {
-        (0, import_log.log)("buffered signal", {
-          peerId: this.ownId,
-          remoteId: this.remoteId,
-          msg: msg.data
-        }, {
-          F: __dxlog_file,
-          L: 380,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._incomingSignalBuffer.push(signal);
-      } else {
-        (0, import_invariant.invariant)(this._transport, "Connection not ready to accept signals.", {
-          F: __dxlog_file,
-          L: 383,
-          S: this,
-          A: [
-            "this._transport",
-            "'Connection not ready to accept signals.'"
-          ]
-        });
-        (0, import_log.log)("received signal", {
-          peerId: this.ownId,
-          remoteId: this.remoteId,
-          msg: msg.data
-        }, {
-          F: __dxlog_file,
-          L: 384,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await this._transport.signal(signal);
-      }
-    }
-  }
-  initiate() {
-    this._changeState(ConnectionState.INITIAL);
-  }
-  _changeState(state) {
-    (0, import_log.log)("stateChanged", {
-      from: this._state,
-      to: state,
-      peerId: this.ownId
-    }, {
-      F: __dxlog_file,
-      L: 395,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant.invariant)(state !== this._state, "Already in this state.", {
-      F: __dxlog_file,
-      L: 396,
-      S: this,
-      A: [
-        "state !== this._state",
-        "'Already in this state.'"
-      ]
-    });
-    this._state = state;
-    this.stateChanged.emit(state);
-  }
-};
-_ts_decorate([
-  import_async.synchronized
-], Connection.prototype, "abort", null);
-_ts_decorate([
-  import_async.synchronized
-], Connection.prototype, "close", null);
-
-// packages/core/mesh/network-manager/src/swarm/swarm.ts
-var import_async3 = require("@dxos/async");
-var import_context4 = require("@dxos/context");
-var import_debug2 = require("@dxos/debug");
-var import_invariant4 = require("@dxos/invariant");
-var import_keys4 = require("@dxos/keys");
-var import_log4 = require("@dxos/log");
-var import_protocols4 = require("@dxos/protocols");
-var import_util2 = require("@dxos/util");
-
-// packages/core/mesh/network-manager/src/swarm/peer.ts
-var import_async2 = require("@dxos/async");
-var import_context2 = require("@dxos/context");
-var import_invariant2 = require("@dxos/invariant");
-var import_keys2 = require("@dxos/keys");
-var import_log2 = require("@dxos/log");
-var import_protocols2 = require("@dxos/protocols");
-function _ts_decorate2(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 __dxlog_file2 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/swarm/peer.ts";
-var ConnectionDisplacedError = class extends import_protocols2.SystemError {
-  constructor() {
-    super("Connection displaced by remote initiator.");
-  }
-};
-var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
-var Peer = class {
-  // TODO(burdon): Convert to map?
-  constructor(id, topic, localPeerId, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
-    this.id = id;
-    this.topic = topic;
-    this.localPeerId = localPeerId;
-    this._signalMessaging = _signalMessaging;
-    this._protocolProvider = _protocolProvider;
-    this._transportFactory = _transportFactory;
-    this._connectionLimiter = _connectionLimiter;
-    this._callbacks = _callbacks;
-    this._availableAfter = 0;
-    this.availableToConnect = true;
-    this._ctx = new import_context2.Context();
-    this.advertizing = false;
-    this.initiating = false;
-    this.connectionDisplaced = new import_async2.Event();
-  }
-  /**
-  * Respond to remote offer.
-  */
-  async onOffer(message) {
-    const remoteId = message.author;
-    if (this.connection && ![
-      ConnectionState.CREATED,
-      ConnectionState.INITIAL,
-      ConnectionState.CONNECTING
-    ].includes(this.connection.state)) {
-      import_log2.log.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
-        F: __dxlog_file2,
-        L: 115,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return {
-        accept: false
-      };
-    }
-    if (this.connection || this.initiating) {
-      if (remoteId.toHex() < this.localPeerId.toHex()) {
-        (0, import_log2.log)("close local connection", {
-          localPeerId: this.id,
-          topic: this.topic,
-          remotePeerId: this.localPeerId,
-          sessionId: this.connection?.sessionId
-        }, {
-          F: __dxlog_file2,
-          L: 124,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (this.connection) {
-          await this.closeConnection(new ConnectionDisplacedError());
-        }
-      } else {
-        return {
-          accept: false
-        };
-      }
-    }
-    if (await this._callbacks.onOffer(remoteId)) {
-      if (!this.connection) {
-        (0, import_invariant2.invariant)(message.sessionId, void 0, {
-          F: __dxlog_file2,
-          L: 144,
-          S: this,
-          A: [
-            "message.sessionId",
-            ""
-          ]
-        });
-        const connection = this._createConnection(false, message.sessionId);
-        try {
-          await this._connectionLimiter.connecting(message.sessionId);
-          connection.initiate();
-          await connection.openConnection();
-        } catch (err) {
-          if (!(err instanceof import_protocols2.CancelledError)) {
-            import_log2.log.info("connection error", {
-              topic: this.topic,
-              peerId: this.localPeerId,
-              remoteId: this.id,
-              err
-            }, {
-              F: __dxlog_file2,
-              L: 154,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-          await this.closeConnection(err);
-        }
-        return {
-          accept: true
-        };
-      }
-    }
-    return {
-      accept: false
-    };
-  }
-  /**
-  * Initiate a connection to the remote peer.
-  */
-  async initiateConnection() {
-    (0, import_invariant2.invariant)(!this.initiating, "Initiation in progress.", {
-      F: __dxlog_file2,
-      L: 171,
-      S: this,
-      A: [
-        "!this.initiating",
-        "'Initiation in progress.'"
-      ]
-    });
-    (0, import_invariant2.invariant)(!this.connection, "Already connected.", {
-      F: __dxlog_file2,
-      L: 172,
-      S: this,
-      A: [
-        "!this.connection",
-        "'Already connected.'"
-      ]
-    });
-    const sessionId = import_keys2.PublicKey.random();
-    (0, import_log2.log)("initiating...", {
-      id: this.id,
-      topic: this.topic,
-      peerId: this.id,
-      sessionId
-    }, {
-      F: __dxlog_file2,
-      L: 174,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const connection = this._createConnection(true, sessionId);
-    this.initiating = true;
-    let answer;
-    try {
-      await this._connectionLimiter.connecting(sessionId);
-      connection.initiate();
-      answer = await this._signalMessaging.offer({
-        author: this.localPeerId,
-        recipient: this.id,
-        sessionId,
-        topic: this.topic,
-        data: {
-          offer: {}
-        }
-      });
-      (0, import_log2.log)("received", {
-        answer,
-        topic: this.topic,
-        ownId: this.localPeerId,
-        remoteId: this.id
-      }, {
-        F: __dxlog_file2,
-        L: 191,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (connection.state !== ConnectionState.INITIAL) {
-        (0, import_log2.log)("ignoring response", void 0, {
-          F: __dxlog_file2,
-          L: 193,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return;
-      }
-    } catch (err) {
-      (0, import_log2.log)("initiation error: send offer", {
-        err,
-        topic: this.topic,
-        peerId: this.localPeerId,
-        remoteId: this.id
-      }, {
-        F: __dxlog_file2,
-        L: 197,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await connection.abort(err);
-      throw err;
-    } finally {
-      this.initiating = false;
-    }
-    try {
-      if (!answer.accept) {
-        this._callbacks.onRejected();
-        return;
-      }
-    } catch (err) {
-      (0, import_log2.log)("initiation error: accept answer", {
-        err,
-        topic: this.topic,
-        peerId: this.localPeerId,
-        remoteId: this.id
-      }, {
-        F: __dxlog_file2,
-        L: 210,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await connection.abort(err);
-      throw err;
-    } finally {
-      this.initiating = false;
-    }
-    try {
-      (0, import_log2.log)("opening connection as initiator", void 0, {
-        F: __dxlog_file2,
-        L: 223,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await connection.openConnection();
-      this._callbacks.onAccepted();
-    } catch (err) {
-      (0, import_log2.log)("initiation error: open connection", {
-        err,
-        topic: this.topic,
-        peerId: this.localPeerId,
-        remoteId: this.id
-      }, {
-        F: __dxlog_file2,
-        L: 227,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      import_log2.log.warn("closing connection due to unhandled error on openConnection", {
-        err
-      }, {
-        F: __dxlog_file2,
-        L: 234,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.closeConnection(err);
-      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) {
-    (0, import_log2.log)("creating connection", {
-      topic: this.topic,
-      peerId: this.localPeerId,
-      remoteId: this.id,
-      initiator,
-      sessionId
-    }, {
-      F: __dxlog_file2,
-      L: 248,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant2.invariant)(!this.connection, "Already connected.", {
-      F: __dxlog_file2,
-      L: 255,
-      S: this,
-      A: [
-        "!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,
-      {
-        onConnected: () => {
-          this.availableToConnect = true;
-          this._lastConnectionTime = Date.now();
-          this._callbacks.onConnected();
-          this._connectionLimiter.doneConnecting(sessionId);
-          import_log2.log.trace("dxos.mesh.connection.connected", {
-            topic: this.topic,
-            localPeerId: this.localPeerId,
-            remotePeerId: this.id,
-            sessionId,
-            initiator
-          }, {
-            F: __dxlog_file2,
-            L: 274,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        },
-        onClosed: (err) => {
-          (0, import_log2.log)("connection closed", {
-            topic: this.topic,
-            peerId: this.localPeerId,
-            remoteId: this.id,
-            initiator
-          }, {
-            F: __dxlog_file2,
-            L: 283,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._connectionLimiter.doneConnecting(sessionId);
-          (0, import_invariant2.invariant)(this.connection === connection, "Connection mismatch (race condition).", {
-            F: __dxlog_file2,
-            L: 288,
-            S: this,
-            A: [
-              "this.connection === connection",
-              "'Connection mismatch (race condition).'"
-            ]
-          });
-          import_log2.log.trace("dxos.mesh.connection.closed", {
-            topic: this.topic,
-            localPeerId: this.localPeerId,
-            remotePeerId: this.id,
-            sessionId,
-            initiator
-          }, {
-            F: __dxlog_file2,
-            L: 290,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          if (err instanceof ConnectionDisplacedError) {
-            this.connectionDisplaced.emit(this.connection);
-          } else {
-            if (this._lastConnectionTime && this._lastConnectionTime + CONNECTION_COUNTS_STABLE_AFTER < Date.now()) {
-              this._availableAfter = 0;
-            } else {
-              this.availableToConnect = false;
-              this._availableAfter = increaseInterval(this._availableAfter);
-            }
-            this._callbacks.onDisconnected();
-            (0, import_async2.scheduleTask)(this._connectionCtx, () => {
-              this.availableToConnect = true;
-              this._callbacks.onPeerAvailable();
-            }, this._availableAfter);
-          }
-          this.connection = void 0;
-        }
-      }
-    );
-    this._callbacks.onInitiated(connection);
-    void this._connectionCtx?.dispose();
-    this._connectionCtx = this._ctx.derive();
-    connection.errors.handle((err) => {
-      import_log2.log.info("connection error, closing", {
-        topic: this.topic,
-        peerId: this.localPeerId,
-        remoteId: this.id,
-        initiator,
-        err
-      }, {
-        F: __dxlog_file2,
-        L: 330,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      import_log2.log.trace("dxos.mesh.connection.error", {
-        topic: this.topic,
-        localPeerId: this.localPeerId,
-        remotePeerId: this.id,
-        sessionId,
-        initiator,
-        err
-      }, {
-        F: __dxlog_file2,
-        L: 337,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      void this.closeConnection(err);
-    });
-    this.connection = connection;
-    return connection;
-  }
-  async closeConnection(err) {
-    if (!this.connection) {
-      return;
-    }
-    const connection = this.connection;
-    (0, import_log2.log)("closing...", {
-      peerId: this.id,
-      sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file2,
-      L: 362,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await connection.close(err);
-    (0, import_log2.log)("closed", {
-      peerId: this.id,
-      sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file2,
-      L: 368,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async onSignal(message) {
-    if (!this.connection) {
-      (0, import_log2.log)("dropping signal message for non-existent connection", {
-        message
-      }, {
-        F: __dxlog_file2,
-        L: 373,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    await this.connection.signal(message);
-  }
-  async destroy(reason) {
-    await this._ctx.dispose();
-    (0, import_log2.log)("Destroying peer", {
-      peerId: this.id,
-      topic: this.topic
-    }, {
-      F: __dxlog_file2,
-      L: 383,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this?.connection?.close(reason);
-  }
-};
-_ts_decorate2([
-  import_async2.synchronized
-], Peer.prototype, "destroy", null);
-var increaseInterval = (interval) => {
-  if (interval === 0) {
-    return 50;
-  } else if (interval < 500) {
-    return 500;
-  } else if (interval < 1e3) {
-    return 1e3;
-  } else if (interval < 5e3) {
-    return 5e3;
-  }
-  return 1e4;
-};
-
-// packages/core/mesh/network-manager/src/signal/swarm-messenger.ts
-var import_context3 = require("@dxos/context");
-var import_invariant3 = require("@dxos/invariant");
-var import_keys3 = require("@dxos/keys");
-var import_log3 = require("@dxos/log");
-var import_protocols3 = require("@dxos/protocols");
-var import_util = require("@dxos/util");
-var __dxlog_file3 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
-var SwarmMessage = import_protocols3.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
-var SwarmMessenger = class {
-  constructor({ sendMessage, onSignal, onOffer, topic }) {
-    this._ctx = new import_context3.Context();
-    this._offerRecords = new import_util.ComplexMap((key) => key.toHex());
-    this._sendMessage = sendMessage;
-    this._onSignal = onSignal;
-    this._onOffer = onOffer;
-    this._topic = topic;
-  }
-  async receiveMessage({ author, recipient, payload }) {
-    if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
-      return;
-    }
-    const message = SwarmMessage.decode(payload.value);
-    if (!this._topic.equals(message.topic)) {
-      return;
-    }
-    (0, import_log3.log)("received", {
-      from: author,
-      to: recipient,
-      msg: message
-    }, {
-      F: __dxlog_file3,
-      L: 69,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (message.data?.offer) {
-      await this._handleOffer({
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.answer) {
-      await this._resolveAnswers(message);
-    } else if (message.data?.signal) {
-      await this._handleSignal({
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.signalBatch) {
-      await this._handleSignal({
-        author,
-        recipient,
-        message
-      });
-    } else {
-      import_log3.log.warn("unknown message", {
-        message
-      }, {
-        F: __dxlog_file3,
-        L: 80,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  async signal(message) {
-    (0, import_invariant3.invariant)(message.data?.signal || message.data?.signalBatch, "Invalid message", {
-      F: __dxlog_file3,
-      L: 85,
-      S: this,
-      A: [
-        "message.data?.signal || message.data?.signalBatch",
-        "'Invalid message'"
-      ]
-    });
-    await this._sendReliableMessage({
-      author: message.author,
-      recipient: message.recipient,
-      message
-    });
-  }
-  async offer(message) {
-    const networkMessage = {
-      ...message,
-      messageId: import_keys3.PublicKey.random()
-    };
-    return new Promise((resolve, reject) => {
-      this._offerRecords.set(networkMessage.messageId, {
-        resolve
-      });
-      this._sendReliableMessage({
-        author: message.author,
-        recipient: message.recipient,
-        message: networkMessage
-      }).catch((err) => reject(err));
-    });
-  }
-  async _sendReliableMessage({ author, recipient, message }) {
-    const networkMessage = {
-      ...message,
-      // Setting unique message_id if it not specified yet.
-      messageId: message.messageId ?? import_keys3.PublicKey.random()
-    };
-    (0, import_log3.log)("sending", {
-      from: author,
-      to: recipient,
-      msg: networkMessage
-    }, {
-      F: __dxlog_file3,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._sendMessage({
-      author,
-      recipient,
-      payload: {
-        type_url: "dxos.mesh.swarm.SwarmMessage",
-        value: SwarmMessage.encode(networkMessage)
-      }
-    });
-  }
-  async _resolveAnswers(message) {
-    (0, import_invariant3.invariant)(message.data?.answer?.offerMessageId, "No offerMessageId", {
-      F: __dxlog_file3,
-      L: 135,
-      S: this,
-      A: [
-        "message.data?.answer?.offerMessageId",
-        "'No offerMessageId'"
-      ]
-    });
-    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
-    if (offerRecord) {
-      this._offerRecords.delete(message.data.answer.offerMessageId);
-      (0, import_invariant3.invariant)(message.data?.answer, "No answer", {
-        F: __dxlog_file3,
-        L: 139,
-        S: this,
-        A: [
-          "message.data?.answer",
-          "'No answer'"
-        ]
-      });
-      (0, import_log3.log)("resolving", {
-        answer: message.data.answer
-      }, {
-        F: __dxlog_file3,
-        L: 140,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      offerRecord.resolve(message.data.answer);
-    }
-  }
-  async _handleOffer({ author, recipient, message }) {
-    (0, import_invariant3.invariant)(message.data.offer, "No offer", {
-      F: __dxlog_file3,
-      L: 154,
-      S: this,
-      A: [
-        "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;
-    try {
-      await this._sendReliableMessage({
-        author: recipient,
-        recipient: author,
-        message: {
-          topic: message.topic,
-          sessionId: message.sessionId,
-          data: {
-            answer
-          }
-        }
-      });
-    } catch (err) {
-      if (err instanceof import_protocols3.TimeoutError) {
-        import_log3.log.info("timeout sending answer to offer", {
-          err
-        }, {
-          F: __dxlog_file3,
-          L: 175,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      } else {
-        import_log3.log.info("error sending answer to offer", {
-          err
-        }, {
-          F: __dxlog_file3,
-          L: 177,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-  }
-  async _handleSignal({ author, recipient, message }) {
-    (0, import_invariant3.invariant)(message.messageId, void 0, {
-      F: __dxlog_file3,
-      L: 191,
-      S: this,
-      A: [
-        "message.messageId",
-        ""
-      ]
-    });
-    (0, import_invariant3.invariant)(message.data.signal || message.data.signalBatch, "Invalid message", {
-      F: __dxlog_file3,
-      L: 192,
-      S: this,
-      A: [
-        "message.data.signal || message.data.signalBatch",
-        "'Invalid message'"
-      ]
-    });
-    const signalMessage = {
-      author,
-      recipient,
-      ...message,
-      data: {
-        signal: message.data.signal,
-        signalBatch: message.data.signalBatch
-      }
-    };
-    await this._onSignal(signalMessage);
-  }
-};
-
-// packages/core/mesh/network-manager/src/swarm/swarm.ts
-function _ts_decorate3(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 __dxlog_file4 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/swarm/swarm.ts";
-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, _connectionLimiter, _initiationDelay = INITIATION_DELAY) {
-    this._topic = _topic;
-    this._ownPeerId = _ownPeerId;
-    this._topology = _topology;
-    this._protocolProvider = _protocolProvider;
-    this._messenger = _messenger;
-    this._transportFactory = _transportFactory;
-    this._label = _label;
-    this._connectionLimiter = _connectionLimiter;
-    this._initiationDelay = _initiationDelay;
-    this._ctx = new import_context4.Context();
-    this._listeningHandle = void 0;
-    this._peers = new import_util2.ComplexMap(import_keys4.PublicKey.hash);
-    this._instanceId = import_keys4.PublicKey.random().toHex();
-    this.connectionAdded = new import_async3.Event();
-    this.disconnected = new import_async3.Event();
-    this.connected = new import_async3.Event();
-    this.errors = new import_debug2.ErrorStream();
-    import_log4.log.trace("dxos.mesh.swarm.constructor", import_protocols4.trace.begin({
-      id: this._instanceId,
-      data: {
-        topic: this._topic.toHex(),
-        peerId: this._ownPeerId.toHex()
-      }
-    }), {
-      F: __dxlog_file4,
-      L: 88,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_log4.log)("creating swarm", {
-      peerId: _ownPeerId
-    }, {
-      F: __dxlog_file4,
-      L: 92,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    _topology.init(this._getSwarmController());
-    this._swarmMessenger = new SwarmMessenger({
-      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
-    });
-    import_log4.log.trace("dxos.mesh.swarm.constructor", import_protocols4.trace.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file4,
-      L: 101,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  get connections() {
-    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(import_util2.isNotNullOrUndefined);
-  }
-  get ownPeerId() {
-    return this._ownPeerId;
-  }
-  /**
-  * 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;
-  }
-  async open() {
-    (0, import_invariant4.invariant)(!this._listeningHandle, void 0, {
-      F: __dxlog_file4,
-      L: 128,
-      S: this,
-      A: [
-        "!this._listeningHandle",
-        ""
-      ]
-    });
-    this._listeningHandle = await this._messenger.listen({
-      peerId: this._ownPeerId,
-      payloadType: "dxos.mesh.swarm.SwarmMessage",
-      onMessage: async (message) => {
-        await this._swarmMessenger.receiveMessage(message).catch((err) => import_log4.log.info("Error while receiving message", {
-          err
-        }, {
-          F: __dxlog_file4,
-          L: 136,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
-      }
-    });
-  }
-  async destroy() {
-    (0, import_log4.log)("destroying...", void 0, {
-      F: __dxlog_file4,
-      L: 142,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._listeningHandle?.unsubscribe();
-    this._listeningHandle = void 0;
-    await this._ctx.dispose();
-    await this._topology.destroy();
-    await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key, "swarm destroyed")));
-    (0, import_log4.log)("destroyed", void 0, {
-      F: __dxlog_file4,
-      L: 149,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async setTopology(topology) {
-    (0, import_invariant4.invariant)(!this._ctx.disposed, "Swarm is offline", {
-      F: __dxlog_file4,
-      L: 153,
-      S: this,
-      A: [
-        "!this._ctx.disposed",
-        "'Swarm is offline'"
-      ]
-    });
-    if (topology === this._topology) {
-      return;
-    }
-    (0, import_log4.log)("setting topology", {
-      previous: getClassName(this._topology),
-      topology: getClassName(topology)
-    }, {
-      F: __dxlog_file4,
-      L: 157,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._topology.destroy();
-    this._topology = topology;
-    this._topology.init(this._getSwarmController());
-    this._topology.update();
-  }
-  onSwarmEvent(swarmEvent) {
-    (0, import_log4.log)("swarm event", {
-      swarmEvent
-    }, {
-      F: __dxlog_file4,
-      L: 170,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this._ctx.disposed) {
-      (0, import_log4.log)("swarm event ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
-        L: 173,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    if (swarmEvent.peerAvailable) {
-      const peerId = import_keys4.PublicKey.from(swarmEvent.peerAvailable.peer);
-      (0, import_log4.log)("new peer", {
-        peerId
-      }, {
-        F: __dxlog_file4,
-        L: 179,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (!peerId.equals(this._ownPeerId)) {
-        const peer = this._getOrCreatePeer(peerId);
-        peer.advertizing = true;
-      }
-    } else if (swarmEvent.peerLeft) {
-      const peer = this._peers.get(import_keys4.PublicKey.from(swarmEvent.peerLeft.peer));
-      if (peer) {
-        peer.advertizing = false;
-        if (peer.connection?.state !== ConnectionState.CONNECTED) {
-          void this._destroyPeer(peer.id, "peer left").catch((err) => import_log4.log.catch(err, void 0, {
-            F: __dxlog_file4,
-            L: 190,
-            S: this,
-            C: (f, a) => f(...a)
-          }));
-        }
-      } else {
-        (0, import_log4.log)("received peerLeft but no peer found", {
-          peer: swarmEvent.peerLeft.peer
-        }, {
-          F: __dxlog_file4,
-          L: 193,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-    this._topology.update();
-  }
-  async onOffer(message) {
-    (0, import_log4.log)("offer", {
-      message
-    }, {
-      F: __dxlog_file4,
-      L: 202,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this._ctx.disposed) {
-      (0, import_log4.log)("ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
-        L: 204,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return {
-        accept: false
-      };
-    }
-    (0, import_invariant4.invariant)(message.author, void 0, {
-      F: __dxlog_file4,
-      L: 209,
-      S: this,
-      A: [
-        "message.author",
-        ""
-      ]
-    });
-    if (!message.recipient?.equals(this._ownPeerId)) {
-      (0, import_log4.log)("rejecting offer with incorrect peerId", {
-        message
-      }, {
-        F: __dxlog_file4,
-        L: 211,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return {
-        accept: false
-      };
-    }
-    if (!message.topic?.equals(this._topic)) {
-      (0, import_log4.log)("rejecting offer with incorrect topic", {
-        message
-      }, {
-        F: __dxlog_file4,
-        L: 215,
-        S: this,
-        C: (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) {
-    (0, import_log4.log)("signal", {
-      message
-    }, {
-      F: __dxlog_file4,
-      L: 226,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this._ctx.disposed) {
-      import_log4.log.info("ignored for offline swarm", void 0, {
-        F: __dxlog_file4,
-        L: 228,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    (0, import_invariant4.invariant)(message.recipient?.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, {
-      F: __dxlog_file4,
-      L: 231,
-      S: this,
-      A: [
-        "message.recipient?.equals(this._ownPeerId)",
-        "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"
-      ]
-    });
-    (0, import_invariant4.invariant)(message.topic?.equals(this._topic), void 0, {
-      F: __dxlog_file4,
-      L: 235,
-      S: this,
-      A: [
-        "message.topic?.equals(this._topic)",
-        ""
-      ]
-    });
-    (0, import_invariant4.invariant)(message.author, void 0, {
-      F: __dxlog_file4,
-      L: 236,
-      S: this,
-      A: [
-        "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, "goOffline")));
-  }
-  // For debug purposes
-  async goOnline() {
-    this._ctx = new import_context4.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, this._connectionLimiter, {
-        onInitiated: (connection) => {
-          this.connectionAdded.emit(connection);
-        },
-        onConnected: () => {
-          this.connected.emit(peerId);
-        },
-        onDisconnected: async () => {
-          if (!peer.advertizing) {
-            await this._destroyPeer(peer.id, "peer disconnected");
-          }
-          this.disconnected.emit(peerId);
-          this._topology.update();
-        },
-        onRejected: () => {
-          if (this._peers.has(peerId)) {
-            (0, import_log4.log)("peer rejected connection", {
-              peerId
-            }, {
-              F: __dxlog_file4,
-              L: 285,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            void this._destroyPeer(peerId, "peer rejected connection");
-          }
-        },
-        onAccepted: () => {
-          this._topology.update();
-        },
-        onOffer: (remoteId) => {
-          return this._topology.onOffer(remoteId);
-        },
-        onPeerAvailable: () => {
-          this._topology.update();
-        }
-      });
-      this._peers.set(peerId, peer);
-    }
-    return peer;
-  }
-  async _destroyPeer(peerId, reason) {
-    (0, import_invariant4.invariant)(this._peers.has(peerId), void 0, {
-      F: __dxlog_file4,
-      L: 307,
-      S: this,
-      A: [
-        "this._peers.has(peerId)",
-        ""
-      ]
-    });
-    await this._peers.get(peerId).destroy(new Error(reason));
-    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 && peer.availableToConnect).map((peer) => peer.id)
-      }),
-      connect: (peer) => {
-        if (this._ctx.disposed) {
-          return;
-        }
-        (0, import_async3.scheduleTask)(this._ctx, async () => {
-          try {
-            await this._initiateConnection(peer);
-          } catch (err) {
-            (0, import_log4.log)("initiation error", err, {
-              F: __dxlog_file4,
-              L: 333,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-        });
-      },
-      disconnect: async (peer) => {
-        if (this._ctx.disposed) {
-          return;
-        }
-        (0, import_async3.scheduleTask)(this._ctx, async () => {
-          await this._closeConnection(peer);
-          this._topology.update();
-        });
-      }
-    };
-  }
-  /**
-  * Creates a connection then sends message over signal network.
-  */
-  async _initiateConnection(remoteId) {
-    const ctx = this._ctx;
-    if (remoteId.toHex() < this._ownPeerId.toHex()) {
-      (0, import_log4.log)("initiation delay", {
-        remoteId
-      }, {
-        F: __dxlog_file4,
-        L: 360,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await (0, import_async3.sleep)(this._initiationDelay);
-    }
-    if (ctx.disposed) {
-      return;
-    }
-    const peer = this._getOrCreatePeer(remoteId);
-    if (peer.connection) {
-      return;
-    }
-    (0, import_log4.log)("initiating connection...", {
-      remoteId
-    }, {
-      F: __dxlog_file4,
-      L: 374,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await peer.initiateConnection();
-    this._topology.update();
-    (0, import_log4.log)("initiated", {
-      remoteId
-    }, {
-      F: __dxlog_file4,
-      L: 377,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async _closeConnection(peerId) {
-    const peer = this._peers.get(peerId);
-    if (!peer) {
-      return;
-    }
-    await peer.closeConnection();
-  }
-};
-_ts_decorate3([
-  import_log4.logInfo
-], Swarm.prototype, "_instanceId", void 0);
-_ts_decorate3([
-  import_log4.logInfo
-], Swarm.prototype, "ownPeerId", null);
-_ts_decorate3([
-  import_log4.logInfo
-], Swarm.prototype, "topic", null);
-_ts_decorate3([
-  import_async3.synchronized
-], Swarm.prototype, "onSwarmEvent", null);
-_ts_decorate3([
-  import_async3.synchronized
-], Swarm.prototype, "onOffer", null);
-_ts_decorate3([
-  import_async3.synchronized
-], Swarm.prototype, "goOffline", null);
-_ts_decorate3([
-  import_async3.synchronized
-], Swarm.prototype, "goOnline", null);
-
-// packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts
-var import_async4 = require("@dxos/async");
-var import_keys5 = require("@dxos/keys");
-var import_log5 = require("@dxos/log");
-var import_util3 = require("@dxos/util");
-var __dxlog_file5 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
-var SwarmMapper = class {
-  get peers() {
-    return Array.from(this._peers.values());
-  }
-  constructor(_swarm) {
-    this._swarm = _swarm;
-    this._subscriptions = new import_async4.EventSubscriptions();
-    this._connectionSubscriptions = new import_util3.ComplexMap(import_keys5.PublicKey.hash);
-    this._peers = new import_util3.ComplexMap(import_keys5.PublicKey.hash);
-    this.mapUpdated = new import_async4.Event();
-    this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
-      this._update();
-      this._connectionSubscriptions.set(connection.remoteId, connection.stateChanged.on(() => {
-        this._update();
-      }));
-    }));
-    this._subscriptions.add(_swarm.disconnected.on((peerId) => {
-      this._connectionSubscriptions.get(peerId)?.();
-      this._connectionSubscriptions.delete(peerId);
-      this._update();
-    }));
-    this._update();
-  }
-  _update() {
-    (0, import_log5.log)("updating swarm", void 0, {
-      F: __dxlog_file5,
-      L: 72,
-      S: this,
-      C: (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
-        ]
-      });
-    }
-    (0, import_log5.log)("graph changed", {
-      directConnections: this._swarm.connections.length,
-      totalPeersInSwarm: this._peers.size
-    }, {
-      F: __dxlog_file5,
-      L: 113,
-      S: this,
-      C: (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/swarm/connection-limiter.ts
-var import_async5 = require("@dxos/async");
-var import_context5 = require("@dxos/context");
-var import_invariant5 = require("@dxos/invariant");
-var import_keys6 = require("@dxos/keys");
-var import_log6 = require("@dxos/log");
-var import_protocols5 = require("@dxos/protocols");
-var import_util4 = require("@dxos/util");
-var __dxlog_file6 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
-var MAX_CONCURRENT_INITIATING_CONNECTIONS = 50;
-var ConnectionLimiter = class {
-  constructor({ maxConcurrentInitConnections = MAX_CONCURRENT_INITIATING_CONNECTIONS } = {}) {
-    this._ctx = new import_context5.Context();
-    /**
-    * Queue of promises to resolve when initiating connections amount is below the limit.
-    */
-    this._waitingPromises = new import_util4.ComplexMap(import_keys6.PublicKey.hash);
-    this.resolveWaitingPromises = new import_async5.DeferredTask(this._ctx, async () => {
-      Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
-        resolve();
-      });
-    });
-    this._maxConcurrentInitConnections = maxConcurrentInitConnections;
-  }
-  /**
-  * @returns Promise that resolves in queue when connections amount with 'CONNECTING' state is below the limit.
-  */
-  async connecting(sessionId) {
-    (0, import_invariant5.invariant)(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", {
-      F: __dxlog_file6,
-      L: 48,
-      S: this,
-      A: [
-        "!this._waitingPromises.has(sessionId)",
-        "'Peer is already waiting for connection'"
-      ]
-    });
-    (0, import_log6.log)("waiting", {
-      sessionId
-    }, {
-      F: __dxlog_file6,
-      L: 49,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await new Promise((resolve, reject) => {
-      this._waitingPromises.set(sessionId, {
-        resolve,
-        reject
-      });
-      this.resolveWaitingPromises.schedule();
-    });
-    (0, import_log6.log)("allow", {
-      sessionId
-    }, {
-      F: __dxlog_file6,
-      L: 57,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  /**
-  * Rejects promise returned by `connecting` method.
-  */
-  doneConnecting(sessionId) {
-    (0, import_log6.log)("done", {
-      sessionId
-    }, {
-      F: __dxlog_file6,
-      L: 64,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!this._waitingPromises.has(sessionId)) {
-      return;
-    }
-    this._waitingPromises.get(sessionId).reject(new import_protocols5.CancelledError());
-    this._waitingPromises.delete(sessionId);
-    this.resolveWaitingPromises.schedule();
-  }
-};
-
-// 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 import_util5.ComplexMap(import_keys7.PublicKey.hash);
-    this.update = new import_async6.Event();
-  }
-  getSwarmInfo(swarmId) {
-    return this._swarms.get(swarmId) ?? (0, import_debug3.raise)(new Error(`Swarm not found: ${swarmId}`));
-  }
-  get swarms() {
-    return Array.from(this._swarms.values());
-  }
-  joinedSwarm(swarm) {
-    const info = {
-      id: import_keys7.PublicKey.from(swarm._instanceId),
-      topic: swarm.topic,
-      isActive: true,
-      label: swarm.label,
-      connections: []
-    };
-    this._swarms.set(import_keys7.PublicKey.from(swarm._instanceId), info);
-    this.update.emit();
-    swarm.connectionAdded.on((connection) => {
-      const connectionInfo = {
-        state: ConnectionState.CREATED,
-        closeReason: connection.closeReason,
-        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.closeReason = connection.closeReason;
-        connectionInfo.events.push({
-          type: EventType.CONNECTION_STATE_CHANGED,
-          newState: state
-        });
-        this.update.emit();
-      });
-      connection.protocol?.stats?.on((stats) => {
-        connectionInfo.readBufferSize = stats.readBufferSize;
-        connectionInfo.writeBufferSize = stats.writeBufferSize;
-        connectionInfo.streams = stats.channels;
-        this.update.emit();
-      });
-    });
-  }
-  leftSwarm(swarm) {
-    this.getSwarmInfo(import_keys7.PublicKey.from(swarm._instanceId)).isActive = false;
-    this.update.emit();
-  }
-};
-
-// packages/core/mesh/network-manager/src/network-manager.ts
-var import_async7 = require("@dxos/async");
-var import_invariant6 = require("@dxos/invariant");
-var import_keys8 = require("@dxos/keys");
-var import_log7 = require("@dxos/log");
-var import_messaging = require("@dxos/messaging");
-var import_protocols6 = require("@dxos/protocols");
-var import_services = require("@dxos/protocols/proto/dxos/client/services");
-var import_util6 = require("@dxos/util");
-var __dxlog_file7 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/network-manager.ts";
-var NetworkManager = class {
-  constructor({ transportFactory, signalManager, log: log1 }) {
-    /**
-    * @internal
-    */
-    this._swarms = new import_util6.ComplexMap(import_keys8.PublicKey.hash);
-    this._mappers = new import_util6.ComplexMap(import_keys8.PublicKey.hash);
-    this._connectionState = import_services.ConnectionState.ONLINE;
-    this.connectionStateChanged = new import_async7.Event();
-    this.topicsUpdated = new import_async7.Event();
-    this._instanceId = import_keys8.PublicKey.random().toHex();
-    this._transportFactory = transportFactory;
-    this._signalManager = signalManager;
-    this._signalManager.swarmEvent.on(({ topic, swarmEvent: event }) => this._swarms.get(topic)?.onSwarmEvent(event));
-    this._messenger = new import_messaging.Messenger({
-      signalManager: this._signalManager
-    });
-    this._signalConnection = {
-      join: (opts) => this._signalManager.join(opts),
-      leave: (opts) => this._signalManager.leave(opts)
-    };
-    this._connectionLimiter = new ConnectionLimiter();
-    if (log1) {
-      this._connectionLog = new ConnectionLog();
-    }
-  }
-  // TODO(burdon): Remove access (Devtools only).
-  get connectionLog() {
-    return this._connectionLog;
-  }
-  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() {
-    import_log7.log.trace("dxos.mesh.network-manager.open", import_protocols6.trace.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file7,
-      L: 130,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._messenger.open();
-    await this._signalManager.open();
-    import_log7.log.trace("dxos.mesh.network-manager.open", import_protocols6.trace.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file7,
-      L: 133,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async close() {
-    for (const topic of this._swarms.keys()) {
-      await this.leaveSwarm(topic).catch((err) => {
-        (0, import_log7.log)(err, void 0, {
-          F: __dxlog_file7,
-          L: 139,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      });
-    }
-    await this._messenger.close();
-    await this._signalManager.close();
-  }
-  /**
-  * Join the swarm.
-  */
-  async joinSwarm({ topic, peerId, topology, protocolProvider: protocol, label }) {
-    (0, import_invariant6.invariant)(import_keys8.PublicKey.isPublicKey(topic), void 0, {
-      F: __dxlog_file7,
-      L: 157,
-      S: this,
-      A: [
-        "PublicKey.isPublicKey(topic)",
-        ""
-      ]
-    });
-    (0, import_invariant6.invariant)(import_keys8.PublicKey.isPublicKey(peerId), void 0, {
-      F: __dxlog_file7,
-      L: 158,
-      S: this,
-      A: [
-        "PublicKey.isPublicKey(peerId)",
-        ""
-      ]
-    });
-    (0, import_invariant6.invariant)(topology, void 0, {
-      F: __dxlog_file7,
-      L: 159,
-      S: this,
-      A: [
-        "topology",
-        ""
-      ]
-    });
-    (0, import_invariant6.invariant)(typeof protocol === "function", void 0, {
-      F: __dxlog_file7,
-      L: 160,
-      S: this,
-      A: [
-        "typeof protocol === 'function'",
-        ""
-      ]
-    });
-    if (this._swarms.has(topic)) {
-      throw new Error(`Already connected to swarm: ${import_keys8.PublicKey.from(topic)}`);
-    }
-    (0, import_log7.log)("joining", {
-      topic: import_keys8.PublicKey.from(topic),
-      peerId,
-      topology: topology.toString()
-    }, {
-      F: __dxlog_file7,
-      L: 165,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const swarm = new Swarm(topic, peerId, topology, protocol, this._messenger, this._transportFactory, label, this._connectionLimiter);
-    swarm.errors.handle((error) => {
-      (0, import_log7.log)("swarm error", {
-        error
-      }, {
-        F: __dxlog_file7,
-        L: 178,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-    this._swarms.set(topic, swarm);
-    this._mappers.set(topic, new SwarmMapper(swarm));
-    await swarm.open();
-    this._signalConnection.join({
-      topic,
-      peerId
-    }).catch((error) => import_log7.log.catch(error, void 0, {
-      F: __dxlog_file7,
-      L: 187,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    this.topicsUpdated.emit();
-    this._connectionLog?.joinedSwarm(swarm);
-    (0, import_log7.log)("joined", {
-      topic: import_keys8.PublicKey.from(topic),
-      count: this._swarms.size
-    }, {
-      F: __dxlog_file7,
-      L: 191,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      close: () => this.leaveSwarm(topic)
-    };
-  }
-  /**
-  * Close the connection.
-  */
-  async leaveSwarm(topic) {
-    if (!this._swarms.has(topic)) {
-      return;
-    }
-    (0, import_log7.log)("leaving", {
-      topic: import_keys8.PublicKey.from(topic)
-    }, {
-      F: __dxlog_file7,
-      L: 207,
-      S: this,
-      C: (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);
-    this._connectionLog?.leftSwarm(swarm);
-    await swarm.destroy();
-    this._swarms.delete(topic);
-    await this.topicsUpdated.emit();
-    (0, import_log7.log)("left", {
-      topic: import_keys8.PublicKey.from(topic),
-      count: this._swarms.size
-    }, {
-      F: __dxlog_file7,
-      L: 221,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async setConnectionState(state) {
-    if (state === this._connectionState) {
-      return;
-    }
-    switch (state) {
-      case import_services.ConnectionState.OFFLINE: {
-        this._connectionState = state;
-        await Promise.all([
-          ...this._swarms.values()
-        ].map((swarm) => swarm.goOffline()));
-        await this._messenger.close();
-        await this._signalManager.close();
-        break;
-      }
-      case import_services.ConnectionState.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
-var import_invariant7 = require("@dxos/invariant");
-var __dxlog_file8 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
-var FullyConnectedTopology = class {
-  toString() {
-    return "FullyConnectedTopology";
-  }
-  init(controller) {
-    (0, import_invariant7.invariant)(!this._controller, "Already initialized", {
-      F: __dxlog_file8,
-      L: 18,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized'"
-      ]
-    });
-    this._controller = controller;
-  }
-  update() {
-    (0, import_invariant7.invariant)(this._controller, "Not initialized", {
-      F: __dxlog_file8,
-      L: 23,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { candidates: discovered } = this._controller.getState();
-    for (const peer of discovered) {
-      this._controller.connect(peer);
-    }
-  }
-  async onOffer(peer) {
-    return true;
-  }
-  async destroy() {
-  }
-};
-
-// packages/core/mesh/network-manager/src/topology/mmst-topology.ts
-var import_xor_distance = __toESM(require("xor-distance"));
-var import_invariant8 = require("@dxos/invariant");
-var import_log8 = require("@dxos/log");
-var __dxlog_file9 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/topology/mmst-topology.ts";
-var MMSTTopology = class {
-  constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 } = {}) {
-    this._sampleCollected = false;
-    this._originateConnections = originateConnections;
-    this._maxPeers = maxPeers;
-    this._sampleSize = sampleSize;
-  }
-  init(controller) {
-    (0, import_invariant8.invariant)(!this._controller, "Already initialized", {
-      F: __dxlog_file9,
-      L: 46,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized'"
-      ]
-    });
-    this._controller = controller;
-  }
-  update() {
-    (0, import_invariant8.invariant)(this._controller, "Not initialized", {
-      F: __dxlog_file9,
-      L: 51,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { connected, candidates } = this._controller.getState();
-    if (this._sampleCollected || connected.length > this._maxPeers || candidates.length > 0) {
-      (0, import_log8.log)("Running the algorithm.", void 0, {
-        F: __dxlog_file9,
-        L: 55,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._sampleCollected = true;
-      this._runAlgorithm();
-    }
-  }
-  async onOffer(peer) {
-    (0, import_invariant8.invariant)(this._controller, "Not initialized", {
-      F: __dxlog_file9,
-      L: 62,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { connected } = this._controller.getState();
-    const accept = connected.length < this._maxPeers;
-    (0, import_log8.log)(`Offer ${peer} accept=${accept}`, void 0, {
-      F: __dxlog_file9,
-      L: 65,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return accept;
-  }
-  async destroy() {
-  }
-  _runAlgorithm() {
-    (0, import_invariant8.invariant)(this._controller, "Not initialized", {
-      F: __dxlog_file9,
-      L: 74,
-      S: this,
-      A: [
-        "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) {
-        (0, import_log8.log)(`Disconnect ${peer}.`, void 0, {
-          F: __dxlog_file9,
-          L: 83,
-          S: this,
-          C: (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 sorted = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);
-      for (const peer of sorted) {
-        (0, import_log8.log)(`Connect ${peer}.`, void 0, {
-          F: __dxlog_file9,
-          L: 91,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._controller.connect(peer);
-      }
-    }
-  }
-  toString() {
-    return "MMSTTopology";
-  }
-};
-var sortByXorDistance = (keys, reference) => keys.sort((a, b) => import_xor_distance.default.gt((0, import_xor_distance.default)(a.asBuffer(), reference.asBuffer()), (0, import_xor_distance.default)(b.asBuffer(), reference.asBuffer())));
-
-// packages/core/mesh/network-manager/src/topology/star-topology.ts
-var import_invariant9 = require("@dxos/invariant");
-var import_log9 = require("@dxos/log");
-var __dxlog_file10 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/topology/star-topology.ts";
-var StarTopology = class {
-  constructor(_centralPeer) {
-    this._centralPeer = _centralPeer;
-  }
-  toString() {
-    return `StarTopology(${this._centralPeer.truncate()})`;
-  }
-  init(controller) {
-    (0, import_invariant9.invariant)(!this._controller, "Already initialized.", {
-      F: __dxlog_file10,
-      L: 21,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized.'"
-      ]
-    });
-    this._controller = controller;
-  }
-  update() {
-    (0, import_invariant9.invariant)(this._controller, "Not initialized.", {
-      F: __dxlog_file10,
-      L: 26,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized.'"
-      ]
-    });
-    const { candidates, connected, ownPeerId } = this._controller.getState();
-    if (!ownPeerId.equals(this._centralPeer)) {
-      (0, import_log9.log)("leaf peer dropping all connections apart from central peer.", void 0, {
-        F: __dxlog_file10,
-        L: 29,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      for (const peer of connected) {
-        if (!peer.equals(this._centralPeer)) {
-          (0, import_log9.log)("dropping connection", {
-            peer
-          }, {
-            F: __dxlog_file10,
-            L: 34,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._controller.disconnect(peer);
-        }
-      }
-    }
-    for (const peer of candidates) {
-      if (peer.equals(this._centralPeer) || ownPeerId.equals(this._centralPeer)) {
-        (0, import_log9.log)("connecting to peer", {
-          peer
-        }, {
-          F: __dxlog_file10,
-          L: 43,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._controller.connect(peer);
-      }
-    }
-  }
-  async onOffer(peer) {
-    (0, import_invariant9.invariant)(this._controller, "Not initialized.", {
-      F: __dxlog_file10,
-      L: 50,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized.'"
-      ]
-    });
-    const { ownPeerId } = this._controller.getState();
-    (0, import_log9.log)("offer", {
-      peer,
-      isCentral: peer.equals(this._centralPeer),
-      isSelfCentral: ownPeerId.equals(this._centralPeer)
-    }, {
-      F: __dxlog_file10,
-      L: 52,
-      S: this,
-      C: (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
-var import_node_stream = require("node:stream");
-var import_async8 = require("@dxos/async");
-var import_debug4 = require("@dxos/debug");
-var import_invariant10 = require("@dxos/invariant");
-var import_keys9 = require("@dxos/keys");
-var import_log10 = require("@dxos/log");
-var import_util7 = require("@dxos/util");
-function _ts_decorate4(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 __dxlog_file11 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
-var MEMORY_TRANSPORT_DELAY = 1;
-var createStreamDelay = (delay) => {
-  return new import_node_stream.Transform({
-    objectMode: true,
-    transform: (chunk, _, cb) => {
-      setTimeout(() => cb(null, chunk), delay);
-    }
-  });
-};
-var MemoryTransportFactory = {
-  createTransport: (params) => new MemoryTransport(params)
-};
-var MemoryTransport = class _MemoryTransport {
-  static {
-    // TODO(burdon): Remove static properties (inject context into constructor).
-    this._connections = new import_util7.ComplexMap(import_keys9.PublicKey.hash);
-  }
-  constructor(options) {
-    this.options = options;
-    this.closed = new import_async8.Event();
-    this.connected = new import_async8.Event();
-    this.errors = new import_debug4.ErrorStream();
-    this._instanceId = import_keys9.PublicKey.random();
-    this._remote = new import_async8.Trigger();
-    this._outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-    this._incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-    this._destroyed = false;
-    (0, import_log10.log)("creating", void 0, {
-      F: __dxlog_file11,
-      L: 64,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant10.invariant)(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", {
-      F: __dxlog_file11,
-      L: 66,
-      S: this,
-      A: [
-        "!MemoryTransport._connections.has(this._instanceId)",
-        "'Duplicate memory connection'"
-      ]
-    });
-    _MemoryTransport._connections.set(this._instanceId, this);
-    if (this.options.initiator) {
-      setTimeout(async () => {
-        (0, import_log10.log)("sending signal", void 0, {
-          F: __dxlog_file11,
-          L: 73,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        void this.options.sendSignal({
-          payload: {
-            transportId: this._instanceId.toHex()
-          }
-        }).catch((err) => {
-          if (!this._destroyed) {
-            this.errors.raise(err);
-          }
-        });
-      });
-    } else {
-      this._remote.wait({
-        timeout: this.options.timeout ?? 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;
-        }
-        (0, import_invariant10.invariant)(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
-          F: __dxlog_file11,
-          L: 99,
-          S: this,
-          A: [
-            "!this._remoteConnection._remoteConnection",
-            "`Remote already connected: ${this._remoteInstanceId}`"
-          ]
-        });
-        this._remoteConnection._remoteConnection = this;
-        this._remoteConnection._remoteInstanceId = this._instanceId;
-        (0, import_log10.log)("connected", void 0, {
-          F: __dxlog_file11,
-          L: 103,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.options.stream.pipe(this._outgoingDelay).pipe(this._remoteConnection.options.stream).pipe(this._incomingDelay).pipe(this.options.stream);
-        this.connected.emit();
-        this._remoteConnection.connected.emit();
-      }).catch((err) => {
-        if (this._destroyed) {
-          return;
-        }
-        this.errors.raise(err);
-      });
-    }
-  }
-  async destroy() {
-    (0, import_log10.log)("closing", void 0, {
-      F: __dxlog_file11,
-      L: 124,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._destroyed = true;
-    _MemoryTransport._connections.delete(this._instanceId);
-    if (this._remoteConnection) {
-      (0, import_log10.log)("closing", void 0, {
-        F: __dxlog_file11,
-        L: 129,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._remoteConnection._destroyed = true;
-      _MemoryTransport._connections.delete(this._remoteInstanceId);
-      this.options.stream.unpipe(this._incomingDelay);
-      this._incomingDelay.unpipe(this._remoteConnection.options.stream);
-      this._remoteConnection.options.stream.unpipe(this._outgoingDelay);
-      this._outgoingDelay.unpipe(this.options.stream);
-      this.options.stream.unpipe(this._outgoingDelay);
-      this._remoteConnection.closed.emit();
-      this._remoteConnection._remoteConnection = void 0;
-      this._remoteConnection = void 0;
-      (0, import_log10.log)("closed", void 0, {
-        F: __dxlog_file11,
-        L: 150,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    this.closed.emit();
-    (0, import_log10.log)("closed", void 0, {
-      F: __dxlog_file11,
-      L: 154,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  signal({ payload }) {
-    (0, import_log10.log)("received signal", {
-      payload
-    }, {
-      F: __dxlog_file11,
-      L: 158,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!payload?.transportId) {
-      return;
-    }
-    const transportId = payload.transportId;
-    if (transportId) {
-      const remoteId = import_keys9.PublicKey.fromHex(transportId);
-      this._remote.wake(remoteId);
-    }
-  }
-};
-_ts_decorate4([
-  import_log10.logInfo
-], MemoryTransport.prototype, "_instanceId", void 0);
-_ts_decorate4([
-  import_log10.logInfo
-], MemoryTransport.prototype, "_remoteInstanceId", void 0);
-
-// packages/core/mesh/network-manager/src/transport/transport.ts
-var TransportKind;
-(function(TransportKind2) {
-  TransportKind2["SIMPLE_PEER"] = "SIMPLE_PEER";
-  TransportKind2["LIBDATACHANNEL"] = "LIBDATACHANNEL";
-  TransportKind2["SIMPLE_PEER_PROXY"] = "SIMPLE_PEER_PROXY";
-  TransportKind2["MEMORY"] = "MEMORY";
-  TransportKind2["TCP"] = "TCP";
-})(TransportKind || (TransportKind = {}));
-
-// packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
-var import_simple_peer = __toESM(require("simple-peer"));
-var import_tiny_invariant = __toESM(require("tiny-invariant"));
-var import_async9 = require("@dxos/async");
-var import_debug5 = require("@dxos/debug");
-var import_keys10 = require("@dxos/keys");
-var import_log11 = require("@dxos/log");
-var import_protocols7 = require("@dxos/protocols");
-
-// packages/core/mesh/network-manager/src/transport/webrtc.ts
-var wrtc = null;
-try {
-  wrtc = require("@koush/wrtc");
-} catch {
-}
-
-// packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
-var __dxlog_file12 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts";
-var SimplePeerTransport = class {
-  constructor(params) {
-    this.params = params;
-    this._closed = false;
-    this._piped = false;
-    this.closed = new import_async9.Event();
-    this.connected = new import_async9.Event();
-    this.errors = new import_debug5.ErrorStream();
-    this._instanceId = import_keys10.PublicKey.random().toHex();
-    import_log11.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols7.trace.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file12,
-      L: 41,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_log11.log)("created connection", params, {
-      F: __dxlog_file12,
-      L: 42,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._peer = new import_simple_peer.default({
-      channelName: "dxos.mesh.transport",
-      initiator: this.params.initiator,
-      wrtc: import_simple_peer.default.WEBRTC_SUPPORT ? void 0 : wrtc ?? (0, import_debug5.raise)(new Error("wrtc not available")),
-      config: this.params.webrtcConfig
-    });
-    this._peer.on("signal", async (data) => {
-      (0, import_log11.log)("signal", data, {
-        F: __dxlog_file12,
-        L: 51,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.params.sendSignal({
-        payload: {
-          data
-        }
-      });
-    });
-    this._peer.on("connect", () => {
-      (0, import_log11.log)("connected", void 0, {
-        F: __dxlog_file12,
-        L: 56,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this.params.stream.pipe(this._peer).pipe(this.params.stream);
-      this._piped = true;
-      this.connected.emit();
-    });
-    this._peer.on("close", async () => {
-      (0, import_log11.log)("closed", void 0, {
-        F: __dxlog_file12,
-        L: 63,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.destroy();
-    });
-    this._peer.on("error", async (err) => {
-      if (typeof RTCError !== "undefined" && err instanceof RTCError) {
-        if (err.errorDetail === "sctp-failure") {
-          this.errors.raise(new import_protocols7.ConnectionResetError("sctp-failure from RTCError", err));
-        } else {
-          this.errors.raise(new import_protocols7.UnknownProtocolError("unknown RTCError", err));
-        }
-      } else if ("code" in err) {
-        import_log11.log.info("simple-peer error", err, {
-          F: __dxlog_file12,
-          L: 78,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        switch (err.code) {
-          case "ERR_WEBRTC_SUPPORT":
-            this.errors.raise(new import_protocols7.ProtocolError("WebRTC not supported", err));
-            break;
-          case "ERR_ICE_CONNECTION_FAILURE":
-          case "ERR_DATA_CHANNEL":
-          case "ERR_CONNECTION_FAILURE":
-          case "ERR_SIGNALING":
-            this.errors.raise(new import_protocols7.ConnectivityError("unknown communication failure", err));
-            break;
-          case "ERR_CREATE_OFFER":
-          case "ERR_CREATE_ANSWER":
-          case "ERR_SET_LOCAL_DESCRIPTION":
-          case "ERR_SET_REMOTE_DESCRIPTION":
-          case "ERR_ADD_ICE_CANDIDATE":
-            this.errors.raise(new import_protocols7.UnknownProtocolError("unknown simple-peer library failure", err));
-            break;
-          default:
-            this.errors.raise(new Error("unknown simple-peer error"));
-            break;
-        }
-      } else {
-        import_log11.log.info("unknown peer connection error", err, {
-          F: __dxlog_file12,
-          L: 102,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.errors.raise(err);
-      }
-      try {
-        if (typeof this._peer?._pc?.getStats === "function") {
-          this._peer._pc.getStats().then((stats) => {
-            import_log11.log.info("report after webrtc error", {
-              config: this.params.webrtcConfig,
-              stats
-            }, {
-              F: __dxlog_file12,
-              L: 110,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          });
-        }
-      } catch (err2) {
-        import_log11.log.catch(err2, void 0, {
-          F: __dxlog_file12,
-          L: 117,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      await this.destroy();
-    });
-    import_log11.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols7.trace.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file12,
-      L: 122,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async destroy() {
-    (0, import_log11.log)("closing...", void 0, {
-      F: __dxlog_file12,
-      L: 126,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this._closed) {
-      return;
-    }
-    this._closed = true;
-    this._disconnectStreams();
-    this._peer.destroy();
-    this.closed.emit();
-    (0, import_log11.log)("closed", void 0, {
-      F: __dxlog_file12,
-      L: 134,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  signal(signal) {
-    if (this._closed) {
-      return;
-    }
-    (0, import_tiny_invariant.default)(signal.payload.data, "Signal message must contain signal data.");
-    this._peer.signal(signal.payload.data);
-  }
-  _disconnectStreams() {
-    if (this._piped) {
-      this.params.stream.unpipe?.(this._peer)?.unpipe?.(this.params.stream);
-    }
-  }
-};
-var createSimplePeerTransportFactory = (webrtcConfig) => ({
-  createTransport: (params) => new SimplePeerTransport({
-    ...params,
-    webrtcConfig
-  })
-});
-
-// packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts
-var import_node_stream2 = require("node:stream");
-var import_codec_protobuf = require("@dxos/codec-protobuf");
-var import_invariant11 = require("@dxos/invariant");
-var import_keys11 = require("@dxos/keys");
-var import_log12 = require("@dxos/log");
-var import_bridge = require("@dxos/protocols/proto/dxos/mesh/bridge");
-var import_util8 = require("@dxos/util");
-var __dxlog_file13 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts";
-var SimplePeerTransportService = class {
-  constructor(_webrtcConfig) {
-    this._webrtcConfig = _webrtcConfig;
-    this.transports = new import_util8.ComplexMap(import_keys11.PublicKey.hash);
-  }
-  open(request) {
-    const rpcStream = new import_codec_protobuf.Stream(({ ready, next, close }) => {
-      const duplex = new import_node_stream2.Duplex({
-        read: () => {
-          const callbacks = [
-            ...transportState.writeCallbacks
-          ];
-          transportState.writeCallbacks.length = 0;
-          for (const cb of callbacks) {
-            cb();
-          }
-        },
-        write: function(chunk, _, callback) {
-          next({
-            data: {
-              payload: chunk
-            }
-          });
-          callback();
-        }
-      });
-      const transport = new SimplePeerTransport({
-        initiator: request.initiator,
-        stream: duplex,
-        webrtcConfig: this._webrtcConfig,
-        sendSignal: async (signal) => {
-          next({
-            signal: {
-              payload: signal
-            }
-          });
-        }
-      });
-      next({
-        connection: {
-          state: import_bridge.ConnectionState.CONNECTING
-        }
-      });
-      transport.connected.on(() => {
-        next({
-          connection: {
-            state: import_bridge.ConnectionState.CONNECTED
-          }
-        });
-      });
-      transport.errors.handle((err) => {
-        next({
-          connection: {
-            state: import_bridge.ConnectionState.CLOSED,
-            error: err.toString()
-          }
-        });
-        close(err);
-      });
-      transport.closed.on(() => {
-        next({
-          connection: {
-            state: import_bridge.ConnectionState.CLOSED
-          }
-        });
-        close();
-      });
-      const transportState = {
-        transport,
-        stream: duplex,
-        writeCallbacks: [],
-        state: "OPEN"
-      };
-      ready();
-      this.transports.set(request.proxyId, transportState);
-    });
-    return rpcStream;
-  }
-  async sendSignal({ proxyId, signal }) {
-    (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
-      F: __dxlog_file13,
-      L: 112,
-      S: this,
-      A: [
-        "this.transports.has(proxyId)",
-        ""
-      ]
-    });
-    await this.transports.get(proxyId).transport.signal(signal);
-  }
-  async sendData({ proxyId, payload }) {
-    if (this.transports.get(proxyId)?.state !== "OPEN") {
-      import_log12.log.debug("transport is closed", void 0, {
-        F: __dxlog_file13,
-        L: 118,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
-      F: __dxlog_file13,
-      L: 120,
-      S: this,
-      A: [
-        "this.transports.has(proxyId)",
-        ""
-      ]
-    });
-    const state = this.transports.get(proxyId);
-    const bufferHasSpace = state.stream.push(payload);
-    if (!bufferHasSpace) {
-      await new Promise((resolve) => {
-        state.writeCallbacks.push(resolve);
-      });
-    }
-  }
-  async close({ proxyId }) {
-    await this.transports.get(proxyId)?.transport.destroy();
-    await this.transports.get(proxyId)?.stream.end();
-    if (this.transports.get(proxyId)) {
-      this.transports.get(proxyId).state = "CLOSED";
-    }
-    (0, import_log12.log)("Closed.", void 0, {
-      F: __dxlog_file13,
-      L: 136,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-};
-
-// packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts
-var import_node_stream3 = require("node:stream");
-var import_async10 = require("@dxos/async");
-var import_context6 = require("@dxos/context");
-var import_debug6 = require("@dxos/debug");
-var import_invariant12 = require("@dxos/invariant");
-var import_keys12 = require("@dxos/keys");
-var import_log13 = require("@dxos/log");
-var import_protocols8 = require("@dxos/protocols");
-var import_bridge2 = require("@dxos/protocols/proto/dxos/mesh/bridge");
-var import_util9 = require("@dxos/util");
-var __dxlog_file14 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts";
-var RESP_MIN_THRESHOLD = 500;
-var TIMEOUT_THRESHOLD = 10;
-var SimplePeerTransportProxy = class {
-  constructor(_params) {
-    this._params = _params;
-    this._proxyId = import_keys12.PublicKey.random();
-    this._ctx = new import_context6.Context();
-    this._timeoutCount = 0;
-    this.closed = new import_async10.Event();
-    this.connected = new import_async10.Event();
-    this.errors = new import_debug6.ErrorStream();
-    this._closed = false;
-    this._serviceStream = this._params.bridgeService.open({
-      proxyId: this._proxyId,
-      initiator: this._params.initiator
-    });
-    this._serviceStream.waitUntilReady().then(() => {
-      this._serviceStream.subscribe(async (event) => {
-        (0, import_log13.log)("SimplePeerTransportProxy: event", event, {
-          F: __dxlog_file14,
-          L: 59,
-          S: this,
-          C: (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 proxyStream = new import_node_stream3.Writable({
-        write: (chunk, _, callback) => {
-          const then = performance.now();
-          this._params.bridgeService.sendData({
-            proxyId: this._proxyId,
-            payload: chunk
-          }).then(() => {
-            if (performance.now() - then > RESP_MIN_THRESHOLD) {
-              (0, import_log13.log)("slow response, delaying callback", void 0, {
-                F: __dxlog_file14,
-                L: 80,
-                S: this,
-                C: (f, a) => f(...a)
-              });
-              (0, import_async10.scheduleTask)(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
-            } else {
-              callback();
-            }
-            this._timeoutCount = 0;
-          }, (err) => {
-            if (err instanceof import_protocols8.TimeoutError || err.constructor.name === "TimeoutError") {
-              if (this._timeoutCount++ > TIMEOUT_THRESHOLD) {
-                throw new import_protocols8.TimeoutError(`too many timeoutes (${this._timeoutCount} > ${TIMEOUT_THRESHOLD}`);
-              } else {
-                (0, import_log13.log)("timeout error, but still invoking callback", void 0, {
-                  F: __dxlog_file14,
-                  L: 92,
-                  S: this,
-                  C: (f, a) => f(...a)
-                });
-                callback();
-              }
-            } else {
-              import_log13.log.catch(err, void 0, {
-                F: __dxlog_file14,
-                L: 96,
-                S: this,
-                C: (f, a) => f(...a)
-              });
-            }
-          });
-        }
-      });
-      proxyStream.on("error", (err) => {
-        (0, import_log13.log)("proxystream error", {
-          err
-        }, {
-          F: __dxlog_file14,
-          L: 104,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      });
-      this._params.stream.pipe(proxyStream);
-    }, (error) => import_log13.log.catch(error, void 0, {
-      F: __dxlog_file14,
-      L: 109,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-  }
-  async _handleConnection(connectionEvent) {
-    if (connectionEvent.error) {
-      this.errors.raise(decodeError(connectionEvent.error));
-    }
-    switch (connectionEvent.state) {
-      case import_bridge2.ConnectionState.CONNECTED: {
-        this.connected.emit();
-        break;
-      }
-      case import_bridge2.ConnectionState.CLOSED: {
-        await this.destroy();
-        break;
-      }
-    }
-  }
-  _handleData(dataEvent) {
-    this._params.stream.write((0, import_util9.arrayToBuffer)(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(decodeError(err)));
-  }
-  // TODO(burdon): Move open from constructor.
-  async destroy() {
-    await this._ctx.dispose();
-    if (this._closed) {
-      return;
-    }
-    await this._serviceStream.close();
-    try {
-      await this._params.bridgeService.close({
-        proxyId: this._proxyId
-      });
-    } catch (err) {
-      import_log13.log.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 160,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    this.closed.emit();
-    this._closed = true;
-  }
-  /**
-  * Called when underlying proxy service becomes unavailable.
-  */
-  // TODO(burdon): Option on close method.
-  forceClose() {
-    void this._serviceStream.close();
-    this.closed.emit();
-    this._closed = true;
-  }
-};
-var SimplePeerTransportProxyFactory = 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) {
-    (0, import_invariant12.invariant)(this._bridgeService, "SimplePeerTransportProxyFactory is not ready to open connections", {
-      F: __dxlog_file14,
-      L: 197,
-      S: this,
-      A: [
-        "this._bridgeService",
-        "'SimplePeerTransportProxyFactory is not ready to open connections'"
-      ]
-    });
-    const transport = new SimplePeerTransportProxy({
-      ...options,
-      bridgeService: this._bridgeService
-    });
-    this._connections.add(transport);
-    transport.closed.on(() => this._connections.delete(transport));
-    return transport;
-  }
-};
-var decodeError = (err) => {
-  const message = typeof err === "string" ? err : err.message;
-  if (message.includes("CONNECTION_RESET")) {
-    return new import_protocols8.ConnectionResetError(message);
-  } else if (message.includes("TIMEOUT")) {
-    return new import_protocols8.TimeoutError(message);
-  } else if (message.includes("PROTOCOL_ERROR")) {
-    return new import_protocols8.ProtocolError(message);
-  } else if (message.includes("CONNECTIVITY_ERROR")) {
-    return new import_protocols8.ConnectivityError(message);
-  } else if (message.includes("UNKNOWN_PROTOCOL_ERROR")) {
-    return new import_protocols8.UnknownProtocolError(message);
-  } else {
-    return typeof err === "string" ? new Error(err) : err;
-  }
-};
-
-// packages/core/mesh/network-manager/src/transport/index.ts
-init_datachannel();
-
-// packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts
-var import_stream = require("stream");
-var import_async11 = require("@dxos/async");
-var import_debug7 = require("@dxos/debug");
-var import_log14 = require("@dxos/log");
-function _ts_decorate5(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 __dxlog_file15 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts";
-var DATACHANNEL_LABEL = "dxos.mesh.transport";
-var MAX_BUFFERED_AMOUNT = 64 * 1024;
-var MAX_MESSAGE_SIZE = 64 * 1024;
-var LibDataChannelTransport = class {
-  constructor(params) {
-    this.params = params;
-    this._closed = false;
-    this.closed = new import_async11.Event();
-    this._connected = false;
-    this.connected = new import_async11.Event();
-    this.errors = new import_debug7.ErrorStream();
-    this._readyForCandidates = new import_async11.Trigger();
-    this._writeCallback = null;
-    this._peer = (async () => {
-      const { RTCPeerConnection: PeerConnection2 } = await Promise.resolve().then(() => (init_datachannel(), datachannel_exports));
-      if (this._closed) {
-        this.errors.raise(new Error("connection already closed"));
-      }
-      const peer = new PeerConnection2(params.webrtcConfig);
-      peer.onicecandidateerror = (event) => {
-        import_log14.log.error("peer.onicecandidateerror", {
-          event
-        }, {
-          F: __dxlog_file15,
-          L: 53,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      };
-      peer.onconnectionstatechange = (event) => {
-        import_log14.log.debug("peer.onconnectionstatechange", {
-          event,
-          peerConnectionState: peer.connectionState,
-          transportConnectionState: this._connected
-        }, {
-          F: __dxlog_file15,
-          L: 57,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      };
-      peer.onicecandidate = async (event) => {
-        import_log14.log.debug("peer.onicecandidate", {
-          event
-        }, {
-          F: __dxlog_file15,
-          L: 66,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (event.candidate) {
-          try {
-            await params.sendSignal({
-              payload: {
-                data: {
-                  type: "candidate",
-                  candidate: {
-                    candidate: event.candidate.candidate,
-                    // these fields never seem to be not null, but connecting to Chrome doesn't work if they are
-                    sdpMLineIndex: event.candidate.sdpMLineIndex ?? 0,
-                    sdpMid: event.candidate.sdpMid ?? 0
-                  }
-                }
-              }
-            });
-          } catch (err) {
-            import_log14.log.info("signaling errror", {
-              err
-            }, {
-              F: __dxlog_file15,
-              L: 83,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-        }
-      };
-      if (params.initiator) {
-        peer.createOffer().then(async (offer) => {
-          if (peer.connectionState !== "connecting") {
-            import_log14.log.error("i am initiator but peer not in state connecting", {
-              peer
-            }, {
-              F: __dxlog_file15,
-              L: 92,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            this.errors.raise(new Error("invalid state: peer is initiator, but other peer not in state connecting"));
-          }
-          import_log14.log.debug(`im the initiator, creating offer, peer is in state ${peer.connectionState}`, {
-            offer
-          }, {
-            F: __dxlog_file15,
-            L: 95,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          await peer.setLocalDescription(offer);
-          await params.sendSignal({
-            payload: {
-              data: {
-                type: offer.type,
-                sdp: offer.sdp
-              }
-            }
-          });
-          return offer;
-        }).catch((err) => {
-          this.errors.raise(err);
-        });
-        this.handleChannel(peer.createDataChannel(DATACHANNEL_LABEL));
-        import_log14.log.debug("created data channel", void 0, {
-          F: __dxlog_file15,
-          L: 104,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        peer.ondatachannel = (event) => {
-          this.errors.raise(new Error("got ondatachannel when i am the initiator?"));
-        };
-      } else {
-        peer.ondatachannel = (event) => {
-          import_log14.log.debug("peer.ondatachannel (non-initiator)", {
-            event
-          }, {
-            F: __dxlog_file15,
-            L: 110,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          if (event.channel.label !== DATACHANNEL_LABEL) {
-            this.errors.raise(new Error(`unexpected channel label ${event.channel.label}`));
-          }
-          this.handleChannel(event.channel);
-        };
-      }
-      return peer;
-    })();
-  }
-  handleChannel(dataChannel) {
-    this._channel = dataChannel;
-    this._channel.onopen = () => {
-      import_log14.log.debug("dataChannel.onopen", void 0, {
-        F: __dxlog_file15,
-        L: 126,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const duplex = new import_stream.Duplex({
-        read: () => {
-        },
-        write: (chunk, encoding, callback) => {
-          if (chunk.length > MAX_MESSAGE_SIZE) {
-            this.errors.raise(new Error(`message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}`));
-          }
-          dataChannel.send(chunk);
-          if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
-            if (this._writeCallback !== null) {
-              import_log14.log.error("consumer trying to write before we're ready for more data", void 0, {
-                F: __dxlog_file15,
-                L: 139,
-                S: this,
-                C: (f, a) => f(...a)
-              });
-            }
-            this._writeCallback = callback;
-          } else {
-            callback();
-          }
-        }
-      });
-      duplex.pipe(this.params.stream).pipe(duplex);
-      this._stream = duplex;
-      this._connected = true;
-      this.connected.emit();
-    };
-    this._channel.onerror = async (err) => {
-      this.errors.raise(new Error("channel error: " + err.toString()));
-      await this._close();
-    };
-    this._channel.onclose = async (err) => {
-      import_log14.log.info("channel onclose", {
-        err
-      }, {
-        F: __dxlog_file15,
-        L: 159,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this._close();
-    };
-    this._channel.onmessage = (event) => {
-      let data = event.data;
-      if (data instanceof ArrayBuffer) {
-        data = Buffer.from(data);
-      }
-      this._stream.push(data);
-    };
-    this._channel.onbufferedamountlow = () => {
-      const cb = this._writeCallback;
-      this._writeCallback = null;
-      cb?.();
-    };
-  }
-  async _close() {
-    if (this._closed) {
-      return;
-    }
-    await this._disconnectStreams();
-    this._closed = true;
-    this.closed.emit();
-  }
-  signal(signal) {
-    this._peer.then(async (peer) => {
-      const data = signal.payload.data;
-      switch (data.type) {
-        case "offer": {
-          if ((await this._peer).connectionState !== "new") {
-            import_log14.log.error("received offer but peer not in state new", {
-              peer
-            }, {
-              F: __dxlog_file15,
-              L: 194,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            this.errors.raise(new Error("invalid signalling state: received offer when peer is not in state new"));
-            break;
-          }
-          try {
-            await peer.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            const answer = await peer.createAnswer();
-            await peer.setLocalDescription(answer);
-            await this.params.sendSignal({
-              payload: {
-                data: {
-                  type: answer.type,
-                  sdp: answer.sdp
-                }
-              }
-            });
-            this._readyForCandidates.wake();
-          } catch (err) {
-            import_log14.log.error("can't handle offer from signalling server", {
-              err
-            }, {
-              F: __dxlog_file15,
-              L: 205,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            this.errors.raise(new Error("error handling offer"));
-          }
-          break;
-        }
-        case "answer":
-          try {
-            await peer.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            this._readyForCandidates.wake();
-          } catch (err) {
-            import_log14.log.error("can't handle answer from signalling server", {
-              err
-            }, {
-              F: __dxlog_file15,
-              L: 216,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            this.errors.raise(new Error("error handling answer"));
-          }
-          break;
-        case "candidate":
-          await this._readyForCandidates.wait();
-          await peer.addIceCandidate({
-            candidate: data.candidate.candidate
-          });
-          break;
-        default:
-          import_log14.log.error("unhandled signal type", {
-            type: data.type,
-            signal
-          }, {
-            F: __dxlog_file15,
-            L: 227,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this.errors.raise(new Error(`unhandled signal type ${data.type}`));
-      }
-    }).catch((err) => {
-      import_log14.log.catch(err, void 0, {
-        F: __dxlog_file15,
-        L: 232,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-  }
-  // TODO(nf): add classmethod to call node-datachannel.cleanup() when all instances have been destroyed?
-  async destroy() {
-    await this._close();
-  }
-  async _disconnectStreams() {
-    this.params.stream.unpipe?.(this._stream)?.unpipe?.(this.params.stream);
-  }
-};
-_ts_decorate5([
-  import_async11.synchronized
-], LibDataChannelTransport.prototype, "_close", null);
-var createLibDataChannelTransportFactory = (webrtcConfig) => ({
-  createTransport: (params) => new LibDataChannelTransport({
-    ...params,
-    webrtcConfig
-  })
-});
-
-// packages/core/mesh/network-manager/src/transport/tcp-transport.ts
-var import_node_net = require("node:net");
-var import_async12 = require("@dxos/async");
-var import_debug8 = require("@dxos/debug");
-var import_log15 = require("@dxos/log");
-var __dxlog_file16 = "/mnt/ramdisk/work/packages/core/mesh/network-manager/src/transport/tcp-transport.ts";
-var TcpTransportFactory = {
-  createTransport: (params) => new TcpTransport(params)
-};
-var TcpTransport = class {
-  constructor(options) {
-    this.options = options;
-    this._server = void 0;
-    this._socket = void 0;
-    this.closed = new import_async12.Event();
-    this.connected = new import_async12.Event();
-    this.errors = new import_debug8.ErrorStream();
-    this._destroyed = false;
-    this._connected = false;
-    (0, import_log15.log)("creating", void 0, {
-      F: __dxlog_file16,
-      L: 34,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this.options.initiator) {
-      setTimeout(async () => {
-        const { Server } = await import("node:net");
-        this._server = new Server((socket) => {
-          (0, import_log15.log)("new connection", void 0, {
-            F: __dxlog_file16,
-            L: 42,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          if (this._connected) {
-            socket.destroy();
-          }
-          this._handleSocket(socket);
-        });
-        this._server.on("listening", () => {
-          const { port } = this._server.address();
-          (0, import_log15.log)("listening", {
-            port
-          }, {
-            F: __dxlog_file16,
-            L: 51,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          void this.options.sendSignal({
-            payload: {
-              port
-            }
-          }).catch((err) => {
-            if (!this._destroyed) {
-              this.errors.raise(err);
-            }
-          });
-        });
-        this._server.on("error", (err) => {
-          this.errors.raise(err);
-        });
-        this._server.listen(0);
-      });
-    }
-  }
-  async destroy() {
-    (0, import_log15.log)("closing", void 0, {
-      F: __dxlog_file16,
-      L: 72,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._socket?.destroy();
-    this._server?.close();
-    this._destroyed = true;
-  }
-  signal({ payload }) {
-    (0, import_log15.log)("received signal", {
-      payload
-    }, {
-      F: __dxlog_file16,
-      L: 80,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (this.options.initiator || this._connected) {
-      return;
-    }
-    const socket = new import_node_net.Socket();
-    this._handleSocket(socket);
-    socket.connect({
-      port: payload.port,
-      host: "localhost"
-    });
-  }
-  _handleSocket(socket) {
-    (0, import_log15.log)("handling socket", {
-      remotePort: socket.remotePort,
-      localPort: socket.localPort
-    }, {
-      F: __dxlog_file16,
-      L: 91,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._socket = socket;
-    this.connected.emit();
-    this.options.stream.pipe(this._socket).pipe(this.options.stream);
-    this._socket.on("connect", () => {
-      (0, import_log15.log)("connected to", {
-        port: this._socket?.remotePort
-      }, {
-        F: __dxlog_file16,
-        L: 97,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._connected = true;
-    });
-    this._socket.on("error", (err) => {
-      this.errors.raise(err);
-    });
-    this._socket.on("close", () => {
-      this.closed.emit();
-    });
-  }
-};
-
-// packages/core/mesh/network-manager/src/wire-protocol.ts
-var import_teleport = require("@dxos/teleport");
-var createTeleportProtocolFactory = (onConnection) => {
-  return (params) => {
-    const teleport = new import_teleport.Teleport(params);
-    return {
-      stream: teleport.stream,
-      open: async () => {
-        await teleport.open();
-        await onConnection(teleport);
-      },
-      close: async () => {
-        await teleport.close();
-      },
-      abort: async () => {
-        await teleport.abort();
-      }
-    };
-  };
-};
+module.exports = __toCommonJS(node_exports);
+var import_chunk_PWHTYBOL = require("./chunk-PWHTYBOL.cjs");
+var import_chunk_XE5JOIGD = require("./chunk-XE5JOIGD.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Connection,