@livedesk/hub 0.1.26 → 0.1.28

package/src/transport/agent-binary-ingress.js

@@ -0,0 +1,810 @@
+const DEFAULT_MAX_PACKETS = 3;
+const DEFAULT_MAX_QUEUE_BYTES = 12 * 1024 * 1024;
+const DEFAULT_MAX_QUEUE_AGE_MS = 120;
+const DEFAULT_DRAIN_BUDGET_PACKETS = 3;
+const DEFAULT_MODE5_PACKETS_PER_STREAM = 2;
+
+function boundedInteger(value, minimum, maximum, fallback) {
+    const parsed = Math.floor(Number(value));
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    return Math.max(minimum, Math.min(maximum, parsed));
+}
+
+function stringValue(value, maxLength = 160) {
+    return String(value ?? '').trim().slice(0, maxLength);
+}
+
+function bufferValue(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return Buffer.from(value ?? []);
+}
+
+/**
+ * Append-only segmented byte storage for socket parsers.
+ *
+ * Appends retain the incoming immutable socket chunk instead of copying all
+ * historical bytes. Materialization always owns one exact-sized backing store,
+ * and discard/clear releases references to consumed chunks synchronously.
+ */
+export class BoundedSegmentedBuffer {
+    constructor(maxBytes) {
+        this.maxBytes = boundedInteger(maxBytes, 1, Number.MAX_SAFE_INTEGER, 1);
+        this.chunks = [];
+        this.headIndex = 0;
+        this.headOffset = 0;
+        this.byteLength = 0;
+        this.highWaterBytes = 0;
+        this.appendedBytes = 0;
+        this.materializedBytes = 0;
+        this.rejectedBytes = 0;
+    }
+
+    get length() {
+        return this.byteLength;
+    }
+
+    get segmentCount() {
+        return Math.max(0, this.chunks.length - this.headIndex);
+    }
+
+    append(value) {
+        const chunk = bufferValue(value);
+        if (chunk.length === 0) {
+            return true;
+        }
+        if (chunk.length > this.maxBytes - this.byteLength) {
+            this.rejectedBytes += chunk.length;
+            return false;
+        }
+
+        this.chunks.push(chunk);
+        this.byteLength += chunk.length;
+        this.appendedBytes += chunk.length;
+        this.highWaterBytes = Math.max(this.highWaterBytes, this.byteLength);
+        return true;
+    }
+
+    byteAt(index) {
+        const target = Math.floor(Number(index));
+        if (!Number.isFinite(target) || target < 0 || target >= this.byteLength) {
+            return undefined;
+        }
+
+        let remaining = target;
+        for (let chunkIndex = this.headIndex; chunkIndex < this.chunks.length; chunkIndex += 1) {
+            const chunk = this.chunks[chunkIndex];
+            const start = chunkIndex === this.headIndex ? this.headOffset : 0;
+            const available = chunk.length - start;
+            if (remaining < available) {
+                return chunk[start + remaining];
+            }
+            remaining -= available;
+        }
+        return undefined;
+    }
+
+    readExact(startIndex, length) {
+        const start = Math.floor(Number(startIndex));
+        const requested = Math.floor(Number(length));
+        if (!Number.isFinite(start)
+            || !Number.isFinite(requested)
+            || start < 0
+            || requested < 0
+            || start + requested > this.byteLength) {
+            return null;
+        }
+        if (requested === 0) {
+            return Buffer.alloc(0);
+        }
+
+        // allocUnsafeSlow owns an exact ArrayBuffer instead of retaining a
+        // large socket chunk or a pooled backing store through subarray().
+        const output = Buffer.allocUnsafeSlow(requested);
+        let skip = start;
+        let written = 0;
+        for (let chunkIndex = this.headIndex; chunkIndex < this.chunks.length && written < requested; chunkIndex += 1) {
+            const chunk = this.chunks[chunkIndex];
+            const baseOffset = chunkIndex === this.headIndex ? this.headOffset : 0;
+            const available = chunk.length - baseOffset;
+            if (skip >= available) {
+                skip -= available;
+                continue;
+            }
+
+            const sourceStart = baseOffset + skip;
+            const copyLength = Math.min(requested - written, chunk.length - sourceStart);
+            chunk.copy(output, written, sourceStart, sourceStart + copyLength);
+            written += copyLength;
+            skip = 0;
+        }
+
+        if (written !== requested) {
+            return null;
+        }
+        this.materializedBytes += requested;
+        return output;
+    }
+
+    readUInt16BE(index) {
+        const first = this.byteAt(index);
+        const second = this.byteAt(Number(index) + 1);
+        if (first === undefined || second === undefined) {
+            return null;
+        }
+        return ((first << 8) | second) >>> 0;
+    }
+
+    readUInt32BE(index) {
+        const first = this.byteAt(index);
+        const second = this.byteAt(Number(index) + 1);
+        const third = this.byteAt(Number(index) + 2);
+        const fourth = this.byteAt(Number(index) + 3);
+        if (first === undefined
+            || second === undefined
+            || third === undefined
+            || fourth === undefined) {
+            return null;
+        }
+        return (((first << 24) >>> 0)
+            | (second << 16)
+            | (third << 8)
+            | fourth) >>> 0;
+    }
+
+    readBigUInt64BE(index) {
+        let value = 0n;
+        for (let offset = 0; offset < 8; offset += 1) {
+            const byte = this.byteAt(Number(index) + offset);
+            if (byte === undefined) {
+                return null;
+            }
+            value = (value << 8n) | BigInt(byte);
+        }
+        return value;
+    }
+
+    startsWith(sequence, startIndex = 0) {
+        const expected = bufferValue(sequence);
+        const start = Math.floor(Number(startIndex));
+        if (!Number.isFinite(start)
+            || start < 0
+            || expected.length === 0
+            || start + expected.length > this.byteLength) {
+            return false;
+        }
+        for (let index = 0; index < expected.length; index += 1) {
+            if (this.byteAt(start + index) !== expected[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    indexOfByte(value, startIndex = 0) {
+        const needle = Number(value) & 0xff;
+        const start = Math.max(0, Math.floor(Number(startIndex) || 0));
+        if (start >= this.byteLength) {
+            return -1;
+        }
+
+        let logicalOffset = 0;
+        for (let chunkIndex = this.headIndex; chunkIndex < this.chunks.length; chunkIndex += 1) {
+            const chunk = this.chunks[chunkIndex];
+            const baseOffset = chunkIndex === this.headIndex ? this.headOffset : 0;
+            const available = chunk.length - baseOffset;
+            if (logicalOffset + available <= start) {
+                logicalOffset += available;
+                continue;
+            }
+            const localStart = baseOffset + Math.max(0, start - logicalOffset);
+            const found = chunk.indexOf(needle, localStart);
+            if (found >= 0) {
+                return logicalOffset + found - baseOffset;
+            }
+            logicalOffset += available;
+        }
+        return -1;
+    }
+
+    findIndex(predicate, startIndex = 0) {
+        if (typeof predicate !== 'function') {
+            return -1;
+        }
+        const start = Math.max(0, Math.floor(Number(startIndex) || 0));
+        if (start >= this.byteLength) {
+            return -1;
+        }
+
+        let logicalIndex = 0;
+        for (let chunkIndex = this.headIndex; chunkIndex < this.chunks.length; chunkIndex += 1) {
+            const chunk = this.chunks[chunkIndex];
+            const baseOffset = chunkIndex === this.headIndex ? this.headOffset : 0;
+            for (let offset = baseOffset; offset < chunk.length; offset += 1, logicalIndex += 1) {
+                if (logicalIndex >= start && predicate(chunk[offset], logicalIndex)) {
+                    return logicalIndex;
+                }
+            }
+        }
+        return -1;
+    }
+
+    indexOfSequence(sequence, startIndex = 0) {
+        const needle = bufferValue(sequence);
+        const start = Math.max(0, Math.floor(Number(startIndex) || 0));
+        if (needle.length === 0) {
+            return Math.min(start, this.byteLength);
+        }
+        if (start >= this.byteLength || needle.length > this.byteLength - start) {
+            return -1;
+        }
+
+        const prefix = new Uint32Array(needle.length);
+        for (let index = 1, matched = 0; index < needle.length; index += 1) {
+            while (matched > 0 && needle[index] !== needle[matched]) {
+                matched = prefix[matched - 1];
+            }
+            if (needle[index] === needle[matched]) {
+                matched += 1;
+            }
+            prefix[index] = matched;
+        }
+
+        let logicalIndex = 0;
+        let matched = 0;
+        for (let chunkIndex = this.headIndex; chunkIndex < this.chunks.length; chunkIndex += 1) {
+            const chunk = this.chunks[chunkIndex];
+            const baseOffset = chunkIndex === this.headIndex ? this.headOffset : 0;
+            for (let offset = baseOffset; offset < chunk.length; offset += 1, logicalIndex += 1) {
+                if (logicalIndex < start) {
+                    continue;
+                }
+                const current = chunk[offset];
+                while (matched > 0 && current !== needle[matched]) {
+                    matched = prefix[matched - 1];
+                }
+                if (current === needle[matched]) {
+                    matched += 1;
+                }
+                if (matched === needle.length) {
+                    return logicalIndex - needle.length + 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+    discard(length) {
+        let remaining = Math.max(0, Math.min(this.byteLength, Math.floor(Number(length) || 0)));
+        const discarded = remaining;
+        while (remaining > 0 && this.headIndex < this.chunks.length) {
+            const chunk = this.chunks[this.headIndex];
+            const available = chunk.length - this.headOffset;
+            if (remaining < available) {
+                this.headOffset += remaining;
+                remaining = 0;
+                break;
+            }
+            remaining -= available;
+            this.chunks[this.headIndex] = null;
+            this.headIndex += 1;
+            this.headOffset = 0;
+        }
+        this.byteLength -= discarded;
+
+        if (this.byteLength === 0) {
+            this.chunks = [];
+            this.headIndex = 0;
+            this.headOffset = 0;
+        } else if (this.headIndex >= 64 && this.headIndex * 2 >= this.chunks.length) {
+            this.chunks = this.chunks.slice(this.headIndex);
+            this.headIndex = 0;
+        }
+        return discarded;
+    }
+
+    consumeExact(length) {
+        const output = this.readExact(0, length);
+        if (!output) {
+            return null;
+        }
+        this.discard(length);
+        return output;
+    }
+
+    clear() {
+        this.chunks = [];
+        this.headIndex = 0;
+        this.headOffset = 0;
+        this.byteLength = 0;
+    }
+
+    getStatus() {
+        return {
+            bytes: this.byteLength,
+            segments: this.segmentCount,
+            maxBytes: this.maxBytes,
+            highWaterBytes: this.highWaterBytes,
+            appendedBytes: this.appendedBytes,
+            appendCopyBytes: 0,
+            materializedBytes: this.materializedBytes,
+            rejectedBytes: this.rejectedBytes
+        };
+    }
+}
+
+function normalizeFrameMode(header) {
+    return stringValue(header?.frameMode ?? header?.mode, 48).toLowerCase();
+}
+
+function isMode5Header(header) {
+    return normalizeFrameMode(header) === 'mode5-lzo-delta';
+}
+
+function isH264Header(header) {
+    const mode = normalizeFrameMode(header);
+    const codec = stringValue(
+        header?.codec
+        ?? header?.codecName
+        ?? header?.mimeType
+        ?? header?.format,
+        96).toLowerCase();
+    return mode.includes('h264')
+        || codec.includes('h264')
+        || codec.includes('avc');
+}
+
+function isH264KeyHeader(header) {
+    const chunkType = stringValue(header?.chunkType, 24).toLowerCase();
+    return header?.isKeyFrame === true
+        || chunkType === 'key'
+        || chunkType === 'idr'
+        || chunkType === 'keyframe';
+}
+
+function ingressBindingKey(header) {
+    return [
+        stringValue(header?.deviceId, 160),
+        stringValue(header?.sessionId, 160),
+        stringValue(header?.streamId, 160),
+        stringValue(header?.commandId, 160),
+        stringValue(header?.streamPurpose ?? header?.purpose, 40),
+        stringValue(header?.monitorIndex, 24),
+        stringValue(header?.captureGeneration, 40)
+    ].join('\u001f');
+}
+
+function mode5StreamKey(header) {
+    return [
+        stringValue(header?.streamId, 160),
+        stringValue(header?.captureGeneration, 40)
+    ].join('\u001f');
+}
+
+/**
+ * One exact Agent socket owns one lane. The lane is packet- and payload-byte
+ * bounded, drains only a small budget per event-loop turn, and enters H.264
+ * key-frame recovery whenever queue pressure creates a dependency gap.
+ */
+export function createBoundedAgentBinaryIngressLane(options = {}) {
+    const maxPackets = boundedInteger(
+        options.maxPackets,
+        1,
+        16,
+        DEFAULT_MAX_PACKETS);
+    const maxBytes = boundedInteger(
+        options.maxBytes,
+        1,
+        256 * 1024 * 1024,
+        DEFAULT_MAX_QUEUE_BYTES);
+    const drainBudgetPackets = boundedInteger(
+        options.drainBudgetPackets,
+        1,
+        4,
+        DEFAULT_DRAIN_BUDGET_PACKETS);
+    const maxQueueAgeMs = boundedInteger(
+        options.maxQueueAgeMs,
+        80,
+        150,
+        DEFAULT_MAX_QUEUE_AGE_MS);
+    const mode5PacketsPerStream = boundedInteger(
+        options.mode5PacketsPerStream,
+        1,
+        16,
+        DEFAULT_MODE5_PACKETS_PER_STREAM);
+    const maxRetainedPayloadBackingOverheadBytes = boundedInteger(
+        options.maxRetainedPayloadBackingOverheadBytes,
+        0,
+        1024 * 1024,
+        0);
+    const consume = typeof options.consume === 'function' ? options.consume : () => {};
+    const onAccounting = typeof options.onAccounting === 'function' ? options.onAccounting : () => {};
+    const onDrop = typeof options.onDrop === 'function' ? options.onDrop : () => {};
+    const onError = typeof options.onError === 'function' ? options.onError : () => {};
+    const schedule = typeof options.schedule === 'function'
+        ? options.schedule
+        : callback => setImmediate(callback);
+    const cancelSchedule = typeof options.cancelSchedule === 'function'
+        ? options.cancelSchedule
+        : handle => clearImmediate(handle);
+    const isOwnerCurrent = typeof options.isOwnerCurrent === 'function'
+        ? options.isOwnerCurrent
+        : () => true;
+    const now = typeof options.now === 'function'
+        ? options.now
+        : () => Date.now();
+
+    let queue = [];
+    let queuedBytes = 0;
+    let queuedPackets = 0;
+    let queuedBytesHighWater = 0;
+    let queuedPacketsHighWater = 0;
+    let scheduled = false;
+    let scheduleHandle = null;
+    let draining = false;
+    let closed = false;
+    let underflowCount = 0;
+    let enqueuedPackets = 0;
+    let drainedPackets = 0;
+    let droppedPackets = 0;
+    let droppedBytes = 0;
+    let payloadBackingCopies = 0;
+    let payloadBackingCopyBytes = 0;
+    let retainedBackingOverheadBytesHighWater = 0;
+    const awaitingKeyFrames = new Set();
+
+    function emitAccounting(event, packetDelta = 0, byteDelta = 0, extra = {}) {
+        const nextPackets = queuedPackets + packetDelta;
+        const nextBytes = queuedBytes + byteDelta;
+        if (nextPackets < 0 || nextBytes < 0) {
+            underflowCount += 1;
+        }
+        queuedPackets = nextPackets;
+        queuedBytes = nextBytes;
+        queuedPacketsHighWater = Math.max(queuedPacketsHighWater, queuedPackets);
+        queuedBytesHighWater = Math.max(queuedBytesHighWater, queuedBytes);
+        onAccounting({
+            event,
+            queuedPacketsDelta: packetDelta,
+            queuedBytesDelta: byteDelta,
+            queuedPackets,
+            queuedBytes,
+            ...extra
+        });
+    }
+
+    function describeItem(header, payload) {
+        let ownedPayload = bufferValue(payload);
+        let retainedByteLength = Math.max(
+            ownedPayload.length,
+            Number(ownedPayload.buffer?.byteLength || ownedPayload.length));
+        let backingOverheadBytes = Math.max(0, retainedByteLength - ownedPayload.length);
+        if (backingOverheadBytes > maxRetainedPayloadBackingOverheadBytes) {
+            const exactPayload = Buffer.allocUnsafeSlow(ownedPayload.length);
+            ownedPayload.copy(exactPayload);
+            ownedPayload = exactPayload;
+            retainedByteLength = exactPayload.length;
+            backingOverheadBytes = 0;
+            payloadBackingCopies += 1;
+            payloadBackingCopyBytes += exactPayload.length;
+        }
+        retainedBackingOverheadBytesHighWater = Math.max(
+            retainedBackingOverheadBytesHighWater,
+            backingOverheadBytes);
+        const h264 = isH264Header(header);
+        return {
+            header,
+            payload: ownedPayload,
+            byteLength: retainedByteLength,
+            payloadByteLength: ownedPayload.length,
+            backingOverheadBytes,
+            h264,
+            keyFrame: h264 && isH264KeyHeader(header),
+            bindingKey: h264 ? ingressBindingKey(header) : '',
+            mode5: isMode5Header(header),
+            mode5Key: isMode5Header(header) ? mode5StreamKey(header) : '',
+            enqueuedAtMs: 0
+        };
+    }
+
+    function markDropped(item, reason) {
+        droppedPackets += 1;
+        droppedBytes += item.byteLength;
+        onDrop({ item, reason });
+        onAccounting({
+            event: 'drop',
+            reason,
+            queuedPacketsDelta: 0,
+            queuedBytesDelta: 0,
+            queuedPackets,
+            queuedBytes,
+            droppedPacketBytes: item.byteLength
+        });
+    }
+
+    function removeAt(index, reason, { dropped = true, recover = true } = {}) {
+        if (index < 0 || index >= queue.length) {
+            return null;
+        }
+        const [item] = queue.splice(index, 1);
+        emitAccounting(
+            dropped ? 'evict' : reason,
+            -1,
+            -item.byteLength,
+            { reason, packetBytes: item.byteLength });
+        if (dropped) {
+            markDropped(item, reason);
+        }
+        if (recover && dropped && item.h264) {
+            awaitingKeyFrames.add(item.bindingKey);
+        }
+        return item;
+    }
+
+    function retireH264Deltas(bindingKey, reason) {
+        for (let index = queue.length - 1; index >= 0; index -= 1) {
+            const item = queue[index];
+            if (item.h264 && !item.keyFrame && item.bindingKey === bindingKey) {
+                removeAt(index, reason, { dropped: true, recover: false });
+            }
+        }
+    }
+
+    function markH264Gap(item, reason) {
+        if (item.h264) {
+            awaitingKeyFrames.add(item.bindingKey);
+            retireH264Deltas(item.bindingKey, `${reason}-dependent`);
+        }
+        markDropped(item, reason);
+    }
+
+    function purgeOlderH264Binding(bindingKey) {
+        for (let index = queue.length - 1; index >= 0; index -= 1) {
+            const item = queue[index];
+            if (item.h264 && item.bindingKey === bindingKey) {
+                removeAt(index, 'superseded-by-latest-key', {
+                    dropped: true,
+                    recover: false
+                });
+            }
+        }
+    }
+
+    function chooseCapacityVictim() {
+        let index = queue.findIndex(item => !item.h264 && !item.mode5);
+        if (index >= 0) {
+            return index;
+        }
+        index = queue.findIndex(item => item.mode5);
+        if (index >= 0) {
+            return index;
+        }
+        index = queue.findIndex(item => item.h264 && !item.keyFrame);
+        if (index >= 0) {
+            return index;
+        }
+        return queue.length > 0 ? 0 : -1;
+    }
+
+    function makeCapacity(item) {
+        if (item.h264 && !item.keyFrame) {
+            return queue.length < maxPackets
+                && queuedBytes + item.byteLength <= maxBytes;
+        }
+
+        while (queue.length >= maxPackets || queuedBytes + item.byteLength > maxBytes) {
+            const victimIndex = chooseCapacityVictim();
+            if (victimIndex < 0) {
+                return false;
+            }
+            const victim = removeAt(victimIndex, 'ingress-capacity', {
+                dropped: true,
+                recover: true
+            });
+            if (victim?.h264) {
+                retireH264Deltas(victim.bindingKey, 'ingress-capacity-dependent');
+            }
+        }
+        return true;
+    }
+
+    function expireStaleItems(nowMs = now()) {
+        let expired = 0;
+        while (queue.length > 0) {
+            const item = queue[0];
+            const ageMs = Math.max(0, Number(nowMs) - Number(item.enqueuedAtMs || 0));
+            if (ageMs <= maxQueueAgeMs) {
+                break;
+            }
+            const removed = removeAt(0, 'ingress-age-limit', {
+                dropped: true,
+                recover: true
+            });
+            if (!removed) {
+                break;
+            }
+            expired += 1;
+            if (removed.h264) {
+                retireH264Deltas(removed.bindingKey, 'ingress-age-limit-dependent');
+            }
+        }
+        return expired;
+    }
+
+    function requestDrain() {
+        if (closed || scheduled || queue.length === 0) {
+            return;
+        }
+        scheduled = true;
+        scheduleHandle = schedule(() => {
+            scheduled = false;
+            scheduleHandle = null;
+            drain();
+        });
+    }
+
+    function drain() {
+        if (closed || draining) {
+            return;
+        }
+        if (!isOwnerCurrent()) {
+            close('stale-agent-binary-owner');
+            return;
+        }
+
+        draining = true;
+        let processed = 0;
+        try {
+            expireStaleItems();
+            while (!closed && queue.length > 0 && processed < drainBudgetPackets) {
+                const item = removeAt(0, 'drain', {
+                    dropped: false,
+                    recover: false
+                });
+                if (!item) {
+                    break;
+                }
+                try {
+                    consume(item);
+                } catch (error) {
+                    onError(error);
+                }
+                drainedPackets += 1;
+                processed += 1;
+            }
+        } finally {
+            draining = false;
+        }
+        if (!closed && queue.length > 0) {
+            requestDrain();
+        }
+    }
+
+    function enqueue(header, payload) {
+        const item = describeItem(header, payload);
+        if (closed || !isOwnerCurrent()) {
+            markDropped(item, 'stale-agent-binary-owner');
+            return false;
+        }
+        if (item.byteLength <= 0 || item.byteLength > maxBytes) {
+            markH264Gap(item, 'ingress-packet-byte-limit');
+            return false;
+        }
+        expireStaleItems();
+
+        if (item.h264) {
+            if (item.keyFrame) {
+                purgeOlderH264Binding(item.bindingKey);
+                awaitingKeyFrames.delete(item.bindingKey);
+            } else if (awaitingKeyFrames.has(item.bindingKey)) {
+                markDropped(item, 'h264-awaiting-key');
+                return false;
+            }
+        }
+
+        if (item.mode5) {
+            let sameStreamCount = queue.filter(queued => queued.mode5 && queued.mode5Key === item.mode5Key).length;
+            while (sameStreamCount >= mode5PacketsPerStream) {
+                const index = queue.findIndex(queued => queued.mode5 && queued.mode5Key === item.mode5Key);
+                if (index < 0) {
+                    break;
+                }
+                removeAt(index, 'mode5-latest-packet', {
+                    dropped: true,
+                    recover: false
+                });
+                sameStreamCount -= 1;
+            }
+        }
+
+        if (!makeCapacity(item)) {
+            markH264Gap(item, 'ingress-capacity');
+            return false;
+        }
+
+        item.enqueuedAtMs = now();
+        queue.push(item);
+        enqueuedPackets += 1;
+        emitAccounting('enqueue', 1, item.byteLength, {
+            packetBytes: item.byteLength,
+            h264: item.h264,
+            keyFrame: item.keyFrame
+        });
+        if (item.h264 && item.keyFrame) {
+            awaitingKeyFrames.delete(item.bindingKey);
+        }
+        requestDrain();
+        return true;
+    }
+
+    function close(reason = 'agent-binary-ingress-close') {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        if (scheduled && scheduleHandle !== null && scheduleHandle !== undefined) {
+            try {
+                cancelSchedule(scheduleHandle);
+            } catch {
+                // The scheduled callback still observes closed=true.
+            }
+        }
+        scheduled = false;
+        scheduleHandle = null;
+        while (queue.length > 0) {
+            removeAt(0, reason, {
+                dropped: false,
+                recover: false
+            });
+        }
+        awaitingKeyFrames.clear();
+    }
+
+    function getStatus() {
+        const oldestAgeMs = queue.length > 0
+            ? Math.max(0, now() - Number(queue[0].enqueuedAtMs || 0))
+            : 0;
+        return {
+            closed,
+            scheduled,
+            draining,
+            queuedPackets,
+            queuedBytes,
+            queuedPacketsHighWater,
+            queuedBytesHighWater,
+            maxPackets,
+            maxBytes,
+            maxQueueAgeMs,
+            oldestAgeMs,
+            drainBudgetPackets,
+            mode5PacketsPerStream,
+            maxRetainedPayloadBackingOverheadBytes,
+            awaitingKeyFrameBindings: awaitingKeyFrames.size,
+            enqueuedPackets,
+            drainedPackets,
+            droppedPackets,
+            droppedBytes,
+            payloadBackingCopies,
+            payloadBackingCopyBytes,
+            retainedBackingOverheadBytesHighWater,
+            underflowCount,
+            terminalZero: queuedPackets === 0
+                && queuedBytes === 0
+                && scheduled === false
+                && draining === false
+        };
+    }
+
+    return {
+        enqueue,
+        drain,
+        close,
+        getStatus
+    };
+}