@livedesk/hub 0.1.35 → 0.1.37

package/src/transport/udp-hub-transport.js

@@ -1,21 +1,21 @@
-import crypto from 'node:crypto';
-import { lookup } from 'node:dns/promises';
-import dgram from 'node:dgram';
+import crypto from 'node:crypto';
+import { lookup } from 'node:dns/promises';
+import dgram from 'node:dgram';
 import {
-    UDP_MAX_DATAGRAM_BYTES,
-    UDP_FRAME_CHUNK_PROTOCOL,
-    UDP_P2P_PROTOCOL,
-    UdpFrameReassembler,
-    UdpReplayWindow,
-    decodeRendezvousMessage,
-    decodeUdpPacket,
+    UDP_MAX_DATAGRAM_BYTES,
+    UDP_FRAME_CHUNK_PROTOCOL,
+    UDP_P2P_PROTOCOL,
+    UdpFrameReassembler,
+    UdpReplayWindow,
+    decodeRendezvousMessage,
+    decodeUdpPacket,
     encodeRendezvousMessage,
     encodeUdpPacket,
-    createUdpSessionKey,
-    isUdpBinaryDatagram,
-    peekUdpSessionRouteKey,
-    udpSessionRouteKey
-} from './udp-protocol.js';
+    createUdpSessionKey,
+    isUdpBinaryDatagram,
+    peekUdpSessionRouteKey,
+    udpSessionRouteKey
+} from './udp-protocol.js';
 
 function isEnabled(value, fallback = false) {
     if (value === undefined || value === null || value === '') return fallback;
@@ -31,207 +31,206 @@ function numberEnv(value, min, max, fallback) {
     return Number.isFinite(number) ? Math.max(min, Math.min(max, Math.floor(number))) : fallback;
 }
 
-function sameEndpoint(left, right) {
-    return !!left && !!right && String(left.address) === String(right.address) && Number(left.port) === Number(right.port);
-}
-
-function normalizedAddress(value) {
-    const address = safeText(value, 128).toLowerCase();
-    return address.startsWith('::ffff:') ? address.slice(7) : address;
-}
-
-function isPublicIPv4(value) {
-    const address = normalizedAddress(value);
-    const octets = address.split('.').map(Number);
-    if (octets.length !== 4
-        || octets.some(octet => !Number.isInteger(octet) || octet < 0 || octet > 255)) {
-        return false;
-    }
-    const [a, b] = octets;
-    const c = octets[2];
-    return a !== 0
-        && a !== 10
-        && a !== 127
-        && !(a === 100 && b >= 64 && b <= 127)
-        && !(a === 169 && b === 254)
-        && !(a === 172 && b >= 16 && b <= 31)
-        && !(a === 192 && (b === 0 || b === 168 || (b === 88 && c === 99)))
-        && !(a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100)))
-        && !(a === 203 && b === 0 && c === 113)
-        && !(a >= 224);
-}
-
-export function createHubUdpTransport({ env = process.env, logEvent = () => {}, logWarn = () => {} } = {}) {
-    const enabled = isEnabled(env.LIVEDESK_UDP_ENABLED, true);
-    const preferP2p = isEnabled(env.LIVEDESK_UDP_PREFER_P2P, false);
+function sameEndpoint(left, right) {
+    return !!left && !!right && String(left.address) === String(right.address) && Number(left.port) === Number(right.port);
+}
+
+function normalizedAddress(value) {
+    const address = safeText(value, 128).toLowerCase();
+    return address.startsWith('::ffff:') ? address.slice(7) : address;
+}
+
+function isPublicIPv4(value) {
+    const address = normalizedAddress(value);
+    const octets = address.split('.').map(Number);
+    if (octets.length !== 4
+        || octets.some(octet => !Number.isInteger(octet) || octet < 0 || octet > 255)) {
+        return false;
+    }
+    const [a, b] = octets;
+    const c = octets[2];
+    return a !== 0
+        && a !== 10
+        && a !== 127
+        && !(a === 100 && b >= 64 && b <= 127)
+        && !(a === 169 && b === 254)
+        && !(a === 172 && b >= 16 && b <= 31)
+        && !(a === 192 && (b === 0 || b === 168 || (b === 88 && c === 99)))
+        && !(a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100)))
+        && !(a === 203 && b === 0 && c === 113)
+        && !(a >= 224);
+}
+
+export function createHubUdpTransport({ env = process.env, logEvent = () => {}, logWarn = () => {} } = {}) {
+    const enabled = isEnabled(env.LIVEDESK_UDP_ENABLED, true);
+    const preferP2p = isEnabled(env.LIVEDESK_UDP_PREFER_P2P, false);
     const bindHost = safeText(env.LIVEDESK_UDP_BIND_HOST || '0.0.0.0', 128) || '0.0.0.0';
     const requestedPort = numberEnv(env.LIVEDESK_UDP_PORT, 0, 65535, 0);
     const advertiseHost = safeText(env.LIVEDESK_UDP_ADVERTISE_HOST || env.LIVEDESK_REMOTE_PUBLIC_HOST || '', 128);
-    const rendezvousHost = safeText(env.LIVEDESK_UDP_RENDEZVOUS_HOST || 'www.gnsoftech.com', 128);
-    const rendezvousPort = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_PORT, 1, 65535, 5199);
-    const rendezvousRefreshMs = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_REFRESH_MS, 1000, 50_000, 25_000);
+    const rendezvousHost = safeText(env.LIVEDESK_UDP_RENDEZVOUS_HOST || 'www.gnsoftech.com', 128);
+    const rendezvousPort = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_PORT, 1, 65535, 5199);
+    const rendezvousRefreshMs = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_REFRESH_MS, 1000, 50_000, 25_000);
     const punchTimeoutMs = numberEnv(env.LIVEDESK_UDP_PUNCH_TIMEOUT_MS, 500, 10_000, 3000);
-    const frameTimeoutMs = numberEnv(env.LIVEDESK_UDP_FRAME_TIMEOUT_MS, 20, 2000, 500);
+    const frameTimeoutMs = numberEnv(env.LIVEDESK_UDP_FRAME_TIMEOUT_MS, 20, 2000, 500);
     const maxPendingFrames = numberEnv(env.LIVEDESK_UDP_MAX_PENDING_FRAMES, 1, 16, 2);
