@streamr/sdk 103.3.1 → 103.7.0-rc.2

package/dist/exports-umd.js

@@ -41288,6 +41288,22 @@
 	        cb();
 	    }, ms);
 	};
+	/**
+	 * setInterval with AbortSignal support. Aborting will simply clear
+	 * the interval silently.
+	 */
+	const setAbortableInterval = (cb, ms, abortSignal) => {
+	    if (abortSignal.aborted) {
+	        return;
+	    }
+	    const abortListener = () => {
+	        clearInterval(timeoutRef);
+	    };
+	    abortSignal.addEventListener('abort', abortListener, { once: true });
+	    const timeoutRef = setInterval(() => {
+	        cb();
+	    }, ms);
+	};
 
 	const noopExecutor = () => { };
 	/**
@@ -73321,7 +73337,7 @@
 	    }
 	}
 
-	const logger$D = new Logger('LoggingJsonRpcProvider');
+	const logger$E = new Logger('LoggingJsonRpcProvider');
 	class LoggingJsonRpcProvider extends JsonRpcProvider {
 	    urlConfig;
 	    constructor(urlConfig, network, options) {
@@ -73340,20 +73356,20 @@
 	                timeout: this.urlConfig.timeout
 	            }
 	        };
-	        logger$D.debug('Send request', logContext);
+	        logger$E.debug('Send request', logContext);
 	        let result;
 	        try {
 	            result = await super.send(method, params);
 	        }
 	        catch (err) {
-	            logger$D.debug('Encountered error while requesting', {
+	            logger$E.debug('Encountered error while requesting', {
 	                ...logContext,
 	                err,
 	                elapsedTime: Date.now() - startTime
 	            });
 	            throw err;
 	        }
-	        logger$D.debug('Received response', {
+	        logger$E.debug('Received response', {
 	            ...logContext,
 	            elapsedTime: Date.now() - startTime
 	        });
@@ -80246,7 +80262,7 @@
 	                this.deferredPromises.trailer.resolve({});
 	            }
 	            catch (err) {
-	                logger$y.debug(`Could not parse response, received message is likely `);
+	                logger$z.debug(`Could not parse response, received message is likely `);
 	                const error = new FailedToParse(`Failed to parse received response, network protocol version likely is likely incompatible`, err);
 	                this.rejectDeferredPromises(error, StatusCode.SERVER_ERROR);
 	            }
@@ -80267,7 +80283,7 @@
 	        return this.callContext;
 	    }
 	}
-	const logger$y = new Logger('RpcCommunicator');
+	const logger$z = new Logger('RpcCommunicator');
 	class RpcCommunicator {
 	    stopped = false;
 	    rpcClientTransport;
@@ -80321,7 +80337,7 @@
 	        if (deferredPromises && (!callContext || !callContext.notification)) {
 	            this.registerRequest(rpcMessage.requestId, deferredPromises, callContext, requestOptions.timeout);
 	        }
-	        logger$y.trace(`onOutGoingMessage, messageId: ${rpcMessage.requestId}`);
+	        logger$z.trace(`onOutGoingMessage, messageId: ${rpcMessage.requestId}`);
 	        if (this.outgoingMessageListener) {
 	            this.outgoingMessageListener(rpcMessage, rpcMessage.requestId, callContext)
 	                .catch((clientSideException) => {
@@ -80352,7 +80368,7 @@
 	        }
 	    }
 	    async onIncomingMessage(rpcMessage, callContext) {
-	        logger$y.trace(`onIncomingMessage, requestId: ${rpcMessage.requestId}`);
+	        logger$z.trace(`onIncomingMessage, requestId: ${rpcMessage.requestId}`);
 	        if (rpcMessage.header.response && this.ongoingRequests.has(rpcMessage.requestId)) {
 	            if (rpcMessage.errorType !== undefined) {
 	                this.rejectOngoingRequest(rpcMessage);
@@ -80414,7 +80430,7 @@
 	            await this.rpcServerRegistry.handleNotification(rpcMessage, callContext);
 	        }
 	        catch (err) {
-	            logger$y.debug('error', { err });
+	            logger$z.debug('error', { err });
 	        }
 	    }
 	    registerRequest(requestId, deferredPromises, callContext, timeout = this.rpcRequestTimeout) {
@@ -81601,6 +81617,355 @@
 	var ipaddrExports = requireIpaddr();
 	var ipaddr = /*@__PURE__*/getDefaultExportFromCjs$1(ipaddrExports);
 
