@dxos/network-manager 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/dist/lib/browser/{chunk-HQNQOWFA.mjs → chunk-LRGOUKHO.mjs}

@@ -1,25 +1,24 @@
 import "@dxos/node-std/globals";
 
 // src/swarm/connection.ts
-import { DeferredTask, Event, sleep, scheduleTask, scheduleTaskInterval, synchronized, Trigger } from "@dxos/async";
-import { Context, cancelWithContext, ContextDisposedError } from "@dxos/context";
+import { DeferredTask, Event, Trigger, scheduleTask, scheduleTaskInterval, sleep, synchronized } from "@dxos/async";
+import { Context, ContextDisposedError, cancelWithContext } from "@dxos/context";
 import { ErrorStream } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
 import { log, logInfo } from "@dxos/log";
-import { CancelledError, ProtocolError, ConnectionResetError, ConnectivityError, TimeoutError, trace } from "@dxos/protocols";
+import { CancelledError, ConnectionResetError, ConnectivityError, ProtocolError, TimeoutError } from "@dxos/protocols";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
 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 = "/__w/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 = /* @__PURE__ */ function(ConnectionState5) {
+var ConnectionState = /* @__PURE__ */ (function(ConnectionState5) {
   ConnectionState5["CREATED"] = "CREATED";
   ConnectionState5["INITIAL"] = "INITIAL";
   ConnectionState5["CONNECTING"] = "CONNECTING";
@@ -29,8 +28,33 @@ var ConnectionState = /* @__PURE__ */ function(ConnectionState5) {
   ConnectionState5["ABORTING"] = "ABORTING";
   ConnectionState5["ABORTED"] = "ABORTED";
   return ConnectionState5;
-}({});
+})({});
 var Connection = class {
+  topic;
+  localInfo;
+  remoteInfo;
+  sessionId;
+  initiator;
+  _signalMessaging;
+  _protocol;
+  _transportFactory;
+  _callbacks;
+  _ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 66 });
+  connectedTimeoutContext = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67 });
+  _protocolClosed = new Trigger();
+  _transportClosed = new Trigger();
+  _state = "CREATED";
+  _transport;
+  closeReason;
+  _incomingSignalBuffer = [];
+  _outgoingSignalBuffer = [];
+  stateChanged = new Event();
+  errors = new ErrorStream();
+  transportStats = new Event();
+  _signalSendTask = new DeferredTask(this._ctx, async () => {
+    await this._flushSignalBuffer(this._ctx);
+  });
+  _signallingDelay = STARTING_SIGNALLING_DELAY;
   constructor(topic, localInfo, remoteInfo, sessionId, initiator, _signalMessaging, _protocol, _transportFactory, _callbacks) {
     this.topic = topic;
     this.localInfo = localInfo;
@@ -41,39 +65,13 @@ var Connection = class {
     this._protocol = _protocol;
     this._transportFactory = _transportFactory;
     this._callbacks = _callbacks;
-    this._ctx = new Context(void 0, {
-      F: __dxlog_file,
-      L: 100
-    });
-    this.connectedTimeoutContext = new Context(void 0, {
-      F: __dxlog_file,
-      L: 101
-    });
-    this._protocolClosed = new Trigger();
-    this._transportClosed = new Trigger();
-    this._state = "CREATED";
-    this._incomingSignalBuffer = [];
-    this._outgoingSignalBuffer = [];
-    this.stateChanged = new Event();
-    this.errors = new ErrorStream();
-    this._instanceId = PublicKey.random().toHex();
-    this.transportStats = new Event();
-    this._signalSendTask = new DeferredTask(this._ctx, async () => {
-      await this._flushSignalBuffer();
-    });
-    this._signallingDelay = STARTING_SIGNALLING_DELAY;
     log.trace("dxos.mesh.connection.construct", {
       sessionId: this.sessionId,
       topic: this.topic,
       localPeer: this.localInfo,
       remotePeer: this.remoteInfo,
       initiator: this.initiator
-    }, {
-      F: __dxlog_file,
-      L: 137,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 92, S: this });
   }
   get sessionIdString() {
     return this.sessionId.truncate();
@@ -91,69 +89,35 @@ var Connection = class {
   * Create an underlying transport and prepares it for the connection.
   */
   async openConnection() {
-    invariant(this._state === "INITIAL", "Invalid state.", {
-      F: __dxlog_file,
-      L: 167,
-      S: this,
-      A: [
-        "this._state === ConnectionState.INITIAL",
-        "'Invalid state.'"
-      ]
-    });
-    log.trace("dxos.mesh.connection.open-connection", trace.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file,
-      L: 168,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    invariant(this._state === "INITIAL", "Invalid state.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 115, S: this, A: ['this._state === "INITIAL"', "'Invalid state.'"] });
+    log("opening connection", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 116, S: this });
     log.trace("dxos.mesh.connection.open", {
       sessionId: this.sessionId,
       topic: this.topic,
       localPeerId: this.localInfo,
       remotePeerId: this.remoteInfo,
       initiator: this.initiator
-    }, {
-      F: __dxlog_file,
-      L: 169,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 117, S: this });
     this._changeState("CONNECTING");
     this._protocol.open(this.sessionId).catch((err) => {
       this.errors.raise(err);
     });
     this._protocol.stream.on("close", () => {
-      log("protocol stream closed", void 0, {
-        F: __dxlog_file,
-        L: 186,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log("protocol stream closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: this });
       this._protocolClosed.wake();
       this.close({
-        error: new ProtocolError("protocol stream closed")
+        error: new ProtocolError({
+          message: "protocol stream closed"
+        })
       }).catch((err) => this.errors.raise(err));
     });
     scheduleTask(this.connectedTimeoutContext, async () => {
-      log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, {
-        F: __dxlog_file,
-        L: 194,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      await this.abort(new TimeoutError(`${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect`)).catch((err) => this.errors.raise(err));
+      log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 140, S: this });
+      await this.abort(new TimeoutError({
+        message: `${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect`
+      })).catch((err) => this.errors.raise(err));
     }, TRANSPORT_CONNECTION_TIMEOUT);
-    invariant(!this._transport, void 0, {
-      F: __dxlog_file,
-      L: 202,
-      S: this,
-      A: [
-        "!this._transport",
-        ""
-      ]
-    });
+    invariant(!this._transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 145, S: this, A: ["!this._transport", ""] });
     this._transport = this._transportFactory.createTransport({
       ownPeerKey: this.localInfo.peerKey,
       remotePeerKey: this.remoteInfo.peerKey,
@@ -172,41 +136,21 @@ var Connection = class {
     this._transport.closed.once(() => {
       this._transport = void 0;
       this._transportClosed.wake();
-      log("abort triggered by transport close", void 0, {
-        F: __dxlog_file,
-        L: 224,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log("abort triggered by transport close", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 164, S: this });
       this.abort().catch((err) => this.errors.raise(err));
     });
     this._transport.errors.handle(async (err) => {
       log("transport error:", {
         err
-      }, {
-        F: __dxlog_file,
-        L: 229,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 168, S: this });
       if (!this.closeReason) {
         this.closeReason = err?.message;
       }
       if (err instanceof ConnectionResetError) {
-        log.info("aborting due to transport ConnectionResetError", void 0, {
-          F: __dxlog_file,
-          L: 236,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log.info("aborting due to transport ConnectionResetError", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 176, S: this });
         this.abort(err).catch((err2) => this.errors.raise(err2));
       } else if (err instanceof ConnectivityError) {
-        log.info("aborting due to transport ConnectivityError", void 0, {
-          F: __dxlog_file,
-          L: 239,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log.info("aborting due to transport ConnectivityError", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 179, S: this });
         this.abort(err).catch((err2) => this.errors.raise(err2));
       }
       if (this._state !== "CLOSED" && this._state !== "CLOSING") {
@@ -219,31 +163,14 @@ var Connection = class {
       void this._transport.onSignal(signal);
     }
     this._incomingSignalBuffer = [];
-    log.trace("dxos.mesh.connection.open-connection", trace.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file,
-      L: 258,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log("opened connection", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: this });
   }
   async abort(err) {
     log("abort", {
       err
-    }, {
-      F: __dxlog_file,
-      L: 265,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 196, S: this });
     if (this._state === "CLOSED" || this._state === "ABORTED") {
-      log(`abort ignored: already ${this._state}`, this.closeReason, {
-        F: __dxlog_file,
-        L: 267,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log(`abort ignored: already ${this._state}`, this.closeReason, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 200, S: this });
       return;
     }
     await this.connectedTimeoutContext.dispose();
@@ -255,55 +182,30 @@ var Connection = class {
     log("aborting...", {
       peerId: this.localInfo,
       err
-    }, {
-      F: __dxlog_file,
-      L: 279,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 209, S: this });
     try {
       await this._closeProtocol({
         abort: true
       });
     } catch (err2) {
-      log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 285,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 219, S: this });
     }
     try {
       await this._closeTransport();
     } catch (err2) {
-      log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 292,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 225, S: this });
     }
     try {
       this._callbacks?.onClosed?.(err);
     } catch (err2) {
-      log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 298,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 230, S: this });
     }
     this._changeState("ABORTED");
   }
   async close({ error, reason } = {}) {
     log("close", {
       error
-    }, {
-      F: __dxlog_file,
-      L: 305,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 235, S: this });
     if (!this.closeReason) {
       this.closeReason = reason ?? error?.message;
     } else {
@@ -313,12 +215,7 @@ var Connection = class {
       log("close ignored: already in progress", {
         state: this._state,
         error
-      }, {
-        F: __dxlog_file,
-        L: 316,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 244, S: this });
       return;
     }
     const lastState = this._state;
@@ -327,111 +224,66 @@ var Connection = class {
     await this._ctx.dispose();
     let abortProtocol = false;
     if (lastState !== "CONNECTED" || error != null) {
-      log(`graceful close requested when we were in ${lastState} state? aborting`, void 0, {
-        F: __dxlog_file,
-        L: 327,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log(`graceful close requested when we were in ${lastState} state? aborting`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 256, S: this });
       abortProtocol = true;
     }
     log("closing...", {
       peerId: this.localInfo,
       abortProtocol,
       error
-    }, {
-      F: __dxlog_file,
-      L: 331,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 259, S: this });
     try {
       await this._closeProtocol({
         abort: abortProtocol
       });
     } catch (err) {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
-        L: 336,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 269, S: this });
     }
     try {
       await this._closeTransport();
     } catch (err) {
-      log.catch(err, void 0, {
-        F: __dxlog_file,
-        L: 342,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 275, S: this });
     }
     log("closed", {
       peerId: this.localInfo
-    }, {
-      F: __dxlog_file,
-      L: 345,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, S: this });
     this._changeState("CLOSED");
     this._callbacks?.onClosed?.(error);
   }
   async _closeProtocol(options) {
-    log("closing protocol", options, {
-      F: __dxlog_file,
-      L: 351,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log("closing protocol", options, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 284, S: this });
     await Promise.race([
       options?.abort ? this._protocol.abort() : this._protocol.close(),
       this._protocolClosed.wait()
     ]);
-    log("protocol closed", options, {
-      F: __dxlog_file,
-      L: 353,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log("protocol closed", options, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 289, S: this });
   }
   async _closeTransport() {
-    log("closing transport", void 0, {
-      F: __dxlog_file,
-      L: 357,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log("closing transport", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 292, S: this });
     await Promise.race([
       this._transport?.close(),
       this._transportClosed.wait()
     ]);
-    log("transport closed", void 0, {
-      F: __dxlog_file,
-      L: 359,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log("transport closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 297, S: this });
   }
   _sendSignal(signal) {
     this._outgoingSignalBuffer.push(signal);
     this._signalSendTask.schedule();
   }
-  async _flushSignalBuffer() {
+  async _flushSignalBuffer(ctx) {
     if (this._outgoingSignalBuffer.length === 0) {
       return;
     }
     try {
       if (true) {
-        await cancelWithContext(this._ctx, sleep(this._signallingDelay));
+        await cancelWithContext(ctx, 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({
+      await this._signalMessaging.signal(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId: this.sessionId,
@@ -448,66 +300,27 @@ var Connection = class {
       }
       log.info("signal message failed to deliver", {
         err
-      }, {
-        F: __dxlog_file,
-        L: 399,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 333, S: this });
       await this.close({
-        error: new ConnectivityError("signal message failed to deliver", err)
+        error: new ConnectivityError({
+          message: "signal message failed to deliver",
+          cause: err
+        })
       });
     }
   }
   /**
   * Receive a signal from the remote peer.
   */
-  async signal(msg) {
-    invariant(msg.sessionId, void 0, {
-      F: __dxlog_file,
-      L: 408,
-      S: this,
-      A: [
-        "msg.sessionId",
-        ""
-      ]
-    });
+  async signal(_ctx, msg) {
+    invariant(msg.sessionId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 347, S: this, A: ["msg.sessionId", ""] });
     if (!msg.sessionId.equals(this.sessionId)) {
-      log("dropping signal for incorrect session id", void 0, {
-        F: __dxlog_file,
-        L: 410,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log("dropping signal for incorrect session id", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 349, S: this });
       return;
     }
-    invariant(msg.data.signal || msg.data.signalBatch, void 0, {
-      F: __dxlog_file,
-      L: 413,
-      S: this,
-      A: [
-        "msg.data.signal || msg.data.signalBatch",
-        ""
-      ]
-    });
-    invariant(msg.author.peerKey === this.remoteInfo.peerKey, void 0, {
-      F: __dxlog_file,
-      L: 414,
-      S: this,
-      A: [
-        "msg.author.peerKey === this.remoteInfo.peerKey",
-        ""
-      ]
-    });
-    invariant(msg.recipient.peerKey === this.localInfo.peerKey, void 0, {
-      F: __dxlog_file,
-      L: 415,
-      S: this,
-      A: [
-        "msg.recipient.peerKey === this.localInfo.peerKey",
-        ""
-      ]
-    });
+    invariant(msg.data.signal || msg.data.signalBatch, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 352, S: this, A: ["msg.data.signal || msg.data.signalBatch", ""] });
+    invariant(msg.author.peerKey === this.remoteInfo.peerKey, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 353, S: this, A: ["msg.author.peerKey === this.remoteInfo.peerKey", ""] });
+    invariant(msg.recipient.peerKey === this.localInfo.peerKey, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 354, S: this, A: ["msg.recipient.peerKey === this.localInfo.peerKey", ""] });
     const signals = msg.data.signalBatch ? msg.data.signalBatch.signals ?? [] : [
       msg.data.signal
     ];
@@ -523,33 +336,15 @@ var Connection = class {
           peerId: this.localInfo,
           remoteId: this.remoteInfo,
           msg: msg.data
-        }, {
-          F: __dxlog_file,
-          L: 424,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 366, S: this });
         this._incomingSignalBuffer.push(signal);
       } else {
-        invariant(this._transport, "Connection not ready to accept signals.", {
-          F: __dxlog_file,
-          L: 427,
-          S: this,
-          A: [
-            "this._transport",
-            "'Connection not ready to accept signals.'"
-          ]
-        });
+        invariant(this._transport, "Connection not ready to accept signals.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 373, S: this, A: ["this._transport", "'Connection not ready to accept signals.'"] });
         log("received signal", {
           peerId: this.localInfo,
           remoteId: this.remoteInfo,
           msg: msg.data
-        }, {
-          F: __dxlog_file,
-          L: 428,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 374, S: this });
         await this._transport.onSignal(signal);
       }
     }
@@ -562,21 +357,8 @@ var Connection = class {
       from: this._state,
       to: state,
       peerId: this.localInfo
-    }, {
-      F: __dxlog_file,
-      L: 439,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    invariant(state !== this._state, "Already in this state.", {
-      F: __dxlog_file,
-      L: 440,
-      S: this,
-      A: [
-        "state !== this._state",
-        "'Already in this state.'"
-      ]
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 387, S: this });
+    invariant(state !== this._state, "Already in this state.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 392, S: this, A: ["state !== this._state", "'Already in this state.'"] });
     this._state = state;
     this.stateChanged.emit(state);
   }
@@ -597,62 +379,28 @@ _ts_decorate([
   synchronized
 ], Connection.prototype, "close", null);
 
-// src/signal/ice.ts
-import { asyncTimeout } from "@dxos/async";
-import { log as log2 } from "@dxos/log";
-import { isNonNullable } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/signal/ice.ts";
-var createIceProvider = (iceProviders) => {
-  let cachedIceServers;
-  return {
-    getIceServers: async () => {
-      if (cachedIceServers) {
-        return cachedIceServers;
-      }
-      cachedIceServers = (await Promise.all(iceProviders.map(({ urls }) => asyncTimeout(fetch(urls, {
-        method: "GET"
-      }), 1e4).then((response) => response.json()).catch((err) => {
-        const isDev = typeof window !== "undefined" && window.location.href.includes("localhost");
-        if (!isDev) {
-          log2.error("Failed to fetch ICE servers from provider", {
-            urls,
-            err
-          }, {
-            F: __dxlog_file2,
-            L: 30,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-        }
-      })))).filter(isNonNullable).map(({ iceServers }) => iceServers).flat();
-      return cachedIceServers;
-    }
-  };
-};
-
 // src/signal/swarm-messenger.ts
-import { Context as Context2 } from "@dxos/context";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log3 } from "@dxos/log";
+import { PublicKey } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
 import { TimeoutError as TimeoutError2 } from "@dxos/protocols";
 import { schema } from "@dxos/protocols/proto";
 import { ComplexMap } from "@dxos/util";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
 var SwarmMessage = schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
 var SwarmMessenger = class {
+  _sendMessage;
+  _onSignal;
+  _onOffer;
+  _topic;
+  _offerRecords = new ComplexMap((key) => key.toHex());
   constructor({ sendMessage, onSignal, onOffer, topic }) {
-    this._ctx = new Context2(void 0, {
-      F: __dxlog_file3,
-      L: 35
-    });
-    this._offerRecords = new ComplexMap((key) => key.toHex());
     this._sendMessage = sendMessage;
     this._onSignal = onSignal;
     this._onOffer = onOffer;
     this._topic = topic;
   }
-  async receiveMessage({ author, recipient, payload }) {
+  async receiveMessage(ctx, { author, recipient, payload }) {
     if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
       return;
     }
@@ -660,18 +408,13 @@ var SwarmMessenger = class {
     if (!this._topic.equals(message.topic)) {
       return;
     }
-    log3("received", {
+    log2("received", {
       from: author,
       to: recipient,
       msg: message
-    }, {
-      F: __dxlog_file3,
-      L: 71,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 35, S: this });
     if (message.data?.offer) {
-      await this._handleOffer({
+      await this._handleOffer(ctx, {
         author,
         recipient,
         message
@@ -679,77 +422,59 @@ var SwarmMessenger = class {
     } else if (message.data?.answer) {
       await this._resolveAnswers(message);
     } else if (message.data?.signal) {
-      await this._handleSignal({
+      await this._handleSignal(ctx, {
         author,
         recipient,
         message
       });
     } else if (message.data?.signalBatch) {
-      await this._handleSignal({
+      await this._handleSignal(ctx, {
         author,
         recipient,
         message
       });
     } else {
-      log3.warn("unknown message", {
+      log2.warn("unknown message", {
         message
-      }, {
-        F: __dxlog_file3,
-        L: 82,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 61, S: this });
     }
   }
-  async signal(message) {
-    invariant2(message.data?.signal || message.data?.signalBatch, "Invalid message", {
-      F: __dxlog_file3,
-      L: 87,
-      S: this,
-      A: [
-        "message.data?.signal || message.data?.signalBatch",
-        "'Invalid message'"
-      ]
-    });
-    await this._sendReliableMessage({
+  async signal(ctx, message) {
+    invariant2(message.data?.signal || message.data?.signalBatch, "Invalid message", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 67, S: this, A: ["message.data?.signal || message.data?.signalBatch", "'Invalid message'"] });
+    await this._sendReliableMessage(ctx, {
       author: message.author,
       recipient: message.recipient,
       message
     });
   }
-  async offer(message) {
+  async offer(ctx, message) {
     const networkMessage = {
       ...message,
-      messageId: PublicKey2.random()
+      messageId: PublicKey.random()
     };
     return new Promise((resolve, reject) => {
       this._offerRecords.set(networkMessage.messageId, {
         resolve
       });
-      this._sendReliableMessage({
+      this._sendReliableMessage(ctx, {
         author: message.author,
         recipient: message.recipient,
         message: networkMessage
       }).catch((err) => reject(err));
     });
   }
-  async _sendReliableMessage({ author, recipient, message }) {
+  async _sendReliableMessage(ctx, { author, recipient, message }) {
     const networkMessage = {
       ...message,
       // Setting unique message_id if it not specified yet.
-      messageId: message.messageId ?? PublicKey2.random()
+      messageId: message.messageId ?? PublicKey.random()
     };
-    log3("sending", {
+    log2("sending", {
       from: author,
       to: recipient,
       msg: networkMessage
-    }, {
-      F: __dxlog_file3,
-      L: 125,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._sendMessage({
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 96, S: this });
+    await this._sendMessage(ctx, {
       author,
       recipient,
       payload: {
@@ -759,48 +484,19 @@ var SwarmMessenger = class {
     });
   }
   async _resolveAnswers(message) {
-    invariant2(message.data?.answer?.offerMessageId, "No offerMessageId", {
-      F: __dxlog_file3,
-      L: 137,
-      S: this,
-      A: [
-        "message.data?.answer?.offerMessageId",
-        "'No offerMessageId'"
-      ]
-    });
+    invariant2(message.data?.answer?.offerMessageId, "No offerMessageId", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 111, 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);
-      invariant2(message.data?.answer, "No answer", {
-        F: __dxlog_file3,
-        L: 141,
-        S: this,
-        A: [
-          "message.data?.answer",
-          "'No answer'"
-        ]
-      });
-      log3("resolving", {
+      invariant2(message.data?.answer, "No answer", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 115, S: this, A: ["message.data?.answer", "'No answer'"] });
+      log2("resolving", {
         answer: message.data.answer
-      }, {
-        F: __dxlog_file3,
-        L: 142,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 116, S: this });
       offerRecord.resolve(message.data.answer);
     }
   }
-  async _handleOffer({ author, recipient, message }) {
-    invariant2(message.data.offer, "No offer", {
-      F: __dxlog_file3,
-      L: 156,
-      S: this,
-      A: [
-        "message.data.offer",
-        "'No offer'"
-      ]
-    });
+  async _handleOffer(ctx, { author, recipient, message }) {
+    invariant2(message.data.offer, "No offer", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 123, S: this, A: ["message.data.offer", "'No offer'"] });
     const offerMessage = {
       author,
       recipient,
@@ -809,10 +505,10 @@ var SwarmMessenger = class {
         offer: message.data.offer
       }
     };
-    const answer = await this._onOffer(offerMessage);
+    const answer = await this._onOffer(ctx, offerMessage);
     answer.offerMessageId = message.messageId;
     try {
-      await this._sendReliableMessage({
+      await this._sendReliableMessage(ctx, {
         author: recipient,
         recipient: author,
         message: {
@@ -825,45 +521,19 @@ var SwarmMessenger = class {
       });
     } catch (err) {
       if (err instanceof TimeoutError2) {
-        log3.info("timeout sending answer to offer", {
+        log2.info("timeout sending answer to offer", {
           err
-        }, {
-          F: __dxlog_file3,
-          L: 177,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 148, S: this });
       } else {
-        log3.info("error sending answer to offer", {
+        log2.info("error sending answer to offer", {
           err
-        }, {
-          F: __dxlog_file3,
-          L: 179,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 152, S: this });
       }
     }
   }
-  async _handleSignal({ author, recipient, message }) {
-    invariant2(message.messageId, void 0, {
-      F: __dxlog_file3,
-      L: 193,
-      S: this,
-      A: [
-        "message.messageId",
-        ""
-      ]
-    });
-    invariant2(message.data.signal || message.data.signalBatch, "Invalid message", {
-      F: __dxlog_file3,
-      L: 194,
-      S: this,
-      A: [
-        "message.data.signal || message.data.signalBatch",
-        "'Invalid message'"
-      ]
-    });
+  async _handleSignal(ctx, { author, recipient, message }) {
+    invariant2(message.messageId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 159, S: this, A: ["message.messageId", ""] });
+    invariant2(message.data.signal || message.data.signalBatch, "Invalid message", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 160, S: this, A: ["message.data.signal || message.data.signalBatch", "'Invalid message'"] });
     const signalMessage = {
       author,
       recipient,
@@ -873,42 +543,66 @@ var SwarmMessenger = class {
         signalBatch: message.data.signalBatch
       }
     };
-    await this._onSignal(signalMessage);
+    await this._onSignal(ctx, signalMessage);
   }
 };
 
 // src/swarm/swarm.ts
 import { Event as Event3, scheduleTask as scheduleTask3, sleep as sleep2, synchronized as synchronized3 } from "@dxos/async";
-import { Context as Context4 } from "@dxos/context";
+import { Context as Context3 } from "@dxos/context";
 import { ErrorStream as ErrorStream2 } from "@dxos/debug";
 import { invariant as invariant4 } from "@dxos/invariant";
-import { PublicKey as PublicKey4 } from "@dxos/keys";
-import { log as log5, logInfo as logInfo2 } from "@dxos/log";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
+import { log as log4, logInfo as logInfo2 } from "@dxos/log";
 import { PeerInfoHash } from "@dxos/messaging";
-import { trace as trace2 } from "@dxos/protocols";
-import { ComplexMap as ComplexMap2, isNonNullable as isNonNullable2 } from "@dxos/util";
+import { ComplexMap as ComplexMap2, isNonNullable } from "@dxos/util";
 
 // src/swarm/peer.ts
 import { Event as Event2, scheduleTask as scheduleTask2, synchronized as synchronized2 } from "@dxos/async";
-import { Context as Context3 } from "@dxos/context";
+import { Context as Context2 } from "@dxos/context";
 import { invariant as invariant3 } from "@dxos/invariant";
-import { PublicKey as PublicKey3 } from "@dxos/keys";
-import { log as log4 } from "@dxos/log";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
 import { CancelledError as CancelledError2, SystemError } from "@dxos/protocols";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
 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_file4 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
 var ConnectionDisplacedError = class extends SystemError {
   constructor() {
-    super("Connection displaced by remote initiator.");
+    super({
+      message: "Connection displaced by remote initiator."
+    });
   }
 };
 var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
 var Peer = class {
+  remoteInfo;
+  topic;
+  localInfo;
+  _signalMessaging;
+  _protocolProvider;
+  _transportFactory;
+  _connectionLimiter;
+  _callbacks;
+  /**
+  * Will be available to connect after this time.
+  */
+  _availableAfter = 0;
+  availableToConnect = true;
+  _lastConnectionTime;
+  _ctx = new Context2(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 44 });
+  _connectionCtx;
+  connection;
+  /**
+  * Whether the peer is currently advertizing itself on the signal-network.
+  */
+  advertizing = false;
+  initiating = false;
+  connectionDisplaced = new Event2();
   constructor(remoteInfo, topic, localInfo, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
     this.remoteInfo = remoteInfo;
     this.topic = topic;
@@ -918,49 +612,30 @@ var Peer = class {
     this._transportFactory = _transportFactory;
     this._connectionLimiter = _connectionLimiter;
     this._callbacks = _callbacks;
-    this._availableAfter = 0;
-    this.availableToConnect = true;
-    this._ctx = new Context3(void 0, {
-      F: __dxlog_file4,
-      L: 80
-    });
-    this.advertizing = false;
-    this.initiating = false;
-    this.connectionDisplaced = new Event2();
   }
   /**
   * Respond to remote offer.
   */
-  async onOffer(message) {
+  async onOffer(_ctx, message) {
     const remote = message.author;
     if (this.connection && ![
       ConnectionState.CREATED,
       ConnectionState.INITIAL,
       ConnectionState.CONNECTING
     ].includes(this.connection.state)) {
-      log4.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
-        F: __dxlog_file4,
-        L: 115,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log3.info(`received offer when connection already in ${this.connection.state} state`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 71, S: this });
       return {
         accept: false
       };
     }
     if (this.connection || this.initiating) {
       if (remote.peerKey < this.localInfo.peerKey) {
-        log4("close local connection", {
+        log3("close local connection", {
           localPeer: this.localInfo,
           topic: this.topic,
           remotePeer: this.remoteInfo,
           sessionId: this.connection?.sessionId
-        }, {
-          F: __dxlog_file4,
-          L: 124,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 82, S: this });
         if (this.connection) {
           await this.closeConnection(new ConnectionDisplacedError());
         }
@@ -972,15 +647,7 @@ var Peer = class {
     }
     if (await this._callbacks.onOffer(remote)) {
       if (!this.connection) {
-        invariant3(message.sessionId, void 0, {
-          F: __dxlog_file4,
-          L: 144,
-          S: this,
-          A: [
-            "message.sessionId",
-            ""
-          ]
-        });
+        invariant3(message.sessionId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 102, S: this, A: ["message.sessionId", ""] });
         const connection = this._createConnection(false, message.sessionId);
         try {
           await this._connectionLimiter.connecting(message.sessionId);
@@ -988,17 +655,12 @@ var Peer = class {
           await connection.openConnection();
         } catch (err) {
           if (!(err instanceof CancelledError2)) {
-            log4.info("connection error", {
+            log3.info("connection error", {
               topic: this.topic,
               peerId: this.localInfo,
               remoteId: this.remoteInfo,
               err
-            }, {
-              F: __dxlog_file4,
-              L: 154,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 110, S: this });
           }
           await this.closeConnection(err);
         }
@@ -1014,44 +676,23 @@ var Peer = class {
   /**
   * Initiate a connection to the remote peer.
   */
-  async initiateConnection() {
-    invariant3(!this.initiating, "Initiation in progress.", {
-      F: __dxlog_file4,
-      L: 171,
-      S: this,
-      A: [
-        "!this.initiating",
-        "'Initiation in progress.'"
-      ]
-    });
-    invariant3(!this.connection, "Already connected.", {
-      F: __dxlog_file4,
-      L: 172,
-      S: this,
-      A: [
-        "!this.connection",
-        "'Already connected.'"
-      ]
-    });
-    const sessionId = PublicKey3.random();
-    log4("initiating...", {
+  async initiateConnection(ctx) {
+    invariant3(!this.initiating, "Initiation in progress.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 132, S: this, A: ["!this.initiating", "'Initiation in progress.'"] });
+    invariant3(!this.connection, "Already connected.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 133, S: this, A: ["!this.connection", "'Already connected.'"] });
+    const sessionId = PublicKey2.random();
+    log3("initiating...", {
       local: this.localInfo,
       topic: this.topic,
       remote: this.remoteInfo,
       sessionId
-    }, {
-      F: __dxlog_file4,
-      L: 174,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 135, S: this });
     const connection = this._createConnection(true, sessionId);
     this.initiating = true;
     let answer;
     try {
       await this._connectionLimiter.connecting(sessionId);
       connection.initiate();
-      answer = await this._signalMessaging.offer({
+      answer = await this._signalMessaging.offer(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId,
@@ -1060,38 +701,23 @@ var Peer = class {
           offer: {}
         }
       });
-      log4("received", {
+      log3("received", {
         answer,
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file4,
-        L: 191,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 156, S: this });
       if (connection.state !== ConnectionState.INITIAL) {
-        log4("ignoring response", void 0, {
-          F: __dxlog_file4,
-          L: 193,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log3("ignoring response", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 163, S: this });
         return;
       }
     } catch (err) {
-      log4("initiation error: send offer", {
+      log3("initiation error: send offer", {
         err,
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file4,
-        L: 197,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 167, S: this });
       await connection.abort(err);
       throw err;
     } finally {
@@ -1103,51 +729,31 @@ var Peer = class {
         return;
       }
     } catch (err) {
-      log4("initiation error: accept answer", {
+      log3("initiation error: accept answer", {
         err,
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file4,
-        L: 210,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 184, S: this });
       await connection.abort(err);
       throw err;
     } finally {
       this.initiating = false;
     }
     try {
-      log4("opening connection as initiator", void 0, {
-        F: __dxlog_file4,
-        L: 223,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log3("opening connection as initiator", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 196, S: this });
       await connection.openConnection();
       this._callbacks.onAccepted();
     } catch (err) {
-      log4("initiation error: open connection", {
+      log3("initiation error: open connection", {
         err,
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file4,
-        L: 227,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      log4.warn("closing connection due to unhandled error on openConnection", {
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 200, S: this });
+      log3.warn("closing connection due to unhandled error on openConnection", {
         err
-      }, {
-        F: __dxlog_file4,
-        L: 234,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 207, S: this });
       await this.closeConnection(err);
       throw err;
     } finally {
@@ -1159,27 +765,14 @@ var Peer = class {
   * Either we're initiating a connection or creating one in response to an offer from the other peer.
   */
   _createConnection(initiator, sessionId) {
-    log4("creating connection", {
+    log3("creating connection", {
       topic: this.topic,
       peerId: this.localInfo,
       remoteId: this.remoteInfo,
       initiator,
       sessionId
-    }, {
-      F: __dxlog_file4,
-      L: 248,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    invariant3(!this.connection, "Already connected.", {
-      F: __dxlog_file4,
-      L: 255,
-      S: this,
-      A: [
-        "!this.connection",
-        "'Already connected.'"
-      ]
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 221, S: this });
+    invariant3(!this.connection, "Already connected.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 228, S: this, A: ["!this.connection", "'Already connected.'"] });
     const connection = new Connection(
       this.topic,
       this.localInfo,
@@ -1190,8 +783,8 @@ var Peer = class {
       // TODO(dmaretskyi): Init only when connection is established.
       this._protocolProvider({
         initiator,
-        localPeerId: PublicKey3.from(this.localInfo.peerKey),
-        remotePeerId: PublicKey3.from(this.remoteInfo.peerKey),
+        localPeerId: PublicKey2.from(this.localInfo.peerKey),
+        remotePeerId: PublicKey2.from(this.remoteInfo.peerKey),
         topic: this.topic
       }),
       this._transportFactory,
@@ -1201,18 +794,13 @@ var Peer = class {
           this._lastConnectionTime = Date.now();
           this._callbacks.onConnected();
           this._connectionLimiter.doneConnecting(sessionId);
-          log4.trace("dxos.mesh.connection.connected", {
+          log3.trace("dxos.mesh.connection.connected", {
             topic: this.topic,
             localPeerId: this.localInfo,
             remotePeerId: this.remoteInfo,
             sessionId,
             initiator
-          }, {
-            F: __dxlog_file4,
-            L: 279,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 241, S: this });
         },
         onClosed: (err) => {
           const logMeta = {
@@ -1221,34 +809,16 @@ var Peer = class {
             remoteId: this.remoteInfo,
             initiator
           };
-          log4("connection closed", logMeta, {
-            F: __dxlog_file4,
-            L: 289,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          log3("connection closed", logMeta, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 256, S: this });
           this._connectionLimiter.doneConnecting(sessionId);
-          invariant3(this.connection === connection, "Connection mismatch (race condition).", {
-            F: __dxlog_file4,
-            L: 294,
-            S: this,
-            A: [
-              "this.connection === connection",
-              "'Connection mismatch (race condition).'"
-            ]
-          });
-          log4.trace("dxos.mesh.connection.closed", {
+          invariant3(this.connection === connection, "Connection mismatch (race condition).", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 259, S: this, A: ["this.connection === connection", "'Connection mismatch (race condition).'"] });
+          log3.trace("dxos.mesh.connection.closed", {
             topic: this.topic,
             localPeerId: this.localInfo,
             remotePeerId: this.remoteInfo,
             sessionId,
             initiator
-          }, {
-            F: __dxlog_file4,
-            L: 296,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 260, S: this });
           if (err instanceof ConnectionDisplacedError) {
             this.connectionDisplaced.emit(this.connection);
           } else {
@@ -1260,12 +830,7 @@ var Peer = class {
             }
             this._callbacks.onDisconnected();
             scheduleTask2(this._connectionCtx, () => {
-              log4("peer became available", logMeta, {
-                F: __dxlog_file4,
-                L: 320,
-                S: this,
-                C: (f, a) => f(...a)
-              });
+              log3("peer became available", logMeta, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 279, S: this });
               this.availableToConnect = true;
               this._callbacks.onPeerAvailable();
             }, this._availableAfter);
@@ -1278,31 +843,21 @@ var Peer = class {
     void this._connectionCtx?.dispose();
     this._connectionCtx = this._ctx.derive();
     connection.errors.handle((err) => {
-      log4.info("connection error, closing", {
+      log3.info("connection error, closing", {
         topic: this.topic,
         peerId: this.localInfo,
         remoteId: this.remoteInfo,
         initiator,
         err
-      }, {
-        F: __dxlog_file4,
-        L: 338,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      log4.trace("dxos.mesh.connection.error", {
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 291, S: this });
+      log3.trace("dxos.mesh.connection.error", {
         topic: this.topic,
         localPeerId: this.localInfo,
         remotePeerId: this.remoteInfo,
         sessionId,
         initiator,
         err
-      }, {
-        F: __dxlog_file4,
-        L: 345,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 298, S: this });
       void this.closeConnection(err);
     });
     this.connection = connection;
@@ -1313,53 +868,33 @@ var Peer = class {
       return;
     }
     const connection = this.connection;
-    log4("closing...", {
+    log3("closing...", {
       peerId: this.remoteInfo,
       sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file4,
-      L: 370,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 317, S: this });
     await connection.close({
       error: err
     });
-    log4("closed", {
+    log3("closed", {
       peerId: this.remoteInfo,
       sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file4,
-      L: 376,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 326, S: this });
   }
-  async onSignal(message) {
+  async onSignal(ctx, message) {
     if (!this.connection) {
-      log4("dropping signal message for non-existent connection", {
+      log3("dropping signal message for non-existent connection", {
         message
-      }, {
-        F: __dxlog_file4,
-        L: 381,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 333, S: this });
       return;
     }
-    await this.connection.signal(message);
+    await this.connection.signal(ctx, message);
   }
   async safeDestroy(reason) {
     await this._ctx.dispose();
-    log4("Destroying peer", {
+    log3("Destroying peer", {
       peerId: this.remoteInfo,
       topic: this.topic
-    }, {
-      F: __dxlog_file4,
-      L: 391,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 342, S: this });
     await this?.connection?.close({
       reason
     });
@@ -1382,16 +917,53 @@ var increaseInterval = (interval) => {
 };
 
 // src/swarm/swarm.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file5 = "/__w/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 {
+  _topic;
+  _ownPeer;
+  _topology;
+  _protocolProvider;
+  _messenger;
+  _transportFactory;
+  _label;
+  _connectionLimiter;
+  _initiationDelay;
+  _swarmMessenger;
+  _ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 39 });
+  _listeningHandle = void 0;
+  /**
+  * PeerInfo -> Peer.
+  * @internal
+  */
+  _peers = new ComplexMap2(PeerInfoHash);
+  /**
+  * Unique id of the swarm, local to the current peer, generated when swarm is joined.
+  */
+  _instanceId = PublicKey3.random().toHex();
+  /**
+  * New connection to a peer is started.
+  * @internal
+  */
+  connectionAdded = new Event3();
+  /**
+  * Connection to a peer is dropped.
+  * @internal
+  */
+  disconnected = new Event3();
+  /**
+  * Connection is established to a new peer.
+  * @internal
+  */
+  connected = new Event3();
+  errors = new ErrorStream2();
   // TODO(burdon): Swarm => Peer.create/destroy =< Connection.open/close
   // TODO(burdon): Pass in object.
   constructor(_topic, _ownPeer, _topology, _protocolProvider, _messenger, _transportFactory, _label, _connectionLimiter, _initiationDelay = INITIATION_DELAY) {
@@ -1404,58 +976,23 @@ var Swarm = class {
     this._label = _label;
     this._connectionLimiter = _connectionLimiter;
     this._initiationDelay = _initiationDelay;
-    this._ctx = new Context4(void 0, {
-      F: __dxlog_file5,
-      L: 38
-    });
-    this._listeningHandle = void 0;
-    this._peers = new ComplexMap2(PeerInfoHash);
-    this._instanceId = PublicKey4.random().toHex();
-    this.connectionAdded = new Event3();
-    this.disconnected = new Event3();
-    this.connected = new Event3();
-    this.errors = new ErrorStream2();
-    log5.trace("dxos.mesh.swarm.constructor", trace2.begin({
-      id: this._instanceId,
-      data: {
-        topic: this._topic.toHex(),
-        peer: this._ownPeer
-      }
-    }), {
-      F: __dxlog_file5,
-      L: 88,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    log5("creating swarm", {
-      peerId: _ownPeer
-    }, {
-      F: __dxlog_file5,
-      L: 92,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log4("creating swarm", {
+      topic: this._topic.toHex(),
+      peer: this._ownPeer
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 73, S: this });
     _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),
+      sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
+      onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
+      onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
       topic: this._topic
     });
-    log5.trace("dxos.mesh.swarm.constructor", trace2.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file5,
-      L: 101,
-      S: this,
-      C: (f, a) => f(...a)
-    });
   }
   get connections() {
-    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(isNonNullable2);
+    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(isNonNullable);
   }
   get ownPeerId() {
-    return PublicKey4.from(this._ownPeer.peerKey);
+    return PublicKey3.from(this._ownPeer.peerKey);
   }
   get ownPeer() {
     return this._ownPeer;
@@ -1470,105 +1007,54 @@ var Swarm = class {
     return this._topic;
   }
   async open() {
-    invariant4(!this._listeningHandle, void 0, {
-      F: __dxlog_file5,
-      L: 132,
-      S: this,
-      A: [
-        "!this._listeningHandle",
-        ""
-      ]
-    });
+    invariant4(!this._listeningHandle, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 103, S: this, A: ["!this._listeningHandle", ""] });
     this._listeningHandle = await this._messenger.listen({
       peer: this._ownPeer,
       payloadType: "dxos.mesh.swarm.SwarmMessage",
       onMessage: async (message) => {
-        await this._swarmMessenger.receiveMessage(message).catch((err) => log5.info("Error while receiving message", {
+        await this._swarmMessenger.receiveMessage(this._ctx, message).catch((err) => log4.info("Error while receiving message", {
           err
-        }, {
-          F: __dxlog_file5,
-          L: 140,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 109, S: this }));
       }
     });
   }
   async destroy() {
-    log5("destroying...", void 0, {
-      F: __dxlog_file5,
-      L: 146,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log4("destroying...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 116, S: this });
     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")));
-    log5("destroyed", void 0, {
-      F: __dxlog_file5,
-      L: 153,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log4("destroyed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 122, S: this });
   }
   async setTopology(topology) {
-    invariant4(!this._ctx.disposed, "Swarm is offline", {
-      F: __dxlog_file5,
-      L: 157,
-      S: this,
-      A: [
-        "!this._ctx.disposed",
-        "'Swarm is offline'"
-      ]
-    });
+    invariant4(!this._ctx.disposed, "Swarm is offline", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 125, S: this, A: ["!this._ctx.disposed", "'Swarm is offline'"] });
     if (topology === this._topology) {
       return;
     }
-    log5("setting topology", {
+    log4("setting topology", {
       previous: getClassName(this._topology),
       topology: getClassName(topology)
-    }, {
-      F: __dxlog_file5,
-      L: 161,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 129, S: this });
     await this._topology.destroy();
     this._topology = topology;
     this._topology.init(this._getSwarmController());
     this._topology.update();
   }
   async onSwarmEvent(swarmEvent) {
-    log5("swarm event", {
+    log4("swarm event", {
       swarmEvent
-    }, {
-      F: __dxlog_file5,
-      L: 174,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 139, S: this });
     if (this._ctx.disposed) {
-      log5("swarm event ignored for disposed swarm", void 0, {
-        F: __dxlog_file5,
-        L: 177,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log4("swarm event ignored for disposed swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 143, S: this });
       return;
     }
     if (swarmEvent.peerAvailable) {
       const peerId = swarmEvent.peerAvailable.peer.peerKey;
       if (peerId !== this._ownPeer.peerKey) {
-        log5("new peer", {
+        log4("new peer", {
           peerId
-        }, {
-          F: __dxlog_file5,
-          L: 184,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 149, S: this });
         const peer = this._getOrCreatePeer(swarmEvent.peerAvailable.peer);
         peer.advertizing = true;
       }
@@ -1577,89 +1063,46 @@ var Swarm = class {
       if (peer) {
         peer.advertizing = false;
         if (this._isConnectionEstablishmentInProgress(peer)) {
-          log5(`destroying peer, state: ${peer.connection?.state}`, void 0, {
-            F: __dxlog_file5,
-            L: 195,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          void this._destroyPeer(swarmEvent.peerLeft.peer, "peer left").catch((err) => log5.catch(err, void 0, {
-            F: __dxlog_file5,
-            L: 196,
-            S: this,
-            C: (f, a) => f(...a)
-          }));
+          log4(`destroying peer, state: ${peer.connection?.state}`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 162, S: this });
+          void this._destroyPeer(swarmEvent.peerLeft.peer, "peer left").catch((err) => log4.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 163, S: this }));
         }
       } else {
-        log5("received peerLeft but no peer found", {
+        log4("received peerLeft but no peer found", {
           peer: swarmEvent.peerLeft.peer.peerKey
-        }, {
-          F: __dxlog_file5,
-          L: 199,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 166, S: this });
       }
     }
     this._topology.update();
   }
-  async onOffer(message) {
-    log5("offer", {
+  async onOffer(ctx, message) {
+    log4("offer", {
       message
-    }, {
-      F: __dxlog_file5,
-      L: 208,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 174, S: this });
     if (this._ctx.disposed) {
-      log5("ignored for disposed swarm", void 0, {
-        F: __dxlog_file5,
-        L: 210,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log4("ignored for disposed swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 178, S: this });
       return {
         accept: false
       };
     }
-    invariant4(message.author, void 0, {
-      F: __dxlog_file5,
-      L: 215,
-      S: this,
-      A: [
-        "message.author",
-        ""
-      ]
-    });
+    invariant4(message.author, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 184, S: this, A: ["message.author", ""] });
     if (message.recipient.peerKey !== this._ownPeer.peerKey) {
-      log5("rejecting offer with incorrect peerId", {
+      log4("rejecting offer with incorrect peerId", {
         message
-      }, {
-        F: __dxlog_file5,
-        L: 217,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 186, S: this });
       return {
         accept: false
       };
     }
     if (!message.topic?.equals(this._topic)) {
-      log5("rejecting offer with incorrect topic", {
+      log4("rejecting offer with incorrect topic", {
         message
-      }, {
-        F: __dxlog_file5,
-        L: 221,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 194, S: this });
       return {
         accept: false
       };
     }
     const peer = this._getOfferSenderPeer(message.author);
-    const answer = await peer.onOffer(message);
+    const answer = await peer.onOffer(ctx, message);
     this._topology.update();
     return answer;
   }
@@ -1673,53 +1116,19 @@ var Swarm = class {
     }
     return peer;
   }
-  async onSignal(message) {
-    log5("signal", {
+  async onSignal(ctx, message) {
+    log4("signal", {
       message
-    }, {
-      F: __dxlog_file5,
-      L: 246,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 218, S: this });
     if (this._ctx.disposed) {
-      log5.info("ignored for offline swarm", void 0, {
-        F: __dxlog_file5,
-        L: 248,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log4.info("ignored for offline swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 222, S: this });
       return;
     }
-    invariant4(message.recipient.peerKey === this._ownPeer.peerKey, `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, {
-      F: __dxlog_file5,
-      L: 251,
-      S: this,
-      A: [
-        "message.recipient.peerKey === this._ownPeer.peerKey",
-        "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"
-      ]
-    });
-    invariant4(message.topic?.equals(this._topic), void 0, {
-      F: __dxlog_file5,
-      L: 255,
-      S: this,
-      A: [
-        "message.topic?.equals(this._topic)",
-        ""
-      ]
-    });
-    invariant4(message.author, void 0, {
-      F: __dxlog_file5,
-      L: 256,
-      S: this,
-      A: [
-        "message.author",
-        ""
-      ]
-    });
+    invariant4(message.recipient.peerKey === this._ownPeer.peerKey, `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 225, S: this, A: ["message.recipient.peerKey === this._ownPeer.peerKey", "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"] });
+    invariant4(message.topic?.equals(this._topic), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 226, S: this, A: ["message.topic?.equals(this._topic)", ""] });
+    invariant4(message.author, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 227, S: this, A: ["message.author", ""] });
     const peer = this._getOrCreatePeer(message.author);
-    await peer.onSignal(message);
+    await peer.onSignal(ctx, message);
   }
   // For debug purposes
   async goOffline() {
@@ -1730,21 +1139,10 @@ var Swarm = class {
   }
   // For debug purposes
   async goOnline() {
-    this._ctx = new Context4(void 0, {
-      F: __dxlog_file5,
-      L: 272
-    });
+    this._ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 240 });
   }
   _getOrCreatePeer(peerInfo) {
-    invariant4(peerInfo.peerKey, "PeerInfo.peerKey is required", {
-      F: __dxlog_file5,
-      L: 276,
-      S: this,
-      A: [
-        "peerInfo.peerKey",
-        "'PeerInfo.peerKey is required'"
-      ]
-    });
+    invariant4(peerInfo.peerKey, "PeerInfo.peerKey is required", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 243, S: this, A: ["peerInfo.peerKey", "'PeerInfo.peerKey is required'"] });
     let peer = this._peers.get(peerInfo);
     if (!peer) {
       peer = new Peer(peerInfo, this._topic, this._ownPeer, this._swarmMessenger, this._protocolProvider, this._transportFactory, this._connectionLimiter, {
@@ -1756,12 +1154,7 @@ var Swarm = class {
         },
         onDisconnected: async () => {
           if (this._isUnregistered(peer)) {
-            log5.verbose("ignored onDisconnected for unregistered peer", void 0, {
-              F: __dxlog_file5,
-              L: 296,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            log4.verbose("ignored onDisconnected for unregistered peer", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 255, S: this });
             return;
           }
           if (!peer.advertizing) {
@@ -1772,14 +1165,9 @@ var Swarm = class {
         },
         onRejected: () => {
           if (!this._isUnregistered(peer)) {
-            log5("peer rejected connection", {
+            log4("peer rejected connection", {
               peerInfo
-            }, {
-              F: __dxlog_file5,
-              L: 310,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 268, S: this });
             void this._destroyPeer(peerInfo, "peer rejected connection");
           }
         },
@@ -1787,7 +1175,7 @@ var Swarm = class {
           this._topology.update();
         },
         onOffer: (remoteId) => {
-          return this._topology.onOffer(PublicKey4.from(remoteId.peerKey));
+          return this._topology.onOffer(PublicKey3.from(remoteId.peerKey));
         },
         onPeerAvailable: () => {
           this._topology.update();
@@ -1798,35 +1186,22 @@ var Swarm = class {
     return peer;
   }
   async _destroyPeer(peerInfo, reason) {
-    log5("destroy peer", {
+    log4("destroy peer", {
       peerKey: peerInfo.peerKey,
       reason
-    }, {
-      F: __dxlog_file5,
-      L: 332,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 289, S: this });
     const peer = this._peers.get(peerInfo);
-    invariant4(peer, void 0, {
-      F: __dxlog_file5,
-      L: 334,
-      S: this,
-      A: [
-        "peer",
-        ""
-      ]
-    });
+    invariant4(peer, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 294, S: this, A: ["peer", ""] });
     this._peers.delete(peerInfo);
     await peer.safeDestroy(reason);
   }
   _getSwarmController() {
     return {
       getState: () => ({
-        ownPeerId: PublicKey4.from(this._ownPeer.peerKey),
-        connected: Array.from(this._peers.entries()).filter(([_, peer]) => peer.connection).map(([info]) => PublicKey4.from(info.peerKey)),
-        candidates: Array.from(this._peers.entries()).filter(([_, peer]) => !peer.connection && peer.advertizing && peer.availableToConnect).map(([info]) => PublicKey4.from(info.peerKey)),
-        allPeers: Array.from(this._peers.keys()).map((info) => PublicKey4.from(info.peerKey))
+        ownPeerId: PublicKey3.from(this._ownPeer.peerKey),
+        connected: Array.from(this._peers.entries()).filter(([_, peer]) => peer.connection).map(([info]) => PublicKey3.from(info.peerKey)),
+        candidates: Array.from(this._peers.entries()).filter(([_, peer]) => !peer.connection && peer.advertizing && peer.availableToConnect).map(([info]) => PublicKey3.from(info.peerKey)),
+        allPeers: Array.from(this._peers.keys()).map((info) => PublicKey3.from(info.peerKey))
       }),
       connect: (peer) => {
         if (this._ctx.disposed) {
@@ -1838,12 +1213,7 @@ var Swarm = class {
               peerKey: peer.toHex()
             });
           } catch (err) {
-            log5("initiation error", err, {
-              F: __dxlog_file5,
-              L: 361,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            log4("initiation error", err, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 317, S: this });
           }
         });
       },
@@ -1867,14 +1237,9 @@ var Swarm = class {
     const ctx = this._ctx;
     const peer = this._getOrCreatePeer(remotePeer);
     if (remotePeer.peerKey < this._ownPeer.peerKey) {
-      log5("initiation delay", {
+      log4("initiation delay", {
         remotePeer
-      }, {
-        F: __dxlog_file5,
-        L: 389,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 343, S: this });
       await sleep2(this._initiationDelay);
     }
     if (ctx.disposed) {
@@ -1886,24 +1251,14 @@ var Swarm = class {
     if (peer.connection) {
       return;
     }
-    log5("initiating connection...", {
+    log4("initiating connection...", {
       remotePeer
-    }, {
-      F: __dxlog_file5,
-      L: 405,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await peer.initiateConnection();
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 358, S: this });
+    await peer.initiateConnection(ctx);
     this._topology.update();
-    log5("initiated", {
+    log4("initiated", {
       remotePeer
-    }, {
-      F: __dxlog_file5,
-      L: 408,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 363, S: this });
   }
   async _closeConnection(peerInfo) {
     const peer = this._peers.get(peerInfo);
@@ -1950,21 +1305,22 @@ _ts_decorate3([
 
 // src/swarm/swarm-mapper.ts
 import { Event as Event4, SubscriptionList } from "@dxos/async";
-import { PublicKey as PublicKey5 } from "@dxos/keys";
-import { log as log6 } from "@dxos/log";
+import { PublicKey as PublicKey4 } from "@dxos/keys";
+import { log as log5 } from "@dxos/log";
 import { PeerInfoHash as PeerInfoHash2 } from "@dxos/messaging";
 import { ComplexMap as ComplexMap3 } from "@dxos/util";
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
 var SwarmMapper = class {
+  _swarm;
+  _subscriptions = new SubscriptionList();
+  _connectionSubscriptions = new ComplexMap3(PeerInfoHash2);
+  _peers = new ComplexMap3(PeerInfoHash2);
+  mapUpdated = new Event4();
   get peers() {
     return Array.from(this._peers.values());
   }
   constructor(_swarm) {
     this._swarm = _swarm;
-    this._subscriptions = new SubscriptionList();
-    this._connectionSubscriptions = new ComplexMap3(PeerInfoHash2);
-    this._peers = new ComplexMap3(PeerInfoHash2);
-    this.mapUpdated = new Event4();
     this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
       this._update();
       this._connectionSubscriptions.set(connection.remoteInfo, connection.stateChanged.on(() => {
@@ -1979,12 +1335,7 @@ var SwarmMapper = class {
     this._update();
   }
   _update() {
-    log6("updating swarm", void 0, {
-      F: __dxlog_file6,
-      L: 71,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log5("updating swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 40, S: this });
     this._peers.clear();
     this._peers.set(this._swarm.ownPeer, {
       id: this._swarm.ownPeerId,
@@ -1993,22 +1344,17 @@ var SwarmMapper = class {
     });
     for (const connection of this._swarm.connections) {
       this._peers.set(connection.remoteInfo, {
-        id: PublicKey5.from(connection.remoteInfo.peerKey),
+        id: PublicKey4.from(connection.remoteInfo.peerKey),
         state: connection.state,
         connections: [
           this._swarm.ownPeerId
         ]
       });
     }
-    log6("graph changed", {
+    log5("graph changed", {
       directConnections: this._swarm.connections.length,
       totalPeersInSwarm: this._peers.size
-    }, {
-      F: __dxlog_file6,
-      L: 112,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 77, S: this });
     this.mapUpdated.emit(Array.from(this._peers.values()));
   }
   // TODO(burdon): Async open/close.
@@ -2021,52 +1367,37 @@ var SwarmMapper = class {
 
 // src/swarm/connection-limiter.ts
 import { DeferredTask as DeferredTask2 } from "@dxos/async";
-import { Context as Context5 } from "@dxos/context";
+import { Context as Context4 } from "@dxos/context";
 import { invariant as invariant5 } from "@dxos/invariant";
-import { PublicKey as PublicKey6 } from "@dxos/keys";
-import { log as log7 } from "@dxos/log";
+import { PublicKey as PublicKey5 } from "@dxos/keys";
+import { log as log6 } from "@dxos/log";
 import { CancelledError as CancelledError3 } from "@dxos/protocols";
 import { ComplexMap as ComplexMap4 } from "@dxos/util";
-var __dxlog_file7 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
+var __dxlog_file6 = "/__w/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 Context5(void 0, {
-      F: __dxlog_file7,
-      L: 23
-    });
-    /**
-    * Queue of promises to resolve when initiating connections amount is below the limit.
-    */
-    this._waitingPromises = new ComplexMap4(PublicKey6.hash);
-    this.resolveWaitingPromises = new DeferredTask2(this._ctx, async () => {
-      Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
-        resolve();
-      });
+  _ctx = new Context4(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 15 });
+  _maxConcurrentInitConnections;
+  /**
+  * Queue of promises to resolve when initiating connections amount is below the limit.
+  */
+  _waitingPromises = new ComplexMap4(PublicKey5.hash);
+  resolveWaitingPromises = new DeferredTask2(this._ctx, async () => {
+    Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
+      resolve();
     });
+  });
+  constructor({ maxConcurrentInitConnections = MAX_CONCURRENT_INITIATING_CONNECTIONS } = {}) {
     this._maxConcurrentInitConnections = maxConcurrentInitConnections;
   }
   /**
   * @returns Promise that resolves in queue when connections amount with 'CONNECTING' state is below the limit.
   */
   async connecting(sessionId) {
-    invariant5(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", {
-      F: __dxlog_file7,
-      L: 48,
-      S: this,
-      A: [
-        "!this._waitingPromises.has(sessionId)",
-        "'Peer is already waiting for connection'"
-      ]
-    });
-    log7("waiting", {
+    invariant5(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 31, S: this, A: ["!this._waitingPromises.has(sessionId)", "'Peer is already waiting for connection'"] });
+    log6("waiting", {
       sessionId
-    }, {
-      F: __dxlog_file7,
-      L: 49,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 32, S: this });
     await new Promise((resolve, reject) => {
       this._waitingPromises.set(sessionId, {
         resolve,
@@ -2074,27 +1405,17 @@ var ConnectionLimiter = class {
       });
       this.resolveWaitingPromises.schedule();
     });
-    log7("allow", {
+    log6("allow", {
       sessionId
-    }, {
-      F: __dxlog_file7,
-      L: 57,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 42, S: this });
   }
   /**
   * Rejects promise returned by `connecting` method.
   */
   doneConnecting(sessionId) {
-    log7("done", {
+    log6("done", {
       sessionId
-    }, {
-      F: __dxlog_file7,
-      L: 64,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 49, S: this });
     if (!this._waitingPromises.has(sessionId)) {
       return;
     }
@@ -2107,25 +1428,23 @@ var ConnectionLimiter = class {
 // src/connection-log.ts
 import { Event as Event5 } from "@dxos/async";
 import { raise } from "@dxos/debug";
-import { PublicKey as PublicKey7 } from "@dxos/keys";
+import { PublicKey as PublicKey6 } from "@dxos/keys";
 import { ComplexMap as ComplexMap5 } from "@dxos/util";
 var CONNECTION_GC_THRESHOLD = 1e3 * 60 * 15;
-var EventType = /* @__PURE__ */ function(EventType2) {
+var EventType = /* @__PURE__ */ (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";
   return EventType2;
-}({});
+})({});
 var ConnectionLog = class {
-  constructor() {
-    /**
-    * SwarmId => info
-    */
-    this._swarms = new ComplexMap5(PublicKey7.hash);
-    this.update = new Event5();
-  }
+  /**
+  * SwarmId => info
+  */
+  _swarms = new ComplexMap5(PublicKey6.hash);
+  update = new Event5();
   getSwarmInfo(swarmId) {
     return this._swarms.get(swarmId) ?? raise(new Error(`Swarm not found: ${swarmId}`));
   }
@@ -2134,19 +1453,19 @@ var ConnectionLog = class {
   }
   joinedSwarm(swarm) {
     const info = {
-      id: PublicKey7.from(swarm._instanceId),
+      id: PublicKey6.from(swarm._instanceId),
       topic: swarm.topic,
       isActive: true,
       label: swarm.label,
       connections: []
     };
-    this._swarms.set(PublicKey7.from(swarm._instanceId), info);
+    this._swarms.set(PublicKey6.from(swarm._instanceId), info);
     this.update.emit();
     swarm.connectionAdded.on((connection) => {
       const connectionInfo = {
         state: ConnectionState.CREATED,
         closeReason: connection.closeReason,
-        remotePeerId: PublicKey7.from(connection.remoteInfo.peerKey),
+        remotePeerId: PublicKey6.from(connection.remoteInfo.peerKey),
         sessionId: connection.sessionId,
         transport: connection.transport && Object.getPrototypeOf(connection.transport).constructor.name,
         protocolExtensions: [],
@@ -2186,7 +1505,7 @@ var ConnectionLog = class {
     });
   }
   leftSwarm(swarm) {
-    this.getSwarmInfo(PublicKey7.from(swarm._instanceId)).isActive = false;
+    this.getSwarmInfo(PublicKey6.from(swarm._instanceId)).isActive = false;
     this.update.emit();
   }
 };
@@ -2199,31 +1518,35 @@ var gcSwarm = (swarm) => {
 // src/network-manager.ts
 import { Event as Event6, synchronized as synchronized4 } from "@dxos/async";
 import { invariant as invariant6 } from "@dxos/invariant";
-import { PublicKey as PublicKey8 } from "@dxos/keys";
-import { log as log8 } from "@dxos/log";
+import { PublicKey as PublicKey7 } from "@dxos/keys";
+import { log as log7 } from "@dxos/log";
 import { Messenger } from "@dxos/messaging";
-import { trace as trace3 } from "@dxos/protocols";
 import { ConnectionState as ConnectionState2 } from "@dxos/protocols/proto/dxos/client/services";
 import { ComplexMap as ComplexMap6 } from "@dxos/util";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
 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_file8 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
 var SwarmNetworkManager = class {
+  /**
+  * @internal
+  */
+  _swarms = new ComplexMap6(PublicKey7.hash);
+  _mappers = new ComplexMap6(PublicKey7.hash);
+  _transportFactory;
+  _signalManager;
+  _messenger;
+  _signalConnection;
+  _connectionLimiter;
+  _connectionLog;
+  _peerInfo = void 0;
+  _connectionState = ConnectionState2.ONLINE;
+  connectionStateChanged = new Event6();
+  topicsUpdated = new Event6();
   constructor({ transportFactory, signalManager, enableDevtoolsLogging, peerInfo }) {
-    /**
-    * @internal
-    */
-    this._swarms = new ComplexMap6(PublicKey8.hash);
-    this._mappers = new ComplexMap6(PublicKey8.hash);
-    this._instanceId = PublicKey8.random().toHex();
-    this._peerInfo = void 0;
-    this._connectionState = ConnectionState2.ONLINE;
-    this.connectionStateChanged = new Event6();
-    this.topicsUpdated = new Event6();
     this._transportFactory = transportFactory;
     this._signalManager = signalManager;
     this._signalManager.swarmEvent.on((event) => this._swarms.get(event.topic)?.onSwarmEvent(event));
@@ -2231,8 +1554,8 @@ var SwarmNetworkManager = class {
       signalManager: this._signalManager
     });
     this._signalConnection = {
-      join: (opts) => this._signalManager.join(opts),
-      leave: (opts) => this._signalManager.leave(opts)
+      join: (ctx, opts) => this._signalManager.join(ctx, opts),
+      leave: (ctx, opts) => this._signalManager.leave(ctx, opts)
     };
     this._peerInfo = peerInfo;
     this._connectionLimiter = new ConnectionLimiter();
@@ -2261,34 +1584,15 @@ var SwarmNetworkManager = class {
     this._peerInfo = peerInfo;
   }
   async open() {
-    log8.trace("dxos.mesh.network-manager.open", trace3.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file8,
-      L: 133,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log7("opening network manager", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 76, S: this });
     await this._messenger.open();
     await this._signalManager.open();
-    log8.trace("dxos.mesh.network-manager.open", trace3.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file8,
-      L: 136,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log7("opened network manager", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 79, S: this });
   }
-  async close() {
+  async close(ctx) {
     for (const topic of this._swarms.keys()) {
-      await this.leaveSwarm(topic).catch((err) => {
-        log8(err, void 0, {
-          F: __dxlog_file8,
-          L: 142,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+      await this.leaveSwarm(ctx, topic).catch((err) => {
+        log7(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 84, S: this });
       });
     }
     await this._messenger.close();
@@ -2297,111 +1601,54 @@ var SwarmNetworkManager = class {
   /**
   * Join the swarm.
   */
-  async joinSwarm({ topic, topology, protocolProvider: protocol, label }) {
-    invariant6(PublicKey8.isPublicKey(topic), void 0, {
-      F: __dxlog_file8,
-      L: 160,
-      S: this,
-      A: [
-        "PublicKey.isPublicKey(topic)",
-        ""
-      ]
-    });
-    invariant6(topology, void 0, {
-      F: __dxlog_file8,
-      L: 161,
-      S: this,
-      A: [
-        "topology",
-        ""
-      ]
-    });
-    invariant6(this._peerInfo, void 0, {
-      F: __dxlog_file8,
-      L: 162,
-      S: this,
-      A: [
-        "this._peerInfo",
-        ""
-      ]
-    });
-    invariant6(typeof protocol === "function", void 0, {
-      F: __dxlog_file8,
-      L: 163,
-      S: this,
-      A: [
-        "typeof protocol === 'function'",
-        ""
-      ]
-    });
+  async joinSwarm(ctx, { topic, topology, protocolProvider: protocol, label }) {
+    invariant6(PublicKey7.isPublicKey(topic), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 93, S: this, A: ["PublicKey.isPublicKey(topic)", ""] });
+    invariant6(topology, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 94, S: this, A: ["topology", ""] });
+    invariant6(this._peerInfo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 95, S: this, A: ["this._peerInfo", ""] });
+    invariant6(typeof protocol === "function", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 96, S: this, A: ["typeof protocol === 'function'", ""] });
     if (this._swarms.has(topic)) {
-      throw new Error(`Already connected to swarm: ${PublicKey8.from(topic)}`);
+      throw new Error(`Already connected to swarm: ${PublicKey7.from(topic)}`);
     }
-    log8("joining", {
-      topic: PublicKey8.from(topic),
+    log7("joining", {
+      topic: PublicKey7.from(topic),
       peerInfo: this._peerInfo,
       topology: topology.toString()
-    }, {
-      F: __dxlog_file8,
-      L: 168,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 100, S: this });
     const swarm = new Swarm(topic, this._peerInfo, topology, protocol, this._messenger, this._transportFactory, label, this._connectionLimiter);
     swarm.errors.handle((error) => {
-      log8("swarm error", {
+      log7("swarm error", {
         error
-      }, {
-        F: __dxlog_file8,
-        L: 181,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 107, S: this });
     });
     this._swarms.set(topic, swarm);
     this._mappers.set(topic, new SwarmMapper(swarm));
     await swarm.open();
-    this._signalConnection.join({
+    this._signalConnection.join(ctx, {
       topic,
       peer: this._peerInfo
-    }).catch((error) => log8.catch(error, void 0, {
-      F: __dxlog_file8,
-      L: 190,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
+    }).catch((error) => log7.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 118, S: this }));
     this.topicsUpdated.emit();
     this._connectionLog?.joinedSwarm(swarm);
-    log8("joined", {
-      topic: PublicKey8.from(topic),
+    log7("joined", {
+      topic: PublicKey7.from(topic),
       count: this._swarms.size
-    }, {
-      F: __dxlog_file8,
-      L: 194,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 121, S: this });
     return {
-      close: () => this.leaveSwarm(topic)
+      close: (ctx2) => this.leaveSwarm(ctx2, topic)
     };
   }
   /**
   * Close the connection.
   */
-  async leaveSwarm(topic) {
+  async leaveSwarm(ctx, topic) {
     if (!this._swarms.has(topic)) {
       return;
     }
-    log8("leaving", {
-      topic: PublicKey8.from(topic)
-    }, {
-      F: __dxlog_file8,
-      L: 211,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log7("leaving", {
+      topic: PublicKey7.from(topic)
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 136, S: this });
     const swarm = this._swarms.get(topic);
-    await this._signalConnection.leave({
+    await this._signalConnection.leave(ctx, {
       topic,
       peer: swarm.ownPeer
     });
@@ -2412,15 +1659,10 @@ var SwarmNetworkManager = class {
     await swarm.destroy();
     this._swarms.delete(topic);
     this.topicsUpdated.emit();
-    log8("left", {
-      topic: PublicKey8.from(topic),
+    log7("left", {
+      topic: PublicKey7.from(topic),
       count: this._swarms.size
-    }, {
-      F: __dxlog_file8,
-      L: 225,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 151, S: this });
   }
   async setConnectionState(state) {
     if (state === this._connectionState) {
@@ -2458,33 +1700,18 @@ _ts_decorate4([
 
 // src/topology/fully-connected-topology.ts
 import { invariant as invariant7 } from "@dxos/invariant";
-var __dxlog_file9 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
 var FullyConnectedTopology = class {
+  _controller;
   toString() {
     return "FullyConnectedTopology";
   }
   init(controller) {
-    invariant7(!this._controller, "Already initialized", {
-      F: __dxlog_file9,
-      L: 18,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized'"
-      ]
-    });
+    invariant7(!this._controller, "Already initialized", { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 11, S: this, A: ["!this._controller", "'Already initialized'"] });
     this._controller = controller;
   }
   update() {
-    invariant7(this._controller, "Not initialized", {
-      F: __dxlog_file9,
-      L: 23,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
+    invariant7(this._controller, "Not initialized", { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 15, S: this, A: ["this._controller", "'Not initialized'"] });
     const { candidates: discovered } = this._controller.getState();
     for (const peer of discovered) {
       this._controller.connect(peer);
@@ -2497,323 +1724,21 @@ var FullyConnectedTopology = class {
   }
 };
 
-// src/topology/mmst-topology.ts
-import { invariant as invariant8 } from "@dxos/invariant";
-import { log as log9 } from "@dxos/log";
-var __dxlog_file10 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/topology/mmst-topology.ts";
-var MIN_UPDATE_INTERVAL = 1e3 * 10;
-var MAX_CHANGES_PER_UPDATE = 1;
-var MMSTTopology = class {
-  constructor({ originateConnections = 2, maxPeers = 4, sampleSize = 10 } = {}) {
-    this._sampleCollected = false;
-    this._lastAction = /* @__PURE__ */ new Date(0);
-    this._originateConnections = originateConnections;
-    this._maxPeers = maxPeers;
-    this._sampleSize = sampleSize;
-  }
-  init(controller) {
-    invariant8(!this._controller, "Already initialized", {
-      F: __dxlog_file10,
-      L: 49,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized'"
-      ]
-    });
-    this._controller = controller;
-  }
-  update() {
-    invariant8(this._controller, "Not initialized", {
-      F: __dxlog_file10,
-      L: 54,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { connected, candidates } = this._controller.getState();
-    if (this._sampleCollected || connected.length > this._maxPeers || candidates.length > 0) {
-      log9("Running the algorithm.", void 0, {
-        F: __dxlog_file10,
-        L: 58,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._sampleCollected = true;
-      this._runAlgorithm();
-    }
-  }
-  forceUpdate() {
-    this._lastAction = /* @__PURE__ */ new Date(0);
-    this.update();
-  }
-  async onOffer(peer) {
-    invariant8(this._controller, "Not initialized", {
-      F: __dxlog_file10,
-      L: 70,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { connected } = this._controller.getState();
-    const accept = connected.length < this._maxPeers;
-    log9(`Offer ${peer} accept=${accept}`, void 0, {
-      F: __dxlog_file10,
-      L: 73,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return accept;
-  }
-  async destroy() {
-  }
-  _runAlgorithm() {
-    invariant8(this._controller, "Not initialized", {
-      F: __dxlog_file10,
-      L: 82,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized'"
-      ]
-    });
-    const { connected, candidates, ownPeerId } = this._controller.getState();
-    if (connected.length > this._maxPeers) {
-      log9(`disconnect ${connected.length - this._maxPeers} peers.`, void 0, {
-        F: __dxlog_file10,
-        L: 88,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const sorted = sortByXorDistance(connected, ownPeerId).reverse().slice(0, this._maxPeers - connected.length);
-      invariant8(sorted.length === 0, void 0, {
-        F: __dxlog_file10,
-        L: 92,
-        S: this,
-        A: [
-          "sorted.length === 0",
-          ""
-        ]
-      });
-      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
-        log9(`want to disconnect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`, void 0, {
-          F: __dxlog_file10,
-          L: 95,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
-        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
-          log9(`Disconnect ${peer}.`, void 0, {
-            F: __dxlog_file10,
-            L: 100,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._controller.disconnect(peer);
-        }
-        this._lastAction = /* @__PURE__ */ new Date();
-      } else {
-        log9("rate limited disconnect", void 0, {
-          F: __dxlog_file10,
-          L: 105,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    } else if (connected.length < this._originateConnections) {
-      log9(`connect ${this._originateConnections - connected.length} peers.`, void 0, {
-        F: __dxlog_file10,
-        L: 109,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const sample = candidates.sort(() => Math.random() - 0.5).slice(0, this._sampleSize);
-      const sorted = sortByXorDistance(sample, ownPeerId).slice(0, this._originateConnections - connected.length);
-      if (sorted.length > MAX_CHANGES_PER_UPDATE) {
-        log9(`want to connect ${sorted.length} peers but limited to ${MAX_CHANGES_PER_UPDATE}`, void 0, {
-          F: __dxlog_file10,
-          L: 114,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      if (Date.now() - this._lastAction.getTime() > MIN_UPDATE_INTERVAL) {
-        for (const peer of sorted.slice(0, MAX_CHANGES_PER_UPDATE)) {
-          log9(`Connect ${peer}.`, void 0, {
-            F: __dxlog_file10,
-            L: 118,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._controller.connect(peer);
-        }
-        this._lastAction = /* @__PURE__ */ new Date();
-      } else {
-        log9("rate limited connect", void 0, {
-          F: __dxlog_file10,
-          L: 123,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-  }
-  toString() {
-    return "MMSTTopology";
-  }
-};
-var sortByXorDistance = (keys, reference) => {
-  const sorted = keys.sort((a, b) => {
-    return compareXor(distXor(a.asBuffer(), reference.asBuffer()), distXor(b.asBuffer(), reference.asBuffer()));
-  });
-  log9("Sorted keys", {
-    keys,
-    reference,
-    sorted
-  }, {
-    F: __dxlog_file10,
-    L: 137,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  return sorted;
-};
-var distXor = (a, b) => {
-  const maxLength = Math.max(a.length, b.length);
-  const result = Buffer.allocUnsafe(maxLength);
-  for (let i = 0; i < maxLength; i++) {
-    result[i] = (a[i] || 0) ^ (b[i] || 0);
-  }
-  return result;
-};
-var compareXor = (a, b) => {
-  const maxLength = Math.max(a.length, b.length);
-  for (let i = 0; i < maxLength; i++) {
-    if ((a[i] || 0) === (b[i] || 0)) {
-      continue;
-    }
-    return (a[i] || 0) < (b[i] || 0) ? -1 : 1;
-  }
-  return 0;
-};
-
-// src/topology/star-topology.ts
-import { invariant as invariant9 } from "@dxos/invariant";
-import { log as log10 } from "@dxos/log";
-var __dxlog_file11 = "/__w/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) {
-    invariant9(!this._controller, "Already initialized.", {
-      F: __dxlog_file11,
-      L: 21,
-      S: this,
-      A: [
-        "!this._controller",
-        "'Already initialized.'"
-      ]
-    });
-    this._controller = controller;
-  }
-  update() {
-    invariant9(this._controller, "Not initialized.", {
-      F: __dxlog_file11,
-      L: 26,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized.'"
-      ]
-    });
-    const { candidates, connected, ownPeerId } = this._controller.getState();
-    if (!ownPeerId.equals(this._centralPeer)) {
-      log10("leaf peer dropping all connections apart from central peer.", void 0, {
-        F: __dxlog_file11,
-        L: 29,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      for (const peer of connected) {
-        if (!peer.equals(this._centralPeer)) {
-          log10("dropping connection", {
-            peer
-          }, {
-            F: __dxlog_file11,
-            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)) {
-        log10("connecting to peer", {
-          peer
-        }, {
-          F: __dxlog_file11,
-          L: 43,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._controller.connect(peer);
-      }
-    }
-  }
-  async onOffer(peer) {
-    invariant9(this._controller, "Not initialized.", {
-      F: __dxlog_file11,
-      L: 50,
-      S: this,
-      A: [
-        "this._controller",
-        "'Not initialized.'"
-      ]
-    });
-    const { ownPeerId } = this._controller.getState();
-    log10("offer", {
-      peer,
-      isCentral: peer.equals(this._centralPeer),
-      isSelfCentral: ownPeerId.equals(this._centralPeer)
-    }, {
-      F: __dxlog_file11,
-      L: 52,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);
-  }
-  async destroy() {
-  }
-};
-
 // src/transport/memory-transport.ts
 import { Transform } from "@dxos/node-std/stream";
 import { Event as Event7, Trigger as Trigger2 } from "@dxos/async";
 import { ErrorStream as ErrorStream3 } from "@dxos/debug";
-import { invariant as invariant10 } from "@dxos/invariant";
-import { PublicKey as PublicKey9 } from "@dxos/keys";
-import { log as log11, logInfo as logInfo3 } from "@dxos/log";
+import { invariant as invariant8 } from "@dxos/invariant";
+import { PublicKey as PublicKey8 } from "@dxos/keys";
+import { log as log8, logInfo as logInfo3 } from "@dxos/log";
 import { ComplexMap as ComplexMap7 } from "@dxos/util";
+var __dxlog_file9 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
 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_file12 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
 var MEMORY_TRANSPORT_DELAY = 1;
 var createStreamDelay = (delay) => {
   return new Transform({
@@ -2827,48 +1752,31 @@ var MemoryTransportFactory = {
   createTransport: (options) => new MemoryTransport(options)
 };
 var MemoryTransport = class _MemoryTransport {
-  static {
-    // TODO(burdon): Remove static properties (inject context into constructor).
-    this._connections = new ComplexMap7(PublicKey9.hash);
-  }
+  _options;
+  // TODO(burdon): Remove static properties (inject context into constructor).
+  static _connections = new ComplexMap7(PublicKey8.hash);
+  _instanceId = PublicKey8.random();
+  _remote = new Trigger2();
+  _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+  _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+  _closed = false;
+  _remoteInstanceId;
+  _remoteConnection;
+  closed = new Event7();
+  connected = new Event7();
+  errors = new ErrorStream3();
   constructor(_options) {
     this._options = _options;
-    this._instanceId = PublicKey9.random();
-    this._remote = new Trigger2();
-    this._outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-    this._incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-    this._closed = false;
-    this.closed = new Event7();
-    this.connected = new Event7();
-    this.errors = new ErrorStream3();
-    invariant10(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", {
-      F: __dxlog_file12,
-      L: 64,
-      S: this,
-      A: [
-        "!MemoryTransport._connections.has(this._instanceId)",
-        "'Duplicate memory connection'"
-      ]
-    });
+    invariant8(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 51, S: this, A: ["!MemoryTransport._connections.has(this._instanceId)", "'Duplicate memory connection'"] });
     _MemoryTransport._connections.set(this._instanceId, this);
   }
   get isOpen() {
     return !this._closed;
   }
   async open() {
-    log11("opening...", void 0, {
-      F: __dxlog_file12,
-      L: 74,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log8("opening...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 59, S: this });
     if (this._options.initiator) {
-      log11("sending signal", void 0, {
-        F: __dxlog_file12,
-        L: 78,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log8("sending signal", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 62, S: this });
       try {
         await this._options.sendSignal({
           payload: {
@@ -2894,23 +1802,10 @@ var MemoryTransport = class _MemoryTransport {
           this.closed.emit();
           return;
         }
-        invariant10(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
-          F: __dxlog_file12,
-          L: 104,
-          S: this,
-          A: [
-            "!this._remoteConnection._remoteConnection",
-            "`Remote already connected: ${this._remoteInstanceId}`"
-          ]
-        });
+        invariant8(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 90, S: this, A: ["!this._remoteConnection._remoteConnection", "`Remote already connected: ${this._remoteInstanceId}`"] });
         this._remoteConnection._remoteConnection = this;
         this._remoteConnection._remoteInstanceId = this._instanceId;
-        log11("connected", void 0, {
-          F: __dxlog_file12,
-          L: 108,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log8("connected", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 93, S: this });
         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();
@@ -2924,12 +1819,7 @@ var MemoryTransport = class _MemoryTransport {
     return this;
   }
   async close() {
-    log11("closing...", void 0, {
-      F: __dxlog_file12,
-      L: 130,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log8("closing...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 107, S: this });
     this._closed = true;
     _MemoryTransport._connections.delete(this._instanceId);
     if (this._remoteConnection) {
@@ -2945,29 +1835,19 @@ var MemoryTransport = class _MemoryTransport {
       this._remoteConnection = void 0;
     }
     this.closed.emit();
-    log11("closed", void 0, {
-      F: __dxlog_file12,
-      L: 158,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log8("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 130, S: this });
     return this;
   }
   async onSignal({ payload }) {
-    log11("received signal", {
+    log8("received signal", {
       payload
-    }, {
-      F: __dxlog_file12,
-      L: 163,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 134, S: this });
     if (!payload?.transportId) {
       return;
     }
     const transportId = payload.transportId;
     if (transportId) {
-      const remoteId = PublicKey9.fromHex(transportId);
+      const remoteId = PublicKey8.fromHex(transportId);
       this._remote.wake(remoteId);
     }
   }
@@ -2992,13 +1872,13 @@ _ts_decorate5([
 var toError = (err) => err instanceof Error ? err : new Error(String(err));
 
 // src/transport/transport.ts
-var TransportKind = /* @__PURE__ */ function(TransportKind2) {
+var TransportKind = /* @__PURE__ */ (function(TransportKind2) {
   TransportKind2["WEB_RTC"] = "WEB-RTC";
   TransportKind2["WEB_RTC_PROXY"] = "WEB-RTC_PROXY";
   TransportKind2["MEMORY"] = "MEMORY";
   TransportKind2["TCP"] = "TCP";
   return TransportKind2;
-}({});
+})({});
 
 // src/transport/webrtc/rtc-connection-factory.ts
 import { Mutex } from "@dxos/async";
@@ -3014,14 +1894,10 @@ var BrowserRtcConnectionFactory = class {
   }
 };
 var NodeRtcConnectionFactory = class _NodeRtcConnectionFactory {
-  static {
-    this._createdConnections = 0;
-  }
-  static {
-    this._cleanupMutex = new Mutex();
-  }
+  static _createdConnections = 0;
+  static _cleanupMutex = new Mutex();
   // This should be inside the function to avoid triggering `eval` in the global scope.
-  // eslint-disable-next-line no-new-func
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
   // TODO(burdon): Do imports here?
   async initialize() {
   }
@@ -3050,19 +1926,19 @@ var getRtcConnectionFactory = () => {
 };
 
 // src/transport/webrtc/rtc-peer-connection.ts
-import { synchronized as synchronized5, Trigger as Trigger3, Mutex as Mutex2 } from "@dxos/async";
-import { invariant as invariant12 } from "@dxos/invariant";
-import { log as log13, logInfo as logInfo4 } from "@dxos/log";
+import { Mutex as Mutex2, Trigger as Trigger3, synchronized as synchronized5 } from "@dxos/async";
+import { invariant as invariant10 } from "@dxos/invariant";
+import { log as log10, logInfo as logInfo4 } from "@dxos/log";
 import { ConnectivityError as ConnectivityError3 } from "@dxos/protocols";
-import { trace as trace4 } from "@dxos/tracing";
+import { trace } from "@dxos/tracing";
 
 // src/transport/webrtc/rtc-transport-channel.ts
 import { Duplex } from "@dxos/node-std/stream";
 import { Event as AsyncEvent } from "@dxos/async";
 import { Resource } from "@dxos/context";
 import { ErrorStream as ErrorStream4 } from "@dxos/debug";
-import { invariant as invariant11 } from "@dxos/invariant";
-import { log as log12 } from "@dxos/log";
+import { invariant as invariant9 } from "@dxos/invariant";
+import { log as log9 } from "@dxos/log";
 import { ConnectivityError as ConnectivityError2 } from "@dxos/protocols";
 
 // src/transport/webrtc/rtc-transport-stats.ts
@@ -3113,12 +1989,21 @@ var getRtcConnectionStats = async (connection, channelTopic) => {
 };
 
 // src/transport/webrtc/rtc-transport-channel.ts
-var __dxlog_file13 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts";
+var __dxlog_file10 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts";
 var MAX_MESSAGE_SIZE = 64 * 1024;
 var MAX_BUFFERED_AMOUNT = 64 * 1024;
 var RtcTransportChannel = class extends Resource {
+  _connection;
+  _options;
+  closed = new AsyncEvent();
+  connected = new AsyncEvent();
+  errors = new ErrorStream4();
+  _channel;
+  _stream;
+  _streamDataFlushedCallback = null;
+  _isChannelCreationInProgress = false;
   constructor(_connection, _options) {
-    super(), this._connection = _connection, this._options = _options, this.closed = new AsyncEvent(), this.connected = new AsyncEvent(), this.errors = new ErrorStream4(), this._streamDataFlushedCallback = null, this._isChannelCreationInProgress = false;
+    super(), this._connection = _connection, this._options = _options;
   }
   get isRtcChannelCreationInProgress() {
     return this._isChannelCreationInProgress;
@@ -3129,15 +2014,7 @@ var RtcTransportChannel = class extends Resource {
     }
   }
   async _open() {
-    invariant11(!this._isChannelCreationInProgress, void 0, {
-      F: __dxlog_file13,
-      L: 56,
-      S: this,
-      A: [
-        "!this._isChannelCreationInProgress",
-        ""
-      ]
-    });
+    invariant9(!this._isChannelCreationInProgress, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 41, S: this, A: ["!this._isChannelCreationInProgress", ""] });
     this._isChannelCreationInProgress = true;
     this._connection.createDataChannel(this._options.topic).then((channel) => {
       if (this.isOpen) {
@@ -3148,17 +2025,14 @@ var RtcTransportChannel = class extends Resource {
       }
     }).catch((err) => {
       if (this.isOpen) {
-        const error = err instanceof Error ? err : new ConnectivityError2(`Failed to create a channel: ${JSON.stringify(err?.message)}`);
+        const error = err instanceof Error ? err : new ConnectivityError2({
+          message: `Failed to create a channel: ${JSON.stringify(err?.message)}`
+        });
         this.errors.raise(error);
       } else {
-        log12.verbose("connection establishment failed after transport was closed", {
+        log9.verbose("connection establishment failed after transport was closed", {
           err
-        }, {
-          F: __dxlog_file13,
-          L: 76,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 57, S: this });
       }
     }).finally(() => {
       this._isChannelCreationInProgress = false;
@@ -3171,34 +2045,19 @@ var RtcTransportChannel = class extends Resource {
       this._stream = void 0;
     }
     this.closed.emit();
-    log12("closed", void 0, {
-      F: __dxlog_file13,
-      L: 92,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log9("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 72, S: this });
   }
   _initChannel(channel) {
     Object.assign(channel, {
       onopen: () => {
         if (!this.isOpen) {
-          log12.warn("channel opened in a closed transport", {
+          log9.warn("channel opened in a closed transport", {
             topic: this._options.topic
-          }, {
-            F: __dxlog_file13,
-            L: 99,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 78, S: this });
           this._safeCloseChannel(channel);
           return;
         }
-        log12("onopen", void 0, {
-          F: __dxlog_file13,
-          L: 104,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log9("onopen", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 84, S: this });
         const duplex = new Duplex({
           read: () => {
           },
@@ -3211,22 +2070,12 @@ var RtcTransportChannel = class extends Resource {
         this.connected.emit();
       },
       onclose: async () => {
-        log12("onclose", void 0, {
-          F: __dxlog_file13,
-          L: 117,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log9("onclose", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 96, S: this });
         await this.close();
       },
       onmessage: async (event) => {
         if (!this._stream) {
-          log12.warn("ignoring message on a closed channel", void 0, {
-            F: __dxlog_file13,
-            L: 123,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          log9.warn("ignoring message on a closed channel", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 101, S: this });
           return;
         }
         let data = event.data;
@@ -3252,12 +2101,7 @@ var RtcTransportChannel = class extends Resource {
   }
   async _handleChannelWrite(chunk, callback) {
     if (!this._channel) {
-      log12.warn("writing to a channel after a connection was closed", void 0, {
-        F: __dxlog_file13,
-        L: 153,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log9.warn("writing to a channel after a connection was closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 127, S: this });
       return;
     }
     if (chunk.length > MAX_MESSAGE_SIZE) {
@@ -3275,12 +2119,7 @@ var RtcTransportChannel = class extends Resource {
     }
     if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
       if (this._streamDataFlushedCallback !== null) {
-        log12.error("consumer trying to write before we are ready for more data", void 0, {
-          F: __dxlog_file13,
-          L: 174,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log9.error("consumer trying to write before we are ready for more data", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 145, S: this });
       }
       this._streamDataFlushedCallback = callback;
     } else {
@@ -3291,12 +2130,7 @@ var RtcTransportChannel = class extends Resource {
     try {
       channel.close();
     } catch (error) {
-      log12.catch(error, void 0, {
-        F: __dxlog_file13,
-        L: 186,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log9.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 156, S: this });
     }
   }
   onSignal(signal) {
@@ -3337,22 +2171,35 @@ var deduplicatedSdpLines = (sdp) => {
 };
 
 // src/transport/webrtc/rtc-peer-connection.ts
+var __dxlog_file11 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
 function _ts_decorate6(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_file14 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
 var RtcPeerConnection = class {
+  _factory;
+  _options;
+  // A peer who is not the initiator waits for another party to open a channel.
+  _channelCreatedCallbacks = /* @__PURE__ */ new Map();
+  // Channels indexed by topic.
+  _transportChannels = /* @__PURE__ */ new Map();
+  _dataChannels = /* @__PURE__ */ new Map();
+  // A peer is ready to receive ICE candidates when local and remote description were set.
+  _readyForCandidates = new Trigger3();
+  _offerProcessingMutex = new Mutex2();
+  /**
+  * Can't use peer.connection.initiator, because if two connections to the same peer are created in
+  * different swarms, we might be the initiator of the first one, but not of the other one.
+  * Use a stable peer keypair property (key ordering) to decide who's acting as the initiator of
+  * transport connection establishment and data channel creation.
+  */
+  _initiator;
+  _connection;
   constructor(_factory, _options) {
     this._factory = _factory;
     this._options = _options;
-    this._channelCreatedCallbacks = /* @__PURE__ */ new Map();
-    this._transportChannels = /* @__PURE__ */ new Map();
-    this._dataChannels = /* @__PURE__ */ new Map();
-    this._readyForCandidates = new Trigger3();
-    this._offerProcessingMutex = new Mutex2();
     this._initiator = chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
   }
   get transportChannelCount() {
@@ -3378,12 +2225,7 @@ var RtcPeerConnection = class {
       if (existingChannel) {
         return existingChannel;
       }
-      log13("waiting for initiator-peer to open a data channel", void 0, {
-        F: __dxlog_file14,
-        L: 95,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10("waiting for initiator-peer to open a data channel", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 63, S: this });
       return new Promise((resolve, reject) => {
         this._channelCreatedCallbacks.set(topic, {
           resolve,
@@ -3407,38 +2249,20 @@ var RtcPeerConnection = class {
     if (this._connection) {
       return this._connection;
     }
-    log13("initializing connection...", () => ({
+    log10("initializing connection...", () => ({
       remotePeer: this._options.remotePeerKey
-    }), {
-      F: __dxlog_file14,
-      L: 120,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }), { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 87, S: this });
     const config = await this._loadConnectionConfig();
     const connection = await this._factory.createConnection(config);
     const iceCandidateErrors = [];
     Object.assign(connection, {
       onnegotiationneeded: async () => {
-        invariant12(this._initiator, void 0, {
-          F: __dxlog_file14,
-          L: 135,
-          S: this,
-          A: [
-            "this._initiator",
-            ""
-          ]
-        });
+        invariant10(this._initiator, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 100, S: this, A: ["this._initiator", ""] });
         if (connection !== this._connection) {
           this._onConnectionCallbackAfterClose("onnegotiationneeded", connection);
           return;
         }
-        log13("onnegotiationneeded", void 0, {
-          F: __dxlog_file14,
-          L: 142,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log10("onnegotiationneeded", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 105, S: this });
         try {
           const offer = await connection.createOffer();
           await connection.setLocalDescription(offer);
@@ -3455,22 +2279,12 @@ var RtcPeerConnection = class {
           return;
         }
         if (event.candidate) {
-          log13("onicecandidate", {
+          log10("onicecandidate", {
             candidate: event.candidate.candidate
-          }, {
-            F: __dxlog_file14,
-            L: 161,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 122, S: this });
           await this._sendIceCandidate(event.candidate);
         } else {
-          log13("onicecandidate gathering complete", void 0, {
-            F: __dxlog_file14,
-            L: 164,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          log10("onicecandidate gathering complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 127, S: this });
         }
       },
       // When error occurs while performing ICE negotiations through a STUN or TURN server.
@@ -3491,14 +2305,9 @@ var RtcPeerConnection = class {
           this._onConnectionCallbackAfterClose("oniceconnectionstatechange", connection);
           return;
         }
-        log13("oniceconnectionstatechange", {
+        log10("oniceconnectionstatechange", {
           state: connection.iceConnectionState
-        }, {
-          F: __dxlog_file14,
-          L: 184,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 148, S: this });
         if (connection.iceConnectionState === "failed") {
           void this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
         }
@@ -3513,52 +2322,29 @@ var RtcPeerConnection = class {
           }
           return;
         }
-        log13("onconnectionstatechange", {
+        log10("onconnectionstatechange", {
           state: connection.connectionState
-        }, {
-          F: __dxlog_file14,
-          L: 201,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 165, S: this });
         if (connection.connectionState === "failed") {
           void this._lockAndAbort(connection, new Error("Connection failed."));
         }
       },
       onsignalingstatechange: () => {
-        log13("onsignalingstatechange", {
+        log10("onsignalingstatechange", {
           state: connection.signalingState
-        }, {
-          F: __dxlog_file14,
-          L: 208,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 173, S: this });
       },
       // When channel is added to connection.
       // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event
       ondatachannel: (event) => {
-        invariant12(!this._initiator, "Initiator is expected to create data channels.", {
-          F: __dxlog_file14,
-          L: 214,
-          S: this,
-          A: [
-            "!this._initiator",
-            "'Initiator is expected to create data channels.'"
-          ]
-        });
+        invariant10(!this._initiator, "Initiator is expected to create data channels.", { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 180, S: this, A: ["!this._initiator", "'Initiator is expected to create data channels.'"] });
         if (connection !== this._connection) {
           this._onConnectionCallbackAfterClose("ondatachannel", connection);
           return;
         }
-        log13("ondatachannel", {
+        log10("ondatachannel", {
           label: event.channel.label
-        }, {
-          F: __dxlog_file14,
-          L: 221,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 185, S: this });
         this._dataChannels.set(event.channel.label, event.channel);
         const pendingCallback = this._channelCreatedCallbacks.get(event.channel.label);
         if (pendingCallback) {
@@ -3579,14 +2365,9 @@ var RtcPeerConnection = class {
   }
   _abortConnection(connection, error) {
     if (connection !== this._connection) {
-      log13.error("attempted to abort an inactive connection", {
+      log10.error("attempted to abort an inactive connection", {
         error
-      }, {
-        F: __dxlog_file14,
-        L: 246,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 208, S: this });
       this._safeCloseConnection(connection);
       return;
     }
@@ -3600,46 +2381,23 @@ var RtcPeerConnection = class {
     }
     this._transportChannels.clear();
     this._safeCloseConnection();
-    log13("connection aborted", {
+    log10("connection aborted", {
       reason: error.message
-    }, {
-      F: __dxlog_file14,
-      L: 260,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 224, S: this });
   }
   async _lockAndCloseConnection() {
-    invariant12(this._transportChannels.size === 0, void 0, {
-      F: __dxlog_file14,
-      L: 265,
-      S: this,
-      A: [
-        "this._transportChannels.size === 0",
-        ""
-      ]
-    });
+    invariant10(this._transportChannels.size === 0, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 229, S: this, A: ["this._transportChannels.size === 0", ""] });
     if (this._connection) {
       this._safeCloseConnection();
-      log13("connection closed", void 0, {
-        F: __dxlog_file14,
-        L: 268,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10("connection closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 232, S: this });
     }
   }
   async onSignal(signal) {
     const connection = this._connection;
     if (!connection) {
-      log13.warn("a signal ignored because the connection was closed", {
+      log10.warn("a signal ignored because the connection was closed", {
         type: signal.payload.data.type
-      }, {
-        F: __dxlog_file14,
-        L: 276,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 238, S: this });
       return;
     }
     const data = signal.payload.data;
@@ -3699,66 +2457,36 @@ var RtcPeerConnection = class {
         this._abortConnection(connection, new Error(`Unknown signal type ${data.type}.`));
         break;
     }
-    log13("signal processed", {
+    log10("signal processed", {
       type: data.type
-    }, {
-      F: __dxlog_file14,
-      L: 335,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 301, S: this });
   }
   async _processIceCandidate(connection, candidate) {
     try {
       await this._readyForCandidates.wait();
       if (connection === this._connection) {
-        log13("adding ice candidate", {
+        log10("adding ice candidate", {
           candidate
-        }, {
-          F: __dxlog_file14,
-          L: 343,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 310, S: this });
         await connection.addIceCandidate(candidate);
       }
     } catch (err) {
-      log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 347,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 316, S: this });
     }
   }
   _onSessionNegotiated(connection) {
     if (connection === this._connection) {
-      log13("ready to process ice candidates", void 0, {
-        F: __dxlog_file14,
-        L: 353,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10("ready to process ice candidates", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 321, S: this });
       this._readyForCandidates.wake();
     } else {
-      log13.warn("session was negotiated after connection became inactive", void 0, {
-        F: __dxlog_file14,
-        L: 356,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10.warn("session was negotiated after connection became inactive", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 324, S: this });
     }
   }
   _onConnectionCallbackAfterClose(callback, connection) {
-    log13.warn("callback invoked after a connection was destroyed, this is probably a bug", {
+    log10.warn("callback invoked after a connection was destroyed, this is probably a bug", {
       callback,
       state: connection.connectionState
-    }, {
-      F: __dxlog_file14,
-      L: 361,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 328, S: this });
     this._safeCloseConnection(connection);
   }
   _safeCloseConnection(connection = this._connection) {
@@ -3766,23 +2494,13 @@ var RtcPeerConnection = class {
     try {
       connection?.close();
     } catch (err) {
-      log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 373,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 339, S: this });
     }
     if (resetFields) {
       this._connection = void 0;
       this._dataChannels.clear();
       this._readyForCandidates.wake();
-      void this._factory.onConnectionDestroyed().catch((err) => log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 379,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
+      void this._factory.onConnectionDestroyed().catch((err) => log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 345, S: this }));
       for (const [_, pendingCallback] of this._channelCreatedCallbacks.entries()) {
         pendingCallback.reject("Connection closed.");
       }
@@ -3802,12 +2520,7 @@ var RtcPeerConnection = class {
         ];
       }
     } catch (error) {
-      log13.catch(error, void 0, {
-        F: __dxlog_file14,
-        L: 395,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 365, S: this });
     }
     return config;
   }
@@ -3827,14 +2540,9 @@ var RtcPeerConnection = class {
         }
       });
     } catch (err) {
-      log13.warn("signaling error", {
+      log10.warn("signaling error", {
         err
-      }, {
-        F: __dxlog_file14,
-        L: 416,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 385, S: this });
     }
   }
   async _sendDescription(connection, description) {
@@ -3892,13 +2600,13 @@ _ts_decorate6([
   synchronized5
 ], RtcPeerConnection.prototype, "onSignal", null);
 _ts_decorate6([
-  trace4.info()
+  trace.info()
 ], RtcPeerConnection.prototype, "_connectionInfo", null);
 _ts_decorate6([
   logInfo4
 ], RtcPeerConnection.prototype, "_loggerContext", null);
 RtcPeerConnection = _ts_decorate6([
-  trace4.resource()
+  trace.resource()
 ], RtcPeerConnection);
 var isRemoteDescriptionSet = (connection, data) => {
   if (!connection.remoteDescription?.type || connection.remoteDescription?.type !== data.type) {
@@ -3908,8 +2616,10 @@ var isRemoteDescriptionSet = (connection, data) => {
 };
 var createIceFailureError = (details) => {
   const candidateErrors = details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`);
-  return new ConnectivityError3(`ICE failed:
-${candidateErrors.join("\n")}`);
+  return new ConnectivityError3({
+    message: `ICE failed:
+${candidateErrors.join("\n")}`
+  });
 };
 
 // src/transport/webrtc/rtc-transport-factory.ts
@@ -3935,19 +2645,25 @@ import { Writable } from "@dxos/node-std/stream";
 import { Event as Event8, scheduleTask as scheduleTask4 } from "@dxos/async";
 import { Resource as Resource2 } from "@dxos/context";
 import { ErrorStream as ErrorStream5 } from "@dxos/debug";
-import { invariant as invariant13 } from "@dxos/invariant";
-import { PublicKey as PublicKey10 } from "@dxos/keys";
-import { log as log14 } from "@dxos/log";
+import { invariant as invariant11 } from "@dxos/invariant";
+import { PublicKey as PublicKey9 } from "@dxos/keys";
+import { log as log11 } from "@dxos/log";
 import { ConnectionResetError as ConnectionResetError2, ConnectivityError as ConnectivityError4, TimeoutError as TimeoutError3 } from "@dxos/protocols";
 import { ConnectionState as ConnectionState3 } from "@dxos/protocols/proto/dxos/mesh/bridge";
 import { arrayToBuffer } from "@dxos/util";
-var __dxlog_file15 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts";
+var __dxlog_file12 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts";
 var RPC_TIMEOUT = 1e4;
 var CLOSE_RPC_TIMEOUT = 3e3;
 var RESP_MIN_THRESHOLD = 500;
 var RtcTransportProxy = class extends Resource2 {
+  _options;
+  _proxyId = PublicKey9.random();
+  closed = new Event8();
+  connected = new Event8();
+  errors = new ErrorStream5();
+  _serviceStream;
   constructor(_options) {
-    super(), this._options = _options, this._proxyId = PublicKey10.random(), this.closed = new Event8(), this.connected = new Event8(), this.errors = new ErrorStream5();
+    super(), this._options = _options;
   }
   async _open() {
     let stream;
@@ -3968,12 +2684,7 @@ var RtcTransportProxy = class extends Resource2 {
     this._serviceStream = stream;
     stream.waitUntilReady().then(() => {
       stream.subscribe(async (event) => {
-        log14("rtc transport proxy event", event, {
-          F: __dxlog_file15,
-          L: 66,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log11("rtc transport proxy event", event, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 46, S: this });
         if (event.connection) {
           await this._handleConnection(event.connection);
         } else if (event.data) {
@@ -3982,14 +2693,9 @@ var RtcTransportProxy = class extends Resource2 {
           await this._handleSignal(event.signal);
         }
       }, (err) => {
-        log14("rtc bridge stream closed", {
+        log11("rtc bridge stream closed", {
           err
-        }, {
-          F: __dxlog_file15,
-          L: 76,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 55, S: this });
         if (err) {
           this._raiseIfOpen(err);
         } else {
@@ -4006,12 +2712,7 @@ var RtcTransportProxy = class extends Resource2 {
             timeout: RPC_TIMEOUT
           }).then(() => {
             if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
-              log14("slow response, delaying callback", void 0, {
-                F: __dxlog_file15,
-                L: 93,
-                S: this,
-                C: (f, a) => f(...a)
-              });
+              log11("slow response, delaying callback", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 74, S: this });
               scheduleTask4(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
             } else {
               callback();
@@ -4039,12 +2740,7 @@ var RtcTransportProxy = class extends Resource2 {
       await this._serviceStream?.close();
       this._serviceStream = void 0;
     } catch (err) {
-      log14.catch(err, void 0, {
-        F: __dxlog_file15,
-        L: 128,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log11.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 102, S: this });
     }
     try {
       await this._options.bridgeService.close({
@@ -4053,12 +2749,7 @@ var RtcTransportProxy = class extends Resource2 {
         timeout: CLOSE_RPC_TIMEOUT
       });
     } catch (err) {
-      log14.catch(err, void 0, {
-        F: __dxlog_file15,
-        L: 134,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log11.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 111, S: this });
     }
     this.closed.emit();
   }
@@ -4099,7 +2790,9 @@ var RtcTransportProxy = class extends Resource2 {
     } catch (error) {
       const type = signalEvent.payload.payload.data?.type;
       if (type === "offer" || type === "answer") {
-        this._raiseIfOpen(new ConnectivityError4(`Session establishment failed: ${type} couldn't be sent.`));
+        this._raiseIfOpen(new ConnectivityError4({
+          message: `Session establishment failed: ${type} couldn't be sent.`
+        }));
       }
     }
   }
@@ -4137,14 +2830,9 @@ var RtcTransportProxy = class extends Resource2 {
     if (this.isOpen) {
       this.errors.raise(error);
     } else {
-      log14.info("error swallowed because transport was closed", {
+      log11.info("error swallowed because transport was closed", {
         message: error.message
-      }, {
-        F: __dxlog_file15,
-        L: 215,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 195, S: this });
     }
   }
   /**
@@ -4156,9 +2844,8 @@ var RtcTransportProxy = class extends Resource2 {
   }
 };
 var RtcTransportProxyFactory = class {
-  constructor() {
-    this._connections = /* @__PURE__ */ new Set();
-  }
+  _bridgeService;
+  _connections = /* @__PURE__ */ new Set();
   /**
   * Sets the current BridgeService to be used to open connections.
   * Calling this method will close any existing connections.
@@ -4171,15 +2858,7 @@ var RtcTransportProxyFactory = class {
     return this;
   }
   createTransport(options) {
-    invariant13(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", {
-      F: __dxlog_file15,
-      L: 245,
-      S: this,
-      A: [
-        "this._bridgeService",
-        "'RtcTransportProxyFactory is not ready to open connections'"
-      ]
-    });
+    invariant11(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 221, S: this, A: ["this._bridgeService", "'RtcTransportProxyFactory is not ready to open connections'"] });
     const transport = new RtcTransportProxy({
       ...options,
       bridgeService: this._bridgeService
@@ -4194,11 +2873,17 @@ var RtcTransportProxyFactory = class {
 var decodeError = (err) => {
   const message = typeof err === "string" ? err : err.message;
   if (message.includes("CONNECTION_RESET")) {
-    return new ConnectionResetError2(message);
+    return new ConnectionResetError2({
+      message
+    });
   } else if (message.includes("TIMEOUT")) {
-    return new TimeoutError3(message);
+    return new TimeoutError3({
+      message
+    });
   } else if (message.includes("CONNECTIVITY_ERROR")) {
-    return new ConnectivityError4(message);
+    return new ConnectivityError4({
+      message
+    });
   } else {
     return typeof err === "string" ? new Error(err) : err;
   }
@@ -4207,16 +2892,17 @@ var decodeError = (err) => {
 // src/transport/webrtc/rtc-transport-service.ts
 import { Duplex as Duplex2 } from "@dxos/node-std/stream";
 import { Stream } from "@dxos/codec-protobuf/stream";
-import { invariant as invariant14 } from "@dxos/invariant";
-import { PublicKey as PublicKey11 } from "@dxos/keys";
-import { log as log15 } from "@dxos/log";
+import { invariant as invariant12 } from "@dxos/invariant";
+import { PublicKey as PublicKey10 } from "@dxos/keys";
+import { log as log12 } from "@dxos/log";
 import { ConnectionState as ConnectionState4 } from "@dxos/protocols/proto/dxos/mesh/bridge";
 import { ComplexMap as ComplexMap8 } from "@dxos/util";
-var __dxlog_file16 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
+var __dxlog_file13 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
 var RtcTransportService = class {
+  _transportFactory;
+  _openTransports = new ComplexMap8(PublicKey10.hash);
   constructor(webrtcConfig, iceProvider, _transportFactory = createRtcTransportFactory(webrtcConfig, iceProvider)) {
     this._transportFactory = _transportFactory;
-    this._openTransports = new ComplexMap8(PublicKey11.hash);
   }
   hasOpenTransports() {
     return this._openTransports.size > 0;
@@ -4224,12 +2910,7 @@ var RtcTransportService = class {
   open(request) {
     const existingTransport = this._openTransports.get(request.proxyId);
     if (existingTransport) {
-      log15.error("requesting a new transport bridge for an existing proxy", void 0, {
-        F: __dxlog_file16,
-        L: 53,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log12.error("requesting a new transport bridge for an existing proxy", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 24, S: this });
       void this._safeCloseTransport(existingTransport);
       this._openTransports.delete(request.proxyId);
     }
@@ -4290,69 +2971,32 @@ var RtcTransportService = class {
         close(err);
       });
       ready();
-      log15("stream ready", void 0, {
-        F: __dxlog_file16,
-        L: 115,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log12("stream ready", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 85, S: this });
       pushNewState(ConnectionState4.CONNECTING);
     });
   }
   async sendSignal({ proxyId, signal }) {
     const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 123,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
+    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 91, S: this, A: ["transport", ""] });
     await transport.transport.onSignal(signal);
   }
   async getDetails({ proxyId }) {
     const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 130,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
+    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 96, S: this, A: ["transport", ""] });
     return {
       details: await transport.transport.getDetails()
     };
   }
   async getStats({ proxyId }) {
     const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 137,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
+    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 103, S: this, A: ["transport", ""] });
     return {
       stats: await transport.transport.getStats()
     };
   }
   async sendData({ proxyId, payload }) {
     const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 144,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
+    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 110, S: this, A: ["transport", ""] });
     const bufferHasSpace = transport.connectorStream.push(payload);
     if (!bufferHasSpace) {
       await new Promise((resolve) => {
@@ -4376,33 +3020,18 @@ var RtcTransportService = class {
     try {
       await transport.transport.close();
     } catch (error) {
-      log15.warn("transport close error", {
+      log12.warn("transport close error", {
         message: error?.message
-      }, {
-        F: __dxlog_file16,
-        L: 174,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 134, S: this });
     }
     try {
       transport.connectorStream.end();
     } catch (error) {
-      log15.warn("connectorStream close error", {
+      log12.warn("connectorStream close error", {
         message: error?.message
-      }, {
-        F: __dxlog_file16,
-        L: 179,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 141, S: this });
     }
-    log15("closed", void 0, {
-      F: __dxlog_file16,
-      L: 181,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log12("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 145, S: this });
   }
 };
 var createStateUpdater = (next) => {
@@ -4420,10 +3049,10 @@ var createStateUpdater = (next) => {
 
 // src/wire-protocol.ts
 import { Teleport } from "@dxos/teleport";
-var createTeleportProtocolFactory = (onConnection, defaultParams) => {
+var createTeleportProtocolFactory = (onConnection, defaultProps) => {
   return (params) => {
     const teleport = new Teleport({
-      ...defaultParams,
+      ...defaultProps,
       ...params
     });
     return {
@@ -4445,7 +3074,6 @@ var createTeleportProtocolFactory = (onConnection, defaultParams) => {
 export {
   ConnectionState,
   Connection,
-  createIceProvider,
   SwarmMessenger,
   Swarm,
   SwarmMapper,
@@ -4455,8 +3083,6 @@ export {
   ConnectionLog,
   SwarmNetworkManager,
   FullyConnectedTopology,
-  MMSTTopology,
-  StarTopology,
   MemoryTransportFactory,
   MemoryTransport,
   TransportKind,
@@ -4466,4 +3092,4 @@ export {
   RtcTransportService,
   createTeleportProtocolFactory
 };
-//# sourceMappingURL=chunk-HQNQOWFA.mjs.map
+//# sourceMappingURL=chunk-LRGOUKHO.mjs.map