@dxos/network-manager 0.6.12-main.5cc132e → 0.6.12-main.78ddbdf

package/dist/types/src/transport/webrtc/rtc-transport-stats.d.ts

@@ -0,0 +1,4 @@
+import type { TransportStats } from '../transport';
+export declare const describeSelectedRemoteCandidate: (connection?: RTCPeerConnection) => Promise<string>;
+export declare const createRtcTransportStats: (connection: RTCPeerConnection | undefined, topic: string) => Promise<TransportStats>;
+//# sourceMappingURL=rtc-transport-stats.d.ts.map

package/dist/types/src/transport/webrtc/rtc-transport-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtc-transport-stats.d.ts","sourceRoot":"","sources":["../../../../../src/transport/webrtc/rtc-transport-stats.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,eAAO,MAAM,+BAA+B,gBAAuB,iBAAiB,KAAG,OAAO,CAAC,MAAM,CAYpG,CAAC;AAEF,eAAO,MAAM,uBAAuB,eACtB,iBAAiB,GAAG,SAAS,SAClC,MAAM,KACZ,OAAO,CAAC,cAAc,CAmBxB,CAAC"}

package/dist/types/src/transport/webrtc/rtc-transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rtc-transport.test.d.ts.map

package/dist/types/src/transport/webrtc/rtc-transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtc-transport.test.d.ts","sourceRoot":"","sources":["../../../../../src/transport/webrtc/rtc-transport.test.ts"],"names":[],"mappings":""}

package/dist/types/src/transport/webrtc/test-utils.d.ts

@@ -0,0 +1,5 @@
+import { type Transport } from '../transport';
+export declare const handleChannelErrors: (channel: Transport) => {
+    expectErrorRaised: () => Promise<void>;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/types/src/transport/webrtc/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../../../src/transport/webrtc/test-utils.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,eAAO,MAAM,mBAAmB,YAAa,SAAS;;CAWrD,CAAC"}

package/dist/types/src/transport/webrtc/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const chooseInitiatorPeer: (peer1Key: string, peer2Key: string) => string;
+export declare const areSdpEqual: (sdp1: string, sdp2: string) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/src/transport/webrtc/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/transport/webrtc/utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,aAAc,MAAM,YAAY,MAAM,WAAgD,CAAC;AAEvH,eAAO,MAAM,WAAW,SAAU,MAAM,QAAQ,MAAM,YAOrD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/network-manager",
-  "version": "0.6.12-main.5cc132e",
+  "version": "0.6.12-main.78ddbdf",
   "description": "Network Manager",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,6 +16,13 @@
       "browser": "./module-stub.js",
       "workerd": "./module-stub.js",
       "default": "node-datachannel/*"
+    },
+    "#tcp-transport": {
+      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
+      "node": "./dist/lib/node/transport/tcp/index.cjs",
+      "import": "./dist/lib/browser/transport/tcp/index.mjs",
+      "require": "./dist/lib/node/transport/tcp/index.cjs",
+      "types": "./dist/types/src/transport/tcp/index.d.ts"
     }
   },
   "exports": {
@@ -34,16 +41,27 @@
         "default": "./dist/lib/node-esm/testing/index.mjs"
       },
       "types": "./dist/types/src/testing/index.d.ts"
+    },
+    "./tcp": {
+      "browser": "./dist/lib/browser/transport/tcp/index.mjs",
+      "node": {
+        "require": "./dist/lib/node/transport/tcp/index.cjs",
+        "default": "./dist/lib/node-esm/transport/tcp/index.mjs"
+      },
+      "types": "./dist/types/src/transport/tcp/index.d.ts"
     }
   },
   "browser": {
-    "./src/transport/tcp-transport.ts": "./src/transport/tcp-transport.browser.ts"
+    "./src/transport/tcp/tcp-transport.ts": "./src/transport/tcp/tcp-transport.browser.ts"
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
     "*": {
       "testing": [
         "dist/types/src/testing/index.d.ts"
+      ],
+      "tcp": [
+        "dist/types/src/transport/tcp/index.d.ts"
       ]
     }
   },
