@dxos/network-manager 0.3.8-next.f4e0086 → 0.3.9-main.14901ff

package/dist/lib/node/chunk-3SCPMSHV.cjs

@@ -0,0 +1,3998 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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);
+var chunk_3SCPMSHV_exports = {};
+__export(chunk_3SCPMSHV_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,
+  SimplePeerTransport: () => SimplePeerTransport,
+  SimplePeerTransportProxy: () => SimplePeerTransportProxy,
+  SimplePeerTransportProxyFactory: () => SimplePeerTransportProxyFactory,
+  SimplePeerTransportService: () => SimplePeerTransportService,
+  StarTopology: () => StarTopology,
+  Swarm: () => Swarm,
+  SwarmMapper: () => SwarmMapper,
+  SwarmMessenger: () => SwarmMessenger,
+  TcpTransport: () => TcpTransport,
+  TcpTransportFactory: () => TcpTransportFactory,
+  TransportKind: () => TransportKind,
+  createLibDataChannelTransportFactory: () => createLibDataChannelTransportFactory,
+  createSimplePeerTransportFactory: () => createSimplePeerTransportFactory,
+  createTeleportProtocolFactory: () => createTeleportProtocolFactory
+});
+module.exports = __toCommonJS(chunk_3SCPMSHV_exports);
+var import_chunk_DMWORJG3 = require("./chunk-DMWORJG3.cjs");
+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");
+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");
+var import_util = require("@dxos/util");
+var import_async2 = require("@dxos/async");
+var import_context3 = require("@dxos/context");
+var import_debug2 = require("@dxos/debug");
+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_util2 = require("@dxos/util");
+var import_async3 = require("@dxos/async");
+var import_context4 = require("@dxos/context");
+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_async4 = require("@dxos/async");
+var import_keys5 = require("@dxos/keys");
+var import_log5 = require("@dxos/log");
+var import_util3 = require("@dxos/util");
+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 import_async6 = require("@dxos/async");
+var import_debug3 = require("@dxos/debug");
+var import_keys7 = require("@dxos/keys");
+var import_util5 = require("@dxos/util");
+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 import_invariant7 = require("@dxos/invariant");
+var import_xor_distance = __toESM(require("xor-distance"));
+var import_invariant8 = require("@dxos/invariant");
+var import_log8 = require("@dxos/log");
+var import_invariant9 = require("@dxos/invariant");
+var import_log9 = require("@dxos/log");
+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");
+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");
+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 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 import_stream = require("stream");
+var import_async11 = require("@dxos/async");
+var import_debug7 = require("@dxos/debug");
+var import_log14 = require("@dxos/log");
+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 import_teleport = require("@dxos/teleport");
+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 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
+var STARTING_SIGNALLING_DELAY = 10;
+var TRANSPORT_CONNECTION_TIMEOUT = 1e4;
+var TRANSPORT_STATS_INTERVAL = 5e3;
+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.transportStats = new import_async.Event();
+    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: 134,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  get sessionIdString() {
+    return this.sessionId.truncate();
+  }
+  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: 164,
+      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: 165,
+      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: 166,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._changeState(ConnectionState.CONNECTING);
+    this._protocol.open(this.sessionId).catch((err) => {
+      this.errors.raise(err);
+    });
+    this._protocol.stream.on("close", () => {
+      (0, import_log.log)("protocol stream closed", void 0, {
+        F: __dxlog_file,
+        L: 183,
+        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 ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, {
+        F: __dxlog_file,
+        L: 190,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this.abort(new import_protocols.TimeoutError(`${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect`)).catch((err) => this.errors.raise(err));
+    }, TRANSPORT_CONNECTION_TIMEOUT);
+    (0, import_invariant.invariant)(!this._transport, void 0, {
+      F: __dxlog_file,
+      L: 198,
+      S: this,
+      A: [
+        "!this._transport",
+        ""
+      ]
+    });
+    this._transport = this._transportFactory.createTransport({
+      initiator: this.initiator,
+      stream: this._protocol.stream,
+      sendSignal: async (signal) => this._sendSignal(signal),
+      sessionId: this.sessionId
+    });
+    this._transport.connected.once(async () => {
+      this._changeState(ConnectionState.CONNECTED);
+      await this.connectedTimeoutContext.dispose();
+      this._callbacks?.onConnected?.();
+      (0, import_async.scheduleTaskInterval)(this._ctx, async () => this._emitTransportStats(), TRANSPORT_STATS_INTERVAL);
+    });
+    this._transport.closed.once(() => {
+      this._transport = void 0;
+      (0, import_log.log)("abort triggered by transport close", void 0, {
+        F: __dxlog_file,
+        L: 216,
+        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: 221,
+        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: 228,
+          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: 231,
+          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: 234,
+          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: 250,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async abort(err) {
+    (0, import_log.log)("aborting...", {
+      err
+    }, {
+      F: __dxlog_file,
+      L: 257,
+      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: 259,
+        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: 273,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this._protocol.abort();
+    } catch (err2) {
+      import_log.log.catch(err2, void 0, {
+        F: __dxlog_file,
+        L: 276,
+        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: 283,
+        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: 289,
+        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: 314,
+      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: 321,
+          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: 328,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    } else {
+      import_log.log.info(`graceful close requested when we were in ${lastState} state? aborting`, void 0, {
+        F: __dxlog_file,
+        L: 331,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      try {
+        await this._protocol.abort();
+      } catch (err2) {
+        import_log.log.catch(err2, void 0, {
+          F: __dxlog_file,
+          L: 335,
+          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: 340,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    (0, import_log.log)("closed", {
+      peerId: this.ownId
+    }, {
+      F: __dxlog_file,
+      L: 344,
+      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: 382,
+        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: 391,
+      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: 393,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    (0, import_invariant.invariant)(msg.data.signal || msg.data.signalBatch, void 0, {
+      F: __dxlog_file,
+      L: 396,
+      S: this,
+      A: [
+        "msg.data.signal || msg.data.signalBatch",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(msg.author?.equals(this.remoteId), void 0, {
+      F: __dxlog_file,
+      L: 397,
+      S: this,
+      A: [
+        "msg.author?.equals(this.remoteId)",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(msg.recipient?.equals(this.ownId), void 0, {
+      F: __dxlog_file,
+      L: 398,
+      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: 407,
+          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: 410,
+          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: 411,
+          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: 422,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    (0, import_invariant.invariant)(state !== this._state, "Already in this state.", {
+      F: __dxlog_file,
+      L: 423,
+      S: this,
+      A: [
+        "state !== this._state",
+        "'Already in this state.'"
+      ]
+    });
+    this._state = state;
+    this.stateChanged.emit(state);
+  }
+  async _emitTransportStats() {
+    const stats = await this.transport?.getStats();
+    if (stats) {
+      this.transportStats.emit(stats);
+    }
+  }
+};
+_ts_decorate([
+  import_log.logInfo
+], Connection.prototype, "sessionIdString", null);
+_ts_decorate([
+  import_async.synchronized
+], Connection.prototype, "abort", null);
+_ts_decorate([
+  import_async.synchronized
+], Connection.prototype, "close", null);
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
+var SwarmMessage = import_protocols2.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
+var SwarmMessenger = class {
+  constructor({ sendMessage, onSignal, onOffer, topic }) {
+    this._ctx = new import_context2.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_log2.log)("received", {
+      from: author,
+      to: recipient,
+      msg: message
+    }, {
+      F: __dxlog_file2,
+      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_log2.log.warn("unknown message", {
+        message
+      }, {
+        F: __dxlog_file2,
+        L: 80,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  async signal(message) {
+    (0, import_invariant2.invariant)(message.data?.signal || message.data?.signalBatch, "Invalid message", {
+      F: __dxlog_file2,
+      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_keys2.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_keys2.PublicKey.random()
+    };
+    (0, import_log2.log)("sending", {
+      from: author,
+      to: recipient,
+      msg: networkMessage
+    }, {
+      F: __dxlog_file2,
+      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_invariant2.invariant)(message.data?.answer?.offerMessageId, "No offerMessageId", {
+      F: __dxlog_file2,
+      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_invariant2.invariant)(message.data?.answer, "No answer", {
+        F: __dxlog_file2,
+        L: 139,
+        S: this,
+        A: [
+          "message.data?.answer",
+          "'No answer'"
+        ]
+      });
+      (0, import_log2.log)("resolving", {
+        answer: message.data.answer
+      }, {
+        F: __dxlog_file2,
+        L: 140,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+  async _handleOffer({ author, recipient, message }) {
+    (0, import_invariant2.invariant)(message.data.offer, "No offer", {
+      F: __dxlog_file2,
+      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_protocols2.TimeoutError) {
+        import_log2.log.info("timeout sending answer to offer", {
+          err
+        }, {
+          F: __dxlog_file2,
+          L: 175,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      } else {
+        import_log2.log.info("error sending answer to offer", {
+          err
+        }, {
+          F: __dxlog_file2,
+          L: 177,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+  }
+  async _handleSignal({ author, recipient, message }) {
+    (0, import_invariant2.invariant)(message.messageId, void 0, {
+      F: __dxlog_file2,
+      L: 191,
+      S: this,
+      A: [
+        "message.messageId",
+        ""
+      ]
+    });
+    (0, import_invariant2.invariant)(message.data.signal || message.data.signalBatch, "Invalid message", {
+      F: __dxlog_file2,
+      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);
+  }
+};
+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_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
+var ConnectionDisplacedError = class extends import_protocols4.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_context4.Context();
+    this.advertizing = false;
+    this.initiating = false;
+    this.connectionDisplaced = new import_async3.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_log4.log.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
+        F: __dxlog_file3,
+        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_log4.log)("close local connection", {
+          localPeerId: this.id,
+          topic: this.topic,
+          remotePeerId: this.localPeerId,
+          sessionId: this.connection?.sessionId
+        }, {
+          F: __dxlog_file3,
+          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_invariant4.invariant)(message.sessionId, void 0, {
+          F: __dxlog_file3,
+          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_protocols4.CancelledError)) {
+            import_log4.log.info("connection error", {
+              topic: this.topic,
+              peerId: this.localPeerId,
+              remoteId: this.id,
+              err
+            }, {
+              F: __dxlog_file3,
+              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_invariant4.invariant)(!this.initiating, "Initiation in progress.", {
+      F: __dxlog_file3,
+      L: 171,
+      S: this,
+      A: [
+        "!this.initiating",
+        "'Initiation in progress.'"
+      ]
+    });
+    (0, import_invariant4.invariant)(!this.connection, "Already connected.", {
+      F: __dxlog_file3,
+      L: 172,
+      S: this,
+      A: [
+        "!this.connection",
+        "'Already connected.'"
+      ]
+    });
+    const sessionId = import_keys4.PublicKey.random();
+    (0, import_log4.log)("initiating...", {
+      id: this.id,
+      topic: this.topic,
+      peerId: this.id,
+      sessionId
+    }, {
+      F: __dxlog_file3,
+      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_log4.log)("received", {
+        answer,
+        topic: this.topic,
+        ownId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: __dxlog_file3,
+        L: 191,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (connection.state !== ConnectionState.INITIAL) {
+        (0, import_log4.log)("ignoring response", void 0, {
+          F: __dxlog_file3,
+          L: 193,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+    } catch (err) {
+      (0, import_log4.log)("initiation error: send offer", {
+        err,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: __dxlog_file3,
+        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_log4.log)("initiation error: accept answer", {
+        err,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: __dxlog_file3,
+        L: 210,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await connection.abort(err);
+      throw err;
+    } finally {
+      this.initiating = false;
+    }
+    try {
+      (0, import_log4.log)("opening connection as initiator", void 0, {
+        F: __dxlog_file3,
+        L: 223,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await connection.openConnection();
+      this._callbacks.onAccepted();
+    } catch (err) {
+      (0, import_log4.log)("initiation error: open connection", {
+        err,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: __dxlog_file3,
+        L: 227,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      import_log4.log.warn("closing connection due to unhandled error on openConnection", {
+        err
+      }, {
+        F: __dxlog_file3,
+        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_log4.log)("creating connection", {
+      topic: this.topic,
+      peerId: this.localPeerId,
+      remoteId: this.id,
+      initiator,
+      sessionId
+    }, {
+      F: __dxlog_file3,
+      L: 248,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    (0, import_invariant4.invariant)(!this.connection, "Already connected.", {
+      F: __dxlog_file3,
+      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_log4.log.trace("dxos.mesh.connection.connected", {
+            topic: this.topic,
+            localPeerId: this.localPeerId,
+            remotePeerId: this.id,
+            sessionId,
+            initiator
+          }, {
+            F: __dxlog_file3,
+            L: 274,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        },
+        onClosed: (err) => {
+          (0, import_log4.log)("connection closed", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            initiator
+          }, {
+            F: __dxlog_file3,
+            L: 283,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._connectionLimiter.doneConnecting(sessionId);
+          (0, import_invariant4.invariant)(this.connection === connection, "Connection mismatch (race condition).", {
+            F: __dxlog_file3,
+            L: 288,
+            S: this,
+            A: [
+              "this.connection === connection",
+              "'Connection mismatch (race condition).'"
+            ]
+          });
+          import_log4.log.trace("dxos.mesh.connection.closed", {
+            topic: this.topic,
+            localPeerId: this.localPeerId,
+            remotePeerId: this.id,
+            sessionId,
+            initiator
+          }, {
+            F: __dxlog_file3,
+            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_async3.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_log4.log.info("connection error, closing", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        initiator,
+        err
+      }, {
+        F: __dxlog_file3,
+        L: 330,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      import_log4.log.trace("dxos.mesh.connection.error", {
+        topic: this.topic,
+        localPeerId: this.localPeerId,
+        remotePeerId: this.id,
+        sessionId,
+        initiator,
+        err
+      }, {
+        F: __dxlog_file3,
+        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_log4.log)("closing...", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      F: __dxlog_file3,
+      L: 362,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await connection.close(err);
+    (0, import_log4.log)("closed", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      F: __dxlog_file3,
+      L: 368,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async onSignal(message) {
+    if (!this.connection) {
+      (0, import_log4.log)("dropping signal message for non-existent connection", {
+        message
+      }, {
+        F: __dxlog_file3,
+        L: 373,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    await this.connection.signal(message);
+  }
+  async destroy(reason) {
+    await this._ctx.dispose();
+    (0, import_log4.log)("Destroying peer", {
+      peerId: this.id,
+      topic: this.topic
+    }, {
+      F: __dxlog_file3,
+      L: 383,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this?.connection?.close(reason);
+  }
+};
+_ts_decorate2([
+  import_async3.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;
+};
+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 = "/home/runner/work/dxos/dxos/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_context3.Context();
+    this._listeningHandle = void 0;
+    this._peers = new import_util2.ComplexMap(import_keys3.PublicKey.hash);
+    this._instanceId = import_keys3.PublicKey.random().toHex();
+    this.connectionAdded = new import_async2.Event();
+    this.disconnected = new import_async2.Event();
+    this.connected = new import_async2.Event();
+    this.errors = new import_debug2.ErrorStream();
+    import_log3.log.trace("dxos.mesh.swarm.constructor", import_protocols3.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_log3.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_log3.log.trace("dxos.mesh.swarm.constructor", import_protocols3.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_invariant3.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_log3.log.info("Error while receiving message", {
+          err
+        }, {
+          F: __dxlog_file4,
+          L: 136,
+          S: this,
+          C: (f, a) => f(...a)
+        }));
+      }
+    });
+  }
+  async destroy() {
+    (0, import_log3.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_log3.log)("destroyed", void 0, {
+      F: __dxlog_file4,
+      L: 149,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async setTopology(topology) {
+    (0, import_invariant3.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_log3.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_log3.log)("swarm event", {
+      swarmEvent
+    }, {
+      F: __dxlog_file4,
+      L: 170,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      (0, import_log3.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_keys3.PublicKey.from(swarmEvent.peerAvailable.peer);
+      (0, import_log3.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_keys3.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_log3.log.catch(err, void 0, {
+            F: __dxlog_file4,
+            L: 190,
+            S: this,
+            C: (f, a) => f(...a)
+          }));
+        }
+      } else {
+        (0, import_log3.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_log3.log)("offer", {
+      message
+    }, {
+      F: __dxlog_file4,
+      L: 202,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      (0, import_log3.log)("ignored for disposed swarm", void 0, {
+        F: __dxlog_file4,
+        L: 204,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
+    (0, import_invariant3.invariant)(message.author, void 0, {
+      F: __dxlog_file4,
+      L: 209,
+      S: this,
+      A: [
+        "message.author",
+        ""
+      ]
+    });
+    if (!message.recipient?.equals(this._ownPeerId)) {
+      (0, import_log3.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_log3.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_log3.log)("signal", {
+      message
+    }, {
+      F: __dxlog_file4,
+      L: 226,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ctx.disposed) {
+      import_log3.log.info("ignored for offline swarm", void 0, {
+        F: __dxlog_file4,
+        L: 228,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    (0, import_invariant3.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_invariant3.invariant)(message.topic?.equals(this._topic), void 0, {
+      F: __dxlog_file4,
+      L: 235,
+      S: this,
+      A: [
+        "message.topic?.equals(this._topic)",
+        ""
+      ]
+    });
+    (0, import_invariant3.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_context3.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_log3.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_invariant3.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_async2.scheduleTask)(this._ctx, async () => {
+          try {
+            await this._initiateConnection(peer);
+          } catch (err) {
+            (0, import_log3.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_async2.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_log3.log)("initiation delay", {
+        remoteId
+      }, {
+        F: __dxlog_file4,
+        L: 360,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await (0, import_async2.sleep)(this._initiationDelay);
+    }
+    if (ctx.disposed) {
+      return;
+    }
+    const peer = this._getOrCreatePeer(remoteId);
+    if (peer.connection) {
+      return;
+    }
+    (0, import_log3.log)("initiating connection...", {
+      remoteId
+    }, {
+      F: __dxlog_file4,
+      L: 374,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await peer.initiateConnection();
+    this._topology.update();
+    (0, import_log3.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_log3.logInfo
+], Swarm.prototype, "_instanceId", void 0);
+_ts_decorate3([
+  import_log3.logInfo
+], Swarm.prototype, "ownPeerId", null);
+_ts_decorate3([
+  import_log3.logInfo
+], Swarm.prototype, "topic", null);
+_ts_decorate3([
+  import_async2.synchronized
+], Swarm.prototype, "onSwarmEvent", null);
+_ts_decorate3([
+  import_async2.synchronized
+], Swarm.prototype, "onOffer", null);
+_ts_decorate3([
+  import_async2.synchronized
+], Swarm.prototype, "goOffline", null);
+_ts_decorate3([
+  import_async2.synchronized
+], Swarm.prototype, "goOnline", null);
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/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();
+  }
+};
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/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();
+    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();
+  }
+};
+var CONNECTION_GC_THRESHOLD = 1e3 * 60 * 15;
+var EventType;
+(function(EventType2) {
+  EventType2["CONNECTION_STATE_CHANGED"] = "CONNECTION_STATE_CHANGED";
+  EventType2["PROTOCOL_ERROR"] = "PROTOCOL_ERROR";
+  EventType2["PROTOCOL_EXTENSIONS_INITIALIZED"] = "PROTOCOL_EXTENSIONS_INITIALIZED";
+  EventType2["PROTOCOL_EXTENSIONS_HANDSHAKE"] = "PROTOCOL_EXTENSIONS_HANDSHAKE";
+  EventType2["PROTOCOL_HANDSHAKE"] = "PROTOCOL_HANDSHAKE";
+})(EventType || (EventType = {}));
+var ConnectionLog = class {
+  constructor() {
+    this._swarms = new import_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: [],
+        lastUpdate: /* @__PURE__ */ new Date()
+      };
+      info.connections.push(connectionInfo);
+      this.update.emit();
+      connection.stateChanged.on(async (state) => {
+        connectionInfo.state = state;
+        connectionInfo.closeReason = connection.closeReason;
+        connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
+        connectionInfo.events.push({
+          type: EventType.CONNECTION_STATE_CHANGED,
+          newState: state
+        });
+        if (state === ConnectionState.CONNECTED) {
+          const details = await connection.transport?.getDetails();
+          connectionInfo.transportDetails = details;
+        }
+        this.update.emit();
+      });
+      connection.protocol?.stats?.on((stats) => {
+        connectionInfo.readBufferSize = stats.readBufferSize;
+        connectionInfo.writeBufferSize = stats.writeBufferSize;
+        connectionInfo.streams = stats.channels;
+        connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
+        this.update.emit();
+      });
+      connection.transportStats?.on((stats) => {
+        connectionInfo.transportBytesSent = stats.bytesSent;
+        connectionInfo.transportBytesReceived = stats.bytesReceived;
+        connectionInfo.transportPacketsSent = stats.packetsSent;
+        connectionInfo.transportPacketsReceived = stats.packetsReceived;
+      });
+      gcSwarm(info);
+    });
+  }
+  leftSwarm(swarm) {
+    this.getSwarmInfo(import_keys7.PublicKey.from(swarm._instanceId)).isActive = false;
+    this.update.emit();
+  }
+};
+var gcSwarm = (swarm) => {
+  swarm.connections = swarm.connections?.filter((connection) => {
+    return connection.lastUpdate ? Date.now() - connection.lastUpdate.getTime() < CONNECTION_GC_THRESHOLD : true;
+  });
+};
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
+var NetworkManager = class {
+  constructor({ transportFactory, signalManager, log: log1 }) {
+    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);
+  }
+};
+var __dxlog_file8 = "/home/runner/work/dxos/dxos/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() {
+  }
+};
+var __dxlog_file9 = "/home/runner/work/dxos/dxos/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())));
+var __dxlog_file10 = "/home/runner/work/dxos/dxos/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() {
+  }
+};
+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 = "/home/runner/work/dxos/dxos/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 {
+    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);
+    }
+  }
+  async getDetails() {
+    return this._instanceId.toHex();
+  }
+  async getStats() {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0
+    };
+  }
+};
+_ts_decorate4([
+  import_log10.logInfo
+], MemoryTransport.prototype, "_instanceId", void 0);
+_ts_decorate4([
+  import_log10.logInfo
+], MemoryTransport.prototype, "_remoteInstanceId", void 0);
+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 = {}));
+var wrtc = null;
+try {
+  wrtc = (0, import_chunk_DMWORJG3.__require)("@koush/wrtc");
+} catch {
+}
+var __dxlog_file12 = "/home/runner/work/dxos/dxos/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 {
+          import_log11.log.info("unknown RTCError", {
+            err
+          }, {
+            F: __dxlog_file12,
+            L: 74,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          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: 79,
+          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_SIGNALING":
+            this.errors.raise(new import_protocols7.ConnectivityError("signaling failure", err));
+            break;
+          case "ERR_ICE_CONNECTION_FAILURE":
+          case "ERR_DATA_CHANNEL":
+          case "ERR_CONNECTION_FAILURE":
+            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: 105,
+          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: Object.fromEntries(stats.entries())
+            }, {
+              F: __dxlog_file12,
+              L: 113,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          });
+        }
+      } catch (err2) {
+        import_log11.log.catch(err2, void 0, {
+          F: __dxlog_file12,
+          L: 120,
+          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: 126,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async getStats() {
+    const stats = await this._getStats();
+    if (!stats) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: {}
+      };
+    }
+    return {
+      bytesSent: stats.transport.bytesSent,
+      bytesReceived: stats.transport.bytesReceived,
+      packetsSent: stats.transport.messagesSent,
+      packetsReceived: stats.transport.messagesReceived,
+      rawStats: stats.raw
+    };
+  }
+  async _getStats() {
+    if (typeof this._peer?._pc?.getStats !== "function") {
+      return null;
+    }
+    return await this._peer._pc.getStats().then((stats) => {
+      const statsEntries = Array.from(stats.entries());
+      const transport = statsEntries.filter((s) => s[1].type === "transport")[0][1];
+      const candidatePair = statsEntries.filter((s) => s[0] === transport.selectedCandidatePairId);
+      let selectedCandidatePair;
+      let remoteCandidate;
+      if (candidatePair.length > 0) {
+        selectedCandidatePair = candidatePair[0][1];
+        remoteCandidate = statsEntries.filter((s) => s[0] === selectedCandidatePair.remoteCandidateId)[0][1];
+      }
+      return {
+        datachannel: statsEntries.filter((s) => s[1].type === "data-channel")[0][1],
+        transport,
+        selectedCandidatePair,
+        remoteCandidate,
+        raw: Object.fromEntries(stats.entries())
+      };
+    });
+  }
+  async getDetails() {
+    const stats = await this._getStats();
+    const rc = stats?.remoteCandidate;
+    if (!rc) {
+      return "unavailable";
+    }
+    if (rc.relay) {
+      return `${rc.ip}:${rc.port}/${rc.protocol} relay for XXX ${rc.candidateType}`;
+    }
+    return `${rc.ip}:${rc.port}/${rc.protocol} ${rc.candidateType}`;
+  }
+  async destroy() {
+    (0, import_log11.log)("closing...", void 0, {
+      F: __dxlog_file12,
+      L: 189,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._disconnectStreams();
+    this._peer.destroy();
+    this._closed = true;
+    this.closed.emit();
+    (0, import_log11.log)("closed", void 0, {
+      F: __dxlog_file12,
+      L: 198,
+      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
+  })
+});
+var __dxlog_file13 = "/home/runner/work/dxos/dxos/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: 116,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    });
+    await this.transports.get(proxyId).transport.signal(signal);
+  }
+  async getDetails({ proxyId }) {
+    (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
+      F: __dxlog_file13,
+      L: 121,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    });
+    return {
+      details: await this.transports.get(proxyId).transport.getDetails()
+    };
+  }
+  async getStats({ proxyId }) {
+    (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
+      F: __dxlog_file13,
+      L: 126,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    });
+    return {
+      stats: await this.transports.get(proxyId).transport.getStats()
+    };
+  }
+  async sendData({ proxyId, payload }) {
+    if (this.transports.get(proxyId)?.state !== "OPEN") {
+      import_log12.log.debug("transport is closed", void 0, {
+        F: __dxlog_file13,
+        L: 132,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
+      F: __dxlog_file13,
+      L: 134,
+      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: 150,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/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)));
+  }
+  async getDetails() {
+    return (await this._params.bridgeService.getDetails({
+      proxyId: this._proxyId
+    })).details;
+  }
+  async getStats() {
+    return (await this._params.bridgeService.getStats({
+      proxyId: this._proxyId
+    })).stats;
+  }
+  // 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: 168,
+        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: 205,
+      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;
+  }
+};
+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 = "/home/runner/work/dxos/dxos/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: PeerConnection } = await import("./datachannel-ABYQKZRC.cjs");
+      if (this._closed) {
+        this.errors.raise(new Error("connection already closed"));
+      }
+      const peer = new PeerConnection(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: async (chunk, encoding, callback) => {
+          if (chunk.length > MAX_MESSAGE_SIZE) {
+            this.errors.raise(new Error(`message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}`));
+          }
+          try {
+            dataChannel.send(chunk);
+          } catch (err) {
+            this.errors.raise(err);
+            await this._close();
+          }
+          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: 143,
+                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: 163,
+        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: 198,
+              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: 209,
+              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: 220,
+              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: 231,
+            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: 236,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  }
+  async getDetails() {
+    return this._peer.then(async (peer) => {
+      const cp = await peer.getSelectedCandidatePair();
+      if (!cp) {
+        return "unavailable";
+      }
+      return `${cp.remote.address}:${cp.remote.port}/${cp.remote.transportType} ${cp.remote.type}`;
+    }).catch((err) => {
+      import_log14.log.catch(err, void 0, {
+        F: __dxlog_file15,
+        L: 250,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return "unavailable";
+    });
+  }
+  async getStats() {
+    return this._peer.then((peer) => {
+      return {
+        bytesSent: peer.bytesSent(),
+        bytesReceived: peer.bytesReceived(),
+        packetsSent: 0,
+        packetsReceived: 0
+      };
+    }).catch((err) => {
+      import_log14.log.catch(err, void 0, {
+        F: __dxlog_file15,
+        L: 266,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0
+      };
+    });
+  }
+  // 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
+  })
+});
+var __dxlog_file16 = "/home/runner/work/dxos/dxos/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"
+    });
+  }
+  async getDetails() {
+    if (this.options.initiator) {
+      const { port: port2, address: address2 } = this._server?.address();
+      return `LISTEN ${address2}:${port2}`;
+    }
+    const { port, address } = this._socket?.address();
+    return `ACCEPT ${address}:${port}`;
+  }
+  async getStats() {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0
+    };
+  }
+  _handleSocket(socket) {
+    (0, import_log15.log)("handling socket", {
+      remotePort: socket.remotePort,
+      localPort: socket.localPort
+    }, {
+      F: __dxlog_file16,
+      L: 109,
+      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: 115,
+        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();
+    });
+  }
+};
+var createTeleportProtocolFactory = (onConnection) => {
+  return (params) => {
+    const teleport = new import_teleport.Teleport(params);
+    return {
+      stream: teleport.stream,
+      open: async (sessionId) => {
+        await teleport.open(sessionId);
+        await onConnection(teleport);
+      },
+      close: async () => {
+        await teleport.close();
+      },
+      abort: async () => {
+        await teleport.abort();
+      }
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Connection,
+  ConnectionLimiter,
+  ConnectionLog,
+  ConnectionState,
+  EventType,
+  FullyConnectedTopology,
+  LibDataChannelTransport,
+  MAX_CONCURRENT_INITIATING_CONNECTIONS,
+  MMSTTopology,
+  MemoryTransport,
+  MemoryTransportFactory,
+  NetworkManager,
+  SimplePeerTransport,
+  SimplePeerTransportProxy,
+  SimplePeerTransportProxyFactory,
+  SimplePeerTransportService,
+  StarTopology,
+  Swarm,
+  SwarmMapper,
+  SwarmMessenger,
+  TcpTransport,
+  TcpTransportFactory,
+  TransportKind,
+  createLibDataChannelTransportFactory,
+  createSimplePeerTransportFactory,
+  createTeleportProtocolFactory
+});
+//# sourceMappingURL=chunk-3SCPMSHV.cjs.map