+	/**
+	 * @license
+	 * Copyright 2019 Google LLC
+	 * SPDX-License-Identifier: Apache-2.0
+	 */
+	const proxyMarker = Symbol("Comlink.proxy");
+	const createEndpoint = Symbol("Comlink.endpoint");
+	const releaseProxy = Symbol("Comlink.releaseProxy");
+	const finalizer = Symbol("Comlink.finalizer");
+	const throwMarker = Symbol("Comlink.thrown");
+	const isObject$1 = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+	/**
+	 * Internal transfer handle to handle objects marked to proxy.
+	 */
+	const proxyTransferHandler = {
+	    canHandle: (val) => isObject$1(val) && val[proxyMarker],
+	    serialize(obj) {
+	        const { port1, port2 } = new MessageChannel();
+	        expose(obj, port1);
+	        return [port2, [port2]];
+	    },
+	    deserialize(port) {
+	        port.start();
+	        return wrap$1(port);
+	    },
+	};
+	/**
+	 * Internal transfer handler to handle thrown exceptions.
+	 */
+	const throwTransferHandler = {
+	    canHandle: (value) => isObject$1(value) && throwMarker in value,
+	    serialize({ value }) {
+	        let serialized;
+	        if (value instanceof Error) {
+	            serialized = {
+	                isError: true,
+	                value: {
+	                    message: value.message,
+	                    name: value.name,
+	                    stack: value.stack,
+	                },
+	            };
+	        }
+	        else {
+	            serialized = { isError: false, value };
+	        }
+	        return [serialized, []];
+	    },
+	    deserialize(serialized) {
+	        if (serialized.isError) {
+	            throw Object.assign(new Error(serialized.value.message), serialized.value);
+	        }
+	        throw serialized.value;
+	    },
+	};
+	/**
+	 * Allows customizing the serialization of certain values.
+	 */
+	const transferHandlers = new Map([
+	    ["proxy", proxyTransferHandler],
+	    ["throw", throwTransferHandler],
+	]);
+	function isAllowedOrigin(allowedOrigins, origin) {
+	    for (const allowedOrigin of allowedOrigins) {
+	        if (origin === allowedOrigin || allowedOrigin === "*") {
+	            return true;
+	        }
+	        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+	    ep.addEventListener("message", function callback(ev) {
+	        if (!ev || !ev.data) {
+	            return;
+	        }
+	        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+	            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+	            return;
+	        }
+	        const { id, type, path } = Object.assign({ path: [] }, ev.data);
+	        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+	        let returnValue;
+	        try {
+	            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+	            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+	            switch (type) {
+	                case "GET" /* MessageType.GET */:
+	                    {
+	                        returnValue = rawValue;
+	                    }
+	                    break;
+	                case "SET" /* MessageType.SET */:
+	                    {
+	                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+	                        returnValue = true;
+	                    }
+	                    break;
+	                case "APPLY" /* MessageType.APPLY */:
+	                    {
+	                        returnValue = rawValue.apply(parent, argumentList);
+	                    }
+	                    break;
+	                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+	                    {
+	                        const value = new rawValue(...argumentList);
+	                        returnValue = proxy(value);
+	                    }
+	                    break;
+	                case "ENDPOINT" /* MessageType.ENDPOINT */:
+	                    {
+	                        const { port1, port2 } = new MessageChannel();
+	                        expose(obj, port2);
+	                        returnValue = transfer(port1, [port1]);
+	                    }
+	                    break;
+	                case "RELEASE" /* MessageType.RELEASE */:
+	                    {
+	                        returnValue = undefined;
+	                    }
+	                    break;
+	                default:
+	                    return;
+	            }
+	        }
+	        catch (value) {
+	            returnValue = { value, [throwMarker]: 0 };
+	        }
+	        Promise.resolve(returnValue)
+	            .catch((value) => {
+	            return { value, [throwMarker]: 0 };
+	        })
+	            .then((returnValue) => {
+	            const [wireValue, transferables] = toWireValue(returnValue);
+	            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+	            if (type === "RELEASE" /* MessageType.RELEASE */) {
+	                // detach and deactive after sending release response above.
+	                ep.removeEventListener("message", callback);
+	                closeEndPoint(ep);
+	                if (finalizer in obj && typeof obj[finalizer] === "function") {
+	                    obj[finalizer]();
+	                }
+	            }
+	        })
+	            .catch((error) => {
+	            // Send Serialization Error To Caller
+	            const [wireValue, transferables] = toWireValue({
+	                value: new TypeError("Unserializable return value"),
+	                [throwMarker]: 0,
+	            });
+	            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+	        });
+	    });
+	    if (ep.start) {
+	        ep.start();
+	    }
+	}
+	function isMessagePort(endpoint) {
+	    return endpoint.constructor.name === "MessagePort";
+	}
+	function closeEndPoint(endpoint) {
+	    if (isMessagePort(endpoint))
+	        endpoint.close();
+	}
+	function wrap$1(ep, target) {
+	    const pendingListeners = new Map();
+	    ep.addEventListener("message", function handleMessage(ev) {
+	        const { data } = ev;
+	        if (!data || !data.id) {
+	            return;
+	        }
+	        const resolver = pendingListeners.get(data.id);
+	        if (!resolver) {
+	            return;
+	        }
+	        try {
+	            resolver(data);
+	        }
+	        finally {
+	            pendingListeners.delete(data.id);
+	        }
+	    });
+	    return createProxy(ep, pendingListeners, [], target);
+	}
+	function throwIfProxyReleased(isReleased) {
+	    if (isReleased) {
+	        throw new Error("Proxy has been released and is not useable");
+	    }
+	}
+	function releaseEndpoint(ep) {
+	    return requestResponseMessage(ep, new Map(), {
+	        type: "RELEASE" /* MessageType.RELEASE */,
+	    }).then(() => {
+	        closeEndPoint(ep);
+	    });
+	}
+	const proxyCounter = new WeakMap();
+	const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+	    new FinalizationRegistry((ep) => {
+	        const newCount = (proxyCounter.get(ep) || 0) - 1;
+	        proxyCounter.set(ep, newCount);
+	        if (newCount === 0) {
+	            releaseEndpoint(ep);
+	        }
+	    });
+	function registerProxy(proxy, ep) {
+	    const newCount = (proxyCounter.get(ep) || 0) + 1;
+	    proxyCounter.set(ep, newCount);
+	    if (proxyFinalizers) {
+	        proxyFinalizers.register(proxy, ep, proxy);
+	    }
+	}
+	function unregisterProxy(proxy) {
+	    if (proxyFinalizers) {
+	        proxyFinalizers.unregister(proxy);
+	    }
+	}
+	function createProxy(ep, pendingListeners, path = [], target = function () { }) {
+	    let isProxyReleased = false;
+	    const proxy = new Proxy(target, {
+	        get(_target, prop) {
+	            throwIfProxyReleased(isProxyReleased);
+	            if (prop === releaseProxy) {
+	                return () => {
+	                    unregisterProxy(proxy);
+	                    releaseEndpoint(ep);
+	                    pendingListeners.clear();
+	                    isProxyReleased = true;
+	                };
+	            }
+	            if (prop === "then") {
+	                if (path.length === 0) {
+	                    return { then: () => proxy };
+	                }
+	                const r = requestResponseMessage(ep, pendingListeners, {
+	                    type: "GET" /* MessageType.GET */,
+	                    path: path.map((p) => p.toString()),
+	                }).then(fromWireValue);
+	                return r.then.bind(r);
+	            }
+	            return createProxy(ep, pendingListeners, [...path, prop]);
+	        },
+	        set(_target, prop, rawValue) {
+	            throwIfProxyReleased(isProxyReleased);
+	            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+	            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+	            const [value, transferables] = toWireValue(rawValue);
+	            return requestResponseMessage(ep, pendingListeners, {
+	                type: "SET" /* MessageType.SET */,
+	                path: [...path, prop].map((p) => p.toString()),
+	                value,
+	            }, transferables).then(fromWireValue);
+	        },
+	        apply(_target, _thisArg, rawArgumentList) {
+	            throwIfProxyReleased(isProxyReleased);
+	            const last = path[path.length - 1];
+	            if (last === createEndpoint) {
+	                return requestResponseMessage(ep, pendingListeners, {
+	                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
+	                }).then(fromWireValue);
+	            }
+	            // We just pretend that `bind()` didn’t happen.
+	            if (last === "bind") {
+	                return createProxy(ep, pendingListeners, path.slice(0, -1));
+	            }
+	            const [argumentList, transferables] = processArguments(rawArgumentList);
+	            return requestResponseMessage(ep, pendingListeners, {
+	                type: "APPLY" /* MessageType.APPLY */,
+	                path: path.map((p) => p.toString()),
+	                argumentList,
+	            }, transferables).then(fromWireValue);
+	        },
+	        construct(_target, rawArgumentList) {
+	            throwIfProxyReleased(isProxyReleased);
+	            const [argumentList, transferables] = processArguments(rawArgumentList);
+	            return requestResponseMessage(ep, pendingListeners, {
+	                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+	                path: path.map((p) => p.toString()),
+	                argumentList,
+	            }, transferables).then(fromWireValue);
+	        },
+	    });
+	    registerProxy(proxy, ep);
+	    return proxy;
+	}
+	function myFlat(arr) {
+	    return Array.prototype.concat.apply([], arr);
+	}
+	function processArguments(argumentList) {
+	    const processed = argumentList.map(toWireValue);
+	    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+	}
+	const transferCache = new WeakMap();
+	function transfer(obj, transfers) {
+	    transferCache.set(obj, transfers);
+	    return obj;
+	}
+	function proxy(obj) {
+	    return Object.assign(obj, { [proxyMarker]: true });
+	}
+	function toWireValue(value) {
+	    for (const [name, handler] of transferHandlers) {
+	        if (handler.canHandle(value)) {
+	            const [serializedValue, transferables] = handler.serialize(value);
+	            return [
+	                {
+	                    type: "HANDLER" /* WireValueType.HANDLER */,
+	                    name,
+	                    value: serializedValue,
+	                },
+	                transferables,
+	            ];
+	        }
+	    }
+	    return [
+	        {
+	            type: "RAW" /* WireValueType.RAW */,
+	            value,
+	        },
+	        transferCache.get(value) || [],
+	    ];
+	}
+	function fromWireValue(value) {
+	    switch (value.type) {
+	        case "HANDLER" /* WireValueType.HANDLER */:
+	            return transferHandlers.get(value.name).deserialize(value.value);
+	        case "RAW" /* WireValueType.RAW */:
+	            return value.value;
+	    }
+	}
+	function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+	    return new Promise((resolve) => {
+	        const id = generateUUID();
+	        pendingListeners.set(id, resolve);
+	        if (ep.start) {
+	            ep.start();
+	        }
+	        ep.postMessage(Object.assign({ id }, msg), transfers);
+	    });
+	}
+	function generateUUID() {
+	    return new Array(4)
+	        .fill(0)
+	        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+	        .join("-");
+	}
+
 	var global$1;
 	var hasRequiredGlobal;
 
