@streamr/dht 103.3.0 → 103.6.0-rc.0

package/dist/exports-browser.js

@@ -1,3 +1,4 @@
+import 'timers-browserify';
 import { binaryToHex, hexToBinary, randomBytes, areEqualBinaries, Logger, computeMd5, Defer, MetricsContext, CountMetric, LevelMetric, RateMetric, waitForEvent, setAbortableTimeout, raceForEvent, ipv4ToNumber, wait, EcdsaSecp256k1Evm, Gate, withTimeout, scheduleAtInterval, MapWithTtl, executeSafePromise, merge, addManagedEventListener, until } from '@streamr/utils';
 import { EventEmitter } from 'eventemitter3';
 import sample from 'lodash/sample';
@@ -8,6 +9,7 @@ import { ServiceType, stackIntercept } from '@protobuf-ts/runtime-rpc';
 import { v4 } from 'uuid';
 import { ProtoCallContext, RpcCommunicator, toProtoRpcClient, protoClasses as protoClasses$1, RpcError } from '@streamr/proto-rpc';
 import ipaddr from 'ipaddr.js';
+import * as Comlink from 'comlink';
 import { w3cwebsocket } from 'websocket';
 import { SERVICE_ID } from '@streamr/autocertifier-client';
 import shuffle from 'lodash/shuffle';
@@ -1797,7 +1799,7 @@ const createRandomConnectionId = () => {
     return v4();
 };
 
-const logger$C = new Logger('ManagedConnection');
+const logger$D = new Logger('ManagedConnection');
 // ManagedConnection is a component used as a wrapper for IConnection after they have been successfully handshaked.
 // Should only be used in the ConnectionManager.
 class ManagedConnection extends EventEmitter {
@@ -1827,7 +1829,7 @@ class ManagedConnection extends EventEmitter {
         this.remotePeerDescriptor = peerDescriptor;
     }
     onDisconnected(gracefulLeave) {
-        logger$C.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave);
+        logger$D.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave);
         if (!this.replacedAsDuplicate) {
             this.emit('disconnected', gracefulLeave);
         }