@@ -54,29 +72,35 @@
     "src"
   ],
   "dependencies": {
-    "@koush/wrtc": "^0.5.3",
-    "node-datachannel": "^0.5.5",
-    "simple-peer": "9.11.1",
+    "isomorphic-ws": "^5.0.0",
+    "nanomessage-rpc": "^3.0.0",
+    "node-datachannel": "^0.9.2",
+    "p-defer": "^3.0.0",
     "stream": "^0.0.3",
-    "@dxos/async": "0.6.12-main.5cc132e",
-    "@dxos/codec-protobuf": "0.6.12-main.5cc132e",
-    "@dxos/context": "0.6.12-main.5cc132e",
-    "@dxos/debug": "0.6.12-main.5cc132e",
-    "@dxos/invariant": "0.6.12-main.5cc132e",
-    "@dxos/keys": "0.6.12-main.5cc132e",
-    "@dxos/messaging": "0.6.12-main.5cc132e",
-    "@dxos/node-std": "0.6.12-main.5cc132e",
-    "@dxos/log": "0.6.12-main.5cc132e",
-    "@dxos/protocols": "0.6.12-main.5cc132e",
-    "@dxos/rpc": "0.6.12-main.5cc132e",
-    "@dxos/teleport": "0.6.12-main.5cc132e",
-    "@dxos/util": "0.6.12-main.5cc132e"
+    "tiny-invariant": "^1.3.1",
+    "ws": "^8.14.2",
+    "xor-distance": "^2.0.0",
+    "@dxos/async": "0.6.12-main.78ddbdf",
+    "@dxos/codec-protobuf": "0.6.12-main.78ddbdf",
+    "@dxos/context": "0.6.12-main.78ddbdf",
+    "@dxos/invariant": "0.6.12-main.78ddbdf",
+    "@dxos/debug": "0.6.12-main.78ddbdf",
+    "@dxos/keys": "0.6.12-main.78ddbdf",
+    "@dxos/messaging": "0.6.12-main.78ddbdf",
+    "@dxos/log": "0.6.12-main.78ddbdf",
+    "@dxos/node-std": "0.6.12-main.78ddbdf",
+    "@dxos/rpc": "0.6.12-main.78ddbdf",
+    "@dxos/protocols": "0.6.12-main.78ddbdf",
+    "@dxos/teleport": "0.6.12-main.78ddbdf",
+    "@dxos/tracing": "0.6.12-main.78ddbdf",
+    "@dxos/util": "0.6.12-main.78ddbdf"
   },
   "devDependencies": {
-    "@types/simple-peer": "9.11.3",
+    "@swc-node/register": "1.9.1",
+    "@types/ws": "^7.4.0",
     "fast-check": "^3.19.0",
     "fetch-mock": "^11.0.0",
-    "@dxos/signal": "0.6.12-main.5cc132e"
+    "@dxos/signal": "0.6.12-main.78ddbdf"
   },
   "publishConfig": {
     "access": "public"

package/src/signal/swarm-messenger.node.test.ts

@@ -13,7 +13,7 @@ import { runTestSignalServer } from '@dxos/signal';
 import { type OfferMessage, type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
 
-describe('SwarmMessenger', () => {
+describe('SwarmMessenger', { timeout: 7000 }, () => {
   let topic: PublicKey;
 
   let broker1: Awaited<ReturnType<typeof runTestSignalServer>>;

package/src/swarm/connection.test.ts

@@ -9,72 +9,96 @@ import { PublicKey } from '@dxos/keys';
 
 import { Connection } from './connection';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
-import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
+import { createRtcTransportFactory } from '../transport';
+import { chooseInitiatorPeer } from '../transport/webrtc/utils';
 
 describe('Connection', () => {
+  test('responder opens after initiator', async () => {
+    const { initiator, responder } = createPeerKeys();
+    await connectionTest({
+      fastConnectionKey: initiator,
+      slowConnectionKey: responder,
+    });
+  });
+
   test('initiator opens after responder', async () => {
+    const { initiator, responder } = createPeerKeys();
+    await connectionTest({
+      fastConnectionKey: responder,
+      slowConnectionKey: initiator,
+    });
+  });
+
+  const connectionTest = async (setup: { fastConnectionKey: PublicKey; slowConnectionKey: PublicKey }) => {
     const [topic, sessionId] = PublicKey.randomSequence();
-    const peer1 = { peerKey: PublicKey.random().toHex() };
-    const peer2 = { peerKey: PublicKey.random().toHex() };
-    const protocol1 = new TestWireProtocol(PublicKey.from(peer1.peerKey));
-    const connection1 = new Connection(
+    const slowPeer = { peerKey: setup.slowConnectionKey.toHex() };
+    const fastPeer = { peerKey: setup.fastConnectionKey.toHex() };
+
+    const slowPeerProtocol = new TestWireProtocol(PublicKey.from(slowPeer.peerKey));
+    const slowConnection = new Connection(
       topic,
-      peer1,
-      peer2,
+      slowPeer,
+      fastPeer,
       sessionId,
       true,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection2.signal(msg);
+          await fastConnection.signal(msg);
         },
       },
-      protocol1.factory({
+      slowPeerProtocol.factory({
         initiator: true,
-        localPeerId: PublicKey.from(peer1.peerKey),
-        remotePeerId: PublicKey.from(peer2.peerKey),
+        localPeerId: PublicKey.from(slowPeer.peerKey),
+        remotePeerId: PublicKey.from(fastPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    const protocol2 = new TestWireProtocol(PublicKey.from(peer2.peerKey));
-    const connection2 = new Connection(
+    const fastPeerProtocol = new TestWireProtocol(PublicKey.from(fastPeer.peerKey));
+    const fastConnection = new Connection(
       topic,
-      peer2,
-      peer1,
+      fastPeer,
+      slowPeer,
       sessionId,
       false,
       {
-        offer: async (msg) => {
-          return { accept: true };
-        },
+        offer: async (msg) => ({ accept: true }),
         signal: async (msg) => {
-          await connection1.signal(msg);
+          await slowConnection.signal(msg);
         },
       },
-      protocol2.factory({
+      fastPeerProtocol.factory({
         initiator: false,
-        localPeerId: PublicKey.from(peer2.peerKey),
-        remotePeerId: PublicKey.from(peer1.peerKey),
+        localPeerId: PublicKey.from(fastPeer.peerKey),
+        remotePeerId: PublicKey.from(slowPeer.peerKey),
         topic,
       }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
     );
 
-    connection2.initiate();
-    await connection2.openConnection();
-    await sleep(100);
+    fastConnection.initiate();
+    await fastConnection.openConnection();
+    await sleep(200);
+
+    slowConnection.initiate();
+    await slowConnection.openConnection();
 
-    connection1.initiate();
-    await connection1.openConnection();
     await Promise.all([
-      protocol1.testConnection(PublicKey.from(peer2.peerKey), 'test message 1'),
-      protocol2.testConnection(PublicKey.from(peer1.peerKey), 'test message 2'),
+      slowPeerProtocol.testConnection(PublicKey.from(fastPeer.peerKey), 'test message 1'),
+      fastPeerProtocol.testConnection(PublicKey.from(slowPeer.peerKey), 'test message 2'),
     ]);
-  });
+  };
+
+  const createPeerKeys = () => {
+    const peer1 = PublicKey.random();
+    const peer2 = PublicKey.random();
+    const initiator = PublicKey.fromHex(chooseInitiatorPeer(peer1.toHex(), peer2.toHex()));
+    if (initiator.equals(peer1)) {
+      return { initiator: peer1, responder: peer2 };
+    } else {
+      return { initiator: peer2, responder: peer1 };
+    }
+  };
 });

package/src/swarm/connection.ts

@@ -15,7 +15,6 @@ import {
   ConnectionResetError,
   ConnectivityError,
   TimeoutError,
-  UnknownProtocolError,
   trace,
 } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -202,14 +201,15 @@ export class Connection {
 
     invariant(!this._transport);
     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(ConnectionState.CONNECTED);
       await this.connectedTimeoutContext.dispose();
@@ -238,8 +238,6 @@ export class Connection {
       } else if (err instanceof ConnectivityError) {
         log.info('aborting due to transport ConnectivityError');
         this.abort().catch((err) => this.errors.raise(err));
-      } else if (err instanceof UnknownProtocolError) {
-        log.warn('unsure what to do with UnknownProtocolError, will keep on truckin', { err });
       }
 
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
@@ -248,6 +246,8 @@ export class Connection {
       }
     });
 
+    await this._transport.open();
+
     // Replay signals that were received before transport was created.
     for (const signal of this._incomingSignalBuffer) {
       void this._transport.onSignal(signal); // TODO(burdon): Remove async?

package/src/swarm/swarm.test.ts

@@ -20,7 +20,7 @@ import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
-import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory } from '../transport';
+import { createRtcTransportFactory } from '../transport';
 
 type TestPeer = {
   swarm: Swarm;
@@ -53,8 +53,7 @@ describe('Swarm', () => {
       new FullyConnectedTopology(),
       protocol.factory,
       new Messenger({ signalManager }),
-      // TODO(nf): configure better
-      process.env.MOCHA_ENV === 'nodejs' ? createLibDataChannelTransportFactory() : createSimplePeerTransportFactory(),
+      createRtcTransportFactory(),
       undefined,
       connectionLimiter,
       initiationDelay,

package/src/swarm/swarm.ts

@@ -29,7 +29,7 @@ const getClassName = (obj: any) => Object.getPrototypeOf(obj).constructor.name;
 
 /**
  * A single peer's view of the swarm.
- * Manages a set of connections implemented by simple-peer instances.
+ * Manages a set of peers subscribed on the same topic.
  * Routes signal events and maintains swarm topology.
  */
 export class Swarm {

package/src/testing/test-builder.ts

@@ -16,19 +16,12 @@ import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { createLinkedPorts, createProtoRpcPeer, type ProtoRpcPeer } from '@dxos/rpc';
 import { ComplexMap } from '@dxos/util';
 
+import { TcpTransportFactory } from '#tcp-transport';
 import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 import { SwarmNetworkManager } from '../network-manager';
 import { FullyConnectedTopology } from '../topology';
-import {
-  createLibDataChannelTransportFactory,
-  createSimplePeerTransportFactory,
-  MemoryTransportFactory,
-  SimplePeerTransportProxyFactory,
-  SimplePeerTransportService,
-  type TransportFactory,
-  TransportKind,
-} from '../transport';
-import { TcpTransportFactory } from '../transport/tcp-transport';
+import { MemoryTransportFactory, type TransportFactory, TransportKind } from '../transport';
+import { createRtcTransportFactory, RtcTransportProxyFactory, RtcTransportService } from '../transport';
 
 // Signal server will be started by the setup script.
 const port = process.env.SIGNAL_PORT ?? 4000;
@@ -85,18 +78,12 @@ export class TestPeer {
   constructor(
     private readonly testBuilder: TestBuilder,
     public readonly peerId: PublicKey,
-    public readonly transport?: TransportKind,
+    public readonly transport: TransportKind = testBuilder.options.signalHosts
+      ? TransportKind.WEB_RTC
+      : TransportKind.MEMORY,
   ) {
     this._signalManager = this.testBuilder.createSignalManager();
-    if (!transport) {
-      if (this.testBuilder.options.signalHosts) {
-        // TODO(nf): configure better
-        transport = process.env.MOCHA_ENV === 'nodejs' ? TransportKind.LIBDATACHANNEL : TransportKind.SIMPLE_PEER;
-      } else {
-        transport = TransportKind.MEMORY;
-      }
-    }
-    this._networkManager = this.createNetworkManager(transport);
+    this._networkManager = this.createNetworkManager(this.transport);
   }
 
   // TODO(burdon): Move to TestBuilder.
@@ -110,13 +97,10 @@ export class TestPeer {
         case TransportKind.TCP:
           transportFactory = TcpTransportFactory;
           break;
-        case TransportKind.SIMPLE_PEER:
-          transportFactory = createSimplePeerTransportFactory();
-          break;
-        case TransportKind.LIBDATACHANNEL:
-          transportFactory = createLibDataChannelTransportFactory();
+        case TransportKind.WEB_RTC:
+          transportFactory = createRtcTransportFactory();
           break;
-        case TransportKind.SIMPLE_PEER_PROXY:
+        case TransportKind.WEB_RTC_PROXY:
           {
             // Simulates bridge to shared worker.
             const [proxyPort, servicePort] = createLinkedPorts();
@@ -137,14 +121,14 @@ export class TestPeer {
               exposed: {
                 BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
               },
-              handlers: { BridgeService: new SimplePeerTransportService() },
+              handlers: { BridgeService: new RtcTransportService() },
               noHandshake: true,
               encodingOptions: {
                 preserveAny: true,
               },
             });
 
-            transportFactory = new SimplePeerTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
+            transportFactory = new RtcTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
           }
           break;
         default:

package/src/transport/index.ts

@@ -4,8 +4,4 @@
 
 export * from './memory-transport';
 export * from './transport';
-export * from './simplepeer-transport';
-export * from './simplepeer-transport-service';
-export * from './simplepeer-transport-proxy';
-export * from './libdatachannel-transport';
-export * from './tcp-transport';
+export * from './webrtc';

package/src/transport/memory-transport.ts

@@ -123,6 +123,7 @@ export class MemoryTransport implements Transport {
           this.errors.raise(err);
         });
     }
+    return this;
   }
 
   async close() {
@@ -155,6 +156,7 @@ export class MemoryTransport implements Transport {
 
     this.closed.emit();
     log('closed');
+    return this;
   }
 
   async onSignal({ payload }: Signal) {

package/src/transport/tcp/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './tcp-transport';

package/src/transport/{tcp-transport.browser.ts → tcp/tcp-transport.browser.ts}

@@ -5,7 +5,7 @@
 import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 
-import { type Transport, type TransportFactory, type TransportStats } from './transport';
+import { type Transport, type TransportFactory, type TransportStats } from '../transport';
 
 export const TcpTransportFactory: TransportFactory = {
   createTransport: () => new TcpTransport(),
@@ -23,9 +23,13 @@ export class TcpTransport implements Transport {
     return true;
   }
 
-  async open() {}
+  async open() {
+    return this;
+  }
 
-  async close() {}
+  async close() {
+    return this;
+  }
 
   async onSignal() {
     throw new Error('Method not implemented.');

package/src/transport/{tcp-transport.ts → tcp/tcp-transport.ts}

@@ -9,7 +9,7 @@ import { ErrorStream } from '@dxos/debug';
 import { log } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from '../transport';
 
 export const TcpTransportFactory: TransportFactory = {
   createTransport: (options) => new TcpTransport(options),
@@ -72,6 +72,7 @@ export class TcpTransport implements Transport {
         this._server.listen(0);
       });
     }
+    return this;
   }
 
   async close() {
@@ -79,6 +80,7 @@ export class TcpTransport implements Transport {
     this._socket?.destroy();
     this._server?.close();
     this._closed = true;
+    return this;
   }
 
   async onSignal({ payload }: Signal) {

package/src/transport/transport.ts

@@ -8,9 +8,8 @@ import { type PublicKey } from '@dxos/keys';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 export enum TransportKind {
-  SIMPLE_PEER = 'SIMPLE_PEER',
-  SIMPLE_PEER_PROXY = 'SIMPLE_PEER_PROXY',
-  LIBDATACHANNEL = 'LIBDATACHANNEL',
+  WEB_RTC = 'WEB-RTC',
+  WEB_RTC_PROXY = 'WEB-RTC_PROXY',
   MEMORY = 'MEMORY',
   TCP = 'TCP',
 }
@@ -25,10 +24,8 @@ export interface Transport {
   connected: Event;
   errors: ErrorStream;
 
-  open(): Promise<void>;
-  close(): Promise<void>;
-
-  get isOpen(): boolean;
+  open(): Promise<this>;
+  close(): Promise<this>;
 
   /**
    * Handle message from signaling.
@@ -50,6 +47,10 @@ export interface Transport {
  * Common options for all transports.
  */
 export type TransportOptions = {
+  ownPeerKey: string;
+  remotePeerKey: string;
+
+  topic: string;
   /**
    * Did local node initiate this connection.
    */

package/src/transport/webrtc/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './rtc-transport-factory';
+export * from './rtc-transport-proxy';
+export * from './rtc-transport-service';

package/src/transport/webrtc/rtc-connection-factory.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Mutex } from '@dxos/async';
+
+export type ConnectionInfo = {
+  initiator: boolean;
+};
+
+export interface RtcConnectionFactory {
+  initialize(): Promise<void>;
+  onConnectionDestroyed(): Promise<void>;
+  createConnection(config: RTCConfiguration): Promise<RTCPeerConnection>;
+  initConnection(connection: RTCPeerConnection, info: ConnectionInfo): Promise<void>;
+}
+
+/**
+ * Use built-in browser RTCPeerConnection.
+ */
+class BrowserRtcConnectionFactory implements RtcConnectionFactory {
+  async initialize() {}
+  async onConnectionDestroyed() {}
+
+  async createConnection(config: RTCConfiguration) {
+    return new RTCPeerConnection(config);
+  }
+
+  async initConnection(connection: RTCPeerConnection, info: ConnectionInfo): Promise<void> {}
+}
+
+/**
+ * Use `node-datachannel` polyfill.
+ * https://github.com/paullouisageneau/libdatachannel
+ */
+class NodeRtcConnectionFactory implements RtcConnectionFactory {
+  private static _createdConnections = 0;
+  private static _cleanupMutex = new Mutex();
+
+  // This should be inside the function to avoid triggering `eval` in the global scope.
+  // eslint-disable-next-line no-new-func
+
+  // 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: RTCConfiguration) {
+    return NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
+      const { RTCPeerConnection } = await import('#node-datachannel/polyfill');
+      NodeRtcConnectionFactory._createdConnections++;
+      return new RTCPeerConnection(config);
+    });
+  }
+
+  async initConnection(connection: RTCPeerConnection, info: ConnectionInfo): Promise<void> {
+    // Initiator peer is responsible for data-channel creation. This triggers the callback in browsers.
+    // In node-datachannel/polyfill createOffer() / setLocalDescription(offer) are no-ops, the process
+    // is handled by c++ implementation when a data-channel gets created.
+    // By calling the method here we'll start waiting for an offer promise that'll resolve on data-channel creation
+    // at which point we'll need to send an SDP to a remote peer.
+    // https://github.com/murat-dogan/node-datachannel/blob/master/polyfill/RTCPeerConnection.js#L452C1-L459C6
+    //
+    if (info.initiator) {
+      connection.onnegotiationneeded?.(null as any);
+    }
+  }
+}
+
+/**
+ * Create platform-specific connection factory.
+ */
+export const getRtcConnectionFactory = (): RtcConnectionFactory => {
+  return typeof (globalThis as any).RTCPeerConnection === 'undefined'
+    ? new NodeRtcConnectionFactory()
+    : new BrowserRtcConnectionFactory();
+};