@@ -85073,7 +85438,7 @@
 	};
 
 	const DEFAULT_MAX_CACHE_AGE = 1000 * 60 * 60; // 1 hour
-	const logger$v = new Logger('getLocalRegion');
+	const logger$w = new Logger('getLocalRegion');
 	let cachedLocalRegion = undefined;
 	let cachedLocalRegionFetchTime = undefined;
 	const getLocalAirportCode = async () => {
@@ -85093,7 +85458,7 @@
 	    // indicate that the region is random by adding 99, the convention is
 	    // that random region numbers end with 99
 	    const randomRegion = airportCodeToRegion[randomAirportCode][0] + 99;
-	    logger$v.warn(`Could not get airport code, using random region: ${randomRegion}`);
+	    logger$w.warn(`Could not get airport code, using random region: ${randomRegion}`);
 	    return randomRegion;
 	};
 	const getLocalRegionWithCache = async (maxCacheAge = DEFAULT_MAX_CACHE_AGE) => {
@@ -85745,6 +86110,9 @@
 	class SendFailed extends Err {
 	    constructor(message, originalError) { super(ErrorCode.SEND_FAILED, message, originalError); }
 	}
+	function logGapDiagnosticSampled(layer, opts = {}) {
+	    return;
+	}
 
 	// @generated message type with reflection information, may provide speed optimized methods
 	let Empty$Type$2 = class Empty$Type extends MessageType {
@@ -87288,7 +87656,7 @@
 	    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 {
@@ -87318,7 +87686,7 @@
 	        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);
 	        }
@@ -87327,7 +87695,7 @@
 	    // 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) {
@@ -87474,10 +87842,10 @@
 	    }
 	}
 