@@ -1836,7 +1838,7 @@ class ManagedConnection extends EventEmitter {
     // TODO: Can this be removed if ManagedConnections can never be duplicates?
     // Handle duplicates in the ConncetorFacade and no longer have PendingConnections in ConnectionManager
     replaceAsDuplicate() {
-        logger$C.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
+        logger$D.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
         this.replacedAsDuplicate = true;
     }
     send(data) {
@@ -1983,10 +1985,10 @@ class RpcRemote {
     }
 }
 
-const logger$B = new Logger('ConnectionLockRpcRemote');
+const logger$C = new Logger('ConnectionLockRpcRemote');
 class ConnectionLockRpcRemote extends RpcRemote {
     async lockRequest(lockId) {
-        logger$B.trace(`Requesting locked connection to ${toNodeId(this.getPeerDescriptor())}`);
+        logger$C.trace(`Requesting locked connection to ${toNodeId(this.getPeerDescriptor())}`);
         const request = {
             lockId
         };
@@ -1996,12 +1998,12 @@ class ConnectionLockRpcRemote extends RpcRemote {
             return res.accepted;
         }
         catch (err) {
-            logger$B.debug('Connection lock rejected', { err });
+            logger$C.debug('Connection lock rejected', { err });
             return false;
         }
     }
     unlockRequest(lockId) {
-        logger$B.trace(`Requesting connection to be unlocked from ${toNodeId(this.getPeerDescriptor())}`);
+        logger$C.trace(`Requesting connection to be unlocked from ${toNodeId(this.getPeerDescriptor())}`);
         const request = {
             lockId
         };
@@ -2009,11 +2011,11 @@ class ConnectionLockRpcRemote extends RpcRemote {
             notification: true
         });
         this.getClient().unlockRequest(request, options).catch((_e) => {
-            logger$B.trace('failed to send unlockRequest');
+            logger$C.trace('failed to send unlockRequest');
         });
     }
     async gracefulDisconnect(disconnectMode) {
-        logger$B.trace(`Notifying a graceful disconnect to ${toNodeId(this.getPeerDescriptor())}`);
+        logger$C.trace(`Notifying a graceful disconnect to ${toNodeId(this.getPeerDescriptor())}`);
         const request = {
             disconnectMode
         };
@@ -2025,7 +2027,7 @@ class ConnectionLockRpcRemote extends RpcRemote {
         await this.getClient().gracefulDisconnect(request, options);
     }
     async setPrivate(isPrivate) {
-        logger$B.trace(`Setting isPrivate: ${isPrivate} for ${toNodeId(this.getPeerDescriptor())}`);
+        logger$C.trace(`Setting isPrivate: ${isPrivate} for ${toNodeId(this.getPeerDescriptor())}`);
         const request = {
             isPrivate
         };
@@ -2037,7 +2039,7 @@ class ConnectionLockRpcRemote extends RpcRemote {
     }
 }
 
-const logger$A = new Logger('ConnectionLockRpcLocal');
+const logger$B = new Logger('ConnectionLockRpcLocal');
 class ConnectionLockRpcLocal {
     options;
     constructor(options) {
@@ -2066,7 +2068,7 @@ class ConnectionLockRpcLocal {
     }
     async gracefulDisconnect(disconnectNotice, context) {
         const senderPeerDescriptor = context.incomingSourceDescriptor;
-        logger$A.trace(getNodeIdOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice');
+        logger$B.trace(getNodeIdOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice');
         if (disconnectNotice.disconnectMode === DisconnectMode.LEAVING) {
             await this.options.closeConnection(senderPeerDescriptor, true, 'graceful leave notified');
         }
@@ -2117,7 +2119,7 @@ var NatType;
     NatType["OPEN_INTERNET"] = "open_internet";
     NatType["UNKNOWN"] = "unknown";
 })(NatType || (NatType = {}));
-const logger$z = new Logger('ConnectionManager');
+const logger$A = new Logger('ConnectionManager');
 var ConnectionManagerState;
 (function (ConnectionManagerState) {
     ConnectionManagerState["IDLE"] = "idle";
@@ -2167,7 +2169,7 @@ class ConnectionManager extends EventEmitter {
             getLocalPeerDescriptor: () => this.getLocalPeerDescriptor(),
             setPrivate: (id, isPrivate) => {
                 if (!this.options.allowIncomingPrivateConnections) {
-                    logger$z.debug(`node ${id} attemted to set a connection as private, but it is not allowed`);
+                    logger$A.debug(`node ${id} attemted to set a connection as private, but it is not allowed`);
                     return;
                 }
                 if (isPrivate) {
@@ -2201,7 +2203,7 @@ class ConnectionManager extends EventEmitter {
                 const connection = endpoint.connection;
                 const nodeId = connection.getNodeId();
                 if (!this.locks.isLocked(nodeId) && !this.locks.isPrivate(nodeId) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
-                    logger$z.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()));
+                    logger$A.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()));
                     disconnectionCandidates.addContact(connection);
                 }
             }
@@ -2209,7 +2211,7 @@ class ConnectionManager extends EventEmitter {
         const disconnectables = disconnectionCandidates.getFurthestContacts(this.endpoints.size - maxConnections);
         for (const disconnectable of disconnectables) {
             const peerDescriptor = disconnectable.getPeerDescriptor();
-            logger$z.trace('garbageCollecting ' + toNodeId(peerDescriptor));
+            logger$A.trace('garbageCollecting ' + toNodeId(peerDescriptor));
             this.gracefullyDisconnectAsync(peerDescriptor, DisconnectMode.NORMAL).catch((_e) => { });
         }
     }
@@ -2218,11 +2220,11 @@ class ConnectionManager extends EventEmitter {
             throw new CouldNotStart(`Cannot start already ${this.state} module`);
         }
         this.state = ConnectionManagerState.RUNNING;
-        logger$z.trace(`Starting ConnectionManager...`);
+        logger$A.trace(`Starting ConnectionManager...`);
         await this.connectorFacade.start((connection) => this.onNewConnection(connection), (nodeId) => this.hasConnection(nodeId), this);
         // Garbage collection of connections
         this.disconnectorIntervalRef = setInterval(() => {
-            logger$z.trace('disconnectorInterval');
+            logger$A.trace('disconnectorInterval');
             const LAST_USED_LIMIT = 20000;
             this.garbageCollectConnections(this.options.maxConnections ?? 80, LAST_USED_LIMIT);
         }, 5000); // TODO use options option or named constant?
@@ -2232,7 +2234,7 @@ class ConnectionManager extends EventEmitter {
             return;
         }
         this.state = ConnectionManagerState.STOPPING;
-        logger$z.trace(`Stopping ConnectionManager`);
+        logger$A.trace(`Stopping ConnectionManager`);
         if (this.disconnectorIntervalRef) {
             clearInterval(this.disconnectorIntervalRef);
         }
@@ -2242,23 +2244,23 @@ class ConnectionManager extends EventEmitter {
                     await this.gracefullyDisconnectAsync(endpoint.connection.getPeerDescriptor(), DisconnectMode.LEAVING);
                 }
                 catch (e) {
-                    logger$z.error(e);
+                    logger$A.error(e);
                 }
             }
             else {
                 const connection = endpoint.connection;
-                logger$z.trace('handshake of connection not completed, force-closing');
+                logger$A.trace('handshake of connection not completed, force-closing');
                 // TODO use options option or named constant?
                 const eventReceived = waitForEvent(connection, 'disconnected', 2000);
                 // TODO should we have some handling for this floating promise?
                 connection.close(true);
                 try {
                     await eventReceived;
-                    logger$z.trace('resolving after receiving disconnected event from non-handshaked connection');
+                    logger$A.trace('resolving after receiving disconnected event from non-handshaked connection');
                 }
                 catch (e) {
                     endpoint.buffer.reject();
-                    logger$z.trace('force-closing non-handshaked connection timed out ' + e);
+                    logger$A.trace('force-closing non-handshaked connection timed out ' + e);
                 }
             }
         }));
@@ -2287,7 +2289,7 @@ class ConnectionManager extends EventEmitter {
             throw new CannotConnectToSelf('Cannot send to self');
         }
         const nodeId = toNodeId(peerDescriptor);
-        logger$z.trace(`Sending message to: ${nodeId}`);
+        logger$A.trace(`Sending message to: ${nodeId}`);
         message = {
             ...message,
             sourceDescriptor: this.getLocalPeerDescriptor()
@@ -2342,13 +2344,13 @@ class ConnectionManager extends EventEmitter {
     }
     handleMessage(message) {
         const messageType = message.body.oneofKind;
-        logger$z.trace('Received message of type ' + messageType);
+        logger$A.trace('Received message of type ' + messageType);
         if (messageType !== 'rpcMessage') {
-            logger$z.trace('Filtered out non-RPC message of type ' + messageType);
+            logger$A.trace('Filtered out non-RPC message of type ' + messageType);
             return;
         }
         if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger$z.trace('handleMessage filtered duplicate ' + toNodeId(message.sourceDescriptor)
+            logger$A.trace('handleMessage filtered duplicate ' + toNodeId(message.sourceDescriptor)
                 + ' ' + message.serviceId + ' ' + message.messageId);
             return;
         }
@@ -2357,7 +2359,7 @@ class ConnectionManager extends EventEmitter {
             this.rpcCommunicator?.handleMessageFromPeer(message);
         }
         else {
-            logger$z.trace('emit "message" ' + toNodeId(message.sourceDescriptor)
+            logger$A.trace('emit "message" ' + toNodeId(message.sourceDescriptor)
                 + ' ' + message.serviceId + ' ' + message.messageId);
             this.emit('message', message);
         }
@@ -2374,7 +2376,7 @@ class ConnectionManager extends EventEmitter {
         }
         catch (e) {
             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            logger$z.debug(`Parsing incoming data into Message failed: ${e}`);
+            logger$A.debug(`Parsing incoming data into Message failed: ${e}`);
             return;
         }
         message.sourceDescriptor = peerDescriptor;
@@ -2383,7 +2385,7 @@ class ConnectionManager extends EventEmitter {
         }
         catch (e) {
             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            logger$z.debug(`Handling incoming data failed: ${e}`);
+            logger$A.debug(`Handling incoming data failed: ${e}`);
         }
     }
     onConnected(peerDescriptor, connection) {
@@ -2396,7 +2398,7 @@ class ConnectionManager extends EventEmitter {
         const pendingConnection = endpoint.connection;
         const buffer = outputBuffer.getBuffer();
         while (buffer.length > 0) {
-            logger$z.trace('emptying buffer');
+            logger$A.trace('emptying buffer');
             managedConnection.send(buffer.shift());
         }
         outputBuffer.resolve();
@@ -2413,7 +2415,7 @@ class ConnectionManager extends EventEmitter {
     }
     onDisconnected(peerDescriptor, gracefulLeave) {
         const nodeId = toNodeId(peerDescriptor);
-        logger$z.trace(nodeId + ' onDisconnected() gracefulLeave: ' + gracefulLeave);
+        logger$A.trace(nodeId + ' onDisconnected() gracefulLeave: ' + gracefulLeave);
         const endpoint = this.endpoints.get(nodeId);
         if (endpoint) {
             this.locks.clearAllLocks(nodeId);
@@ -2421,7 +2423,7 @@ class ConnectionManager extends EventEmitter {
                 endpoint.buffer.reject();
             }
             this.endpoints.delete(nodeId);
-            logger$z.trace(nodeId + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave);
+            logger$A.trace(nodeId + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave);
             this.emit('disconnected', peerDescriptor, gracefulLeave);
             this.onConnectionCountChange();
         }
@@ -2430,7 +2432,7 @@ class ConnectionManager extends EventEmitter {
         if (this.state === ConnectionManagerState.STOPPED) {
             return false;
         }
-        logger$z.trace('onNewConnection()');
+        logger$A.trace('onNewConnection()');
         if (!this.acceptNewConnection(connection)) {
             return false;
         }
@@ -2440,7 +2442,7 @@ class ConnectionManager extends EventEmitter {
     }
     acceptNewConnection(newConnection) {
         const nodeId = toNodeId(newConnection.getPeerDescriptor());
-        logger$z.trace(nodeId + ' acceptNewConnection()');
+        logger$A.trace(nodeId + ' acceptNewConnection()');
         if (this.endpoints.has(nodeId)) {
             if (getOfferer(toNodeId(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
                 let buffer;
@@ -2449,14 +2451,14 @@ class ConnectionManager extends EventEmitter {
                 // Could be related to WS client connections not realizing that they have been disconnected.
                 // Makes refactoring duplicate connection handling to the connectors very difficult. 
                 if (this.endpoints.get(nodeId).connected) {
-                    logger$z.debug('replacing connected connection', { nodeId });
+                    logger$A.debug('replacing connected connection', { nodeId });
                     buffer = new OutputBuffer();
                 }
                 else {
                     buffer = endpoint.buffer;
                 }
                 const oldConnection = endpoint.connection;
-                logger$z.trace('replaced: ' + nodeId);
+                logger$A.trace('replaced: ' + nodeId);
                 oldConnection.replaceAsDuplicate();
                 this.endpoints.set(nodeId, { connected: false, connection: newConnection, buffer: buffer });
                 return true;
@@ -2465,7 +2467,7 @@ class ConnectionManager extends EventEmitter {
                 return false;
             }
         }
-        logger$z.trace(nodeId + ' added to connections at acceptNewConnection');
+        logger$A.trace(nodeId + ' added to connections at acceptNewConnection');
         this.endpoints.set(nodeId, {
             connected: false,
             buffer: new OutputBuffer(),
@@ -2475,14 +2477,14 @@ class ConnectionManager extends EventEmitter {
     }
     async closeConnection(peerDescriptor, gracefulLeave, reason) {
         const nodeId = toNodeId(peerDescriptor);
-        logger$z.trace(nodeId + ' ' + 'closeConnection() ' + reason);
+        logger$A.trace(nodeId + ' ' + 'closeConnection() ' + reason);
         this.locks.clearAllLocks(nodeId);
         if (this.endpoints.has(nodeId)) {
             const connectionToClose = this.endpoints.get(nodeId).connection;
             await connectionToClose.close(gracefulLeave);
         }
         else {
-            logger$z.trace(nodeId + ' ' + 'closeConnection() this.endpoints did not have the id');
+            logger$A.trace(nodeId + ' ' + 'closeConnection() this.endpoints did not have the id');
             this.emit('disconnected', peerDescriptor, false);
         }
     }
@@ -2494,8 +2496,8 @@ class ConnectionManager extends EventEmitter {
         const rpcRemote = new ConnectionLockRpcRemote(this.getLocalPeerDescriptor(), targetDescriptor, this.rpcCommunicator, ConnectionLockRpcClient);
         this.locks.addLocalLocked(nodeId, lockId);
         rpcRemote.lockRequest(lockId)
-            .then((_accepted) => logger$z.trace('LockRequest successful'))
-            .catch((err) => { logger$z.debug(err); });
+            .then((_accepted) => logger$A.trace('LockRequest successful'))
+            .catch((err) => { logger$A.debug(err); });
     }
     unlockConnection(targetDescriptor, lockId) {
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
@@ -2547,7 +2549,7 @@ class ConnectionManager extends EventEmitter {
     async gracefullyDisconnectAsync(targetDescriptor, disconnectMode) {
         const endpoint = this.endpoints.get(toNodeId(targetDescriptor));
         if (!endpoint) {
-            logger$z.debug('gracefullyDisconnectedAsync() tried on a non-existing connection');
+            logger$A.debug('gracefullyDisconnectedAsync() tried on a non-existing connection');
             return;
         }
         if (endpoint.connected) {
@@ -2556,15 +2558,15 @@ class ConnectionManager extends EventEmitter {
                 // TODO use options option or named constant?
                 // eslint-disable-next-line promise/catch-or-return
                 waitForEvent(connection, 'disconnected', 2000).then(() => {
-                    logger$z.trace('disconnected event received in gracefullyDisconnectAsync()');
+                    logger$A.trace('disconnected event received in gracefullyDisconnectAsync()');
                 })
                     .catch((e) => {
-                    logger$z.trace('force-closing connection after timeout ' + e);
+                    logger$A.trace('force-closing connection after timeout ' + e);
                     // TODO should we have some handling for this floating promise?
                     connection.close(true);
                 })
                     .finally(() => {
-                    logger$z.trace('resolving after receiving disconnected event');
+                    logger$A.trace('resolving after receiving disconnected event');
                     resolve();
                 });
             });
@@ -2579,13 +2581,13 @@ class ConnectionManager extends EventEmitter {
     }
     async doGracefullyDisconnectAsync(targetDescriptor, disconnectMode) {
         const nodeId = toNodeId(targetDescriptor);
-        logger$z.trace(nodeId + ' gracefullyDisconnectAsync()');
+        logger$A.trace(nodeId + ' gracefullyDisconnectAsync()');
         const rpcRemote = new ConnectionLockRpcRemote(this.getLocalPeerDescriptor(), targetDescriptor, this.rpcCommunicator, ConnectionLockRpcClient);
         try {
             await rpcRemote.gracefulDisconnect(disconnectMode);
         }
         catch (ex) {
-            logger$z.trace(nodeId + ' remote.gracefulDisconnect() failed' + ex);
+            logger$A.trace(nodeId + ' remote.gracefulDisconnect() failed' + ex);
         }
     }
     getConnections() {
@@ -2652,7 +2654,7 @@ function protoToString(protoObj, objectType) {
     return ret;
 }
 
-const logger$y = new Logger('SimulatorConnection');
+const logger$z = new Logger('SimulatorConnection');
 class SimulatorConnection extends Connection {
     stopped = false;
     localPeerDescriptor;
@@ -2674,46 +2676,46 @@ class SimulatorConnection extends Connection {
         this.doDisconnect = this.doDisconnect.bind(this);
     }
     send(data) {
-        logger$y.trace('send()');
+        logger$z.trace('send()');
         if (!this.stopped) {
             this.simulator.send(this, data);
         }
         else {
             const localNodeId = toNodeId(this.localPeerDescriptor);
             const targetNodeId = toNodeId(this.targetPeerDescriptor);
-            logger$y.error(localNodeId + ', ' + targetNodeId + 'tried to send() on a stopped connection');
+            logger$z.error(localNodeId + ', ' + targetNodeId + 'tried to send() on a stopped connection');
         }
     }
     async close(gracefulLeave) {
         const localNodeId = toNodeId(this.localPeerDescriptor);
         const targetNodeId = toNodeId(this.targetPeerDescriptor);
-        logger$y.trace(localNodeId + ', ' + targetNodeId + ' close()');
+        logger$z.trace(localNodeId + ', ' + targetNodeId + ' close()');
         if (!this.stopped) {
-            logger$y.trace(localNodeId + ', ' + targetNodeId + ' close() not stopped');
+            logger$z.trace(localNodeId + ', ' + targetNodeId + ' close() not stopped');
             this.stopped = true;
             try {
-                logger$y.trace(localNodeId + ', ' + targetNodeId + ' close() calling simulator.disconnect()');
+                logger$z.trace(localNodeId + ', ' + targetNodeId + ' close() calling simulator.disconnect()');
                 this.simulator.close(this);
-                logger$y.trace(localNodeId + ', ' + targetNodeId + ' close() simulator.disconnect returned');
+                logger$z.trace(localNodeId + ', ' + targetNodeId + ' close() simulator.disconnect returned');
             }
             catch (e) {
-                logger$y.trace(localNodeId + ', ' + targetNodeId + 'close aborted' + e);
+                logger$z.trace(localNodeId + ', ' + targetNodeId + 'close aborted' + e);
             }
             finally {
-                logger$y.trace(localNodeId + ', ' + targetNodeId + ' calling this.doDisconnect');
+                logger$z.trace(localNodeId + ', ' + targetNodeId + ' calling this.doDisconnect');
                 this.doDisconnect(gracefulLeave);
             }
         }
         else {
-            logger$y.trace(localNodeId + ', ' + targetNodeId + ' close() tried to close a stopped connection');
+            logger$z.trace(localNodeId + ', ' + targetNodeId + ' close() tried to close a stopped connection');
         }
     }
     connect() {
         if (!this.stopped) {
-            logger$y.trace('connect() called');
+            logger$z.trace('connect() called');
             this.simulator.connect(this, this.targetPeerDescriptor, (error) => {
                 if (error !== undefined) {
-                    logger$y.trace(error);
+                    logger$z.trace(error);
                     this.doDisconnect(false);
                 }
                 else {
@@ -2722,46 +2724,46 @@ class SimulatorConnection extends Connection {
             });
         }
         else {
-            logger$y.trace('tried to connect() a stopped connection');
+            logger$z.trace('tried to connect() a stopped connection');
         }
     }
     handleIncomingData(data) {
         if (!this.stopped) {
-            logger$y.trace('handleIncomingData() ' + protoToString(Message.fromBinary(data), Message));
+            logger$z.trace('handleIncomingData() ' + protoToString(Message.fromBinary(data), Message));
             this.emit('data', data);
         }
         else {
-            logger$y.trace('tried to call handleIncomingData() a stopped connection');
+            logger$z.trace('tried to call handleIncomingData() a stopped connection');
         }
     }
     handleIncomingDisconnection() {
         if (!this.stopped) {
             const localNodeId = toNodeId(this.localPeerDescriptor);
-            logger$y.trace(localNodeId + ' handleIncomingDisconnection()');
+            logger$z.trace(localNodeId + ' handleIncomingDisconnection()');
             this.stopped = true;
             this.doDisconnect(false);
         }
         else {
-            logger$y.trace('tried to call handleIncomingDisconnection() a stopped connection');
+            logger$z.trace('tried to call handleIncomingDisconnection() a stopped connection');
         }
     }
     destroy() {
         const localNodeId = toNodeId(this.localPeerDescriptor);
         if (!this.stopped) {
-            logger$y.trace(localNodeId + ' destroy()');
+            logger$z.trace(localNodeId + ' destroy()');
             this.removeAllListeners();
             this.close(false).catch((_e) => { });
         }
         else {
-            logger$y.trace(localNodeId + ' tried to call destroy() a stopped connection');
+            logger$z.trace(localNodeId + ' tried to call destroy() a stopped connection');
         }
     }
     doDisconnect(gracefulLeave) {
         const localNodeId = toNodeId(this.localPeerDescriptor);
         const targetNodeId = toNodeId(this.targetPeerDescriptor);
-        logger$y.trace(localNodeId + ' doDisconnect()');
+        logger$z.trace(localNodeId + ' doDisconnect()');
         this.stopped = true;
-        logger$y.trace(localNodeId + ', ' + targetNodeId + ' doDisconnect emitting');
+        logger$z.trace(localNodeId + ', ' + targetNodeId + ' doDisconnect emitting');
         this.emit('disconnected', gracefulLeave);
     }
 }
@@ -2799,9 +2801,9 @@ const parseVersion = (version) => {
     }
 };
 
-var version = "103.3.0";
+var version = "103.6.0-rc.0";
 
-const logger$x = new Logger('Handshaker');
+const logger$y = new Logger('Handshaker');
 // Optimally the Outgoing and Incoming Handshakers could be their own separate classes
 // However, in cases where the PeerDescriptor of the other end of the connection can be known
 // only after a HandshakeRequest a base Handshaker class is needed as the IncomingHandshaker currently
@@ -2823,7 +2825,7 @@ const createOutgoingHandshaker = (localPeerDescriptor, pendingConnection, connec
         }
     };
     const handshakeCompletedListener = (peerDescriptor) => {
-        logger$x.trace('handshake completed for outgoing connection, ' + toNodeId(peerDescriptor));
+        logger$y.trace('handshake completed for outgoing connection, ' + toNodeId(peerDescriptor));
         pendingConnection.onHandshakeCompleted(connection);
         stopHandshaker();
     };
@@ -2923,12 +2925,12 @@ class Handshaker extends EventEmitter {
         try {
             const message = Message.fromBinary(data);
             if (message.body.oneofKind === 'handshakeRequest') {
-                logger$x.trace('handshake request received');
+                logger$y.trace('handshake request received');
                 const handshake = message.body.handshakeRequest;
                 this.emit('handshakeRequest', handshake.sourcePeerDescriptor, handshake.protocolVersion, handshake.targetPeerDescriptor);
             }
             if (message.body.oneofKind === 'handshakeResponse') {
-                logger$x.trace('handshake response received');
+                logger$y.trace('handshake response received');
                 const handshake = message.body.handshakeResponse;
                 const error = !isMaybeSupportedProtocolVersion(handshake.protocolVersion)
                     ? HandshakeError.UNSUPPORTED_PROTOCOL_VERSION : handshake.error;
@@ -2941,18 +2943,18 @@ class Handshaker extends EventEmitter {
             }
         }
         catch (err) {
-            logger$x.debug('error while parsing handshake message', err);
+            logger$y.debug('error while parsing handshake message', err);
         }
     }
     sendHandshakeRequest(remotePeerDescriptor) {
         const msg = createHandshakeRequest(this.localPeerDescriptor, remotePeerDescriptor);
         this.connection.send(Message.toBinary(msg));
-        logger$x.trace('handshake request sent');
+        logger$y.trace('handshake request sent');
     }
     sendHandshakeResponse(error) {
         const msg = createHandshakeResponse(this.localPeerDescriptor, error);
         this.connection.send(Message.toBinary(msg));
-        logger$x.trace('handshake response sent');
+        logger$y.trace('handshake response sent');
     }
     stop() {
         this.connection.off('data', this.onDataListener);
@@ -2960,7 +2962,7 @@ class Handshaker extends EventEmitter {
     }
 }
 
-const logger$w = new Logger('PendingConnection');
+const logger$x = new Logger('PendingConnection');
 // PendingConnection is used as a reference to a connection that should be opened and handshaked to a given PeerDescriptor
 // It does not hold a connection internally. The public method onHandshakedCompleted should be called once a connection for the 
 // remotePeerDescriptor is opened and handshaked successfully.
@@ -2978,7 +2980,7 @@ class PendingConnection extends EventEmitter {
         }, timeout, this.connectingAbortController.signal);
     }
     replaceAsDuplicate() {
-        logger$w.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
+        logger$x.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
         this.replacedAsDuplicate = true;
     }
     onHandshakeCompleted(connection) {
@@ -3009,7 +3011,7 @@ class PendingConnection extends EventEmitter {
     }
 }
 
-const logger$v = new Logger('SimulatorConnector');
+const logger$w = new Logger('SimulatorConnector');
 class SimulatorConnector {
     connectingConnections = new Map();
     stopped = false;
@@ -3022,7 +3024,7 @@ class SimulatorConnector {
         this.onNewConnection = onNewConnection;
     }
     connect(targetPeerDescriptor) {
-        logger$v.trace('connect() ' + toNodeId(targetPeerDescriptor));
+        logger$w.trace('connect() ' + toNodeId(targetPeerDescriptor));
         const nodeId = toNodeId(targetPeerDescriptor);
         const existingConnection = this.connectingConnections.get(nodeId);
         if (existingConnection) {
@@ -3051,18 +3053,18 @@ class SimulatorConnector {
         // connection is incoming, so remotePeerDescriptor is localPeerDescriptor
         const remotePeerDescriptor = sourceConnection.localPeerDescriptor;
         const remoteNodeId = toNodeId(sourceConnection.localPeerDescriptor);
-        logger$v.trace(remoteNodeId + ' incoming connection, stopped: ' + this.stopped);
+        logger$w.trace(remoteNodeId + ' incoming connection, stopped: ' + this.stopped);
         if (this.stopped) {
             return;
         }
         const connection = new SimulatorConnection(this.localPeerDescriptor, remotePeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator);
         const pendingConnection = new PendingConnection(remotePeerDescriptor);
         const handshaker = createIncomingHandshaker(this.localPeerDescriptor, pendingConnection, connection);
-        logger$v.trace('connected');
+        logger$w.trace('connected');
         handshaker.once('handshakeRequest', () => {
-            logger$v.trace(remoteNodeId + ' incoming handshake request');
+            logger$w.trace(remoteNodeId + ' incoming handshake request');
             if (this.onNewConnection(pendingConnection)) {
-                logger$v.trace(remoteNodeId + ' calling acceptHandshake');
+                logger$w.trace(remoteNodeId + ' calling acceptHandshake');
                 acceptHandshake(handshaker, pendingConnection, connection);
             }
             else {
@@ -3102,6 +3104,8 @@ class ListeningRpcCommunicator extends RoutingRpcCommunicator {
     }
 }
 
+const isWorkerEnvironment = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
+
 var RtcDescription;
 (function (RtcDescription) {
     RtcDescription["OFFER"] = "offer";
@@ -3116,8 +3120,8 @@ var DisconnectedRtcPeerConnectionStateEnum;
     DisconnectedRtcPeerConnectionStateEnum["FAILED"] = "failed";
     DisconnectedRtcPeerConnectionStateEnum["CLOSED"] = "closed";
 })(DisconnectedRtcPeerConnectionStateEnum || (DisconnectedRtcPeerConnectionStateEnum = {}));
-const logger$u = new Logger('WebrtcConnection (browser)');
-class WebrtcConnection extends EventEmitter {
+const logger$v = new Logger('DirectWebrtcConnection (browser)');
+class DirectWebrtcConnection extends EventEmitter {
     connectionId;
     connectionType = ConnectionType.WEBRTC;
     // We need to keep track of connection state ourselves because
@@ -3155,7 +3159,7 @@ class WebrtcConnection extends EventEmitter {
             }
         };
         this.peerConnection.onicegatheringstatechange = () => {
-            logger$u.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`);
+            logger$v.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`);
         };
         this.peerConnection.onconnectionstatechange = () => this.onStateChange();
         if (isOffering) {
@@ -3166,7 +3170,7 @@ class WebrtcConnection extends EventEmitter {
                         await this.peerConnection.setLocalDescription();
                     }
                     catch (err) {
-                        logger$u.warn('Failed to set local description', { err });
+                        logger$v.warn('Failed to set local description', { err });
                     }
                     if (this.peerConnection.localDescription !== null) {
                         this.emit('localDescription', this.peerConnection.localDescription?.sdp, this.peerConnection.localDescription?.type);
@@ -3194,14 +3198,14 @@ class WebrtcConnection extends EventEmitter {
             clearTimeout(this.earlyTimeout);
         }
         catch (err) {
-            logger$u.warn('Failed to set remote description', { err });
+            logger$v.warn('Failed to set remote description', { err });
         }
         if ((type.toLowerCase() === RtcDescription.OFFER) && (this.peerConnection !== undefined)) {
             try {
                 await this.peerConnection.setLocalDescription();
             }
             catch (err) {
-                logger$u.warn('Failed to set local description', { err });
+                logger$v.warn('Failed to set local description', { err });
             }
             if (this.peerConnection.localDescription !== null) {
                 this.emit('localDescription', this.peerConnection.localDescription.sdp, this.peerConnection.localDescription.type);
@@ -3211,7 +3215,7 @@ class WebrtcConnection extends EventEmitter {
     addRemoteCandidate(candidate, mid) {
         this.peerConnection?.addIceCandidate({ candidate: candidate, sdpMid: mid })
             .catch((err) => {
-            logger$u.warn('Failed to add ICE candidate', { err });
+            logger$v.warn('Failed to add ICE candidate', { err });
         });
     }
     isOpen() {
@@ -3234,7 +3238,7 @@ class WebrtcConnection extends EventEmitter {
                     this.dataChannel.close();
                 }
                 catch (err) {
-                    logger$u.warn('Failed to close data channel', { err });
+                    logger$v.warn('Failed to close data channel', { err });
                 }
             }
             this.dataChannel = undefined;
@@ -3243,7 +3247,7 @@ class WebrtcConnection extends EventEmitter {
                     this.peerConnection.close();
                 }
                 catch (err) {
-                    logger$u.warn('Failed to close connection', { err });
+                    logger$v.warn('Failed to close connection', { err });
                 }
             }
             this.peerConnection = undefined;
@@ -3263,7 +3267,7 @@ class WebrtcConnection extends EventEmitter {
             }
         }
         else {
-            logger$u.warn('Tried to send on a connection with last state ' + this.lastState);
+            logger$v.warn('Tried to send on a connection with last state ' + this.lastState);
         }
     }
     setupDataChannel(dataChannel) {
@@ -3271,22 +3275,22 @@ class WebrtcConnection extends EventEmitter {
         this.dataChannel.binaryType = 'arraybuffer';
         this.dataChannel.bufferedAmountLowThreshold = this.bufferThresholdLow;
         dataChannel.onopen = () => {
-            logger$u.trace('dc.onOpen');
+            logger$v.trace('dc.onOpen');
             this.onDataChannelOpen();
         };
         dataChannel.onclose = () => {
-            logger$u.trace('dc.onClosed');
+            logger$v.trace('dc.onClosed');
             this.doClose(false);
         };
         dataChannel.onerror = (err) => {
-            logger$u.warn('Data channel error', { err });
+            logger$v.warn('Data channel error', { err });
         };
         dataChannel.onmessage = (msg) => {
-            logger$u.trace('dc.onmessage');
+            logger$v.trace('dc.onmessage');
             this.emit('data', new Uint8Array(msg.data));
         };
         dataChannel.onbufferedamountlow = () => {
-            logger$u.trace('dc.onBufferedAmountLow');
+            logger$v.trace('dc.onBufferedAmountLow');
             while (this.messageQueue.length > 0 && this.dataChannel.bufferedAmount < this.bufferThresholdHigh) {
                 const data = this.messageQueue.shift();
                 this.dataChannel.send(data);
@@ -3325,6 +3329,431 @@ class WebrtcConnection extends EventEmitter {
     }
 }
 
+/**
+ * WebrtcBridge — runs on the MAIN THREAD.
+ *
+ * Manages RTCPeerConnection instances on behalf of a worker that cannot
+ * access them directly.  Each logical connection is identified by a
+ * `connectionId` string supplied by the worker.
+ *
+ * Signaling (ICE candidates, SDP offers/answers, connection-state changes)
+ * is relayed to the worker through Comlink proxy callbacks.
+ *
+ * Once a DataChannel is created (offerer) or received (answerer) it is
+ * **transferred** to the worker so that all data-path events fire inside
+ * the worker's event loop — the main thread never touches data traffic.
+ */
+// ── Bridge implementation ───────────────────────────────────────────
+class WebrtcBridge {
+    connections = new Map();
+    async start(connectionId, iceServers, isOffering, callbacks) {
+        const pc = new RTCPeerConnection({ iceServers });
+        const conn = {
+            pc,
+            callbacks,
+            isOffering,
+            makingOffer: false,
+        };
+        this.connections.set(connectionId, conn);
+        // ── ICE candidates ──────────────────────────────────────
+        pc.onicecandidate = (event) => {
+            if (event.candidate !== null && event.candidate.sdpMid !== null) {
+                callbacks.onLocalCandidate(event.candidate.candidate, event.candidate.sdpMid);
+            }
+        };
+        // ── Connection state → forwarded to worker ──────────────
+        pc.onconnectionstatechange = () => {
+            callbacks.onConnectionStateChange(pc.connectionState);
+        };
+        // ── Offerer path ────────────────────────────────────────
+        if (isOffering) {
+            pc.onnegotiationneeded = async () => {
+                conn.makingOffer = true;
+                try {
+                    await pc.setLocalDescription();
+                }
+                catch (_err) {
+                    // intentionally swallowed – mirrors DirectWebrtcConnection
+                }
+                if (pc.localDescription !== null) {
+                    callbacks.onLocalDescription(pc.localDescription.sdp, pc.localDescription.type);
+                }
+                conn.makingOffer = false;
+            };
+            const dc = pc.createDataChannel('streamrDataChannel');
+            // Transfer DataChannel ownership to the worker immediately.
+            // The worker will attach onopen/onclose/onmessage handlers.
+            callbacks.onDataChannel(Comlink.transfer(dc, [dc]));
+        }
+        else {
+            // ── Answerer path ───────────────────────────────────
+            pc.ondatachannel = (event) => {
+                callbacks.onDataChannel(Comlink.transfer(event.channel, [event.channel]));
+            };
+        }
+    }
+    async setRemoteDescription(connectionId, description, type) {
+        const conn = this.connections.get(connectionId);
+        if (!conn) {
+            return false;
+        }
+        const lowerType = type.toLowerCase();
+        // Perfect-negotiation collision detection
+        const offerCollision = lowerType === 'offer' &&
+            (conn.makingOffer || conn.pc.signalingState !== 'stable');
+        if (conn.isOffering && offerCollision) {
+            return false;
+        }
+        try {
+            await conn.pc.setRemoteDescription({ sdp: description, type: lowerType });
+        }
+        catch (_err) {
+            return false;
+        }
+        // If we received an offer, create an answer
+        if (lowerType === 'offer') {
+            try {
+                await conn.pc.setLocalDescription();
+            }
+            catch (_err) {
+                // intentionally swallowed
+            }
+            if (conn.pc.localDescription !== null) {
+                conn.callbacks.onLocalDescription(conn.pc.localDescription.sdp, conn.pc.localDescription.type);
+            }
+        }
+        return true;
+    }
+    async addRemoteCandidate(connectionId, candidate, mid) {
+        const conn = this.connections.get(connectionId);
+        if (!conn) {
+            return;
+        }
+        try {
+            await conn.pc.addIceCandidate({ candidate, sdpMid: mid });
+        }
+        catch (_err) {
+            // intentionally swallowed
+        }
+    }
+    async renameConnection(oldId, newId) {
+        const conn = this.connections.get(oldId);
+        if (conn) {
+            this.connections.delete(oldId);
+            this.connections.set(newId, conn);
+        }
+    }
+    async close(connectionId) {
+        const conn = this.connections.get(connectionId);
+        if (!conn) {
+            return;
+        }
+        this.connections.delete(connectionId);
+        // Tear down event handlers
+        conn.pc.onicecandidate = null;
+        conn.pc.onconnectionstatechange = null;
+        conn.pc.onnegotiationneeded = null;
+        conn.pc.ondatachannel = null;
+        try {
+            conn.pc.close();
+        }
+        catch (_err) {
+            // intentionally swallowed
+        }
+    }
+}
+
+/**
+ * Call this function on the **main thread** before the worker starts using
+ * WebRTC connections.  It creates a dedicated `MessageChannel`, exposes a
+ * {@link WebrtcBridge} instance on one port, and sends the other port to
+ * the worker so that `WorkerWebrtcConnection` can reach the bridge.
+ *
+ * @example
+ * ```ts
+ * import { installWebrtcBridge } from '@streamr/dht'
+ *
+ * const worker = new Worker('./my-worker.ts', { type: 'module' })
+ * installWebrtcBridge(worker)
+ * ```
+ */
+const WEBRTC_BRIDGE_PORT_MESSAGE_TYPE = 'streamr-webrtc-bridge-port';
+function installWebrtcBridge(worker) {
+    const bridge = new WebrtcBridge();
+    const channel = new MessageChannel();
+    // Expose the bridge API on port1 — the worker will Comlink.wrap(port2).
+    Comlink.expose(bridge, channel.port1);
+    // Send port2 to the worker.  It is transferred (not cloned).
+    worker.postMessage({ type: WEBRTC_BRIDGE_PORT_MESSAGE_TYPE, port: channel.port2 }, [channel.port2]);
+}
+
+/**
+ * WorkerWebrtcConnection — runs inside a **Web Worker**.
+ *
+ * Implements the same IWebrtcConnection + IConnection interfaces as
+ * DirectWebrtcConnection, but delegates RTCPeerConnection management to
+ * the main-thread {@link WebrtcBridge} via Comlink.
+ *
+ * The RTCDataChannel is **transferred** from the main thread and lives
+ * entirely in the worker — all data events (onmessage, onopen, onclose,
+ * onbufferedamountlow) fire in the worker's event loop.  The main thread
+ * is never involved in the data path.
+ */
+// ── Module-level bridge client (initialized once per worker) ────────
+let resolveBridgeProxy;
+const bridgeProxyPromise = new Promise((resolve) => {
+    resolveBridgeProxy = resolve;
+});
+// Listen for the bridge port message from the main thread.
+// This is guarded so it only runs inside a worker context.
+if (isWorkerEnvironment) {
+    const handler = (e) => {
+        if (e.data?.type === WEBRTC_BRIDGE_PORT_MESSAGE_TYPE && e.data.port) {
+            const proxy = Comlink.wrap(e.data.port);
+            resolveBridgeProxy(proxy);
+            self.removeEventListener('message', handler);
+        }
+    };
+    self.addEventListener('message', handler);
+}
+function getBridgeProxy() {
+    return bridgeProxyPromise;
+}
+// ── Disconnection states ────────────────────────────────────────────
+var DisconnectedState;
+(function (DisconnectedState) {
+    DisconnectedState["DISCONNECTED"] = "disconnected";
+    DisconnectedState["FAILED"] = "failed";
+    DisconnectedState["CLOSED"] = "closed";
+})(DisconnectedState || (DisconnectedState = {}));
+const logger$u = new Logger('WorkerWebrtcConnection');
+// ── WorkerWebrtcConnection ──────────────────────────────────────────
+class WorkerWebrtcConnection extends EventEmitter {
+    connectionId;
+    connectionType = ConnectionType.WEBRTC;
+    iceServers;
+    bufferThresholdHigh;
+    bufferThresholdLow;
+    dataChannel;
+    bridge;
+    closed = false;
+    connected = false;
+    earlyTimeout;
+    messageQueue = [];
+    startPromise;
+    constructor(params) {
+        super();
+        this.connectionId = createRandomConnectionId();
+        this.iceServers = params.iceServers ?? [];
+        this.bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17;
+        this.bufferThresholdLow = params.bufferThresholdLow ?? 2 ** 15;
+        this.earlyTimeout = setTimeout(() => {
+            this.doClose(false, 'timed out due to remote descriptor not being set');
+        }, EARLY_TIMEOUT);
+    }
+    // ── IWebrtcConnection ───────────────────────────────────────
+    start(isOffering) {
+        this.startPromise = this.doStart(isOffering);
+        this.startPromise.catch((err) => {
+            logger$u.warn('Failed to start worker WebRTC connection', { err });
+            this.doClose(false, 'Failed to start');
+        });
+    }
+    async doStart(isOffering) {
+        this.bridge = await getBridgeProxy();
+        const iceServers = this.iceServers.map(({ url, port, username, password }) => ({
+            urls: `${url}:${port}`,
+            username,
+            credential: password,
+        }));
+        await this.bridge.start(this.connectionId, iceServers, isOffering, Comlink.proxy({
+            onLocalCandidate: (candidate, mid) => {
+                if (!this.closed) {
+                    this.emit('localCandidate', candidate, mid);
+                }
+            },
+            onLocalDescription: (description, type) => {
+                if (!this.closed) {
+                    this.emit('localDescription', description, type);
+                }
+            },
+            onConnectionStateChange: (state) => {
+                if (state === DisconnectedState.CLOSED ||
+                    state === DisconnectedState.DISCONNECTED ||
+                    state === DisconnectedState.FAILED) {
+                    this.doClose(false);
+                }
+            },
+            onDataChannel: (channel) => {
+                if (!this.closed) {
+                    this.setupDataChannel(channel);
+                    // If the channel was already open at transfer time
+                    if (channel.readyState === 'open') {
+                        this.onDataChannelOpen();
+                    }
+                }
+            },
+        }));
+    }
+    async setRemoteDescription(description, type) {
+        if (this.startPromise) {
+            await this.startPromise;
+        }
+        if (!this.bridge || this.closed) {
+            return;
+        }
+        const wasSet = await this.bridge.setRemoteDescription(this.connectionId, description, type);
+        if (wasSet) {
+            clearTimeout(this.earlyTimeout);
+        }
+    }
+    addRemoteCandidate(candidate, mid) {
+        this.doAddRemoteCandidate(candidate, mid).catch((err) => {
+            logger$u.warn('Failed to add remote candidate via bridge', { err });
+        });
+    }
+    async doAddRemoteCandidate(candidate, mid) {
+        if (this.startPromise) {
+            await this.startPromise;
+        }
+        if (!this.bridge || this.closed) {
+            return;
+        }
+        await this.bridge.addRemoteCandidate(this.connectionId, candidate, mid);
+    }
+    isOpen() {
+        return this.connected;
+    }
+    // ── IConnection ─────────────────────────────────────────────
+    async close(gracefulLeave, reason) {
+        this.doClose(gracefulLeave, reason);
+    }
+    destroy() {
+        this.removeAllListeners();
+        this.doClose(false);
+    }
+    send(data) {
+        if (this.connected && this.dataChannel) {
+            if (this.dataChannel.bufferedAmount > this.bufferThresholdHigh) {
+                this.messageQueue.push(data);
+            }
+            else {
+                this.dataChannel.send(data);
+            }
+        }
+        else if (!this.closed) {
+            this.messageQueue.push(data);
+        }
+    }
+    setConnectionId(connectionId) {
+        const oldId = this.connectionId;
+        this.connectionId = connectionId;
+        if (this.bridge && oldId !== connectionId) {
+            this.bridge.renameConnection(oldId, connectionId).catch(() => { });
+        }
+    }
+    // ── DataChannel handling (runs entirely in the worker) ──────
+    setupDataChannel(dataChannel) {
+        this.dataChannel = dataChannel;
+        this.dataChannel.binaryType = 'arraybuffer';
+        this.dataChannel.bufferedAmountLowThreshold = this.bufferThresholdLow;
+        dataChannel.onopen = () => {
+            logger$u.trace('dc.onOpen (worker)');
+            this.onDataChannelOpen();
+        };
+        dataChannel.onclose = () => {
+            logger$u.trace('dc.onClosed (worker)');
+            this.doClose(false);
+        };
+        dataChannel.onerror = (err) => {
+            logger$u.warn('Data channel error (worker)', { err });
+        };
+        dataChannel.onmessage = (msg) => {
+            logger$u.trace('dc.onmessage (worker)');
+            this.emit('data', new Uint8Array(msg.data));
+        };
+        dataChannel.onbufferedamountlow = () => {
+            logger$u.trace('dc.onBufferedAmountLow (worker)');
+            while (this.messageQueue.length > 0 &&
+                this.dataChannel.bufferedAmount < this.bufferThresholdHigh) {
+                const data = this.messageQueue.shift();
+                this.dataChannel.send(data);
+            }
+        };
+    }
+    onDataChannelOpen() {
+        this.connected = true;
+        this.flushMessageQueue();
+        this.emit('connected');
+    }
+    flushMessageQueue() {
+        while (this.messageQueue.length > 0 &&
+            this.dataChannel &&
+            this.dataChannel.bufferedAmount < this.bufferThresholdHigh) {
+            const data = this.messageQueue.shift();
+            this.dataChannel.send(data);
+        }
+    }
+    // ── Teardown ────────────────────────────────────────────────
+    doClose(gracefulLeave, reason) {
+        if (!this.closed) {
+            this.closed = true;
+            this.connected = false;
+            this.messageQueue.length = 0;
+            clearTimeout(this.earlyTimeout);
+            this.stopListening();
+            this.emit('disconnected', gracefulLeave, undefined, reason);
+            this.removeAllListeners();
+            if (this.dataChannel !== undefined) {
+                try {
+                    this.dataChannel.close();
+                }
+                catch (err) {
+                    logger$u.warn('Failed to close data channel (worker)', { err });
+                }
+            }
+            this.dataChannel = undefined;
+            // Tell the main-thread bridge to tear down the RTCPeerConnection.
+            // Fire-and-forget — we don't block on this.
+            this.bridge
+                ?.close(this.connectionId)
+                .catch(() => {
+                // intentionally swallowed
+            });
+        }
+    }
+    stopListening() {
+        if (this.dataChannel !== undefined) {
+            this.dataChannel.onopen = null;
+            this.dataChannel.onclose = null;
+            this.dataChannel.onerror = null;
+            this.dataChannel.onbufferedamountlow = null;
+            this.dataChannel.onmessage = null;
+        }
+    }
+}
+
+/**
+ * Conditional re-export of the browser WebrtcConnection.
+ *
+ * At module-load time we detect whether we are running inside a Web Worker.
+ * - **Main thread** → use {@link DirectWebrtcConnection} which owns the
+ *   `RTCPeerConnection` and `RTCDataChannel` directly.
+ * - **Worker thread** → use {@link WorkerWebrtcConnection} which delegates
+ *   `RTCPeerConnection` signaling to the main thread via a Comlink bridge
+ *   and receives a transferred `RTCDataChannel` that lives entirely in the
+ *   worker.
+ *
+ * Both classes implement `IWebrtcConnection & IConnection` and expose the
+ * same public API, so upstream code (WebrtcConnector, etc.) is unaffected.
+ */
+// The constructor — points to the right class based on the runtime
+// environment.  The type assertion is safe because both implementations
+// share the same public interface surface.
+const WebrtcConnection = (isWorkerEnvironment
+    ? WorkerWebrtcConnection
+    : DirectWebrtcConnection);
+
 const logger$t = new Logger('WebrtcConnectorRpcRemote');
 class WebrtcConnectorRpcRemote extends RpcRemote {
     requestConnection() {
@@ -7607,5 +8036,5 @@ class SimulatorTransport extends ConnectionManager {
     }
 }
 
-export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, randomDhtAddress, toDhtAddress, toDhtAddressRaw, toNodeId };
+export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, installWebrtcBridge, randomDhtAddress, toDhtAddress, toDhtAddressRaw, toNodeId };
 //# sourceMappingURL=exports-browser.js.map