@blockcast/mmt-container 0.1.0-main.0399efef1f07

package/dist/mfu-reassembler.js

@@ -0,0 +1,3085 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// ../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
+    }
+  };
+}
+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) {
+  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;
+  try {
+    header = parseMMTPHeader(mmtpPacket);
+  } catch (error) {
+    return {
+      rejection: {
+        gate: "mmtp-header-unparseable",
+        detail: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  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) {
+  const result = planMfuExtraction(mmtpPacket, options);
+  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;
+}
+
+// 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 _buffers, _timeouts, _activeDataUnits, _pendingContinuations, _emitted, _emittedOrder, _completed, _completedOrder, _timeoutMs, _maxBuffered, _nextAdmissionSeq, _MFUReassembler_instances, addAssociatedFragment_fn, parkContinuation_fn, drainPendingContinuations_fn, unopenedParkedRunCount_fn, incompleteRunCount_fn, evictLeastRecentlyAdmitted_fn, releaseSlot_fn, reject_fn, associateDataUnit_fn, tryReassemble_fn, assemble_fn, setTimeout_fn, clearPendingTimeout_fn, armHeadlessPendingTimeout_fn, deletePendingRun_fn, onPendingTimeout_fn, clearTimeout_fn, markEmitted_fn, markCompleted_fn, orderValue_fn, removeActiveDataUnitForBuffer_fn, openRunAt_fn, onTimeout_fn, pendingDebugSamples_fn;
+var MFUReassembler = class {
+  constructor(options) {
+    __privateAdd(this, _MFUReassembler_instances);
+    // 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.
+    __privateAdd(this, _buffers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _timeouts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _activeDataUnits, /* @__PURE__ */ new Map());
+    __privateAdd(this, _pendingContinuations, /* @__PURE__ */ new Map());
+    __privateAdd(this, _emitted, /* @__PURE__ */ new Set());
+    // same sample keys, so FEC-recovered duplicate heads are dropped
+    __privateAdd(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.)
+    __privateAdd(this, _completed, /* @__PURE__ */ new Set());
+    __privateAdd(this, _completedOrder, []);
+    __privateAdd(this, _timeoutMs);
+    __privateAdd(this, _maxBuffered);
+    /**
+     * Monotonic admission ordinal. Counts slot admissions, never reads a clock,
+     * so eviction order survives on hosts that run `timeoutMs: null`.
+     */
+    __privateAdd(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");
+    }
+    __privateSet(this, _timeoutMs, options.timeoutMs);
+    __privateSet(this, _maxBuffered, maxBuffered);
+  }
+  /** 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)");
+    }
+    __privateSet(this, _timeoutMs, ms);
+    const now = Date.now();
+    for (const [bufferKey, state] of __privateGet(this, _timeouts)) {
+      if (state.timeoutId !== void 0) clearTimeout(state.timeoutId);
+      delete state.timeoutId;
+      if (ms !== null) {
+        state.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onTimeout_fn).call(this, bufferKey), Math.max(0, state.startedAt + ms - now));
+      }
+    }
+    for (const address of __privateGet(this, _pendingContinuations).keys()) {
+      __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+      __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
+    }
+  }
+  get timeoutMs() {
+    return __privateGet(this, _timeoutMs);
+  }
+  /**
+   * Add a fragment and return reassembled MFU if complete
+   */
+  addFragment(fragment) {
+    this.stats.totalFragments++;
+    if (!hasValidFragmentHeader(fragment)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "invalid-fragment-state", "invalid MFU fragmentation indicator or counter");
+    }
+    if (fragment.itemId !== void 0 && hasAnySampleIdentityField(fragment)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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) {
+        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-data-unit-identity", "complete MFU has no intrinsic DU identity");
+      }
+      if (hasSampleFields && !sampleIdentity) {
+        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-data-unit-identity", "complete MFU has an incomplete sample identity");
+      }
+      if (hasItemIdentity && !isU32(fragment.itemId)) {
+        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-packet-sequence", "fragmented MFU has no MMTP packet sequence number");
+    }
+    const address = dataUnitAddress(fragment, sequence);
+    if (fragmentationIndicator !== 1) {
+      const open = __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address);
+      if (open === void 0) {
+        if (__privateGet(this, _completed).has(address)) {
+          __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "MFU continuation names a data unit that already completed");
+        }
+        __privateMethod(this, _MFUReassembler_instances, parkContinuation_fn).call(this, address, fragment);
+        return null;
+      }
+      const [runKey2, active] = open;
+      if (active.nextFragmentCounter > fragment.fragmentCounter) {
+        __privateMethod(this, _MFUReassembler_instances, parkContinuation_fn).call(this, address, fragment);
+        return null;
+      }
+      if (active.nextFragmentCounter < fragment.fragmentCounter) {
+        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "MFU continuation is behind the authored fragment-counter countdown");
+      }
+      const result2 = __privateMethod(this, _MFUReassembler_instances, addAssociatedFragment_fn).call(this, fragment, runKey2, address);
+      if (result2 !== null) return result2;
+      return __privateMethod(this, _MFUReassembler_instances, drainPendingContinuations_fn).call(this, address, runKey2);
+    }
+    const runKey = objectKey(fragment);
+    if ((hasSampleIdentity(fragment) || isU32(fragment.itemId)) && __privateGet(this, _emitted).has(runKey)) {
+      return null;
+    }
+    if (__privateGet(this, _activeDataUnits).has(runKey)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "overlapping-data-unit", "fragmented MFU overlaps an active data unit");
+    }
+    if (__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "overlapping-data-unit", "fragmented MFU opens on an address held by an open data unit");
+    }
+    const pending = __privateGet(this, _pendingContinuations).get(address);
+    if (pending !== void 0 && [...pending.fragments.keys()].some((counter) => counter >= fragment.fragmentCounter)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "queued continuation counter is not below the authored first-fragment counter");
+    }
+    const result = __privateMethod(this, _MFUReassembler_instances, addAssociatedFragment_fn).call(this, fragment, runKey, address, pending?.startedAt);
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    if (result !== null) return result;
+    return __privateMethod(this, _MFUReassembler_instances, drainPendingContinuations_fn).call(this, address, runKey);
+  }
+  /**
+   * Flush all buffered fragments
+   */
+  flush() {
+    for (const key of __privateGet(this, _buffers).keys()) {
+      __privateMethod(this, _MFUReassembler_instances, clearTimeout_fn).call(this, key);
+    }
+    __privateGet(this, _buffers).clear();
+    __privateGet(this, _timeouts).clear();
+    __privateGet(this, _activeDataUnits).clear();
+    for (const address of __privateGet(this, _pendingContinuations).keys()) {
+      __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    }
+    __privateGet(this, _pendingContinuations).clear();
+    __privateGet(this, _emitted).clear();
+    __privateGet(this, _emittedOrder).length = 0;
+    __privateGet(this, _completed).clear();
+    __privateGet(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 __privateGet(this, _buffers)) {
+      if (fragments.some((fragment) => fragment.catalogTrackName === catalogTrackName)) {
+        discarded.add(key);
+      }
+    }
+    for (const [objectKey2, active] of __privateGet(this, _activeDataUnits)) {
+      if (active.catalogTrackName === catalogTrackName) {
+        discarded.add(active.bufferKey);
+        __privateGet(this, _activeDataUnits).delete(objectKey2);
+      }
+    }
+    for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
+      if ([...pending.fragments.values()].some((fragment) => fragment.catalogTrackName === catalogTrackName) || belongsToStream(address))
+        __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
+    }
+    for (const key of __privateGet(this, _emitted)) {
+      if (belongsToStream(key)) discarded.add(key);
+    }
+    for (const key of discarded) {
+      __privateMethod(this, _MFUReassembler_instances, clearTimeout_fn).call(this, key);
+      __privateGet(this, _buffers).delete(key);
+      __privateGet(this, _emitted).delete(key);
+    }
+    __privateSet(this, _emittedOrder, __privateGet(this, _emittedOrder).filter((key) => !discarded.has(key)));
+    for (const address of __privateGet(this, _completed)) {
+      if (belongsToStream(address)) __privateGet(this, _completed).delete(address);
+    }
+    __privateSet(this, _completedOrder, __privateGet(this, _completedOrder).filter((address) => __privateGet(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 __privateGet(this, _buffers).size + __privateMethod(this, _MFUReassembler_instances, unopenedParkedRunCount_fn).call(this);
+  }
+  /**
+   * Get current buffer status
+   */
+  getStatus() {
+    let pendingFragments = 0;
+    for (const fragments of __privateGet(this, _buffers).values()) {
+      pendingFragments += fragments.length;
+    }
+    for (const pending of __privateGet(this, _pendingContinuations).values()) {
+      pendingFragments += pending.fragments.size;
+    }
+    return {
+      bufferedMFUs: this.pendingCount,
+      pendingFragments,
+      pendingSamples: __privateMethod(this, _MFUReassembler_instances, pendingDebugSamples_fn).call(this),
+      stats: { ...this.stats }
+    };
+  }
+};
+_buffers = new WeakMap();
+_timeouts = new WeakMap();
+_activeDataUnits = new WeakMap();
+_pendingContinuations = new WeakMap();
+_emitted = new WeakMap();
+_emittedOrder = new WeakMap();
+_completed = new WeakMap();
+_completedOrder = new WeakMap();
+_timeoutMs = new WeakMap();
+_maxBuffered = new WeakMap();
+_nextAdmissionSeq = new WeakMap();
+_MFUReassembler_instances = new WeakSet();
+addAssociatedFragment_fn = function(fragment, runKey, address, startedAt) {
+  const association = __privateMethod(this, _MFUReassembler_instances, associateDataUnit_fn).call(this, fragment, runKey, address);
+  const { bufferKey, first, terminal } = association;
+  let fragments = __privateGet(this, _buffers).get(bufferKey);
+  if (first) {
+    if (fragments !== void 0) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "overlapping-data-unit", "intrinsic data-unit buffer already exists");
+    }
+    fragments = [];
+    __privateGet(this, _buffers).set(bufferKey, fragments);
+  } else if (fragments === void 0) {
+    throw new Error("[MFUReassembler] active data unit has no fragment buffer");
+  }
+  if (first) __privateMethod(this, _MFUReassembler_instances, setTimeout_fn).call(this, bufferKey, startedAt);
+  fragments.push(fragment);
+  if (!terminal) return null;
+  const result = __privateMethod(this, _MFUReassembler_instances, tryReassemble_fn).call(this, bufferKey);
+  __privateGet(this, _activeDataUnits).delete(runKey);
+  if (result === null) {
+    __privateMethod(this, _MFUReassembler_instances, clearTimeout_fn).call(this, bufferKey);
+    __privateGet(this, _buffers).delete(bufferKey);
+    __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "incomplete-terminal-fragment", "validated terminal fragment did not complete its data unit");
+  }
+  __privateMethod(this, _MFUReassembler_instances, markCompleted_fn).call(this, address);
+  return result;
+};
+parkContinuation_fn = function(address, fragment) {
+  let pending = __privateGet(this, _pendingContinuations).get(address);
+  const open = __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address);
+  const alreadyCharged = open !== void 0 || parkedRunHoldsASlot(open !== void 0, pending?.fragments.size ?? 0);
+  if (!alreadyCharged && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
+    if (!__privateMethod(this, _MFUReassembler_instances, evictLeastRecentlyAdmitted_fn).call(this)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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 : __privateWrapper(this, _nextAdmissionSeq)._++
+    };
+    __privateGet(this, _pendingContinuations).set(address, pending);
+    armAfterInsert = true;
+  } else if (!alreadyCharged) {
+    pending.admissionSeq = __privateWrapper(this, _nextAdmissionSeq)._++;
+    pending.startedAt = Date.now();
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    armAfterInsert = true;
+  }
+  if (pending.fragments.has(fragment.fragmentCounter)) {
+    __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "duplicate queued continuation counter would replace retained media");
+  }
+  pending.fragments.set(fragment.fragmentCounter, fragment);
+  if (armAfterInsert) __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
+};
+drainPendingContinuations_fn = function(address, runKey) {
+  while (true) {
+    const active = __privateGet(this, _activeDataUnits).get(runKey);
+    const pending = __privateGet(this, _pendingContinuations).get(address);
+    if (active === void 0) {
+      if (pending?.fragments.size === 0) __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
+      return null;
+    }
+    const fragment = pending?.fragments.get(active.nextFragmentCounter);
+    if (fragment === void 0) {
+      if (pending?.fragments.size === 0) __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
+      return null;
+    }
+    pending.fragments.delete(active.nextFragmentCounter);
+    if (pending.fragments.size === 0) __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
+    const result = __privateMethod(this, _MFUReassembler_instances, addAssociatedFragment_fn).call(this, 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_fn = function() {
+  let count = 0;
+  for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
+    if (parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, 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_fn = function() {
+  return __privateGet(this, _activeDataUnits).size + __privateMethod(this, _MFUReassembler_instances, unopenedParkedRunCount_fn).call(this);
+};
+/**
+ * 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_fn = function() {
+  let victimAddress;
+  let victimSeq = Number.POSITIVE_INFINITY;
+  for (const [, active] of __privateGet(this, _activeDataUnits)) {
+    if (active.admissionSeq < victimSeq) {
+      victimSeq = active.admissionSeq;
+      victimAddress = active.address;
+    }
+  }
+  for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
+    if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+      continue;
+    }
+    if (pending.admissionSeq < victimSeq) {
+      victimSeq = pending.admissionSeq;
+      victimAddress = address;
+    }
+  }
+  if (victimAddress === void 0) return false;
+  __privateMethod(this, _MFUReassembler_instances, releaseSlot_fn).call(this, 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_fn = function(address) {
+  const open = __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address);
+  if (open !== void 0) {
+    const [runKey, active] = open;
+    __privateGet(this, _activeDataUnits).delete(runKey);
+    __privateMethod(this, _MFUReassembler_instances, clearTimeout_fn).call(this, active.bufferKey);
+    __privateGet(this, _buffers).delete(active.bufferKey);
+  }
+  __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
+};
+reject_fn = function(code, message) {
+  this.stats.rejectedFragments++;
+  throw new MfuReassemblyError(code, message);
+};
+associateDataUnit_fn = function(fragment, runKey, address) {
+  const fi = fragment.fragmentationIndicator;
+  if (fi === 1) {
+    const parked = __privateGet(this, _pendingContinuations).get(address);
+    const inheritsParkedSlot = parkedRunHoldsASlot(
+      __privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0,
+      parked?.fragments.size ?? 0
+    );
+    const sampleIdentity = hasSampleIdentity(fragment);
+    const hasSampleFields = hasAnySampleIdentityField(fragment);
+    const hasItemIdentity = fragment.itemId !== void 0;
+    if (sampleIdentity && hasItemIdentity) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "conflicting-data-unit-identity", "fragmented MFU carries timed and non-timed DU identities");
+    }
+    if (!sampleIdentity && !hasItemIdentity) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-data-unit-identity", "first fragment has no intrinsic DU identity");
+    }
+    if (hasSampleFields && !sampleIdentity) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-data-unit-identity", "first fragment has an incomplete sample identity");
+    }
+    if (hasItemIdentity && !isU32(fragment.itemId)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "missing-data-unit-identity", "first fragment has an invalid Item_ID");
+    }
+    const bufferKey = objectKey(fragment);
+    if (__privateGet(this, _buffers).has(bufferKey)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "overlapping-data-unit", "intrinsic data-unit buffer already exists");
+    }
+    let sampleEnd = null;
+    if (sampleIdentity) {
+      sampleEnd = checkedSampleEnd(fragment.sampleOffset, fragment.data.byteLength);
+      if (sampleEnd === null) __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "offset-overflow", "sample byte offset overflow");
+    }
+    if (!inheritsParkedSlot && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
+      if (!__privateMethod(this, _MFUReassembler_instances, evictLeastRecentlyAdmitted_fn).call(this)) {
+        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "active-data-unit-limit", "active MFU data-unit limit reached");
+      }
+    }
+    const admissionSeq = inheritsParkedSlot ? parked.admissionSeq : __privateWrapper(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 }
+      };
+    }
+    __privateGet(this, _activeDataUnits).set(objectKey(fragment), active2);
+    return { bufferKey, first: true, terminal: false };
+  }
+  const active = __privateGet(this, _activeDataUnits).get(runKey);
+  if (active === void 0) {
+    throw new Error("[MFUReassembler] continuation was not parked before association");
+  }
+  if (fragment.fragmentCounter !== active.nextFragmentCounter) {
+    __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "MFU continuation does not follow the authored fragment-counter countdown");
+  }
+  if (active.kind === "sample") {
+    if (fragment.itemId !== void 0) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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)) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "data-unit-identity-mismatch", "sample continuation identity does not match");
+    }
+    const nextOffset = checkedSampleEnd(active.nextOffset, fragment.data.byteLength);
+    if (nextOffset === null) __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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) {
+      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "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_fn = function(bufferKey) {
+  const fragments = __privateGet(this, _buffers).get(bufferKey);
+  if (!fragments || fragments.length === 0) {
+    return null;
+  }
+  const sorted = [...fragments].sort((a, b) => __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, a) - __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, b));
+  if (sorted[0].fragmentationIndicator !== 1 || sorted[sorted.length - 1].fragmentationIndicator !== 3) {
+    return null;
+  }
+  if (sorted.slice(1, -1).some((fragment) => fragment.fragmentationIndicator !== 2)) {
+    return null;
+  }
+  for (let i = 1; i < sorted.length; i++) {
+    if (__privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, sorted[i]) !== __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, sorted[i - 1]) + 1) {
+      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;
+      }
+    }
+  }
+  fragments.splice(0, fragments.length, ...sorted);
+  return __privateMethod(this, _MFUReassembler_instances, assemble_fn).call(this, bufferKey, fragments);
+};
+assemble_fn = function(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;
+  }
+  __privateMethod(this, _MFUReassembler_instances, clearTimeout_fn).call(this, bufferKey);
+  __privateGet(this, _buffers).delete(bufferKey);
+  __privateMethod(this, _MFUReassembler_instances, markEmitted_fn).call(this, bufferKey);
+  this.stats.reassembledMFUs++;
+  return {
+    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
+  };
+};
+setTimeout_fn = function(bufferKey, startedAt = Date.now()) {
+  const state = { startedAt };
+  if (__privateGet(this, _timeoutMs) !== null) {
+    state.timeoutId = setTimeout(
+      () => __privateMethod(this, _MFUReassembler_instances, onTimeout_fn).call(this, bufferKey),
+      Math.max(0, startedAt + __privateGet(this, _timeoutMs) - Date.now())
+    );
+  }
+  __privateGet(this, _timeouts).set(bufferKey, state);
+};
+clearPendingTimeout_fn = function(address) {
+  const pending = __privateGet(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_fn = function(address) {
+  const pending = __privateGet(this, _pendingContinuations).get(address);
+  if (pending === void 0 || pending.timeoutId !== void 0 || __privateGet(this, _timeoutMs) === null) return;
+  if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) return;
+  pending.timeoutId = setTimeout(
+    () => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address),
+    Math.max(0, pending.startedAt + __privateGet(this, _timeoutMs) - Date.now())
+  );
+};
+deletePendingRun_fn = function(address) {
+  __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+  __privateGet(this, _pendingContinuations).delete(address);
+};
+onPendingTimeout_fn = function(address) {
+  const pending = __privateGet(this, _pendingContinuations).get(address);
+  if (pending === void 0) return;
+  if (!parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    return;
+  }
+  this.stats.timedOutMFUs++;
+  console.warn(
+    `[MfuReassembler] timeout: run=${address} fragments=${pending.fragments.size} (continuations awaiting first fragment, discarded)`
+  );
+  __privateGet(this, _pendingContinuations).delete(address);
+};
+clearTimeout_fn = function(bufferKey) {
+  const state = __privateGet(this, _timeouts).get(bufferKey);
+  if (state !== void 0) {
+    if (state.timeoutId !== void 0) clearTimeout(state.timeoutId);
+    __privateGet(this, _timeouts).delete(bufferKey);
+  }
+};
+markEmitted_fn = function(bufferKey) {
+  if (__privateGet(this, _emitted).has(bufferKey)) return;
+  __privateGet(this, _emitted).add(bufferKey);
+  __privateGet(this, _emittedOrder).push(bufferKey);
+  while (__privateGet(this, _emittedOrder).length > __privateGet(this, _maxBuffered)) {
+    const oldest = __privateGet(this, _emittedOrder).shift();
+    if (oldest !== void 0) __privateGet(this, _emitted).delete(oldest);
+  }
+};
+markCompleted_fn = function(address) {
+  if (__privateGet(this, _completed).has(address)) return;
+  __privateGet(this, _completed).add(address);
+  __privateGet(this, _completedOrder).push(address);
+  const cap = __privateGet(this, _maxBuffered) * COMPLETED_ADDRESS_WINDOW_MULTIPLE;
+  while (__privateGet(this, _completedOrder).length > cap) {
+    const oldest = __privateGet(this, _completedOrder).shift();
+    if (oldest !== void 0) __privateGet(this, _completed).delete(oldest);
+  }
+};
+orderValue_fn = function(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_fn = function(bufferKey) {
+  for (const [objectKey2, active] of __privateGet(this, _activeDataUnits)) {
+    if (active.bufferKey === bufferKey) {
+      __privateGet(this, _activeDataUnits).delete(objectKey2);
+      __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, 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_fn = function(address) {
+  for (const entry of __privateGet(this, _activeDataUnits)) {
+    if (entry[1].address === address) return entry;
+  }
+  return void 0;
+};
+onTimeout_fn = function(bufferKey) {
+  const fragments = __privateGet(this, _buffers).get(bufferKey);
+  if (!fragments || fragments.length === 0) {
+    __privateGet(this, _buffers).delete(bufferKey);
+    __privateGet(this, _timeouts).delete(bufferKey);
+    __privateMethod(this, _MFUReassembler_instances, removeActiveDataUnitForBuffer_fn).call(this, 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)`);
+  __privateGet(this, _buffers).delete(bufferKey);
+  __privateGet(this, _timeouts).delete(bufferKey);
+  __privateMethod(this, _MFUReassembler_instances, removeActiveDataUnitForBuffer_fn).call(this, bufferKey);
+};
+pendingDebugSamples_fn = function() {
+  const out = [];
+  for (const [key, fragments] of __privateGet(this, _buffers)) {
+    if (fragments.length === 0) continue;
+    const sorted = [...fragments].sort((a, b) => __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, a) - __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, 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: __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, 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: __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, sorted[0]),
+      lastOrder: __privateMethod(this, _MFUReassembler_instances, orderValue_fn).call(this, 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;
+  }
+  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
+  };
+}
+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
+        });
+        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");
+    });
+  });
+}
+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