@dxos/network-manager 0.6.12-staging.e11e696 → 0.6.12

package/dist/lib/browser/{chunk-YOKKEU6T.mjs → chunk-XYSYUN63.mjs}

@@ -1,7 +1,17 @@
 import "@dxos/node-std/globals";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// inject-globals:@inject-globals
 import {
-  Buffer
-} from "./chunk-GW3YM55A.mjs";
+  global,
+  Buffer as Buffer2,
+  process
+} from "@dxos/node-std/inject-globals";
 
 // packages/core/mesh/network-manager/src/swarm/connection.ts
 import { DeferredTask, Event, sleep, scheduleTask, scheduleTaskInterval, synchronized, Trigger } from "@dxos/async";
@@ -10,7 +20,7 @@ import { ErrorStream } from "@dxos/debug";
 import { invariant } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
 import { log, logInfo } from "@dxos/log";
-import { CancelledError, ProtocolError, ConnectionResetError, ConnectivityError, TimeoutError, trace } from "@dxos/protocols";
+import { CancelledError, ProtocolError, ConnectionResetError, ConnectivityError, TimeoutError, UnknownProtocolError, trace } from "@dxos/protocols";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -46,11 +56,11 @@ var Connection = class {
     this._callbacks = _callbacks;
     this._ctx = new Context(void 0, {
       F: __dxlog_file,
-      L: 100
+      L: 101
     });
     this.connectedTimeoutContext = new Context(void 0, {
       F: __dxlog_file,
-      L: 101
+      L: 102
     });
     this._protocolClosed = new Trigger();
     this._transportClosed = new Trigger();
@@ -73,7 +83,7 @@ var Connection = class {
       initiator: this.initiator
     }, {
       F: __dxlog_file,
-      L: 137,
+      L: 138,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -96,7 +106,7 @@ var Connection = class {
   async openConnection() {
     invariant(this._state === "INITIAL", "Invalid state.", {
       F: __dxlog_file,
-      L: 167,
+      L: 168,
       S: this,
       A: [
         "this._state === ConnectionState.INITIAL",
@@ -107,7 +117,7 @@ var Connection = class {
       id: this._instanceId
     }), {
       F: __dxlog_file,
-      L: 168,
+      L: 169,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -119,7 +129,7 @@ var Connection = class {
       initiator: this.initiator
     }, {
       F: __dxlog_file,
-      L: 169,
+      L: 170,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -130,7 +140,7 @@ var Connection = class {
     this._protocol.stream.on("close", () => {
       log("protocol stream closed", void 0, {
         F: __dxlog_file,
-        L: 186,
+        L: 187,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -140,7 +150,7 @@ var Connection = class {
     scheduleTask(this.connectedTimeoutContext, async () => {
       log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, {
         F: __dxlog_file,
-        L: 194,
+        L: 195,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -148,7 +158,7 @@ var Connection = class {
     }, TRANSPORT_CONNECTION_TIMEOUT);
     invariant(!this._transport, void 0, {
       F: __dxlog_file,
-      L: 202,
+      L: 203,
       S: this,
       A: [
         "!this._transport",
@@ -156,14 +166,12 @@ var Connection = class {
       ]
     });
     this._transport = this._transportFactory.createTransport({
-      ownPeerKey: this.localInfo.peerKey,
-      remotePeerKey: this.remoteInfo.peerKey,
-      topic: this.topic.toHex(),
       initiator: this.initiator,
       stream: this._protocol.stream,
       sendSignal: async (signal) => this._sendSignal(signal),
       sessionId: this.sessionId
     });
+    await this._transport.open();
     this._transport.connected.once(async () => {
       this._changeState("CONNECTED");
       await this.connectedTimeoutContext.dispose();
@@ -209,13 +217,21 @@ var Connection = class {
           C: (f, a) => f(...a)
         });
         this.abort().catch((err2) => this.errors.raise(err2));
+      } else if (err instanceof UnknownProtocolError) {
+        log.warn("unsure what to do with UnknownProtocolError, will keep on truckin", {
+          err
+        }, {
+          F: __dxlog_file,
+          L: 242,
+          S: this,
+          C: (f, a) => f(...a)
+        });
       }
       if (this._state !== "CLOSED" && this._state !== "CLOSING") {
         await this.connectedTimeoutContext.dispose();
         this.errors.raise(err);
       }
     });
-    await this._transport.open();
     for (const signal of this._incomingSignalBuffer) {
       void this._transport.onSignal(signal);
     }
@@ -2614,7 +2630,7 @@ var sortByXorDistance = (keys, reference) => {
 };
 var distXor = (a, b) => {
   const maxLength = Math.max(a.length, b.length);
-  const result = Buffer.allocUnsafe(maxLength);
+  const result = Buffer2.allocUnsafe(maxLength);
   for (let i = 0; i < maxLength; i++) {
     result[i] = (a[i] || 0) ^ (b[i] || 0);
   }
@@ -2849,12 +2865,11 @@ var MemoryTransport = class _MemoryTransport {
         this.errors.raise(err);
       });
     }
-    return this;
   }
   async close() {
     log11("closing...", void 0, {
       F: __dxlog_file12,
-      L: 130,
+      L: 129,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2875,18 +2890,17 @@ var MemoryTransport = class _MemoryTransport {
     this.closed.emit();
     log11("closed", void 0, {
       F: __dxlog_file12,
-      L: 158,
+      L: 157,
       S: this,
       C: (f, a) => f(...a)
     });
-    return this;
   }
   async onSignal({ payload }) {
     log11("received signal", {
       payload
     }, {
       F: __dxlog_file12,
-      L: 163,
+      L: 161,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2922,1018 +2936,550 @@ var toError = (err) => err instanceof Error ? err : new Error(String(err));
 // packages/core/mesh/network-manager/src/transport/transport.ts
 var TransportKind;
 (function(TransportKind2) {
-  TransportKind2["WEB_RTC"] = "WEB-RTC";
-  TransportKind2["WEB_RTC_PROXY"] = "WEB-RTC_PROXY";
+  TransportKind2["SIMPLE_PEER"] = "SIMPLE_PEER";
+  TransportKind2["SIMPLE_PEER_PROXY"] = "SIMPLE_PEER_PROXY";
+  TransportKind2["LIBDATACHANNEL"] = "LIBDATACHANNEL";
   TransportKind2["MEMORY"] = "MEMORY";
   TransportKind2["TCP"] = "TCP";
 })(TransportKind || (TransportKind = {}));
 
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-connection-factory.ts
-import { Mutex } from "@dxos/async";
-var BrowserRtcConnectionFactory = class {
-  async initialize() {
-  }
-  async onConnectionDestroyed() {
-  }
-  async createConnection(config) {
-    return new RTCPeerConnection(config);
-  }
-  async initConnection(connection, info) {
-  }
-};
-var NodeRtcConnectionFactory = class _NodeRtcConnectionFactory {
-  static {
-    this._createdConnections = 0;
-  }
-  static {
-    this._cleanupMutex = new Mutex();
-  }
-  // This should be inside the function to avoid triggering `eval` in the global scope.
-  // eslint-disable-next-line no-new-func
-  // TODO(burdon): Do imports here?
-  async initialize() {
-  }
-  async onConnectionDestroyed() {
-    return _NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
-      if (--_NodeRtcConnectionFactory._createdConnections === 0) {
-        (await import("#node-datachannel")).cleanup();
-      }
-    });
-  }
-  async createConnection(config) {
-    return _NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
-      const { RTCPeerConnection: RTCPeerConnection1 } = await import("#node-datachannel/polyfill");
-      _NodeRtcConnectionFactory._createdConnections++;
-      return new RTCPeerConnection1(config);
-    });
-  }
-  async initConnection(connection, info) {
-    if (info.initiator) {
-      connection.onnegotiationneeded?.(null);
-    }
-  }
-};
-var getRtcConnectionFactory = () => {
-  return typeof globalThis.RTCPeerConnection === "undefined" ? new NodeRtcConnectionFactory() : new BrowserRtcConnectionFactory();
-};
-
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts
-import { synchronized as synchronized5, Trigger as Trigger3, Mutex as Mutex2 } from "@dxos/async";
-import { invariant as invariant12 } from "@dxos/invariant";
-import { log as log13, logInfo as logInfo4 } from "@dxos/log";
-import { ConnectivityError as ConnectivityError3 } from "@dxos/protocols";
-import { trace as trace4 } from "@dxos/tracing";
-
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts
-import { Duplex } from "@dxos/node-std/stream";
-import { Event as AsyncEvent } from "@dxos/async";
-import { Resource } from "@dxos/context";
-import { ErrorStream as ErrorStream4 } from "@dxos/debug";
-import { invariant as invariant11 } from "@dxos/invariant";
+// packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
+import SimplePeerConstructor from "simple-peer";
+import invariant11 from "tiny-invariant";
+import { Event as Event8, synchronized as synchronized5 } from "@dxos/async";
+import { ErrorStream as ErrorStream4, raise as raise2 } from "@dxos/debug";
+import { PublicKey as PublicKey10 } from "@dxos/keys";
 import { log as log12 } from "@dxos/log";
-import { ConnectivityError as ConnectivityError2 } from "@dxos/protocols";
+import { ConnectionResetError as ConnectionResetError2, ConnectivityError as ConnectivityError2, ProtocolError as ProtocolError2, UnknownProtocolError as UnknownProtocolError2, trace as trace4 } from "@dxos/protocols";
+
+// packages/core/mesh/network-manager/src/transport/webrtc.ts
+var wrtc = null;
+try {
+  wrtc = __require("@koush/wrtc");
+} catch {
+}
 
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-stats.ts
-var describeSelectedRemoteCandidate = async (connection) => {
-  const stats = connection && await getRtcConnectionStats(connection);
-  const rc = stats?.remoteCandidate;
-  if (!rc) {
-    return "unavailable";
+// packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts";
+var createSimplePeerTransportFactory = (webrtcConfig, iceProvider) => ({
+  createTransport: (options) => new SimplePeerTransport({
+    ...options,
+    webrtcConfig,
+    iceProvider
+  })
+});
+var SimplePeerTransport = class {
+  get isOpen() {
+    return this._piped && !this._closed;
   }
-  if (rc.candidateType === "relay") {
-    return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+  /**
+  * @params opts.config formatted as per https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection
+  */
+  constructor(_params) {
+    this._params = _params;
+    this._peer = void 0;
+    this._closed = false;
+    this._piped = false;
+    this.closed = new Event8();
+    this.connected = new Event8();
+    this.errors = new ErrorStream4();
+    this._instanceId = PublicKey10.random().toHex();
   }
-  return `${rc.ip}:${rc.port} ${rc.candidateType}`;
-};
-var createRtcTransportStats = async (connection, topic) => {
-  const stats = connection && await getRtcConnectionStats(connection, topic);
-  if (!stats) {
+  async getStats() {
+    const stats = await this._getStats();
+    if (!stats) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: {}
+      };
+    }
     return {
-      bytesSent: 0,
-      bytesReceived: 0,
-      packetsSent: 0,
-      packetsReceived: 0,
-      rawStats: {}
+      bytesSent: stats.transport.bytesSent,
+      bytesReceived: stats.transport.bytesReceived,
+      packetsSent: stats.transport.packetsSent,
+      packetsReceived: stats.transport.packetsReceived,
+      rawStats: stats.raw
     };
   }
-  return {
-    bytesSent: stats.dataChannel?.bytesSent,
-    bytesReceived: stats.dataChannel?.bytesReceived,
-    packetsSent: 0,
-    packetsReceived: 0,
-    rawStats: stats.raw
-  };
-};
-var getRtcConnectionStats = async (connection, channelTopic) => {
-  const stats = await connection.getStats();
-  const statsEntries = Array.from(stats.entries());
-  const transport = statsEntries.find(([_, entry]) => entry.type === "transport")?.[1];
-  const selectedCandidatePair = transport && statsEntries.find(([entryId]) => entryId === transport.selectedCandidatePairId)?.[1];
-  const remoteCandidate = selectedCandidatePair && statsEntries.find(([entryId]) => entryId === selectedCandidatePair.remoteCandidateId)?.[1];
-  const dataChannel = channelTopic && statsEntries.find(([_, entry]) => entry.type === "data-channel" && entry.label === channelTopic)?.[1];
-  return {
-    transport,
-    selectedCandidatePair,
-    dataChannel,
-    remoteCandidate,
-    raw: Object.fromEntries(stats)
-  };
-};
-
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts
-var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts";
-var MAX_MESSAGE_SIZE = 64 * 1024;
-var MAX_BUFFERED_AMOUNT = 64 * 1024;
-var RtcTransportChannel = class extends Resource {
-  constructor(_connection, _options) {
-    super();
-    this._connection = _connection;
-    this._options = _options;
-    this.closed = new AsyncEvent();
-    this.connected = new AsyncEvent();
-    this.errors = new ErrorStream4();
-    this._streamDataFlushedCallback = null;
-    this._isChannelCreationInProgress = false;
-  }
-  get isRtcChannelCreationInProgress() {
-    return this._isChannelCreationInProgress;
+  async _getStats() {
+    if (typeof this._peer?._pc?.getStats !== "function") {
+      return null;
+    }
+    return await this._peer._pc.getStats().then((stats) => {
+      const statsEntries = Array.from(stats.entries());
+      const transport = statsEntries.filter((s) => s[1].type === "transport")[0][1];
+      const candidatePair = statsEntries.filter((s) => s[0] === transport.selectedCandidatePairId);
+      let selectedCandidatePair;
+      let remoteCandidate;
+      if (candidatePair.length > 0) {
+        selectedCandidatePair = candidatePair[0][1];
+        remoteCandidate = statsEntries.filter((s) => s[0] === selectedCandidatePair.remoteCandidateId)[0][1];
+      }
+      return {
+        datachannel: statsEntries.filter((s) => s[1].type === "data-channel")[0][1],
+        transport,
+        selectedCandidatePair,
+        remoteCandidate,
+        raw: Object.fromEntries(stats.entries())
+      };
+    });
   }
-  onConnectionError(error) {
-    if (this.isOpen) {
-      this.errors.raise(error);
+  async getDetails() {
+    const stats = await this._getStats();
+    const rc = stats?.remoteCandidate;
+    if (!rc) {
+      return "unavailable";
     }
+    if (rc.candidateType === "relay") {
+      return `${rc.ip}:${rc.port}/${rc.protocol} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+    }
+    return `${rc.ip}:${rc.port}/${rc.protocol} ${rc.candidateType}`;
   }
-  async _open() {
-    invariant11(!this._isChannelCreationInProgress, void 0, {
+  async open() {
+    log12.trace("dxos.mesh.webrtc-transport.open", trace4.begin({
+      id: this._instanceId
+    }), {
       F: __dxlog_file13,
-      L: 56,
+      L: 122,
       S: this,
-      A: [
-        "!this._isChannelCreationInProgress",
-        ""
-      ]
-    });
-    this._isChannelCreationInProgress = true;
-    this._connection.createDataChannel(this._options.topic).then((channel) => {
-      if (this.isOpen) {
-        this._channel = channel;
-        this._initChannel(this._channel);
-      } else {
-        this._safeCloseChannel(channel);
-      }
-    }).catch((err) => {
-      if (this.isOpen) {
-        this.errors.raise(new ConnectivityError2(`Failed to create a channel: ${err?.message ?? "unknown reason."}`));
-      }
-    }).finally(() => {
-      this._isChannelCreationInProgress = false;
+      C: (f, a) => f(...a)
     });
-  }
-  async _close() {
-    if (this._channel) {
-      this._safeCloseChannel(this._channel);
-      this._channel = void 0;
-      this._stream = void 0;
-    }
-    this.closed.emit();
-    log12("closed", void 0, {
+    log12("created connection", {
+      params: this._params
+    }, {
       F: __dxlog_file13,
-      L: 86,
+      L: 123,
       S: this,
       C: (f, a) => f(...a)
     });
-  }
-  _initChannel(channel) {
-    Object.assign(channel, {
-      onopen: () => {
-        if (!this.isOpen) {
-          log12.warn("channel opened in a closed transport", {
-            topic: this._options.topic
+    const providedIceServers = await this._params.iceProvider?.getIceServers();
+    if (!this._params.webrtcConfig) {
+      this._params.webrtcConfig = {};
+    }
+    this._params.webrtcConfig.iceServers = [
+      ...this._params.webrtcConfig.iceServers ?? [],
+      ...providedIceServers ?? []
+    ];
+    this._peer = new SimplePeerConstructor({
+      channelName: "dxos.mesh.transport",
+      initiator: this._params.initiator,
+      wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? void 0 : wrtc ?? raise2(new Error("wrtc not available")),
+      config: this._params.webrtcConfig
+    });
+    this._peer.on("signal", async (data) => {
+      log12("signal", data, {
+        F: __dxlog_file13,
+        L: 142,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this._params.sendSignal({
+        payload: {
+          data
+        }
+      });
+    });
+    this._peer.on("connect", () => {
+      log12("connected", void 0, {
+        F: __dxlog_file13,
+        L: 147,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._params.stream.pipe(this._peer).pipe(this._params.stream);
+      this._piped = true;
+      this.connected.emit();
+    });
+    this._peer.on("close", async () => {
+      log12("closed", void 0, {
+        F: __dxlog_file13,
+        L: 154,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this.close();
+    });
+    this._peer.on("error", async (err) => {
+      if (typeof RTCError !== "undefined" && err instanceof RTCError) {
+        if (err.errorDetail === "sctp-failure") {
+          this.errors.raise(new ConnectionResetError2("sctp-failure from RTCError", err));
+        } else {
+          log12.info("unknown RTCError", {
+            err
           }, {
             F: __dxlog_file13,
-            L: 93,
+            L: 165,
             S: this,
             C: (f, a) => f(...a)
           });
-          this._safeCloseChannel(channel);
-          return;
+          this.errors.raise(new UnknownProtocolError2("unknown RTCError", err));
         }
-        log12("onopen", void 0, {
+      } else if ("code" in err) {
+        log12.info("simple-peer error", err, {
           F: __dxlog_file13,
-          L: 98,
+          L: 170,
           S: this,
           C: (f, a) => f(...a)
         });
-        const duplex = new Duplex({
-          read: () => {
-          },
-          write: (chunk, encoding, callback) => {
-            return this._handleChannelWrite(chunk, callback);
-          }
-        });
-        duplex.pipe(this._options.stream).pipe(duplex);
-        this._stream = duplex;
-        this.connected.emit();
-      },
-      onclose: async () => {
-        log12("onclose", void 0, {
+        switch (err.code) {
+          case "ERR_WEBRTC_SUPPORT":
+            this.errors.raise(new ProtocolError2("WebRTC not supported", err));
+            break;
+          case "ERR_SIGNALING":
+            this.errors.raise(new ConnectivityError2("signaling failure", err));
+            break;
+          case "ERR_ICE_CONNECTION_FAILURE":
+          case "ERR_DATA_CHANNEL":
+          case "ERR_CONNECTION_FAILURE":
+            this.errors.raise(new ConnectivityError2("unknown communication failure", err));
+            break;
+          // errors due to library issues or improper API usage
+          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 UnknownProtocolError2("unknown simple-peer library failure", err));
+            break;
+          default:
+            this.errors.raise(new Error("unknown simple-peer error"));
+            break;
+        }
+      } else {
+        log12.info("unknown peer connection error", err, {
           F: __dxlog_file13,
-          L: 111,
+          L: 196,
           S: this,
           C: (f, a) => f(...a)
         });
-        await this.close();
-      },
-      onmessage: (event) => {
-        if (!this._stream) {
-          log12.warn("ignoring message on a closed channel", void 0, {
-            F: __dxlog_file13,
-            L: 117,
-            S: this,
-            C: (f, a) => f(...a)
+        this.errors.raise(err);
+      }
+      try {
+        if (typeof this._peer?._pc?.getStats === "function") {
+          this._peer._pc.getStats().then((stats) => {
+            log12.info("report after webrtc error", {
+              config: this._params.webrtcConfig,
+              stats: Object.fromEntries(stats.entries())
+            }, {
+              F: __dxlog_file13,
+              L: 204,
+              S: this,
+              C: (f, a) => f(...a)
+            });
           });
-          return;
         }
-        let data = event.data;
-        if (data instanceof ArrayBuffer) {
-          data = Buffer.from(data);
-        }
-        this._stream.push(data);
-      },
-      onerror: (event) => {
-        if (this.isOpen) {
-          const err = event.error instanceof Error ? event.error : new Error(`Datachannel error: ${event.type}.`);
-          this.errors.raise(err);
-        }
-      },
-      onbufferedamountlow: () => {
-        const cb = this._streamDataFlushedCallback;
-        this._streamDataFlushedCallback = null;
-        cb?.();
-      }
-    });
-  }
-  async _handleChannelWrite(chunk, callback) {
-    if (!this._channel) {
-      log12.warn("writing to a channel after a connection was closed", void 0, {
-        F: __dxlog_file13,
-        L: 145,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    if (chunk.length > MAX_MESSAGE_SIZE) {
-      const error = new Error(`Message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}.`);
-      this.errors.raise(error);
-      callback();
-      return;
-    }
-    try {
-      this._channel.send(chunk);
-    } catch (err) {
-      this.errors.raise(err);
-      callback();
-      return;
-    }
-    if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
-      if (this._streamDataFlushedCallback !== null) {
-        log12.error("consumer trying to write before we are ready for more data", void 0, {
+      } catch (err2) {
+        log12.catch(err2, void 0, {
           F: __dxlog_file13,
-          L: 166,
+          L: 211,
           S: this,
           C: (f, a) => f(...a)
         });
       }
-      this._streamDataFlushedCallback = callback;
-    } else {
-      callback();
-    }
+      await this.close();
+    });
+    log12.trace("dxos.mesh.webrtc-transport.open", trace4.end({
+      id: this._instanceId
+    }), {
+      F: __dxlog_file13,
+      L: 217,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
-  _safeCloseChannel(channel) {
-    try {
-      channel.close();
-    } catch (error) {
-      log12.catch(error, void 0, {
-        F: __dxlog_file13,
-        L: 178,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+  async close() {
+    log12("closing...", void 0, {
+      F: __dxlog_file13,
+      L: 222,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._closed) {
+      return;
     }
+    this._disconnectStreams();
+    this._peer.destroy();
+    this._closed = true;
+    this.closed.emit();
+    log12("closed", void 0, {
+      F: __dxlog_file13,
+      L: 230,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
-  onSignal(signal) {
-    return this._connection.onSignal(signal);
-  }
-  async getDetails() {
-    return describeSelectedRemoteCandidate(this._connection.currentConnection);
-  }
-  async getStats() {
-    return createRtcTransportStats(this._connection.currentConnection, this._options.topic);
-  }
-};
-
-// packages/core/mesh/network-manager/src/transport/webrtc/utils.ts
-var chooseInitiatorPeer = (peer1Key, peer2Key) => peer1Key < peer2Key ? peer1Key : peer2Key;
-var areSdpEqual = (sdp1, sdp2) => {
-  const sdp1Lines = deduplicatedSdpLines(sdp1);
-  const sdp2Lines = deduplicatedSdpLines(sdp2);
-  if (sdp1Lines.length !== sdp2Lines.length) {
-    return false;
-  }
-  return sdp1Lines.every((line, idx) => line === sdp2Lines[idx]);
-};
-var deduplicatedSdpLines = (sdp) => {
-  const deduplicatedLines = [];
-  const seenLines = [];
-  for (const line of sdp.split("\r\n")) {
-    if (line.startsWith("m")) {
-      seenLines.length = 0;
+  async onSignal(signal) {
+    if (this._closed) {
+      return;
     }
-    if (seenLines.includes(line)) {
-      continue;
+    invariant11(signal.payload.data, "Signal message must contain signal data.");
+    invariant11(this._peer, "Peer must be initialized before receiving signals.");
+    this._peer.signal(signal.payload.data);
+  }
+  _disconnectStreams() {
+    if (this._piped) {
+      this._params.stream.unpipe?.(this._peer)?.unpipe?.(this._params.stream);
     }
-    seenLines.push(line);
-    deduplicatedLines.push(line);
   }
-  return deduplicatedLines;
 };
+_ts_decorate6([
+  synchronized5
+], SimplePeerTransport.prototype, "open", null);
+_ts_decorate6([
+  synchronized5
+], SimplePeerTransport.prototype, "close", null);
+_ts_decorate6([
+  synchronized5
+], SimplePeerTransport.prototype, "onSignal", null);
 
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts
-function _ts_decorate6(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
-var RtcPeerConnection = class {
-  constructor(_factory, _options) {
-    this._factory = _factory;
-    this._options = _options;
-    this._channelCreatedCallbacks = /* @__PURE__ */ new Map();
-    this._transportChannels = /* @__PURE__ */ new Map();
-    this._dataChannels = /* @__PURE__ */ new Map();
-    this._readyForCandidates = new Trigger3();
-    this._offerProcessingMutex = new Mutex2();
-    this._initiator = chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
-  }
-  get transportChannelCount() {
-    return this._transportChannels.size;
-  }
-  get currentConnection() {
-    return this._connection;
-  }
-  async createDataChannel(topic) {
-    const connection = await this._openConnection();
-    if (!this._transportChannels.has(topic)) {
-      if (!this._transportChannels.size) {
-        this._lockAndCloseConnection();
-      }
-      throw new Error("Transport closed while connection was being open");
-    }
-    if (this._initiator) {
-      const channel = connection.createDataChannel(topic);
-      this._dataChannels.set(topic, channel);
-      return channel;
-    } else {
-      const existingChannel = this._dataChannels.get(topic);
-      if (existingChannel) {
-        return existingChannel;
-      }
-      log13("waiting for initiator-peer to open a data channel", void 0, {
-        F: __dxlog_file14,
-        L: 90,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return new Promise((resolve, reject) => {
-        this._channelCreatedCallbacks.set(topic, {
-          resolve,
-          reject
-        });
-      });
-    }
-  }
-  createTransportChannel(options) {
-    const channel = new RtcTransportChannel(this, options);
-    this._transportChannels.set(options.topic, channel);
-    channel.closed.on(() => {
-      this._transportChannels.delete(options.topic);
-      if (this._transportChannels.size === 0) {
-        this._lockAndCloseConnection();
-      }
-    });
-    return channel;
+// packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts
+import { Duplex } from "@dxos/node-std/stream";
+import { Stream } from "@dxos/codec-protobuf";
+import { invariant as invariant12 } from "@dxos/invariant";
+import { PublicKey as PublicKey11 } from "@dxos/keys";
+import { log as log13 } from "@dxos/log";
+import { ConnectionState as ConnectionState3 } from "@dxos/protocols/proto/dxos/mesh/bridge";
+import { ComplexMap as ComplexMap8 } from "@dxos/util";
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts";
+var SimplePeerTransportService = class {
+  constructor(_webrtcConfig, _iceProvider) {
+    this._webrtcConfig = _webrtcConfig;
+    this._iceProvider = _iceProvider;
+    this.transports = new ComplexMap8(PublicKey11.hash);
   }
-  async _openConnection() {
-    if (this._connection) {
-      return this._connection;
-    }
-    log13("initializing connection...", () => ({
-      remotePeer: this._options.remotePeerKey
-    }), {
-      F: __dxlog_file14,
-      L: 115,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const config = await this._loadConnectionConfig();
-    const connection = await this._factory.createConnection(config);
-    const iceCandidateErrors = [];
-    Object.assign(connection, {
-      onnegotiationneeded: async () => {
-        invariant12(this._initiator, void 0, {
-          F: __dxlog_file14,
-          L: 130,
-          S: this,
-          A: [
-            "this._initiator",
-            ""
-          ]
-        });
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("onnegotiationneeded", connection);
-          return;
-        }
-        log13("onnegotiationneeded", void 0, {
-          F: __dxlog_file14,
-          L: 137,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        try {
-          const offer = await connection.createOffer();
-          await connection.setLocalDescription(offer);
-          await this._sendDescription(connection, offer);
-        } catch (err) {
-          this._lockAndAbort(connection, err);
-        }
-      },
-      // When ICE candidate identified (should be sent to remote peer) and when ICE gathering finalized.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/icecandidate_event
-      onicecandidate: async (event) => {
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("onicecandidate", connection);
-          return;
-        }
-        if (event.candidate) {
-          log13("onicecandidate", {
-            candidate: event.candidate.candidate
-          }, {
-            F: __dxlog_file14,
-            L: 156,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          await this._sendIceCandidate(event.candidate);
-        } else {
-          log13("onicecandidate gathering complete", void 0, {
-            F: __dxlog_file14,
-            L: 159,
-            S: this,
-            C: (f, a) => f(...a)
+  open(request) {
+    const rpcStream = new Stream(({ ready, next, close }) => {
+      const duplex = new Duplex({
+        read: () => {
+          const callbacks = [
+            ...transportState.writeCallbacks
+          ];
+          transportState.writeCallbacks.length = 0;
+          for (const cb of callbacks) {
+            cb();
+          }
+        },
+        write: function(chunk, _, callback) {
+          next({
+            data: {
+              payload: chunk
+            }
           });
+          callback();
         }
-      },
-      // When error occurs while performing ICE negotiations through a STUN or TURN server.
-      // It's ok for some candidates to fail if a working pair is eventually found.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/icecandidateerror_event
-      onicecandidateerror: (event) => {
-        const { url, errorCode, errorText } = event;
-        iceCandidateErrors.push({
-          url,
-          errorCode,
-          errorText
-        });
-      },
-      // When possible error during ICE gathering.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceconnectionstatechange_event
-      oniceconnectionstatechange: () => {
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("oniceconnectionstatechange", connection);
-          return;
-        }
-        log13("oniceconnectionstatechange", {
-          state: connection.iceConnectionState
-        }, {
-          F: __dxlog_file14,
-          L: 179,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (connection.iceConnectionState === "failed") {
-          this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
+      });
+      const transport = new SimplePeerTransport({
+        initiator: request.initiator,
+        stream: duplex,
+        webrtcConfig: this._webrtcConfig,
+        sendSignal: async (signal) => {
+          next({
+            signal: {
+              payload: signal
+            }
+          });
+        },
+        iceProvider: this._iceProvider
+      });
+      void transport.open();
+      next({
+        connection: {
+          state: ConnectionState3.CONNECTING
         }
-      },
-      // When new track (or channel) is added.
-      // State: { new, connecting, connected, disconnected, failed, closed }
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/connectionstatechange_event
-      onconnectionstatechange: () => {
-        if (connection !== this._connection) {
-          if (connection.connectionState !== "closed" && connection.connectionState !== "failed") {
-            this._onConnectionCallbackAfterClose("onconnectionstatechange", connection);
+      });
+      transport.connected.on(() => {
+        next({
+          connection: {
+            state: ConnectionState3.CONNECTED
           }
-          return;
-        }
-        log13("onconnectionstatechange", {
-          state: connection.connectionState
-        }, {
-          F: __dxlog_file14,
-          L: 196,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (connection.connectionState === "failed") {
-          this._lockAndAbort(connection, new Error("Connection failed."));
-        }
-      },
-      onsignalingstatechange: () => {
-        log13("onsignalingstatechange", {
-          state: connection.signalingState
-        }, {
-          F: __dxlog_file14,
-          L: 203,
-          S: this,
-          C: (f, a) => f(...a)
         });
-      },
-      // When channel is added to connection.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event
-      ondatachannel: (event) => {
-        invariant12(!this._initiator, "Initiator is expected to create data channels.", {
-          F: __dxlog_file14,
-          L: 209,
-          S: this,
-          A: [
-            "!this._initiator",
-            "'Initiator is expected to create data channels.'"
-          ]
+      });
+      transport.errors.handle((err) => {
+        next({
+          connection: {
+            state: ConnectionState3.CLOSED,
+            error: err.toString()
+          }
         });
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("ondatachannel", connection);
-          return;
-        }
-        log13("ondatachannel", {
-          label: event.channel.label
-        }, {
-          F: __dxlog_file14,
-          L: 216,
-          S: this,
-          C: (f, a) => f(...a)
+        close(err);
+      });
+      transport.closed.on(() => {
+        next({
+          connection: {
+            state: ConnectionState3.CLOSED
+          }
         });
-        this._dataChannels.set(event.channel.label, event.channel);
-        const pendingCallback = this._channelCreatedCallbacks.get(event.channel.label);
-        if (pendingCallback) {
-          this._channelCreatedCallbacks.delete(event.channel.label);
-          pendingCallback.resolve(event.channel);
-        }
-      }
-    });
-    this._connection = connection;
-    this._readyForCandidates.reset();
-    await this._factory.initConnection(connection, {
-      initiator: this._initiator
+        close();
+      });
+      const transportState = {
+        transport,
+        stream: duplex,
+        writeCallbacks: [],
+        state: "OPEN"
+      };
+      ready();
+      this.transports.set(request.proxyId, transportState);
     });
-    return this._connection;
+    return rpcStream;
   }
-  _lockAndAbort(connection, error) {
-    this._abortConnection(connection, error);
+  async sendSignal({ proxyId, signal }) {
+    invariant12(this.transports.has(proxyId), void 0, {
+      F: __dxlog_file14,
+      L: 124,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    });
+    await this.transports.get(proxyId).transport.onSignal(signal);
   }
-  _abortConnection(connection, error) {
-    if (connection !== this._connection) {
-      log13.error("attempted to abort an inactive connection", {
-        error
-      }, {
-        F: __dxlog_file14,
-        L: 241,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._safeCloseConnection(connection);
-      return;
-    }
-    for (const [topic, pendingCallback] of this._channelCreatedCallbacks.entries()) {
-      pendingCallback.reject(error);
-      this._transportChannels.delete(topic);
-    }
-    this._channelCreatedCallbacks.clear();
-    for (const channel of this._transportChannels.values()) {
-      channel.onConnectionError(error);
-    }
-    this._transportChannels.clear();
-    this._safeCloseConnection();
-    log13("connection aborted", {
-      reason: error.message
-    }, {
+  async getDetails({ proxyId }) {
+    invariant12(this.transports.has(proxyId), void 0, {
       F: __dxlog_file14,
-      L: 255,
+      L: 129,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
     });
+    return {
+      details: await this.transports.get(proxyId).transport.getDetails()
+    };
   }
-  _lockAndCloseConnection() {
-    invariant12(this._transportChannels.size === 0, void 0, {
+  async getStats({ proxyId }) {
+    invariant12(this.transports.has(proxyId), void 0, {
       F: __dxlog_file14,
-      L: 260,
+      L: 134,
       S: this,
       A: [
-        "this._transportChannels.size === 0",
+        "this.transports.has(proxyId)",
         ""
       ]
     });
-    if (this._connection) {
-      this._safeCloseConnection();
-      log13("connection closed", void 0, {
-        F: __dxlog_file14,
-        L: 263,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
+    return {
+      stats: await this.transports.get(proxyId).transport.getStats()
+    };
   }
-  async onSignal(signal) {
-    const connection = this._connection;
-    if (!connection) {
-      log13.warn("a signal ignored because the connection was closed", {
-        type: signal.payload.data.type
-      }, {
+  async sendData({ proxyId, payload }) {
+    if (this.transports.get(proxyId)?.state !== "OPEN") {
+      log13.debug("transport is closed", void 0, {
         F: __dxlog_file14,
-        L: 271,
+        L: 140,
         S: this,
         C: (f, a) => f(...a)
       });
-      return;
-    }
-    const data = signal.payload.data;
-    switch (data.type) {
-      case "offer": {
-        await this._offerProcessingMutex.executeSynchronized(async () => {
-          if (isRemoteDescriptionSet(connection, data)) {
-            return;
-          }
-          if (connection.connectionState !== "new") {
-            this._abortConnection(connection, new Error(`Received an offer in ${connection.connectionState}.`));
-            return;
-          }
-          try {
-            await connection.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            const answer = await connection.createAnswer();
-            await connection.setLocalDescription(answer);
-            await this._sendDescription(connection, answer);
-            this._onSessionNegotiated(connection);
-          } catch (err) {
-            this._abortConnection(connection, new Error("Error handling a remote offer.", {
-              cause: err
-            }));
-          }
-        });
-        break;
-      }
-      case "answer":
-        await this._offerProcessingMutex.executeSynchronized(async () => {
-          try {
-            if (isRemoteDescriptionSet(connection, data)) {
-              return;
-            }
-            if (connection.signalingState !== "have-local-offer") {
-              this._abortConnection(connection, new Error(`Unexpected answer from remote peer, signalingState was ${connection.signalingState}.`));
-              return;
-            }
-            await connection.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            this._onSessionNegotiated(connection);
-          } catch (err) {
-            this._abortConnection(connection, new Error("Error handling a remote answer.", {
-              cause: err
-            }));
-          }
-        });
-        break;
-      case "candidate":
-        void this._processIceCandidate(connection, data.candidate);
-        break;
-      default:
-        this._abortConnection(connection, new Error(`Unknown signal type ${data.type}.`));
-        break;
     }
-    log13("signal processed", void 0, {
+    invariant12(this.transports.has(proxyId), void 0, {
       F: __dxlog_file14,
-      L: 330,
+      L: 142,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
     });
-  }
-  async _processIceCandidate(connection, candidate) {
-    try {
-      await this._readyForCandidates.wait();
-      if (connection === this._connection) {
-        log13("adding ice candidate", {
-          candidate
-        }, {
-          F: __dxlog_file14,
-          L: 338,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await connection.addIceCandidate(candidate);
-      }
-    } catch (err) {
-      log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 342,
-        S: this,
-        C: (f, a) => f(...a)
+    const state = this.transports.get(proxyId);
+    const bufferHasSpace = state.stream.push(payload);
+    if (!bufferHasSpace) {
+      await new Promise((resolve) => {
+        state.writeCallbacks.push(resolve);
       });
     }
   }
-  _onSessionNegotiated(connection) {
-    if (connection === this._connection) {
-      log13("ready to process ice candidates", void 0, {
-        F: __dxlog_file14,
-        L: 348,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._readyForCandidates.wake();
-    } else {
-      log13.warn("session was negotiated after connection became inactive", void 0, {
-        F: __dxlog_file14,
-        L: 351,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+  async close({ proxyId }) {
+    await this.transports.get(proxyId)?.transport.close();
+    await this.transports.get(proxyId)?.stream.end();
+    if (this.transports.get(proxyId)) {
+      this.transports.get(proxyId).state = "CLOSED";
     }
-  }
-  _onConnectionCallbackAfterClose(callback, connection) {
-    log13.warn("callback invoked after a connection was destroyed, this is probably a bug", {
-      callback,
-      state: connection.connectionState
-    }, {
+    log13("Closed.", void 0, {
       F: __dxlog_file14,
-      L: 356,
+      L: 158,
       S: this,
       C: (f, a) => f(...a)
     });
-    this._safeCloseConnection(connection);
   }
-  _safeCloseConnection(connection = this._connection) {
-    const resetFields = this._connection && connection === this._connection;
-    try {
-      connection?.close();
-    } catch (err) {
-      log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 368,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    if (resetFields) {
-      this._connection = void 0;
-      this._dataChannels.clear();
-      this._readyForCandidates.wake();
-      void this._factory.onConnectionDestroyed().catch((err) => log13.catch(err, void 0, {
-        F: __dxlog_file14,
-        L: 374,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
-      for (const [_, pendingCallback] of this._channelCreatedCallbacks.entries()) {
-        pendingCallback.reject("Connection closed.");
-      }
-      this._channelCreatedCallbacks.clear();
-    }
+};
+
+// packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts
+import { Writable } from "@dxos/node-std/stream";
+import { Event as Event9, scheduleTask as scheduleTask4 } from "@dxos/async";
+import { Context as Context6 } from "@dxos/context";
+import { ErrorStream as ErrorStream5 } from "@dxos/debug";
+import { invariant as invariant13 } from "@dxos/invariant";
+import { PublicKey as PublicKey12 } from "@dxos/keys";
+import { log as log14 } from "@dxos/log";
+import { ConnectionResetError as ConnectionResetError3, TimeoutError as TimeoutError3, ProtocolError as ProtocolError3, ConnectivityError as ConnectivityError3, UnknownProtocolError as UnknownProtocolError3 } from "@dxos/protocols";
+import { ConnectionState as ConnectionState4 } from "@dxos/protocols/proto/dxos/mesh/bridge";
+import { arrayToBuffer } from "@dxos/util";
+var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-proxy.ts";
+var RPC_TIMEOUT = 1e4;
+var RESP_MIN_THRESHOLD = 500;
+var TIMEOUT_THRESHOLD = 10;
+var SimplePeerTransportProxy = class {
+  constructor(_options) {
+    this._options = _options;
+    this._proxyId = PublicKey12.random();
+    this._ctx = new Context6(void 0, {
+      F: __dxlog_file15,
+      L: 37
+    });
+    this._timeoutCount = 0;
+    this.closed = new Event9();
+    this.connected = new Event9();
+    this.errors = new ErrorStream5();
+    this._closed = false;
   }
-  async _loadConnectionConfig() {
-    const config = {
-      ...this._options.webrtcConfig
-    };
-    try {
-      const providedIceServers = await this._options.iceProvider?.getIceServers() ?? [];
-      if (providedIceServers.length > 0) {
-        config.iceServers = [
-          ...config.iceServers ?? [],
-          ...providedIceServers
-        ];
-      }
-    } catch (error) {
-      log13.catch(error, void 0, {
-        F: __dxlog_file14,
-        L: 390,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    return config;
+  get isOpen() {
+    return !this._closed;
   }
-  async _sendIceCandidate(candidate) {
-    try {
-      await this._options.sendSignal({
-        payload: {
-          data: {
-            type: "candidate",
-            candidate: {
-              candidate: candidate.candidate,
-              // These fields never seem to be not null, but connecting to Chrome doesn't work if they are.
-              sdpMLineIndex: candidate.sdpMLineIndex ?? "0",
-              sdpMid: candidate.sdpMid ?? "0"
-            }
-          }
+  async open() {
+    this._serviceStream = this._options.bridgeService.open({
+      proxyId: this._proxyId,
+      initiator: this._options.initiator
+    }, {
+      timeout: RPC_TIMEOUT
+    });
+    this._serviceStream.waitUntilReady().then(() => {
+      this._serviceStream.subscribe(async (event) => {
+        log14("SimplePeerTransportProxy: event", event, {
+          F: __dxlog_file15,
+          L: 66,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (event.connection) {
+          await this._handleConnection(event.connection);
+        } else if (event.data) {
+          this._handleData(event.data);
+        } else if (event.signal) {
+          await this._handleSignal(event.signal);
         }
       });
-    } catch (err) {
-      log13.warn("signaling error", {
-        err
-      }, {
-        F: __dxlog_file14,
-        L: 411,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  async _sendDescription(connection, description) {
-    if (connection !== this._connection) {
-      return;
-    }
-    const data = {
-      type: description.type,
-      sdp: description.sdp
-    };
-    await this._options.sendSignal({
-      payload: {
-        data
-      }
-    });
-  }
-  get _connectionInfo() {
-    const connectionInfo = this._connection && {
-      connectionState: this._connection.connectionState,
-      iceConnectionState: this._connection.iceConnectionState,
-      iceGatheringState: this._connection.iceGatheringState,
-      signalingState: this._connection.signalingState,
-      remoteDescription: this._connection.remoteDescription,
-      localDescription: this._connection.localDescription
-    };
-    return {
-      ...connectionInfo,
-      ts: Date.now(),
-      remotePeerKey: this._options.remotePeerKey,
-      channels: [
-        ...this._transportChannels.keys()
-      ].map((topic) => topic),
-      config: this._connection?.getConfiguration()
-    };
-  }
-  get _loggerContext() {
-    return {
-      ownPeerKey: this._options.ownPeerKey,
-      remotePeerKey: this._options.remotePeerKey,
-      initiator: this._initiator,
-      channels: this._transportChannels.size
-    };
-  }
-};
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_openConnection", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_lockAndAbort", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_lockAndCloseConnection", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "onSignal", null);
-_ts_decorate6([
-  trace4.info()
-], RtcPeerConnection.prototype, "_connectionInfo", null);
-_ts_decorate6([
-  logInfo4
-], RtcPeerConnection.prototype, "_loggerContext", null);
-RtcPeerConnection = _ts_decorate6([
-  trace4.resource()
-], RtcPeerConnection);
-var isRemoteDescriptionSet = (connection, data) => {
-  if (!connection.remoteDescription?.type || connection.remoteDescription?.type !== data.type) {
-    return false;
-  }
-  return areSdpEqual(connection.remoteDescription.sdp, data.sdp);
-};
-var createIceFailureError = (details) => {
-  const candidateErrors = details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`);
-  return new ConnectivityError3(`ICE failed:
-${candidateErrors.join("\n")}`);
-};
-
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-factory.ts
-var createRtcTransportFactory = (webrtcConfig, iceProvider) => {
-  const connectionFactory = getRtcConnectionFactory();
-  return {
-    createTransport: (options) => {
-      const connection = new RtcPeerConnection(connectionFactory, {
-        ownPeerKey: options.ownPeerKey,
-        remotePeerKey: options.remotePeerKey,
-        sendSignal: options.sendSignal,
-        webrtcConfig,
-        iceProvider
-      });
-      return connection.createTransportChannel(options);
-    }
-  };
-};
-
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts
-import { Writable } from "@dxos/node-std/stream";
-import { Event as Event8, scheduleTask as scheduleTask4 } from "@dxos/async";
-import { Resource as Resource2 } from "@dxos/context";
-import { ErrorStream as ErrorStream5 } from "@dxos/debug";
-import { invariant as invariant13 } from "@dxos/invariant";
-import { PublicKey as PublicKey10 } from "@dxos/keys";
-import { log as log14 } from "@dxos/log";
-import { ConnectionResetError as ConnectionResetError2, ConnectivityError as ConnectivityError4, TimeoutError as TimeoutError3 } from "@dxos/protocols";
-import { ConnectionState as ConnectionState3 } from "@dxos/protocols/proto/dxos/mesh/bridge";
-import { arrayToBuffer } from "@dxos/util";
-var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts";
-var RPC_TIMEOUT = 1e4;
-var CLOSE_RPC_TIMEOUT = 3e3;
-var RESP_MIN_THRESHOLD = 500;
-var RtcTransportProxy = class extends Resource2 {
-  constructor(_options) {
-    super();
-    this._options = _options;
-    this._proxyId = PublicKey10.random();
-    this.closed = new Event8();
-    this.connected = new Event8();
-    this.errors = new ErrorStream5();
-  }
-  async _open() {
-    let stream;
-    try {
-      stream = this._options.bridgeService.open({
-        proxyId: this._proxyId,
-        remotePeerKey: this._options.remotePeerKey,
-        ownPeerKey: this._options.ownPeerKey,
-        topic: this._options.topic,
-        initiator: this._options.initiator ?? false
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-    } catch (error) {
-      this.errors.raise(error);
-      return;
-    }
-    this._serviceStream = stream;
-    stream.waitUntilReady().then(() => {
-      stream.subscribe(async (event) => {
-        log14("rtc transport proxy event", event, {
-          F: __dxlog_file15,
-          L: 66,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (event.connection) {
-          await this._handleConnection(event.connection);
-        } else if (event.data) {
-          this._handleData(event.data);
-        } else if (event.signal) {
-          await this._handleSignal(event.signal);
-        }
-      }, (err) => {
-        log14("rtc bridge stream closed", {
-          err
-        }, {
-          F: __dxlog_file15,
-          L: 76,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (err) {
-          this._raiseIfOpen(err);
-        } else {
-          void this.close();
-        }
-      });
-      const connectorStream = new Writable({
+      const proxyStream = new Writable({
         write: (chunk, _, callback) => {
-          const sendStartMs = Date.now();
+          const then = performance.now();
           this._options.bridgeService.sendData({
             proxyId: this._proxyId,
             payload: chunk
           }, {
             timeout: RPC_TIMEOUT
           }).then(() => {
-            if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
+            if (performance.now() - then > RESP_MIN_THRESHOLD) {
               log14("slow response, delaying callback", void 0, {
                 F: __dxlog_file15,
-                L: 93,
+                L: 90,
                 S: this,
                 C: (f, a) => f(...a)
               });
@@ -3941,41 +3487,60 @@ var RtcTransportProxy = class extends Resource2 {
             } else {
               callback();
             }
+            this._timeoutCount = 0;
           }, (err) => {
-            callback();
-            this._raiseIfOpen(err);
+            if (err instanceof TimeoutError3 || err.constructor.name === "TimeoutError") {
+              if (this._timeoutCount++ > TIMEOUT_THRESHOLD) {
+                throw new TimeoutError3(`too many timeouts (${this._timeoutCount} > ${TIMEOUT_THRESHOLD}`);
+              } else {
+                log14("timeout error, but still invoking callback", void 0, {
+                  F: __dxlog_file15,
+                  L: 102,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+                callback();
+              }
+            } else {
+              log14.catch(err, void 0, {
+                F: __dxlog_file15,
+                L: 106,
+                S: this,
+                C: (f, a) => f(...a)
+              });
+            }
           });
         }
       });
-      connectorStream.on("error", (err) => {
-        this._raiseIfOpen(err);
+      proxyStream.on("error", (err) => {
+        log14("proxystream error", {
+          err
+        }, {
+          F: __dxlog_file15,
+          L: 114,
+          S: this,
+          C: (f, a) => f(...a)
+        });
       });
-      this._options.stream.pipe(connectorStream);
-    }, (error) => {
-      if (error) {
-        this._raiseIfOpen(error);
-      } else {
-        void this.close();
-      }
-    });
+      this._options.stream.pipe(proxyStream);
+    }, (error) => log14.catch(error, void 0, {
+      F: __dxlog_file15,
+      L: 119,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
   }
-  async _close() {
-    try {
-      await this._serviceStream?.close();
-      this._serviceStream = void 0;
-    } catch (err) {
-      log14.catch(err, void 0, {
-        F: __dxlog_file15,
-        L: 128,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+  async close() {
+    await this._ctx.dispose();
+    if (this._closed) {
+      return;
     }
+    await this._serviceStream.close();
     try {
       await this._options.bridgeService.close({
         proxyId: this._proxyId
       }, {
-        timeout: CLOSE_RPC_TIMEOUT
+        timeout: RPC_TIMEOUT
       });
     } catch (err) {
       log14.catch(err, void 0, {
@@ -3986,6 +3551,7 @@ var RtcTransportProxy = class extends Resource2 {
       });
     }
     this.closed.emit();
+    this._closed = true;
   }
   async onSignal(signal) {
     this._options.bridgeService.sendSignal({
@@ -3993,94 +3559,54 @@ var RtcTransportProxy = class extends Resource2 {
       signal
     }, {
       timeout: RPC_TIMEOUT
-    }).catch((err) => this._raiseIfOpen(decodeError(err)));
+    }).catch((err) => this.errors.raise(decodeError(err)));
   }
   async _handleConnection(connectionEvent) {
     if (connectionEvent.error) {
       this.errors.raise(decodeError(connectionEvent.error));
-      return;
     }
     switch (connectionEvent.state) {
-      case ConnectionState3.CONNECTED: {
+      case ConnectionState4.CONNECTED: {
         this.connected.emit();
         break;
       }
-      case ConnectionState3.CLOSED: {
+      case ConnectionState4.CLOSED: {
         await this.close();
         break;
       }
     }
   }
   _handleData(dataEvent) {
-    try {
-      this._options.stream.write(arrayToBuffer(dataEvent.payload));
-    } catch (error) {
-      this._raiseIfOpen(error);
-    }
+    this._options.stream.write(arrayToBuffer(dataEvent.payload));
   }
   async _handleSignal(signalEvent) {
-    try {
-      await this._options.sendSignal(signalEvent.payload);
-    } catch (error) {
-      const type = signalEvent.payload.payload.data?.type;
-      if (type === "offer" || type === "answer") {
-        this._raiseIfOpen(new ConnectivityError4(`Session establishment failed: ${type} couldn't be sent.`));
-      }
-    }
+    await this._options.sendSignal(signalEvent.payload);
   }
   async getDetails() {
-    try {
-      const response = await this._options.bridgeService.getDetails({
-        proxyId: this._proxyId
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-      return response.details;
-    } catch (err) {
-      return "bridge-svc unreachable";
-    }
+    return (await this._options.bridgeService.getDetails({
+      proxyId: this._proxyId
+    }, {
+      timeout: RPC_TIMEOUT
+    })).details;
   }
   async getStats() {
-    try {
-      const response = await this._options.bridgeService.getStats({
-        proxyId: this._proxyId
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-      return response.stats;
-    } catch (err) {
-      return {
-        bytesSent: 0,
-        bytesReceived: 0,
-        packetsSent: 0,
-        packetsReceived: 0,
-        rawStats: "bridge-svc unreachable"
-      };
-    }
-  }
-  _raiseIfOpen(error) {
-    if (this.isOpen) {
-      this.errors.raise(error);
-    } else {
-      log14.info("error swallowed because transport was closed", {
-        message: error.message
-      }, {
-        F: __dxlog_file15,
-        L: 215,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
+    return (await this._options.bridgeService.getStats({
+      proxyId: this._proxyId
+    }, {
+      timeout: RPC_TIMEOUT
+    })).stats;
   }
   /**
   * Called when underlying proxy service becomes unavailable.
   */
+  // TODO(burdon): Option on close method.
   forceClose() {
-    void this._serviceStream?.close();
+    void this._serviceStream.close();
     this.closed.emit();
+    this._closed = true;
   }
 };
-var RtcTransportProxyFactory = class {
+var SimplePeerTransportProxyFactory = class {
   constructor() {
     this._connections = /* @__PURE__ */ new Set();
   }
@@ -4096,16 +3622,16 @@ var RtcTransportProxyFactory = class {
     return this;
   }
   createTransport(options) {
-    invariant13(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", {
+    invariant13(this._bridgeService, "SimplePeerTransportProxyFactory is not ready to open connections", {
       F: __dxlog_file15,
-      L: 245,
+      L: 218,
       S: this,
       A: [
         "this._bridgeService",
-        "'RtcTransportProxyFactory is not ready to open connections'"
+        "'SimplePeerTransportProxyFactory is not ready to open connections'"
       ]
     });
-    const transport = new RtcTransportProxy({
+    const transport = new SimplePeerTransportProxy({
       ...options,
       bridgeService: this._bridgeService
     });
@@ -4117,222 +3643,496 @@ var RtcTransportProxyFactory = class {
 var decodeError = (err) => {
   const message = typeof err === "string" ? err : err.message;
   if (message.includes("CONNECTION_RESET")) {
-    return new ConnectionResetError2(message);
+    return new ConnectionResetError3(message);
   } else if (message.includes("TIMEOUT")) {
     return new TimeoutError3(message);
+  } else if (message.includes("PROTOCOL_ERROR")) {
+    return new ProtocolError3(message);
   } else if (message.includes("CONNECTIVITY_ERROR")) {
-    return new ConnectivityError4(message);
+    return new ConnectivityError3(message);
+  } else if (message.includes("UNKNOWN_PROTOCOL_ERROR")) {
+    return new UnknownProtocolError3(message);
   } else {
     return typeof err === "string" ? new Error(err) : err;
   }
 };
 
-// packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts
-import { Duplex as Duplex2 } from "@dxos/node-std/stream";
-import { Stream } from "@dxos/codec-protobuf";
+// packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts
+import { Duplex as Duplex2 } from "stream";
+import { Event as Event10, Trigger as Trigger3, synchronized as synchronized6 } from "@dxos/async";
+import { ErrorStream as ErrorStream6 } from "@dxos/debug";
 import { invariant as invariant14 } from "@dxos/invariant";
-import { PublicKey as PublicKey11 } from "@dxos/keys";
 import { log as log15 } from "@dxos/log";
-import { ConnectionState as ConnectionState4 } from "@dxos/protocols/proto/dxos/mesh/bridge";
-import { ComplexMap as ComplexMap8 } from "@dxos/util";
-var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
-var RtcTransportService = class {
-  constructor(webrtcConfig, iceProvider, _transportFactory = createRtcTransportFactory(webrtcConfig, iceProvider)) {
-    this._transportFactory = _transportFactory;
-    this._openTransports = new ComplexMap8(PublicKey11.hash);
+function _ts_decorate7(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_file16 = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts";
+var DATACHANNEL_LABEL = "dxos.mesh.transport";
+var MAX_BUFFERED_AMOUNT = 64 * 1024;
+var MAX_MESSAGE_SIZE = 64 * 1024;
+var createLibDataChannelTransportFactory = (webrtcConfig, iceProvider) => {
+  return {
+    createTransport: (options) => new LibDataChannelTransport({
+      ...options,
+      webrtcConfig,
+      iceProvider
+    })
+  };
+};
+var LibDataChannelTransport = class _LibDataChannelTransport {
+  static {
+    this._instanceCount = 0;
   }
-  hasOpenTransports() {
-    return this._openTransports.size > 0;
+  constructor(_options) {
+    this._options = _options;
+    this._closed = false;
+    this._connected = false;
+    this._writeCallback = null;
+    this._readyForCandidates = new Trigger3();
+    this.closed = new Event10();
+    this.connected = new Event10();
+    this.errors = new ErrorStream6();
   }
-  open(request) {
-    const existingTransport = this._openTransports.get(request.proxyId);
-    if (existingTransport) {
-      log15.error("requesting a new transport bridge for an existing proxy", void 0, {
+  get isOpen() {
+    return !!this._peer && !this._closed;
+  }
+  async open() {
+    if (this._closed) {
+      this.errors.raise(new Error("connection already closed"));
+    }
+    const { RTCPeerConnection } = (await importESM("node-datachannel/polyfill")).default;
+    const providedIceServers = await this._options.iceProvider?.getIceServers();
+    if (!this._options.webrtcConfig) {
+      this._options.webrtcConfig = {};
+    }
+    this._options.webrtcConfig.iceServers = [
+      ...this._options.webrtcConfig.iceServers ?? [],
+      ...providedIceServers ?? []
+    ];
+    this._peer = new RTCPeerConnection(this._options.webrtcConfig);
+    this._peer.onicecandidateerror = (event) => {
+      log15.error("peer.onicecandidateerror", {
+        event
+      }, {
         F: __dxlog_file16,
-        L: 53,
+        L: 93,
         S: this,
         C: (f, a) => f(...a)
       });
-      void this._safeCloseTransport(existingTransport);
-      this._openTransports.delete(request.proxyId);
-    }
-    return new Stream(({ ready, next, close }) => {
-      const pushNewState = createStateUpdater(next);
-      const transportStream = new Duplex2({
-        read: () => {
-          const callbacks = [
-            ...transportState.writeProcessedCallbacks
-          ];
-          transportState.writeProcessedCallbacks.length = 0;
-          callbacks.forEach((cb) => cb());
-        },
-        write: function(chunk, _, callback) {
-          next({
-            data: {
-              payload: chunk
+    };
+    this._peer.onconnectionstatechange = (event) => {
+      log15.debug("peer.onconnectionstatechange", {
+        event,
+        peerConnectionState: this._peer?.connectionState,
+        transportConnectionState: this._connected
+      }, {
+        F: __dxlog_file16,
+        L: 97,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    };
+    this._peer.onicecandidate = async (event) => {
+      log15.debug("peer.onicecandidate", {
+        event
+      }, {
+        F: __dxlog_file16,
+        L: 107,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (event.candidate) {
+        try {
+          await this._options.sendSignal({
+            payload: {
+              data: {
+                type: "candidate",
+                candidate: {
+                  candidate: event.candidate.candidate,
+                  // These fields never seem to be not null, but connecting to Chrome doesn't work if they are.
+                  sdpMLineIndex: event.candidate.sdpMLineIndex ?? 0,
+                  sdpMid: event.candidate.sdpMid ?? 0
+                }
+              }
             }
           });
-          callback();
+        } catch (err) {
+          log15.info("signaling error", {
+            err
+          }, {
+            F: __dxlog_file16,
+            L: 124,
+            S: this,
+            C: (f, a) => f(...a)
+          });
         }
+      }
+    };
+    if (this._options.initiator) {
+      invariant14(this._peer, "not open", {
+        F: __dxlog_file16,
+        L: 130,
+        S: this,
+        A: [
+          "this._peer",
+          "'not open'"
+        ]
       });
-      const transport = this._transportFactory.createTransport({
-        initiator: request.initiator,
-        topic: request.topic,
-        ownPeerKey: request.ownPeerKey,
-        remotePeerKey: request.remotePeerKey,
-        stream: transportStream,
-        sendSignal: async (signal) => {
-          next({
-            signal: {
-              payload: signal
-            }
+      this._peer.createOffer().then(async (offer) => {
+        if (this._closed) {
+          return;
+        }
+        if (this._peer?.connectionState !== "connecting") {
+          log15.error("peer not connecting", {
+            peer: this._peer
+          }, {
+            F: __dxlog_file16,
+            L: 141,
+            S: this,
+            C: (f, a) => f(...a)
           });
+          this.errors.raise(new Error("invalid state: peer is initiator, but other peer not in state connecting"));
         }
+        log15.debug("creating offer", {
+          peer: this._peer,
+          offer
+        }, {
+          F: __dxlog_file16,
+          L: 145,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        await this._peer.setLocalDescription(offer);
+        await this._options.sendSignal({
+          payload: {
+            data: {
+              type: offer.type,
+              sdp: offer.sdp
+            }
+          }
+        });
+      }).catch((err) => {
+        this.errors.raise(err);
       });
-      const transportState = {
-        proxyId: request.proxyId,
-        transport,
-        connectorStream: transportStream,
-        writeProcessedCallbacks: []
+      this._handleChannel(this._peer.createDataChannel(DATACHANNEL_LABEL));
+      log15.debug("created data channel", void 0, {
+        F: __dxlog_file16,
+        L: 155,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._peer.ondatachannel = () => {
+        this.errors.raise(new Error("unexpected ondatachannel event for initiator"));
       };
-      pushNewState(ConnectionState4.CONNECTING);
-      transport.connected.on(() => pushNewState(ConnectionState4.CONNECTED));
-      transport.errors.handle(async (err) => {
-        pushNewState(ConnectionState4.CLOSED, err);
-        void this._safeCloseTransport(transportState);
-        close(err);
+    } else {
+      this._peer.ondatachannel = (event) => {
+        log15.debug("peer.ondatachannel (non-initiator)", {
+          event
+        }, {
+          F: __dxlog_file16,
+          L: 161,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (event.channel.label !== DATACHANNEL_LABEL) {
+          this.errors.raise(new Error(`unexpected channel label ${event.channel.label}`));
+        }
+        this._handleChannel(event.channel);
+      };
+    }
+    _LibDataChannelTransport._instanceCount++;
+  }
+  async close() {
+    await this._close();
+    if (--_LibDataChannelTransport._instanceCount === 0) {
+      (await importESM("node-datachannel")).cleanup();
+    }
+  }
+  async _close() {
+    if (this._closed) {
+      return;
+    }
+    await this._disconnectStreams();
+    try {
+      this._peer?.close();
+    } catch (err) {
+      this.errors.raise(err);
+    }
+    this._peer = void 0;
+    this._closed = true;
+    this.closed.emit();
+  }
+  /**
+  * Handle data channel events.
+  */
+  _handleChannel(dataChannel) {
+    this._channel = dataChannel;
+    this._channel.onopen = () => {
+      log15.debug("channel.onopen", void 0, {
+        F: __dxlog_file16,
+        L: 206,
+        S: this,
+        C: (f, a) => f(...a)
       });
-      transport.closed.on(async () => {
-        pushNewState(ConnectionState4.CLOSED);
-        void this._safeCloseTransport(transportState);
-        close();
+      const duplex = new Duplex2({
+        read: () => {
+        },
+        write: async (chunk, encoding, callback) => {
+          if (chunk.length > MAX_MESSAGE_SIZE) {
+            this.errors.raise(new Error(`message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}`));
+          }
+          try {
+            dataChannel.send(chunk);
+          } catch (err) {
+            this.errors.raise(err);
+            await this._close();
+          }
+          if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
+            if (this._writeCallback !== null) {
+              log15.error("consumer trying to write before we are ready for more data", void 0, {
+                F: __dxlog_file16,
+                L: 223,
+                S: this,
+                C: (f, a) => f(...a)
+              });
+            }
+            this._writeCallback = callback;
+          } else {
+            callback();
+          }
+        }
       });
-      this._openTransports.set(request.proxyId, transportState);
-      transport.open().catch(async (err) => {
-        pushNewState(ConnectionState4.CLOSED, err);
-        void this._safeCloseTransport(transportState);
-        close(err);
+      duplex.pipe(this._options.stream).pipe(duplex);
+      this._stream = duplex;
+      this._connected = true;
+      this.connected.emit();
+    };
+    this._channel.onclose = async (err) => {
+      log15.info("channel.onclose", {
+        err
+      }, {
+        F: __dxlog_file16,
+        L: 239,
+        S: this,
+        C: (f, a) => f(...a)
       });
-      ready();
-    });
+      await this._close();
+    };
+    this._channel.onerror = async (err) => {
+      this.errors.raise(new Error("channel error: " + err.toString()));
+      await this._close();
+    };
+    this._channel.onbufferedamountlow = () => {
+      const cb = this._writeCallback;
+      this._writeCallback = null;
+      cb?.();
+    };
+    this._channel.onmessage = (event) => {
+      let data = event.data;
+      if (data instanceof ArrayBuffer) {
+        data = Buffer2.from(data);
+      }
+      this._stream.push(data);
+    };
   }
-  async sendSignal({ proxyId, signal }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
+  async onSignal(signal) {
+    invariant14(this._peer, "not open", {
       F: __dxlog_file16,
-      L: 121,
+      L: 265,
       S: this,
       A: [
-        "transport",
-        ""
+        "this._peer",
+        "'not open'"
       ]
     });
-    await transport.transport.onSignal(signal);
+    try {
+      const data = signal.payload.data;
+      switch (data.type) {
+        case "offer": {
+          if (this._peer.connectionState !== "new") {
+            log15.error("received offer but peer not in state new", {
+              peer: this._peer
+            }, {
+              F: __dxlog_file16,
+              L: 272,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            this.errors.raise(new Error("invalid signalling state: received offer when peer is not in state new"));
+            break;
+          }
+          try {
+            await this._peer.setRemoteDescription({
+              type: data.type,
+              sdp: data.sdp
+            });
+            const answer = await this._peer.createAnswer();
+            await this._peer.setLocalDescription(answer);
+            await this._options.sendSignal({
+              payload: {
+                data: {
+                  type: answer.type,
+                  sdp: answer.sdp
+                }
+              }
+            });
+            this._readyForCandidates.wake();
+          } catch (err) {
+            log15.error("cannot handle offer from signalling server", {
+              err
+            }, {
+              F: __dxlog_file16,
+              L: 284,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            this.errors.raise(new Error("error handling offer"));
+          }
+          break;
+        }
+        case "answer":
+          try {
+            await this._peer.setRemoteDescription({
+              type: data.type,
+              sdp: data.sdp
+            });
+            this._readyForCandidates.wake();
+          } catch (err) {
+            log15.error("cannot handle answer from signalling server", {
+              err
+            }, {
+              F: __dxlog_file16,
+              L: 295,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            this.errors.raise(new Error("error handling answer"));
+          }
+          break;
+        case "candidate":
+          await this._readyForCandidates.wait();
+          await this._peer.addIceCandidate({
+            candidate: data.candidate.candidate
+          });
+          break;
+        default:
+          log15.error("unhandled signal type", {
+            type: data.type,
+            signal
+          }, {
+            F: __dxlog_file16,
+            L: 306,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this.errors.raise(new Error(`unhandled signal type ${data.type}`));
+      }
+    } catch (err) {
+      log15.catch(err, void 0, {
+        F: __dxlog_file16,
+        L: 310,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
   }
-  async getDetails({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 128,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
+  async getDetails() {
+    const stats = await this._getStats();
+    const rc = stats?.remoteCandidate;
+    if (!rc) {
+      return "unavailable";
+    }
+    if (rc.candidateType === "relay") {
+      return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+    }
+    return `${rc.ip}:${rc.port} ${rc.candidateType}`;
+  }
+  async getStats() {
+    const stats = await this._getStats();
+    if (!stats) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: {}
+      };
+    }
     return {
-      details: await transport.transport.getDetails()
+      bytesSent: stats.transport.bytesSent,
+      bytesReceived: stats.transport.bytesReceived,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: stats.raw
     };
   }
-  async getStats({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
+  async _getStats() {
+    invariant14(this._peer, "not open", {
       F: __dxlog_file16,
-      L: 135,
+      L: 350,
       S: this,
       A: [
-        "transport",
-        ""
+        "this._peer",
+        "'not open'"
       ]
     });
+    const stats = await this._peer.getStats();
+    const statsEntries = Array.from(stats.entries());
+    const transport = statsEntries.filter((s) => s[1].type === "transport")[0][1];
+    const candidatePair = statsEntries.filter((s) => s[0] === transport.selectedCandidatePairId);
+    let selectedCandidatePair;
+    let remoteCandidate;
+    if (candidatePair.length > 0) {
+      selectedCandidatePair = candidatePair[0][1];
+      remoteCandidate = statsEntries.filter((s) => s[0] === selectedCandidatePair.remoteCandidateId)[0][1];
+    }
     return {
-      stats: await transport.transport.getStats()
+      transport,
+      selectedCandidatePair,
+      remoteCandidate,
+      raw: Object.fromEntries(stats)
     };
   }
-  async sendData({ proxyId, payload }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant14(transport, void 0, {
-      F: __dxlog_file16,
-      L: 142,
-      S: this,
-      A: [
-        "transport",
-        ""
-      ]
-    });
-    const bufferHasSpace = transport.connectorStream.push(payload);
-    if (!bufferHasSpace) {
-      await new Promise((resolve) => {
-        transport.writeProcessedCallbacks.push(resolve);
-      });
-    }
+  async _disconnectStreams() {
+    this._options.stream.unpipe?.(this._stream)?.unpipe?.(this._options.stream);
   }
-  async close({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    if (!transport) {
-      return;
-    }
-    this._openTransports.delete(proxyId);
-    await this._safeCloseTransport(transport);
+};
+_ts_decorate7([
+  synchronized6
+], LibDataChannelTransport.prototype, "_close", null);
+var importESM = Function("path", "return import(path)");
+
+// packages/core/mesh/network-manager/src/transport/tcp-transport.browser.ts
+import { Event as Event11 } from "@dxos/async";
+import { ErrorStream as ErrorStream7 } from "@dxos/debug";
+var TcpTransportFactory = {
+  createTransport: () => new TcpTransport()
+};
+var TcpTransport = class {
+  constructor() {
+    this.closed = new Event11();
+    this.connected = new Event11();
+    this.errors = new ErrorStream7();
   }
-  async _safeCloseTransport(transport) {
-    if (this._openTransports.get(transport.proxyId) === transport) {
-      this._openTransports.delete(transport.proxyId);
-    }
-    transport.writeProcessedCallbacks.forEach((cb) => cb());
-    try {
-      await transport.transport.close();
-    } catch (error) {
-      log15.warn("transport close error", {
-        message: error?.message
-      }, {
-        F: __dxlog_file16,
-        L: 172,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    try {
-      transport.connectorStream.end();
-    } catch (error) {
-      log15.warn("connectorStream close error", {
-        message: error?.message
-      }, {
-        F: __dxlog_file16,
-        L: 177,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    log15("closed", void 0, {
-      F: __dxlog_file16,
-      L: 179,
-      S: this,
-      C: (f, a) => f(...a)
-    });
+  get isOpen() {
+    return true;
+  }
+  async open() {
+  }
+  async close() {
+  }
+  async onSignal() {
+    throw new Error("Method not implemented.");
+  }
+  async getStats() {
+    throw new Error("Method not implemented.");
+  }
+  async getDetails() {
+    throw new Error("Method not implemented.");
   }
-};
-var createStateUpdater = (next) => {
-  return (state, err) => {
-    next({
-      connection: {
-        state,
-        ...err ? {
-          error: err.message
-        } : void 0
-      }
-    });
-  };
 };
 
 // packages/core/mesh/network-manager/src/wire-protocol.ts
@@ -4360,6 +4160,7 @@ var createTeleportProtocolFactory = (onConnection, defaultParams) => {
 };
 
 export {
+  process,
   ConnectionState,
   Connection,
   createIceProvider,
@@ -4377,10 +4178,15 @@ export {
   MemoryTransportFactory,
   MemoryTransport,
   TransportKind,
-  createRtcTransportFactory,
-  RtcTransportProxy,
-  RtcTransportProxyFactory,
-  RtcTransportService,
+  createSimplePeerTransportFactory,
+  SimplePeerTransport,
+  SimplePeerTransportService,
+  SimplePeerTransportProxy,
+  SimplePeerTransportProxyFactory,
+  createLibDataChannelTransportFactory,
+  LibDataChannelTransport,
+  TcpTransportFactory,
+  TcpTransport,
   createTeleportProtocolFactory
 };
-//# sourceMappingURL=chunk-YOKKEU6T.mjs.map
+//# sourceMappingURL=chunk-XYSYUN63.mjs.map