-	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
 	        };
@@ -87487,12 +87855,12 @@
 	            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
 	        };
@@ -87500,11 +87868,11 @@
 	            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
 	        };
@@ -87516,7 +87884,7 @@
 	        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
 	        };
@@ -87528,7 +87896,7 @@
 	    }
 	}
 
-	const logger$A = new Logger('ConnectionLockRpcLocal');
+	const logger$B = new Logger('ConnectionLockRpcLocal');
 	class ConnectionLockRpcLocal {
 	    options;
 	    constructor(options) {
@@ -87557,7 +87925,7 @@
 	    }
 	    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$2.LEAVING) {
 	            await this.options.closeConnection(senderPeerDescriptor, true, 'graceful leave notified');
 	        }
@@ -87608,7 +87976,7 @@
 	    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";
@@ -87658,7 +88026,7 @@
 	            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) {
@@ -87692,7 +88060,7 @@
 	                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);
 	                }
 	            }
@@ -87700,7 +88068,7 @@
 	        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$2.NORMAL).catch((_e) => { });
 	        }
 	    }
@@ -87709,11 +88077,11 @@
 	            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?
@@ -87723,7 +88091,7 @@
 	            return;
 	        }
 	        this.state = ConnectionManagerState.STOPPING;
-	        logger$z.trace(`Stopping ConnectionManager`);
+	        logger$A.trace(`Stopping ConnectionManager`);
 	        if (this.disconnectorIntervalRef) {
 	            clearInterval(this.disconnectorIntervalRef);
 	        }
@@ -87733,23 +88101,23 @@
 	                    await this.gracefullyDisconnectAsync(endpoint.connection.getPeerDescriptor(), DisconnectMode$2.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);
 	                }
 	            }
 	        }));
@@ -87778,7 +88146,7 @@
 	            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()
@@ -87833,13 +88201,13 @@
 	    }
 	    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;
 	        }
@@ -87848,7 +88216,7 @@
 	            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);
 	        }
@@ -87865,7 +88233,7 @@
 	        }
 	        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;
@@ -87874,7 +88242,7 @@
 	        }
 	        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) {
@@ -87887,7 +88255,7 @@
 	        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();
@@ -87904,7 +88272,7 @@
 	    }
 	    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);
@@ -87912,7 +88280,7 @@
 	                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();
 	        }
@@ -87921,7 +88289,7 @@
 	        if (this.state === ConnectionManagerState.STOPPED) {
 	            return false;
 	        }
-	        logger$z.trace('onNewConnection()');
+	        logger$A.trace('onNewConnection()');
 	        if (!this.acceptNewConnection(connection)) {
 	            return false;
 	        }
