@streamr/sdk 103.7.0-rc.2 → 103.8.0-rc.3

package/dist/exports-umd.js

@@ -1762,7 +1762,7 @@
 	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 	}
 
-	function __awaiter$1(thisArg, _arguments, P, generator) {
+	function __awaiter(thisArg, _arguments, P, generator) {
 	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 	    return new (P || (P = Promise))(function (resolve, reject) {
 	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -2350,7 +2350,7 @@
 	        });
 	    };
 	    InternalDependencyContainer.prototype.dispose = function () {
-	        return __awaiter$1(this, void 0, void 0, function () {
+	        return __awaiter(this, void 0, void 0, function () {
 	            var promises;
 	            return __generator$1(this, function (_a) {
 	                switch (_a.label) {
@@ -79595,52 +79595,6 @@
 	    }
 	}
 
-	var __awaiter = (window && window.__awaiter) || function (thisArg, _arguments, P, generator) {
-	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-	    return new (P || (P = Promise))(function (resolve, reject) {
-	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-	        step((generator = generator.apply(thisArg, _arguments || [])).next());
-	    });
-	};
-	/**
-	 * A unary RPC call. Unary means there is exactly one input message and
-	 * exactly one output message unless an error occurred.
-	 */
-	class UnaryCall {
-	    constructor(method, requestHeaders, request, headers, response, status, trailers) {
-	        this.method = method;
-	        this.requestHeaders = requestHeaders;
-	        this.request = request;
-	        this.headers = headers;
-	        this.response = response;
-	        this.status = status;
-	        this.trailers = trailers;
-	    }
-	    /**
-	     * If you are only interested in the final outcome of this call,
-	     * you can await it to receive a `FinishedUnaryCall`.
-	     */
-	    then(onfulfilled, onrejected) {
-	        return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason));
-	    }
-	    promiseFinished() {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            let [headers, response, status, trailers] = yield Promise.all([this.headers, this.response, this.status, this.trailers]);
-	            return {
-	                method: this.method,
-	                requestHeaders: this.requestHeaders,
-	                request: this.request,
-	                headers,
-	                response,
-	                status,
-	                trailers
-	            };
-	        });
-	    }
-	}
-
 	/**
 	 * Creates a "stack" of of all interceptors specified in the given `RpcOptions`.
 	 * Used by generated client implementations.
@@ -79952,33 +79906,42 @@
 	            notification: notification ? 'notification' : undefined
 	        };
 	    }
-	    unary(method, input, options) {
-	        if (!options?.isProtoRpc) {
-	            // eslint-disable-next-line max-len
-	            throw new Error('ProtoRpc ClientTransport can only be used with ProtoRpcClients. Please convert your protobuf-ts generated client to a ProtoRpcClient by calling toProtoRpcclient(yourClient).');
-	        }
-	        const requestBody = Any$3.pack(input, method.I);
+	    // ProtoRpc clients drive `request()` / `notification()` directly (via
+	    // toProtoRpcClient); this RpcTransport entry point is only reached by a raw
+	    // protobuf-ts client that was never wrapped — hence the guard.
+	    // eslint-disable-next-line class-methods-use-this
+	    unary(_method, _input, _options) {
+	        // eslint-disable-next-line max-len
+	        throw new Error('ProtoRpc ClientTransport can only be used with ProtoRpcClients. Please convert your protobuf-ts generated client to a ProtoRpcClient by calling toProtoRpcclient(yourClient).');
+	    }
+	    // Direct request path: one response deferred, no UnaryCall / header /
+	    // status / trailer. Returns the response message promise.
+	    request(method, input, options) {
 	        const request = {
-	            header: ClientTransport.createRequestHeaders(method, options.notification),
-	            body: requestBody,
+	            header: ClientTransport.createRequestHeaders(method, false),
+	            body: Any$3.pack(input, method.I),
 	            requestId: v4()
 	        };
-	        const defHeader = new Deferred();
-	        const defMessage = new Deferred();
-	        const defStatus = new Deferred();
-	        const defTrailer = new Deferred();
-	        const unary = new UnaryCall(method, {}, input, defHeader.promise, defMessage.promise, defStatus.promise, defTrailer.promise);
-	        const deferredParser = (bytes) => method.O.fromBinary(bytes);
-	        const deferred = {
-	            message: defMessage,
-	            header: defHeader,
-	            trailer: defTrailer,
-	            status: defStatus,
-	            messageParser: deferredParser
+	        const message = new Deferred();
+	        logger$2$3.trace(`New rpc request, ${request.requestId}`);
+	        this.emit('rpcRequest', request, options, {
+	            message: message,
+	            messageParser: (bytes) => method.O.fromBinary(bytes)
+	        });
+	        return message.promise;
+	    }
+	    // Direct notification path: fire-and-forget, no deferreds / OngoingRequest.
+	    // Returns the send promise so the caller still sees send success/failure.
+	    notification(method, input, options) {
+	        const request = {
+	            header: ClientTransport.createRequestHeaders(method, true),
+	            body: Any$3.pack(input, method.I),
+	            requestId: v4()
 	        };
-	        logger$2$3.trace(`New rpc ${options.notification ? 'notification' : 'request'}, ${request.requestId}`);
-	        this.emit('rpcRequest', request, options, deferred);
-	        return unary;
+	        logger$2$3.trace(`New rpc notification, ${request.requestId}`);
+	        let sendResult = Promise.resolve();
+	        this.emit('rpcNotification', request, options, (result) => { sendResult = result; });
+	        return sendResult;
 	    }
 	    // eslint-disable-next-line class-methods-use-this
 	    clientStreaming(method) {
@@ -80178,8 +80141,13 @@
 	    async handleNotification(rpcMessage, callContext) {
 	        logger$1$4.trace(`Server processing RPC notification ${rpcMessage.requestId}`);
 	        const implementation = this.getImplementation(rpcMessage, this.notifications);
-	        const timeout = implementation.options.timeout;
-	        await promiseTimeout(timeout, implementation.fn(rpcMessage.body, callContext ?? new ProtoCallContext()));
+	        // Notifications have no response and their rejection is swallowed by
+	        // the caller (RpcCommunicator.handleNotification logs and drops it),
+	        // so a per-message timeout — which armed/cleared a setTimeout on every
+	        // inbound data-plane message — bought nothing but timer/promise churn.
+	        // Requests keep their timeout in handleRequest (they have a caller
+	        // awaiting a result).
+	        await implementation.fn(rpcMessage.body, callContext ?? new ProtoCallContext());
 	    }
 	    registerRpcMethod(requestClass, returnClass, name, fn, opts = {}) {
 	        const options = parseOptions(opts);
@@ -80206,7 +80174,6 @@
 	    }
 	}
 
-	/* eslint-disable promise/catch-or-return */
 	var StatusCode;
 	(function (StatusCode) {
 	    StatusCode["OK"] = "OK";
@@ -80235,17 +80202,6 @@
 	        }
 	        this.resolveDeferredPromises(response);
 	    }
-	    resolveNotification() {
-	        if (this.timeoutRef) {
-	            clearTimeout(this.timeoutRef);
-	        }
-	        if (this.deferredPromises.message.state === DeferredState.PENDING) {
-	            this.deferredPromises.message.resolve({});
-	            this.deferredPromises.header.resolve({});
-	            this.deferredPromises.status.resolve({ code: StatusCode.OK, detail: '' });
-	            this.deferredPromises.trailer.resolve({});
-	        }
-	    }
 	    rejectRequest(error, code) {
 	        if (this.timeoutRef) {
 	            clearTimeout(this.timeoutRef);
@@ -80257,9 +80213,6 @@
 	            try {
 	                const parsedResponse = this.deferredPromises.messageParser(response.body.value);
 	                this.deferredPromises.message.resolve(parsedResponse);
-	                this.deferredPromises.header.resolve({});
-	                this.deferredPromises.status.resolve({ code: StatusCode.OK, detail: '' });
-	                this.deferredPromises.trailer.resolve({});
 	            }
 	            catch (err) {
 	                logger$z.debug(`Could not parse response, received message is likely `);
@@ -80268,12 +80221,9 @@
 	            }
 	        }
 	    }
-	    rejectDeferredPromises(error, code) {
+	    rejectDeferredPromises(error, _code) {
 	        if (this.deferredPromises.message.state === DeferredState.PENDING) {
 	            this.deferredPromises.message.reject(error);
-	            this.deferredPromises.header.reject(error);
-	            this.deferredPromises.status.reject({ code, detail: error.message });
-	            this.deferredPromises.trailer.reject(error);
 	        }
 	    }
 	    fulfillsPredicate(predicate) {
@@ -80300,6 +80250,10 @@
 	        this.rpcClientTransport.on('rpcRequest', (rpcMessage, options, deferredPromises) => {
 	            this.onOutgoingMessage(rpcMessage, options, deferredPromises);
 	        });
+	        // Client side listener for outgoing notification (fire-and-forget).
+	        this.rpcClientTransport.on('rpcNotification', (rpcMessage, options, setSendResult) => {
+	            setSendResult(this.onOutgoingNotification(rpcMessage, options));
+	        });
 	    }
 	    async handleIncomingMessage(message, callContext) {
 	        if (this.stopped) {
@@ -80324,6 +80278,8 @@
 	        this.ongoingRequests.clear();
 	        this.rpcClientTransport.stop();
 	    }
+	    // Sends a client request (deferredPromises present) or a server response
+	    // (deferredPromises undefined). Notifications use onOutgoingNotification.
 	    onOutgoingMessage(rpcMessage, callContext, deferredPromises) {
 	        if (this.stopped) {
 	            if (deferredPromises) {
@@ -80332,40 +80288,30 @@
 	            }
 	            return;
 	        }
-	        const requestOptions = this.rpcClientTransport.mergeOptions(callContext);
-	        // do not register a notification
-	        if (deferredPromises && (!callContext || !callContext.notification)) {
-	            this.registerRequest(rpcMessage.requestId, deferredPromises, callContext, requestOptions.timeout);
+	        if (deferredPromises) {
+	            const timeout = callContext.timeout ?? this.rpcRequestTimeout;
+	            this.registerRequest(rpcMessage.requestId, deferredPromises, callContext, timeout);
 	        }
 	        logger$z.trace(`onOutGoingMessage, messageId: ${rpcMessage.requestId}`);
 	        if (this.outgoingMessageListener) {
 	            this.outgoingMessageListener(rpcMessage, rpcMessage.requestId, callContext)
 	                .catch((clientSideException) => {
 	                if (deferredPromises) {
-	                    if (this.ongoingRequests.has(rpcMessage.requestId)) {
-	                        this.handleClientError(rpcMessage.requestId, clientSideException);
-	                    }
-	                    else {
-	                        const ongoingRequest = new OngoingRequest(deferredPromises, callContext);
-	                        ongoingRequest.rejectRequest(clientSideException, StatusCode.SERVER_ERROR);
-	                    }
-	                }
-	            })
-	                .then(() => {
-	                if (deferredPromises) {
-	                    if (!this.ongoingRequests.has(rpcMessage.requestId)) {
-	                        const ongoingRequest = new OngoingRequest(deferredPromises, callContext);
-	                        ongoingRequest.resolveNotification();
-	                    }
+	                    this.handleClientError(rpcMessage.requestId, clientSideException);
 	                }
 	            });
 	        }
-	        else if (deferredPromises) {
-	            if (!this.ongoingRequests.has(rpcMessage.requestId)) {
-	                const ongoingRequest = new OngoingRequest(deferredPromises, callContext);
-	                ongoingRequest.resolveNotification();
-	            }
+	    }
+	    // Fire-and-forget outgoing notification: no deferreds, no OngoingRequest.
+	    // Returns the send promise so the caller observes send success/failure.
+	    onOutgoingNotification(rpcMessage, callContext) {
+	        if (this.stopped) {
+	            return Promise.reject(new Error('stopped'));
+	        }
+	        if (this.outgoingMessageListener) {
+	            return this.outgoingMessageListener(rpcMessage, rpcMessage.requestId, callContext);
 	        }
+	        return Promise.resolve();
 	    }
 	    async onIncomingMessage(rpcMessage, callContext) {
 	        logger$z.trace(`onIncomingMessage, requestId: ${rpcMessage.requestId}`);
@@ -80505,41 +80451,43 @@
 	    }
 	}
 
-	/* eslint-disable prefer-spread, @typescript-eslint/consistent-indexed-object-style */
+	/* eslint-disable @typescript-eslint/consistent-indexed-object-style */
 	function toProtoRpcClient(orig) {
 	    const ret = {};
 	    Object.assign(ret, orig);
-	    const notify = async (methodName, obj, args) => {
-	        if (args.length < 2) {
-	            args.push({});
-	        }
-	        else {
-	            args[1] ??= {};
-	        }
-	        args[1].isProtoRpc = true;
-	        args[1].notification = true;
-	        await obj[methodName].apply(obj, args);
+	    // The generated protobuf-ts client only exists to forward to its transport;
+	    // we drive that transport directly (building the RpcMessage ourselves),
+	    // bypassing UnaryCall / mergeOptions / stackIntercept. `_transport` is the
+	    // protobuf-ts generated client's parameter property.
+	    // eslint-disable-next-line no-underscore-dangle
+	    const transport = orig._transport;
+	    const buildOptions = (args, notification) => {
+	        const options = (args.length >= 2 && args[1] != undefined) ? args[1] : {};
+	        options.isProtoRpc = true;
+	        if (notification) {
+	            options.notification = true;
+	        }
+	        return options;
 	    };
-	    const callRpc = (methodName, obj, args) => {
-	        if (args.length < 2) {
-	            args.push({});
-	        }
-	        else {
-	            args[1] ??= {};
-	        }
-	        args[1].isProtoRpc = true;
-	        return obj[methodName].apply(obj, args);
+	    // Legacy fallback (only if the client is backed by a non-ClientTransport
+	    // RpcTransport — never happens in this codebase): keep the generated path.
+	    const legacyNotify = async (methodName, obj, args) => {
+	        await obj[methodName].apply(obj, [args[0], buildOptions(args, true)]);
+	    };
+	    const legacyCall = (methodName, obj, args) => {
+	        return obj[methodName].apply(obj, [args[0], buildOptions(args, false)]);
 	    };
 	    orig.methods.forEach((method) => {
-	        if (method.O.typeName === Empty$3.typeName) {
-	            ret[method.name] = (...args) => {
-	                return notify(method.name, orig, args);
-	            };
+	        const isNotification = method.O.typeName === Empty$3.typeName;
+	        if (transport instanceof ClientTransport) {
+	            ret[method.name] = isNotification
+	                ? (...args) => transport.notification(method, args[0], buildOptions(args, true))
+	                : (...args) => transport.request(method, args[0], buildOptions(args, false));
 	        }
 	        else {
-	            ret[method.name] = (...args) => {
-	                return callRpc(method.name, orig, args).response;
-	            };
+	            ret[method.name] = isNotification
+	                ? (...args) => legacyNotify(method.name, orig, args)
+	                : (...args) => legacyCall(method.name, orig, args).response;
 	        }
 	    });
 	    return ret;
@@ -86110,8 +86058,56 @@
 	class SendFailed extends Err {
 	    constructor(message, originalError) { super(ErrorCode.SEND_FAILED, message, originalError); }
 	}
+	const SUMMARY_INTERVAL_MS = 2000;
+	const accumulators = new Map();
 	function logGapDiagnosticSampled(layer, opts = {}) {
-	    return;
+	    const now = performance.now();
+	    const threshold = opts.outlierThresholdMs ?? 30;
+	    let acc = accumulators.get(layer);
+	    if (acc === undefined) {
+	        acc = { count: 0, sumDeltaMs: 0, maxDeltaMs: 0, outlierCount: 0, lastReportMs: now, lastEventMs: now };
+	        accumulators.set(layer, acc);
+	        return;
+	    }
+	    const deltaMs = now - acc.lastEventMs;
+	    acc.lastEventMs = now;
+	    acc.count++;
+	    if (deltaMs > acc.maxDeltaMs)
+	        acc.maxDeltaMs = deltaMs;
+	    acc.sumDeltaMs += deltaMs;
+	    if (deltaMs > threshold)
+	        acc.outlierCount++;
+	    if (deltaMs > threshold) {
+	        const payload = {
+	            layer,
+	            timestampMs: now,
+	            deltaMs: +deltaMs.toFixed(2),
+	            detail: opts.detail,
+	        };
+	        // eslint-disable-next-line no-console
+	        console.log('[gap-diagnostics]', JSON.stringify(payload));
+	    }
+	    if (now - acc.lastReportMs >= SUMMARY_INTERVAL_MS) {
+	        const summaryDetail = {
+	            count: acc.count,
+	            meanDeltaMs: acc.count > 0 ? +(acc.sumDeltaMs / acc.count).toFixed(2) : 0,
+	            maxDeltaMs: +acc.maxDeltaMs.toFixed(2),
+	            outlierCount: acc.outlierCount,
+	            periodMs: +(now - acc.lastReportMs).toFixed(1),
+	        };
+	        const summary = {
+	            layer: `${layer}.summary`,
+	            timestampMs: now,
+	            detail: summaryDetail,
+	        };
+	        // eslint-disable-next-line no-console
+	        console.log('[gap-diagnostics]', JSON.stringify(summary));
+	        acc.count = 0;
+	        acc.sumDeltaMs = 0;
+	        acc.maxDeltaMs = 0;
+	        acc.outlierCount = 0;
+	        acc.lastReportMs = now;
+	    }
 	}
 
 	// @generated message type with reflection information, may provide speed optimized methods
@@ -88141,6 +88137,7 @@
 	        if ((this.state === ConnectionManagerState.STOPPED || this.state === ConnectionManagerState.STOPPING) && !opts.sendIfStopped) {
 	            return;
 	        }
+	        logGapDiagnosticSampled('dht.connMgr.send');
 	        const peerDescriptor = message.targetDescriptor;
 	        if (this.isConnectionToSelf(peerDescriptor)) {
 	            throw new CannotConnectToSelf('Cannot send to self');
@@ -88216,6 +88213,7 @@
 	            this.rpcCommunicator?.handleMessageFromPeer(message);
 	        }
 	        else {
+	            logGapDiagnosticSampled('dht.connMgr.emitMessage');
 	            logger$A.trace('emit "message" ' + toNodeId(message.sourceDescriptor)
 	                + ' ' + message.serviceId + ' ' + message.messageId);
 	            this.emit('message', message);
@@ -88225,6 +88223,7 @@
 	        if (this.state === ConnectionManagerState.STOPPED) {
 	            return;
 	        }
+	        logGapDiagnosticSampled('dht.connMgr.onData');
 	        this.metrics.receiveBytesPerSecond.record(data.byteLength);
 	        this.metrics.receiveMessagesPerSecond.record(1);
 	        let message;
@@ -88504,7 +88503,7 @@
 	    }
 	};
 
-	var version$2 = "103.7.0-rc.2";
+	var version$2 = "103.8.0-rc.3";
 
 	const logger$y = new Logger('Handshaker');
 	// Optimally the Outgoing and Incoming Handshakers could be their own separate classes
@@ -88926,6 +88925,7 @@
 	        };
 	        dataChannel.onmessage = (msg) => {
 	            logger$v.trace('dc.onmessage');
+	            logGapDiagnosticSampled('dht.dc.onmessage');
 	            this.emit('data', new Uint8Array(msg.data));
 	        };
 	        dataChannel.onbufferedamountlow = () => {
@@ -88996,6 +88996,66 @@
 	 * onbufferedamountlow) fire in the worker's event loop.  The main thread
 	 * is never involved in the data path.
 	 */
+	// ── agent log: layer0-vs-layer2 contention probe ────────────────────
+	// Every DHT connection's datachannel `onmessage` runs in THIS one worker, and
+	// `emit('data')` synchronously drives the downstream routing / RPC dispatch.
+	// So timing each emit captures the per-message synchronous processing cost —
+	// and aggregating across ALL connections tells us how much of the worker's
+	// event loop is consumed servicing GLOBAL-DHT layer0 traffic (routing for the
+	// hundreds of nodes we forward for) vs our handful of media messages. If a
+	// media arrival gap coincides with a window of high non-media processing, that
+	// is layer0 starving layer2. Emitted in the same `[gap-diagnostics]` line
+	// shape the analyzer already parses.
+	let dcWinStart = performance.now();
+	let dcWinCount = 0;
+	let dcWinBusyMs = 0;
+	let dcWinMaxMs = 0;
+	function recordDcProcessing(procMs) {
+	    dcWinCount++;
+	    dcWinBusyMs += procMs;
+	    if (procMs > dcWinMaxMs)
+	        dcWinMaxMs = procMs;
+	    // Individual event for a single message whose inline processing blocked the
+	    // loop unusually long (one expensive routing/RPC dispatch).
+	    if (procMs > 15) {
+	        try {
+	            console.log('[gap-diagnostics]', JSON.stringify({
+	                layer: 'dht.dc.processing.slow',
+	                timestampMs: performance.now(),
+	                deltaMs: +procMs.toFixed(2),
+	            }));
+	        }
+	        catch {
+	            /* ignore */
+	        }
+	    }
+	    const now = performance.now();
+	    const winElapsed = now - dcWinStart;
+	    if (winElapsed >= 1000) {
+	        try {
+	            console.log('[gap-diagnostics]', JSON.stringify({
+	                layer: 'dht.dc.processing.window',
+	                timestampMs: now,
+	                detail: {
+	                    windowMs: +winElapsed.toFixed(0),
+	                    count: dcWinCount,
+	                    msgPerSec: +((dcWinCount / winElapsed) * 1000).toFixed(0),
+	                    busyMs: +dcWinBusyMs.toFixed(1),
+	                    occupancyPct: +((dcWinBusyMs / winElapsed) *
+	                        100).toFixed(1),
+	                    maxMs: +dcWinMaxMs.toFixed(1),
+	                },
+	            }));
+	        }
+	        catch {
+	            /* ignore */
+	        }
+	        dcWinStart = now;
+	        dcWinCount = 0;
+	        dcWinBusyMs = 0;
+	        dcWinMaxMs = 0;
+	    }
+	}
 	// ── Module-level bridge client (initialized once per worker) ────────
 	let resolveBridgeProxy;
 	const bridgeProxyPromise = new Promise((resolve) => {
@@ -89038,6 +89098,19 @@
 	    earlyTimeout;
 	    messageQueue = [];
 	    startPromise;
+	    // agent log: PER-CONNECTION datachannel receive cadence. The global
+	    // `dht.dc.onmessage` accumulator can't isolate one stream; this tracks
+	    // inter-message arrival on THIS connection so we can pick the connection
+	    // carrying the composite media (highest count/bytes) and compare its
+	    // datachannel-level gaps against messageArrival (post-routing) and
+	    // videoFrameArrival (post-decrypt) — i.e. localize WHERE the gap is born.
+	    lastRecvMs;
+	    recvWinStart = 0;
+	    recvCount = 0;
+	    recvSumDelta = 0;
+	    recvMaxDelta = 0;
+	    recvBytes = 0;
+	    recvMaxBytes = 0;
 	    constructor(params) {
 	        super();
 	        this.connectionId = createRandomConnectionId();
@@ -89153,6 +89226,59 @@
 	        }
 	    }
 	    // ── DataChannel handling (runs entirely in the worker) ──────
+	    recordRecv(bytes) {
+	        const now = performance.now();
+	        const conn = String(this.connectionId).slice(0, 8);
+	        if (this.lastRecvMs !== undefined) {
+	            const delta = now - this.lastRecvMs;
+	            this.recvSumDelta += delta;
+	            if (delta > this.recvMaxDelta)
+	                this.recvMaxDelta = delta;
+	            if (delta > 60) {
+	                try {
+	                    console.log('[gap-diagnostics]', JSON.stringify({
+	                        layer: 'dht.dc.recvGap',
+	                        timestampMs: now,
+	                        deltaMs: +delta.toFixed(1),
+	                        detail: { conn, bytes },
+	                    }));
+	                }
+	                catch (_e) { /* ignore */ }
+	            }
+	        }
+	        this.lastRecvMs = now;
+	        this.recvCount++;
+	        this.recvBytes += bytes;
+	        if (bytes > this.recvMaxBytes)
+	            this.recvMaxBytes = bytes;
+	        if (this.recvWinStart === 0)
+	            this.recvWinStart = now;
+	        const elapsed = now - this.recvWinStart;
+	        if (elapsed >= 1000) {
+	            try {
+	                console.log('[gap-diagnostics]', JSON.stringify({
+	                    layer: 'dht.dc.recv',
+	                    timestampMs: now,
+	                    detail: {
+	                        conn,
+	                        count: this.recvCount,
+	                        perSec: Math.round((this.recvCount / elapsed) * 1000),
+	                        meanMs: +(this.recvSumDelta / Math.max(1, this.recvCount)).toFixed(1),
+	                        maxMs: +this.recvMaxDelta.toFixed(1),
+	                        bytesPerSec: Math.round((this.recvBytes / elapsed) * 1000),
+	                        maxBytes: this.recvMaxBytes,
+	                    },
+	                }));
+	            }
+	            catch (_e) { /* ignore */ }
+	            this.recvWinStart = now;
+	            this.recvCount = 0;
+	            this.recvSumDelta = 0;
+	            this.recvMaxDelta = 0;
+	            this.recvBytes = 0;
+	            this.recvMaxBytes = 0;
+	        }
+	    }
 	    setupDataChannel(dataChannel) {
 	        this.dataChannel = dataChannel;
 	        this.dataChannel.binaryType = 'arraybuffer';
@@ -89170,7 +89296,11 @@
 	        };
 	        dataChannel.onmessage = (msg) => {
 	            logger$u.trace('dc.onmessage (worker)');
+	            logGapDiagnosticSampled('dht.dc.onmessage');
+	            this.recordRecv(msg.data instanceof ArrayBuffer ? msg.data.byteLength : 0);
+	            const t0 = performance.now();
 	            this.emit('data', new Uint8Array(msg.data));
+	            recordDcProcessing(performance.now() - t0);
 	        };
 	        dataChannel.onbufferedamountlow = () => {
 	            logger$u.trace('dc.onBufferedAmountLow (worker)');
@@ -93732,7 +93862,7 @@
 	    }
 	}
 
-	var version$1 = "103.7.0-rc.2";
+	var version$1 = "103.8.0-rc.3";
 
 	// @generated message type with reflection information, may provide speed optimized methods
 	let Any$Type$1 = class Any$Type extends MessageType {
@@ -96479,7 +96609,13 @@
 	        if (!previousNode) {
 	            markAndCheckDuplicate(this.duplicateDetectors, msg.messageId, msg.previousMessageRef);
 	        }
-	        this.emit('message', msg);
+	        // Deliver to local listeners — except own publishes (no previousNode)
+	        // when loopback is suppressed: nothing local consumes them and they
+	        // would otherwise be re-serialized across a worker boundary just to be
+	        // discarded. Propagation + duplicate detection below are unaffected.
+	        if (previousNode !== undefined || !this.options.suppressOwnMessageLoopback) {
+	            this.emit('message', msg);
+	        }
 	        const skipBackPropagation = previousNode !== undefined && !this.options.temporaryConnectionRpcLocal.hasNode(previousNode);
 	        this.options.propagation.feedUnseenMessage(msg, this.getPropagationTargets(msg), skipBackPropagation ? previousNode : null);
 	        this.messagesPropagated += 1;
@@ -97858,6 +97994,7 @@
 	            neighborUpdateInterval: this.options.neighborUpdateInterval,
 	            isLocalNodeEntryPoint,
 	            bufferWhileConnecting: this.options.bufferWhileConnecting,
+	            suppressOwnMessageLoopback: this.options.suppressOwnMessageLoopback,
 	            plumtreeOptimization: streamPartDeliveryOptions?.plumtreeOptimization?.enabled,
 	            plumtreeMaxPausedNeighbors: streamPartDeliveryOptions?.plumtreeOptimization?.enabled === true ?
 	                streamPartDeliveryOptions?.plumtreeOptimization?.maxPausedNeighbors : undefined