-    const trace = isEnabled(env.LIVEDESK_UDP_TRACE, false);
-    const socket = dgram.createSocket('udp4');
-    const sessions = new Map();
-    const sessionsBySessionId = new Map();
-    const sessionsByRouteKey = new Map();
-    const resource = {
-        datagramsReceived: 0,
-        binaryDatagramsReceived: 0,
-        rendezvousJsonParseAttempts: 0,
-        binaryJsonParseAttempts: 0,
-        sessionLookupCount: 0,
-        linearSessionScanCount: 0,
-        authenticatedDatagrams: 0,
-        rejectedDatagrams: 0
-    };
+    const trace = isEnabled(env.LIVEDESK_UDP_TRACE, false);
+    const socket = dgram.createSocket('udp4');
+    const sessions = new Map();
+    const sessionsBySessionId = new Map();
+    const sessionsByRouteKey = new Map();
+    const resource = {
+        datagramsReceived: 0,
+        binaryDatagramsReceived: 0,
+        rendezvousJsonParseAttempts: 0,
+        binaryJsonParseAttempts: 0,
+        sessionLookupCount: 0,
+        linearSessionScanCount: 0,
+        authenticatedDatagrams: 0,
+        rejectedDatagrams: 0
+    };
     let frameHandler = () => {};
-    let eventHandler = () => {};
-    let started = false;
-    let boundPort = requestedPort;
-    let sequence = crypto.randomInt(1, 0x7fffffff);
-    let rendezvousAddresses = new Set();
-    let rendezvousRefreshTimer = null;
-    let rendezvousRefreshPromise = null;
-    let frameExpiryTimer = null;
-    let rendezvousProofIssuer = null;
-    const peerProbeBurstDelaysMs = [0, 120, 360];
+    let eventHandler = () => {};
+    let started = false;
+    let boundPort = requestedPort;
+    let sequence = crypto.randomInt(1, 0x7fffffff);
+    let rendezvousAddresses = new Set();
+    let rendezvousRefreshTimer = null;
+    let rendezvousRefreshPromise = null;
+    let frameExpiryTimer = null;
+    const peerProbeBurstDelaysMs = [0, 120, 360];
 
     function emit(type, event = {}) {
         eventHandler(type, event);
         if (trace) logEvent('udp', `${type} ${JSON.stringify({ deviceId: event.deviceId || '', state: event.state || '', reason: event.reason || '' })}`);
     }
 
