@blockcast/mmt-container 0.3.0 → 0.4.0-main.1e94b11199ea

package/node_modules/@blockcast/mmt-fec/src/oti.ts

@@ -1,463 +0,0 @@
-/**
- * RFC 6330 Object Transmission Information (OTI) utilities.
- *
- * Shared OTI encoding/decoding for both moq-lib and moqtail players.
- * Eliminates duplicated OTI byte manipulation across codebases.
- */
-
-import { parseMoqRepairFrame } from "@blockcast/mmt-base";
-
-export interface OTIParams {
-	/** Transfer length F (total source block size in bytes) */
-	transferLength: number;
-	/** Symbol size T (bytes per symbol) */
-	symbolSize: number;
-	/** Number of source blocks Z */
-	sourceBlocks: number;
-	/** Number of sub-blocks N */
-	subBlocks: number;
-	/** Symbol alignment Al */
-	alignment: number;
-}
-
-/**
- * Build a 12-byte RFC 6330 Common + Scheme-Specific OTI from parameters.
- *
- * Wire format (per RFC 6330 §4.3.1 + §4.3.3):
- *   byte 0:    F high byte (bit 32 — transfer length is 40-bit)
- *   bytes 1-4: F low 32 bits (big-endian)
- *   byte 5:    reserved (0)
- *   bytes 6-7: T (symbol size, big-endian)
- *   byte 8:    Z (source blocks)
- *   bytes 9-10: N (sub-blocks, big-endian)
- *   byte 11:   Al (alignment)
- */
-export function buildOTI(params: OTIParams): Uint8Array {
-	const {
-		transferLength: F,
-		symbolSize: T,
-		sourceBlocks: Z,
-		subBlocks: N,
-		alignment: Al,
-	} = params;
-	validateOTIFields(F, T, Z, N, Al);
-	const oti = new Uint8Array(12);
-	// F: 40-bit big-endian (byte 0 = high, bytes 1-4 = low 32)
-	oti[0] = (F / 0x100000000) & 0xFF;
-	oti[1] = (F >>> 24) & 0xFF;
-	oti[2] = (F >>> 16) & 0xFF;
-	oti[3] = (F >>> 8) & 0xFF;
-	oti[4] = F & 0xFF;
-	// byte 5: reserved
-	oti[6] = (T >>> 8) & 0xFF;
-	oti[7] = T & 0xFF;
-	oti[8] = Z & 0xFF;
-	oti[9] = (N >>> 8) & 0xFF;
-	oti[10] = N & 0xFF;
-	oti[11] = Al & 0xFF;
-	return oti;
-}
-
-/**
- * Build OTI from catalog FEC config (K and T).
- * F = K × T (interleaved encoder convention from FFmpeg moqenc_mmt.c).
- */
-export function buildOTIFromCatalog(K: number, T: number): Uint8Array {
-	if (!Number.isInteger(K) || K <= 0 || K > 56_403) {
-		throw new Error(`K must be an integer in 1..56403 (got ${K})`);
-	}
-	return buildOTI({
-		transferLength: K * T,
-		symbolSize: T,
-		sourceBlocks: 1,
-		subBlocks: 1,
-		alignment: 8,
-	});
-}
-
-/**
- * Parse a 12-byte OTI into structured parameters.
- */
-export function parseOTI(oti: Uint8Array): OTIParams & { K: number } {
-	if (oti.length !== 12) throw new Error(`OTI must be exactly 12 bytes (got ${oti.length})`);
-	if (oti[5] !== 0) throw new Error(`OTI reserved byte 5 must be zero (got ${oti[5]})`);
-	const F = ((oti[0] & 0xFF) * 0x100000000) +
-		(((oti[1] << 24) | (oti[2] << 16) | (oti[3] << 8) | oti[4]) >>> 0);
-	const T = (oti[6] << 8) | oti[7];
-	const Z = oti[8];
-	const N = (oti[9] << 8) | oti[10];
-	const Al = oti[11];
-	validateOTIFields(F, T, Z, N, Al);
-	const K = Math.ceil(Math.ceil(F / T) / Z);
-	return { transferLength: F, symbolSize: T, sourceBlocks: Z, subBlocks: N, alignment: Al, K };
-}
-
-function validateOTIFields(F: number, T: number, Z: number, N: number, Al: number): void {
-	if (!Number.isSafeInteger(F) || F <= 0 || F > 0xffffffffff) {
-		throw new Error(`F must be a positive 40-bit integer (got ${F})`);
-	}
-	if (!Number.isInteger(T) || T <= 0 || T > 0xffff) {
-		throw new Error(`T must be an integer in 1..65535 (got ${T})`);
-	}
-	if (!Number.isInteger(Z) || Z <= 0 || Z > 0xff) {
-		throw new Error(`Z must be an integer in 1..255 (got ${Z})`);
-	}
-	if (!Number.isInteger(N) || N <= 0 || N > 0xffff) {
-		throw new Error(`N must be an integer in 1..65535 (got ${N})`);
-	}
-	if (!Number.isInteger(Al) || Al <= 0 || Al > 0xff || T % Al !== 0) {
-		throw new Error(`Al must be an integer in 1..255 that divides T (got Al=${Al}, T=${T})`);
-	}
-	const K = Math.ceil(Math.ceil(F / T) / Z);
-	if (K > 56_403) {
-		throw new Error(`OTI requires K=${K}, above the RFC 6330 systematic limit 56403`);
-	}
-}
-
-/**
- * Resolve a catalog FEC block's span in milliseconds.
- *
- * The catalog carries exactly ONE interleave field: `interleaveDepthMs`, the
- * full FEC block span in MILLISECONDS (draft-ramadan-moq-fec §5.1). Receivers
- * derive D -- the MEDIA UNITS per block, not a block count -- with
- * `deriveFecInterleaveDepth`. Reading D as a block count is BLO-35597.
- *
- * Absent, non-finite or non-positive → undefined; callers treat that as
- * unconfigured and error rather than guess. Finiteness is checked separately
- * from `> 0` because `Infinity` satisfies `> 0`: a JSON catalog cannot spell
- * `Infinity`, but any overflowing literal (`1e999`) parses to it, and it would
- * then reach `fecBlockBudgetMs` as an unbounded span. The legacy
- * `interleaveDepth` frame-count key and
- * the `interleaveMs` alias were removed in the BLO-14526 clean cut — producers
- * emit milliseconds only, and there is deliberately NO fallback read.
- */
-export type FecInterleaveCatalog = {
-	interleaveDepthMs?: number;
-};
-
-export function catalogFecInterleaveMs(
-	fec: FecInterleaveCatalog | undefined,
-): number | undefined {
-	const ms = fec?.interleaveDepthMs;
-	return typeof ms === "number" && ms > 0 && Number.isFinite(ms) ? ms : undefined;
-}
-
-/**
- * Derive the integer FEC interleave depth D from a catalog block span and the
- * duration of one media unit.
- *
- * `interleaveDepthMs` is nearest-millisecond catalog signaling while media
- * unit durations are commonly fractional. Invert that quantization with
- * positive-value round-half-up semantics:
- *
- *   D = max(1, floor(interleaveDepthMs / mediaUnitDurationMs + 0.5))
- *
- * `Math.ceil` is not equivalent: 4000 / 33.333 is slightly greater than 120,
- * but represents D=120 rather than D=121.
- */
-export function deriveFecInterleaveDepth(
-	interleaveDepthMs: number,
-	mediaUnitDurationMs: number,
-): number {
-	if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
-		throw new Error(`[FEC] interleaveDepthMs must be finite and > 0 (got ${interleaveDepthMs})`);
-	}
-	if (!Number.isFinite(mediaUnitDurationMs) || mediaUnitDurationMs <= 0) {
-		throw new Error(`[FEC] mediaUnitDurationMs must be finite and > 0 (got ${mediaUnitDurationMs})`);
-	}
-	return Math.max(1, Math.floor(interleaveDepthMs / mediaUnitDurationMs + 0.5));
-}
-
-/**
- * Compute the full FEC block completion timeout from the catalog block span.
- *
- * The catalog's `interleaveDepthMs` IS the full FEC block span in
- * milliseconds (draft-ramadan-moq-fec §5.1): producers emit
- * D × unit-duration, and every symbol of a block — source and repair —
- * arrives within that span. The full-block timeout is therefore
- * K-INDEPENDENT:
- *
- *   timeout = interleaveDepthMs * safetyFactor
- *
- * A caller that genuinely needs a per-sub-block deadline scales the block
- * span by K_sub / K. Never scale it by a symbol count: the span already
- * covers every symbol of the block.
- *
- * @param interleaveDepthMs - Full FEC block span in ms (catalog fec.interleaveDepthMs)
- * @param safetyFactor - Jitter margin (default 3.0)
- * @returns Timeout in milliseconds
- */
-export function computeFecTimeout(
-	interleaveDepthMs: number,
-	safetyFactor: number = 3.0,
-): number {
-	// Finite, not merely > 0, and on BOTH arguments: the product is the caller's
-	// expiry deadline, so a non-finite either side makes every `now > deadline`
-	// comparison false and the block never expires -- strictly worse than
-	// expiring late. `NaN <= 0` is false, so a bare `> 0` guard passes it
-	// through. Both values reach here from JSON (the catalog span, and the
-	// safety factor via test-vectors/catalog-validation.json), where an
-	// overflowing literal such as `1e999` parses to Infinity -- JSON has no
-	// Infinity literal, so there is no other way to spell it.
-	if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
-		throw new Error(`[FEC] interleaveDepthMs must be a finite value > 0 (got ${interleaveDepthMs}ms). Fix encoder config.`);
-	}
-	if (!Number.isFinite(safetyFactor) || safetyFactor <= 0) {
-		throw new Error(`[FEC] safetyFactor must be a finite value > 0 (got ${safetyFactor}). Fix encoder config.`);
-	}
-	// interleaveDepthMs IS the block span. K=4, D=4 at 30fps:
-	// interleaveDepthMs = 133ms → timeout = ceil(133 * 3) = 399ms.
-	return Math.ceil(interleaveDepthMs * safetyFactor);
-}
-
-/**
- * Absolute deadline for one FEC block.
- *
- *   deadline = firstAcceptedAtMs + interleaveDepthMs + reorderToleranceMs
- *
- * Two properties matter, and both are contract, not preference:
- *
- * 1. The anchor is an ABSOLUTE receiver-local timestamp of the first accepted
- *    packet of the block -- not "now when we noticed", and not a duration a
- *    caller starts counting at an unspecified moment. A relative timeout
- *    cannot say WHEN a block was due, so it cannot yield playback latency and
- *    it cannot be compared across two consumers that started their timers at
- *    different instants.
- *
- * 2. The reorder/jitter allowance is ADDITIVE and SIGNALED, never a multiplier
- *    on the span. Jitter is a property of the network path; the FEC block span
- *    is a property of the encoder. Multiplying them couples two independent
- *    quantities: at a 133ms video span a x3 factor grants 266ms of slack, and
- *    at a 43ms audio span only 86ms -- for the same network. The tolerance
- *    therefore arrives as its own catalog value and is added once.
- *
- * Both arguments are required. There is no default tolerance: a missing value
- * is an encoder/catalog bug and must surface at the boundary, not be papered
- * over with a constant here.
- *
- * @param firstAcceptedAtMs - Receiver-local ms timestamp of the block's first accepted packet
- * @param interleaveDepthMs - Full FEC block span in ms (catalog fec.interleaveDepthMs)
- * @param reorderToleranceMs - Declared jitter/reorder allowance in ms (catalog fec.reorderToleranceMs)
- * @returns Absolute receiver-local deadline in milliseconds
- */
-export function fecBlockDeadlineMs(params: {
-	firstAcceptedAtMs: number;
-	interleaveDepthMs: number;
-	reorderToleranceMs: number;
-}): number {
-	const { firstAcceptedAtMs, interleaveDepthMs, reorderToleranceMs } = params;
-	if (!Number.isFinite(firstAcceptedAtMs)) {
-		throw new Error(`[FEC] firstAcceptedAtMs must be finite (got ${firstAcceptedAtMs}).`);
-	}
-	return firstAcceptedAtMs + fecBlockBudgetMs(interleaveDepthMs, reorderToleranceMs);
-}
-
-/**
- * Relative budget for one FEC block: span + declared tolerance.
- *
- * Only for consumers whose interface genuinely takes a duration (the WASM
- * reassembler's `timeoutMs`). Anything that can hold a timestamp should use
- * `fecBlockDeadlineMs` instead, so the anchor stays explicit and latency stays
- * extractable. This is deliberately NOT `span * factor` -- see the note on
- * `fecBlockDeadlineMs` for why the tolerance is additive.
- */
-export function fecBlockBudgetMs(interleaveDepthMs: number, reorderToleranceMs: number): number {
-	// Finite, not merely > 0: Infinity satisfies `> 0` and would yield an
-	// infinite budget, which fecBlockDeadlineMs then turns into a deadline no
-	// block can ever miss -- the eviction bound silently stops bounding. The
-	// tolerance check below already required finiteness; this is the same bar
-	// for the encoder's span.
-	if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0)) {
-		throw new Error(
-			`[FEC] interleaveDepthMs must be a finite value > 0 (got ${interleaveDepthMs}ms). Fix encoder config.`,
-		);
-	}
-	if (!(reorderToleranceMs >= 0) || !Number.isFinite(reorderToleranceMs)) {
-		throw new Error(
-			`[FEC] reorderToleranceMs must be a finite value >= 0 (got ${reorderToleranceMs}ms). ` +
-				`It is a catalog value (fec.reorderToleranceMs), not a local default.`,
-		);
-	}
-	return Math.ceil(interleaveDepthMs + reorderToleranceMs);
-}
-
-/**
- * How many FEC blocks a receiver must retain, in SBN distance.
- *
- * THE ONE derivation of "the interleave horizon". Every site that retires a
- * block by SBN distance consumes this: the Worker/WASM decoder's retention
- * (`interleaveDepth` -> `cleanup_by_sbn`) and FECManager's ordered-relay
- * settlement horizon. They are not two quantities that happen to agree -- a
- * settlement that fires inside the decoder's retention kills a block the
- * decoder would still have recovered, so the invariant is:
- *
- *   ordered-relay settlement must never fire on a block the decoder would
- *   still accept -- manager horizon >= decoder retention.
- *
- * Deriving it twice is what broke it (BLO-35597): `deriveFecInterleaveDepth`
- * returns D, MEDIA UNITS per block, and reading that as a block count made the
- * two horizons disagree the moment either side moved. Add a consumer here
- * rather than re-deriving at the call site.
- *
- * The count is the blocks that can be in flight within one block's delivery
- * budget, plus the one being filled.
- *
- * That is DELIBERATELY two blocks of slack, not an exact minimum. The decoder
- * retains `depth + 1` blocks, not `depth` -- `cleanup_by_sbn` retires only
- * blocks strictly behind `current_sbn - interleave_depth`, so the newest block
- * and the `depth` behind it all survive. The smallest depth satisfying the
- * invariant is therefore `ceil(W/S) - 1`. The slack is bought on purpose: it
- * costs retained-block memory and the depth-scaled caps (`maxBlocks`,
- * `pendingVerifyCap` in fec-worker), and it buys headroom against a catalog
- * whose signaled span runs slightly short of the real one -- the failure this
- * whole issue is about. Do not "tighten" it to the minimum without a measured
- * reason; being one block short is what fails a block, being two long is not.
- *
- * The cost ceiling is relative, not absolute: the slack is always two blocks
- * of whatever the retention already is, so it scales with the geometry rather
- * than with the stream. On the live ISS 720p/33ms catalog that is two blocks
- * of six (a third of the buffer, the expensive end); at a 255-block retention
- * it is two of 255 (under 1%). If you come here to tighten it, the number to
- * weigh is the ratio at YOUR geometry -- tightening buys most where retention
- * is small, which is also where being one block short is most likely.
- *
- * @param deliveryWindowMs - The block's own delivery budget (computeFecDeliveryWindowMs / fecBlockBudgetMs)
- * @param interleaveDepthMs - Full FEC block span in ms (catalog fec.interleaveDepthMs)
- * @returns Block count in 2..=255 for every geometry a catalog can express.
- *   The floor is 2, not 1: both inputs are guarded `> 0`, so `ceil(quotient)`
- *   is `>= 1` and the result `>= 2`. A consumer branching on a `1` case is
- *   reading a contract no real geometry produces. The one arithmetic exception
- *   is a quotient that underflows to exactly `0` (`Number.MIN_VALUE` over
- *   33ms), which returns 1 -- reachable only by calling this directly with
- *   values a catalog cannot produce. NOT a denormal INPUT specifically: the
- *   underflow is a property of the QUOTIENT, so two normal operands reach it
- *   too (`1e-300` over `1e308` returns 1; min normal is ~2.225e-308). Do not
- *   re-narrow this to "a denormal" -- the guards below admit both of those.
- *   That a catalog cannot produce such values is a proof, not a judgement
- *   about plausible values: BOTH branches of `computeFecDeliveryWindowMs` are
- *   `Math.ceil`-wrapped (one directly, the other via `fecBlockBudgetMs`), so
- *   every catalog-derived `deliveryWindowMs` is an integer `>= 1`; the quotient
- *   is then `>= 1/interleaveDepthMs`, which no FINITE span can push below
- *   `Number.MIN_VALUE`. Documented rather than guarded -- a comparison on the
- *   per-symbol path for an input the type can express and the system cannot
- *   produce, and clamping would be the `Math.min(0xff, ...)` anti-pattern this
- *   change removed.
- */
-export function deriveFecRetentionBlocks(
-	deliveryWindowMs: number,
-	interleaveDepthMs: number,
-): number {
-	const blocks = tryDeriveFecRetentionBlocks(deliveryWindowMs, interleaveDepthMs);
-	if (blocks !== undefined) return blocks;
-
-	// Undefined means one of three things. Re-test to say which -- this is the
-	// throwing path, so the cost is irrelevant and the diagnosis is the point.
-	if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0)) {
-		throw new Error(
-			`[FEC] interleaveDepthMs must be a finite value > 0 (got ${interleaveDepthMs}ms). Fix encoder config.`,
-		);
-	}
-	if (!Number.isFinite(deliveryWindowMs) || !(deliveryWindowMs > 0)) {
-		throw new Error(
-			`[FEC] deliveryWindowMs must be a finite value > 0 (got ${deliveryWindowMs}ms). ` +
-				`It is derived from catalog geometry, not a local default.`,
-		);
-	}
-	// Fail closed rather than clamp. 255 is the ceiling the WASM decoder and the
-	// ISO/IEC 23008-1 AL-FEC signaling byte both accept; silently clamping to it
-	// would hand back a retention SHORTER than the caller's own delivery window
-	// -- the exact skew this function exists to remove, reintroduced invisibly
-	// and only on out-of-range catalogs, where it is hardest to notice.
-	//
-	// This is the RESIDUAL, not a tested branch: it is reached by elimination
-	// once the two guards above have failed to match. That is exact only while
-	// `tryDeriveFecRetentionBlocks` returns `undefined` in exactly three places.
-	// Add a fourth and this arm mis-diagnoses it as a ceiling violation AND
-	// prints a computed block count that is not the reason -- so if you grow a
-	// case there, add the matching arm here.
-	throw new Error(
-		`[FEC] retention of ${Math.ceil(deliveryWindowMs / interleaveDepthMs) + 1} blocks exceeds the 255 the decoder and the ` +
-			`ISO/IEC 23008-1 AL-FEC signaling byte accept ` +
-			`(deliveryWindowMs=${deliveryWindowMs}ms over interleaveDepthMs=${interleaveDepthMs}ms). ` +
-			`Fix the catalog geometry: a span this short cannot carry a window this wide.`,
-	);
-}
-
-/**
- * The ceiling the WASM decoder and the ISO/IEC 23008-1 AL-FEC signaling byte
- * both accept. One owner: do not re-state `0xff` against a block count
- * anywhere else.
- */
-export const MAX_FEC_RETENTION_BLOCKS = 0xff;
-
-/**
- * `deriveFecRetentionBlocks` without the throw: the block count, or `undefined`
- * when the geometry cannot define one.
- *
- * THIS is the arithmetic; the throwing variant is this plus a diagnosis of
- * which guard failed. Callers reached from a **per-symbol** path must use this
- * one. An out-of-range `timeoutMs` does not narrow back on its own, so there
- * the throwing variant is not a rare error but steady state, and it would
- * construct an `Error` with a stack capture and unwind it for every symbol on
- * the stream.
- */
-export function tryDeriveFecRetentionBlocks(
-	deliveryWindowMs: number,
-	interleaveDepthMs: number,
-): number | undefined {
-	if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0)) return undefined;
-	if (!Number.isFinite(deliveryWindowMs) || !(deliveryWindowMs > 0)) return undefined;
-	const blocks = Math.ceil(deliveryWindowMs / interleaveDepthMs) + 1;
-	return blocks > MAX_FEC_RETENTION_BLOCKS ? undefined : blocks;
-}
-
-/**
- * Playback latency for a block, from the same anchor the deadline uses.
- *
- *   latency = presentedAtMs - firstAcceptedAtMs
- *
- * Both timestamps are receiver-local, so this needs NO publisher/receiver
- * clock agreement. That is the point of anchoring the deadline absolutely:
- * publisher-stamped media time and receiver BCTM disagree by roughly the
- * quantity we are trying to measure, which makes any cross-host subtraction
- * unusable at a 33ms target. This subtraction is immune to that skew.
- *
- * It measures first-accepted-packet to presentation. It is NOT glass-to-glass
- * and must not be reported as such -- capture and encode sit outside both
- * timestamps.
- */
-export function playbackLatencyMs(params: { presentedAtMs: number; firstAcceptedAtMs: number }): number {
-	const { presentedAtMs, firstAcceptedAtMs } = params;
-	if (!Number.isFinite(presentedAtMs) || !Number.isFinite(firstAcceptedAtMs)) {
-		throw new Error(`[FEC] playback latency needs two finite timestamps (got ${presentedAtMs}, ${firstAcceptedAtMs}).`);
-	}
-	if (presentedAtMs < firstAcceptedAtMs) {
-		throw new Error(
-			`[FEC] presentedAtMs ${presentedAtMs} precedes firstAcceptedAtMs ${firstAcceptedAtMs}; ` +
-				`the two timestamps must come from one receiver-local clock.`,
-		);
-	}
-	return presentedAtMs - firstAcceptedAtMs;
-}
-
-/**
- * Extract FEC parameters from an MMTP repair packet.
- *
- * Per ISO/IEC 23008-1 Section C.5.3, the 13-byte Repair FEC Payload ID
- * follows the complete MMTP header, including optional C/X fields.
- *
- * Returns raw fields — caller passes directly to WASM add_repair(ss_start, ssb_length, rs_id, data).
- * No SBN/ESI derivation — the WASM decoder handles block assignment.
- */
-export function parseRepairPacket(packet: Uint8Array): {
-	ssStart: number; ssbLength: number; rsId: number; repairData: Uint8Array;
-} | null {
-	const parsed = parseMoqRepairFrame(packet);
-	if (!parsed) return null;
-	return {
-		ssStart: parsed.ssStart,
-		ssbLength: parsed.ssbLength,
-		rsId: parsed.rsId,
-		repairData: parsed.symbolData,
-	};
-}

