@dxos/network-manager 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/dist/lib/browser/{chunk-AQSYW43M.mjs → chunk-UFYPMUBI.mjs}

@@ -5,16 +5,15 @@ import { DeferredTask, Event, Trigger, scheduleTask, scheduleTaskInterval, sleep
 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, ConnectionResetError, ConnectivityError, ProtocolError, 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;
@@ -40,14 +39,8 @@ var Connection = class {
   _protocol;
   _transportFactory;
   _callbacks;
-  _ctx = new Context(void 0, {
-    F: __dxlog_file,
-    L: 100
-  });
-  connectedTimeoutContext = new Context(void 0, {
-    F: __dxlog_file,
-    L: 101
-  });
+  _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";
@@ -57,10 +50,9 @@ var Connection = class {
   _outgoingSignalBuffer = [];
   stateChanged = new Event();
   errors = new ErrorStream();
-  _instanceId = PublicKey.random().toHex();
   transportStats = new Event();
   _signalSendTask = new DeferredTask(this._ctx, async () => {
-    await this._flushSignalBuffer();
+    await this._flushSignalBuffer(this._ctx);
   });
   _signallingDelay = STARTING_SIGNALLING_DELAY;
   constructor(topic, localInfo, remoteInfo, sessionId, initiator, _signalMessaging, _protocol, _transportFactory, _callbacks) {
@@ -79,12 +71,7 @@ var Connection = class {
       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();
@@ -102,46 +89,21 @@ 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({
@@ -150,25 +112,12 @@ var Connection = class {
       }).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: 196,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      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: 204,
-      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,
@@ -187,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: 226,
-        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: 231,
-        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: 238,
-          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: 241,
-          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") {
@@ -234,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: 260,
-      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: 267,
-      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: 269,
-        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();
@@ -270,55 +182,30 @@ var Connection = class {
     log("aborting...", {
       peerId: this.localInfo,
       err
-    }, {
-      F: __dxlog_file,
-      L: 281,
-      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: 287,
-        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: 294,
-        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: 300,
-        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: 307,
-      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 {
@@ -328,12 +215,7 @@ var Connection = class {
       log("close ignored: already in progress", {
         state: this._state,
         error
-      }, {
-        F: __dxlog_file,
-        L: 318,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 244, S: this });
       return;
     }
     const lastState = this._state;
@@ -342,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: 329,
-        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: 333,
-      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: 338,
-        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: 344,
-        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: 347,
-      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: 353,
-      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: 355,
-      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: 359,
-      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: 361,
-      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,
@@ -463,12 +300,7 @@ var Connection = class {
       }
       log.info("signal message failed to deliver", {
         err
-      }, {
-        F: __dxlog_file,
-        L: 401,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 333, S: this });
       await this.close({
         error: new ConnectivityError({
           message: "signal message failed to deliver",
@@ -480,52 +312,15 @@ var Connection = class {
   /**
   * Receive a signal from the remote peer.
   */
-  async signal(msg) {
-    invariant(msg.sessionId, void 0, {
-      F: __dxlog_file,
-      L: 410,
-      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: 412,
-        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: 415,
-      S: this,
-      A: [
-        "msg.data.signal || msg.data.signalBatch",
-        ""
-      ]
-    });
-    invariant(msg.author.peerKey === this.remoteInfo.peerKey, void 0, {
-      F: __dxlog_file,
-      L: 416,
-      S: this,
-      A: [
-        "msg.author.peerKey === this.remoteInfo.peerKey",
-        ""
-      ]
-    });
-    invariant(msg.recipient.peerKey === this.localInfo.peerKey, void 0, {
-      F: __dxlog_file,
-      L: 417,
-      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
     ];
@@ -541,33 +336,15 @@ var Connection = class {
           peerId: this.localInfo,
           remoteId: this.remoteInfo,
           msg: msg.data
-        }, {
-          F: __dxlog_file,
-          L: 426,
-          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: 429,
-          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: 430,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 374, S: this });
         await this._transport.onSignal(signal);
       }
     }
@@ -580,21 +357,8 @@ var Connection = class {
       from: this._state,
       to: state,
       peerId: this.localInfo
-    }, {
-      F: __dxlog_file,
-      L: 441,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    invariant(state !== this._state, "Already in this state.", {
-      F: __dxlog_file,
-      L: 442,
-      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);
   }
@@ -616,9 +380,8 @@ _ts_decorate([
 ], Connection.prototype, "close", null);
 
 // 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 { PublicKey } from "@dxos/keys";
 import { log as log2 } from "@dxos/log";
 import { TimeoutError as TimeoutError2 } from "@dxos/protocols";
 import { schema } from "@dxos/protocols/proto";
@@ -626,10 +389,6 @@ import { ComplexMap } from "@dxos/util";
 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 {
-  _ctx = new Context2(void 0, {
-    F: __dxlog_file2,
-    L: 35
-  });
   _sendMessage;
   _onSignal;
   _onOffer;
@@ -641,7 +400,7 @@ var SwarmMessenger = class {
     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;
     }
@@ -653,14 +412,9 @@ var SwarmMessenger = class {
       from: author,
       to: recipient,
       msg: message
-    }, {
-      F: __dxlog_file2,
-      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
@@ -668,13 +422,13 @@ 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
@@ -682,63 +436,45 @@ var SwarmMessenger = class {
     } else {
       log2.warn("unknown message", {
         message
-      }, {
-        F: __dxlog_file2,
-        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_file2,
-      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()
     };
     log2("sending", {
       from: author,
       to: recipient,
       msg: networkMessage
-    }, {
-      F: __dxlog_file2,
-      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: {
@@ -748,48 +484,19 @@ var SwarmMessenger = class {
     });
   }
   async _resolveAnswers(message) {
-    invariant2(message.data?.answer?.offerMessageId, "No offerMessageId", {
-      F: __dxlog_file2,
-      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_file2,
-        L: 141,
-        S: this,
-        A: [
-          "message.data?.answer",
-          "'No answer'"
-        ]
-      });
+      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_file2,
-        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_file2,
-      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,
@@ -798,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: {
@@ -816,43 +523,17 @@ var SwarmMessenger = class {
       if (err instanceof TimeoutError2) {
         log2.info("timeout sending answer to offer", {
           err
-        }, {
-          F: __dxlog_file2,
-          L: 177,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 148, S: this });
       } else {
         log2.info("error sending answer to offer", {
           err
-        }, {
-          F: __dxlog_file2,
-          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_file2,
-      L: 193,
-      S: this,
-      A: [
-        "message.messageId",
-        ""
-      ]
-    });
-    invariant2(message.data.signal || message.data.signalBatch, "Invalid message", {
-      F: __dxlog_file2,
-      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,
@@ -862,35 +543,34 @@ 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 { 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 } 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 { 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_file3 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
 var ConnectionDisplacedError = class extends SystemError {
   constructor() {
     super({
@@ -914,10 +594,7 @@ var Peer = class {
   _availableAfter = 0;
   availableToConnect = true;
   _lastConnectionTime;
-  _ctx = new Context3(void 0, {
-    F: __dxlog_file3,
-    L: 81
-  });
+  _ctx = new Context2(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 44 });
   _connectionCtx;
   connection;
   /**
@@ -939,19 +616,14 @@ var Peer = class {
   /**
   * 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)) {
-      log3.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
-        F: __dxlog_file3,
-        L: 116,
-        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
       };
@@ -963,12 +635,7 @@ var Peer = class {
           topic: this.topic,
           remotePeer: this.remoteInfo,
           sessionId: this.connection?.sessionId
-        }, {
-          F: __dxlog_file3,
-          L: 125,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 82, S: this });
         if (this.connection) {
           await this.closeConnection(new ConnectionDisplacedError());
         }
@@ -980,15 +647,7 @@ var Peer = class {
     }
     if (await this._callbacks.onOffer(remote)) {
       if (!this.connection) {
-        invariant3(message.sessionId, void 0, {
-          F: __dxlog_file3,
-          L: 145,
-          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);
@@ -1001,12 +660,7 @@ var Peer = class {
               peerId: this.localInfo,
               remoteId: this.remoteInfo,
               err
-            }, {
-              F: __dxlog_file3,
-              L: 155,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 110, S: this });
           }
           await this.closeConnection(err);
         }
@@ -1022,44 +676,23 @@ var Peer = class {
   /**
   * Initiate a connection to the remote peer.
   */
-  async initiateConnection() {
-    invariant3(!this.initiating, "Initiation in progress.", {
-      F: __dxlog_file3,
-      L: 173,
-      S: this,
-      A: [
-        "!this.initiating",
-        "'Initiation in progress.'"
-      ]
-    });
-    invariant3(!this.connection, "Already connected.", {
-      F: __dxlog_file3,
-      L: 174,
-      S: this,
-      A: [
-        "!this.connection",
-        "'Already connected.'"
-      ]
-    });
-    const sessionId = PublicKey3.random();
+  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_file3,
-      L: 176,
-      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,
@@ -1073,19 +706,9 @@ var Peer = class {
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file3,
-        L: 193,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 156, S: this });
       if (connection.state !== ConnectionState.INITIAL) {
-        log3("ignoring response", void 0, {
-          F: __dxlog_file3,
-          L: 195,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        log3("ignoring response", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 163, S: this });
         return;
       }
     } catch (err) {
@@ -1094,12 +717,7 @@ var Peer = class {
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file3,
-        L: 199,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 167, S: this });
       await connection.abort(err);
       throw err;
     } finally {
@@ -1116,24 +734,14 @@ var Peer = class {
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file3,
-        L: 212,
-        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 {
-      log3("opening connection as initiator", void 0, {
-        F: __dxlog_file3,
-        L: 225,
-        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) {
@@ -1142,20 +750,10 @@ var Peer = class {
         topic: this.topic,
         local: this.localInfo,
         remote: this.remoteInfo
-      }, {
-        F: __dxlog_file3,
-        L: 229,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 200, S: this });
       log3.warn("closing connection due to unhandled error on openConnection", {
         err
-      }, {
-        F: __dxlog_file3,
-        L: 236,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 207, S: this });
       await this.closeConnection(err);
       throw err;
     } finally {
@@ -1173,21 +771,8 @@ var Peer = class {
       remoteId: this.remoteInfo,
       initiator,
       sessionId
-    }, {
-      F: __dxlog_file3,
-      L: 250,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    invariant3(!this.connection, "Already connected.", {
-      F: __dxlog_file3,
-      L: 257,
-      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,
@@ -1198,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,
@@ -1215,12 +800,7 @@ var Peer = class {
             remotePeerId: this.remoteInfo,
             sessionId,
             initiator
-          }, {
-            F: __dxlog_file3,
-            L: 281,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 241, S: this });
         },
         onClosed: (err) => {
           const logMeta = {
@@ -1229,34 +809,16 @@ var Peer = class {
             remoteId: this.remoteInfo,
             initiator
           };
-          log3("connection closed", logMeta, {
-            F: __dxlog_file3,
-            L: 291,
-            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_file3,
-            L: 296,
-            S: this,
-            A: [
-              "this.connection === connection",
-              "'Connection mismatch (race condition).'"
-            ]
-          });
+          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_file3,
-            L: 298,
-            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 {
@@ -1268,12 +830,7 @@ var Peer = class {
             }
             this._callbacks.onDisconnected();
             scheduleTask2(this._connectionCtx, () => {
-              log3("peer became available", logMeta, {
-                F: __dxlog_file3,
-                L: 322,
-                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);
@@ -1292,12 +849,7 @@ var Peer = class {
         remoteId: this.remoteInfo,
         initiator,
         err
-      }, {
-        F: __dxlog_file3,
-        L: 340,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 291, S: this });
       log3.trace("dxos.mesh.connection.error", {
         topic: this.topic,
         localPeerId: this.localInfo,
@@ -1305,12 +857,7 @@ var Peer = class {
         sessionId,
         initiator,
         err
-      }, {
-        F: __dxlog_file3,
-        L: 347,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 298, S: this });
       void this.closeConnection(err);
     });
     this.connection = connection;
@@ -1324,50 +871,30 @@ var Peer = class {
     log3("closing...", {
       peerId: this.remoteInfo,
       sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file3,
-      L: 372,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 317, S: this });
     await connection.close({
       error: err
     });
     log3("closed", {
       peerId: this.remoteInfo,
       sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file3,
-      L: 378,
-      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) {
       log3("dropping signal message for non-existent connection", {
         message
-      }, {
-        F: __dxlog_file3,
-        L: 383,
-        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();
     log3("Destroying peer", {
       peerId: this.remoteInfo,
       topic: this.topic
-    }, {
-      F: __dxlog_file3,
-      L: 393,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 342, S: this });
     await this?.connection?.close({
       reason
     });
@@ -1390,13 +917,13 @@ 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_file4 = "/__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 {
@@ -1410,10 +937,7 @@ var Swarm = class {
   _connectionLimiter;
   _initiationDelay;
   _swarmMessenger;
-  _ctx = new Context4(void 0, {
-    F: __dxlog_file4,
-    L: 39
-  });
+  _ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 39 });
   _listeningHandle = void 0;
   /**
   * PeerInfo -> Peer.
@@ -1423,7 +947,7 @@ var Swarm = class {
   /**
   * Unique id of the swarm, local to the current peer, generated when swarm is joined.
   */
-  _instanceId = PublicKey4.random().toHex();
+  _instanceId = PublicKey3.random().toHex();
   /**
   * New connection to a peer is started.
   * @internal
@@ -1452,47 +976,23 @@ var Swarm = class {
     this._label = _label;
     this._connectionLimiter = _connectionLimiter;
     this._initiationDelay = _initiationDelay;
-    log4.trace("dxos.mesh.swarm.constructor", trace2.begin({
-      id: this._instanceId,
-      data: {
-        topic: this._topic.toHex(),
-        peer: this._ownPeer
-      }
-    }), {
-      F: __dxlog_file4,
-      L: 89,
-      S: this,
-      C: (f, a) => f(...a)
-    });
     log4("creating swarm", {
-      peerId: _ownPeer
-    }, {
-      F: __dxlog_file4,
-      L: 93,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+      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
     });
-    log4.trace("dxos.mesh.swarm.constructor", trace2.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file4,
-      L: 102,
-      S: this,
-      C: (f, a) => f(...a)
-    });
   }
   get connections() {
     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;
@@ -1507,71 +1007,35 @@ var Swarm = class {
     return this._topic;
   }
   async open() {
-    invariant4(!this._listeningHandle, void 0, {
-      F: __dxlog_file4,
-      L: 133,
-      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) => log4.info("Error while receiving message", {
+        await this._swarmMessenger.receiveMessage(this._ctx, message).catch((err) => log4.info("Error while receiving message", {
           err
-        }, {
-          F: __dxlog_file4,
-          L: 141,
-          S: this,
-          C: (f, a) => f(...a)
-        }));
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 109, S: this }));
       }
     });
   }
   async destroy() {
-    log4("destroying...", void 0, {
-      F: __dxlog_file4,
-      L: 147,
-      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")));
-    log4("destroyed", void 0, {
-      F: __dxlog_file4,
-      L: 154,
-      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_file4,
-      L: 158,
-      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;
     }
     log4("setting topology", {
       previous: getClassName(this._topology),
       topology: getClassName(topology)
-    }, {
-      F: __dxlog_file4,
-      L: 162,
-      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());
@@ -1580,19 +1044,9 @@ var Swarm = class {
   async onSwarmEvent(swarmEvent) {
     log4("swarm event", {
       swarmEvent
-    }, {
-      F: __dxlog_file4,
-      L: 175,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 139, S: this });
     if (this._ctx.disposed) {
-      log4("swarm event ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
-        L: 178,
-        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) {
@@ -1600,12 +1054,7 @@ var Swarm = class {
       if (peerId !== this._ownPeer.peerKey) {
         log4("new peer", {
           peerId
-        }, {
-          F: __dxlog_file4,
-          L: 185,
-          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;
       }
@@ -1614,70 +1063,32 @@ var Swarm = class {
       if (peer) {
         peer.advertizing = false;
         if (this._isConnectionEstablishmentInProgress(peer)) {
-          log4(`destroying peer, state: ${peer.connection?.state}`, void 0, {
-            F: __dxlog_file4,
-            L: 196,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          void this._destroyPeer(swarmEvent.peerLeft.peer, "peer left").catch((err) => log4.catch(err, void 0, {
-            F: __dxlog_file4,
-            L: 197,
-            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 {
         log4("received peerLeft but no peer found", {
           peer: swarmEvent.peerLeft.peer.peerKey
-        }, {
-          F: __dxlog_file4,
-          L: 200,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 166, S: this });
       }
     }
     this._topology.update();
   }
-  async onOffer(message) {
+  async onOffer(ctx, message) {
     log4("offer", {
       message
-    }, {
-      F: __dxlog_file4,
-      L: 209,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 174, S: this });
     if (this._ctx.disposed) {
-      log4("ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
-        L: 211,
-        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_file4,
-      L: 216,
-      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) {
       log4("rejecting offer with incorrect peerId", {
         message
-      }, {
-        F: __dxlog_file4,
-        L: 218,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 186, S: this });
       return {
         accept: false
       };
@@ -1685,18 +1096,13 @@ var Swarm = class {
     if (!message.topic?.equals(this._topic)) {
       log4("rejecting offer with incorrect topic", {
         message
-      }, {
-        F: __dxlog_file4,
-        L: 222,
-        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;
   }
@@ -1710,53 +1116,19 @@ var Swarm = class {
     }
     return peer;
   }
-  async onSignal(message) {
+  async onSignal(ctx, message) {
     log4("signal", {
       message
-    }, {
-      F: __dxlog_file4,
-      L: 247,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 218, S: this });
     if (this._ctx.disposed) {
-      log4.info("ignored for offline swarm", void 0, {
-        F: __dxlog_file4,
-        L: 249,
-        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_file4,
-      L: 252,
-      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_file4,
-      L: 256,
-      S: this,
-      A: [
-        "message.topic?.equals(this._topic)",
-        ""
-      ]
-    });
-    invariant4(message.author, void 0, {
-      F: __dxlog_file4,
-      L: 257,
-      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() {
@@ -1767,21 +1139,10 @@ var Swarm = class {
   }
   // For debug purposes
   async goOnline() {
-    this._ctx = new Context4(void 0, {
-      F: __dxlog_file4,
-      L: 273
-    });
+    this._ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 240 });
   }
   _getOrCreatePeer(peerInfo) {
-    invariant4(peerInfo.peerKey, "PeerInfo.peerKey is required", {
-      F: __dxlog_file4,
-      L: 277,
-      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, {
@@ -1793,12 +1154,7 @@ var Swarm = class {
         },
         onDisconnected: async () => {
           if (this._isUnregistered(peer)) {
-            log4.verbose("ignored onDisconnected for unregistered peer", void 0, {
-              F: __dxlog_file4,
-              L: 297,
-              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) {
@@ -1811,12 +1167,7 @@ var Swarm = class {
           if (!this._isUnregistered(peer)) {
             log4("peer rejected connection", {
               peerInfo
-            }, {
-              F: __dxlog_file4,
-              L: 311,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 268, S: this });
             void this._destroyPeer(peerInfo, "peer rejected connection");
           }
         },
@@ -1824,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();
@@ -1838,32 +1189,19 @@ var Swarm = class {
     log4("destroy peer", {
       peerKey: peerInfo.peerKey,
       reason
-    }, {
-      F: __dxlog_file4,
-      L: 333,
-      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_file4,
-      L: 335,
-      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) {
@@ -1875,12 +1213,7 @@ var Swarm = class {
               peerKey: peer.toHex()
             });
           } catch (err) {
-            log4("initiation error", err, {
-              F: __dxlog_file4,
-              L: 362,
-              S: this,
-              C: (f, a) => f(...a)
-            });
+            log4("initiation error", err, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 317, S: this });
           }
         });
       },
@@ -1906,12 +1239,7 @@ var Swarm = class {
     if (remotePeer.peerKey < this._ownPeer.peerKey) {
       log4("initiation delay", {
         remotePeer
-      }, {
-        F: __dxlog_file4,
-        L: 390,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 343, S: this });
       await sleep2(this._initiationDelay);
     }
     if (ctx.disposed) {
@@ -1925,22 +1253,12 @@ var Swarm = class {
     }
     log4("initiating connection...", {
       remotePeer
-    }, {
-      F: __dxlog_file4,
-      L: 406,
-      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();
     log4("initiated", {
       remotePeer
-    }, {
-      F: __dxlog_file4,
-      L: 409,
-      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);
@@ -1987,7 +1305,7 @@ _ts_decorate3([
 
 // src/swarm/swarm-mapper.ts
 import { Event as Event4, SubscriptionList } from "@dxos/async";
-import { PublicKey as PublicKey5 } from "@dxos/keys";
+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";
@@ -2017,12 +1335,7 @@ var SwarmMapper = class {
     this._update();
   }
   _update() {
-    log5("updating swarm", void 0, {
-      F: __dxlog_file5,
-      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,
@@ -2031,7 +1344,7 @@ 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
@@ -2041,12 +1354,7 @@ var SwarmMapper = class {
     log5("graph changed", {
       directConnections: this._swarm.connections.length,
       totalPeersInSwarm: this._peers.size
-    }, {
-      F: __dxlog_file5,
-      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.
@@ -2059,24 +1367,21 @@ 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 { 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_file6 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
 var MAX_CONCURRENT_INITIATING_CONNECTIONS = 50;
 var ConnectionLimiter = class {
-  _ctx = new Context5(void 0, {
-    F: __dxlog_file6,
-    L: 23
-  });
+  _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(PublicKey6.hash);
+  _waitingPromises = new ComplexMap4(PublicKey5.hash);
   resolveWaitingPromises = new DeferredTask2(this._ctx, async () => {
     Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
       resolve();
@@ -2089,23 +1394,10 @@ var ConnectionLimiter = class {
   * @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_file6,
-      L: 48,
-      S: this,
-      A: [
-        "!this._waitingPromises.has(sessionId)",
-        "'Peer is already waiting for connection'"
-      ]
-    });
+    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_file6,
-      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,
@@ -2115,12 +1407,7 @@ var ConnectionLimiter = class {
     });
     log6("allow", {
       sessionId
-    }, {
-      F: __dxlog_file6,
-      L: 57,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 42, S: this });
   }
   /**
   * Rejects promise returned by `connecting` method.
@@ -2128,12 +1415,7 @@ var ConnectionLimiter = class {
   doneConnecting(sessionId) {
     log6("done", {
       sessionId
-    }, {
-      F: __dxlog_file6,
-      L: 64,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 49, S: this });
     if (!this._waitingPromises.has(sessionId)) {
       return;
     }
@@ -2146,7 +1428,7 @@ 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) {
@@ -2161,7 +1443,7 @@ var ConnectionLog = class {
   /**
   * SwarmId => info
   */
-  _swarms = new ComplexMap5(PublicKey7.hash);
+  _swarms = new ComplexMap5(PublicKey6.hash);
   update = new Event5();
   getSwarmInfo(swarmId) {
     return this._swarms.get(swarmId) ?? raise(new Error(`Swarm not found: ${swarmId}`));
@@ -2171,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: [],
@@ -2223,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();
   }
 };
@@ -2236,32 +1518,30 @@ 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 { 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_file7 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
 var SwarmNetworkManager = class {
   /**
   * @internal
   */
-  _swarms = new ComplexMap6(PublicKey8.hash);
-  _mappers = new ComplexMap6(PublicKey8.hash);
+  _swarms = new ComplexMap6(PublicKey7.hash);
+  _mappers = new ComplexMap6(PublicKey7.hash);
   _transportFactory;
   _signalManager;
   _messenger;
   _signalConnection;
   _connectionLimiter;
   _connectionLog;
-  _instanceId = PublicKey8.random().toHex();
   _peerInfo = void 0;
   _connectionState = ConnectionState2.ONLINE;
   connectionStateChanged = new Event6();
@@ -2274,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();
@@ -2304,34 +1584,15 @@ var SwarmNetworkManager = class {
     this._peerInfo = peerInfo;
   }
   async open() {
-    log7.trace("dxos.mesh.network-manager.open", trace3.begin({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file7,
-      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();
-    log7.trace("dxos.mesh.network-manager.open", trace3.end({
-      id: this._instanceId
-    }), {
-      F: __dxlog_file7,
-      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) => {
-        log7(err, void 0, {
-          F: __dxlog_file7,
-          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();
@@ -2340,111 +1601,54 @@ var SwarmNetworkManager = class {
   /**
   * Join the swarm.
   */
-  async joinSwarm({ topic, topology, protocolProvider: protocol, label }) {
-    invariant6(PublicKey8.isPublicKey(topic), void 0, {
-      F: __dxlog_file7,
-      L: 160,
-      S: this,
-      A: [
-        "PublicKey.isPublicKey(topic)",
-        ""
-      ]
-    });
-    invariant6(topology, void 0, {
-      F: __dxlog_file7,
-      L: 161,
-      S: this,
-      A: [
-        "topology",
-        ""
-      ]
-    });
-    invariant6(this._peerInfo, void 0, {
-      F: __dxlog_file7,
-      L: 162,
-      S: this,
-      A: [
-        "this._peerInfo",
-        ""
-      ]
-    });
-    invariant6(typeof protocol === "function", void 0, {
-      F: __dxlog_file7,
-      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)}`);
     }
     log7("joining", {
-      topic: PublicKey8.from(topic),
+      topic: PublicKey7.from(topic),
       peerInfo: this._peerInfo,
       topology: topology.toString()
-    }, {
-      F: __dxlog_file7,
-      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) => {
       log7("swarm error", {
         error
-      }, {
-        F: __dxlog_file7,
-        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) => log7.catch(error, void 0, {
-      F: __dxlog_file7,
-      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);
     log7("joined", {
-      topic: PublicKey8.from(topic),
+      topic: PublicKey7.from(topic),
       count: this._swarms.size
-    }, {
-      F: __dxlog_file7,
-      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;
     }
     log7("leaving", {
-      topic: PublicKey8.from(topic)
-    }, {
-      F: __dxlog_file7,
-      L: 211,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+      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
     });
@@ -2456,14 +1660,9 @@ var SwarmNetworkManager = class {
     this._swarms.delete(topic);
     this.topicsUpdated.emit();
     log7("left", {
-      topic: PublicKey8.from(topic),
+      topic: PublicKey7.from(topic),
       count: this._swarms.size
-    }, {
-      F: __dxlog_file7,
-      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) {
@@ -2508,27 +1707,11 @@ var FullyConnectedTopology = class {
     return "FullyConnectedTopology";
   }
   init(controller) {
-    invariant7(!this._controller, "Already initialized", {
-      F: __dxlog_file8,
-      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_file8,
-      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);
@@ -2546,16 +1729,16 @@ 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 invariant8 } from "@dxos/invariant";
-import { PublicKey as PublicKey9 } from "@dxos/keys";
+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_file9 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
 var MEMORY_TRANSPORT_DELAY = 1;
 var createStreamDelay = (delay) => {
   return new Transform({
@@ -2571,8 +1754,8 @@ var MemoryTransportFactory = {
 var MemoryTransport = class _MemoryTransport {
   _options;
   // TODO(burdon): Remove static properties (inject context into constructor).
-  static _connections = new ComplexMap7(PublicKey9.hash);
-  _instanceId = PublicKey9.random();
+  static _connections = new ComplexMap7(PublicKey8.hash);
+  _instanceId = PublicKey8.random();
   _remote = new Trigger2();
   _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
   _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
@@ -2584,34 +1767,16 @@ var MemoryTransport = class _MemoryTransport {
   errors = new ErrorStream3();
   constructor(_options) {
     this._options = _options;
-    invariant8(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", {
-      F: __dxlog_file9,
-      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() {
-    log8("opening...", void 0, {
-      F: __dxlog_file9,
-      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) {
-      log8("sending signal", void 0, {
-        F: __dxlog_file9,
-        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: {
@@ -2637,23 +1802,10 @@ var MemoryTransport = class _MemoryTransport {
           this.closed.emit();
           return;
         }
-        invariant8(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
-          F: __dxlog_file9,
-          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;
-        log8("connected", void 0, {
-          F: __dxlog_file9,
-          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();
@@ -2667,12 +1819,7 @@ var MemoryTransport = class _MemoryTransport {
     return this;
   }
   async close() {
-    log8("closing...", void 0, {
-      F: __dxlog_file9,
-      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) {
@@ -2688,29 +1835,19 @@ var MemoryTransport = class _MemoryTransport {
       this._remoteConnection = void 0;
     }
     this.closed.emit();
-    log8("closed", void 0, {
-      F: __dxlog_file9,
-      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 }) {
     log8("received signal", {
       payload
-    }, {
-      F: __dxlog_file9,
-      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);
     }
   }
@@ -2793,7 +1930,7 @@ import { Mutex as Mutex2, Trigger as Trigger3, synchronized as synchronized5 } f
 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";
@@ -2877,15 +2014,7 @@ var RtcTransportChannel = class extends Resource {
     }
   }
   async _open() {
-    invariant9(!this._isChannelCreationInProgress, void 0, {
-      F: __dxlog_file10,
-      L: 57,
-      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) {
@@ -2903,12 +2032,7 @@ var RtcTransportChannel = class extends Resource {
       } else {
         log9.verbose("connection establishment failed after transport was closed", {
           err
-        }, {
-          F: __dxlog_file10,
-          L: 77,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 57, S: this });
       }
     }).finally(() => {
       this._isChannelCreationInProgress = false;
@@ -2921,12 +2045,7 @@ var RtcTransportChannel = class extends Resource {
       this._stream = void 0;
     }
     this.closed.emit();
-    log9("closed", void 0, {
-      F: __dxlog_file10,
-      L: 93,
-      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, {
@@ -2934,21 +2053,11 @@ var RtcTransportChannel = class extends Resource {
         if (!this.isOpen) {
           log9.warn("channel opened in a closed transport", {
             topic: this._options.topic
-          }, {
-            F: __dxlog_file10,
-            L: 100,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 78, S: this });
           this._safeCloseChannel(channel);
           return;
         }
-        log9("onopen", void 0, {
-          F: __dxlog_file10,
-          L: 105,
-          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: () => {
           },
@@ -2961,22 +2070,12 @@ var RtcTransportChannel = class extends Resource {
         this.connected.emit();
       },
       onclose: async () => {
-        log9("onclose", void 0, {
-          F: __dxlog_file10,
-          L: 118,
-          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) {
-          log9.warn("ignoring message on a closed channel", void 0, {
-            F: __dxlog_file10,
-            L: 124,
-            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;
@@ -3002,12 +2101,7 @@ var RtcTransportChannel = class extends Resource {
   }
   async _handleChannelWrite(chunk, callback) {
     if (!this._channel) {
-      log9.warn("writing to a channel after a connection was closed", void 0, {
-        F: __dxlog_file10,
-        L: 154,
-        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) {
@@ -3025,12 +2119,7 @@ var RtcTransportChannel = class extends Resource {
     }
     if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
       if (this._streamDataFlushedCallback !== null) {
-        log9.error("consumer trying to write before we are ready for more data", void 0, {
-          F: __dxlog_file10,
-          L: 175,
-          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 {
@@ -3041,12 +2130,7 @@ var RtcTransportChannel = class extends Resource {
     try {
       channel.close();
     } catch (error) {
-      log9.catch(error, void 0, {
-        F: __dxlog_file10,
-        L: 187,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log9.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 156, S: this });
     }
   }
   onSignal(signal) {
@@ -3087,13 +2171,13 @@ 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_file11 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
 var RtcPeerConnection = class {
   _factory;
   _options;
@@ -3141,12 +2225,7 @@ var RtcPeerConnection = class {
       if (existingChannel) {
         return existingChannel;
       }
-      log10("waiting for initiator-peer to open a data channel", void 0, {
-        F: __dxlog_file11,
-        L: 96,
-        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,
@@ -3172,36 +2251,18 @@ var RtcPeerConnection = class {
     }
     log10("initializing connection...", () => ({
       remotePeer: this._options.remotePeerKey
-    }), {
-      F: __dxlog_file11,
-      L: 121,
-      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 () => {
-        invariant10(this._initiator, void 0, {
-          F: __dxlog_file11,
-          L: 136,
-          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;
         }
-        log10("onnegotiationneeded", void 0, {
-          F: __dxlog_file11,
-          L: 143,
-          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);
@@ -3220,20 +2281,10 @@ var RtcPeerConnection = class {
         if (event.candidate) {
           log10("onicecandidate", {
             candidate: event.candidate.candidate
-          }, {
-            F: __dxlog_file11,
-            L: 162,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 122, S: this });
           await this._sendIceCandidate(event.candidate);
         } else {
-          log10("onicecandidate gathering complete", void 0, {
-            F: __dxlog_file11,
-            L: 165,
-            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.
@@ -3256,12 +2307,7 @@ var RtcPeerConnection = class {
         }
         log10("oniceconnectionstatechange", {
           state: connection.iceConnectionState
-        }, {
-          F: __dxlog_file11,
-          L: 185,
-          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));
         }
@@ -3278,12 +2324,7 @@ var RtcPeerConnection = class {
         }
         log10("onconnectionstatechange", {
           state: connection.connectionState
-        }, {
-          F: __dxlog_file11,
-          L: 202,
-          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."));
         }
@@ -3291,37 +2332,19 @@ var RtcPeerConnection = class {
       onsignalingstatechange: () => {
         log10("onsignalingstatechange", {
           state: connection.signalingState
-        }, {
-          F: __dxlog_file11,
-          L: 209,
-          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) => {
-        invariant10(!this._initiator, "Initiator is expected to create data channels.", {
-          F: __dxlog_file11,
-          L: 215,
-          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;
         }
         log10("ondatachannel", {
           label: event.channel.label
-        }, {
-          F: __dxlog_file11,
-          L: 222,
-          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) {
@@ -3344,12 +2367,7 @@ var RtcPeerConnection = class {
     if (connection !== this._connection) {
       log10.error("attempted to abort an inactive connection", {
         error
-      }, {
-        F: __dxlog_file11,
-        L: 247,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 208, S: this });
       this._safeCloseConnection(connection);
       return;
     }
@@ -3365,31 +2383,13 @@ var RtcPeerConnection = class {
     this._safeCloseConnection();
     log10("connection aborted", {
       reason: error.message
-    }, {
-      F: __dxlog_file11,
-      L: 261,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 224, S: this });
   }
   async _lockAndCloseConnection() {
-    invariant10(this._transportChannels.size === 0, void 0, {
-      F: __dxlog_file11,
-      L: 266,
-      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();
-      log10("connection closed", void 0, {
-        F: __dxlog_file11,
-        L: 269,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10("connection closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 232, S: this });
     }
   }
   async onSignal(signal) {
@@ -3397,12 +2397,7 @@ var RtcPeerConnection = class {
     if (!connection) {
       log10.warn("a signal ignored because the connection was closed", {
         type: signal.payload.data.type
-      }, {
-        F: __dxlog_file11,
-        L: 277,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 238, S: this });
       return;
     }
     const data = signal.payload.data;
@@ -3464,12 +2459,7 @@ var RtcPeerConnection = class {
     }
     log10("signal processed", {
       type: data.type
-    }, {
-      F: __dxlog_file11,
-      L: 336,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 301, S: this });
   }
   async _processIceCandidate(connection, candidate) {
     try {
@@ -3477,51 +2467,26 @@ var RtcPeerConnection = class {
       if (connection === this._connection) {
         log10("adding ice candidate", {
           candidate
-        }, {
-          F: __dxlog_file11,
-          L: 344,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 310, S: this });
         await connection.addIceCandidate(candidate);
       }
     } catch (err) {
-      log10.catch(err, void 0, {
-        F: __dxlog_file11,
-        L: 348,
-        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) {
-      log10("ready to process ice candidates", void 0, {
-        F: __dxlog_file11,
-        L: 354,
-        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 {
-      log10.warn("session was negotiated after connection became inactive", void 0, {
-        F: __dxlog_file11,
-        L: 357,
-        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) {
     log10.warn("callback invoked after a connection was destroyed, this is probably a bug", {
       callback,
       state: connection.connectionState
-    }, {
-      F: __dxlog_file11,
-      L: 362,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 328, S: this });
     this._safeCloseConnection(connection);
   }
   _safeCloseConnection(connection = this._connection) {
@@ -3529,23 +2494,13 @@ var RtcPeerConnection = class {
     try {
       connection?.close();
     } catch (err) {
-      log10.catch(err, void 0, {
-        F: __dxlog_file11,
-        L: 374,
-        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) => log10.catch(err, void 0, {
-        F: __dxlog_file11,
-        L: 380,
-        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.");
       }
@@ -3565,12 +2520,7 @@ var RtcPeerConnection = class {
         ];
       }
     } catch (error) {
-      log10.catch(error, void 0, {
-        F: __dxlog_file11,
-        L: 396,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      log10.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 365, S: this });
     }
     return config;
   }
@@ -3592,12 +2542,7 @@ var RtcPeerConnection = class {
     } catch (err) {
       log10.warn("signaling error", {
         err
-      }, {
-        F: __dxlog_file11,
-        L: 417,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 385, S: this });
     }
   }
   async _sendDescription(connection, description) {
@@ -3655,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) {
@@ -3701,7 +2646,7 @@ 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 invariant11 } from "@dxos/invariant";
-import { PublicKey as PublicKey10 } from "@dxos/keys";
+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";
@@ -3712,7 +2657,7 @@ var CLOSE_RPC_TIMEOUT = 3e3;
 var RESP_MIN_THRESHOLD = 500;
 var RtcTransportProxy = class extends Resource2 {
   _options;
-  _proxyId = PublicKey10.random();
+  _proxyId = PublicKey9.random();
   closed = new Event8();
   connected = new Event8();
   errors = new ErrorStream5();
@@ -3739,12 +2684,7 @@ var RtcTransportProxy = class extends Resource2 {
     this._serviceStream = stream;
     stream.waitUntilReady().then(() => {
       stream.subscribe(async (event) => {
-        log11("rtc transport proxy event", event, {
-          F: __dxlog_file12,
-          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) {
@@ -3755,12 +2695,7 @@ var RtcTransportProxy = class extends Resource2 {
       }, (err) => {
         log11("rtc bridge stream closed", {
           err
-        }, {
-          F: __dxlog_file12,
-          L: 76,
-          S: this,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 55, S: this });
         if (err) {
           this._raiseIfOpen(err);
         } else {
@@ -3777,12 +2712,7 @@ var RtcTransportProxy = class extends Resource2 {
             timeout: RPC_TIMEOUT
           }).then(() => {
             if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
-              log11("slow response, delaying callback", void 0, {
-                F: __dxlog_file12,
-                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();
@@ -3810,12 +2740,7 @@ var RtcTransportProxy = class extends Resource2 {
       await this._serviceStream?.close();
       this._serviceStream = void 0;
     } catch (err) {
-      log11.catch(err, void 0, {
-        F: __dxlog_file12,
-        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({
@@ -3824,12 +2749,7 @@ var RtcTransportProxy = class extends Resource2 {
         timeout: CLOSE_RPC_TIMEOUT
       });
     } catch (err) {
-      log11.catch(err, void 0, {
-        F: __dxlog_file12,
-        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();
   }
@@ -3912,12 +2832,7 @@ var RtcTransportProxy = class extends Resource2 {
     } else {
       log11.info("error swallowed because transport was closed", {
         message: error.message
-      }, {
-        F: __dxlog_file12,
-        L: 217,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 195, S: this });
     }
   }
   /**
@@ -3943,15 +2858,7 @@ var RtcTransportProxyFactory = class {
     return this;
   }
   createTransport(options) {
-    invariant11(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", {
-      F: __dxlog_file12,
-      L: 247,
-      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
@@ -3986,14 +2893,14 @@ var decodeError = (err) => {
 import { Duplex as Duplex2 } from "@dxos/node-std/stream";
 import { Stream } from "@dxos/codec-protobuf/stream";
 import { invariant as invariant12 } from "@dxos/invariant";
-import { PublicKey as PublicKey11 } from "@dxos/keys";
+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_file13 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
 var RtcTransportService = class {
   _transportFactory;
-  _openTransports = new ComplexMap8(PublicKey11.hash);
+  _openTransports = new ComplexMap8(PublicKey10.hash);
   constructor(webrtcConfig, iceProvider, _transportFactory = createRtcTransportFactory(webrtcConfig, iceProvider)) {
     this._transportFactory = _transportFactory;
   }
@@ -4003,12 +2910,7 @@ var RtcTransportService = class {
   open(request) {
     const existingTransport = this._openTransports.get(request.proxyId);
     if (existingTransport) {
-      log12.error("requesting a new transport bridge for an existing proxy", void 0, {
-        F: __dxlog_file13,
-        L: 54,
-        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);
     }
@@ -4069,69 +2971,32 @@ var RtcTransportService = class {
         close(err);
       });
       ready();
-      log12("stream ready", void 0, {
-        F: __dxlog_file13,
-        L: 116,
-        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);
-    invariant12(transport, void 0, {
-      F: __dxlog_file13,
-      L: 124,
-      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);
-    invariant12(transport, void 0, {
-      F: __dxlog_file13,
-      L: 131,
-      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);
-    invariant12(transport, void 0, {
-      F: __dxlog_file13,
-      L: 138,
-      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);
-    invariant12(transport, void 0, {
-      F: __dxlog_file13,
-      L: 145,
-      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) => {
@@ -4157,31 +3022,16 @@ var RtcTransportService = class {
     } catch (error) {
       log12.warn("transport close error", {
         message: error?.message
-      }, {
-        F: __dxlog_file13,
-        L: 175,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 134, S: this });
     }
     try {
       transport.connectorStream.end();
     } catch (error) {
       log12.warn("connectorStream close error", {
         message: error?.message
-      }, {
-        F: __dxlog_file13,
-        L: 180,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 141, S: this });
     }
-    log12("closed", void 0, {
-      F: __dxlog_file13,
-      L: 182,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+    log12("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 145, S: this });
   }
 };
 var createStateUpdater = (next) => {
@@ -4242,4 +3092,4 @@ export {
   RtcTransportService,
   createTeleportProtocolFactory
 };
-//# sourceMappingURL=chunk-AQSYW43M.mjs.map
+//# sourceMappingURL=chunk-UFYPMUBI.mjs.map