@@ -87931,7 +88299,7 @@
 	    }
 	    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;
@@ -87940,14 +88308,14 @@
 	                // 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;
@@ -87956,7 +88324,7 @@
 	                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(),
@@ -87966,14 +88334,14 @@
 	    }
 	    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);
 	        }
 	    }
@@ -87985,8 +88353,8 @@
 	        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())) {
@@ -88038,7 +88406,7 @@
 	    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) {
@@ -88047,15 +88415,15 @@
 	                // 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();
 	                });
 	            });
@@ -88070,13 +88438,13 @@
 	    }
 	    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() {
@@ -88136,9 +88504,9 @@
 	    }
 	};
 
-	var version$2 = "103.3.1";
+	var version$2 = "103.7.0-rc.2";
 
-	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
@@ -88160,7 +88528,7 @@
 	        }
 	    };
 	    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();
 	    };
@@ -88260,12 +88628,12 @@
 	        try {
 	            const message = Message$2.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$2.UNSUPPORTED_PROTOCOL_VERSION : handshake.error;
@@ -88278,18 +88646,18 @@
 	            }
 	        }
 	        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$2.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$2.toBinary(msg));
-	        logger$x.trace('handshake response sent');
+	        logger$y.trace('handshake response sent');
 	    }
 	    stop() {
 	        this.connection.off('data', this.onDataListener);
@@ -88297,7 +88665,7 @@
 	    }
 	};
 
-	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.
@@ -88315,7 +88683,7 @@
 	        }, timeout, this.connectingAbortController.signal);
 	    }
 	    replaceAsDuplicate() {
-	        logger$w.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
+	        logger$x.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate');
 	        this.replacedAsDuplicate = true;
 	    }
 	    onHandshakeCompleted(connection) {
@@ -88372,6 +88740,8 @@
 	    }
 	}
 
+	const isWorkerEnvironment = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
+
 	var RtcDescription;
 	(function (RtcDescription) {
 	    RtcDescription["OFFER"] = "offer";
@@ -88386,8 +88756,8 @@
 	    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
@@ -88425,7 +88795,7 @@
 	            }
 	        };
 	        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) {
@@ -88436,7 +88806,7 @@
 	                        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);
@@ -88464,14 +88834,14 @@
 	            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);
@@ -88481,7 +88851,7 @@
 	    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() {
@@ -88504,7 +88874,7 @@
 	                    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;
@@ -88513,7 +88883,7 @@
 	                    this.peerConnection.close();
 	                }
 	                catch (err) {
-	                    logger$u.warn('Failed to close connection', { err });
+	                    logger$v.warn('Failed to close connection', { err });
 	                }
 	            }
 	            this.peerConnection = undefined;
@@ -88525,6 +88895,9 @@
 	    }
 	    send(data) {
 	        if (this.lastState === 'connected') {
+	            logGapDiagnosticSampled('dht.dc.send', {
+	                detail: { bufferedAmount: this.dataChannel.bufferedAmount, queueLen: this.messageQueue.length }
+	            });
 	            if (this.dataChannel.bufferedAmount > this.bufferThresholdHigh) {
 	                this.messageQueue.push(data);
 	            }
@@ -88533,7 +88906,7 @@
 	            }
 	        }
 	        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) {
@@ -88541,22 +88914,22 @@
 	        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);
@@ -88595,6 +88968,292 @@
 	    }
 	}
 
+	/**
+	 * 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';
+
+	/**
+	 * 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 = wrap$1(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, 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, `pcState=${state}`);
+	                }
+	            },
+	            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) {
+	            logGapDiagnosticSampled('dht.dc.send', {
+	                detail: { bufferedAmount: this.dataChannel.bufferedAmount, queueLen: this.messageQueue.length }
+	            });
+	            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.onclose');
+	        };
+	        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() {
@@ -90757,7 +91416,7 @@
 	            logger$d$1.debug(`Ring join on ${this.options.serviceId} timed out`);
 	        }
 	        finally {
-	            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id));
+	            sessions.forEach((session) => this.ongoingRingDiscoverySessions.delete(session.id));
 	        }
 	    }
 	    async rejoinDht(entryPoint, contactedPeers = new Set(), distantJoinContactPeers = new Set()) {
@@ -93073,7 +93732,7 @@
 	    }
 	}
 
-	var version$1 = "103.3.1";
+	var version$1 = "103.7.0-rc.2";
 
 	// @generated message type with reflection information, may provide speed optimized methods
 	let Any$Type$1 = class Any$Type extends MessageType {
@@ -94720,6 +95379,18 @@
 	 */
 	const PauseNeighborRequest = new PauseNeighborRequest$Type();
 	// @generated message type with reflection information, may provide speed optimized methods
