@blockcast/mmt-container 0.1.0 → 0.3.0-main.ef68de90edb3

package/dist/mfu-reassembler.js

@@ -1,320 +1,3086 @@
-/**
- * @mmt/container - MFU Fragment Reassembler
- *
- * Handles out-of-order delivery of fragmented MFUs (Media Fragment Units)
- * according to ISO/IEC 23008-1:2023 Section 9.2.3.3
- *
- * Fragmentation Indicator (FI) values:
- * - 0: Complete MFU (single packet, no fragmentation)
- * - 1: First fragment
- * - 2: Middle fragment
- * - 3: Last fragment
- *
- * @packageDocumentation
- */
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MFUReassembler_instances, _MFUReassembler_buffers, _MFUReassembler_timeouts, _MFUReassembler_timeoutMs, _MFUReassembler_maxBuffered, _MFUReassembler_tryReassemble, _MFUReassembler_setTimeout, _MFUReassembler_clearTimeout, _MFUReassembler_onTimeout, _MFUReassembler_enforceMemoryLimit;
-import { unwrapMMTP, parseMPUHeader, isFecRepairPacket, MPU_HEADER_SIZE, MFU_DU_HEADER_SIZE, } from './mmtp.js';
-/**
- * MFU Reassembler for out-of-order fragment delivery
- * Based on ISO/IEC 23008-1:2023 Section 9.2.3.3
- */
-export class MFUReassembler {
-    constructor(options) {
-        _MFUReassembler_instances.add(this);
-        _MFUReassembler_buffers.set(this, new Map());
-        _MFUReassembler_timeouts.set(this, new Map());
-        _MFUReassembler_timeoutMs.set(this, void 0);
-        _MFUReassembler_maxBuffered.set(this, void 0);
-        /** Statistics for debugging */
-        this.stats = {
-            totalFragments: 0,
-            reassembledMFUs: 0,
-            timedOutMFUs: 0,
-            outOfOrderFragments: 0,
-        };
-        __classPrivateFieldSet(this, _MFUReassembler_timeoutMs, options?.timeoutMs ?? 1000, "f");
-        __classPrivateFieldSet(this, _MFUReassembler_maxBuffered, options?.maxBuffered ?? 100, "f");
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+var MMTP_EXT_TYPE_ALTA_AUTH = 61601;
+var MMTP_EXT_TRAILER_HEADER_SIZE = 4;
+
+// ../mmt-base/dist/mmtp.js
+var MMTP_HEADER_SIZE = 12;
+var MPU_HEADER_SIZE2 = 8;
+var MFU_DU_HEADER_SIZE_TIMED = 14;
+var MFU_DU_HEADER_SIZE_NONTIMED = 4;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+var SOURCE_FEC_PAYLOAD_ID_SIZE = 4;
+var PACKET_TYPE_MPU = 0;
+function parseMMTPHeader(buffer) {
+  if (buffer.length < MMTP_HEADER_SIZE) {
+    throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const version = buffer[0] >> 6 & 3;
+  if (version !== 0) {
+    throw new Error(`Unsupported MMTP version: ${version}`);
+  }
+  const fecType = buffer[0] >> 3 & 3;
+  const packetCounterFlag = (buffer[0] & 32) !== 0;
+  const extensionFlag = (buffer[0] & 2) !== 0;
+  const rapFlag = (buffer[0] & 1) === 1;
+  const packetType = buffer[1] & 63;
+  let offset = 2;
+  const packetId = view.getUint16(offset, false);
+  offset += 2;
+  const timestamp = BigInt(view.getUint32(offset, false));
+  offset += 4;
+  const sequenceNumber = view.getUint32(offset, false);
+  offset += 4;
+  let packetCounter;
+  if (packetCounterFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in packet_counter");
+    packetCounter = view.getUint32(offset, false);
+    offset += 4;
+  }
+  let extension;
+  if (extensionFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in header extension");
+    const type = view.getUint16(offset, false);
+    const length = view.getUint16(offset + 2, false);
+    offset += 4;
+    if (offset + length > buffer.length)
+      throw new Error("MMTP packet truncated in header extension value");
+    extension = { type, data: buffer.subarray(offset, offset + length) };
+    offset += length;
+  }
+  return {
+    version,
+    packetType,
+    packetId,
+    timestamp,
+    sequenceNumber,
+    payloadLength: buffer.length - offset,
+    fecType,
+    packetCounterFlag,
+    packetCounter,
+    extensionFlag,
+    extension,
+    headerLength: offset,
+    rapFlag
+  };
+}
+function parseMPUHeader(payload) {
+  if (payload.length < MPU_HEADER_SIZE2) {
+    throw new Error(`Payload too small for MPU header: ${payload.length} bytes`);
+  }
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  const payloadLength = view.getUint16(0, false);
+  const flagsByte = payload[2];
+  const timedFlag = flagsByte >> 3 & 1;
+  const fragmentationIndicator = flagsByte >> 1 & 3;
+  const aggregationFlag = (flagsByte & 1) !== 0;
+  const fragmentCounter = payload[3];
+  const mpuSequenceNumber = view.getUint32(4, false);
+  return {
+    mpuSequenceNumber,
+    fragmentationIndicator,
+    fragmentCounter,
+    timedFlag,
+    aggregationFlag,
+    payloadLength
+  };
+}
+function parseTimedMfuDuHeader(payload, offset) {
+  if (offset < 0 || offset + MFU_DU_HEADER_SIZE_TIMED > payload.length)
+    return null;
+  const view = new DataView(payload.buffer, payload.byteOffset + offset, MFU_DU_HEADER_SIZE_TIMED);
+  return {
+    movieFragmentSequenceNumber: view.getUint32(0, false),
+    sampleNumber: view.getUint32(4, false),
+    offset: view.getUint32(8, false),
+    priority: payload[offset + 12],
+    dependencyCounter: payload[offset + 13]
+  };
+}
+function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
+  if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE2) {
+    return {
+      rejection: {
+        gate: "mpu-payload-length-below-header-remainder",
+        detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE2}`
+      }
+    };
+  }
+  const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + mpu.payloadLength;
+  if (declaredEnd > payload.length) {
+    return {
+      rejection: {
+        gate: "mpu-declared-end-exceeds-payload",
+        detail: `payload_length=${mpu.payloadLength} implies end=${declaredEnd}, payload is ${payload.length} bytes`
+      }
+    };
+  }
+  const hasHeader = fragmentType === 2 && mpu.fragmentationIndicator <= 1;
+  const mfuHeaderSize = mpu.timedFlag ? MFU_DU_HEADER_SIZE_TIMED : MFU_DU_HEADER_SIZE_NONTIMED;
+  const mfuOffset = MPU_HEADER_SIZE2 + (hasHeader ? mfuHeaderSize : 0);
+  if (mfuOffset >= declaredEnd) {
+    return {
+      rejection: {
+        gate: "mfu-offset-at-or-past-declared-end",
+        detail: `mfuOffset=${mfuOffset} >= declaredEnd=${declaredEnd}`
+      }
+    };
+  }
+  return {
+    layout: {
+      hasMfuDuHeader: hasHeader,
+      mfuOffset,
+      dataEnd: declaredEnd
     }
-    /**
-     * Add a fragment and return reassembled MFU if complete
-     */
-    addFragment(fragment) {
-        this.stats.totalFragments++;
-        const { mpuSequenceNumber, fragmentationIndicator, fragmentCounter } = fragment;
-        // Handle complete MFU (FI=0)
-        if (fragmentationIndicator === 0) {
-            this.stats.reassembledMFUs++;
-            return {
-                mpuSequenceNumber,
-                data: fragment.data,
-                timestamp: fragment.timestamp,
-                fragmentCount: 1,
-                rapFlag: fragment.rapFlag,
-            };
-        }
-        // Get or create fragment buffer for this MPU
-        let fragments = __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").get(mpuSequenceNumber);
-        if (!fragments) {
-            fragments = [];
-            __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").set(mpuSequenceNumber, fragments);
-            __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_setTimeout).call(this, mpuSequenceNumber);
-        }
-        // Check for duplicate fragment
-        const existingIdx = fragments.findIndex((f) => f.fragmentCounter === fragmentCounter);
-        if (existingIdx >= 0) {
-            fragments[existingIdx] = fragment;
-        }
-        else {
-            fragments.push(fragment);
-        }
-        // Track out-of-order delivery
-        if (fragments.length > 1) {
-            const lastFI = fragments[fragments.length - 2].fragmentationIndicator;
-            if (fragmentationIndicator !== lastFI + 1) {
-                this.stats.outOfOrderFragments++;
-            }
+  };
+}
+function isEmptyOrExactAltaTrailer(payload, start, end) {
+  if (start === end)
+    return true;
+  if (start < 0 || end > payload.length || start + MMTP_EXT_TRAILER_HEADER_SIZE > end) {
+    return false;
+  }
+  const view = new DataView(payload.buffer, payload.byteOffset + start, end - start);
+  if (view.getUint16(0, false) !== MMTP_EXT_TYPE_ALTA_AUTH)
+    return false;
+  const authLength = view.getUint16(2, false);
+  return start + MMTP_EXT_TRAILER_HEADER_SIZE + authLength === end;
+}
+function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
+  if (declaredEnd > payload.length)
+    return null;
+  if (options?.skipFecId) {
+    return isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
+  }
+  if (fecType === 1) {
+    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
+    if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {
+      return null;
+    }
+    return { hasFecId: true };
+  }
+  if (fecType !== 0)
+    return null;
+  if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {
+    return { hasFecId: false };
+  }
+  return null;
+}
+function planMfuExtraction(mmtpPacket, options, parsedHeader) {
+  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE2) {
+    return {
+      rejection: {
+        gate: "packet-shorter-than-mmtp-plus-mpu-header",
+        detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE + MPU_HEADER_SIZE2}`
+      }
+    };
+  }
+  let header;
+  if (parsedHeader) {
+    header = parsedHeader;
+  } else {
+    try {
+      header = parseMMTPHeader(mmtpPacket);
+    } catch (error) {
+      return {
+        rejection: {
+          gate: "mmtp-header-unparseable",
+          detail: error instanceof Error ? error.message : String(error)
         }
-        // Enforce memory limits
-        __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_enforceMemoryLimit).call(this);
-        // Try to reassemble
-        return __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_tryReassemble).call(this, mpuSequenceNumber);
+      };
     }