-    function nextSequence() {
-        sequence = (sequence + 1) >>> 0;
-        return sequence;
-    }
-
-    function sendPacket(session, type, header = {}, payload = Buffer.alloc(0), address = session.clientEndpoint || session.peerEndpoint) {
-        if (!address || !session) return false;
-        let packet;
-        try {
-            packet = encodeUdpPacket({ type, sessionId: session.sessionId, key: session.key, sequence: nextSequence(), header, payload });
-        } catch (error) {
-            logWarn('udp', `UDP packet rejected device=${session.deviceId}: ${error?.message || error}`);
-            return false;
-        }
+    function nextSequence() {
+        sequence = (sequence + 1) >>> 0;
+        return sequence;
+    }
+
+    function sendPacket(session, type, header = {}, payload = Buffer.alloc(0), address = session.clientEndpoint || session.peerEndpoint) {
+        if (!address || !session) return false;
+        let packet;
+        try {
+            packet = encodeUdpPacket({ type, sessionId: session.sessionId, key: session.key, sequence: nextSequence(), header, payload });
+        } catch (error) {
+            logWarn('udp', `UDP packet rejected device=${session.deviceId}: ${error?.message || error}`);
+            return false;
+        }
         socket.send(packet, address.port, address.address);
         return true;
     }
 
-    function sendRendezvousRegister(session) {
-        if (!rendezvousHost || rendezvousAddresses.size === 0 || !started) return false;
-        const message = encodeRendezvousMessage({
-            type: 'rendezvous.register',
+    function sendRendezvousRegister(session) {
+        if (!rendezvousHost || rendezvousAddresses.size === 0 || !started) return false;
+        const message = encodeRendezvousMessage({
+            type: 'rendezvous.register',
             protocol: UDP_P2P_PROTOCOL,
             roomId: session.sessionId,
-            role: 'hub',
-            token: session.rendezvousToken
-        });
-        let sent = false;
-        for (const address of rendezvousAddresses) {
-            try {
-                socket.send(message, rendezvousPort, address, error => {
-                    if (error) logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
-                });
-                sent = true;
-            } catch (error) {
-                logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
-            }
-        }
-        return sent;
-    }
-
-    async function resolveRendezvousAddresses() {
-        if (!rendezvousHost) return false;
-        try {
-            const records = await lookup(rendezvousHost, { all: true, family: 4, verbatim: true });
-            const resolved = new Set(records.map(record => normalizedAddress(record.address)).filter(Boolean));
-            if (resolved.size === 0) throw new Error('no-ipv4-address');
-            rendezvousAddresses = resolved;
-            return true;
-        } catch (error) {
-            logWarn('udp', `UDP rendezvous host resolution failed: ${error?.message || error}`);
-            return false;
-        }
-    }
-
-    function refreshRendezvousRegistrations(reason = 'periodic') {
-        if (!started || !rendezvousHost) return Promise.resolve(false);
-        if (rendezvousRefreshPromise) return rendezvousRefreshPromise;
-        rendezvousRefreshPromise = (async () => {
-            await resolveRendezvousAddresses();
-            if (!started) return false;
-            let refreshed = false;
-            for (const session of sessions.values()) {
-                refreshed = sendRendezvousRegister(session) || refreshed;
-            }
-            if (trace && refreshed) emit('UdpRendezvousRegistrationRefreshed', { reason });
-            return refreshed;
-        })().finally(() => {
-            rendezvousRefreshPromise = null;
-        });
-        return rendezvousRefreshPromise;
-    }
-
-    function startRendezvousRefreshTimer() {
-        if (!rendezvousHost || rendezvousRefreshTimer) return;
-        rendezvousRefreshTimer = setInterval(() => {
-            void refreshRendezvousRegistrations('periodic');
-        }, rendezvousRefreshMs);
-        rendezvousRefreshTimer.unref?.();
-    }
-
-    function stopRendezvousRefreshTimer() {
-        if (rendezvousRefreshTimer) clearInterval(rendezvousRefreshTimer);
-        rendezvousRefreshTimer = null;
-    }
-
-    function startFrameExpiryTimer() {
-        if (frameExpiryTimer) return;
-        frameExpiryTimer = setInterval(() => {
-            const now = Date.now();
-            for (const session of sessions.values()) {
-                session.reassembler.expire(now);
-            }
-        }, Math.max(20, Math.min(250, frameTimeoutMs)));
-        frameExpiryTimer.unref?.();
-    }
-
-    function stopFrameExpiryTimer() {
-        if (frameExpiryTimer) clearInterval(frameExpiryTimer);
-        frameExpiryTimer = null;
-    }
-
-    function isTrustedRendezvousSource(rinfo) {
-        return Number(rinfo?.port) === rendezvousPort
-            && rendezvousAddresses.has(normalizedAddress(rinfo?.address));
-    }
-
-    function sessionForPacket(packet) {
-        resource.sessionLookupCount += 1;
-        const routeKey = peekUdpSessionRouteKey(packet);
-        return routeKey === null ? null : sessionsByRouteKey.get(routeKey) || null;
-    }
-
-    function bindAuthenticatedClientEndpoint(session, rinfo) {
-        const endpoint = { address: rinfo.address, port: rinfo.port };
-        if (sameEndpoint(session.clientEndpoint, endpoint)) return false;
-        session.clientEndpoint = endpoint;
-        session.lastPeerAt = Date.now();
-        sendRendezvousRegister(session);
-        void refreshRendezvousRegistrations('authenticated-endpoint-change');
-        emit('UdpAuthenticatedEndpointObserved', {
-            deviceId: session.deviceId,
-            endpoint: `${endpoint.address}:${endpoint.port}`
-        });
-        return true;
-    }
-
+            role: 'hub',
+            token: session.rendezvousToken
+        });
+        let sent = false;
+        for (const address of rendezvousAddresses) {
+            try {
+                socket.send(message, rendezvousPort, address, error => {
+                    if (error) logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
+                });
+                sent = true;
+            } catch (error) {
+                logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
+            }
+        }
+        return sent;
+    }
+
+    async function resolveRendezvousAddresses() {
+        if (!rendezvousHost) return false;
+        try {
+            const records = await lookup(rendezvousHost, { all: true, family: 4, verbatim: true });
+            const resolved = new Set(records.map(record => normalizedAddress(record.address)).filter(Boolean));
+            if (resolved.size === 0) throw new Error('no-ipv4-address');
+            rendezvousAddresses = resolved;
+            return true;
+        } catch (error) {
+            logWarn('udp', `UDP rendezvous host resolution failed: ${error?.message || error}`);
+            return false;
+        }
+    }
+
+    function refreshRendezvousRegistrations(reason = 'periodic') {
+        if (!started || !rendezvousHost) return Promise.resolve(false);
+        if (rendezvousRefreshPromise) return rendezvousRefreshPromise;
+        rendezvousRefreshPromise = (async () => {
+            await resolveRendezvousAddresses();
+            if (!started) return false;
+            let refreshed = false;
+            for (const session of sessions.values()) {
+                refreshed = sendRendezvousRegister(session) || refreshed;
+            }
+            if (trace && refreshed) emit('UdpRendezvousRegistrationRefreshed', { reason });
+            return refreshed;
+        })().finally(() => {
+            rendezvousRefreshPromise = null;
+        });
+        return rendezvousRefreshPromise;
+    }
+
+    function startRendezvousRefreshTimer() {
+        if (!rendezvousHost || rendezvousRefreshTimer) return;
+        rendezvousRefreshTimer = setInterval(() => {
+            void refreshRendezvousRegistrations('periodic');
+        }, rendezvousRefreshMs);
+        rendezvousRefreshTimer.unref?.();
+    }
+
+    function stopRendezvousRefreshTimer() {
+        if (rendezvousRefreshTimer) clearInterval(rendezvousRefreshTimer);
+        rendezvousRefreshTimer = null;
+    }
+
+    function startFrameExpiryTimer() {
+        if (frameExpiryTimer) return;
+        frameExpiryTimer = setInterval(() => {
+            const now = Date.now();
+            for (const session of sessions.values()) {
+                session.reassembler.expire(now);
+            }
+        }, Math.max(20, Math.min(250, frameTimeoutMs)));
+        frameExpiryTimer.unref?.();
+    }
+
+    function stopFrameExpiryTimer() {
+        if (frameExpiryTimer) clearInterval(frameExpiryTimer);
+        frameExpiryTimer = null;
+    }
+
+    function isTrustedRendezvousSource(rinfo) {
+        return Number(rinfo?.port) === rendezvousPort
+            && rendezvousAddresses.has(normalizedAddress(rinfo?.address));
+    }
+
+    function sessionForPacket(packet) {
+        resource.sessionLookupCount += 1;
+        const routeKey = peekUdpSessionRouteKey(packet);
+        return routeKey === null ? null : sessionsByRouteKey.get(routeKey) || null;
+    }
+
+    function bindAuthenticatedClientEndpoint(session, rinfo) {
+        const endpoint = { address: rinfo.address, port: rinfo.port };
+        if (sameEndpoint(session.clientEndpoint, endpoint)) return false;
+        session.clientEndpoint = endpoint;
+        session.lastPeerAt = Date.now();
+        sendRendezvousRegister(session);
+        void refreshRendezvousRegistrations('authenticated-endpoint-change');
+        emit('UdpAuthenticatedEndpointObserved', {
+            deviceId: session.deviceId,
+            endpoint: `${endpoint.address}:${endpoint.port}`
+        });
+        return true;
+    }
+
     function clearPeerProbeTimers(session) {
         if (!session?.peerProbeTimers) return;
         for (const timer of session.peerProbeTimers) clearTimeout(timer);
@@ -242,7 +241,7 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         clearPeerProbeTimers(session);
         for (const delayMs of peerProbeBurstDelaysMs) {
             const sendProbe = () => {
-                if (sessions.get(session.deviceId) !== session
+                if (sessions.get(session.deviceId) !== session
                     || !sameEndpoint(session.peerEndpoint, endpoint)) return;
                 sendPacket(session, 'probe', { punch: true }, Buffer.alloc(0), endpoint);
             };
@@ -259,78 +258,78 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         }
     }
 
-    function onRendezvousPeer(message, rinfo) {
-        const session = sessionsBySessionId.get(safeText(message.roomId, 160));
-        if (!session || message.protocol !== UDP_P2P_PROTOCOL || !isTrustedRendezvousSource(rinfo)) return;
-        const address = safeText(message.host, 128);
-        const port = Number(message.port);
-        if (!address || !Number.isInteger(port) || port < 1 || port > 65535) return;
-        const observedAddress = normalizedAddress(message.observedHost);
-        const observedPort = Number(message.observedPort);
-        if (observedAddress
-            && Number.isInteger(observedPort)
-            && observedPort >= 1
-            && observedPort <= 65535) {
-            session.hubRendezvousEndpoint = {
-                address: observedAddress,
-                port: observedPort
-            };
-            session.hubRendezvousObservedAt = Date.now();
-        }
+    function onRendezvousPeer(message, rinfo) {
+        const session = sessionsBySessionId.get(safeText(message.roomId, 160));
+        if (!session || message.protocol !== UDP_P2P_PROTOCOL || !isTrustedRendezvousSource(rinfo)) return;
+        const address = safeText(message.host, 128);
+        const port = Number(message.port);
+        if (!address || !Number.isInteger(port) || port < 1 || port > 65535) return;
+        const observedAddress = normalizedAddress(message.observedHost);
+        const observedPort = Number(message.observedPort);
+        if (observedAddress
+            && Number.isInteger(observedPort)
+            && observedPort >= 1
+            && observedPort <= 65535) {
+            session.hubRendezvousEndpoint = {
+                address: observedAddress,
+                port: observedPort
+            };
+            session.hubRendezvousObservedAt = Date.now();
+        }
         session.peerEndpoint = { address, port };
         session.lastPeerAt = Date.now();
         schedulePeerProbeBurst(session, session.peerEndpoint);
         emit('UdpPeerEndpointObserved', { deviceId: session.deviceId, endpoint: `${address}:${port}` });
     }
 
-    socket.on('message', (payload, rinfo) => {
-        resource.datagramsReceived += 1;
-        if (!isUdpBinaryDatagram(payload)) {
-            // Rendezvous messages are the only JSON datagrams. Binary packets
-            // never pay a speculative JSON parse/exception before routing.
-            if (payload?.[0] !== 0x7b) {
-                resource.rejectedDatagrams += 1;
-                return;
-            }
-            resource.rendezvousJsonParseAttempts += 1;
-            const rendezvous = decodeRendezvousMessage(payload);
-            if (rendezvous?.type === 'rendezvous.peer') {
-                onRendezvousPeer(rendezvous, rinfo);
-            } else {
-                resource.rejectedDatagrams += 1;
-            }
-            return;
-        }
-        resource.binaryDatagramsReceived += 1;
-        const session = sessionForPacket(payload);
-        if (!session) {
-            resource.rejectedDatagrams += 1;
-            return;
-        }
-        session.resource.binaryDatagramsReceived += 1;
-        session.resource.decryptAttempts += 1;
-        const packet = decodeUdpPacket(payload, session.key, {
-            id: session.sessionId,
-            bytes: session.sessionIdBytes
-        });
-        if (!packet || packet.sessionId !== session.sessionId || !session.replay.accept(packet.sequence)) {
-            session.resource.rejectedDatagrams += 1;
-            resource.rejectedDatagrams += 1;
-            return;
-        }
-        resource.authenticatedDatagrams += 1;
-        session.resource.authenticatedDatagrams += 1;
-        bindAuthenticatedClientEndpoint(session, rinfo);
-        session.lastPacketAt = Date.now();
-        if (packet.type === 'probe') {
-            sendPacket(session, 'probe-ack', { observedHost: rinfo.address, observedPort: rinfo.port });
+    socket.on('message', (payload, rinfo) => {
+        resource.datagramsReceived += 1;
+        if (!isUdpBinaryDatagram(payload)) {
+            // Rendezvous messages are the only JSON datagrams. Binary packets
+            // never pay a speculative JSON parse/exception before routing.
+            if (payload?.[0] !== 0x7b) {
+                resource.rejectedDatagrams += 1;
+                return;
+            }
+            resource.rendezvousJsonParseAttempts += 1;
+            const rendezvous = decodeRendezvousMessage(payload);
+            if (rendezvous?.type === 'rendezvous.peer') {
+                onRendezvousPeer(rendezvous, rinfo);
+            } else {
+                resource.rejectedDatagrams += 1;
+            }
+            return;
+        }
+        resource.binaryDatagramsReceived += 1;
+        const session = sessionForPacket(payload);
+        if (!session) {
+            resource.rejectedDatagrams += 1;
+            return;
+        }
+        session.resource.binaryDatagramsReceived += 1;
+        session.resource.decryptAttempts += 1;
+        const packet = decodeUdpPacket(payload, session.key, {
+            id: session.sessionId,
+            bytes: session.sessionIdBytes
+        });
+        if (!packet || packet.sessionId !== session.sessionId || !session.replay.accept(packet.sequence)) {
+            session.resource.rejectedDatagrams += 1;
+            resource.rejectedDatagrams += 1;
+            return;
+        }
+        resource.authenticatedDatagrams += 1;
+        session.resource.authenticatedDatagrams += 1;
+        bindAuthenticatedClientEndpoint(session, rinfo);
+        session.lastPacketAt = Date.now();
+        if (packet.type === 'probe') {
+            sendPacket(session, 'probe-ack', { observedHost: rinfo.address, observedPort: rinfo.port });
             emit('UdpProbeReceived', { deviceId: session.deviceId });
             return;
         }
         if (packet.type === 'ready') {
             clearPeerProbeTimers(session);
-            session.ready = true;
-            sendPacket(session, 'pong', { state: 'ready' });
+            session.ready = true;
+            sendPacket(session, 'pong', { state: 'ready' });
             session.sendControl?.({
                 type: 'udp.session.ready',
                 protocol: UDP_P2P_PROTOCOL,
@@ -347,53 +346,53 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             return;
         }
         if (packet.type !== 'frame') return;
-        const complete = session.reassembler.ingest(packet);
-        if (!complete) return;
-        session.framesReceived += 1;
-        const reassembly = session.reassembler.getStats();
-        const handled = frameHandler({
-            deviceId: session.deviceId,
-            sessionId: session.sessionId,
-            header: {
-                ...complete.header,
-                hubIngressDropped: Math.max(
-                    Number(complete.header?.hubIngressDropped || 0) || 0,
-                    reassembly.droppedFrames
-                ),
-                udpIncompleteFrames: reassembly.droppedFrames
-            },
-            payload: complete.payload,
-            transport: 'udp-p2p'
-        });
-        const accepted = handled === true || handled?.accepted === true;
-        const proofId = safeText(complete.header?.frameTransportProofId, 96);
-        if (proofId) {
-            if (handled?.suppressProofResponse === true) return;
-            const proofAccepted = accepted && handled?.proofAccepted === true;
-            sendPacket(session, 'pong', {
-                state: proofAccepted ? 'frame-proof-ack' : 'frame-proof-reject',
-                proofId,
-                protocol: 'livedesk.frame-transport-proof.v1',
-                streamId: safeText(complete.header?.streamId, 128),
-                commandId: safeText(complete.header?.commandId, 128),
-                streamPurpose: safeText(complete.header?.streamPurpose, 24),
-                captureGeneration: Number(complete.header?.captureGeneration || 0) || 0,
-                monitorIndex: Number(complete.header?.monitorIndex ?? -1),
-                error: proofAccepted ? '' : safeText(handled?.error || 'frame-proof-rejected', 160)
-            });
-            return;
-        }
-        if (accepted) {
-            sendPacket(session, 'pong', {
-                state: 'frame-ack',
-                frameSeq: Number(complete.header?.frameSeq || 0) || 0,
-                streamId: safeText(complete.header?.streamId, 128),
-                commandId: safeText(complete.header?.commandId, 128),
-                streamPurpose: safeText(complete.header?.streamPurpose, 24),
-                captureGeneration: Number(complete.header?.captureGeneration || 0) || 0,
-                monitorIndex: Number(complete.header?.monitorIndex ?? -1)
-            });
-        }
+        const complete = session.reassembler.ingest(packet);
+        if (!complete) return;
+        session.framesReceived += 1;
+        const reassembly = session.reassembler.getStats();
+        const handled = frameHandler({
+            deviceId: session.deviceId,
+            sessionId: session.sessionId,
+            header: {
+                ...complete.header,
+                hubIngressDropped: Math.max(
+                    Number(complete.header?.hubIngressDropped || 0) || 0,
+                    reassembly.droppedFrames
+                ),
+                udpIncompleteFrames: reassembly.droppedFrames
+            },
+            payload: complete.payload,
+            transport: 'udp-p2p'
+        });
+        const accepted = handled === true || handled?.accepted === true;
+        const proofId = safeText(complete.header?.frameTransportProofId, 96);
+        if (proofId) {
+            if (handled?.suppressProofResponse === true) return;
+            const proofAccepted = accepted && handled?.proofAccepted === true;
+            sendPacket(session, 'pong', {
+                state: proofAccepted ? 'frame-proof-ack' : 'frame-proof-reject',
+                proofId,
+                protocol: 'livedesk.frame-transport-proof.v1',
+                streamId: safeText(complete.header?.streamId, 128),
+                commandId: safeText(complete.header?.commandId, 128),
+                streamPurpose: safeText(complete.header?.streamPurpose, 24),
+                captureGeneration: Number(complete.header?.captureGeneration || 0) || 0,
+                monitorIndex: Number(complete.header?.monitorIndex ?? -1),
+                error: proofAccepted ? '' : safeText(handled?.error || 'frame-proof-rejected', 160)
+            });
+            return;
+        }
+        if (accepted) {
+            sendPacket(session, 'pong', {
+                state: 'frame-ack',
+                frameSeq: Number(complete.header?.frameSeq || 0) || 0,
+                streamId: safeText(complete.header?.streamId, 128),
+                commandId: safeText(complete.header?.commandId, 128),
+                streamPurpose: safeText(complete.header?.streamPurpose, 24),
+                captureGeneration: Number(complete.header?.captureGeneration || 0) || 0,
+                monitorIndex: Number(complete.header?.monitorIndex ?? -1)
+            });
+        }
     });
     socket.on('error', error => logWarn('udp', `UDP socket error: ${error?.message || error}`));
 
@@ -405,93 +404,74 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             socket.once('error', onError);
             socket.once('listening', onListening);
             socket.bind(requestedPort, bindHost);
-        });
-        started = true;
-        boundPort = socket.address().port;
-        try {
-            socket.setRecvBufferSize(8 * 1024 * 1024);
-            socket.setSendBufferSize(1024 * 1024);
-        } catch (error) {
-            logWarn('udp', `UDP socket buffer tuning was unavailable: ${error?.message || error}`);
-        }
-        logEvent('udp', `UDP P2P socket listening on udp://${bindHost}:${boundPort}`);
-        void refreshRendezvousRegistrations('startup');
-        startRendezvousRefreshTimer();
-        startFrameExpiryTimer();
-        return getStatus();
+        });
+        started = true;
+        boundPort = socket.address().port;
+        try {
+            socket.setRecvBufferSize(8 * 1024 * 1024);
+            socket.setSendBufferSize(1024 * 1024);
+        } catch (error) {
+            logWarn('udp', `UDP socket buffer tuning was unavailable: ${error?.message || error}`);
+        }
+        logEvent('udp', `UDP P2P socket listening on udp://${bindHost}:${boundPort}`);
+        void refreshRendezvousRegistrations('startup');
+        startRendezvousRefreshTimer();
+        startFrameExpiryTimer();
+        return getStatus();
     }
 
-    function registerDevice({ deviceId, sessionId: tcpSessionId, sendControl, capabilities } = {}) {
-        if (!enabled || capabilities?.udpP2p !== true || !started) return null;
-        const id = safeText(deviceId, 160);
-        if (!id) return null;
-        const previous = sessions.get(id);
+    function registerDevice({ deviceId, sessionId: tcpSessionId, sendControl, capabilities } = {}) {
+        if (!enabled || capabilities?.udpP2p !== true || !started) return null;
+        const id = safeText(deviceId, 160);
+        if (!id) return null;
+        const previous = sessions.get(id);
         previous?.sendControl?.({ type: 'udp.session.close', reason: 'replaced' });
         if (previous) {
-            clearPeerProbeTimers(previous);
-            sessions.delete(id);
-            sessionsBySessionId.delete(previous.sessionId);
-            sessionsByRouteKey.delete(previous.routeKey);
-            previous.reassembler.clear();
-        }
-        const key = createUdpSessionKey();
-        let udpSessionId;
-        let routeKey;
-        do {
-            udpSessionId = crypto.randomUUID();
-            routeKey = udpSessionRouteKey(udpSessionId);
-        } while (sessionsByRouteKey.has(routeKey));
-        const hubProof = typeof rendezvousProofIssuer === 'function'
-            ? rendezvousProofIssuer({ roomId: udpSessionId, deviceId: id, role: 'hub', ttlMs: 60_000 })
-            : null;
-        const clientProof = typeof rendezvousProofIssuer === 'function'
-            ? rendezvousProofIssuer({ roomId: udpSessionId, deviceId: id, role: 'client', ttlMs: 60_000 })
-            : null;
-        const signedHubRendezvousProof = safeText(hubProof?.proof, 2048);
-        const signedClientRendezvousProof = safeText(clientProof?.proof, 2048);
-        const allowLegacyUnsignedProofForTests = env.LIVEDESK_TEST_MODE === '1'
-            || env.LIVEDESK_TEST_ALLOW_LEGACY_UDP_RENDEZVOUS === '1';
-        const legacyRendezvousToken = allowLegacyUnsignedProofForTests
-            && (!signedHubRendezvousProof || !signedClientRendezvousProof)
-            ? crypto.randomBytes(16).toString('hex')
-            : '';
-        const proofExpiries = [hubProof?.payload?.expiresAt, clientProof?.payload?.expiresAt]
-            .map(Number)
-            .filter(Number.isSafeInteger);
-        const session = {
+            clearPeerProbeTimers(previous);
+            sessions.delete(id);
+            sessionsBySessionId.delete(previous.sessionId);
+            sessionsByRouteKey.delete(previous.routeKey);
+            previous.reassembler.clear();
+        }
+        const key = createUdpSessionKey();
+        let udpSessionId;
+        let routeKey;
+        do {
+            udpSessionId = crypto.randomUUID();
+            routeKey = udpSessionRouteKey(udpSessionId);
+        } while (sessionsByRouteKey.has(routeKey));
+        const session = {
             deviceId: id,
             tcpSessionId: safeText(tcpSessionId, 160),
-            sessionId: udpSessionId,
-            sessionIdBytes: Buffer.from(udpSessionId, 'utf8'),
-            routeKey,
+            sessionId: udpSessionId,
+            sessionIdBytes: Buffer.from(udpSessionId, 'utf8'),
+            routeKey,
             key,
             keyBase64: key.toString('base64'),
-            rendezvousToken: signedHubRendezvousProof || legacyRendezvousToken,
-            clientRendezvousToken: signedClientRendezvousProof || legacyRendezvousToken,
-            rendezvousProofExpiresAt: proofExpiries.length === 2 ? Math.min(...proofExpiries) : 0,
+            rendezvousToken: crypto.randomBytes(16).toString('hex'),
             sendControl,
-            clientEndpoint: null,
-            peerEndpoint: null,
-            hubRendezvousEndpoint: null,
-            hubRendezvousObservedAt: 0,
-            replay: new UdpReplayWindow(),
-            reassembler: new UdpFrameReassembler({ maxPending: maxPendingFrames, timeoutMs: frameTimeoutMs }),
-            resource: {
-                binaryDatagramsReceived: 0,
-                decryptAttempts: 0,
-                authenticatedDatagrams: 0,
-                rejectedDatagrams: 0
-            },
+            clientEndpoint: null,
+            peerEndpoint: null,
+            hubRendezvousEndpoint: null,
+            hubRendezvousObservedAt: 0,
+            replay: new UdpReplayWindow(),
+            reassembler: new UdpFrameReassembler({ maxPending: maxPendingFrames, timeoutMs: frameTimeoutMs }),
+            resource: {
+                binaryDatagramsReceived: 0,
+                decryptAttempts: 0,
+                authenticatedDatagrams: 0,
+                rejectedDatagrams: 0
+            },
             ready: false,
             peerProbeTimers: new Set(),
             createdAt: Date.now(),
             lastPacketAt: 0,
             framesReceived: 0
-        };
-        sessions.set(id, session);
-        sessionsBySessionId.set(session.sessionId, session);
-        sessionsByRouteKey.set(session.routeKey, session);
-        sendControl?.({
+        };
+        sessions.set(id, session);
+        sessionsBySessionId.set(session.sessionId, session);
+        sessionsByRouteKey.set(session.routeKey, session);
+        sendControl?.({
             type: 'udp.session.offer',
             protocol: UDP_P2P_PROTOCOL,
             sessionId: session.sessionId,
@@ -500,206 +480,203 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             port: boundPort,
             expiresInMs: punchTimeoutMs + 15_000,
             punchTimeoutMs,
-            maxDatagramBytes: UDP_MAX_DATAGRAM_BYTES,
-            frameChunkHeader: UDP_FRAME_CHUNK_PROTOCOL,
-            frameTimeoutMs,
+            maxDatagramBytes: UDP_MAX_DATAGRAM_BYTES,
+            frameChunkHeader: UDP_FRAME_CHUNK_PROTOCOL,
+            frameTimeoutMs,
             maxPendingFrames,
-            rendezvous: rendezvousHost && session.clientRendezvousToken
-                ? { host: rendezvousHost, port: rendezvousPort, roomId: session.sessionId, token: session.clientRendezvousToken }
-                : null
+            rendezvous: rendezvousHost
+                ? { host: rendezvousHost, port: rendezvousPort, roomId: session.sessionId, token: session.rendezvousToken }
+                : null
         });
         sendRendezvousRegister(session);
         emit('UdpSessionCreated', { deviceId: id, state: 'udp-session-created' });
         return { sessionId: session.sessionId, ready: false };
     }
 
-    function unregisterDevice(deviceId, tcpSessionId = '') {
+    function unregisterDevice(deviceId, tcpSessionId = '') {
         const id = safeText(deviceId, 160);
         const session = sessions.get(id);
-        if (!session || (tcpSessionId && session.tcpSessionId !== tcpSessionId)) return;
+        if (!session || (tcpSessionId && session.tcpSessionId !== tcpSessionId)) return;
         clearPeerProbeTimers(session);
         sessions.delete(id);
-        sessionsBySessionId.delete(session.sessionId);
-        sessionsByRouteKey.delete(session.routeKey);
-        session.reassembler.clear();
-        emit('UdpSessionClosed', { deviceId: id, reason: 'tcp-session-closed' });
+        sessionsBySessionId.delete(session.sessionId);
+        sessionsByRouteKey.delete(session.routeKey);
+        session.reassembler.clear();
+        emit('UdpSessionClosed', { deviceId: id, reason: 'tcp-session-closed' });
     }
 
-    function getDeviceStatus(deviceId) {
+    function getDeviceStatus(deviceId) {
         const session = sessions.get(safeText(deviceId, 160));
         if (!session) return { enabled, state: enabled ? 'disabled' : 'tcp-only', ready: false };
         return {
             enabled,
             preferred: preferP2p,
-            state: session.ready ? 'udp-ready' : 'udp-session-created',
-            ready: session.ready,
+            state: session.ready ? 'udp-ready' : 'udp-session-created',
+            ready: session.ready,
             sessionId: session.sessionId,
-            lastPacketAt: session.lastPacketAt ? new Date(session.lastPacketAt).toISOString() : '',
-            framesReceived: session.framesReceived,
-            resource: {
-                ...session.resource,
-                binaryJsonParseAttempts: 0,
-                sessionLookup: 'map-o1',
-                linearSessionScanCount: 0
-            },
-            ...session.reassembler.getStats()
-        };
-    }
-
-    async function refreshDeviceDiagnosticNetwork(deviceId, { timeoutMs = 3_000 } = {}) {
-        const session = sessions.get(safeText(deviceId, 160));
-        if (!session || !started || !rendezvousHost) return false;
-        const requestedAt = Date.now();
-        await resolveRendezvousAddresses();
-        if (!sendRendezvousRegister(session)) return false;
-        const deadline = requestedAt + numberEnv(timeoutMs, 250, 5_000, 3_000);
-        while (Date.now() < deadline) {
-            if (session.hubRendezvousObservedAt >= requestedAt) return true;
-            await new Promise(resolve => {
-                const timer = setTimeout(resolve, 40);
-                timer.unref?.();
-            });
-        }
-        return false;
-    }
-
-    function getDeviceDiagnosticNetwork(deviceId, { salt = '' } = {}) {
-        const session = sessions.get(safeText(deviceId, 160));
-        const clientAddress = normalizedAddress(session?.clientEndpoint?.address);
-        const normalizedHubAddress = normalizedAddress(session?.hubRendezvousEndpoint?.address);
-        const hubAddressObservedAt = session?.hubRendezvousObservedAt
-            ? new Date(session.hubRendezvousObservedAt).toISOString()
-            : '';
-        const digest = value => value
-            ? crypto.createHash('sha256')
-                .update(`${safeText(salt, 160)}:${value}`)
-                .digest('hex')
-                .slice(0, 16)
-            : '';
-        if (!session?.ready || !clientAddress) {
-            return {
-                evidence: 'authenticated-udp-endpoint-unavailable',
-                differentPublicEgress: null,
-                clientAddressHash: '',
-                hubAddressHash: digest(normalizedHubAddress),
-                hubAddressObservedAt,
-                hubEndpointSource: normalizedHubAddress
-                    ? 'trusted-rendezvous-observation'
-                    : 'unavailable'
-            };
-        }
-        const clientAddressPublic = isPublicIPv4(clientAddress);
-        const hubAddressPublic = isPublicIPv4(normalizedHubAddress);
-        return {
-            evidence: normalizedHubAddress
-                ? 'authenticated-udp-endpoint-rendezvous-observed'
-                : 'authenticated-udp-endpoint-hub-egress-unavailable',
-            differentPublicEgress: clientAddressPublic && hubAddressPublic
-                ? clientAddress !== normalizedHubAddress
-                : null,
-            clientAddressHash: digest(clientAddress),
-            hubAddressHash: digest(normalizedHubAddress),
-            clientAddressPublic,
-            hubAddressPublic,
-            endpointAuthenticated: true,
-            udpReady: session.ready === true,
-            observedAt: session.lastPacketAt ? new Date(session.lastPacketAt).toISOString() : '',
-            hubAddressObservedAt,
-            hubEndpointSource: normalizedHubAddress
-                ? 'trusted-rendezvous-observation'
-                : 'unavailable'
-        };
-    }
-
-    async function close() {
-        stopRendezvousRefreshTimer();
-        stopFrameExpiryTimer();
+            lastPacketAt: session.lastPacketAt ? new Date(session.lastPacketAt).toISOString() : '',
+            framesReceived: session.framesReceived,
+            resource: {
+                ...session.resource,
+                binaryJsonParseAttempts: 0,
+                sessionLookup: 'map-o1',
+                linearSessionScanCount: 0
+            },
+            ...session.reassembler.getStats()
+        };
+    }
+
+    async function refreshDeviceDiagnosticNetwork(deviceId, { timeoutMs = 3_000 } = {}) {
+        const session = sessions.get(safeText(deviceId, 160));
+        if (!session || !started || !rendezvousHost) return false;
+        const requestedAt = Date.now();
+        await resolveRendezvousAddresses();
+        if (!sendRendezvousRegister(session)) return false;
+        const deadline = requestedAt + numberEnv(timeoutMs, 250, 5_000, 3_000);
+        while (Date.now() < deadline) {
+            if (session.hubRendezvousObservedAt >= requestedAt) return true;
+            await new Promise(resolve => {
+                const timer = setTimeout(resolve, 40);
+                timer.unref?.();
+            });
+        }
+        return false;
+    }
+
+    function getDeviceDiagnosticNetwork(deviceId, { salt = '' } = {}) {
+        const session = sessions.get(safeText(deviceId, 160));
+        const clientAddress = normalizedAddress(session?.clientEndpoint?.address);
+        const normalizedHubAddress = normalizedAddress(session?.hubRendezvousEndpoint?.address);
+        const hubAddressObservedAt = session?.hubRendezvousObservedAt
+            ? new Date(session.hubRendezvousObservedAt).toISOString()
+            : '';
+        const digest = value => value
+            ? crypto.createHash('sha256')
+                .update(`${safeText(salt, 160)}:${value}`)
+                .digest('hex')
+                .slice(0, 16)
+            : '';
+        if (!session?.ready || !clientAddress) {
+            return {
+                evidence: 'authenticated-udp-endpoint-unavailable',
+                differentPublicEgress: null,
+                clientAddressHash: '',
+                hubAddressHash: digest(normalizedHubAddress),
+                hubAddressObservedAt,
+                hubEndpointSource: normalizedHubAddress
+                    ? 'trusted-rendezvous-observation'
+                    : 'unavailable'
+            };
+        }
+        const clientAddressPublic = isPublicIPv4(clientAddress);
+        const hubAddressPublic = isPublicIPv4(normalizedHubAddress);
+        return {
+            evidence: normalizedHubAddress
+                ? 'authenticated-udp-endpoint-rendezvous-observed'
+                : 'authenticated-udp-endpoint-hub-egress-unavailable',
+            differentPublicEgress: clientAddressPublic && hubAddressPublic
+                ? clientAddress !== normalizedHubAddress
+                : null,
+            clientAddressHash: digest(clientAddress),
+            hubAddressHash: digest(normalizedHubAddress),
+            clientAddressPublic,
+            hubAddressPublic,
+            endpointAuthenticated: true,
+            udpReady: session.ready === true,
+            observedAt: session.lastPacketAt ? new Date(session.lastPacketAt).toISOString() : '',
+            hubAddressObservedAt,
+            hubEndpointSource: normalizedHubAddress
+                ? 'trusted-rendezvous-observation'
+                : 'unavailable'
+        };
+    }
+
+    async function close() {
+        stopRendezvousRefreshTimer();
+        stopFrameExpiryTimer();
         for (const session of sessions.values()) {
             clearPeerProbeTimers(session);
             session.reassembler.clear();
-        }
-        sessions.clear();
-        sessionsBySessionId.clear();
-        sessionsByRouteKey.clear();
-        if (!started) return;
-        started = false;
-        await new Promise(resolve => socket.close(() => resolve()));
+        }
+        sessions.clear();
+        sessionsBySessionId.clear();
+        sessionsByRouteKey.clear();
+        if (!started) return;
+        started = false;
+        await new Promise(resolve => socket.close(() => resolve()));
     }
 
     return {
         start,
         close,
         registerDevice,
-        unregisterDevice,
-        getDeviceStatus,
-        refreshDeviceDiagnosticNetwork,
-        getDeviceDiagnosticNetwork,
-        getStatus,
-        setRendezvousProofIssuer: issuer => {
-            rendezvousProofIssuer = typeof issuer === 'function' ? issuer : null;
-        },
+        unregisterDevice,
+        getDeviceStatus,
+        refreshDeviceDiagnosticNetwork,
+        getDeviceDiagnosticNetwork,
+        getStatus,
         setFrameHandler: handler => { frameHandler = typeof handler === 'function' ? handler : () => {}; },
         setEventHandler: handler => { eventHandler = typeof handler === 'function' ? handler : () => {}; }
     };
 
-    function getStatus() {
-        let readySessionCount = 0;
-        const reassembly = {
-            pendingFrames: 0,
-            pendingBytes: 0,
-            pendingChunkBuffers: 0,
-            pendingBytesHighWatermark: 0,
-            pendingChunkBuffersHighWatermark: 0,
-            droppedFrames: 0,
-            completedFrames: 0,
-            completedPayloadCopyCount: 0,
-            completedPayloadCopyBytes: 0,
-            fullWireDuplicateCopyCount: 0,
-            binaryChunkHeaderCount: 0,
-            legacyChunkHeaderCount: 0
-        };
-        for (const session of sessions.values()) {
-            if (session.ready) readySessionCount += 1;
-            const stats = session.reassembler.getStats();
-            reassembly.pendingFrames += stats.pendingFrames;
-            reassembly.pendingBytes += stats.pendingBytes;
-            reassembly.pendingChunkBuffers += stats.pendingChunkBuffers;
-            reassembly.pendingBytesHighWatermark = Math.max(
-                reassembly.pendingBytesHighWatermark,
-                stats.pendingBytesHighWatermark
-            );
-            reassembly.pendingChunkBuffersHighWatermark = Math.max(
-                reassembly.pendingChunkBuffersHighWatermark,
-                stats.pendingChunkBuffersHighWatermark
-            );
-            reassembly.droppedFrames += stats.droppedFrames;
-            reassembly.completedFrames += stats.completedFrames;
-            reassembly.completedPayloadCopyCount += stats.completedPayloadCopyCount;
-            reassembly.completedPayloadCopyBytes += stats.completedPayloadCopyBytes;
-            reassembly.fullWireDuplicateCopyCount += stats.fullWireDuplicateCopyCount;
-            reassembly.binaryChunkHeaderCount += stats.binaryChunkHeaderCount;
-            reassembly.legacyChunkHeaderCount += stats.legacyChunkHeaderCount;
-        }
-        return {
+    function getStatus() {
+        let readySessionCount = 0;
+        const reassembly = {
+            pendingFrames: 0,
+            pendingBytes: 0,
+            pendingChunkBuffers: 0,
+            pendingBytesHighWatermark: 0,
+            pendingChunkBuffersHighWatermark: 0,
+            droppedFrames: 0,
+            completedFrames: 0,
+            completedPayloadCopyCount: 0,
+            completedPayloadCopyBytes: 0,
+            fullWireDuplicateCopyCount: 0,
+            binaryChunkHeaderCount: 0,
+            legacyChunkHeaderCount: 0
+        };
+        for (const session of sessions.values()) {
+            if (session.ready) readySessionCount += 1;
+            const stats = session.reassembler.getStats();
+            reassembly.pendingFrames += stats.pendingFrames;
+            reassembly.pendingBytes += stats.pendingBytes;
+            reassembly.pendingChunkBuffers += stats.pendingChunkBuffers;
+            reassembly.pendingBytesHighWatermark = Math.max(
+                reassembly.pendingBytesHighWatermark,
+                stats.pendingBytesHighWatermark
+            );
+            reassembly.pendingChunkBuffersHighWatermark = Math.max(
+                reassembly.pendingChunkBuffersHighWatermark,
+                stats.pendingChunkBuffersHighWatermark
+            );
+            reassembly.droppedFrames += stats.droppedFrames;
+            reassembly.completedFrames += stats.completedFrames;
+            reassembly.completedPayloadCopyCount += stats.completedPayloadCopyCount;
+            reassembly.completedPayloadCopyBytes += stats.completedPayloadCopyBytes;
+            reassembly.fullWireDuplicateCopyCount += stats.fullWireDuplicateCopyCount;
+            reassembly.binaryChunkHeaderCount += stats.binaryChunkHeaderCount;
+            reassembly.legacyChunkHeaderCount += stats.legacyChunkHeaderCount;
+        }
+        return {
             enabled,
             preferred: preferP2p,
             started,
             bindHost,
             port: boundPort,
             advertiseHost,
-            rendezvousHost,
-            rendezvousPort,
-            rendezvousRefreshMs,
-            rendezvousResolvedAddressCount: rendezvousAddresses.size,
-            maxDatagramBytes: UDP_MAX_DATAGRAM_BYTES,
-            sessionCount: sessions.size,
-            readySessionCount,
-            resource: {
-                ...resource,
-                indexedSessionCount: sessionsBySessionId.size,
-                indexedRouteCount: sessionsByRouteKey.size,
-                ...reassembly
-            }
-        };
+            rendezvousHost,
+            rendezvousPort,
+            rendezvousRefreshMs,
+            rendezvousResolvedAddressCount: rendezvousAddresses.size,
+            maxDatagramBytes: UDP_MAX_DATAGRAM_BYTES,
+            sessionCount: sessions.size,
+            readySessionCount,
+            resource: {
+                ...resource,
+                indexedSessionCount: sessionsBySessionId.size,
+                indexedRouteCount: sessionsByRouteKey.size,
+                ...reassembly
+            }
+        };
     }
 }