package/node_modules/@blockcast/mmt-fec/src/reorder-buffer.ts

@@ -1,101 +0,0 @@
-/**
- * ReorderBuffer — container-agnostic frame reorder buffer for FEC-interleaved streams.
- *
- * FEC interleaving causes frames to complete out of decode order (e.g., frame N+3
- * before N+1). H.264 P-frames reference the previous frame, so feeding out-of-order
- * frames to VideoDecoder produces green artifacts from reference frame mismatch.
- *
- * This buffer accumulates frames and flushes them in sequence order.
- * - In-order frames flush immediately (zero added latency for well-ordered streams).
- * - Out-of-order frames buffer until the gap is filled or the buffer is full.
- * - Keyframes flush all pending frames first (random access point).
- * - Safety timeout force-flushes stalled buffers (missing frame that will never arrive).
- *
- * Used by WebCodecs decode path. NOT needed for MSE (browser handles ordering internally).
- */
-
-export interface ReorderBufferConfig<T> {
-	/** Maximum frames to buffer before force-flushing oldest. */
-	maxSize: number;
-	/** Extract sequence number from a frame. */
-	getSequence: (frame: T) => number;
-	/** Check if a frame is a keyframe (flushes all pending). Optional. */
-	isKeyframe?: (frame: T) => boolean;
-}
-
-export class ReorderBuffer<T> {
-	readonly #config: ReorderBufferConfig<T>;
-	#buffer: T[] = [];
-	#lastFlushedSeq = -1;
-
-	constructor(config: ReorderBufferConfig<T>) {
-		this.#config = config;
-	}
-
-	/**
-	 * Push a frame into the buffer. Returns frames ready to decode (in sequence order).
-	 * May return 0 frames (buffered), 1 frame (in-order), or multiple (gap filled / flush).
-	 */
-	push(frame: T): T[] {
-		const { getSequence, isKeyframe, maxSize } = this.#config;
-
-		// Keyframe: flush all pending in order, then emit keyframe
-		if (isKeyframe?.(frame)) {
-			const flushed = this.flushAll();
-			this.#lastFlushedSeq = getSequence(frame);
-			flushed.push(frame);
-			return flushed;
-		}
-
-		const seq = getSequence(frame);
-
-		// Drop truly stale frames (older than what we've already flushed)
-		if (seq > 0 && seq <= this.#lastFlushedSeq) {
-			return [];
-		}
-
-		// Insert into buffer (maintain sorted order)
-		this.#buffer.push(frame);
-		this.#buffer.sort((a, b) => getSequence(a) - getSequence(b));
-
-		// Flush in-order frames from front
-		const flushed: T[] = [];
-		while (this.#buffer.length > 0) {
-			const frontSeq = getSequence(this.#buffer[0]);
-
-			// Flush if: next expected seq, OR nothing flushed yet (bootstrap), OR buffer full
-			if (frontSeq <= this.#lastFlushedSeq + 1 || this.#lastFlushedSeq < 0 || this.#buffer.length >= maxSize) {
-				const f = this.#buffer.shift()!;
-				this.#lastFlushedSeq = getSequence(f);
-				flushed.push(f);
-			} else {
-				break; // gap — wait for missing frame
-			}
-		}
-
-		return flushed;
-	}
-
-	/**
-	 * Flush all pending frames in sequence order. Call on keyframe or cleanup.
-	 */
-	flushAll(): T[] {
-		this.#buffer.sort((a, b) => this.#config.getSequence(a) - this.#config.getSequence(b));
-		const flushed = this.#buffer.splice(0);
-		if (flushed.length > 0) {
-			this.#lastFlushedSeq = this.#config.getSequence(flushed[flushed.length - 1]);
-		}
-		return flushed;
-	}
-
-	/** Number of frames currently buffered (waiting for gap to fill). */
-	get pending(): number {
-		return this.#buffer.length;
-	}
-
-	/** Reset buffer state. */
-	reset(): void {
-		this.#buffer = [];
-		this.#lastFlushedSeq = -1;
-	}
-}