@dxos/network-manager 0.1.58-next.3349da8 → 0.1.58-next.ffb4cc4

package/dist/lib/node/testing/index.cjs

@@ -515,35 +515,146 @@ module.exports = __toCommonJS(testing_exports);
 var import_keys14 = require("@dxos/keys");
 var import_log17 = require("@dxos/log");
 var import_messaging2 = require("@dxos/messaging");
-var import_protocols6 = require("@dxos/protocols");
+var import_protocols9 = require("@dxos/protocols");
 var import_services2 = require("@dxos/protocols/proto/dxos/client/services");
 var import_rpc = require("@dxos/rpc");
 var import_util11 = require("@dxos/util");
 
+// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
+var import_async = require("@dxos/async");
+var import_keys = require("@dxos/keys");
+var import_log = require("@dxos/log");
+var import_teleport2 = require("@dxos/teleport");
+var import_util = require("@dxos/util");
+
+// packages/core/mesh/network-manager/src/wire-protocol.ts
+var import_teleport = require("@dxos/teleport");
+var createTeleportProtocolFactory = (onConnection) => {
+  return (params) => {
+    const teleport = new import_teleport.Teleport(params);
+    return {
+      stream: teleport.stream,
+      open: async () => {
+        await teleport.open();
+        await onConnection(teleport);
+      },
+      close: async () => {
+        await teleport.close();
+      },
+      abort: async () => {
+        await teleport.abort();
+      }
+    };
+  };
+};
+
+// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts";
+var TestWireProtocol = class {
+  constructor(peerId, _extensionFactory = () => []) {
+    this.peerId = peerId;
+    this._extensionFactory = _extensionFactory;
+    this.connections = new import_util.ComplexMap(import_keys.PublicKey.hash);
+    this.streamConnections = new import_util.ComplexMap(import_keys.PublicKey.hash);
+    this.connected = new import_async.Event();
+    this.disconnected = new import_async.Event();
+    this.otherConnections = new import_util.ComplexMap(({ remotePeerId, extension }) => remotePeerId.toHex() + extension);
+    this.factory = createTeleportProtocolFactory(async (teleport) => {
+      (0, import_log.log)("create", {
+        remotePeerId: teleport.remotePeerId
+      }, {
+        F: __dxlog_file,
+        L: 38,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const extension = new import_teleport2.TestExtension({
+        onClose: async () => {
+          this.connections.delete(teleport.remotePeerId);
+          this.disconnected.emit(teleport.remotePeerId);
+        }
+      });
+      this.connections.set(teleport.remotePeerId, extension);
+      teleport.addExtension("test", extension);
+      this.connected.emit(teleport.remotePeerId);
+      const streamExtension = new import_teleport2.TestExtensionWithStreams({
+        onClose: async () => {
+          this.streamConnections.delete(teleport.remotePeerId);
+        }
+      });
+      this.streamConnections.set(teleport.remotePeerId, streamExtension);
+      teleport.addExtension("test-stream", streamExtension);
+      for (const { name, extension: extension2 } of this._extensionFactory()) {
+        this.otherConnections.set({
+          remotePeerId: teleport.remotePeerId,
+          extension: name
+        }, extension2);
+        teleport.addExtension(name, extension2);
+      }
+    });
+  }
+  async waitForConnection(peerId) {
+    if (this.connections.has(peerId)) {
+      return this.connections.get(peerId);
+    }
+    (0, import_log.log)("waitForConnection", {
+      peerId
+    }, {
+      F: __dxlog_file,
+      L: 67,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await (0, import_async.asyncTimeout)(
+      this.connected.waitFor((connectedId) => connectedId.equals(peerId)),
+      // TODO(nf): Make this configurable.
+      1e4
+    );
+    return this.connections.get(peerId);
+  }
+  async testConnection(peerId, message) {
+    const connection = await this.waitForConnection(peerId);
+    await connection.test(message);
+  }
+  async openStream(peerId, streamTag, streamLoadInterval, streamLoadChunkSize) {
+    if (!this.streamConnections.has(peerId)) {
+      throw new Error("Connection does not exist.");
+    }
+    const connection = this.streamConnections.get(peerId);
+    return connection.addNewStream(streamLoadInterval, streamLoadChunkSize, streamTag);
+  }
+  async closeStream(peerId, streamTag) {
+    if (!this.streamConnections.has(peerId)) {
+      throw new Error("Connection does not exist.");
+    }
+    const connection = this.streamConnections.get(peerId);
+    return connection.closeStream(streamTag);
+  }
+};
+
 // packages/core/mesh/network-manager/src/network-manager.ts
-var import_async7 = require("@dxos/async");
+var import_async8 = require("@dxos/async");
 var import_invariant6 = require("@dxos/invariant");
-var import_keys8 = require("@dxos/keys");
-var import_log7 = require("@dxos/log");
+var import_keys9 = require("@dxos/keys");
+var import_log8 = require("@dxos/log");
 var import_messaging = require("@dxos/messaging");
-var import_protocols4 = require("@dxos/protocols");
+var import_protocols6 = require("@dxos/protocols");
 var import_services = require("@dxos/protocols/proto/dxos/client/services");
-var import_util6 = require("@dxos/util");
+var import_util7 = require("@dxos/util");
 
 // packages/core/mesh/network-manager/src/connection-log.ts
-var import_async6 = require("@dxos/async");
+var import_async7 = require("@dxos/async");
 var import_debug3 = require("@dxos/debug");
-var import_keys7 = require("@dxos/keys");
-var import_util5 = require("@dxos/util");
+var import_keys8 = require("@dxos/keys");
+var import_util6 = require("@dxos/util");
 
 // packages/core/mesh/network-manager/src/swarm/connection.ts
-var import_async = require("@dxos/async");
+var import_async2 = require("@dxos/async");
 var import_context = require("@dxos/context");
 var import_debug = require("@dxos/debug");
-var import_errors = require("@dxos/errors");
 var import_invariant = require("@dxos/invariant");
-var import_keys = require("@dxos/keys");
-var import_log = require("@dxos/log");
+var import_keys2 = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
 var import_protocols = require("@dxos/protocols");
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -555,7 +666,7 @@ function _ts_decorate(decorators, target, key, desc) {
         r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
 var STARTING_SIGNALLING_DELAY = 10;
 var MAX_SIGNALLING_DELAY = 300;
 var ConnectionState;
@@ -615,21 +726,21 @@ var Connection = class {
     this._state = ConnectionState.CREATED;
     this._incomingSignalBuffer = [];
     this._outgoingSignalBuffer = [];
-    this.stateChanged = new import_async.Event();
+    this.stateChanged = new import_async2.Event();
     this.errors = new import_debug.ErrorStream();
-    this._instanceId = import_keys.PublicKey.random().toHex();
-    this._signalSendTask = new import_async.DeferredTask(this._ctx, async () => {
+    this._instanceId = import_keys2.PublicKey.random().toHex();
+    this._signalSendTask = new import_async2.DeferredTask(this._ctx, async () => {
       await this._flushSignalBuffer();
     });
     this._signallingDelay = STARTING_SIGNALLING_DELAY;
-    import_log.log.trace("dxos.mesh.connection.construct", {
+    import_log2.log.trace("dxos.mesh.connection.construct", {
       sessionId: this.sessionId,
       topic: this.topic,
       localPeerId: this.ownId,
       remotePeerId: this.remoteId,
       initiator: this.initiator
     }, {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 123,
       S: this,
       C: (f, a) => f(...a)
@@ -649,7 +760,7 @@ var Connection = class {
   */
   async openConnection() {
     (0, import_invariant.invariant)(this._state === ConnectionState.INITIAL, "Invalid state.", {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 148,
       S: this,
       A: [
@@ -657,22 +768,22 @@ var Connection = class {
         "'Invalid state.'"
       ]
     });
-    import_log.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.begin({
+    import_log2.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.begin({
       id: this._instanceId
     }), {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 149,
       S: this,
       C: (f, a) => f(...a)
     });
-    import_log.log.trace("dxos.mesh.connection.open", {
+    import_log2.log.trace("dxos.mesh.connection.open", {
       sessionId: this.sessionId,
       topic: this.topic,
       localPeerId: this.ownId,
       remotePeerId: this.remoteId,
       initiator: this.initiator
     }, {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 150,
       S: this,
       C: (f, a) => f(...a)
@@ -682,16 +793,16 @@ var Connection = class {
       this.errors.raise(err);
     });
     this._protocol.stream.on("close", () => {
-      (0, import_log.log)("protocol stream closed", void 0, {
-        F: __dxlog_file,
+      (0, import_log2.log)("protocol stream closed", void 0, {
+        F: __dxlog_file2,
         L: 167,
         S: this,
         C: (f, a) => f(...a)
       });
-      this.close(new import_errors.ProtocolError("protocol stream closed")).catch((err) => this.errors.raise(err));
+      this.close(new import_protocols.ProtocolError("protocol stream closed")).catch((err) => this.errors.raise(err));
     });
     (0, import_invariant.invariant)(!this._transport, void 0, {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 171,
       S: this,
       A: [
@@ -710,8 +821,8 @@ var Connection = class {
     });
     this._transport.closed.once(() => {
       this._transport = void 0;
-      (0, import_log.log)("abort triggered by transport close", void 0, {
-        F: __dxlog_file,
+      (0, import_log2.log)("abort triggered by transport close", void 0, {
+        F: __dxlog_file2,
         L: 185,
         S: this,
         C: (f, a) => f(...a)
@@ -719,10 +830,10 @@ var Connection = class {
       this.abort().catch((err) => this.errors.raise(err));
     });
     this._transport.errors.handle((err) => {
-      (0, import_log.log)("transport error:", {
+      (0, import_log2.log)("transport error:", {
         err
       }, {
-        F: __dxlog_file,
+        F: __dxlog_file2,
         L: 190,
         S: this,
         C: (f, a) => f(...a)
@@ -730,27 +841,27 @@ var Connection = class {
       if (!this.closeReason) {
         this.closeReason = err?.message;
       }
-      if (err instanceof import_errors.ConnectionResetError) {
-        (0, import_log.log)("aborting due to transport ConnectionResetError", void 0, {
-          F: __dxlog_file,
+      if (err instanceof import_protocols.ConnectionResetError) {
+        import_log2.log.warn("aborting due to transport ConnectionResetError", void 0, {
+          F: __dxlog_file2,
           L: 197,
           S: this,
           C: (f, a) => f(...a)
         });
         this.abort().catch((err2) => this.errors.raise(err2));
-      } else if (err instanceof import_errors.ConnectivityError) {
-        (0, import_log.log)("aborting due to transport ConnectivityError", void 0, {
-          F: __dxlog_file,
+      } else if (err instanceof import_protocols.ConnectivityError) {
+        import_log2.log.warn("aborting due to transport ConnectivityError", void 0, {
+          F: __dxlog_file2,
           L: 200,
           S: this,
           C: (f, a) => f(...a)
         });
         this.abort().catch((err2) => this.errors.raise(err2));
-      } else if (err instanceof import_errors.UnknownProtocolError) {
-        (0, import_log.log)("unsure what to do for UnknownProtocolError", {
+      } else if (err instanceof import_protocols.UnknownProtocolError) {
+        import_log2.log.warn("unsure what to do with UnknownProtocolError, will keep on truckin", {
           err
         }, {
-          F: __dxlog_file,
+          F: __dxlog_file2,
           L: 203,
           S: this,
           C: (f, a) => f(...a)
@@ -764,28 +875,28 @@ var Connection = class {
       void this._transport.signal(signal);
     }
     this._incomingSignalBuffer = [];
-    import_log.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.end({
+    import_log2.log.trace("dxos.mesh.connection.open-connection", import_protocols.trace.end({
       id: this._instanceId
     }), {
-      F: __dxlog_file,
+      F: __dxlog_file2,
       L: 218,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   async abort(err) {
-    (0, import_log.log)("aborting...", {
+    (0, import_log2.log)("aborting...", {
       err
     }, {
-      F: __dxlog_file,
-      L: 224,
+      F: __dxlog_file2,
+      L: 225,
       S: this,
       C: (f, a) => f(...a)
     });
     if (this._state === ConnectionState.CLOSED || this._state === ConnectionState.ABORTED) {
-      (0, import_log.log)(`abort ignored: already ${this._state}`, this.closeReason, {
-        F: __dxlog_file,
-        L: 226,
+      (0, import_log2.log)(`abort ignored: already ${this._state}`, this.closeReason, {
+        F: __dxlog_file2,
+        L: 227,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -797,19 +908,19 @@ var Connection = class {
     }
     await this._ctx.dispose();
     try {
-      (0, import_log.log)("aborting protocol... ", {
+      (0, import_log2.log)("aborting protocol... ", {
         proto: this._protocol
       }, {
-        F: __dxlog_file,
-        L: 239,
+        F: __dxlog_file2,
+        L: 240,
         S: this,
         C: (f, a) => f(...a)
       });
       await this._protocol.abort();
     } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 242,
+      import_log2.log.catch(err2, void 0, {
+        F: __dxlog_file2,
+        L: 243,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -817,9 +928,9 @@ var Connection = class {
     try {
       await this._transport?.destroy();
     } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 249,
+      import_log2.log.catch(err2, void 0, {
+        F: __dxlog_file2,
+        L: 250,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -827,9 +938,9 @@ var Connection = class {
     try {
       this._callbacks?.onClosed?.(err);
     } catch (err2) {
-      import_log.log.catch(err2, void 0, {
-        F: __dxlog_file,
-        L: 255,
+      import_log2.log.catch(err2, void 0, {
+        F: __dxlog_file2,
+        L: 256,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -846,11 +957,11 @@ var Connection = class {
     const lastState = this._state;
     this._changeState(ConnectionState.CLOSING);
     await this._ctx.dispose();
-    (0, import_log.log)("closing...", {
+    (0, import_log2.log)("closing...", {
       peerId: this.ownId
     }, {
-      F: __dxlog_file,
-      L: 277,
+      F: __dxlog_file2,
+      L: 278,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -858,9 +969,9 @@ var Connection = class {
       try {
         await this._protocol.close();
       } catch (err2) {
-        import_log.log.catch(err2, void 0, {
-          F: __dxlog_file,
-          L: 284,
+        import_log2.log.catch(err2, void 0, {
+          F: __dxlog_file2,
+          L: 285,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -868,19 +979,19 @@ var Connection = class {
       try {
         await this._transport?.destroy();
       } catch (err2) {
-        import_log.log.catch(err2, void 0, {
-          F: __dxlog_file,
-          L: 291,
+        import_log2.log.catch(err2, void 0, {
+          F: __dxlog_file2,
+          L: 292,
           S: this,
           C: (f, a) => f(...a)
         });
       }
     }
-    (0, import_log.log)("closed", {
+    (0, import_log2.log)("closed", {
       peerId: this.ownId
     }, {
-      F: __dxlog_file,
-      L: 295,
+      F: __dxlog_file2,
+      L: 296,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -897,7 +1008,7 @@ var Connection = class {
     }
     try {
       if (process.env.NODE_ENV !== "test") {
-        await (0, import_context.cancelWithContext)(this._ctx, (0, import_async.sleep)(this._signallingDelay));
+        await (0, import_context.cancelWithContext)(this._ctx, (0, import_async2.sleep)(this._signallingDelay));
         this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
       }
       const signals = [
@@ -916,14 +1027,14 @@ var Connection = class {
         }
       });
     } catch (err) {
-      if (err instanceof import_errors.CancelledError) {
+      if (err instanceof import_protocols.CancelledError) {
         return;
       }
-      import_log.log.warn("signal failed", {
+      import_log2.log.warn("signal failed", {
         err
       }, {
-        F: __dxlog_file,
-        L: 332,
+        F: __dxlog_file2,
+        L: 333,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -935,8 +1046,8 @@ var Connection = class {
   */
   async signal(msg) {
     (0, import_invariant.invariant)(msg.sessionId, void 0, {
-      F: __dxlog_file,
-      L: 341,
+      F: __dxlog_file2,
+      L: 342,
       S: this,
       A: [
         "msg.sessionId",
@@ -944,17 +1055,17 @@ var Connection = class {
       ]
     });
     if (!msg.sessionId.equals(this.sessionId)) {
-      (0, import_log.log)("dropping signal for incorrect session id", void 0, {
-        F: __dxlog_file,
-        L: 343,
+      (0, import_log2.log)("dropping signal for incorrect session id", void 0, {
+        F: __dxlog_file2,
+        L: 344,
         S: this,
         C: (f, a) => f(...a)
       });
       return;
     }
     (0, import_invariant.invariant)(msg.data.signal || msg.data.signalBatch, void 0, {
-      F: __dxlog_file,
-      L: 346,
+      F: __dxlog_file2,
+      L: 347,
       S: this,
       A: [
         "msg.data.signal || msg.data.signalBatch",
@@ -962,8 +1073,8 @@ var Connection = class {
       ]
     });
     (0, import_invariant.invariant)(msg.author?.equals(this.remoteId), void 0, {
-      F: __dxlog_file,
-      L: 347,
+      F: __dxlog_file2,
+      L: 348,
       S: this,
       A: [
         "msg.author?.equals(this.remoteId)",
@@ -971,8 +1082,8 @@ var Connection = class {
       ]
     });
     (0, import_invariant.invariant)(msg.recipient?.equals(this.ownId), void 0, {
-      F: __dxlog_file,
-      L: 348,
+      F: __dxlog_file2,
+      L: 349,
       S: this,
       A: [
         "msg.recipient?.equals(this.ownId)",
@@ -990,34 +1101,34 @@ var Connection = class {
         ConnectionState.CREATED,
         ConnectionState.INITIAL
       ].includes(this.state)) {
-        (0, import_log.log)("buffered signal", {
+        (0, import_log2.log)("buffered signal", {
           peerId: this.ownId,
           remoteId: this.remoteId,
           msg: msg.data
         }, {
-          F: __dxlog_file,
-          L: 357,
+          F: __dxlog_file2,
+          L: 358,
           S: this,
           C: (f, a) => f(...a)
         });
         this._incomingSignalBuffer.push(signal);
       } else {
         (0, import_invariant.invariant)(this._transport, "Connection not ready to accept signals.", {
-          F: __dxlog_file,
-          L: 360,
+          F: __dxlog_file2,
+          L: 361,
           S: this,
           A: [
             "this._transport",
             "'Connection not ready to accept signals.'"
           ]
         });
-        (0, import_log.log)("received signal", {
+        (0, import_log2.log)("received signal", {
           peerId: this.ownId,
           remoteId: this.remoteId,
           msg: msg.data
         }, {
-          F: __dxlog_file,
-          L: 361,
+          F: __dxlog_file2,
+          L: 362,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -1029,19 +1140,19 @@ var Connection = class {
     this._changeState(ConnectionState.INITIAL);
   }
   _changeState(state) {
-    (0, import_log.log)("stateChanged", {
+    (0, import_log2.log)("stateChanged", {
       from: this._state,
       to: state,
       peerId: this.ownId
     }, {
-      F: __dxlog_file,
-      L: 372,
+      F: __dxlog_file2,
+      L: 373,
       S: this,
       C: (f, a) => f(...a)
     });
     (0, import_invariant.invariant)(state !== this._state, "Already in this state.", {
-      F: __dxlog_file,
-      L: 373,
+      F: __dxlog_file2,
+      L: 374,
       S: this,
       A: [
         "state !== this._state",
@@ -1053,301 +1164,83 @@ var Connection = class {
   }
 };
 _ts_decorate([
-  import_async.synchronized
+  import_async2.synchronized
 ], Connection.prototype, "abort", null);
 _ts_decorate([
-  import_async.synchronized
+  import_async2.synchronized
 ], Connection.prototype, "close", null);
 
 // packages/core/mesh/network-manager/src/swarm/swarm.ts
-var import_async3 = require("@dxos/async");
+var import_async4 = require("@dxos/async");
 var import_context4 = require("@dxos/context");
 var import_debug2 = require("@dxos/debug");
 var import_invariant4 = require("@dxos/invariant");
-var import_keys4 = require("@dxos/keys");
-var import_log4 = require("@dxos/log");
-var import_protocols3 = require("@dxos/protocols");
-var import_util2 = require("@dxos/util");
+var import_keys5 = require("@dxos/keys");
+var import_log5 = require("@dxos/log");
+var import_protocols4 = require("@dxos/protocols");
+var import_util3 = require("@dxos/util");
 
-// packages/core/mesh/network-manager/src/signal/swarm-messenger.ts
+// packages/core/mesh/network-manager/src/swarm/peer.ts
+var import_async3 = require("@dxos/async");
 var import_context2 = require("@dxos/context");
 var import_invariant2 = require("@dxos/invariant");
-var import_keys2 = require("@dxos/keys");
-var import_log2 = require("@dxos/log");
+var import_keys3 = require("@dxos/keys");
+var import_log3 = require("@dxos/log");
 var import_protocols2 = require("@dxos/protocols");
-var import_util = require("@dxos/util");
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
-var SwarmMessage = import_protocols2.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
-var SwarmMessenger = class {
-  constructor({ sendMessage, onSignal, onOffer, topic }) {
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
+var ConnectionDisplacedError = class extends import_protocols2.SystemError {
+  constructor() {
+    super("Connection displaced by remote initiator.");
+  }
+};
+var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
+var Peer = class {
+  // TODO(burdon): Convert to map?
+  constructor(id, topic, localPeerId, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
+    this.id = id;
+    this.topic = topic;
+    this.localPeerId = localPeerId;
+    this._signalMessaging = _signalMessaging;
+    this._protocolProvider = _protocolProvider;
+    this._transportFactory = _transportFactory;
+    this._connectionLimiter = _connectionLimiter;
+    this._callbacks = _callbacks;
+    this._availableAfter = 0;
+    this.availableToConnect = true;
     this._ctx = new import_context2.Context();
-    this._offerRecords = new import_util.ComplexMap((key) => key.toHex());
-    this._sendMessage = sendMessage;
-    this._onSignal = onSignal;
-    this._onOffer = onOffer;
-    this._topic = topic;
-  }
-  async receiveMessage({ author, recipient, payload }) {
-    if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
-      return;
-    }
-    const message = SwarmMessage.decode(payload.value);
-    if (!this._topic.equals(message.topic)) {
-      return;
-    }
-    (0, import_log2.log)("received", {
-      from: author,
-      to: recipient,
-      msg: message
-    }, {
-      F: __dxlog_file2,
-      L: 69,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (message.data?.offer) {
-      await this._handleOffer({
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.answer) {
-      await this._resolveAnswers(message);
-    } else if (message.data?.signal) {
-      await this._handleSignal({
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.signalBatch) {
-      await this._handleSignal({
-        author,
-        recipient,
-        message
-      });
-    } else {
-      import_log2.log.warn("unknown message", {
-        message
-      }, {
-        F: __dxlog_file2,
-        L: 80,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  async signal(message) {
-    (0, import_invariant2.invariant)(message.data?.signal || message.data?.signalBatch, "Invalid message", {
-      F: __dxlog_file2,
-      L: 85,
-      S: this,
-      A: [
-        "message.data?.signal || message.data?.signalBatch",
-        "'Invalid message'"
-      ]
-    });
-    await this._sendReliableMessage({
-      author: message.author,
-      recipient: message.recipient,
-      message
-    });
-  }
-  async offer(message) {
-    const networkMessage = {
-      ...message,
-      messageId: import_keys2.PublicKey.random()
-    };
-    return new Promise((resolve, reject) => {
-      this._offerRecords.set(networkMessage.messageId, {
-        resolve
-      });
-      this._sendReliableMessage({
-        author: message.author,
-        recipient: message.recipient,
-        message: networkMessage
-      }).catch((err) => reject(err));
-    });
-  }
-  async _sendReliableMessage({ author, recipient, message }) {
-    const networkMessage = {
-      ...message,
-      // Setting unique message_id if it not specified yet.
-      messageId: message.messageId ?? import_keys2.PublicKey.random()
-    };
-    (0, import_log2.log)("sending", {
-      from: author,
-      to: recipient,
-      msg: networkMessage
-    }, {
-      F: __dxlog_file2,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._sendMessage({
-      author,
-      recipient,
-      payload: {
-        type_url: "dxos.mesh.swarm.SwarmMessage",
-        value: SwarmMessage.encode(networkMessage)
-      }
-    });
-  }
-  async _resolveAnswers(message) {
-    (0, import_invariant2.invariant)(message.data?.answer?.offerMessageId, "No offerMessageId", {
-      F: __dxlog_file2,
-      L: 135,
-      S: this,
-      A: [
-        "message.data?.answer?.offerMessageId",
-        "'No offerMessageId'"
-      ]
-    });
-    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
-    if (offerRecord) {
-      this._offerRecords.delete(message.data.answer.offerMessageId);
-      (0, import_invariant2.invariant)(message.data?.answer, "No answer", {
-        F: __dxlog_file2,
-        L: 139,
-        S: this,
-        A: [
-          "message.data?.answer",
-          "'No answer'"
-        ]
-      });
-      (0, import_log2.log)("resolving", {
-        answer: message.data.answer
-      }, {
-        F: __dxlog_file2,
-        L: 140,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      offerRecord.resolve(message.data.answer);
-    }
-  }
-  async _handleOffer({ author, recipient, message }) {
-    (0, import_invariant2.invariant)(message.data.offer, "No offer", {
-      F: __dxlog_file2,
-      L: 154,
-      S: this,
-      A: [
-        "message.data.offer",
-        "'No offer'"
-      ]
-    });
-    const offerMessage = {
-      author,
-      recipient,
-      ...message,
-      data: {
-        offer: message.data.offer
-      }
-    };
-    const answer = await this._onOffer(offerMessage);
-    answer.offerMessageId = message.messageId;
-    try {
-      await this._sendReliableMessage({
-        author: recipient,
-        recipient: author,
-        message: {
-          topic: message.topic,
-          sessionId: message.sessionId,
-          data: {
-            answer
-          }
-        }
-      });
-    } catch (err) {
-      import_log2.log.warn("error sending answer", {
-        err
-      }, {
-        F: __dxlog_file2,
-        L: 174,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  async _handleSignal({ author, recipient, message }) {
-    (0, import_invariant2.invariant)(message.messageId, void 0, {
-      F: __dxlog_file2,
-      L: 187,
-      S: this,
-      A: [
-        "message.messageId",
-        ""
-      ]
-    });
-    (0, import_invariant2.invariant)(message.data.signal || message.data.signalBatch, "Invalid message", {
-      F: __dxlog_file2,
-      L: 188,
-      S: this,
-      A: [
-        "message.data.signal || message.data.signalBatch",
-        "'Invalid message'"
-      ]
-    });
-    const signalMessage = {
-      author,
-      recipient,
-      ...message,
-      data: {
-        signal: message.data.signal,
-        signalBatch: message.data.signalBatch
-      }
-    };
-    await this._onSignal(signalMessage);
-  }
-};
-
-// packages/core/mesh/network-manager/src/swarm/peer.ts
-var import_async2 = require("@dxos/async");
-var import_context3 = require("@dxos/context");
-var import_errors2 = require("@dxos/errors");
-var import_invariant3 = require("@dxos/invariant");
-var import_keys3 = require("@dxos/keys");
-var import_log3 = require("@dxos/log");
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
-var ConnectionDisplacedError = class extends import_errors2.SystemError {
-  constructor() {
-    super("Connection displaced by remote initiator.");
-  }
-};
-var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
-var Peer = class {
-  // TODO(burdon): Convert to map?
-  constructor(id, topic, localPeerId, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
-    this.id = id;
-    this.topic = topic;
-    this.localPeerId = localPeerId;
-    this._signalMessaging = _signalMessaging;
-    this._protocolProvider = _protocolProvider;
-    this._transportFactory = _transportFactory;
-    this._connectionLimiter = _connectionLimiter;
-    this._callbacks = _callbacks;
-    this._availableAfter = 0;
-    this.availableToConnect = true;
-    this._ctx = new import_context3.Context();
-    this.advertizing = false;
-    this.initiating = false;
-    this.connectionDisplaced = new import_async2.Event();
+    this.advertizing = false;
+    this.initiating = false;
+    this.connectionDisplaced = new import_async3.Event();
   }
   /**
   * Respond to remote offer.
   */
   async onOffer(message) {
     const remoteId = message.author;
+    if (this.connection && ![
+      ConnectionState.CREATED,
+      ConnectionState.INITIAL
+    ].includes(this.connection.state)) {
+      import_log3.log.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
+        F: __dxlog_file3,
+        L: 112,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return {
+        accept: false
+      };
+    }
     if (this.connection || this.initiating) {
       if (remoteId.toHex() < this.localPeerId.toHex()) {
         (0, import_log3.log)("close local connection", {
@@ -1357,7 +1250,7 @@ var Peer = class {
           sessionId: this.connection?.sessionId
         }, {
           F: __dxlog_file3,
-          L: 117,
+          L: 121,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -1372,9 +1265,9 @@ var Peer = class {
     }
     if (await this._callbacks.onOffer(remoteId)) {
       if (!this.connection) {
-        (0, import_invariant3.invariant)(message.sessionId, void 0, {
+        (0, import_invariant2.invariant)(message.sessionId, void 0, {
           F: __dxlog_file3,
-          L: 137,
+          L: 141,
           S: this,
           A: [
             "message.sessionId",
@@ -1387,7 +1280,7 @@ var Peer = class {
           connection.initiate();
           await connection.openConnection();
         } catch (err) {
-          if (!(err instanceof import_errors2.CancelledError)) {
+          if (!(err instanceof import_protocols2.CancelledError)) {
             import_log3.log.warn("connection error", {
               topic: this.topic,
               peerId: this.localPeerId,
@@ -1395,7 +1288,7 @@ var Peer = class {
               err
             }, {
               F: __dxlog_file3,
-              L: 147,
+              L: 151,
               S: this,
               C: (f, a) => f(...a)
             });
@@ -1415,18 +1308,18 @@ var Peer = class {
   * Initiate a connection to the remote peer.
   */
   async initiateConnection() {
-    (0, import_invariant3.invariant)(!this.initiating, "Initiation in progress.", {
+    (0, import_invariant2.invariant)(!this.initiating, "Initiation in progress.", {
       F: __dxlog_file3,
-      L: 164,
+      L: 168,
       S: this,
       A: [
         "!this.initiating",
         "'Initiation in progress.'"
       ]
     });
-    (0, import_invariant3.invariant)(!this.connection, "Already connected.", {
+    (0, import_invariant2.invariant)(!this.connection, "Already connected.", {
       F: __dxlog_file3,
-      L: 165,
+      L: 169,
       S: this,
       A: [
         "!this.connection",
@@ -1441,7 +1334,7 @@ var Peer = class {
       sessionId
     }, {
       F: __dxlog_file3,
-      L: 167,
+      L: 171,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1466,14 +1359,14 @@ var Peer = class {
         remoteId: this.id
       }, {
         F: __dxlog_file3,
-        L: 183,
+        L: 187,
         S: this,
         C: (f, a) => f(...a)
       });
       if (connection.state !== ConnectionState.INITIAL) {
         (0, import_log3.log)("ignoring response", void 0, {
           F: __dxlog_file3,
-          L: 185,
+          L: 189,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -1493,11 +1386,17 @@ var Peer = class {
         remoteId: this.id
       }, {
         F: __dxlog_file3,
-        L: 196,
+        L: 200,
         S: this,
         C: (f, a) => f(...a)
       });
-      if (err instanceof import_errors2.TimeoutError) {
+      if (err instanceof import_protocols2.TimeoutError) {
+        import_log3.log.warn("aborting connection due to signalling failure", void 0, {
+          F: __dxlog_file3,
+          L: 202,
+          S: this,
+          C: (f, a) => f(...a)
+        });
         await connection.abort(err);
       }
       await this.closeConnection(err);
@@ -1519,13 +1418,13 @@ var Peer = class {
       sessionId
     }, {
       F: __dxlog_file3,
-      L: 213,
+      L: 218,
       S: this,
       C: (f, a) => f(...a)
     });
-    (0, import_invariant3.invariant)(!this.connection, "Already connected.", {
+    (0, import_invariant2.invariant)(!this.connection, "Already connected.", {
       F: __dxlog_file3,
-      L: 220,
+      L: 225,
       S: this,
       A: [
         "!this.connection",
@@ -1561,7 +1460,7 @@ var Peer = class {
             initiator
           }, {
             F: __dxlog_file3,
-            L: 239,
+            L: 244,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -1574,14 +1473,14 @@ var Peer = class {
             initiator
           }, {
             F: __dxlog_file3,
-            L: 248,
+            L: 253,
             S: this,
             C: (f, a) => f(...a)
           });
           this._connectionLimiter.doneConnecting(sessionId);
-          (0, import_invariant3.invariant)(this.connection === connection, "Connection mismatch (race condition).", {
+          (0, import_invariant2.invariant)(this.connection === connection, "Connection mismatch (race condition).", {
             F: __dxlog_file3,
-            L: 253,
+            L: 258,
             S: this,
             A: [
               "this.connection === connection",
@@ -1596,7 +1495,7 @@ var Peer = class {
             initiator
           }, {
             F: __dxlog_file3,
-            L: 255,
+            L: 260,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -1610,7 +1509,7 @@ var Peer = class {
               this._availableAfter = increaseInterval(this._availableAfter);
             }
             this._callbacks.onDisconnected();
-            (0, import_async2.scheduleTask)(this._connectionCtx, () => {
+            (0, import_async3.scheduleTask)(this._connectionCtx, () => {
               this.availableToConnect = true;
               this._callbacks.onPeerAvailable();
             }, this._availableAfter);
@@ -1631,95 +1530,327 @@ var Peer = class {
         err
       }, {
         F: __dxlog_file3,
-        L: 295,
+        L: 300,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      import_log3.log.trace("dxos.mesh.connection.error", {
+        topic: this.topic,
+        localPeerId: this.localPeerId,
+        remotePeerId: this.id,
+        sessionId,
+        initiator,
+        err
+      }, {
+        F: __dxlog_file3,
+        L: 301,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      void this.closeConnection(err);
+    });
+    this.connection = connection;
+    return connection;
+  }
+  async closeConnection(err) {
+    if (!this.connection) {
+      return;
+    }
+    const connection = this.connection;
+    (0, import_log3.log)("closing...", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      F: __dxlog_file3,
+      L: 326,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await connection.close(err);
+    (0, import_log3.log)("closed", {
+      peerId: this.id,
+      sessionId: connection.sessionId
+    }, {
+      F: __dxlog_file3,
+      L: 332,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async onSignal(message) {
+    if (!this.connection) {
+      (0, import_log3.log)("dropping signal message for non-existent connection", {
+        message
+      }, {
+        F: __dxlog_file3,
+        L: 337,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    await this.connection.signal(message);
+  }
+  async destroy() {
+    await this._ctx.dispose();
+    (0, import_log3.log)("Destroying peer", {
+      peerId: this.id,
+      topic: this.topic
+    }, {
+      F: __dxlog_file3,
+      L: 347,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this?.connection?.close();
+  }
+};
+_ts_decorate2([
+  import_async3.synchronized
+], Peer.prototype, "destroy", null);
+var increaseInterval = (interval) => {
+  if (interval === 0) {
+    return 50;
+  } else if (interval < 500) {
+    return 500;
+  } else if (interval < 1e3) {
+    return 1e3;
+  } else if (interval < 5e3) {
+    return 5e3;
+  }
+  return 1e4;
+};
+
+// packages/core/mesh/network-manager/src/signal/swarm-messenger.ts
+var import_context3 = require("@dxos/context");
+var import_invariant3 = require("@dxos/invariant");
+var import_keys4 = require("@dxos/keys");
+var import_log4 = require("@dxos/log");
+var import_protocols3 = require("@dxos/protocols");
+var import_util2 = require("@dxos/util");
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
+var SwarmMessage = import_protocols3.schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
+var SwarmMessenger = class {
+  constructor({ sendMessage, onSignal, onOffer, topic }) {
+    this._ctx = new import_context3.Context();
+    this._offerRecords = new import_util2.ComplexMap((key) => key.toHex());
+    this._sendMessage = sendMessage;
+    this._onSignal = onSignal;
+    this._onOffer = onOffer;
+    this._topic = topic;
+  }
+  async receiveMessage({ author, recipient, payload }) {
+    if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
+      return;
+    }
+    const message = SwarmMessage.decode(payload.value);
+    if (!this._topic.equals(message.topic)) {
+      return;
+    }
+    (0, import_log4.log)("received", {
+      from: author,
+      to: recipient,
+      msg: message
+    }, {
+      F: __dxlog_file4,
+      L: 69,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (message.data?.offer) {
+      await this._handleOffer({
+        author,
+        recipient,
+        message
+      });
+    } else if (message.data?.answer) {
+      await this._resolveAnswers(message);
+    } else if (message.data?.signal) {
+      await this._handleSignal({
+        author,
+        recipient,
+        message
+      });
+    } else if (message.data?.signalBatch) {
+      await this._handleSignal({
+        author,
+        recipient,
+        message
+      });
+    } else {
+      import_log4.log.warn("unknown message", {
+        message
+      }, {
+        F: __dxlog_file4,
+        L: 80,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  async signal(message) {
+    (0, import_invariant3.invariant)(message.data?.signal || message.data?.signalBatch, "Invalid message", {
+      F: __dxlog_file4,
+      L: 85,
+      S: this,
+      A: [
+        "message.data?.signal || message.data?.signalBatch",
+        "'Invalid message'"
+      ]
+    });
+    await this._sendReliableMessage({
+      author: message.author,
+      recipient: message.recipient,
+      message
+    });
+  }
+  async offer(message) {
+    const networkMessage = {
+      ...message,
+      messageId: import_keys4.PublicKey.random()
+    };
+    return new Promise((resolve, reject) => {
+      this._offerRecords.set(networkMessage.messageId, {
+        resolve
+      });
+      this._sendReliableMessage({
+        author: message.author,
+        recipient: message.recipient,
+        message: networkMessage
+      }).catch((err) => reject(err));
+    });
+  }
+  async _sendReliableMessage({ author, recipient, message }) {
+    const networkMessage = {
+      ...message,
+      // Setting unique message_id if it not specified yet.
+      messageId: message.messageId ?? import_keys4.PublicKey.random()
+    };
+    (0, import_log4.log)("sending", {
+      from: author,
+      to: recipient,
+      msg: networkMessage
+    }, {
+      F: __dxlog_file4,
+      L: 123,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._sendMessage({
+      author,
+      recipient,
+      payload: {
+        type_url: "dxos.mesh.swarm.SwarmMessage",
+        value: SwarmMessage.encode(networkMessage)
+      }
+    });
+  }
+  async _resolveAnswers(message) {
+    (0, import_invariant3.invariant)(message.data?.answer?.offerMessageId, "No offerMessageId", {
+      F: __dxlog_file4,
+      L: 135,
+      S: this,
+      A: [
+        "message.data?.answer?.offerMessageId",
+        "'No offerMessageId'"
+      ]
+    });
+    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
+    if (offerRecord) {
+      this._offerRecords.delete(message.data.answer.offerMessageId);
+      (0, import_invariant3.invariant)(message.data?.answer, "No answer", {
+        F: __dxlog_file4,
+        L: 139,
         S: this,
-        C: (f, a) => f(...a)
+        A: [
+          "message.data?.answer",
+          "'No answer'"
+        ]
       });
-      import_log3.log.trace("dxos.mesh.connection.error", {
-        topic: this.topic,
-        localPeerId: this.localPeerId,
-        remotePeerId: this.id,
-        sessionId,
-        initiator,
-        err
+      (0, import_log4.log)("resolving", {
+        answer: message.data.answer
       }, {
-        F: __dxlog_file3,
-        L: 296,
+        F: __dxlog_file4,
+        L: 140,
         S: this,
         C: (f, a) => f(...a)
       });
-      void this.closeConnection(err);
-    });
-    this.connection = connection;
-    return connection;
-  }
-  async closeConnection(err) {
-    if (!this.connection) {
-      return;
+      offerRecord.resolve(message.data.answer);
     }
-    const connection = this.connection;
-    (0, import_log3.log)("closing...", {
-      peerId: this.id,
-      sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file3,
-      L: 321,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await connection.close(err);
-    (0, import_log3.log)("closed", {
-      peerId: this.id,
-      sessionId: connection.sessionId
-    }, {
-      F: __dxlog_file3,
-      L: 327,
+  }
+  async _handleOffer({ author, recipient, message }) {
+    (0, import_invariant3.invariant)(message.data.offer, "No offer", {
+      F: __dxlog_file4,
+      L: 154,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "message.data.offer",
+        "'No offer'"
+      ]
     });
-  }
-  async onSignal(message) {
-    if (!this.connection) {
-      (0, import_log3.log)("dropping signal message for non-existent connection", {
-        message
+    const offerMessage = {
+      author,
+      recipient,
+      ...message,
+      data: {
+        offer: message.data.offer
+      }
+    };
+    const answer = await this._onOffer(offerMessage);
+    answer.offerMessageId = message.messageId;
+    try {
+      await this._sendReliableMessage({
+        author: recipient,
+        recipient: author,
+        message: {
+          topic: message.topic,
+          sessionId: message.sessionId,
+          data: {
+            answer
+          }
+        }
+      });
+    } catch (err) {
+      import_log4.log.warn("error sending answer", {
+        err
       }, {
-        F: __dxlog_file3,
-        L: 332,
+        F: __dxlog_file4,
+        L: 174,
         S: this,
         C: (f, a) => f(...a)
       });
-      return;
     }
-    await this.connection.signal(message);
   }
-  async destroy() {
-    await this._ctx.dispose();
-    (0, import_log3.log)("Destroying peer", {
-      peerId: this.id,
-      topic: this.topic
-    }, {
-      F: __dxlog_file3,
-      L: 342,
+  async _handleSignal({ author, recipient, message }) {
+    (0, import_invariant3.invariant)(message.messageId, void 0, {
+      F: __dxlog_file4,
+      L: 187,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "message.messageId",
+        ""
+      ]
     });
-    await this?.connection?.close();
-  }
-};
-_ts_decorate2([
-  import_async2.synchronized
-], Peer.prototype, "destroy", null);
-var increaseInterval = (interval) => {
-  if (interval === 0) {
-    return 50;
-  } else if (interval < 500) {
-    return 500;
-  } else if (interval < 1e3) {
-    return 1e3;
-  } else if (interval < 5e3) {
-    return 5e3;
+    (0, import_invariant3.invariant)(message.data.signal || message.data.signalBatch, "Invalid message", {
+      F: __dxlog_file4,
+      L: 188,
+      S: this,
+      A: [
+        "message.data.signal || message.data.signalBatch",
+        "'Invalid message'"
+      ]
+    });
+    const signalMessage = {
+      author,
+      recipient,
+      ...message,
+      data: {
+        signal: message.data.signal,
+        signalBatch: message.data.signalBatch
+      }
+    };
+    await this._onSignal(signalMessage);
   }
-  return 1e4;
 };
 
 // packages/core/mesh/network-manager/src/swarm/swarm.ts
@@ -1733,7 +1864,7 @@ function _ts_decorate3(decorators, target, key, desc) {
         r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts";
 var INITIATION_DELAY = 100;
 var getClassName = (obj) => Object.getPrototypeOf(obj).constructor.name;
 var Swarm = class {
@@ -1751,28 +1882,28 @@ var Swarm = class {
     this._initiationDelay = _initiationDelay;
     this._ctx = new import_context4.Context();
     this._listeningHandle = void 0;
-    this._peers = new import_util2.ComplexMap(import_keys4.PublicKey.hash);
-    this._instanceId = import_keys4.PublicKey.random().toHex();
-    this.connectionAdded = new import_async3.Event();
-    this.disconnected = new import_async3.Event();
-    this.connected = new import_async3.Event();
+    this._peers = new import_util3.ComplexMap(import_keys5.PublicKey.hash);
+    this._instanceId = import_keys5.PublicKey.random().toHex();
+    this.connectionAdded = new import_async4.Event();
+    this.disconnected = new import_async4.Event();
+    this.connected = new import_async4.Event();
     this.errors = new import_debug2.ErrorStream();
-    import_log4.log.trace("dxos.mesh.swarm.constructor", import_protocols3.trace.begin({
+    import_log5.log.trace("dxos.mesh.swarm.constructor", import_protocols4.trace.begin({
       id: this._instanceId,
       data: {
         topic: this._topic.toHex(),
         peerId: this._ownPeerId.toHex()
       }
     }), {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 88,
       S: this,
       C: (f, a) => f(...a)
     });
-    (0, import_log4.log)("creating swarm", {
+    (0, import_log5.log)("creating swarm", {
       peerId: _ownPeerId
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 92,
       S: this,
       C: (f, a) => f(...a)
@@ -1784,17 +1915,17 @@ var Swarm = class {
       onOffer: async (msg) => await this.onOffer(msg),
       topic: this._topic
     });
-    import_log4.log.trace("dxos.mesh.swarm.constructor", import_protocols3.trace.end({
+    import_log5.log.trace("dxos.mesh.swarm.constructor", import_protocols4.trace.end({
       id: this._instanceId
     }), {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 101,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   get connections() {
-    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(import_util2.isNotNullOrUndefined);
+    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(import_util3.isNotNullOrUndefined);
   }
   get ownPeerId() {
     return this._ownPeerId;
@@ -1810,7 +1941,7 @@ var Swarm = class {
   }
   async open() {
     (0, import_invariant4.invariant)(!this._listeningHandle, void 0, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 128,
       S: this,
       A: [
@@ -1822,10 +1953,10 @@ var Swarm = class {
       peerId: this._ownPeerId,
       payloadType: "dxos.mesh.swarm.SwarmMessage",
       onMessage: async (message) => {
-        await this._swarmMessenger.receiveMessage(message).catch((err) => import_log4.log.warn("Error while receiving message", {
+        await this._swarmMessenger.receiveMessage(message).catch((err) => import_log5.log.warn("Error while receiving message", {
           err
         }, {
-          F: __dxlog_file4,
+          F: __dxlog_file5,
           L: 135,
           S: this,
           C: (f, a) => f(...a)
@@ -1834,8 +1965,8 @@ var Swarm = class {
     });
   }
   async destroy() {
-    (0, import_log4.log)("destroying...", void 0, {
-      F: __dxlog_file4,
+    (0, import_log5.log)("destroying...", void 0, {
+      F: __dxlog_file5,
       L: 141,
       S: this,
       C: (f, a) => f(...a)
@@ -1845,8 +1976,8 @@ var Swarm = class {
     await this._ctx.dispose();
     await this._topology.destroy();
     await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key)));
-    (0, import_log4.log)("destroyed", void 0, {
-      F: __dxlog_file4,
+    (0, import_log5.log)("destroyed", void 0, {
+      F: __dxlog_file5,
       L: 148,
       S: this,
       C: (f, a) => f(...a)
@@ -1854,7 +1985,7 @@ var Swarm = class {
   }
   async setTopology(topology) {
     (0, import_invariant4.invariant)(!this._ctx.disposed, "Swarm is offline", {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 152,
       S: this,
       A: [
@@ -1865,11 +1996,11 @@ var Swarm = class {
     if (topology === this._topology) {
       return;
     }
-    (0, import_log4.log)("setting topology", {
+    (0, import_log5.log)("setting topology", {
       previous: getClassName(this._topology),
       topology: getClassName(topology)
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 156,
       S: this,
       C: (f, a) => f(...a)
@@ -1880,17 +2011,17 @@ var Swarm = class {
     this._topology.update();
   }
   onSwarmEvent(swarmEvent) {
-    (0, import_log4.log)("swarm event", {
+    (0, import_log5.log)("swarm event", {
       swarmEvent
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 169,
       S: this,
       C: (f, a) => f(...a)
     });
     if (this._ctx.disposed) {
-      (0, import_log4.log)("swarm event ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
+      (0, import_log5.log)("swarm event ignored for disposed swarm", void 0, {
+        F: __dxlog_file5,
         L: 172,
         S: this,
         C: (f, a) => f(...a)
@@ -1898,11 +2029,11 @@ var Swarm = class {
       return;
     }
     if (swarmEvent.peerAvailable) {
-      const peerId = import_keys4.PublicKey.from(swarmEvent.peerAvailable.peer);
-      (0, import_log4.log)("new peer", {
+      const peerId = import_keys5.PublicKey.from(swarmEvent.peerAvailable.peer);
+      (0, import_log5.log)("new peer", {
         peerId
       }, {
-        F: __dxlog_file4,
+        F: __dxlog_file5,
         L: 178,
         S: this,
         C: (f, a) => f(...a)
@@ -1912,12 +2043,12 @@ var Swarm = class {
         peer.advertizing = true;
       }
     } else if (swarmEvent.peerLeft) {
-      const peer = this._peers.get(import_keys4.PublicKey.from(swarmEvent.peerLeft.peer));
+      const peer = this._peers.get(import_keys5.PublicKey.from(swarmEvent.peerLeft.peer));
       if (peer) {
         peer.advertizing = false;
         if (peer.connection?.state !== ConnectionState.CONNECTED) {
-          void this._destroyPeer(peer.id).catch((err) => import_log4.log.catch(err, void 0, {
-            F: __dxlog_file4,
+          void this._destroyPeer(peer.id).catch((err) => import_log5.log.catch(err, void 0, {
+            F: __dxlog_file5,
             L: 189,
             S: this,
             C: (f, a) => f(...a)
@@ -1928,17 +2059,17 @@ var Swarm = class {
     this._topology.update();
   }
   async onOffer(message) {
-    (0, import_log4.log)("offer", {
+    (0, import_log5.log)("offer", {
       message
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 199,
       S: this,
       C: (f, a) => f(...a)
     });
     if (this._ctx.disposed) {
-      (0, import_log4.log)("ignored for disposed swarm", void 0, {
-        F: __dxlog_file4,
+      (0, import_log5.log)("ignored for disposed swarm", void 0, {
+        F: __dxlog_file5,
         L: 201,
         S: this,
         C: (f, a) => f(...a)
@@ -1948,7 +2079,7 @@ var Swarm = class {
       };
     }
     (0, import_invariant4.invariant)(message.author, void 0, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 206,
       S: this,
       A: [
@@ -1957,10 +2088,10 @@ var Swarm = class {
       ]
     });
     if (!message.recipient?.equals(this._ownPeerId)) {
-      (0, import_log4.log)("rejecting offer with incorrect peerId", {
+      (0, import_log5.log)("rejecting offer with incorrect peerId", {
         message
       }, {
-        F: __dxlog_file4,
+        F: __dxlog_file5,
         L: 208,
         S: this,
         C: (f, a) => f(...a)
@@ -1970,10 +2101,10 @@ var Swarm = class {
       };
     }
     if (!message.topic?.equals(this._topic)) {
-      (0, import_log4.log)("rejecting offer with incorrect topic", {
+      (0, import_log5.log)("rejecting offer with incorrect topic", {
         message
       }, {
-        F: __dxlog_file4,
+        F: __dxlog_file5,
         L: 212,
         S: this,
         C: (f, a) => f(...a)
@@ -1988,17 +2119,17 @@ var Swarm = class {
     return answer;
   }
   async onSignal(message) {
-    (0, import_log4.log)("signal", {
+    (0, import_log5.log)("signal", {
       message
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 223,
       S: this,
       C: (f, a) => f(...a)
     });
     if (this._ctx.disposed) {
-      import_log4.log.info("ignored for offline swarm", void 0, {
-        F: __dxlog_file4,
+      import_log5.log.info("ignored for offline swarm", void 0, {
+        F: __dxlog_file5,
         L: 225,
         S: this,
         C: (f, a) => f(...a)
@@ -2006,7 +2137,7 @@ var Swarm = class {
       return;
     }
     (0, import_invariant4.invariant)(message.recipient?.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 228,
       S: this,
       A: [
@@ -2015,7 +2146,7 @@ var Swarm = class {
       ]
     });
     (0, import_invariant4.invariant)(message.topic?.equals(this._topic), void 0, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 232,
       S: this,
       A: [
@@ -2024,7 +2155,7 @@ var Swarm = class {
       ]
     });
     (0, import_invariant4.invariant)(message.author, void 0, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 233,
       S: this,
       A: [
@@ -2084,7 +2215,7 @@ var Swarm = class {
   }
   async _destroyPeer(peerId) {
     (0, import_invariant4.invariant)(this._peers.has(peerId), void 0, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 303,
       S: this,
       A: [
@@ -2106,12 +2237,12 @@ var Swarm = class {
         if (this._ctx.disposed) {
           return;
         }
-        (0, import_async3.scheduleTask)(this._ctx, async () => {
+        (0, import_async4.scheduleTask)(this._ctx, async () => {
           try {
             await this._initiateConnection(peer);
           } catch (err) {
-            (0, import_log4.log)("initiation error", err, {
-              F: __dxlog_file4,
+            (0, import_log5.log)("initiation error", err, {
+              F: __dxlog_file5,
               L: 329,
               S: this,
               C: (f, a) => f(...a)
@@ -2123,7 +2254,7 @@ var Swarm = class {
         if (this._ctx.disposed) {
           return;
         }
-        (0, import_async3.scheduleTask)(this._ctx, async () => {
+        (0, import_async4.scheduleTask)(this._ctx, async () => {
           await this._closeConnection(peer);
           this._topology.update();
         });
@@ -2136,15 +2267,15 @@ var Swarm = class {
   async _initiateConnection(remoteId) {
     const ctx = this._ctx;
     if (remoteId.toHex() < this._ownPeerId.toHex()) {
-      (0, import_log4.log)("initiation delay", {
+      (0, import_log5.log)("initiation delay", {
         remoteId
       }, {
-        F: __dxlog_file4,
+        F: __dxlog_file5,
         L: 356,
         S: this,
         C: (f, a) => f(...a)
       });
-      await (0, import_async3.sleep)(this._initiationDelay);
+      await (0, import_async4.sleep)(this._initiationDelay);
     }
     if (ctx.disposed) {
       return;
@@ -2153,20 +2284,20 @@ var Swarm = class {
     if (peer.connection) {
       return;
     }
-    (0, import_log4.log)("initiating connection...", {
+    (0, import_log5.log)("initiating connection...", {
       remoteId
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 370,
       S: this,
       C: (f, a) => f(...a)
     });
     await peer.initiateConnection();
     this._topology.update();
-    (0, import_log4.log)("initiated", {
+    (0, import_log5.log)("initiated", {
       remoteId
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 373,
       S: this,
       C: (f, a) => f(...a)
@@ -2181,44 +2312,43 @@ var Swarm = class {
   }
 };
 _ts_decorate3([
-  import_log4.logInfo
+  import_log5.logInfo
 ], Swarm.prototype, "_instanceId", void 0);
 _ts_decorate3([
-  import_log4.logInfo
+  import_log5.logInfo
 ], Swarm.prototype, "ownPeerId", null);
 _ts_decorate3([
-  import_log4.logInfo
+  import_log5.logInfo
 ], Swarm.prototype, "topic", null);
 _ts_decorate3([
-  import_async3.synchronized
+  import_async4.synchronized
 ], Swarm.prototype, "onSwarmEvent", null);
 _ts_decorate3([
-  import_async3.synchronized
+  import_async4.synchronized
 ], Swarm.prototype, "onOffer", null);
 _ts_decorate3([
-  import_async3.synchronized
+  import_async4.synchronized
 ], Swarm.prototype, "goOffline", null);
 _ts_decorate3([
-  import_async3.synchronized
+  import_async4.synchronized
 ], Swarm.prototype, "goOnline", null);
 
 // packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts
-var import_async4 = require("@dxos/async");
-var import_keys5 = require("@dxos/keys");
-var import_log5 = require("@dxos/log");
-var import_util3 = require("@dxos/util");
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
+var import_async5 = require("@dxos/async");
+var import_keys6 = require("@dxos/keys");
+var import_log6 = require("@dxos/log");
+var import_util4 = require("@dxos/util");
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
 var SwarmMapper = class {
   get peers() {
     return Array.from(this._peers.values());
   }
-  // prettier-ignore
   constructor(_swarm) {
     this._swarm = _swarm;
-    this._subscriptions = new import_async4.EventSubscriptions();
-    this._connectionSubscriptions = new import_util3.ComplexMap(import_keys5.PublicKey.hash);
-    this._peers = new import_util3.ComplexMap(import_keys5.PublicKey.hash);
-    this.mapUpdated = new import_async4.Event();
+    this._subscriptions = new import_async5.EventSubscriptions();
+    this._connectionSubscriptions = new import_util4.ComplexMap(import_keys6.PublicKey.hash);
+    this._peers = new import_util4.ComplexMap(import_keys6.PublicKey.hash);
+    this.mapUpdated = new import_async5.Event();
     this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
       this._update();
       this._connectionSubscriptions.set(connection.remoteId, connection.stateChanged.on(() => {
@@ -2233,9 +2363,9 @@ var SwarmMapper = class {
     this._update();
   }
   _update() {
-    (0, import_log5.log)("updating swarm", void 0, {
-      F: __dxlog_file5,
-      L: 75,
+    (0, import_log6.log)("updating swarm", void 0, {
+      F: __dxlog_file6,
+      L: 72,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2254,12 +2384,12 @@ var SwarmMapper = class {
         ]
       });
     }
-    (0, import_log5.log)("graph changed", {
+    (0, import_log6.log)("graph changed", {
       directConnections: this._swarm.connections.length,
       totalPeersInSwarm: this._peers.size
     }, {
-      F: __dxlog_file5,
-      L: 116,
+      F: __dxlog_file6,
+      L: 113,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2273,23 +2403,23 @@ var SwarmMapper = class {
 };
 
 // packages/core/mesh/network-manager/src/swarm/connection-limiter.ts
-var import_async5 = require("@dxos/async");
+var import_async6 = require("@dxos/async");
 var import_context5 = require("@dxos/context");
-var import_errors3 = require("@dxos/errors");
 var import_invariant5 = require("@dxos/invariant");
-var import_keys6 = require("@dxos/keys");
-var import_log6 = require("@dxos/log");
-var import_util4 = require("@dxos/util");
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
-var MAX_CONCURRENT_INITIATING_CONNECTIONS = 10;
+var import_keys7 = require("@dxos/keys");
+var import_log7 = require("@dxos/log");
+var import_protocols5 = require("@dxos/protocols");
+var import_util5 = require("@dxos/util");
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
+var MAX_CONCURRENT_INITIATING_CONNECTIONS = 50;
 var ConnectionLimiter = class {
   constructor({ maxConcurrentInitConnections = MAX_CONCURRENT_INITIATING_CONNECTIONS } = {}) {
     this._ctx = new import_context5.Context();
     /**
     * Queue of promises to resolve when initiating connections amount is below the limit.
     */
-    this._waitingPromises = new import_util4.ComplexMap(import_keys6.PublicKey.hash);
-    this.resolveWaitingPromises = new import_async5.DeferredTask(this._ctx, async () => {
+    this._waitingPromises = new import_util5.ComplexMap(import_keys7.PublicKey.hash);
+    this.resolveWaitingPromises = new import_async6.DeferredTask(this._ctx, async () => {
       Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
         resolve();
       });
@@ -2301,7 +2431,7 @@ var ConnectionLimiter = class {
   */
   async connecting(sessionId) {
     (0, import_invariant5.invariant)(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", {
-      F: __dxlog_file6,
+      F: __dxlog_file7,
       L: 48,
       S: this,
       A: [
@@ -2309,10 +2439,10 @@ var ConnectionLimiter = class {
         "'Peer is already waiting for connection'"
       ]
     });
-    (0, import_log6.log)("waiting", {
+    (0, import_log7.log)("waiting", {
       sessionId
     }, {
-      F: __dxlog_file6,
+      F: __dxlog_file7,
       L: 49,
       S: this,
       C: (f, a) => f(...a)
@@ -2324,10 +2454,10 @@ var ConnectionLimiter = class {
       });
       this.resolveWaitingPromises.schedule();
     });
-    (0, import_log6.log)("allow", {
+    (0, import_log7.log)("allow", {
       sessionId
     }, {
-      F: __dxlog_file6,
+      F: __dxlog_file7,
       L: 57,
       S: this,
       C: (f, a) => f(...a)
@@ -2337,10 +2467,10 @@ var ConnectionLimiter = class {
   * Rejects promise returned by `connecting` method.
   */
   doneConnecting(sessionId) {
-    (0, import_log6.log)("done", {
+    (0, import_log7.log)("done", {
       sessionId
     }, {
-      F: __dxlog_file6,
+      F: __dxlog_file7,
       L: 64,
       S: this,
       C: (f, a) => f(...a)
@@ -2348,7 +2478,7 @@ var ConnectionLimiter = class {
     if (!this._waitingPromises.has(sessionId)) {
       return;
     }
-    this._waitingPromises.get(sessionId).reject(new import_errors3.CancelledError());
+    this._waitingPromises.get(sessionId).reject(new import_protocols5.CancelledError());
     this._waitingPromises.delete(sessionId);
     this.resolveWaitingPromises.schedule();
   }
@@ -2368,8 +2498,8 @@ var ConnectionLog = class {
     /**
     * SwarmId => info
     */
-    this._swarms = new import_util5.ComplexMap(import_keys7.PublicKey.hash);
-    this.update = new import_async6.Event();
+    this._swarms = new import_util6.ComplexMap(import_keys8.PublicKey.hash);
+    this.update = new import_async7.Event();
   }
   getSwarmInfo(swarmId) {
     return this._swarms.get(swarmId) ?? (0, import_debug3.raise)(new Error(`Swarm not found: ${swarmId}`));
@@ -2379,13 +2509,13 @@ var ConnectionLog = class {
   }
   joinedSwarm(swarm) {
     const info = {
-      id: import_keys7.PublicKey.from(swarm._instanceId),
+      id: import_keys8.PublicKey.from(swarm._instanceId),
       topic: swarm.topic,
       isActive: true,
       label: swarm.label,
       connections: []
     };
-    this._swarms.set(import_keys7.PublicKey.from(swarm._instanceId), info);
+    this._swarms.set(import_keys8.PublicKey.from(swarm._instanceId), info);
     this.update.emit();
     swarm.connectionAdded.on((connection) => {
       const connectionInfo = {
@@ -2415,24 +2545,24 @@ var ConnectionLog = class {
     });
   }
   leftSwarm(swarm) {
-    this.getSwarmInfo(import_keys7.PublicKey.from(swarm._instanceId)).isActive = false;
+    this.getSwarmInfo(import_keys8.PublicKey.from(swarm._instanceId)).isActive = false;
     this.update.emit();
   }
 };
 
 // packages/core/mesh/network-manager/src/network-manager.ts
-var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
+var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
 var NetworkManager = class {
   constructor({ transportFactory, signalManager, log: log1 }) {
     /**
     * @internal
     */
-    this._swarms = new import_util6.ComplexMap(import_keys8.PublicKey.hash);
-    this._mappers = new import_util6.ComplexMap(import_keys8.PublicKey.hash);
+    this._swarms = new import_util7.ComplexMap(import_keys9.PublicKey.hash);
+    this._mappers = new import_util7.ComplexMap(import_keys9.PublicKey.hash);
     this._connectionState = import_services.ConnectionState.ONLINE;
-    this.connectionStateChanged = new import_async7.Event();
-    this.topicsUpdated = new import_async7.Event();
-    this._instanceId = import_keys8.PublicKey.random().toHex();
+    this.connectionStateChanged = new import_async8.Event();
+    this.topicsUpdated = new import_async8.Event();
+    this._instanceId = import_keys9.PublicKey.random().toHex();
     this._transportFactory = transportFactory;
     this._signalManager = signalManager;
     this._signalManager.swarmEvent.on(({ topic, swarmEvent: event }) => this._swarms.get(topic)?.onSwarmEvent(event));
@@ -2466,20 +2596,20 @@ var NetworkManager = class {
     return this._swarms.get(topic);
   }
   async open() {
-    import_log7.log.trace("dxos.mesh.network-manager.open", import_protocols4.trace.begin({
+    import_log8.log.trace("dxos.mesh.network-manager.open", import_protocols6.trace.begin({
       id: this._instanceId
     }), {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 130,
       S: this,
       C: (f, a) => f(...a)
     });
     await this._messenger.open();
     await this._signalManager.open();
-    import_log7.log.trace("dxos.mesh.network-manager.open", import_protocols4.trace.end({
+    import_log8.log.trace("dxos.mesh.network-manager.open", import_protocols6.trace.end({
       id: this._instanceId
     }), {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 133,
       S: this,
       C: (f, a) => f(...a)
@@ -2488,8 +2618,8 @@ var NetworkManager = class {
   async close() {
     for (const topic of this._swarms.keys()) {
       await this.leaveSwarm(topic).catch((err) => {
-        (0, import_log7.log)(err, void 0, {
-          F: __dxlog_file7,
+        (0, import_log8.log)(err, void 0, {
+          F: __dxlog_file8,
           L: 139,
           S: this,
           C: (f, a) => f(...a)
@@ -2503,8 +2633,8 @@ var NetworkManager = class {
   * Join the swarm.
   */
   async joinSwarm({ topic, peerId, topology, protocolProvider: protocol, label }) {
-    (0, import_invariant6.invariant)(import_keys8.PublicKey.isPublicKey(topic), void 0, {
-      F: __dxlog_file7,
+    (0, import_invariant6.invariant)(import_keys9.PublicKey.isPublicKey(topic), void 0, {
+      F: __dxlog_file8,
       L: 157,
       S: this,
       A: [
@@ -2512,8 +2642,8 @@ var NetworkManager = class {
         ""
       ]
     });
-    (0, import_invariant6.invariant)(import_keys8.PublicKey.isPublicKey(peerId), void 0, {
-      F: __dxlog_file7,
+    (0, import_invariant6.invariant)(import_keys9.PublicKey.isPublicKey(peerId), void 0, {
+      F: __dxlog_file8,
       L: 158,
       S: this,
       A: [
@@ -2522,7 +2652,7 @@ var NetworkManager = class {
       ]
     });
     (0, import_invariant6.invariant)(topology, void 0, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 159,
       S: this,
       A: [
@@ -2531,7 +2661,7 @@ var NetworkManager = class {
       ]
     });
     (0, import_invariant6.invariant)(typeof protocol === "function", void 0, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 160,
       S: this,
       A: [
@@ -2540,24 +2670,24 @@ var NetworkManager = class {
       ]
     });
     if (this._swarms.has(topic)) {
-      throw new Error(`Already connected to swarm: ${import_keys8.PublicKey.from(topic)}`);
+      throw new Error(`Already connected to swarm: ${import_keys9.PublicKey.from(topic)}`);
     }
-    (0, import_log7.log)("joining", {
-      topic: import_keys8.PublicKey.from(topic),
+    (0, import_log8.log)("joining", {
+      topic: import_keys9.PublicKey.from(topic),
       peerId,
       topology: topology.toString()
     }, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 165,
       S: this,
       C: (f, a) => f(...a)
     });
     const swarm = new Swarm(topic, peerId, topology, protocol, this._messenger, this._transportFactory, label, this._connectionLimiter);
     swarm.errors.handle((error) => {
-      (0, import_log7.log)("swarm error", {
+      (0, import_log8.log)("swarm error", {
         error
       }, {
-        F: __dxlog_file7,
+        F: __dxlog_file8,
         L: 178,
         S: this,
         C: (f, a) => f(...a)
@@ -2569,19 +2699,19 @@ var NetworkManager = class {
     this._signalConnection.join({
       topic,
       peerId
-    }).catch((error) => import_log7.log.catch(error, void 0, {
-      F: __dxlog_file7,
+    }).catch((error) => import_log8.log.catch(error, void 0, {
+      F: __dxlog_file8,
       L: 187,
       S: this,
       C: (f, a) => f(...a)
     }));
     this.topicsUpdated.emit();
     this._connectionLog?.joinedSwarm(swarm);
-    (0, import_log7.log)("joined", {
-      topic: import_keys8.PublicKey.from(topic),
+    (0, import_log8.log)("joined", {
+      topic: import_keys9.PublicKey.from(topic),
       count: this._swarms.size
     }, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 191,
       S: this,
       C: (f, a) => f(...a)
@@ -2597,10 +2727,10 @@ var NetworkManager = class {
     if (!this._swarms.has(topic)) {
       return;
     }
-    (0, import_log7.log)("leaving", {
-      topic: import_keys8.PublicKey.from(topic)
+    (0, import_log8.log)("leaving", {
+      topic: import_keys9.PublicKey.from(topic)
     }, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 207,
       S: this,
       C: (f, a) => f(...a)
@@ -2617,11 +2747,11 @@ var NetworkManager = class {
     await swarm.destroy();
     this._swarms.delete(topic);
     await this.topicsUpdated.emit();
-    (0, import_log7.log)("left", {
-      topic: import_keys8.PublicKey.from(topic),
+    (0, import_log8.log)("left", {
+      topic: import_keys9.PublicKey.from(topic),
       count: this._swarms.size
     }, {
-      F: __dxlog_file7,
+      F: __dxlog_file8,
       L: 221,
       S: this,
       C: (f, a) => f(...a)
@@ -2657,14 +2787,14 @@ var NetworkManager = class {
 
 // packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts
 var import_invariant7 = require("@dxos/invariant");
-var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
+var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
 var FullyConnectedTopology = class {
   toString() {
     return "FullyConnectedTopology";
   }
   init(controller) {
     (0, import_invariant7.invariant)(!this._controller, "Already initialized", {
-      F: __dxlog_file8,
+      F: __dxlog_file9,
       L: 18,
       S: this,
       A: [
@@ -2676,7 +2806,7 @@ var FullyConnectedTopology = class {
   }
   update() {
     (0, import_invariant7.invariant)(this._controller, "Not initialized", {
-      F: __dxlog_file8,
+      F: __dxlog_file9,
       L: 23,
       S: this,
       A: [
@@ -2699,20 +2829,20 @@ var FullyConnectedTopology = class {
 // packages/core/mesh/network-manager/src/topology/mmst-topology.ts
 var import_xor_distance = __toESM(require("xor-distance"));
 var import_invariant8 = require("@dxos/invariant");
-var import_log8 = require("@dxos/log");
+var import_log9 = require("@dxos/log");
 
 // packages/core/mesh/network-manager/src/topology/star-topology.ts
 var import_invariant9 = require("@dxos/invariant");
-var import_log9 = require("@dxos/log");
+var import_log10 = require("@dxos/log");
 
 // packages/core/mesh/network-manager/src/transport/memory-transport.ts
 var import_node_stream = require("node:stream");
-var import_async8 = require("@dxos/async");
+var import_async9 = require("@dxos/async");
 var import_debug4 = require("@dxos/debug");
 var import_invariant10 = require("@dxos/invariant");
-var import_keys9 = require("@dxos/keys");
-var import_log10 = require("@dxos/log");
-var import_util7 = require("@dxos/util");
+var import_keys10 = require("@dxos/keys");
+var import_log11 = require("@dxos/log");
+var import_util8 = require("@dxos/util");
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -2723,7 +2853,7 @@ function _ts_decorate4(decorators, target, key, desc) {
         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 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
+var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
 var MEMORY_TRANSPORT_DELAY = 1;
 var createStreamDelay = (delay) => {
   return new import_node_stream.Transform({
@@ -2739,26 +2869,26 @@ var MemoryTransportFactory = {
 var MemoryTransport = class _MemoryTransport {
   static {
     // TODO(burdon): Remove static properties (inject context into constructor).
-    this._connections = new import_util7.ComplexMap(import_keys9.PublicKey.hash);
+    this._connections = new import_util8.ComplexMap(import_keys10.PublicKey.hash);
   }
   constructor(options) {
     this.options = options;
-    this.closed = new import_async8.Event();
-    this.connected = new import_async8.Event();
+    this.closed = new import_async9.Event();
+    this.connected = new import_async9.Event();
     this.errors = new import_debug4.ErrorStream();
-    this._instanceId = import_keys9.PublicKey.random();
-    this._remote = new import_async8.Trigger();
+    this._instanceId = import_keys10.PublicKey.random();
+    this._remote = new import_async9.Trigger();
     this._outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
     this._incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
     this._destroyed = false;
-    (0, import_log10.log)("creating", void 0, {
-      F: __dxlog_file9,
+    (0, import_log11.log)("creating", void 0, {
+      F: __dxlog_file10,
       L: 64,
       S: this,
       C: (f, a) => f(...a)
     });
     (0, import_invariant10.invariant)(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 66,
       S: this,
       A: [
@@ -2769,8 +2899,8 @@ var MemoryTransport = class _MemoryTransport {
     _MemoryTransport._connections.set(this._instanceId, this);
     if (this.options.initiator) {
       setTimeout(async () => {
-        (0, import_log10.log)("sending signal", void 0, {
-          F: __dxlog_file9,
+        (0, import_log11.log)("sending signal", void 0, {
+          F: __dxlog_file10,
           L: 73,
           S: this,
           C: (f, a) => f(...a)
@@ -2800,7 +2930,7 @@ var MemoryTransport = class _MemoryTransport {
           return;
         }
         (0, import_invariant10.invariant)(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
-          F: __dxlog_file9,
+          F: __dxlog_file10,
           L: 99,
           S: this,
           A: [
@@ -2810,8 +2940,8 @@ var MemoryTransport = class _MemoryTransport {
         });
         this._remoteConnection._remoteConnection = this;
         this._remoteConnection._remoteInstanceId = this._instanceId;
-        (0, import_log10.log)("connected", void 0, {
-          F: __dxlog_file9,
+        (0, import_log11.log)("connected", void 0, {
+          F: __dxlog_file10,
           L: 103,
           S: this,
           C: (f, a) => f(...a)
@@ -2828,8 +2958,8 @@ var MemoryTransport = class _MemoryTransport {
     }
   }
   async destroy() {
-    (0, import_log10.log)("closing", void 0, {
-      F: __dxlog_file9,
+    (0, import_log11.log)("closing", void 0, {
+      F: __dxlog_file10,
       L: 124,
       S: this,
       C: (f, a) => f(...a)
@@ -2837,8 +2967,8 @@ var MemoryTransport = class _MemoryTransport {
     this._destroyed = true;
     _MemoryTransport._connections.delete(this._instanceId);
     if (this._remoteConnection) {
-      (0, import_log10.log)("closing", void 0, {
-        F: __dxlog_file9,
+      (0, import_log11.log)("closing", void 0, {
+        F: __dxlog_file10,
         L: 129,
         S: this,
         C: (f, a) => f(...a)
@@ -2850,26 +2980,26 @@ var MemoryTransport = class _MemoryTransport {
       this._remoteConnection.closed.emit();
       this._remoteConnection._remoteConnection = void 0;
       this._remoteConnection = void 0;
-      (0, import_log10.log)("closed", void 0, {
-        F: __dxlog_file9,
+      (0, import_log11.log)("closed", void 0, {
+        F: __dxlog_file10,
         L: 147,
         S: this,
         C: (f, a) => f(...a)
       });
     }
     this.closed.emit();
-    (0, import_log10.log)("closed", void 0, {
-      F: __dxlog_file9,
+    (0, import_log11.log)("closed", void 0, {
+      F: __dxlog_file10,
       L: 151,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   signal({ payload }) {
-    (0, import_log10.log)("received signal", {
+    (0, import_log11.log)("received signal", {
       payload
     }, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 155,
       S: this,
       C: (f, a) => f(...a)
@@ -2879,16 +3009,16 @@ var MemoryTransport = class _MemoryTransport {
     }
     const transportId = payload.transportId;
     if (transportId) {
-      const remoteId = import_keys9.PublicKey.fromHex(transportId);
+      const remoteId = import_keys10.PublicKey.fromHex(transportId);
       this._remote.wake(remoteId);
     }
   }
 };
 _ts_decorate4([
-  import_log10.logInfo
+  import_log11.logInfo
 ], MemoryTransport.prototype, "_instanceId", void 0);
 _ts_decorate4([
-  import_log10.logInfo
+  import_log11.logInfo
 ], MemoryTransport.prototype, "_remoteInstanceId", void 0);
 
 // packages/core/mesh/network-manager/src/transport/transport.ts
@@ -2904,12 +3034,11 @@ var TransportKind;
 // packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
 var import_simple_peer = __toESM(require("simple-peer"));
 var import_tiny_invariant = __toESM(require("tiny-invariant"));
-var import_async9 = require("@dxos/async");
+var import_async10 = require("@dxos/async");
 var import_debug5 = require("@dxos/debug");
-var import_errors4 = require("@dxos/errors");
-var import_keys10 = require("@dxos/keys");
-var import_log11 = require("@dxos/log");
-var import_protocols5 = require("@dxos/protocols");
+var import_keys11 = require("@dxos/keys");
+var import_log12 = require("@dxos/log");
+var import_protocols7 = require("@dxos/protocols");
 
 // packages/core/mesh/network-manager/src/transport/webrtc.ts
 var wrtc = null;
@@ -2919,26 +3048,26 @@ try {
 }
 
 // packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
-var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts";
+var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts";
 var SimplePeerTransport = class {
   constructor(params) {
     this.params = params;
     this._closed = false;
-    this.closed = new import_async9.Event();
-    this.connected = new import_async9.Event();
+    this.closed = new import_async10.Event();
+    this.connected = new import_async10.Event();
     this.errors = new import_debug5.ErrorStream();
-    this._instanceId = import_keys10.PublicKey.random().toHex();
-    import_log11.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols5.trace.begin({
+    this._instanceId = import_keys11.PublicKey.random().toHex();
+    import_log12.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols7.trace.begin({
       id: this._instanceId
     }), {
-      F: __dxlog_file10,
-      L: 41,
+      F: __dxlog_file11,
+      L: 40,
       S: this,
       C: (f, a) => f(...a)
     });
-    (0, import_log11.log)("created connection", params, {
-      F: __dxlog_file10,
-      L: 42,
+    (0, import_log12.log)("created connection", params, {
+      F: __dxlog_file11,
+      L: 41,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2949,9 +3078,9 @@ var SimplePeerTransport = class {
       config: this.params.webrtcConfig
     });
     this._peer.on("signal", async (data) => {
-      (0, import_log11.log)("signal", data, {
-        F: __dxlog_file10,
-        L: 51,
+      (0, import_log12.log)("signal", data, {
+        F: __dxlog_file11,
+        L: 50,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -2962,9 +3091,9 @@ var SimplePeerTransport = class {
       });
     });
     this._peer.on("connect", () => {
-      (0, import_log11.log)("connected", void 0, {
-        F: __dxlog_file10,
-        L: 56,
+      (0, import_log12.log)("connected", void 0, {
+        F: __dxlog_file11,
+        L: 55,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -2972,9 +3101,9 @@ var SimplePeerTransport = class {
       this.connected.emit();
     });
     this._peer.on("close", async () => {
-      (0, import_log11.log)("closed", void 0, {
-        F: __dxlog_file10,
-        L: 62,
+      (0, import_log12.log)("closed", void 0, {
+        F: __dxlog_file11,
+        L: 61,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -2984,70 +3113,84 @@ var SimplePeerTransport = class {
     this._peer.on("error", async (err) => {
       if (typeof RTCError !== "undefined" && err instanceof RTCError) {
         if (err.errorDetail === "sctp-failure") {
-          this.errors.raise(new import_errors4.ConnectionResetError("sctp-failure from RTCError", err));
+          this.errors.raise(new import_protocols7.ConnectionResetError("sctp-failure from RTCError", err));
         } else {
-          this.errors.raise(new import_errors4.UnknownProtocolError("unknown RTCError", err));
+          this.errors.raise(new import_protocols7.UnknownProtocolError("unknown RTCError", err));
         }
-      } else if (err.name === "InvalidStateError") {
-        this.errors.raise(new import_errors4.ConnectionResetError("safari WebRTC error", err));
       } else if ("code" in err) {
+        import_log12.log.info("simple-peer error", err, {
+          F: __dxlog_file11,
+          L: 77,
+          S: this,
+          C: (f, a) => f(...a)
+        });
         switch (err.code) {
           case "ERR_WEBRTC_SUPPORT":
-            this.errors.raise(new import_errors4.ProtocolError("WebRTC not supported", err));
+            this.errors.raise(new import_protocols7.ProtocolError("WebRTC not supported", err));
+            break;
           case "ERR_ICE_CONNECTION_FAILURE":
           case "ERR_DATA_CHANNEL":
           case "ERR_CONNECTION_FAILURE":
           case "ERR_SIGNALING":
-            this.errors.raise(new import_errors4.ConnectivityError("unknown communication failure", err));
+            this.errors.raise(new import_protocols7.ConnectivityError("unknown communication failure", err));
+            break;
           case "ERR_CREATE_OFFER":
           case "ERR_CREATE_ANSWER":
           case "ERR_SET_LOCAL_DESCRIPTION":
           case "ERR_SET_REMOTE_DESCRIPTION":
           case "ERR_ADD_ICE_CANDIDATE":
-            this.errors.raise(new import_errors4.UnknownProtocolError("unknown simple-peer library failure", err));
+            this.errors.raise(new import_protocols7.UnknownProtocolError("unknown simple-peer library failure", err));
+            break;
           default:
             this.errors.raise(new Error("unknown simple-peer error"));
+            break;
         }
       } else {
+        import_log12.log.info("unknown peer connection error", err, {
+          F: __dxlog_file11,
+          L: 101,
+          S: this,
+          C: (f, a) => f(...a)
+        });
         this.errors.raise(err);
       }
       try {
-        if (typeof this._peer?._pc.getStats === "function") {
+        if (typeof this._peer?._pc?.getStats === "function") {
           this._peer._pc.getStats().then((stats) => {
-            import_log11.log.warn("report after webrtc error", {
+            import_log12.log.warn("report after webrtc error", {
               config: this.params.webrtcConfig,
               stats
             }, {
-              F: __dxlog_file10,
-              L: 107,
+              F: __dxlog_file11,
+              L: 109,
               S: this,
               C: (f, a) => f(...a)
             });
           });
         }
       } catch (err2) {
-        import_log11.log.catch(err2, void 0, {
-          F: __dxlog_file10,
-          L: 114,
+        import_log12.log.catch(err2, void 0, {
+          F: __dxlog_file11,
+          L: 116,
           S: this,
           C: (f, a) => f(...a)
         });
       }
       await this.destroy();
     });
-    import_log11.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols5.trace.end({
+    import_log12.log.trace("dxos.mesh.webrtc-transport.constructor", import_protocols7.trace.end({
       id: this._instanceId
     }), {
-      F: __dxlog_file10,
-      L: 119,
+      F: __dxlog_file11,
+      L: 121,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   async destroy() {
-    (0, import_log11.log)("closing...", void 0, {
-      F: __dxlog_file10,
-      L: 123,
+    (0, import_log12.log)("closing...", void 0, {
+      F: __dxlog_file11,
+      L: 125,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -3055,9 +3198,9 @@ var SimplePeerTransport = class {
     await this._disconnectStreams();
     this._peer.destroy();
     this.closed.emit();
-    (0, import_log11.log)("closed", void 0, {
-      F: __dxlog_file10,
-      L: 128,
+    (0, import_log12.log)("closed", void 0, {
+      F: __dxlog_file11,
+      L: 130,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -3084,16 +3227,15 @@ var createSimplePeerTransportFactory = (webrtcConfig) => ({
 var import_node_stream2 = require("node:stream");
 var import_codec_protobuf = require("@dxos/codec-protobuf");
 var import_invariant11 = require("@dxos/invariant");
-var import_keys11 = require("@dxos/keys");
-var import_log12 = require("@dxos/log");
+var import_keys12 = require("@dxos/keys");
+var import_log13 = require("@dxos/log");
 var import_bridge = require("@dxos/protocols/proto/dxos/mesh/bridge");
-var import_util8 = require("@dxos/util");
-var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts";
+var import_util9 = require("@dxos/util");
+var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts";
 var SimplePeerTransportService = class {
-  // prettier-ignore
   constructor(_webrtcConfig) {
     this._webrtcConfig = _webrtcConfig;
-    this.transports = new import_util8.ComplexMap(import_keys11.PublicKey.hash);
+    this.transports = new import_util9.ComplexMap(import_keys12.PublicKey.hash);
   }
   open(request) {
     const rpcStream = new import_codec_protobuf.Stream(({ ready, next, close }) => {
@@ -3160,7 +3302,8 @@ var SimplePeerTransportService = class {
       const transportState = {
         transport,
         stream: duplex,
-        writeCallbacks: []
+        writeCallbacks: [],
+        state: "OPEN"
       };
       ready();
       this.transports.set(request.proxyId, transportState);
@@ -3169,8 +3312,8 @@ var SimplePeerTransportService = class {
   }
   async sendSignal({ proxyId, signal }) {
     (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
-      F: __dxlog_file11,
-      L: 113,
+      F: __dxlog_file12,
+      L: 112,
       S: this,
       A: [
         "this.transports.has(proxyId)",
@@ -3180,9 +3323,17 @@ var SimplePeerTransportService = class {
     await this.transports.get(proxyId).transport.signal(signal);
   }
   async sendData({ proxyId, payload }) {
+    if (this.transports.get(proxyId)?.state !== "OPEN") {
+      import_log13.log.debug("transport is closed", void 0, {
+        F: __dxlog_file12,
+        L: 118,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
     (0, import_invariant11.invariant)(this.transports.has(proxyId), void 0, {
-      F: __dxlog_file11,
-      L: 118,
+      F: __dxlog_file12,
+      L: 120,
       S: this,
       A: [
         "this.transports.has(proxyId)",
@@ -3200,10 +3351,12 @@ var SimplePeerTransportService = class {
   async close({ proxyId }) {
     await this.transports.get(proxyId)?.transport.destroy();
     await this.transports.get(proxyId)?.stream.end();
-    this.transports.delete(proxyId);
-    (0, import_log12.log)("Closed.", void 0, {
-      F: __dxlog_file11,
-      L: 132,
+    if (this.transports.get(proxyId)) {
+      this.transports.get(proxyId).state = "CLOSED";
+    }
+    (0, import_log13.log)("Closed.", void 0, {
+      F: __dxlog_file12,
+      L: 136,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -3212,24 +3365,23 @@ var SimplePeerTransportService = class {
 
 // packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts
 var import_node_stream3 = require("node:stream");
-var import_async10 = require("@dxos/async");
+var import_async11 = require("@dxos/async");
 var import_context6 = require("@dxos/context");
 var import_debug6 = require("@dxos/debug");
-var import_errors5 = require("@dxos/errors");
 var import_invariant12 = require("@dxos/invariant");
-var import_keys12 = require("@dxos/keys");
-var import_log13 = require("@dxos/log");
+var import_keys13 = require("@dxos/keys");
+var import_log14 = require("@dxos/log");
+var import_protocols8 = require("@dxos/protocols");
 var import_bridge2 = require("@dxos/protocols/proto/dxos/mesh/bridge");
-var import_util9 = require("@dxos/util");
-var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts";
+var import_util10 = require("@dxos/util");
+var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts";
 var SimplePeerTransportProxy = class {
-  // prettier-ignore
   constructor(_params) {
     this._params = _params;
-    this._proxyId = import_keys12.PublicKey.random();
+    this._proxyId = import_keys13.PublicKey.random();
     this._ctx = new import_context6.Context();
-    this.closed = new import_async10.Event();
-    this.connected = new import_async10.Event();
+    this.closed = new import_async11.Event();
+    this.connected = new import_async11.Event();
     this.errors = new import_debug6.ErrorStream();
     this._closed = false;
     this._serviceStream = this._params.bridgeService.open({
@@ -3238,9 +3390,9 @@ var SimplePeerTransportProxy = class {
     });
     this._serviceStream.waitUntilReady().then(() => {
       this._serviceStream.subscribe(async (event) => {
-        (0, import_log13.log)("SimplePeerTransportProxy: event", event, {
-          F: __dxlog_file12,
-          L: 58,
+        (0, import_log14.log)("SimplePeerTransportProxy: event", event, {
+          F: __dxlog_file13,
+          L: 55,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -3258,8 +3410,8 @@ var SimplePeerTransportProxy = class {
             proxyId: this._proxyId,
             payload: chunk
           }).then(() => callback(), (err) => {
-            import_log13.log.catch(err, void 0, {
-              F: __dxlog_file12,
+            import_log14.log.catch(err, void 0, {
+              F: __dxlog_file13,
               L: 76,
               S: this,
               C: (f, a) => f(...a)
@@ -3267,9 +3419,9 @@ var SimplePeerTransportProxy = class {
           });
         }
       }));
-    }, (error) => import_log13.log.catch(error, void 0, {
-      F: __dxlog_file12,
-      L: 82,
+    }, (error) => import_log14.log.catch(error, void 0, {
+      F: __dxlog_file13,
+      L: 83,
       S: this,
       C: (f, a) => f(...a)
     }));
@@ -3290,7 +3442,7 @@ var SimplePeerTransportProxy = class {
     }
   }
   _handleData(dataEvent) {
-    this._params.stream.write((0, import_util9.arrayToBuffer)(dataEvent.payload));
+    this._params.stream.write((0, import_util10.arrayToBuffer)(dataEvent.payload));
   }
   async _handleSignal(signalEvent) {
     await this._params.sendSignal(signalEvent.payload);
@@ -3313,9 +3465,9 @@ var SimplePeerTransportProxy = class {
         proxyId: this._proxyId
       });
     } catch (err) {
-      import_log13.log.catch(err, void 0, {
-        F: __dxlog_file12,
-        L: 133,
+      import_log14.log.catch(err, void 0, {
+        F: __dxlog_file13,
+        L: 134,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -3350,8 +3502,8 @@ var SimplePeerTransportProxyFactory = class {
   }
   createTransport(options) {
     (0, import_invariant12.invariant)(this._bridgeService, "SimplePeerTransportProxyFactory is not ready to open connections", {
-      F: __dxlog_file12,
-      L: 170,
+      F: __dxlog_file13,
+      L: 171,
       S: this,
       A: [
         "this._bridgeService",
@@ -3369,16 +3521,16 @@ var SimplePeerTransportProxyFactory = class {
 };
 var decodeError = (err) => {
   const message = typeof err === "string" ? err : err.message;
-  if (message.includes("ConnectionResetError")) {
-    return new import_errors5.ConnectionResetError(message);
-  } else if (message.includes("TimeoutError")) {
-    return new import_errors5.TimeoutError(message);
-  } else if (message.includes("ProtocolError")) {
-    return new import_errors5.ProtocolError(message);
-  } else if (message.includes("ConnectivityError")) {
-    return new import_errors5.ConnectivityError(message);
-  } else if (message.includes("UnknownProtocolError")) {
-    return new import_errors5.UnknownProtocolError(message);
+  if (message.includes("CONNECTION_RESET")) {
+    return new import_protocols8.ConnectionResetError(message);
+  } else if (message.includes("TIMEOUT")) {
+    return new import_protocols8.TimeoutError(message);
+  } else if (message.includes("PROTOCOL_ERROR")) {
+    return new import_protocols8.ProtocolError(message);
+  } else if (message.includes("CONNECTIVITY_ERROR")) {
+    return new import_protocols8.ConnectivityError(message);
+  } else if (message.includes("UNKNOWN_PROTOCOL_ERROR")) {
+    return new import_protocols8.UnknownProtocolError(message);
   } else {
     return typeof err === "string" ? new Error(err) : err;
   }
@@ -3389,9 +3541,9 @@ init_datachannel();
 
 // packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts
 var import_stream = require("stream");
-var import_async11 = require("@dxos/async");
+var import_async12 = require("@dxos/async");
 var import_debug7 = require("@dxos/debug");
-var import_log14 = require("@dxos/log");
+var import_log15 = require("@dxos/log");
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -3402,7 +3554,7 @@ function _ts_decorate5(decorators, target, key, desc) {
         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_file13 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts";
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts";
 var DATACHANNEL_LABEL = "dxos.mesh.transport";
 var MAX_BUFFERED_AMOUNT = 64 * 1024;
 var MAX_MESSAGE_SIZE = 64 * 1024;
@@ -3410,11 +3562,11 @@ var LibDataChannelTransport = class {
   constructor(params) {
     this.params = params;
     this._closed = false;
-    this.closed = new import_async11.Event();
+    this.closed = new import_async12.Event();
     this._connected = false;
-    this.connected = new import_async11.Event();
+    this.connected = new import_async12.Event();
     this.errors = new import_debug7.ErrorStream();
-    this._readyForCandidates = new import_async11.Trigger();
+    this._readyForCandidates = new import_async12.Trigger();
     this._writeCallback = null;
     this._peer = (async () => {
       const { RTCPeerConnection: PeerConnection2 } = await Promise.resolve().then(() => (init_datachannel(), datachannel_exports));
@@ -3423,32 +3575,32 @@ var LibDataChannelTransport = class {
       }
       const peer = new PeerConnection2(params.webrtcConfig);
       peer.onicecandidateerror = (event) => {
-        import_log14.log.error("peer.onicecandidateerror", {
+        import_log15.log.error("peer.onicecandidateerror", {
           event
         }, {
-          F: __dxlog_file13,
+          F: __dxlog_file14,
           L: 53,
           S: this,
           C: (f, a) => f(...a)
         });
       };
       peer.onconnectionstatechange = (event) => {
-        import_log14.log.debug("peer.onconnectionstatechange", {
+        import_log15.log.debug("peer.onconnectionstatechange", {
           event,
           peerConnectionState: peer.connectionState,
           transportConnectionState: this._connected
         }, {
-          F: __dxlog_file13,
+          F: __dxlog_file14,
           L: 57,
           S: this,
           C: (f, a) => f(...a)
         });
       };
       peer.onicecandidate = async (event) => {
-        import_log14.log.debug("peer.onicecandidate", {
+        import_log15.log.debug("peer.onicecandidate", {
           event
         }, {
-          F: __dxlog_file13,
+          F: __dxlog_file14,
           L: 66,
           S: this,
           C: (f, a) => f(...a)
@@ -3469,10 +3621,10 @@ var LibDataChannelTransport = class {
               }
             });
           } catch (err) {
-            import_log14.log.warn("signaling errror", {
+            import_log15.log.warn("signaling errror", {
               err
             }, {
-              F: __dxlog_file13,
+              F: __dxlog_file14,
               L: 83,
               S: this,
               C: (f, a) => f(...a)
@@ -3483,20 +3635,20 @@ var LibDataChannelTransport = class {
       if (params.initiator) {
         peer.createOffer().then(async (offer) => {
           if (peer.connectionState !== "connecting") {
-            import_log14.log.error("i am initiator but peer not in state connecting", {
+            import_log15.log.error("i am initiator but peer not in state connecting", {
               peer
             }, {
-              F: __dxlog_file13,
+              F: __dxlog_file14,
               L: 92,
               S: this,
               C: (f, a) => f(...a)
             });
             this.errors.raise(new Error("invalid state: peer is initiator, but other peer not in state connecting"));
           }
-          import_log14.log.debug(`im the initiator, creating offer, peer is in state ${peer.connectionState}`, {
+          import_log15.log.debug(`im the initiator, creating offer, peer is in state ${peer.connectionState}`, {
             offer
           }, {
-            F: __dxlog_file13,
+            F: __dxlog_file14,
             L: 95,
             S: this,
             C: (f, a) => f(...a)
@@ -3515,8 +3667,8 @@ var LibDataChannelTransport = class {
           this.errors.raise(err);
         });
         this.handleChannel(peer.createDataChannel(DATACHANNEL_LABEL));
-        import_log14.log.debug("created data channel", void 0, {
-          F: __dxlog_file13,
+        import_log15.log.debug("created data channel", void 0, {
+          F: __dxlog_file14,
           L: 104,
           S: this,
           C: (f, a) => f(...a)
@@ -3526,10 +3678,10 @@ var LibDataChannelTransport = class {
         };
       } else {
         peer.ondatachannel = (event) => {
-          import_log14.log.debug("peer.ondatachannel (non-initiator)", {
+          import_log15.log.debug("peer.ondatachannel (non-initiator)", {
             event
           }, {
-            F: __dxlog_file13,
+            F: __dxlog_file14,
             L: 110,
             S: this,
             C: (f, a) => f(...a)
@@ -3546,8 +3698,8 @@ var LibDataChannelTransport = class {
   handleChannel(dataChannel) {
     this._channel = dataChannel;
     this._channel.onopen = () => {
-      import_log14.log.debug("dataChannel.onopen", void 0, {
-        F: __dxlog_file13,
+      import_log15.log.debug("dataChannel.onopen", void 0, {
+        F: __dxlog_file14,
         L: 126,
         S: this,
         C: (f, a) => f(...a)
@@ -3562,8 +3714,8 @@ var LibDataChannelTransport = class {
           dataChannel.send(chunk);
           if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
             if (this._writeCallback !== null) {
-              import_log14.log.error("consumer trying to write before we're ready for more data", void 0, {
-                F: __dxlog_file13,
+              import_log15.log.error("consumer trying to write before we're ready for more data", void 0, {
+                F: __dxlog_file14,
                 L: 139,
                 S: this,
                 C: (f, a) => f(...a)
@@ -3585,10 +3737,10 @@ var LibDataChannelTransport = class {
       await this._close();
     };
     this._channel.onclose = async (err) => {
-      import_log14.log.info("channel onclose", {
+      import_log15.log.info("channel onclose", {
         err
       }, {
-        F: __dxlog_file13,
+        F: __dxlog_file14,
         L: 159,
         S: this,
         C: (f, a) => f(...a)
@@ -3622,10 +3774,10 @@ var LibDataChannelTransport = class {
       switch (data.type) {
         case "offer": {
           if ((await this._peer).connectionState !== "new") {
-            import_log14.log.error("received offer but peer not in state new", {
+            import_log15.log.error("received offer but peer not in state new", {
               peer
             }, {
-              F: __dxlog_file13,
+              F: __dxlog_file14,
               L: 194,
               S: this,
               C: (f, a) => f(...a)
@@ -3650,10 +3802,10 @@ var LibDataChannelTransport = class {
             });
             this._readyForCandidates.wake();
           } catch (err) {
-            import_log14.log.error("can't handle offer from signalling server", {
+            import_log15.log.error("can't handle offer from signalling server", {
               err
             }, {
-              F: __dxlog_file13,
+              F: __dxlog_file14,
               L: 205,
               S: this,
               C: (f, a) => f(...a)
@@ -3670,10 +3822,10 @@ var LibDataChannelTransport = class {
             });
             this._readyForCandidates.wake();
           } catch (err) {
-            import_log14.log.error("can't handle answer from signalling server", {
+            import_log15.log.error("can't handle answer from signalling server", {
               err
             }, {
-              F: __dxlog_file13,
+              F: __dxlog_file14,
               L: 216,
               S: this,
               C: (f, a) => f(...a)
@@ -3688,11 +3840,11 @@ var LibDataChannelTransport = class {
           });
           break;
         default:
-          import_log14.log.error("unhandled signal type", {
+          import_log15.log.error("unhandled signal type", {
             type: data.type,
             signal
           }, {
-            F: __dxlog_file13,
+            F: __dxlog_file14,
             L: 227,
             S: this,
             C: (f, a) => f(...a)
@@ -3700,8 +3852,8 @@ var LibDataChannelTransport = class {
           this.errors.raise(new Error(`unhandled signal type ${data.type}`));
       }
     }).catch((err) => {
-      import_log14.log.catch(err, void 0, {
-        F: __dxlog_file13,
+      import_log15.log.catch(err, void 0, {
+        F: __dxlog_file14,
         L: 232,
         S: this,
         C: (f, a) => f(...a)
@@ -3717,7 +3869,7 @@ var LibDataChannelTransport = class {
   }
 };
 _ts_decorate5([
-  import_async11.synchronized
+  import_async12.synchronized
 ], LibDataChannelTransport.prototype, "_close", null);
 var createLibDataChannelTransportFactory = (webrtcConfig) => ({
   createTransport: (params) => new LibDataChannelTransport({
@@ -3728,10 +3880,10 @@ var createLibDataChannelTransportFactory = (webrtcConfig) => ({
 
 // packages/core/mesh/network-manager/src/transport/tcp-transport.ts
 var import_node_net = require("node:net");
-var import_async12 = require("@dxos/async");
+var import_async13 = require("@dxos/async");
 var import_debug8 = require("@dxos/debug");
-var import_log15 = require("@dxos/log");
-var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/tcp-transport.ts";
+var import_log16 = require("@dxos/log");
+var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/tcp-transport.ts";
 var TcpTransportFactory = {
   createTransport: (params) => new TcpTransport(params)
 };
@@ -3740,13 +3892,13 @@ var TcpTransport = class {
     this.options = options;
     this._server = void 0;
     this._socket = void 0;
-    this.closed = new import_async12.Event();
-    this.connected = new import_async12.Event();
+    this.closed = new import_async13.Event();
+    this.connected = new import_async13.Event();
     this.errors = new import_debug8.ErrorStream();
     this._destroyed = false;
     this._connected = false;
-    (0, import_log15.log)("creating", void 0, {
-      F: __dxlog_file14,
+    (0, import_log16.log)("creating", void 0, {
+      F: __dxlog_file15,
       L: 34,
       S: this,
       C: (f, a) => f(...a)
@@ -3755,8 +3907,8 @@ var TcpTransport = class {
       setTimeout(async () => {
         const { Server } = await import("node:net");
         this._server = new Server((socket) => {
-          (0, import_log15.log)("new connection", void 0, {
-            F: __dxlog_file14,
+          (0, import_log16.log)("new connection", void 0, {
+            F: __dxlog_file15,
             L: 42,
             S: this,
             C: (f, a) => f(...a)
@@ -3768,10 +3920,10 @@ var TcpTransport = class {
         });
         this._server.on("listening", () => {
           const { port: port2 } = this._server.address();
-          (0, import_log15.log)("listening", {
+          (0, import_log16.log)("listening", {
             port: port2
           }, {
-            F: __dxlog_file14,
+            F: __dxlog_file15,
             L: 51,
             S: this,
             C: (f, a) => f(...a)
@@ -3794,8 +3946,8 @@ var TcpTransport = class {
     }
   }
   async destroy() {
-    (0, import_log15.log)("closing", void 0, {
-      F: __dxlog_file14,
+    (0, import_log16.log)("closing", void 0, {
+      F: __dxlog_file15,
       L: 72,
       S: this,
       C: (f, a) => f(...a)
@@ -3805,10 +3957,10 @@ var TcpTransport = class {
     this._destroyed = true;
   }
   signal({ payload }) {
-    (0, import_log15.log)("received signal", {
+    (0, import_log16.log)("received signal", {
       payload
     }, {
-      F: __dxlog_file14,
+      F: __dxlog_file15,
       L: 80,
       S: this,
       C: (f, a) => f(...a)
@@ -3824,11 +3976,11 @@ var TcpTransport = class {
     });
   }
   _handleSocket(socket) {
-    (0, import_log15.log)("handling socket", {
+    (0, import_log16.log)("handling socket", {
       remotePort: socket.remotePort,
       localPort: socket.localPort
     }, {
-      F: __dxlog_file14,
+      F: __dxlog_file15,
       L: 91,
       S: this,
       C: (f, a) => f(...a)
@@ -3837,10 +3989,10 @@ var TcpTransport = class {
     this.connected.emit();
     this.options.stream.pipe(this._socket).pipe(this.options.stream);
     this._socket.on("connect", () => {
-      (0, import_log15.log)("connected to", {
+      (0, import_log16.log)("connected to", {
         port: this._socket?.remotePort
       }, {
-        F: __dxlog_file14,
+        F: __dxlog_file15,
         L: 97,
         S: this,
         C: (f, a) => f(...a)
@@ -3856,118 +4008,6 @@ var TcpTransport = class {
   }
 };
 
-// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
-var import_async13 = require("@dxos/async");
-var import_keys13 = require("@dxos/keys");
-var import_log16 = require("@dxos/log");
-var import_teleport2 = require("@dxos/teleport");
-var import_util10 = require("@dxos/util");
-
-// packages/core/mesh/network-manager/src/wire-protocol.ts
-var import_teleport = require("@dxos/teleport");
-var createTeleportProtocolFactory = (onConnection) => {
-  return (params) => {
-    const teleport = new import_teleport.Teleport(params);
-    return {
-      stream: teleport.stream,
-      open: async () => {
-        await teleport.open();
-        await onConnection(teleport);
-      },
-      close: async () => {
-        await teleport.close();
-      },
-      abort: async () => {
-        await teleport.abort();
-      }
-    };
-  };
-};
-
-// packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts
-var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-wire-protocol.ts";
-var TestWireProtocol = class {
-  constructor(peerId, _extensionFactory = () => []) {
-    this.peerId = peerId;
-    this._extensionFactory = _extensionFactory;
-    this.connections = new import_util10.ComplexMap(import_keys13.PublicKey.hash);
-    this.streamConnections = new import_util10.ComplexMap(import_keys13.PublicKey.hash);
-    this.connected = new import_async13.Event();
-    this.disconnected = new import_async13.Event();
-    this.otherConnections = new import_util10.ComplexMap(({ remotePeerId, extension }) => remotePeerId.toHex() + extension);
-    this.factory = createTeleportProtocolFactory(async (teleport) => {
-      (0, import_log16.log)("create", {
-        remotePeerId: teleport.remotePeerId
-      }, {
-        F: __dxlog_file15,
-        L: 38,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const extension = new import_teleport2.TestExtension({
-        onClose: async () => {
-          this.connections.delete(teleport.remotePeerId);
-          this.disconnected.emit(teleport.remotePeerId);
-        }
-      });
-      this.connections.set(teleport.remotePeerId, extension);
-      teleport.addExtension("test", extension);
-      this.connected.emit(teleport.remotePeerId);
-      const streamExtension = new import_teleport2.TestExtensionWithStreams({
-        onClose: async () => {
-          this.streamConnections.delete(teleport.remotePeerId);
-        }
-      });
-      this.streamConnections.set(teleport.remotePeerId, streamExtension);
-      teleport.addExtension("test-stream", streamExtension);
-      for (const { name, extension: extension2 } of this._extensionFactory()) {
-        this.otherConnections.set({
-          remotePeerId: teleport.remotePeerId,
-          extension: name
-        }, extension2);
-        teleport.addExtension(name, extension2);
-      }
-    });
-  }
-  async waitForConnection(peerId) {
-    if (this.connections.has(peerId)) {
-      return this.connections.get(peerId);
-    }
-    (0, import_log16.log)("waitForConnection", {
-      peerId
-    }, {
-      F: __dxlog_file15,
-      L: 67,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await (0, import_async13.asyncTimeout)(
-      this.connected.waitFor((connectedId) => connectedId.equals(peerId)),
-      // TODO(nf): Make this configurable.
-      1e4
-    );
-    return this.connections.get(peerId);
-  }
-  async testConnection(peerId, message) {
-    const connection = await this.waitForConnection(peerId);
-    await connection.test(message);
-  }
-  async openStream(peerId, streamTag, streamLoadInterval, streamLoadChunkSize) {
-    if (!this.streamConnections.has(peerId)) {
-      throw new Error("Connection does not exist.");
-    }
-    const connection = this.streamConnections.get(peerId);
-    return connection.addNewStream(streamLoadInterval, streamLoadChunkSize, streamTag);
-  }
-  async closeStream(peerId, streamTag) {
-    if (!this.streamConnections.has(peerId)) {
-      throw new Error("Connection does not exist.");
-    }
-    const connection = this.streamConnections.get(peerId);
-    return connection.closeStream(streamTag);
-  }
-};
-
 // packages/core/mesh/network-manager/src/testing/test-builder.ts
 var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/testing/test-builder.ts";
 var port = process.env.SIGNAL_PORT ?? 4e3;
@@ -4035,7 +4075,7 @@ var TestPeer = class {
             this._proxy = (0, import_rpc.createProtoRpcPeer)({
               port: proxyPort,
               requested: {
-                BridgeService: import_protocols6.schema.getService("dxos.mesh.bridge.BridgeService")
+                BridgeService: import_protocols9.schema.getService("dxos.mesh.bridge.BridgeService")
               },
               noHandshake: true,
               encodingOptions: {
@@ -4045,7 +4085,7 @@ var TestPeer = class {
             this._service = (0, import_rpc.createProtoRpcPeer)({
               port: servicePort,
               exposed: {
-                BridgeService: import_protocols6.schema.getService("dxos.mesh.bridge.BridgeService")
+                BridgeService: import_protocols9.schema.getService("dxos.mesh.bridge.BridgeService")
               },
               handlers: {
                 BridgeService: new SimplePeerTransportService()