dropspace 0.0.0-stage → 0.1.1

package/dist/client/channel.js

@@ -0,0 +1,704 @@
+import { encodeWireFrame, decodeWireFrame, encodeJsonPayload, decodeJsonPayload, WireFrameType, WIRE_PREFIX_BYTES, DEFAULT_MAX_FRAME_PAYLOAD_BYTES, DEFAULT_MAX_TOTAL_FRAME_BYTES, } from "../protocol/index.js";
+import { TypedEventEmitter } from "./events.js";
+export class MessagingError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "MessagingError";
+    }
+}
+let msgCounter = 0;
+function nextMessageId(prefix = "msg") {
+    msgCounter = (msgCounter + 1) % 1_000_000_000;
+    return `${prefix}_${Date.now().toString(36)}_${msgCounter.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Reliable binary-first framing, chunking, backpressure queue, and optional application ACK engine
+ * over an underlying `RTCDataChannel` (Section 13).
+ *
+ * Important Transport Note:
+ * Even an ordered, reliable `RTCDataChannel` only guarantees SCTP in-order delivery within a single
+ * active transport association. Across reconnects or new `RTCPeerConnection` instances, in-flight
+ * SCTP packets can be lost or re-sent. Enable `ack: "received" | "persisted" | "processed"` when
+ * application-level delivery confirmation and deduplication across retries are required.
+ */
+export class PeerChannelMultiplexer {
+    options;
+    events = new TypedEventEmitter();
+    dataChannel = null;
+    maxFramePayloadBytes;
+    maxTotalFrameBytes;
+    highWaterMark;
+    lowWaterMark;
+    maxQueueFrames;
+    maxQueueBytes;
+    maxReassemblyChunks;
+    maxReassemblyBytes;
+    reassemblyTimeoutMs;
+    dedupWindowMs;
+    maxDedupEntries;
+    highQueue = [];
+    interactiveQueue = [];
+    bulkQueue = [];
+    queuedBytes = 0;
+    reassemblyBytes = 0;
+    isFlushing = false;
+    backpressurePaused = false;
+    closed = false;
+    pendingAcks = new Map();
+    seenMessageIds = new Map();
+    partialAssemblies = new Map();
+    boundOnMessage;
+    boundOnBufferedAmountLow;
+    boundOnClose;
+    constructor(options) {
+        this.options = options;
+        this.maxFramePayloadBytes =
+            options.maxFramePayloadBytes ?? DEFAULT_MAX_FRAME_PAYLOAD_BYTES;
+        this.maxTotalFrameBytes =
+            options.maxTotalFrameBytes ?? DEFAULT_MAX_TOTAL_FRAME_BYTES;
+        this.highWaterMark = options.bufferedAmountHighWaterMark ?? 256 * 1024; // 256 KiB
+        this.lowWaterMark = options.bufferedAmountLowWaterMark ?? 64 * 1024; // 64 KiB
+        this.maxQueueFrames = options.maxSendQueueFrames ?? 2048;
+        this.maxQueueBytes = options.maxSendQueueBytes ?? 16 * 1024 * 1024; // 16 MiB
+        this.maxReassemblyChunks = options.maxReassemblyChunks ?? 2048;
+        this.maxReassemblyBytes = options.maxReassemblyBytes ?? 16 * 1024 * 1024; // 16 MiB
+        this.reassemblyTimeoutMs = options.reassemblyTimeoutMs ?? 30_000;
+        this.dedupWindowMs = options.dedupWindowMs ?? 120_000;
+        this.maxDedupEntries = options.maxDedupEntries ?? 4096;
+        this.boundOnMessage = (ev) => this.handleIncomingRaw(ev.data);
+        this.boundOnBufferedAmountLow = () => {
+            this.backpressurePaused = false;
+            this.events.emit("backpressureChange", {
+                bufferedAmount: this.dataChannel?.bufferedAmount ?? 0,
+                queuedBytes: this.queuedBytes,
+                paused: false,
+            });
+            void this.flushQueue();
+        };
+        this.boundOnClose = () => {
+            this.rejectQueuedFrames(new MessagingError("DataChannel closed while frames were queued", "CHANNEL_CLOSED"));
+            this.events.emit("close", undefined);
+        };
+    }
+    attachDataChannel(dc) {
+        this.detachDataChannel();
+        this.closed = false;
+        this.dataChannel = dc;
+        if ("binaryType" in dc) {
+            dc.binaryType = "arraybuffer";
+        }
+        dc.bufferedAmountLowThreshold = this.lowWaterMark;
+        dc.addEventListener("message", this.boundOnMessage);
+        dc.addEventListener("bufferedamountlow", this.boundOnBufferedAmountLow);
+        dc.addEventListener("close", this.boundOnClose);
+        if (dc.readyState === "open") {
+            void this.flushQueue();
+        }
+    }
+    detachDataChannel() {
+        if (!this.dataChannel)
+            return;
+        this.dataChannel.removeEventListener("message", this.boundOnMessage);
+        this.dataChannel.removeEventListener("bufferedamountlow", this.boundOnBufferedAmountLow);
+        this.dataChannel.removeEventListener("close", this.boundOnClose);
+        this.dataChannel = null;
+    }
+    get totalQueuedFrames() {
+        return this.highQueue.length + this.interactiveQueue.length + this.bulkQueue.length;
+    }
+    setMaxTotalFrameBytes(limitBytes) {
+        if (Number.isFinite(limitBytes) && limitBytes >= 16 * 1024) {
+            this.maxTotalFrameBytes = Math.floor(limitBytes);
+        }
+    }
+    getMaxTotalFrameBytes() {
+        return this.maxTotalFrameBytes;
+    }
+    getEffectiveChunkPayloadBytes(headerOverheadEstimate = 512) {
+        const budget = Math.max(1024, this.maxTotalFrameBytes - WIRE_PREFIX_BYTES - headerOverheadEstimate);
+        return Math.min(this.maxFramePayloadBytes, budget);
+    }
+    getQueueMetrics() {
+        return {
+            queuedFrames: this.totalQueuedFrames,
+            queuedBytes: this.queuedBytes,
+            bufferedAmount: this.dataChannel?.bufferedAmount ?? 0,
+        };
+    }
+    async sendBinary(payload, options = {}) {
+        return this.sendInternal(WireFrameType.MESSAGE_BINARY, payload, options);
+    }
+    async sendJson(value, options = {}) {
+        const bytes = encodeJsonPayload(value);
+        return this.sendInternal(WireFrameType.MESSAGE_JSON, bytes, options);
+    }
+    priorityForFrameType(frameType) {
+        if (frameType === WireFrameType.CONTROL_JSON || frameType === WireFrameType.TRANSFER_CONTROL) {
+            return "high";
+        }
+        if (frameType === WireFrameType.TRANSFER_CHUNK) {
+            return "bulk";
+        }
+        return "interactive";
+    }
+    async sendRawWireFrame(frameType, header, payload = new Uint8Array(0), signal) {
+        const priority = this.priorityForFrameType(frameType);
+        const chunkPayloadMax = this.getEffectiveChunkPayloadBytes();
+        // Chunk CRDT_SYNC (or MESSAGE_*) if payload + header + prefix would exceed maxTotalFrameBytes
+        if (frameType === WireFrameType.CRDT_SYNC &&
+            payload.byteLength > chunkPayloadMax) {
+            const totalChunks = Math.ceil(payload.byteLength / chunkPayloadMax);
+            for (let i = 0; i < totalChunks; i++) {
+                if (signal?.aborted) {
+                    throw new MessagingError("Frame send aborted during chunking", "ABORTED");
+                }
+                const start = i * chunkPayloadMax;
+                const end = Math.min(payload.byteLength, start + chunkPayloadMax);
+                const slice = payload.subarray(start, end);
+                const chunkHeader = {
+                    ...header,
+                    chunkIndex: i,
+                    totalChunks,
+                    totalByteLength: payload.byteLength,
+                };
+                const encoded = encodeWireFrame(frameType, chunkHeader, slice, {
+                    maxTotalFrameBytes: this.maxTotalFrameBytes,
+                });
+                await this.enqueueEncodedFrame(encoded, signal, undefined, priority);
+            }
+            return;
+        }
+        const encoded = encodeWireFrame(frameType, header, payload, {
+            maxTotalFrameBytes: this.maxTotalFrameBytes,
+        });
+        await this.enqueueEncodedFrame(encoded, signal, undefined, priority);
+    }
+    async sendInternal(frameType, payload, options) {
+        if (this.closed) {
+            throw new MessagingError("Channel multiplexer is closed", "CHANNEL_CLOSED");
+        }
+        if (options.signal?.aborted) {
+            throw new MessagingError("Message send aborted before start", "ABORTED");
+        }
+        const messageId = options.messageId ?? nextMessageId("msg");
+        const channel = options.channel ?? "default";
+        const ackMode = options.ack ? options.ack : undefined;
+        const maxRetries = options.maxRetries ?? (ackMode ? 2 : 0);
+        const ackTimeoutMs = options.ackTimeoutMs ?? options.timeoutMs ?? 5000;
+        const chunkPayloadMax = this.getEffectiveChunkPayloadBytes(options.viaHubDeviceId ? 1024 : 512);
+        const totalChunks = Math.max(1, Math.ceil(payload.byteLength / chunkPayloadMax));
+        const sendAllChunksOnce = async () => {
+            for (let i = 0; i < totalChunks; i++) {
+                if (options.signal?.aborted) {
+                    throw new MessagingError("Message send aborted during chunking", "ABORTED");
+                }
+                const start = i * chunkPayloadMax;
+                const end = Math.min(payload.byteLength, start + chunkPayloadMax);
+                const slice = payload.subarray(start, end);
+                const header = {
+                    messageId,
+                    channel,
+                    timestamp: Date.now(),
+                    chunkIndex: i,
+                    totalChunks,
+                    totalByteLength: payload.byteLength,
+                    ackRequired: Boolean(ackMode) && i === totalChunks - 1,
+                    ackMode,
+                    meta: options.meta,
+                };
+                let frameBytes = encodeWireFrame(frameType, header, slice, {
+                    maxTotalFrameBytes: this.maxTotalFrameBytes,
+                });
+                if (options.viaHubDeviceId) {
+                    // Wrap inside HUB_RELAY envelope
+                    const relayHeader = {
+                        messageId: `${messageId}_chunk_${i}`,
+                        channel: "hub_relay",
+                        timestamp: Date.now(),
+                        sourceDeviceId: this.options.localDeviceId,
+                        targetDeviceId: this.options.peerDeviceId,
+                        spaceId: options.spaceId,
+                        hopCount: 0,
+                        maxHops: options.maxHops ?? 2,
+                    };
+                    frameBytes = encodeWireFrame(WireFrameType.HUB_RELAY, relayHeader, frameBytes, {
+                        maxTotalFrameBytes: this.maxTotalFrameBytes,
+                    });
+                }
+                await this.enqueueEncodedFrame(frameBytes, options.signal, options.timeoutMs, "interactive");
+            }
+        };
+        if (!ackMode) {
+            await sendAllChunksOnce();
+            return { messageId };
+        }
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            const ackPromise = this.waitForAck(messageId, ackMode, ackTimeoutMs, options.signal);
+            try {
+                await sendAllChunksOnce();
+                const confirmed = await ackPromise;
+                return { messageId, ackSemantics: confirmed };
+            }
+            catch (err) {
+                if (options.signal?.aborted) {
+                    throw new MessagingError("Send aborted while awaiting ACK", "ABORTED");
+                }
+                if (attempt > maxRetries) {
+                    throw err;
+                }
+            }
+        }
+    }
+    waitForAck(messageId, expectedSemantics, timeoutMs, signal) {
+        return new Promise((resolve, reject) => {
+            const existing = this.pendingAcks.get(messageId);
+            if (existing) {
+                clearTimeout(existing.timer);
+            }
+            let onAbort;
+            const cleanup = () => {
+                if (onAbort && signal) {
+                    signal.removeEventListener("abort", onAbort);
+                }
+            };
+            const timer = setTimeout(() => {
+                this.pendingAcks.delete(messageId);
+                cleanup();
+                reject(new MessagingError(`Timed out waiting ${timeoutMs}ms for '${expectedSemantics}' ACK on message '${messageId}'`, "ACK_TIMEOUT"));
+            }, timeoutMs);
+            if (signal) {
+                onAbort = () => {
+                    clearTimeout(timer);
+                    this.pendingAcks.delete(messageId);
+                    reject(new MessagingError("ACK wait aborted by AbortSignal", "ABORTED"));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+            this.pendingAcks.set(messageId, {
+                messageId,
+                expectedSemantics,
+                resolve: (sem) => {
+                    cleanup();
+                    resolve(sem);
+                },
+                reject: (err) => {
+                    cleanup();
+                    reject(err);
+                },
+                timer,
+            });
+        });
+    }
+    queueForPriority(priority) {
+        if (priority === "high")
+            return this.highQueue;
+        if (priority === "bulk")
+            return this.bulkQueue;
+        return this.interactiveQueue;
+    }
+    dequeueNextFrame() {
+        return (this.highQueue.shift() ??
+            this.interactiveQueue.shift() ??
+            this.bulkQueue.shift());
+    }
+    removeQueuedItem(queue, item) {
+        const idx = queue.indexOf(item);
+        if (idx !== -1) {
+            queue.splice(idx, 1);
+            this.queuedBytes = Math.max(0, this.queuedBytes - item.bytes.byteLength);
+            return true;
+        }
+        return false;
+    }
+    enqueueEncodedFrame(bytes, signal, timeoutMs, priority = "interactive") {
+        if (this.closed) {
+            return Promise.reject(new MessagingError("Cannot send frame on closed multiplexer", "CHANNEL_CLOSED"));
+        }
+        if (signal?.aborted) {
+            return Promise.reject(new MessagingError("Frame send aborted", "ABORTED"));
+        }
+        if (this.totalQueuedFrames >= this.maxQueueFrames ||
+            this.queuedBytes + bytes.byteLength > this.maxQueueBytes) {
+            return Promise.reject(new MessagingError(`Send queue limit exceeded (${this.totalQueuedFrames} frames, ${this.queuedBytes} bytes)`, "QUEUE_OVERFLOW"));
+        }
+        const targetQueue = this.queueForPriority(priority);
+        return new Promise((resolve, reject) => {
+            let timeoutHandle;
+            const item = {
+                bytes,
+                resolve: () => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (item.onAbort && signal) {
+                        signal.removeEventListener("abort", item.onAbort);
+                    }
+                    resolve();
+                },
+                reject: (err) => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (item.onAbort && signal) {
+                        signal.removeEventListener("abort", item.onAbort);
+                    }
+                    reject(err);
+                },
+                signal,
+            };
+            if (signal) {
+                item.onAbort = () => {
+                    this.removeQueuedItem(targetQueue, item);
+                    item.reject(new MessagingError("Frame aborted while in send queue", "ABORTED"));
+                };
+                signal.addEventListener("abort", item.onAbort, { once: true });
+            }
+            if (timeoutMs && timeoutMs > 0) {
+                timeoutHandle = setTimeout(() => {
+                    this.removeQueuedItem(targetQueue, item);
+                    item.reject(new MessagingError(`Frame send timed out after ${timeoutMs}ms`, "TIMEOUT"));
+                }, timeoutMs);
+            }
+            targetQueue.push(item);
+            this.queuedBytes += bytes.byteLength;
+            void this.flushQueue();
+        });
+    }
+    async flushQueue() {
+        if (this.isFlushing || this.closed)
+            return;
+        if (!this.dataChannel || this.dataChannel.readyState !== "open")
+            return;
+        this.isFlushing = true;
+        try {
+            while (this.totalQueuedFrames > 0 && this.dataChannel && this.dataChannel.readyState === "open") {
+                if (this.dataChannel.bufferedAmount >= this.highWaterMark) {
+                    this.backpressurePaused = true;
+                    this.events.emit("backpressureChange", {
+                        bufferedAmount: this.dataChannel.bufferedAmount,
+                        queuedBytes: this.queuedBytes,
+                        paused: true,
+                    });
+                    // Wait until bufferedAmount drops below highWaterMark (either via bufferedamountlow event or micro-poll fallback)
+                    await this.waitForBufferDrain();
+                    if (!this.dataChannel || this.dataChannel.readyState !== "open") {
+                        break;
+                    }
+                }
+                const next = this.dequeueNextFrame();
+                if (!next)
+                    break;
+                this.queuedBytes = Math.max(0, this.queuedBytes - next.bytes.byteLength);
+                if (next.signal?.aborted) {
+                    next.reject(new MessagingError("Frame aborted before send", "ABORTED"));
+                    continue;
+                }
+                try {
+                    this.dataChannel.send(next.bytes);
+                    next.resolve();
+                }
+                catch (err) {
+                    next.reject(err instanceof Error
+                        ? err
+                        : new MessagingError(String(err), "CHANNEL_CLOSED"));
+                    break;
+                }
+            }
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    waitForBufferDrain() {
+        return new Promise((resolve) => {
+            if (!this.dataChannel || this.dataChannel.bufferedAmount <= this.lowWaterMark) {
+                this.backpressurePaused = false;
+                resolve();
+                return;
+            }
+            let resolved = false;
+            const done = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                clearInterval(pollTimer);
+                this.dataChannel?.removeEventListener("bufferedamountlow", onLow);
+                this.dataChannel?.removeEventListener("close", onClose);
+                this.backpressurePaused = false;
+                resolve();
+            };
+            const onLow = () => done();
+            const onClose = () => done();
+            this.dataChannel.addEventListener("bufferedamountlow", onLow);
+            this.dataChannel.addEventListener("close", onClose);
+            const pollTimer = setInterval(() => {
+                if (!this.dataChannel ||
+                    this.dataChannel.readyState !== "open" ||
+                    this.dataChannel.bufferedAmount <= this.lowWaterMark) {
+                    done();
+                }
+            }, 15);
+        });
+    }
+    handleIncomingRaw(rawData) {
+        let decoded;
+        try {
+            decoded = decodeWireFrame(rawData);
+        }
+        catch (err) {
+            this.events.emit("error", err instanceof Error ? err : new Error("Failed to decode wire frame"));
+            return;
+        }
+        this.options.onRawFrame?.(decoded);
+        switch (decoded.frameType) {
+            case WireFrameType.CONTROL_JSON: {
+                this.handleControlFrame(decoded);
+                break;
+            }
+            case WireFrameType.TRANSFER_CONTROL:
+            case WireFrameType.TRANSFER_CHUNK: {
+                this.events.emit("transferFrame", decoded);
+                break;
+            }
+            case WireFrameType.CRDT_SYNC: {
+                if ((decoded.header.totalChunks ?? 1) > 1) {
+                    this.handleApplicationFrame(decoded);
+                }
+                else {
+                    this.events.emit("crdtFrame", decoded);
+                }
+                break;
+            }
+            case WireFrameType.HUB_RELAY: {
+                this.events.emit("hubRelayFrame", decoded);
+                break;
+            }
+            case WireFrameType.MESSAGE_BINARY:
+            case WireFrameType.MESSAGE_JSON: {
+                this.handleApplicationFrame(decoded);
+                break;
+            }
+        }
+    }
+    handleControlFrame(frame) {
+        try {
+            const ctrl = decodeJsonPayload(frame.payload);
+            if (ctrl.type === "ack" && ctrl.ackForMessageId) {
+                const pending = this.pendingAcks.get(ctrl.ackForMessageId);
+                if (pending) {
+                    const sem = ctrl.semantics ?? "received";
+                    // Resolve if semantics satisfy expected level
+                    if (pending.expectedSemantics === "received" ||
+                        pending.expectedSemantics === sem ||
+                        sem === "processed") {
+                        clearTimeout(pending.timer);
+                        this.pendingAcks.delete(ctrl.ackForMessageId);
+                        pending.resolve(sem);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore malformed control payload
+        }
+    }
+    prunePartialAssemblies(now) {
+        for (const [msgId, assembly] of this.partialAssemblies.entries()) {
+            if (now - assembly.createdAt > this.reassemblyTimeoutMs) {
+                this.reassemblyBytes = Math.max(0, this.reassemblyBytes - assembly.receivedBytes);
+                this.partialAssemblies.delete(msgId);
+            }
+        }
+    }
+    handleApplicationFrame(frame, routedViaHub) {
+        const { header, payload, frameType } = frame;
+        const totalChunks = header.totalChunks ?? 1;
+        const chunkIndex = header.chunkIndex ?? 0;
+        if (totalChunks <= 1) {
+            if (frameType === WireFrameType.CRDT_SYNC) {
+                this.events.emit("crdtFrame", frame);
+            }
+            else {
+                this.deliverReassembledMessage(frameType, header, payload, routedViaHub);
+            }
+            return;
+        }
+        if (!Number.isInteger(totalChunks) ||
+            totalChunks < 1 ||
+            totalChunks > this.maxReassemblyChunks ||
+            !Number.isInteger(chunkIndex) ||
+            chunkIndex < 0 ||
+            chunkIndex >= totalChunks) {
+            this.events.emit("error", new MessagingError(`Invalid fragment index/count (${chunkIndex}/${totalChunks}) for '${header.messageId}'`, "MESSAGE_TOO_LARGE"));
+            return;
+        }
+        const now = Date.now();
+        this.prunePartialAssemblies(now);
+        let assembly = this.partialAssemblies.get(header.messageId);
+        if (!assembly) {
+            assembly = {
+                frameType,
+                header,
+                totalChunks,
+                chunks: new Map(),
+                receivedBytes: 0,
+                createdAt: now,
+            };
+            this.partialAssemblies.set(header.messageId, assembly);
+        }
+        if (!assembly.chunks.has(chunkIndex)) {
+            if (this.reassemblyBytes + payload.byteLength > this.maxReassemblyBytes) {
+                this.reassemblyBytes = Math.max(0, this.reassemblyBytes - assembly.receivedBytes);
+                this.partialAssemblies.delete(header.messageId);
+                this.events.emit("error", new MessagingError(`Reassembly buffer limit (${this.maxReassemblyBytes} bytes) exceeded`, "MESSAGE_TOO_LARGE"));
+                return;
+            }
+            const copy = new Uint8Array(payload.byteLength);
+            copy.set(payload);
+            assembly.chunks.set(chunkIndex, copy);
+            assembly.receivedBytes += copy.byteLength;
+            this.reassemblyBytes += copy.byteLength;
+        }
+        if (header.ackRequired) {
+            assembly.header = header;
+        }
+        if (assembly.chunks.size === totalChunks) {
+            this.partialAssemblies.delete(header.messageId);
+            this.reassemblyBytes = Math.max(0, this.reassemblyBytes - assembly.receivedBytes);
+            const fullBuffer = new Uint8Array(assembly.receivedBytes);
+            let offset = 0;
+            for (let i = 0; i < totalChunks; i++) {
+                const part = assembly.chunks.get(i);
+                if (!part)
+                    return;
+                fullBuffer.set(part, offset);
+                offset += part.byteLength;
+            }
+            if (assembly.frameType === WireFrameType.CRDT_SYNC) {
+                this.events.emit("crdtFrame", {
+                    frameType: WireFrameType.CRDT_SYNC,
+                    header: assembly.header,
+                    payload: fullBuffer,
+                });
+            }
+            else {
+                this.deliverReassembledMessage(assembly.frameType, assembly.header, fullBuffer, routedViaHub);
+            }
+        }
+    }
+    deliverHubUnwrappedFrame(innerFrame, hubDeviceId) {
+        if (innerFrame.frameType === WireFrameType.MESSAGE_BINARY ||
+            innerFrame.frameType === WireFrameType.MESSAGE_JSON) {
+            this.handleApplicationFrame(innerFrame, hubDeviceId);
+        }
+        else if (innerFrame.frameType === WireFrameType.TRANSFER_CONTROL ||
+            innerFrame.frameType === WireFrameType.TRANSFER_CHUNK) {
+            this.events.emit("transferFrame", innerFrame);
+        }
+        else if (innerFrame.frameType === WireFrameType.CRDT_SYNC) {
+            this.events.emit("crdtFrame", innerFrame);
+        }
+        else if (innerFrame.frameType === WireFrameType.CONTROL_JSON) {
+            this.handleControlFrame(innerFrame);
+        }
+    }
+    deliverReassembledMessage(frameType, header, fullPayload, routedViaHub) {
+        const now = Date.now();
+        this.pruneDeduplicationMap(now);
+        const sendAck = async (semantics = "received") => {
+            if (!header.ackRequired)
+                return;
+            const ackPayload = encodeJsonPayload({
+                type: "ack",
+                ackForMessageId: header.messageId,
+                semantics,
+            });
+            const ackHeader = {
+                messageId: nextMessageId("ack"),
+                channel: header.channel,
+                timestamp: Date.now(),
+                correlationId: header.messageId,
+            };
+            try {
+                await this.sendRawWireFrame(WireFrameType.CONTROL_JSON, ackHeader, ackPayload);
+            }
+            catch {
+                // Best-effort ACK reply
+            }
+        };
+        // Deduplicate by messageId within window
+        const seenAt = this.seenMessageIds.get(header.messageId);
+        if (seenAt !== undefined && now - seenAt < this.dedupWindowMs) {
+            // Still send ACK if peer retried because previous ACK was lost
+            if (header.ackRequired) {
+                void sendAck(header.ackMode ?? "received");
+            }
+            return;
+        }
+        this.seenMessageIds.set(header.messageId, now);
+        // Automatically send "received" ACK immediately if requested mode is "received"
+        if (header.ackRequired && (!header.ackMode || header.ackMode === "received")) {
+            void sendAck("received");
+        }
+        let parsedJson;
+        if (frameType === WireFrameType.MESSAGE_JSON) {
+            try {
+                parsedJson = decodeJsonPayload(fullPayload);
+            }
+            catch {
+                parsedJson = undefined;
+            }
+        }
+        this.events.emit("message", {
+            peerDeviceId: header.sourceDeviceId ?? this.options.peerDeviceId,
+            channel: header.channel,
+            messageId: header.messageId,
+            frameType,
+            header,
+            binary: fullPayload,
+            json: parsedJson,
+            routedViaHub,
+            acknowledge: sendAck,
+        });
+    }
+    pruneDeduplicationMap(now) {
+        if (this.seenMessageIds.size <= this.maxDedupEntries)
+            return;
+        for (const [id, ts] of this.seenMessageIds.entries()) {
+            if (now - ts >= this.dedupWindowMs || this.seenMessageIds.size > this.maxDedupEntries) {
+                this.seenMessageIds.delete(id);
+            }
+        }
+    }
+    rejectQueuedFrames(err) {
+        for (const queue of [this.highQueue, this.interactiveQueue, this.bulkQueue]) {
+            while (queue.length > 0) {
+                const item = queue.shift();
+                item.reject(err);
+            }
+        }
+        this.queuedBytes = 0;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.detachDataChannel();
+        this.rejectQueuedFrames(new MessagingError("PeerChannelMultiplexer closed", "CHANNEL_CLOSED"));
+        for (const pending of this.pendingAcks.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new MessagingError("Channel closed while awaiting ACK", "CHANNEL_CLOSED"));
+        }
+        this.pendingAcks.clear();
+        this.partialAssemblies.clear();
+        this.reassemblyBytes = 0;
+        this.seenMessageIds.clear();
+    }
+    dispose() {
+        this.close();
+        this.events.removeAllListeners();
+    }
+}
+//# sourceMappingURL=channel.js.map