+  }
+  if (header.packetType !== PACKET_TYPE_MPU) {
+    return {
+      rejection: {
+        gate: "not-an-mpu-packet",
+        detail: `packetType=0x${header.packetType.toString(16).padStart(2, "0")}`
+      }
+    };
+  }
+  const payload = mmtpPacket.subarray(header.headerLength);
+  if (payload.length < MPU_HEADER_SIZE2) {
+    return {
+      rejection: {
+        gate: "payload-shorter-than-mpu-header",
+        detail: `${payload.length} bytes < ${MPU_HEADER_SIZE2}`
+      }
+    };
+  }
+  const mpu = parseMPUHeader(payload);
+  if (mpu.aggregationFlag) {
+    return {
+      rejection: { gate: "aggregation-flag-set", detail: "strict profile requires A=0" }
+    };
+  }
+  const fragmentType = payload[2] >> 4 & 15;
+  const layoutResult = resolveMfuPayloadLayout(mpu, fragmentType, payload);
+  if ("rejection" in layoutResult)
+    return layoutResult;
+  const { layout } = layoutResult;
+  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
+  if (!trailerLayout) {
+    if (!options?.skipFecId && header.fecType === 1) {
+      const observed = payload.length - layout.dataEnd;
+      if (observed !== SOURCE_FEC_PAYLOAD_ID_SIZE) {
+        return {
+          rejection: {
+            gate: "source-fec-payload-id-width-mismatch",
+            detail: `producer wrote a ${observed}-byte Source FEC Payload ID, ISO/IEC 23008-1 \xA7C.5.2 requires ${SOURCE_FEC_PAYLOAD_ID_SIZE} (payload=${payload.length}, declaredEnd=${layout.dataEnd})`
+          }
+        };
+      }
+    }
+    return {
+      rejection: {
+        gate: "declared-trailers-unresolved",
+        detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact ALTA trailer (fecType=${header.fecType})`
+      }
+    };
+  }
+  return { plan: { header, payload, mpu, fragmentType, layout, trailerLayout } };
+}
+function extractMFUPayload(mmtpPacket, options) {
+  return extractPlannedMfu(mmtpPacket, planMfuExtraction(mmtpPacket, options));
+}
+function extractPlannedMfu(mmtpPacket, result) {
+  if ("rejection" in result)
+    return null;
+  const { header, payload, mpu, fragmentType, layout, trailerLayout } = result.plan;
+  const mfuDuHeaderPresent = layout.hasMfuDuHeader;
+  const mfuOffset = layout.mfuOffset;
+  const dataEnd = layout.dataEnd;
+  const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE2) : null;
+  const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE2, 4).getUint32(0, false) : null;
+  const data = payload.subarray(mfuOffset, dataEnd);
+  const fecPayloadId = trailerLayout.hasFecId ? {
+    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, SOURCE_FEC_PAYLOAD_ID_SIZE).getUint32(0, false)
+  } : null;
+  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
+}
+function isFecRepairPacket(mmtpPacket) {
+  if (mmtpPacket.length < 1)
+    return false;
+  const fecType = mmtpPacket[0] >> 3 & 3;
+  return fecType >= 2;
+}
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// src/mfu-reassembler.ts
+function foldDeliveryProvenance(verdict, source) {
+  if (verdict === "mixed") return "mixed";
+  if (source === "moq") return "mixed";
+  if (source === void 0) return "unknown";
+  return verdict;
+}
+function fragmentProvenance(fragment) {
+  if (fragment.deliveryProvenance !== void 0) return fragment.deliveryProvenance;
+  if (fragment.source === "moq") return "mixed";
+  if (fragment.source === "multicast") return "multicast";
+  return "unknown";
+}
+function deliveryProvenanceOf(fragments) {
+  if (fragments.length === 0) return "unknown";
+  let verdict = "multicast";
+  for (const fragment of fragments) {
+    const own = fragmentProvenance(fragment);
+    verdict = verdict === "mixed" || own === "mixed" ? "mixed" : verdict === "unknown" || own === "unknown" ? "unknown" : "multicast";
+  }
+  return verdict;
+}
+var MFU_REASSEMBLY_ERROR_CODES = [
+  "invalid-fragment-state",
+  "missing-data-unit-identity",
+  "missing-packet-sequence",
+  "conflicting-data-unit-identity",
+  "overlapping-data-unit",
+  "fragment-counter-mismatch",
+  "data-unit-identity-mismatch",
+  "offset-overflow",
+  "active-data-unit-limit",
+  "incomplete-terminal-fragment",
+  "ambiguous-continuation"
+];
+var mfuReassemblyErrorCodes = new Set(MFU_REASSEMBLY_ERROR_CODES);
+function isMfuReassemblyErrorCode(value) {
+  return typeof value === "string" && mfuReassemblyErrorCodes.has(value);
+}
+var MfuReassemblyError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MfuReassemblyError";
+  }
+};
+function isMfuReassemblyError(error) {
+  if (error instanceof MfuReassemblyError) return true;
+  if (typeof error !== "object" || error === null) return false;
+  return Reflect.get(error, "name") === "MfuReassemblyError" && isMfuReassemblyErrorCode(Reflect.get(error, "code"));
+}
+function assembledPacketSequences(fragments) {
+  const packetSequenceNumbers = [];
+  const repairedPacketSequenceNumbers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const repaired = /* @__PURE__ */ new Set();
+  for (const fragment of fragments) {
+    const sequence = fragment.packetSequenceNumber;
+    if (typeof sequence !== "number" || !Number.isSafeInteger(sequence) || sequence < 0 || sequence > 4294967295) {
+      return {};
+    }
+    if (!seen.has(sequence)) {
+      seen.add(sequence);
+      packetSequenceNumbers.push(sequence);
+    }
+    if (fragment.recovered === true && !repaired.has(sequence)) {
+      repaired.add(sequence);
+      repairedPacketSequenceNumbers.push(sequence);
+    }
+  }
+  return { packetSequenceNumbers, repairedPacketSequenceNumbers };
+}
+function streamScope(fragment) {
+  if (fragment.catalogTrackName !== void 0) return ["catalog", fragment.catalogTrackName];
+  if (fragment.packetId !== void 0) return ["packet", fragment.packetId];
+  return ["unspecified", null];
+}
+function isU32(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+function dataUnitAddress(fragment, packetSequenceNumber) {
+  return JSON.stringify([
+    ...streamScope(fragment),
+    fragment.mpuSequenceNumber,
+    packetSequenceNumber + fragment.fragmentCounter >>> 0
+  ]);
+}
+function hasAnySampleIdentityField(fragment) {
+  return fragment.movieFragmentSequenceNumber !== void 0 || fragment.sampleNumber !== void 0 || fragment.sampleOffset !== void 0;
+}
+function hasSampleIdentity(fragment) {
+  return isU32(fragment.movieFragmentSequenceNumber) && fragment.movieFragmentSequenceNumber > 0 && isU32(fragment.sampleNumber) && fragment.sampleNumber > 0 && isU32(fragment.sampleOffset);
+}
+function hasValidFragmentHeader(fragment) {
+  const { fragmentationIndicator: fi, fragmentCounter: counter } = fragment;
+  if (!Number.isInteger(fi) || fi < 0 || fi > 3) return false;
+  if (!Number.isInteger(counter) || counter < 0 || counter > 255) return false;
+  return fi === 0 || fi === 3 ? counter === 0 : counter > 0;
+}
+function fragmentCounterOrder(fragment) {
+  return 255 - fragment.fragmentCounter;
+}
+function objectKey(fragment) {
+  const scope = streamScope(fragment);
+  if (fragment.itemId !== void 0) {
+    return JSON.stringify([...scope, fragment.mpuSequenceNumber, "item", fragment.itemId]);
+  }
+  if (hasSampleIdentity(fragment)) {
+    return JSON.stringify([
+      ...scope,
+      fragment.mpuSequenceNumber,
+      "sample",
+      fragment.movieFragmentSequenceNumber,
+      fragment.sampleNumber,
+      // The DU's authored base offset (moqcast #37): sibling subsample DUs
+      // of one sample get distinct keys instead of colliding. Only ever
+      // called with the unmutated FI=1 (or FI=0) fragment, whose
+      // sampleOffset is that authored base -- never the accumulating
+      // per-continuation value written by #associateDataUnit.
+      fragment.sampleOffset
+    ]);
+  }
+  return JSON.stringify([...scope, fragment.mpuSequenceNumber, "unidentified"]);
+}
+function ordersByOffset(fragments) {
+  return fragments.every((fragment) => hasSampleIdentity(fragment));
+}
+function checkedSampleEnd(offset, byteLength) {
+  const end = offset + byteLength;
+  return Number.isSafeInteger(end) && end <= 4294967295 ? end : null;
+}
+var COMPLETED_ADDRESS_WINDOW_MULTIPLE = 2;
+var EVICTION_GUARD_MAX_BUFFERED = 4;
+var EVICTION_GUARD_DATA_UNITS = 12;
+function parkedRunHoldsASlot(hasOpenRun, fragmentCount) {
+  return !hasOpenRun && fragmentCount > 0;
+}
+var MFUReassembler = class {
+  constructor(options) {
+    // Fragment buffers and active runs use the authored MFU DU identity.
+    // Continuations may wait in one counter-indexed queue per data-unit address
+    // until FI=1 supplies that identity. The address is transport association
+    // only; the object key stays the intrinsic DU identity.
+    this.#buffers = /* @__PURE__ */ new Map();
+    this.#timeouts = /* @__PURE__ */ new Map();
+    this.#activeDataUnits = /* @__PURE__ */ new Map();
+    this.#pendingContinuations = /* @__PURE__ */ new Map();
+    this.#emitted = /* @__PURE__ */ new Set();
+    // same sample keys, so FEC-recovered duplicate heads are dropped
+    this.#emittedOrder = [];
+    // Addresses of emitted data units. A continuation addressed to one of them
+    // is a late copy of a fragment the run already consumed (FEC recovery
+    // supplied it first), so it is rejected as stale rather than parked as a
+    // headless data unit that would hold a slot until reset. Bounded at
+    // COMPLETED_ADDRESS_WINDOW_MULTIPLE x maxBuffered, the same window the Rust
+    // engine keeps, so both engines forget an address after the same number of
+    // completions. (#emitted is a separate, per-engine window: this engine keeps
+    // maxBuffered sample keys where Rust keeps 2x; the completed set does not
+    // derive from it.)
+    this.#completed = /* @__PURE__ */ new Set();
+    this.#completedOrder = [];
     /**
-     * Flush all buffered fragments
+     * Monotonic admission ordinal. Counts slot admissions, never reads a clock,
+     * so eviction order survives on hosts that run `timeoutMs: null`.
      */
-    flush() {
-        for (const mpuSeq of __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").keys()) {
-            __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_clearTimeout).call(this, mpuSeq);
+    this.#nextAdmissionSeq = 0;
+    /** Statistics for debugging */
+    this.stats = {
+      totalFragments: 0,
+      reassembledMFUs: 0,
+      rejectedFragments: 0,
+      timedOutMFUs: 0,
+      evictedMemoryLimit: 0,
+      outOfOrderFragments: 0
+    };
+    if (options.timeoutMs !== null && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+      throw new Error("[MFUReassembler] timeoutMs must be > 0 (derive from frame duration or FEC config)");
+    }
+    const maxBuffered = options.maxBuffered ?? 100;
+    if (!Number.isInteger(maxBuffered) || maxBuffered <= 0) {
+      throw new Error("[MFUReassembler] maxBuffered must be a positive integer");
+    }
+    this.#timeoutMs = options.timeoutMs;
+    this.#maxBuffered = maxBuffered;
+  }
+  #buffers;
+  #timeouts;
+  #activeDataUnits;
+  #pendingContinuations;
+  #emitted;
+  #emittedOrder;
+  #completed;
+  #completedOrder;
+  #timeoutMs;
+  #maxBuffered;
+  #nextAdmissionSeq;
+  /** Update the expiry policy for all retained and future incomplete MFUs. */
+  set timeoutMs(ms) {
+    if (ms !== null && (!Number.isFinite(ms) || ms <= 0)) {
+      throw new Error("[MFUReassembler] timeoutMs must be > 0 (derive from frame duration or FEC config)");
+    }
+    this.#timeoutMs = ms;
+    const now = Date.now();
+    for (const [bufferKey, state] of this.#timeouts) {
+      if (state.timeoutId !== void 0) clearTimeout(state.timeoutId);
+      delete state.timeoutId;
+      if (ms !== null) {
+        state.timeoutId = setTimeout(() => this.#onTimeout(bufferKey), Math.max(0, state.startedAt + ms - now));
+      }
+    }
+    for (const address of this.#pendingContinuations.keys()) {
+      this.#clearPendingTimeout(address);
+      this.#armHeadlessPendingTimeout(address);
+    }
+  }
+  get timeoutMs() {
+    return this.#timeoutMs;
+  }
+  /**
+   * Add a fragment and return reassembled MFU if complete
+   */
+  addFragment(fragment) {
+    this.stats.totalFragments++;
+    if (!hasValidFragmentHeader(fragment)) {
+      this.#reject("invalid-fragment-state", "invalid MFU fragmentation indicator or counter");
+    }
+    if (fragment.itemId !== void 0 && hasAnySampleIdentityField(fragment)) {
+      this.#reject("conflicting-data-unit-identity", "MFU carries timed and non-timed DU identities");
+    }
+    const { mpuSequenceNumber, fragmentationIndicator } = fragment;
+    if (fragmentationIndicator === 0) {
+      const sampleIdentity = hasSampleIdentity(fragment);
+      const hasSampleFields = hasAnySampleIdentityField(fragment);
+      const hasItemIdentity = fragment.itemId !== void 0;
+      if (!sampleIdentity && !hasItemIdentity) {
+        this.#reject("missing-data-unit-identity", "complete MFU has no intrinsic DU identity");
+      }
+      if (hasSampleFields && !sampleIdentity) {
+        this.#reject("missing-data-unit-identity", "complete MFU has an incomplete sample identity");
+      }
+      if (hasItemIdentity && !isU32(fragment.itemId)) {
+        this.#reject("missing-data-unit-identity", "complete MFU has an invalid Item_ID");
+      }
+      this.stats.reassembledMFUs++;
+      return {
+        mpuSequenceNumber,
+        packetSequenceNumber: fragment.packetSequenceNumber,
+        ...assembledPacketSequences([fragment]),
+        data: fragment.data,
+        timestamp: fragment.timestamp,
+        fragmentCount: 1,
+        rapFlag: fragment.rapFlag,
+        priority: fragment.priority,
+        sampleNumber: fragment.sampleNumber,
+        movieFragmentSequenceNumber: fragment.movieFragmentSequenceNumber,
+        sampleOffset: fragment.sampleOffset,
+        source: fragment.source,
+        deliveryProvenance: deliveryProvenanceOf([fragment]),
+        catalogTrackName: fragment.catalogTrackName
+      };
+    }
+    const sequence = fragment.packetSequenceNumber;
+    if (!isU32(sequence)) {
+      this.#reject("missing-packet-sequence", "fragmented MFU has no MMTP packet sequence number");
+    }
+    const address = dataUnitAddress(fragment, sequence);
+    if (fragmentationIndicator !== 1) {
+      const open = this.#openRunAt(address);
+      if (open === void 0) {
+        if (this.#completed.has(address)) {
+          this.#reject("fragment-counter-mismatch", "MFU continuation names a data unit that already completed");
         }
-        __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").clear();
-        __classPrivateFieldGet(this, _MFUReassembler_timeouts, "f").clear();
+        this.#parkContinuation(address, fragment);
+        return null;
+      }
+      const [runKey2, active] = open;
+      if (active.nextFragmentCounter > fragment.fragmentCounter) {
+        this.#parkContinuation(address, fragment);
+        return null;
+      }
+      if (active.nextFragmentCounter < fragment.fragmentCounter) {
+        this.#reject("fragment-counter-mismatch", "MFU continuation is behind the authored fragment-counter countdown");
+      }
+      const result2 = this.#addAssociatedFragment(fragment, runKey2, address);
+      if (result2 !== null) return result2;
+      return this.#drainPendingContinuations(address, runKey2);
     }
-    /**
-     * Get number of pending MFUs
-     */
-    get pendingCount() {
-        return __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").size;
+    const runKey = objectKey(fragment);
+    if ((hasSampleIdentity(fragment) || isU32(fragment.itemId)) && this.#emitted.has(runKey)) {
+      return null;
     }
-    /**
-     * Get current buffer status
-     */
-    getStatus() {
-        let pendingFragments = 0;
-        for (const fragments of __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").values()) {
-            pendingFragments += fragments.length;
+    if (this.#activeDataUnits.has(runKey)) {
+      this.#reject("overlapping-data-unit", "fragmented MFU overlaps an active data unit");
+    }
+    if (this.#openRunAt(address) !== void 0) {
+      this.#reject("overlapping-data-unit", "fragmented MFU opens on an address held by an open data unit");
+    }
+    const pending = this.#pendingContinuations.get(address);
+    if (pending !== void 0 && [...pending.fragments.keys()].some((counter) => counter >= fragment.fragmentCounter)) {
+      this.#reject(
+        "fragment-counter-mismatch",
+        "queued continuation counter is not below the authored first-fragment counter"
+      );
+    }
+    const result = this.#addAssociatedFragment(fragment, runKey, address, pending?.startedAt);
+    this.#clearPendingTimeout(address);
+    if (result !== null) return result;
+    return this.#drainPendingContinuations(address, runKey);
+  }
+  #addAssociatedFragment(fragment, runKey, address, startedAt) {
+    const association = this.#associateDataUnit(fragment, runKey, address);
+    const { bufferKey, first, terminal } = association;
+    let fragments = this.#buffers.get(bufferKey);
+    if (first) {
+      if (fragments !== void 0) {
+        this.#reject("overlapping-data-unit", "intrinsic data-unit buffer already exists");
+      }
+      fragments = [];
+      this.#buffers.set(bufferKey, fragments);
+    } else if (fragments === void 0) {
+      throw new Error("[MFUReassembler] active data unit has no fragment buffer");
+    }
+    if (first) this.#setTimeout(bufferKey, startedAt);
+    fragments.push(fragment);
+    if (!terminal) return null;
+    const result = this.#tryReassemble(bufferKey);
+    this.#activeDataUnits.delete(runKey);
+    if (result === null) {
+      this.#clearTimeout(bufferKey);
+      this.#buffers.delete(bufferKey);
+      this.#reject("incomplete-terminal-fragment", "validated terminal fragment did not complete its data unit");
+    }
+    this.#markCompleted(address);
+    return result;
+  }
+  #parkContinuation(address, fragment) {
+    let pending = this.#pendingContinuations.get(address);
+    const open = this.#openRunAt(address);
+    const alreadyCharged = open !== void 0 || parkedRunHoldsASlot(open !== void 0, pending?.fragments.size ?? 0);
+    if (!alreadyCharged && this.#incompleteRunCount() >= this.#maxBuffered) {
+      if (!this.#evictLeastRecentlyAdmitted()) {
+        this.#reject("active-data-unit-limit", "active MFU data-unit limit reached");
+      }
+    }
+    let armAfterInsert = false;
+    if (pending === void 0) {
+      pending = {
+        fragments: /* @__PURE__ */ new Map(),
+        startedAt: Date.now(),
+        admissionSeq: open !== void 0 ? open[1].admissionSeq : this.#nextAdmissionSeq++
+      };
+      this.#pendingContinuations.set(address, pending);
+      armAfterInsert = true;
+    } else if (!alreadyCharged) {
+      pending.admissionSeq = this.#nextAdmissionSeq++;
+      pending.startedAt = Date.now();
+      this.#clearPendingTimeout(address);
+      armAfterInsert = true;
+    }
+    if (pending.fragments.has(fragment.fragmentCounter)) {
+      this.#reject("fragment-counter-mismatch", "duplicate queued continuation counter would replace retained media");
+    }
+    pending.fragments.set(fragment.fragmentCounter, fragment);
+    if (armAfterInsert) this.#armHeadlessPendingTimeout(address);
+  }
+  #drainPendingContinuations(address, runKey) {
+    while (true) {
+      const active = this.#activeDataUnits.get(runKey);
+      const pending = this.#pendingContinuations.get(address);
+      if (active === void 0) {
+        if (pending?.fragments.size === 0) this.#deletePendingRun(address);
+        return null;
+      }
+      const fragment = pending?.fragments.get(active.nextFragmentCounter);
+      if (fragment === void 0) {
+        if (pending?.fragments.size === 0) this.#deletePendingRun(address);
+        return null;
+      }
+      pending.fragments.delete(active.nextFragmentCounter);
+      if (pending.fragments.size === 0) this.#deletePendingRun(address);
+      const result = this.#addAssociatedFragment(fragment, runKey, address);
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+  /** Parked data units that hold a `maxBuffered` slot of their own. Membership
+   * is `parkedRunHoldsASlot`, the same rule #evictLeastRecentlyAdmitted offers
+   * as candidates, so nothing can be counted here that eviction cannot reclaim.
+   *
+   * One site, two callers — `#incompleteRunCount` and `pendingCount` — mirroring
+   * Rust's `unopened_parked_run_count`, which `incomplete_run_count` and
+   * `buffered_count` both delegate to. Both callers used to inline this loop
+   * verbatim, so converging the *rule* moved one copy and left the other as the
+   * divergence (Ally's review of #400). The rule can no longer drift now that
+   * every site routes through `parkedRunHoldsASlot`; keeping the loop itself at
+   * one site is what stops the scaffolding drifting the next time this question
+   * grows an argument. */
+  #unopenedParkedRunCount() {
+    let count = 0;
+    for (const [address, pending] of this.#pendingContinuations) {
+      if (parkedRunHoldsASlot(this.#openRunAt(address) !== void 0, pending.fragments.size)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /** Every open run plus every headless parked data unit that holds a slot,
+   * one slot each. This is the quantity maxBuffered bounds. The parked term is
+   * `#unopenedParkedRunCount`, whose membership is `parkedRunHoldsASlot` — the
+   * same rule #evictLeastRecentlyAdmitted offers as candidates, so nothing can
+   * be counted here that eviction cannot reclaim. */
+  #incompleteRunCount() {
+    return this.#activeDataUnits.size + this.#unopenedParkedRunCount();
+  }
+  /**
+   * Drop the incomplete data unit admitted longest ago so a newly arriving one
+   * can take its slot. Selection is by monotonic admission ordinal, never by
+   * wall clock, so this is a bounded-capacity replacement policy and not a
+   * timeout: it behaves identically on hosts that never drive `cleanup_timeouts`
+   * (`timeoutMs: null`). Only incomplete data units are candidates — a data
+   * unit that completed has already left both maps.
+   *
+   * Returns false only if no slot is charged, which cannot happen at the bound
+   * (`maxBuffered` is a positive integer); admission then falls back to the
+   * fail-closed `active-data-unit-limit` reject, which stays a stable host code.
+   * That holds because the candidate set here is built from the same
+   * `parkedRunHoldsASlot` rule `#incompleteRunCount` counts by, so reaching the
+   * bound implies at least one candidate. Filtering one and not the other would
+   * make the claim false: a queue counted but not offered charges a slot no
+   * eviction can reclaim, and the receiver refuses every later data unit
+   * permanently.
+   */
+  #evictLeastRecentlyAdmitted() {
+    let victimAddress;
+    let victimSeq = Number.POSITIVE_INFINITY;
+    for (const [, active] of this.#activeDataUnits) {
+      if (active.admissionSeq < victimSeq) {
+        victimSeq = active.admissionSeq;
+        victimAddress = active.address;
+      }
+    }
+    for (const [address, pending] of this.#pendingContinuations) {
+      if (!parkedRunHoldsASlot(this.#openRunAt(address) !== void 0, pending.fragments.size)) {
+        continue;
+      }
+      if (pending.admissionSeq < victimSeq) {
+        victimSeq = pending.admissionSeq;
+        victimAddress = address;
+      }
+    }
+    if (victimAddress === void 0) return false;
+    this.#releaseSlot(victimAddress);
+    this.stats.evictedMemoryLimit++;
+    return true;
+  }
+  /**
+   * Release every form of state one address holds: its open run, that run's
+   * buffered fragments and deadline, and its continuation queue. The address is
+   * deliberately not marked completed — the data unit never emitted, so a later
+   * fragment of it may open a fresh slot rather than being rejected as stale.
+   */
+  #releaseSlot(address) {
+    const open = this.#openRunAt(address);
+    if (open !== void 0) {
+      const [runKey, active] = open;
+      this.#activeDataUnits.delete(runKey);
+      this.#clearTimeout(active.bufferKey);
+      this.#buffers.delete(active.bufferKey);
+    }
+    this.#deletePendingRun(address);
+  }
+  #reject(code, message) {
+    this.stats.rejectedFragments++;
+    throw new MfuReassemblyError(code, message);
+  }
+  #associateDataUnit(fragment, runKey, address) {
+    const fi = fragment.fragmentationIndicator;
+    if (fi === 1) {
+      const parked = this.#pendingContinuations.get(address);
+      const inheritsParkedSlot = parkedRunHoldsASlot(
+        this.#openRunAt(address) !== void 0,
+        parked?.fragments.size ?? 0
+      );
+      const sampleIdentity = hasSampleIdentity(fragment);
+      const hasSampleFields = hasAnySampleIdentityField(fragment);
+      const hasItemIdentity = fragment.itemId !== void 0;
+      if (sampleIdentity && hasItemIdentity) {
+        this.#reject("conflicting-data-unit-identity", "fragmented MFU carries timed and non-timed DU identities");
+      }
+      if (!sampleIdentity && !hasItemIdentity) {
+        this.#reject("missing-data-unit-identity", "first fragment has no intrinsic DU identity");
+      }
+      if (hasSampleFields && !sampleIdentity) {
+        this.#reject("missing-data-unit-identity", "first fragment has an incomplete sample identity");
+      }
+      if (hasItemIdentity && !isU32(fragment.itemId)) {
+        this.#reject("missing-data-unit-identity", "first fragment has an invalid Item_ID");
+      }
+      const bufferKey = objectKey(fragment);
+      if (this.#buffers.has(bufferKey)) {
+        this.#reject("overlapping-data-unit", "intrinsic data-unit buffer already exists");
+      }
+      let sampleEnd = null;
+      if (sampleIdentity) {
+        sampleEnd = checkedSampleEnd(fragment.sampleOffset, fragment.data.byteLength);
+        if (sampleEnd === null) this.#reject("offset-overflow", "sample byte offset overflow");
+      }
+      if (!inheritsParkedSlot && this.#incompleteRunCount() >= this.#maxBuffered) {
+        if (!this.#evictLeastRecentlyAdmitted()) {
+          this.#reject("active-data-unit-limit", "active MFU data-unit limit reached");
         }
-        return {
-            bufferedMFUs: __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").size,
-            pendingFragments,
-            stats: { ...this.stats },
+      }
+      const admissionSeq = inheritsParkedSlot ? parked.admissionSeq : this.#nextAdmissionSeq++;
+      let active2;
+      if (sampleIdentity) {
+        active2 = {
+          address,
+          kind: "sample",
+          bufferKey,
+          nextFragmentCounter: fragment.fragmentCounter - 1,
+          admissionSeq,
+          movieFragmentSequenceNumber: fragment.movieFragmentSequenceNumber,
+          sampleNumber: fragment.sampleNumber,
+          nextOffset: sampleEnd,
+          ...fragment.catalogTrackName === void 0 ? {} : { catalogTrackName: fragment.catalogTrackName }
         };
+      } else {
+        active2 = {
+          address,
+          kind: "item",
+          bufferKey,
+          nextFragmentCounter: fragment.fragmentCounter - 1,
+          admissionSeq,
+          itemId: fragment.itemId,
+          ...fragment.catalogTrackName === void 0 ? {} : { catalogTrackName: fragment.catalogTrackName }
+        };
+      }
+      this.#activeDataUnits.set(objectKey(fragment), active2);
+      return { bufferKey, first: true, terminal: false };
     }
-}
-_MFUReassembler_buffers = new WeakMap(), _MFUReassembler_timeouts = new WeakMap(), _MFUReassembler_timeoutMs = new WeakMap(), _MFUReassembler_maxBuffered = new WeakMap(), _MFUReassembler_instances = new WeakSet(), _MFUReassembler_tryReassemble = function _MFUReassembler_tryReassemble(mpuSequenceNumber) {
-    const fragments = __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").get(mpuSequenceNumber);
+    const active = this.#activeDataUnits.get(runKey);
+    if (active === void 0) {
+      throw new Error("[MFUReassembler] continuation was not parked before association");
+    }
+    if (fragment.fragmentCounter !== active.nextFragmentCounter) {
+      this.#reject(
+        "fragment-counter-mismatch",
+        "MFU continuation does not follow the authored fragment-counter countdown"
+      );
+    }
+    if (active.kind === "sample") {
+      if (fragment.itemId !== void 0) {
+        this.#reject("data-unit-identity-mismatch", "sample continuation carries an Item_ID");
+      }
+      if (hasAnySampleIdentityField(fragment) && (!hasSampleIdentity(fragment) || fragment.movieFragmentSequenceNumber !== active.movieFragmentSequenceNumber || fragment.sampleNumber !== active.sampleNumber || fragment.sampleOffset !== active.nextOffset)) {
+        this.#reject("data-unit-identity-mismatch", "sample continuation identity does not match");
+      }
+      const nextOffset = checkedSampleEnd(active.nextOffset, fragment.data.byteLength);
+      if (nextOffset === null) this.#reject("offset-overflow", "sample byte offset overflow");
+      fragment.movieFragmentSequenceNumber = active.movieFragmentSequenceNumber;
+      fragment.sampleNumber = active.sampleNumber;
+      fragment.sampleOffset = active.nextOffset;
+      if (fi === 2) {
+        active.nextOffset = nextOffset;
+        active.nextFragmentCounter = fragment.fragmentCounter - 1;
+      }
+    } else {
+      if (hasAnySampleIdentityField(fragment) || fragment.itemId !== void 0 && fragment.itemId !== active.itemId) {
+        this.#reject("data-unit-identity-mismatch", "Item_ID continuation identity does not match");
+      }
+      fragment.itemId = active.itemId;
+      if (fi === 2) active.nextFragmentCounter = fragment.fragmentCounter - 1;
+    }
+    return {
+      bufferKey: active.bufferKey,
+      first: false,
+      terminal: fi === 3
+    };
+  }
+  #tryReassemble(bufferKey) {
+    const fragments = this.#buffers.get(bufferKey);
     if (!fragments || fragments.length === 0) {
-        return null;
+      return null;
+    }
+    const sorted = [...fragments].sort((a, b) => this.#orderValue(a) - this.#orderValue(b));
+    if (sorted[0].fragmentationIndicator !== 1 || sorted[sorted.length - 1].fragmentationIndicator !== 3) {
+      return null;
     }
-    // Sort by fragment counter
-    fragments.sort((a, b) => a.fragmentCounter - b.fragmentCounter);
-    const firstFI = fragments[0].fragmentationIndicator;
-    const lastFI = fragments[fragments.length - 1].fragmentationIndicator;
-    // Need first (FI=1) and last (FI=3) fragments
-    if (firstFI !== 1 || lastFI !== 3) {
+    if (sorted.slice(1, -1).some((fragment) => fragment.fragmentationIndicator !== 2)) {
+      return null;
+    }
+    for (let i = 1; i < sorted.length; i++) {
+      if (this.#orderValue(sorted[i]) !== this.#orderValue(sorted[i - 1]) + 1) {
         return null;
+      }
     }
-    // Verify middle fragments have FI=2
-    for (let i = 1; i < fragments.length - 1; i++) {
-        if (fragments[i].fragmentationIndicator !== 2) {
-            return null;
+    if (ordersByOffset(sorted)) {
+      for (let i = 1; i < sorted.length; i++) {
+        const previous = sorted[i - 1];
+        if (sorted[i].sampleOffset !== previous.sampleOffset + previous.data.byteLength) {
+          return null;
         }
+      }
     }
-    // Reassemble: concatenate all fragment data
+    fragments.splice(0, fragments.length, ...sorted);
+    return this.#assemble(bufferKey, fragments);
+  }
+  #assemble(bufferKey, fragments) {
     const totalSize = fragments.reduce((sum, f) => sum + f.data.length, 0);
     const data = new Uint8Array(totalSize);
     let offset = 0;
     for (const fragment of fragments) {
-        data.set(fragment.data, offset);
-        offset += fragment.data.length;
+      data.set(fragment.data, offset);
+      offset += fragment.data.length;
     }
-    // Cleanup
-    __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_clearTimeout).call(this, mpuSequenceNumber);
-    __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").delete(mpuSequenceNumber);
+    this.#clearTimeout(bufferKey);
+    this.#buffers.delete(bufferKey);
+    this.#markEmitted(bufferKey);
     this.stats.reassembledMFUs++;
     return {
-        mpuSequenceNumber,
-        data,
-        timestamp: fragments[0].timestamp,
-        fragmentCount: fragments.length,
-        rapFlag: fragments[0].rapFlag,
+      mpuSequenceNumber: fragments[0].mpuSequenceNumber,
+      packetSequenceNumber: fragments[0].packetSequenceNumber,
+      ...assembledPacketSequences(fragments),
+      data,
+      timestamp: fragments[0].timestamp,
+      fragmentCount: fragments.length,
+      rapFlag: fragments[0].rapFlag,
+      priority: fragments.find((f) => f.priority !== void 0)?.priority,
+      sampleNumber: fragments[0].sampleNumber,
+      movieFragmentSequenceNumber: fragments[0].movieFragmentSequenceNumber,
+      sampleOffset: fragments[0].sampleOffset,
+      source: fragments[0].source,
+      deliveryProvenance: deliveryProvenanceOf(fragments),
+      catalogTrackName: fragments[0].catalogTrackName
     };
-}, _MFUReassembler_setTimeout = function _MFUReassembler_setTimeout(mpuSequenceNumber) {
-    const timeoutId = setTimeout(() => {
-        __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_onTimeout).call(this, mpuSequenceNumber);
-    }, __classPrivateFieldGet(this, _MFUReassembler_timeoutMs, "f"));
-    __classPrivateFieldGet(this, _MFUReassembler_timeouts, "f").set(mpuSequenceNumber, timeoutId);
-}, _MFUReassembler_clearTimeout = function _MFUReassembler_clearTimeout(mpuSequenceNumber) {
-    const timeoutId = __classPrivateFieldGet(this, _MFUReassembler_timeouts, "f").get(mpuSequenceNumber);
-    if (timeoutId !== undefined) {
-        clearTimeout(timeoutId);
-        __classPrivateFieldGet(this, _MFUReassembler_timeouts, "f").delete(mpuSequenceNumber);
-    }
-}, _MFUReassembler_onTimeout = function _MFUReassembler_onTimeout(mpuSequenceNumber) {
-    const fragments = __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").get(mpuSequenceNumber);
-    if (!fragments)
-        return;
+  }
+  #setTimeout(bufferKey, startedAt = Date.now()) {
+    const state = { startedAt };
+    if (this.#timeoutMs !== null) {
+      state.timeoutId = setTimeout(
+        () => this.#onTimeout(bufferKey),
+        Math.max(0, startedAt + this.#timeoutMs - Date.now())
+      );
+    }
+    this.#timeouts.set(bufferKey, state);
+  }
+  #clearPendingTimeout(address) {
+    const pending = this.#pendingContinuations.get(address);
+    if (pending?.timeoutId !== void 0) clearTimeout(pending.timeoutId);
+    if (pending !== void 0) {
+      delete pending.timeoutId;
+    }
+  }
+  /**
+   * A queue whose run closed without completing is headless again and expires
+   * from its own first arrival, exactly as it would had the head never come.
+   *
+   * An empty queue is not armed: it holds no data unit that could fail to
+   * complete, so there is nothing for a deadline to expire. Every arming site
+   * reaches this function, which takes that test through `parkedRunHoldsASlot`
+   * rather than filtering on the open run alone, which is how this engine
+   * reaches Rust's answer: its
+   * `next_timeout_at` derives candidate deadlines from the queue's live
+   * entries, so an empty queue yields none (BLO-32420).
+   */
+  #armHeadlessPendingTimeout(address) {
+    const pending = this.#pendingContinuations.get(address);
+    if (pending === void 0 || pending.timeoutId !== void 0 || this.#timeoutMs === null) return;
+    if (!parkedRunHoldsASlot(this.#openRunAt(address) !== void 0, pending.fragments.size)) return;
+    pending.timeoutId = setTimeout(
+      () => this.#onPendingTimeout(address),
+      Math.max(0, pending.startedAt + this.#timeoutMs - Date.now())
+    );
+  }
+  #deletePendingRun(address) {
+    this.#clearPendingTimeout(address);
+    this.#pendingContinuations.delete(address);
+  }
+  #onPendingTimeout(address) {
+    const pending = this.#pendingContinuations.get(address);
+    if (pending === void 0) return;
+    if (!parkedRunHoldsASlot(this.#openRunAt(address) !== void 0, pending.fragments.size)) {
+      this.#clearPendingTimeout(address);
+      return;
+    }
     this.stats.timedOutMFUs++;
-    __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").delete(mpuSequenceNumber);
-    __classPrivateFieldGet(this, _MFUReassembler_timeouts, "f").delete(mpuSequenceNumber);
-}, _MFUReassembler_enforceMemoryLimit = function _MFUReassembler_enforceMemoryLimit() {
-    if (__classPrivateFieldGet(this, _MFUReassembler_buffers, "f").size <= __classPrivateFieldGet(this, _MFUReassembler_maxBuffered, "f"))
-        return;
-    const sequences = Array.from(__classPrivateFieldGet(this, _MFUReassembler_buffers, "f").keys()).sort((a, b) => a - b);
-    const toRemove = sequences.slice(0, sequences.length - __classPrivateFieldGet(this, _MFUReassembler_maxBuffered, "f"));
-    for (const mpuSeq of toRemove) {
-        __classPrivateFieldGet(this, _MFUReassembler_instances, "m", _MFUReassembler_clearTimeout).call(this, mpuSeq);
-        __classPrivateFieldGet(this, _MFUReassembler_buffers, "f").delete(mpuSeq);
-        this.stats.timedOutMFUs++;
+    console.warn(
+      `[MfuReassembler] timeout: run=${address} fragments=${pending.fragments.size} (continuations awaiting first fragment, discarded)`
+    );
+    this.#pendingContinuations.delete(address);
+  }
+  #clearTimeout(bufferKey) {
+    const state = this.#timeouts.get(bufferKey);
+    if (state !== void 0) {
+      if (state.timeoutId !== void 0) clearTimeout(state.timeoutId);
+      this.#timeouts.delete(bufferKey);
+    }
+  }
+  #markEmitted(bufferKey) {
+    if (this.#emitted.has(bufferKey)) return;
+    this.#emitted.add(bufferKey);
+    this.#emittedOrder.push(bufferKey);
+    while (this.#emittedOrder.length > this.#maxBuffered) {
+      const oldest = this.#emittedOrder.shift();
+      if (oldest !== void 0) this.#emitted.delete(oldest);
+    }
+  }
+  #markCompleted(address) {
+    if (this.#completed.has(address)) return;
+    this.#completed.add(address);
+    this.#completedOrder.push(address);
+    const cap = this.#maxBuffered * COMPLETED_ADDRESS_WINDOW_MULTIPLE;
+    while (this.#completedOrder.length > cap) {
+      const oldest = this.#completedOrder.shift();
+      if (oldest !== void 0) this.#completed.delete(oldest);
+    }
+  }
+  #orderValue(fragment) {
+    return fragmentCounterOrder(fragment);
+  }
+  /** Close the run behind an expired buffer. Early arrivals parked under its
+   * address stay, now headless, and expire from their own arrival. */
+  #removeActiveDataUnitForBuffer(bufferKey) {
+    for (const [objectKey2, active] of this.#activeDataUnits) {
+      if (active.bufferKey === bufferKey) {
+        this.#activeDataUnits.delete(objectKey2);
+        this.#armHeadlessPendingTimeout(active.address);
+      }
+    }
+  }
+  /** The one open run holding this address, with its object key. Admission
+   * rejects a second head on an open address, so at most one run can match. */
+  #openRunAt(address) {
+    for (const entry of this.#activeDataUnits) {
+      if (entry[1].address === address) return entry;
+    }
+    return void 0;
+  }
+  #onTimeout(bufferKey) {
+    const fragments = this.#buffers.get(bufferKey);
+    if (!fragments || fragments.length === 0) {
+      this.#buffers.delete(bufferKey);
+      this.#timeouts.delete(bufferKey);
+      this.#removeActiveDataUnitForBuffer(bufferKey);
+      this.stats.timedOutMFUs++;
+      console.warn(`[MfuReassembler] timeout: key=${bufferKey} fragments=0 (no data buffered)`);
+      return;
+    }
+    this.stats.timedOutMFUs++;
+    console.warn(`[MfuReassembler] timeout: key=${bufferKey} fragments=${fragments.length} (partial, discarded)`);
+    this.#buffers.delete(bufferKey);
+    this.#timeouts.delete(bufferKey);
+    this.#removeActiveDataUnitForBuffer(bufferKey);
+  }
+  /**
+   * Flush all buffered fragments
+   */
+  flush() {
+    for (const key of this.#buffers.keys()) {
+      this.#clearTimeout(key);
+    }
+    this.#buffers.clear();
+    this.#timeouts.clear();
+    this.#activeDataUnits.clear();
+    for (const address of this.#pendingContinuations.keys()) {
+      this.#clearPendingTimeout(address);
+    }
+    this.#pendingContinuations.clear();
+    this.#emitted.clear();
+    this.#emittedOrder.length = 0;
+    this.#completed.clear();
+    this.#completedOrder.length = 0;
+  }
+  /** Drop one catalog stream's incomplete and dedup state. */
+  resetStream(catalogTrackName) {
+    const belongsToStream = (key) => {
+      try {
+        const decoded = JSON.parse(key);
+        return Array.isArray(decoded) && decoded[0] === "catalog" && decoded[1] === catalogTrackName;
+      } catch {
+        return false;
+      }
+    };
+    const discarded = /* @__PURE__ */ new Set();
+    for (const [key, fragments] of this.#buffers) {
+      if (fragments.some((fragment) => fragment.catalogTrackName === catalogTrackName)) {
+        discarded.add(key);
+      }
+    }
+    for (const [objectKey2, active] of this.#activeDataUnits) {
+      if (active.catalogTrackName === catalogTrackName) {
+        discarded.add(active.bufferKey);
+        this.#activeDataUnits.delete(objectKey2);
+      }
+    }
+    for (const [address, pending] of this.#pendingContinuations) {
+      if ([...pending.fragments.values()].some((fragment) => fragment.catalogTrackName === catalogTrackName) || belongsToStream(address))
+        this.#deletePendingRun(address);
+    }
+    for (const key of this.#emitted) {
+      if (belongsToStream(key)) discarded.add(key);
+    }
+    for (const key of discarded) {
+      this.#clearTimeout(key);
+      this.#buffers.delete(key);
+      this.#emitted.delete(key);
+    }
+    this.#emittedOrder = this.#emittedOrder.filter((key) => !discarded.has(key));
+    for (const address of this.#completed) {
+      if (belongsToStream(address)) this.#completed.delete(address);
+    }
+    this.#completedOrder = this.#completedOrder.filter((address) => this.#completed.has(address));
+  }
+  /** Reset all state — flush buffers and zero stats */
+  reset() {
+    this.flush();
+    this.stats.totalFragments = 0;
+    this.stats.reassembledMFUs = 0;
+    this.stats.rejectedFragments = 0;
+    this.stats.timedOutMFUs = 0;
+    this.stats.evictedMemoryLimit = 0;
+    this.stats.outOfOrderFragments = 0;
+  }
+  /**
+   * Get number of pending MFUs: engine buffers plus every headless parked data
+   * unit that holds a slot.
+   *
+   * This is not one of the four charging sites, but it shares their second term,
+   * so it takes the same rule — by delegating to `#unopenedParkedRunCount`, the
+   * one site that applies it. Rust's public `buffered_count()` is
+   * `inner.buffered_count() + unopened_parked_run_count()`, and that count is
+   * `parked_run_holds_a_slot` — so filtering here on the open run alone would
+   * report a phantom slot for an empty published queue in TypeScript and not in
+   * Rust, out of a *host-observable* counter (`getStatus().bufferedMFUs`). Same
+   * state, two numbers, decided by which engine the host loaded: the divergence
+   * class this file exists to close, so the public counters have to agree too.
+   *
+   * Distinct from `#incompleteRunCount`, which sums `#activeDataUnits` rather
+   * than `#buffers`. Those are different quantities by design and are not being
+   * merged; only the parked term they share is required to agree, which is what
+   * routing both through one method makes structural rather than conventional.
+   */
+  get pendingCount() {
+    return this.#buffers.size + this.#unopenedParkedRunCount();
+  }
+  /**
+   * Get current buffer status
+   */
+  getStatus() {
+    let pendingFragments = 0;
+    for (const fragments of this.#buffers.values()) {
+      pendingFragments += fragments.length;
+    }
+    for (const pending of this.#pendingContinuations.values()) {
+      pendingFragments += pending.fragments.size;
     }
-};
-/**
- * Create MFU fragment from MMTP packet for reassembly
- */
-export function createFragment(mmtpPacket) {
-    const { header, payload } = unwrapMMTP(mmtpPacket);
-    const mpuHeader = parseMPUHeader(payload);
-    const { mpuSequenceNumber, fragmentationIndicator, fragmentCounter } = mpuHeader;
-    // MFU DU header is present only for FI = 0 (complete) or FI = 1 (first)
-    const hasMfuHeader = fragmentationIndicator === 0 || fragmentationIndicator === 1;
-    const headerSize = MPU_HEADER_SIZE + (hasMfuHeader ? MFU_DU_HEADER_SIZE : 0);
-    if (payload.length < headerSize) {
-        throw new Error(`Payload too small for headers: ${payload.length} bytes (need ${headerSize})`);
-    }
-    const data = payload.subarray(headerSize);
     return {
-        fragmentationIndicator,
-        mpuSequenceNumber,
-        fragmentCounter,
-        data,
-        timestamp: header.timestamp,
-        receivedAt: typeof performance !== 'undefined' ? performance.now() : Date.now(),
-        rapFlag: header.rapFlag,
+      bufferedMFUs: this.pendingCount,
+      pendingFragments,
+      pendingSamples: this.#pendingDebugSamples(),
+      stats: { ...this.stats }
     };
-}
-/**
- * Process MMTP packet with fragment reassembly
- */
-export function processMMTPWithReassembly(mmtpPacket, reassembler) {
-    // Skip FEC repair packets
-    if (isFecRepairPacket(mmtpPacket)) {
-        return null;
+  }
+  #pendingDebugSamples() {
+    const out = [];
+    for (const [key, fragments] of this.#buffers) {
+      if (fragments.length === 0) continue;
+      const sorted = [...fragments].sort((a, b) => this.#orderValue(a) - this.#orderValue(b));
+      const fiCounts = [0, 0, 0, 0];
+      let minCounter = Infinity;
+      let maxCounter = -Infinity;
+      let minOffset = Infinity;
+      let maxOffset = -Infinity;
+      for (const fragment of sorted) {
+        fiCounts[fragment.fragmentationIndicator] = (fiCounts[fragment.fragmentationIndicator] ?? 0) + 1;
+        minCounter = Math.min(minCounter, fragment.fragmentCounter);
+        maxCounter = Math.max(maxCounter, fragment.fragmentCounter);
+        if (typeof fragment.sampleOffset === "number") {
+          minOffset = Math.min(minOffset, fragment.sampleOffset);
+          maxOffset = Math.max(maxOffset, fragment.sampleOffset);
+        }
+      }
+      const point = (fragment) => ({
+        fi: fragment.fragmentationIndicator,
+        counter: fragment.fragmentCounter,
+        order: this.#orderValue(fragment),
+        ...typeof fragment.packetSequenceNumber === "number" ? { seq: fragment.packetSequenceNumber } : {},
+        ...typeof fragment.sampleOffset === "number" ? { offset: fragment.sampleOffset } : {}
+      });
+      const summary = {
+        key,
+        fragments: sorted.length,
+        fi0: fiCounts[0] ?? 0,
+        fi1: fiCounts[1] ?? 0,
+        fi2: fiCounts[2] ?? 0,
+        fi3: fiCounts[3] ?? 0,
+        firstFi: sorted[0].fragmentationIndicator,
+        lastFi: sorted[sorted.length - 1].fragmentationIndicator,
+        firstOrder: this.#orderValue(sorted[0]),
+        lastOrder: this.#orderValue(sorted[sorted.length - 1]),
+        minCounter,
+        maxCounter,
+        movieFragmentSequenceNumber: sorted.find((f) => f.movieFragmentSequenceNumber !== void 0)?.movieFragmentSequenceNumber,
+        sampleNumber: sorted.find((f) => f.sampleNumber !== void 0)?.sampleNumber,
+        mpuSequenceNumber: sorted[0].mpuSequenceNumber,
+        sortedHead: sorted.slice(0, 6).map(point),
+        sortedTail: sorted.slice(-6).map(point)
+      };
+      if (minOffset !== Infinity) summary.minOffset = minOffset;
+      if (maxOffset !== -Infinity) summary.maxOffset = maxOffset;
+      out.push(summary);
+      if (out.length >= 12) break;
     }
-    const fragment = createFragment(mmtpPacket);
-    return reassembler.addFragment(fragment);
+    return out;
+  }
+};
+function createFragment(mmtpPacket) {
+  const extraction = extractMFUPayload(mmtpPacket);
+  if (!extraction) throw new Error("Unable to extract MFU payload from MMTP packet");
+  const { header, mpu, data, mfuDuHeader, itemId } = extraction;
+  return {
+    fragmentationIndicator: mpu.fragmentationIndicator,
+    mpuSequenceNumber: mpu.mpuSequenceNumber,
+    fragmentCounter: mpu.fragmentCounter,
+    data,
+    timestamp: header.timestamp,
+    rapFlag: header.rapFlag,
+    sampleNumber: mfuDuHeader?.sampleNumber,
+    movieFragmentSequenceNumber: mfuDuHeader?.movieFragmentSequenceNumber,
+    sampleOffset: mfuDuHeader?.offset,
+    priority: mfuDuHeader?.priority,
+    itemId: itemId ?? void 0,
+    packetSequenceNumber: header.sequenceNumber,
+    packetId: header.packetId
+  };
 }