+	class PauseNeighborResponse$Type extends MessageType {
+	    constructor() {
+	        super("PauseNeighborResponse", [
+	            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+	        ]);
+	    }
+	}
+	/**
+	 * @generated MessageType for protobuf message PauseNeighborResponse
+	 */
+	const PauseNeighborResponse = new PauseNeighborResponse$Type();
+	// @generated message type with reflection information, may provide speed optimized methods
 	class ResumeNeighborRequest$Type extends MessageType {
 	    constructor() {
 	        super("ResumeNeighborRequest", [
@@ -94775,7 +95446,7 @@
 	 * @generated ServiceType for protobuf service PlumtreeRpc
 	 */
 	const PlumtreeRpc = new ServiceType("PlumtreeRpc", [
-	    { name: "pauseNeighbor", options: {}, I: PauseNeighborRequest, O: Empty$1 },
+	    { name: "pauseNeighbor", options: {}, I: PauseNeighborRequest, O: PauseNeighborResponse },
 	    { name: "resumeNeighbor", options: {}, I: ResumeNeighborRequest, O: Empty$1 },
 	    { name: "sendMetadata", options: {}, I: MessageID$1, O: Empty$1 }
 	]);
@@ -95802,6 +96473,7 @@
 	        this.options.neighborFinder.stop();
 	        this.options.neighborUpdateManager.stop();
 	        this.options.inspector.stop();
+	        this.duplicateDetectors.clear();
 	    }
 	    broadcast(msg, previousNode) {
 	        if (!previousNode) {
@@ -96377,14 +97049,17 @@
 	    async pauseNeighbor(request, context) {
 	        const sender = toNodeId(context.incomingSourceDescriptor);
 	        if (this.neighbors.has(sender)) {
-	            this.pausedNodes.add(sender, request.messageChainId);
+	            const accepted = this.pausedNodes.add(sender, request.messageChainId);
+	            return { accepted };
 	        }
-	        return Empty$1;
+	        return { accepted: false };
 	    }
 	    async resumeNeighbor(request, context) {
 	        const sender = context.incomingSourceDescriptor;
-	        this.pausedNodes.delete(toNodeId(sender), request.messageChainId);
-	        await this.sendBuffer(request.fromTimestamp, request.messageChainId, sender);
+	        if (this.neighbors.has(toNodeId(sender))) {
+	            this.pausedNodes.delete(toNodeId(sender), request.messageChainId);
+	            await this.sendBuffer(request.fromTimestamp, request.messageChainId, sender);
+	        }
 	        return Empty$1;
 	    }
 	}
@@ -96397,10 +97072,9 @@
 	        await this.getClient().sendMetadata(msg, options);
 	    }
 	    async pauseNeighbor(messageChainId) {
-	        const options = this.formDhtRpcOptions({
-	            notification: true
-	        });
-	        await this.getClient().pauseNeighbor({ messageChainId }, options);
+	        const options = this.formDhtRpcOptions();
+	        const response = await this.getClient().pauseNeighbor({ messageChainId }, options);
+	        return response.accepted;
 	    }
 	    async resumeNeighbor(fromTimestamp, messageChainId) {
 	        const options = this.formDhtRpcOptions({
@@ -96422,9 +97096,10 @@
 	            this.pausedNeighbors.set(msgChainId, new Set());
 	        }
 	        if (this.pausedNeighbors.get(msgChainId).size >= this.limit) {
-	            return;
+	            return false;
 	        }
 	        this.pausedNeighbors.get(msgChainId).add(node);
+	        return true;
 	    }
 	    delete(node, msgChainId) {
 	        this.pausedNeighbors.get(msgChainId)?.delete(node);
@@ -96457,19 +97132,24 @@
 	}
 
 	const MAX_PAUSED_NEIGHBORS_DEFAULT = 3;
+	const DEFAULT_RECOVERY_TIMEOUT = 500;
+	const DEFAULT_RECOVERY_CHECK_INTERVAL = 200;
+	const DEFAULT_RECOVERY_COOLDOWN = 2500;
 	const logger$4$1 = new Logger('PlumtreeManager');
 	class PlumtreeManager extends EventEmitter {
 	    neighbors;
 	    localPeerDescriptor;
-	    // We have paused sending real data to these neighbrs and only send metadata
 	    localPausedNeighbors;
-	    // We have asked these nodes to pause sending real data to us, used to limit sending of pausing and resuming requests
 	    remotePausedNeighbors;
 	    rpcLocal;
 	    latestMessages = new Map();
 	    rpcCommunicator;
-	    metadataTimestampsAheadOfRealData = new Map();
 	    maxPausedNeighbors;
+	    recoveryState = new Map();
+	    recoveryCooldownUntil = new Map();
+	    recoveryTimeout;
+	    recoveryCooldown;
+	    abortController = new AbortController();
 	    constructor(options) {
 	        super();
 	        this.neighbors = options.neighbors;
@@ -96477,12 +97157,22 @@
 	        this.localPeerDescriptor = options.localPeerDescriptor;
 	        this.localPausedNeighbors = new PausedNeighbors(options.maxPausedNeighbors ?? MAX_PAUSED_NEIGHBORS_DEFAULT);
 	        this.remotePausedNeighbors = new PausedNeighbors(options.maxPausedNeighbors ?? MAX_PAUSED_NEIGHBORS_DEFAULT);
+	        this.recoveryTimeout = options.recoveryTimeout ?? DEFAULT_RECOVERY_TIMEOUT;
+	        this.recoveryCooldown = options.recoveryCooldown ?? DEFAULT_RECOVERY_COOLDOWN;
 	        this.rpcLocal = new PlumtreeRpcLocal(this.neighbors, this.localPausedNeighbors, (metadata, previousNode) => this.onMetadata(metadata, previousNode), (fromTimestamp, msgChainId, remotePeerDescriptor) => this.sendBuffer(fromTimestamp, msgChainId, remotePeerDescriptor));
-	        this.neighbors.on('nodeRemoved', (nodeId) => this.onNeighborRemoved(nodeId));
+	        this.neighbors.on('nodeRemoved', this.onNeighborRemoved);
 	        this.rpcCommunicator = options.rpcCommunicator;
 	        this.rpcCommunicator.registerRpcNotification(MessageID$1, 'sendMetadata', (msg, context) => this.rpcLocal.sendMetadata(msg, context));
-	        this.rpcCommunicator.registerRpcNotification(PauseNeighborRequest, 'pauseNeighbor', (msg, context) => this.rpcLocal.pauseNeighbor(msg, context));
+	        this.rpcCommunicator.registerRpcMethod(PauseNeighborRequest, PauseNeighborResponse, 'pauseNeighbor', (msg, context) => this.rpcLocal.pauseNeighbor(msg, context));
 	        this.rpcCommunicator.registerRpcNotification(ResumeNeighborRequest, 'resumeNeighbor', (msg, context) => this.rpcLocal.resumeNeighbor(msg, context));
+	        setAbortableInterval(() => {
+	            const now = performance.now();
+	            for (const [chainId, state] of this.recoveryState) {
+	                if (now - state.metadataAheadSince >= this.recoveryTimeout && !state.resumeInProgress) {
+	                    this.attemptRecovery(chainId, state, this.getLatestMessageTimestamp(chainId));
+	                }
+	            }
+	        }, options.recoveryCheckInterval ?? DEFAULT_RECOVERY_CHECK_INTERVAL, this.abortController.signal);
 	    }
 	    async pauseNeighbor(node, msgChainId) {
 	        if (this.neighbors.has(toNodeId(node))
@@ -96490,8 +97180,16 @@
 	            && this.remotePausedNeighbors.size(msgChainId) < this.maxPausedNeighbors) {
 	            logger$4$1.debug(`Pausing neighbor ${toNodeId(node)}`);
 	            this.remotePausedNeighbors.add(toNodeId(node), msgChainId);
-	            const remote = this.createRemote(node);
-	            await remote.pauseNeighbor(msgChainId);
+	            try {
+	                const remote = this.createRemote(node);
+	                const accepted = await remote.pauseNeighbor(msgChainId);
+	                if (!accepted) {
+	                    this.remotePausedNeighbors.delete(toNodeId(node), msgChainId);
+	                }
+	            }
+	            catch (_e) {
+	                this.remotePausedNeighbors.delete(toNodeId(node), msgChainId);
+	            }
 	        }
 	    }
 	    async resumeNeighbor(node, msgChainId, fromTimestamp) {
@@ -96502,9 +97200,15 @@
 	            await remote.resumeNeighbor(fromTimestamp, msgChainId);
 	        }
 	    }
-	    onNeighborRemoved(nodeId) {
+	    onNeighborRemoved = (nodeId) => {
 	        this.localPausedNeighbors.deleteAll(nodeId);
 	        this.remotePausedNeighbors.deleteAll(nodeId);
+	        for (const [_chainId, state] of this.recoveryState) {
+	            state.candidates = state.candidates.filter((c) => toNodeId(c) !== nodeId);
+	            if (state.lastAttemptedNode !== null && toNodeId(state.lastAttemptedNode) === nodeId) {
+	                state.lastAttemptedNode = null;
+	            }
+	        }
 	        if (this.neighbors.size() > 0) {
 	            this.remotePausedNeighbors.forEach((pausedNeighbors, msgChainId) => {
 	                if (pausedNeighbors.size >= this.neighbors.size()) {
@@ -96514,7 +97218,7 @@
 	                }
 	            });
 	        }
-	    }
+	    };
 	    getLatestMessageTimestamp(msgChainId) {
 	        if (!this.latestMessages.has(msgChainId) || this.latestMessages.get(msgChainId).length === 0) {
 	            return 0;
@@ -96524,22 +97228,61 @@
 	    async sendBuffer(fromTimestamp, msgChainId, neighbor) {
 	        const remote = new ContentDeliveryRpcRemote(this.localPeerDescriptor, neighbor, this.rpcCommunicator, ContentDeliveryRpcClient);
 	        const messages = this.latestMessages.get(msgChainId)?.filter((msg) => msg.messageId.timestamp > fromTimestamp) ?? [];
-	        await Promise.all(messages.map((msg) => remote.sendStreamMessage(msg)));
+	        for (const msg of messages) {
+	            await remote.sendStreamMessage(msg);
+	        }
 	    }
 	    async onMetadata(msg, previousNode) {
-	        // If we receive newer metadata than messages in the buffer, resume the sending neighbor
-	        const latestMessageTimestamp = this.getLatestMessageTimestamp(msg.messageChainId);
-	        if (latestMessageTimestamp < msg.timestamp) {
-	            if (!this.metadataTimestampsAheadOfRealData.has(msg.messageChainId)) {
-	                this.metadataTimestampsAheadOfRealData.set(msg.messageChainId, new Set());
-	            }
-	            this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).add(msg.timestamp);
-	            if (this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).size > 1) {
-	                await this.resumeNeighbor(previousNode, msg.messageChainId, this.getLatestMessageTimestamp(msg.messageChainId));
-	                this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).forEach((timestamp) => {
-	                    this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).delete(timestamp);
-	                });
-	            }
+	        const latestTs = this.getLatestMessageTimestamp(msg.messageChainId);
+	        if (latestTs >= msg.timestamp) {
+	            return;
+	        }
+	        const chainId = msg.messageChainId;
+	        const cooldownUntil = this.recoveryCooldownUntil.get(chainId);
+	        if (cooldownUntil !== undefined && performance.now() < cooldownUntil) {
+	            return;
+	        }
+	        let state = this.recoveryState.get(chainId);
+	        if (!state) {
+	            state = {
+	                timestampsAhead: new Set(),
+	                metadataAheadSince: performance.now(),
+	                candidates: [],
+	                lastAttemptedNode: null,
+	                resumeInProgress: false
+	            };
+	            this.recoveryState.set(chainId, state);
+	        }
+	        state.timestampsAhead.add(msg.timestamp);
+	        const nodeId = toNodeId(previousNode);
+	        const isLastAttempted = state.lastAttemptedNode !== null && toNodeId(state.lastAttemptedNode) === nodeId;
+	        if (!isLastAttempted && !state.candidates.some((c) => toNodeId(c) === nodeId)) {
+	            state.candidates.push(previousNode);
+	        }
+	        if (state.timestampsAhead.size > 1 && !state.resumeInProgress) {
+	            await this.attemptRecovery(chainId, state, latestTs);
+	        }
+	    }
+	    async attemptRecovery(chainId, state, latestTs) {
+	        const candidate = state.candidates.shift();
+	        if (!candidate) {
+	            state.metadataAheadSince = performance.now();
+	            return;
+	        }
+	        state.resumeInProgress = true;
+	        state.lastAttemptedNode = candidate;
+	        state.candidates = [];
+	        state.timestampsAhead.clear();
+	        state.metadataAheadSince = performance.now();
+	        try {
+	            const remote = this.createRemote(candidate);
+	            await remote.resumeNeighbor(latestTs, chainId);
+	        }
+	        catch (_e) {
+	            logger$4$1.debug('Recovery resume failed, will retry with next candidate');
+	        }
+	        finally {
+	            state.resumeInProgress = false;
 	        }
 	    }
 	    createRemote(neighbor) {
@@ -96557,8 +97300,13 @@
 	            this.latestMessages.get(messageChainId).shift();
 	            this.latestMessages.get(messageChainId).push(msg);
 	        }
-	        if (this.metadataTimestampsAheadOfRealData.has(msg.messageId.messageChainId)) {
-	            this.metadataTimestampsAheadOfRealData.get(msg.messageId.messageChainId).delete(msg.messageId.timestamp);
+	        const state = this.recoveryState.get(messageChainId);
+	        if (state) {
+	            if (state.lastAttemptedNode) {
+	                this.remotePausedNeighbors.delete(toNodeId(state.lastAttemptedNode), messageChainId);
+	            }
+	            this.recoveryState.delete(messageChainId);
+	            this.recoveryCooldownUntil.set(messageChainId, performance.now() + this.recoveryCooldown);
 	        }
 	        this.emit('message', msg);
 	        const neighbors = this.neighbors.getAll().filter((neighbor) => toNodeId(neighbor.getPeerDescriptor()) !== previousNode);
@@ -96576,8 +97324,18 @@
 	        return this.localPausedNeighbors.isPaused(toNodeId(node), msgChainId)
 	            || this.remotePausedNeighbors.isPaused(toNodeId(node), msgChainId);
 	    }
+	    getLocalPausedNeighbors() {
+	        return this.localPausedNeighbors;
+	    }
+	    getRemotePausedNeighbors() {
+	        return this.remotePausedNeighbors;
+	    }
 	    stop() {
+	        this.abortController.abort();
 	        this.neighbors.off('nodeRemoved', this.onNeighborRemoved);
+	        this.latestMessages.clear();
+	        this.recoveryState.clear();
+	        this.recoveryCooldownUntil.clear();
 	    }
 	}