-// =============================================================================
-// Inline Tests (vitest)
-// =============================================================================
-if (import.meta.vitest) {
-    const { describe, test, expect } = import.meta.vitest;
-    describe('MFUReassembler', () => {
-        test('should return complete MFU for FI=0', () => {
-            const reassembler = new MFUReassembler();
-            const result = reassembler.addFragment({
-                fragmentationIndicator: 0,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 0,
-                data: new Uint8Array([1, 2, 3, 4]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: true,
-            });
-            expect(result).not.toBeNull();
-            expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
-            expect(result?.fragmentCount).toBe(1);
-            expect(result?.rapFlag).toBe(true);
-        });
-        test('should buffer and reassemble 2 fragments', () => {
-            const reassembler = new MFUReassembler();
-            // First fragment (FI=1)
-            const result1 = reassembler.addFragment({
-                fragmentationIndicator: 1,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 0,
-                data: new Uint8Array([1, 2]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: true,
-            });
-            expect(result1).toBeNull();
-            // Last fragment (FI=3)
-            const result2 = reassembler.addFragment({
-                fragmentationIndicator: 3,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 1,
-                data: new Uint8Array([3, 4]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: false,
-            });
-            expect(result2).not.toBeNull();
-            expect(result2?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
-            expect(result2?.fragmentCount).toBe(2);
-            expect(result2?.rapFlag).toBe(true); // Should use first fragment's rapFlag
-        });
-        test('should handle out-of-order fragments', () => {
-            const reassembler = new MFUReassembler();
-            // Last fragment first (FI=3)
-            reassembler.addFragment({
-                fragmentationIndicator: 3,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 1,
-                data: new Uint8Array([3, 4]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: false,
-            });
-            // Then first fragment (FI=1)
-            const result = reassembler.addFragment({
-                fragmentationIndicator: 1,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 0,
-                data: new Uint8Array([1, 2]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: true,
-            });
-            expect(result).not.toBeNull();
-            expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
-            expect(result?.rapFlag).toBe(true);
+function processMMTPWithReassembly(mmtpPacket, reassembler) {
+  if (isFecRepairPacket(mmtpPacket)) {
+    return null;
+  }
+  const fragment = createFragment(mmtpPacket);
+  return reassembler.addFragment(fragment);
+}
+if (void 0) {
+  const { describe, test, expect, vi } = void 0;
+  const expectRejection = (call, code) => {
+    let rejection;
+    try {
+      call();
+    } catch (error) {
+      rejection = error;
+    }
+    expect(rejection).toBeInstanceOf(MfuReassemblyError);
+    expect(rejection.code).toBe(code);
+  };
+  const testPacketSequence = (mpu, counter, run = 0) => (mpu * 1e3 + run - counter + 4294967296) % 4294967296;
+  describe("MFUReassembler", () => {
+    test("should return complete MFU for FI=0", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1, 2, 3, 4]),
+        timestamp: 1000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(result?.fragmentCount).toBe(1);
+      expect(result?.rapFlag).toBe(true);
+    });
+    test("rejects a complete MFU without a valid sample identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const complete = (identity) => ({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: true,
+        ...identity
+      });
+      expectRejection(() => reassembler.addFragment(complete({})), "missing-data-unit-identity");
+      expectRejection(
+        () => reassembler.addFragment(
+          complete({
+            movieFragmentSequenceNumber: 2,
+            sampleNumber: 1
+          })
+        ),
+        "missing-data-unit-identity"
+      );
+    });
+    test("accepts a complete subsample MFU with a nonzero authored offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        movieFragmentSequenceNumber: 2,
+        sampleNumber: 1,
+        sampleOffset: 4,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result?.sampleOffset).toBe(4);
+    });
+    test("accepts a fragmented subsample DU whose first fragment has a nonzero authored offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 1,
+          movieFragmentSequenceNumber: 2,
+          sampleNumber: 1,
+          sampleOffset: 4,
+          packetSequenceNumber: testPacketSequence(2, 1),
+          data: new Uint8Array([161]),
+          timestamp: 1000n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.getStatus().pendingFragments).toBe(1);
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(2, 0)
+      });
+      expect(out?.data).toEqual(new Uint8Array([161, 162]));
+      expect(out?.sampleOffset).toBe(4);
+    });
+    test("a mid-data-unit packet sequence gap strands the data unit", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null, maxBuffered: 10 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          packetSequenceNumber: 100,
+          data: new Uint8Array([161]),
+          timestamp: 1100n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      const interleaved = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        packetSequenceNumber: 101,
+        data: new Uint8Array([255]),
+        timestamp: 1101n,
+        rapFlag: true
+      });
+      expect(interleaved?.data).toEqual(new Uint8Array([255]));
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 1,
+          packetSequenceNumber: 102,
+          data: new Uint8Array([162]),
+          timestamp: 1102n,
+          rapFlag: false
+        })
+      ).toBeNull();
+      const output = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        packetSequenceNumber: 103,
+        data: new Uint8Array([163]),
+        timestamp: 1103n,
+        rapFlag: false
+      });
+      expect(output).toBeNull();
+      expect(reassembler.stats.reassembledMFUs).toBe(1);
+      expect(reassembler.stats.rejectedFragments).toBe(0);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(0);
+      expect(reassembler.getStatus().bufferedMFUs).toBe(2);
+      expect(reassembler.getStatus().pendingFragments).toBe(3);
+    });
+    test("sibling subsample DUs of one sample reassemble independently by offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          movieFragmentSequenceNumber: 5,
+          sampleNumber: 9,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 2000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(3, 1, 0)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          movieFragmentSequenceNumber: 5,
+          sampleNumber: 9,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 3,
+          data: new Uint8Array([177]),
+          timestamp: 2001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(3, 1, 1)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      const first = reassembler.addFragment({
+        mpuSequenceNumber: 3,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 2000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(3, 0, 0)
+      });
+      expect(first?.data).toEqual(new Uint8Array([161, 162]));
+      expect(first?.sampleOffset).toBe(0);
+      expect(
+        reassembler.addFragment({
+          mpuSequenceNumber: 3,
+          fragmentationIndicator: 2,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: 2001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(3, 0, 1)
+        })
+      ).toBeNull();
+      const second = reassembler.addFragment({
+        mpuSequenceNumber: 3,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([179]),
+        timestamp: 2001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(3, 0, 2)
+      });
+      expect(second?.data).toEqual(new Uint8Array([177, 178, 179]));
+      expect(second?.sampleOffset).toBe(3);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("isolates colliding fragment coordinates by catalog track identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (catalogTrackName, fragmentationIndicator, fragmentCounter, byte) => ({
+        itemId: 1,
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp: 1000n,
+        rapFlag: fragmentationIndicator === 1,
+        catalogTrackName,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment("video/720p", 1, 1, 113))).toBeNull();
+      expect(reassembler.addFragment(fragment("video/540p", 1, 1, 81))).toBeNull();
+      const high = reassembler.addFragment(fragment("video/720p", 3, 0, 114));
+      const low = reassembler.addFragment(fragment("video/540p", 3, 0, 82));
+      expect(high?.data).toEqual(new Uint8Array([113, 114]));
+      expect(high?.catalogTrackName).toBe("video/720p");
+      expect(low?.data).toEqual(new Uint8Array([81, 82]));
+      expect(low?.catalogTrackName).toBe("video/540p");
+    });
+    test("rejects an overlapping non-timed item without replacing the active run", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (itemId, fragmentationIndicator, fragmentCounter, byte) => ({
+        itemId,
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment(10, 1, 1, 16))).toBeNull();
+      expectRejection(() => reassembler.addFragment(fragment(20, 1, 1, 32)), "overlapping-data-unit");
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.addFragment(fragment(10, 3, 0, 17))?.data).toEqual(new Uint8Array([16, 17]));
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("associates continuations by authored state when packet timestamps change", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const fragment = (itemId, fragmentationIndicator, fragmentCounter, byte, timestamp) => ({
+        ...itemId === void 0 ? {} : { itemId },
+        fragmentationIndicator,
+        fragmentCounter,
+        mpuSequenceNumber: 1,
+        data: new Uint8Array([byte]),
+        timestamp,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, fragmentCounter)
+      });
+      expect(reassembler.addFragment(fragment(10, 1, 2, 16, 1000n))).toBeNull();
+      expect(reassembler.addFragment(fragment(void 0, 2, 1, 17, 1001n))).toBeNull();
+      const out = reassembler.addFragment(fragment(void 0, 3, 0, 18, 1002n));
+      expect(out?.data).toEqual(new Uint8Array([16, 17, 18]));
+      expect(out?.timestamp).toBe(1000n);
+    });
+    test("should buffer and reassemble 2 fragments", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result1 = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result1).toBeNull();
+      const result2 = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3, 4]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result2).not.toBeNull();
+      expect(result2?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(result2?.fragmentCount).toBe(2);
+      expect(result2?.rapFlag).toBe(true);
+    });
+    test("buffers a terminal continuation until its authored first fragment arrives", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 0,
+          data: new Uint8Array([3, 4]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(1, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const completed = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(completed?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(completed?.rapFlag).toBe(true);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("clock-free mode keeps an admitted MFU until completion", async () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1, 2]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3, 4]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result?.data).toEqual(new Uint8Array([1, 2, 3, 4]));
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
+    });
+    test("should track pending count", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(reassembler.pendingCount).toBe(0);
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(reassembler.pendingCount).toBe(1);
+      reassembler.flush();
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("should reassemble 3 fragments (FI=1, FI=2, FI=3)", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 10,
+          fragmentCounter: 2,
+          itemId: 1,
+          data: new Uint8Array([170, 187]),
+          timestamp: 5000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(10, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 10,
+          fragmentCounter: 1,
+          data: new Uint8Array([204, 221]),
+          timestamp: 5000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(10, 1)
+        })
+      ).toBeNull();
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 10,
+        fragmentCounter: 0,
+        data: new Uint8Array([238, 255]),
+        timestamp: 5000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(10, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.data).toEqual(new Uint8Array([170, 187, 204, 221, 238, 255]));
+      expect(result.fragmentCount).toBe(3);
+      expect(result.rapFlag).toBe(true);
+      expect(result.mpuSequenceNumber).toBe(10);
+    });
+    test("should handle interleaved MPU sequences", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 100n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      const r2 = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        itemId: 2,
+        data: new Uint8Array([2]),
+        timestamp: 200n,
+        rapFlag: false
+      });
+      expect(r2).not.toBeNull();
+      expect(r2.mpuSequenceNumber).toBe(2);
+      const r1 = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([3]),
+        timestamp: 100n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(r1).not.toBeNull();
+      expect(r1.data).toEqual(new Uint8Array([1, 3]));
+    });
+    test("rejects overlapping fragmented MFUs sharing one stream and MPU", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const mpuSeq = 5;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 10,
+          data: new Uint8Array([161]),
+          timestamp: 100n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1)
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 20,
+          data: new Uint8Array([177]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1)
+        }),
+        "overlapping-data-unit"
+      );
+      expect(reassembler.pendingCount).toBe(1);
+      const a = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: mpuSeq,
+        fragmentCounter: 0,
+        data: new Uint8Array([162]),
+        timestamp: 101n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(mpuSeq, 0)
+      });
+      expect(a).not.toBeNull();
+      expect(a.data).toEqual(new Uint8Array([161, 162]));
+      expect(a.rapFlag).toBe(true);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: mpuSeq,
+          fragmentCounter: 1,
+          itemId: 20,
+          data: new Uint8Array([177]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(mpuSeq, 1, 10)
+        })
+      ).toBeNull();
+      const b = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: mpuSeq,
+        fragmentCounter: 0,
+        data: new Uint8Array([178]),
+        timestamp: 201n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(mpuSeq, 0, 10)
+      });
+      expect(b).not.toBeNull();
+      expect(b.data).toEqual(new Uint8Array([177, 178]));
+    });
+    test("reassembles FFmpeg timed MFU fragments by sample number and byte offset", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = {
+        mpuSequenceNumber: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 17
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 1000n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(0, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 2,
+          fragmentCounter: 1,
+          sampleOffset: 1,
+          data: new Uint8Array([178]),
+          timestamp: 1001n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(0, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        sampleOffset: 2,
+        data: new Uint8Array([195]),
+        timestamp: 1002n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(0, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.timestamp).toBe(1000n);
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("buffers a counter gap without advancing the active data unit", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = {
+        mpuSequenceNumber: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 17,
+        timestamp: 1000n,
+        rapFlag: true
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([161, 162]),
+          packetSequenceNumber: testPacketSequence(0, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 3,
+          fragmentCounter: 0,
+          sampleOffset: 4,
+          data: new Uint8Array([193, 194]),
+          packetSequenceNumber: testPacketSequence(0, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 2,
+        fragmentCounter: 1,
+        sampleOffset: 2,
+        data: new Uint8Array([177, 178]),
+        packetSequenceNumber: testPacketSequence(0, 1)
+      });
+      expect(out?.data).toEqual(new Uint8Array([161, 162, 177, 178, 193, 194]));
+    });
+    test("reassembles first-only DU-header fragments across changing packet timestamps", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp: 12345n,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(44, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: 12346n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 44,
+        fragmentCounter: 0,
+        data: new Uint8Array([195]),
+        timestamp: 12347n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(44, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.timestamp).toBe(12345n);
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("reassembles first-only DU-header fragments with an ISO countdown", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 12345n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 3,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(44, 3)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 2,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 2)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 44,
+          fragmentCounter: 1,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(44, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 44,
+        fragmentCounter: 0,
+        data: new Uint8Array([212]),
+        timestamp,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(44, 0)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195, 212]));
+      expect(out.sampleNumber).toBe(17);
+      expect(out.movieFragmentSequenceNumber).toBe(9);
+    });
+    test("rejects fragmented MFUs without an authored DU identity", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 22222n;
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 55,
+          fragmentCounter: 2,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(55, 2)
+        }),
+        "missing-data-unit-identity"
+      );
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects fragmented MFUs without an authored packet sequence", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 55,
+          fragmentCounter: 1,
+          itemId: 1,
+          data: new Uint8Array([161]),
+          timestamp: 22222n,
+          rapFlag: true
+        }),
+        "missing-packet-sequence"
+      );
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects fragmented MFUs whose authored packet sequence is not u32", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      for (const packetSequenceNumber of [-1, 4294967296, 1.5, Number.NaN]) {
+        expectRejection(
+          () => reassembler.addFragment({
+            fragmentationIndicator: 1,
+            mpuSequenceNumber: 55,
+            fragmentCounter: 1,
+            itemId: 1,
+            data: new Uint8Array([161]),
+            timestamp: 22222n,
+            rapFlag: true,
+            packetSequenceNumber
+          }),
+          "missing-packet-sequence"
+        );
+      }
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("a packet sequence gap inside a fragmented DU splits it and never completes", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 66666n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 80,
+          fragmentCounter: 3,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 1e3,
+          data: new Uint8Array([160]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      for (const [counter, psn] of [
+        [2, 1002],
+        [1, 1003]
+      ]) {
+        expect(
+          reassembler.addFragment({
+            fragmentationIndicator: 2,
+            mpuSequenceNumber: 80,
+            fragmentCounter: counter,
+            packetSequenceNumber: psn,
+            data: new Uint8Array([160 + counter]),
+            timestamp,
+            rapFlag: false
+          })
+        ).toBeNull();
+      }
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 80,
+          fragmentCounter: 0,
+          packetSequenceNumber: 1004,
+          data: new Uint8Array([177]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.getStatus().pendingFragments).toBe(4);
+      expect(reassembler.stats.reassembledMFUs).toBe(0);
+      expect(reassembler.stats.rejectedFragments).toBe(0);
+    });
+    test("keeps adjacent MFUs with equal countdowns in one MPU separate", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const common = { mpuSequenceNumber: 80, packetId: 7, timestamp: 66666n };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          packetSequenceNumber: 100,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          data: new Uint8Array([161]),
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 1,
+          packetSequenceNumber: 102,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 2,
+          sampleOffset: 0,
+          data: new Uint8Array([177]),
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      const earlier = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        packetSequenceNumber: 101,
+        data: new Uint8Array([162]),
+        rapFlag: false
+      });
+      expect(earlier?.data).toEqual(new Uint8Array([161, 162]));
+      expect(earlier?.packetSequenceNumbers).toEqual([100, 101]);
+      const later = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        packetSequenceNumber: 103,
+        data: new Uint8Array([178]),
+        rapFlag: false
+      });
+      expect(later?.data).toEqual(new Uint8Array([177, 178]));
+      expect(later?.packetSequenceNumbers).toEqual([102, 103]);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("wraps the fragmented run coordinate at u32 packet sequence", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 81,
+          fragmentCounter: 1,
+          packetSequenceNumber: 4294967295,
+          itemId: 1,
+          data: new Uint8Array([161]),
+          timestamp: 66666n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 81,
+          fragmentCounter: 0,
+          packetSequenceNumber: 0,
+          data: new Uint8Array([162]),
+          timestamp: 66667n,
+          rapFlag: false
+        })?.data
+      ).toEqual(new Uint8Array([161, 162]));
+    });
+    test("dedupes recovered copies by ISO fragment-counter position", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 44444n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 12,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 2e3,
+          data: new Uint8Array([161]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 1,
+          packetSequenceNumber: 2001,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 77,
+          fragmentCounter: 0,
+          packetSequenceNumber: 2002,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false
+        })
+      ).not.toBeNull();
+      reassembler.flush();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 13,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 3e3,
+          data: new Uint8Array([212]),
+          timestamp,
+          rapFlag: true
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 1,
+          packetSequenceNumber: 3001,
+          data: new Uint8Array([229]),
+          timestamp,
+          rapFlag: false
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 78,
+          fragmentCounter: 1,
+          packetSequenceNumber: 3001,
+          data: new Uint8Array([229]),
+          timestamp,
+          rapFlag: false
+        }),
+        "fragment-counter-mismatch"
+      );
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 78,
+        fragmentCounter: 0,
+        packetSequenceNumber: 3002,
+        data: new Uint8Array([246]),
+        timestamp,
+        rapFlag: false
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([212, 229, 246]));
+    });
+    test("reassembles middle and terminal continuations that arrive before first", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 54321n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 45,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(45, 1)
+        })
+      ).toBeNull();
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 45,
+          fragmentCounter: 0,
+          data: new Uint8Array([195]),
+          timestamp: timestamp + 1n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(45, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 45,
+        fragmentCounter: 2,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(45, 2)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(out.sampleNumber).toBe(18);
+      expect(out.movieFragmentSequenceNumber).toBe(10);
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects a duplicate continuation before first without replacing retained media", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const timestamp = 54322n;
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 0,
+          data: new Uint8Array([195]),
+          timestamp,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 0)
+        })
+      ).toBeNull();
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 0,
+          data: new Uint8Array([255]),
+          timestamp: timestamp + 1n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 0)
+        }),
+        "fragment-counter-mismatch"
+      );
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 46,
+          fragmentCounter: 1,
+          data: new Uint8Array([178]),
+          timestamp: timestamp + 2n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(46, 1)
+        })
+      ).toBeNull();
+      const out = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 46,
+        fragmentCounter: 2,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 19,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: timestamp + 3n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(46, 2)
+      });
+      expect(out).not.toBeNull();
+      expect(out.data).toEqual(new Uint8Array([161, 178, 195]));
+      expect(reassembler.pendingCount).toBe(0);
+    });
+    test("rejects invalid ISO fragmentation-indicator and counter combinations", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const invalidHeaders = [
+        { fragmentationIndicator: 0, fragmentCounter: 1 },
+        { fragmentationIndicator: 3, fragmentCounter: 1 },
+        { fragmentationIndicator: 1, fragmentCounter: 0 },
+        { fragmentationIndicator: 2, fragmentCounter: 0 },
+        { fragmentationIndicator: -1, fragmentCounter: 1 },
+        { fragmentationIndicator: 4, fragmentCounter: 1 },
+        { fragmentationIndicator: 1.5, fragmentCounter: 1 },
+        { fragmentationIndicator: 1, fragmentCounter: -1 },
+        { fragmentationIndicator: 1, fragmentCounter: 256 },
+        { fragmentationIndicator: 1, fragmentCounter: 1.5 },
+        { fragmentationIndicator: 1, fragmentCounter: Number.NaN }
+      ];
+      for (const header of invalidHeaders) {
+        expectRejection(
+          () => reassembler.addFragment({
+            ...header,
+            mpuSequenceNumber: 48,
+            data: new Uint8Array([161]),
+            timestamp: 54324n,
+            rapFlag: false
+          }),
+          "invalid-fragment-state"
+        );
+      }
+      expect(reassembler.pendingCount).toBe(0);
+      expect(reassembler.stats.reassembledMFUs).toBe(0);
+    });
+    test("reassembles the maximum ISO chain of 256 payloads", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null });
+      const common = {
+        mpuSequenceNumber: 47,
+        timestamp: 54323n,
+        rapFlag: false
+      };
+      expect(
+        reassembler.addFragment({
+          ...common,
+          fragmentationIndicator: 1,
+          fragmentCounter: 255,
+          itemId: 1,
+          data: new Uint8Array([0]),
+          rapFlag: true,
+          packetSequenceNumber: testPacketSequence(47, 255)
+        })
+      ).toBeNull();
+      for (let counter = 254; counter > 0; counter--) {
+        expect(
+          reassembler.addFragment({
+            ...common,
+            fragmentationIndicator: 2,
+            fragmentCounter: counter,
+            data: new Uint8Array([255 - counter]),
+            packetSequenceNumber: testPacketSequence(47, counter)
+          })
+        ).toBeNull();
+      }
+      const out = reassembler.addFragment({
+        ...common,
+        fragmentationIndicator: 3,
+        fragmentCounter: 0,
+        data: new Uint8Array([255]),
+        packetSequenceNumber: testPacketSequence(47, 0)
+      });
+      expect(out?.fragmentCount).toBe(256);
+      expect(out?.data).toEqual(Uint8Array.from({ length: 256 }, (_, index) => index));
+    });
+    test("should not reassemble without last fragment (FI=3)", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 2,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 2)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([2]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+    });
+    test("bounds continuations that arrive before their first fragments", () => {
+      const reassembler = new MFUReassembler({
+        timeoutMs: null,
+        maxBuffered: 1
+      });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 0,
+          data: new Uint8Array([1]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(1, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 0,
+          data: new Uint8Array([2]),
+          timestamp: 1000n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(2, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+      expect(reassembler.getStatus().pendingFragments).toBe(1);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      const completed = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 1,
+        itemId: 2,
+        data: new Uint8Array([4]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(2, 1)
+      });
+      expect(completed?.data).toEqual(new Uint8Array([4, 2]));
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      expect(reassembler.pendingCount).toBe(0);
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([3]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expect(result).toBeNull();
+      expect(reassembler.pendingCount).toBe(1);
+    });
+    test("expires a continuation that never receives its first fragment", () => {
+      vi.useFakeTimers();
+      try {
+        const reassembler = new MFUReassembler({
+          timeoutMs: 50,
+          maxBuffered: 1
         });
-        test('should track pending count', () => {
-            const reassembler = new MFUReassembler();
-            expect(reassembler.pendingCount).toBe(0);
-            reassembler.addFragment({
-                fragmentationIndicator: 1,
-                mpuSequenceNumber: 1,
-                fragmentCounter: 0,
-                data: new Uint8Array([1]),
-                timestamp: 1000n,
-                receivedAt: 0,
-                rapFlag: false,
-            });
-            expect(reassembler.pendingCount).toBe(1);
-            reassembler.flush();
-            expect(reassembler.pendingCount).toBe(0);
+        expect(
+          reassembler.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 1,
+            fragmentCounter: 0,
+            data: new Uint8Array([1]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(1, 0)
+          })
+        ).toBeNull();
+        vi.advanceTimersByTime(50);
+        expect(reassembler.pendingCount).toBe(0);
+        expect(reassembler.stats.timedOutMFUs).toBe(1);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+    test("retimes retained continuations when the timeout policy changes", () => {
+      vi.useFakeTimers();
+      try {
+        const enabled = new MFUReassembler({ timeoutMs: null, maxBuffered: 1 });
+        expect(
+          enabled.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 1,
+            fragmentCounter: 0,
+            data: new Uint8Array([1]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(1, 0)
+          })
+        ).toBeNull();
+        enabled.timeoutMs = 10;
+        vi.advanceTimersByTime(10);
+        expect(enabled.pendingCount).toBe(0);
+        const disabled = new MFUReassembler({ timeoutMs: 10, maxBuffered: 1 });
+        expect(
+          disabled.addFragment({
+            fragmentationIndicator: 3,
+            mpuSequenceNumber: 2,
+            fragmentCounter: 0,
+            data: new Uint8Array([2]),
+            timestamp: 1000n,
+            rapFlag: false,
+            packetSequenceNumber: testPacketSequence(2, 0)
+          })
+        ).toBeNull();
+        disabled.timeoutMs = null;
+        vi.advanceTimersByTime(10);
+        expect(disabled.pendingCount).toBe(1);
+        disabled.flush();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+    test("bounds active data units by evicting the oldest at maxBuffered", () => {
+      const reassembler = new MFUReassembler({
+        timeoutMs: 1e3,
+        maxBuffered: 2
+      });
+      for (let i = 0; i < 2; i++) {
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: i,
+          fragmentCounter: 1,
+          itemId: i,
+          data: new Uint8Array([i]),
+          timestamp: BigInt(i * 100),
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(i, 1)
         });
+      }
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 2,
+          fragmentCounter: 1,
+          itemId: 2,
+          data: new Uint8Array([2]),
+          timestamp: 200n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(2, 1)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(1);
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 3,
+          mpuSequenceNumber: 0,
+          fragmentCounter: 0,
+          data: new Uint8Array([9]),
+          timestamp: 300n,
+          rapFlag: false,
+          packetSequenceNumber: testPacketSequence(0, 0)
+        })
+      ).toBeNull();
+      expect(reassembler.pendingCount).toBe(2);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(2);
+      expect(reassembler.stats.timedOutMFUs).toBe(0);
     });
+    test("should report stats correctly", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 1000n,
+        rapFlag: false
+      });
+      const status = reassembler.getStatus();
+      expect(status.bufferedMFUs).toBe(0);
+      expect(status.stats.totalFragments).toBe(1);
+      expect(status.stats.reassembledMFUs).toBe(1);
+    });
+    test("rejects an overlapping first without replacing the original fragment", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      expectRejection(
+        () => reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 1,
+          fragmentCounter: 1,
+          itemId: 2,
+          data: new Uint8Array([187]),
+          timestamp: 1000n,
+          rapFlag: true,
+          source: "moq",
+          packetSequenceNumber: testPacketSequence(1, 1)
+        }),
+        "overlapping-data-unit"
+      );
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.data).toEqual(new Uint8Array([170, 204]));
+      expect(result.fragmentCount).toBe(2);
+      expect(result.source).toBe("multicast");
+    });
+  });
+  test("should retain an assembly with a gap in fragment counters", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 3,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(1, 3)
+    });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([221]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 0)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    expect(reassembler.getStatus().pendingFragments).toBe(3);
+  });
+  test("accepts a reordered countdown and rejects a stale duplicate", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 3,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(1, 3)
+    });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 2,
+        data: new Uint8Array([187]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 2)
+      })
+    ).toBeNull();
+    expectRejection(
+      () => reassembler.addFragment({
+        fragmentationIndicator: 2,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(1, 1)
+      }),
+      "fragment-counter-mismatch"
+    );
+    const result = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 1,
+      fragmentCounter: 0,
+      data: new Uint8Array([221]),
+      timestamp: 1002n,
+      rapFlag: false,
+      packetSequenceNumber: testPacketSequence(1, 0)
+    });
+    expect(result).not.toBeNull();
+    expect(result.data).toEqual(new Uint8Array([170, 187, 204, 221]));
+    expect(result.fragmentCount).toBe(4);
+  });
+  test("rejects an overlapping first without discarding queued continuations", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    const fragment = (fragmentationIndicator, fragmentCounter, byte) => ({
+      fragmentationIndicator,
+      mpuSequenceNumber: 2,
+      fragmentCounter,
+      data: new Uint8Array([byte]),
+      timestamp: 1000n,
+      rapFlag: fragmentationIndicator === 1,
+      packetSequenceNumber: testPacketSequence(2, fragmentCounter),
+      ...fragmentationIndicator === 1 ? { itemId: 9 } : {}
+    });
+    expect(reassembler.addFragment(fragment(1, 3, 170))).toBeNull();
+    expect(reassembler.addFragment(fragment(2, 1, 204))).toBeNull();
+    expectRejection(() => reassembler.addFragment(fragment(1, 1, 238)), "overlapping-data-unit");
+    expect(reassembler.addFragment(fragment(2, 2, 187))).toBeNull();
+    expect(reassembler.addFragment(fragment(3, 0, 221))?.data).toEqual(new Uint8Array([170, 187, 204, 221]));
+  });
+  test("rejects a duplicate emitted intrinsic identity", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 0,
+        data: new Uint8Array([171]),
+        timestamp: 1001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(42, 0)
+      })
+    ).not.toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 0,
+        data: new Uint8Array([188]),
+        timestamp: 1002n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(42, 0, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([187]),
+        timestamp: 2000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(1);
+    const result = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 43,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([204]),
+      timestamp: 2000n,
+      rapFlag: false,
+      packetSequenceNumber: testPacketSequence(43, 1)
+    });
+    expect(result).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 43,
+        fragmentCounter: 0,
+        data: new Uint8Array([221]),
+        timestamp: 2001n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(43, 0)
+      })?.data
+    ).toEqual(new Uint8Array([204, 221]));
+  });
+  test("does not create active state for an emitted identity duplicate", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 1,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(50, 1)
+      })
+    ).toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 0,
+        data: new Uint8Array([178]),
+        timestamp: 1000n,
+        rapFlag: false,
+        packetSequenceNumber: testPacketSequence(50, 0)
+      })?.data
+    ).toEqual(new Uint8Array([161, 178]));
+    expect(reassembler.pendingCount).toBe(0);
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 50,
+        fragmentCounter: 1,
+        movieFragmentSequenceNumber: 10,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        data: new Uint8Array([161]),
+        timestamp: 2000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(50, 1, 10)
+      })
+    ).toBeNull();
+    expect(reassembler.pendingCount).toBe(0);
+  });
+  test("flush should clear emitted set and allow re-assembly", () => {
+    const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+    const first = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([170]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 1)
+    });
+    expect(first).toBeNull();
+    const assembled = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 0,
+      data: new Uint8Array([187]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 0)
+    });
+    expect(assembled).not.toBeNull();
+    expect(
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 42,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: true,
+        packetSequenceNumber: testPacketSequence(42, 1, 10)
+      })
+    ).toBeNull();
+    reassembler.flush();
+    const r2 = reassembler.addFragment({
+      fragmentationIndicator: 1,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 1,
+      itemId: 1,
+      data: new Uint8Array([221]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 1)
+    });
+    expect(r2).toBeNull();
+    const r3 = reassembler.addFragment({
+      fragmentationIndicator: 3,
+      mpuSequenceNumber: 42,
+      fragmentCounter: 0,
+      data: new Uint8Array([238]),
+      timestamp: 1000n,
+      rapFlag: true,
+      packetSequenceNumber: testPacketSequence(42, 0)
+    });
+    expect(r3).not.toBeNull();
+    expect(r3.data).toEqual(new Uint8Array([221, 238]));
+  });
+  describe("createFragment", () => {
+    test("should create fragment from complete timed MMTP packet", () => {
+      const packet = new Uint8Array(12 + 8 + 14 + 5);
+      packet[0] = 1;
+      packet[1] = 0;
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 42, false);
+      view.setUint32(8, 100, false);
+      view.setUint16(12, 25, false);
+      packet[14] = 40;
+      packet[15] = 0;
+      view.setUint32(16, 999, false);
+      view.setUint32(20, 7, false);
+      view.setUint32(24, 1, false);
+      packet[34] = 222;
+      packet[35] = 173;
+      packet[36] = 190;
+      packet[37] = 239;
+      packet[38] = 1;
+      const frag = createFragment(packet);
+      expect(frag.mpuSequenceNumber).toBe(999);
+      expect(frag.fragmentationIndicator).toBe(0);
+      expect(frag.rapFlag).toBe(true);
+      expect(frag.movieFragmentSequenceNumber).toBe(7);
+      expect(frag.sampleNumber).toBe(1);
+      expect(frag.sampleOffset).toBe(0);
+      expect(frag.data.length).toBe(5);
+    });
+    test("reads Item_ID from a non-timed MFU DU header", () => {
+      const packet = new Uint8Array(12 + 8 + 4 + 2);
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 42, false);
+      view.setUint32(8, 100, false);
+      view.setUint16(12, 12, false);
+      packet[14] = 32;
+      view.setUint32(16, 999, false);
+      view.setUint32(20, 16909060, false);
+      packet.set([222, 173], 24);
+      const fragment = createFragment(packet);
+      expect(fragment.itemId).toBe(16909060);
+      expect(fragment.data).toEqual(new Uint8Array([222, 173]));
+    });
+  });
+  describe("processMMTPWithReassembly", () => {
+    test("should skip FEC repair packets", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const packet = new Uint8Array(12 + 8 + 14 + 4);
+      packet[0] = 16;
+      const result = processMMTPWithReassembly(packet, reassembler);
+      expect(result).toBeNull();
+    });
+    test("should return reassembled MFU for complete packet", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const packet = new Uint8Array(12 + 8 + 14 + 4);
+      packet[0] = 1;
+      packet[1] = 0;
+      const view = new DataView(packet.buffer);
+      view.setUint16(2, 1, false);
+      view.setUint32(4, 100, false);
+      view.setUint32(8, 1, false);
+      view.setUint16(12, 24, false);
+      packet[14] = 40;
+      view.setUint32(16, 42, false);
+      view.setUint32(20, 7, false);
+      view.setUint32(24, 1, false);
+      packet[34] = 0;
+      packet[35] = 0;
+      packet[36] = 0;
+      packet[37] = 1;
+      const result = processMMTPWithReassembly(packet, reassembler);
+      expect(result).not.toBeNull();
+      expect(result.mpuSequenceNumber).toBe(42);
+      expect(result.rapFlag).toBe(true);
+    });
+  });
+  describe("strict delivery provenance", () => {
+    test("folds to multicast only when every fragment is explicitly multicast", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, { source: "multicast" }])).toBe("multicast");
+    });
+    test("a single moq fragment makes the whole frame mixed", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, { source: "moq" }])).toBe("mixed");
+      expect(deliveryProvenanceOf([{ source: "moq" }, { source: "multicast" }])).toBe("mixed");
+    });
+    test("an unattributed fragment degrades multicast to unknown, never to proven", () => {
+      expect(deliveryProvenanceOf([{ source: "multicast" }, {}])).toBe("unknown");
+      expect(deliveryProvenanceOf([{}])).toBe("unknown");
+    });
+    test("mixed absorbs unknown \u2014 a moq byte is worse news than a missing label", () => {
+      expect(deliveryProvenanceOf([{ source: "moq" }, {}])).toBe("mixed");
+      expect(deliveryProvenanceOf([{}, { source: "moq" }])).toBe("mixed");
+    });
+    test("an empty fragment set proves nothing", () => {
+      expect(deliveryProvenanceOf([])).toBe("unknown");
+    });
+    test("the fold never upgrades a verdict", () => {
+      expect(foldDeliveryProvenance("mixed", "multicast")).toBe("mixed");
+      expect(foldDeliveryProvenance("unknown", "multicast")).toBe("unknown");
+      expect(foldDeliveryProvenance("unknown", "moq")).toBe("mixed");
+    });
+    test("a multicast head with a non-multicast tail is NOT multicast-exclusive", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 1000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(1, 1)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 1,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 1000n,
+        rapFlag: false,
+        source: "moq",
+        packetSequenceNumber: testPacketSequence(1, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.fragmentCount).toBe(2);
+      expect(result.source).toBe("multicast");
+      expect(result.deliveryProvenance).toBe("mixed");
+    });
+    test("an all-multicast fragmented frame is multicast-exclusive", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      reassembler.addFragment({
+        fragmentationIndicator: 1,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 1,
+        itemId: 1,
+        data: new Uint8Array([170]),
+        timestamp: 2000n,
+        rapFlag: true,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(2, 1)
+      });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 2,
+        fragmentCounter: 0,
+        data: new Uint8Array([204]),
+        timestamp: 2000n,
+        rapFlag: false,
+        source: "multicast",
+        packetSequenceNumber: testPacketSequence(2, 0)
+      });
+      expect(result).not.toBeNull();
+      expect(result.deliveryProvenance).toBe("multicast");
+    });
+    test("an unlabelled complete frame proves nothing", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
+      const result = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 3,
+        fragmentCounter: 0,
+        itemId: 1,
+        data: new Uint8Array([1]),
+        timestamp: 3000n,
+        rapFlag: true
+      });
+      expect(result).not.toBeNull();
+      expect(result.deliveryProvenance).toBe("unknown");
+    });
+  });
 }
-//# sourceMappingURL=mfu-reassembler.js.map
+export {
+  COMPLETED_ADDRESS_WINDOW_MULTIPLE,
+  EVICTION_GUARD_DATA_UNITS,
+  EVICTION_GUARD_MAX_BUFFERED,
+  MFUReassembler,
+  MFU_REASSEMBLY_ERROR_CODES,
+  MfuReassemblyError,
+  createFragment,
+  deliveryProvenanceOf,
+  foldDeliveryProvenance,
+  isMfuReassemblyError,
+  isMfuReassemblyErrorCode,
+  parkedRunHoldsASlot,
+  processMMTPWithReassembly
+};
+//# sourceMappingURL=mfu-reassembler.js.map