@blockcast/mmt-container 0.1.0-main.149f78a4adae → 0.1.0-main.1fa0d55ca4da

package/dist/browser-runtime.js

@@ -126,7 +126,7 @@ var init_fec_worker_client = __esm({
        */
       feedSource(ssId, data, ts, alta) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] feedSource on a disposed client");
         const cmd = alta ? {
           type: "feedSource",
           ssId,
@@ -149,7 +149,7 @@ var init_fec_worker_client = __esm({
        */
       feedRepair(ssStart, ssbLength, rsId, data, ts) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] feedRepair on a disposed client");
         __privateGet(this, _worker).postMessage({
           type: "feedRepair",
           ssStart,
@@ -164,7 +164,7 @@ var init_fec_worker_client = __esm({
        */
       relayBlockSig(sbn, sig, hash) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] relayBlockSig on a disposed client");
         __privateGet(this, _worker).postMessage({ type: "relayBlockSig", sbn, sig, hash }, [sig, hash]);
       }
       /**
@@ -175,7 +175,7 @@ var init_fec_worker_client = __esm({
        */
       cleanup(currentSbn) {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] cleanup on a disposed client");
         if (!Number.isInteger(currentSbn) || currentSbn < 0 || currentSbn > 4294967295) {
           throw new Error("[FecWorkerClient] cleanup: SBN must be a uint32");
         }
@@ -188,7 +188,7 @@ var init_fec_worker_client = __esm({
       /** Reset this track's decoder epoch while preserving Worker configuration. */
       reset() {
         if (__privateGet(this, _disposed5))
-          return;
+          throw new Error("[FecWorkerClient] reset on a disposed client");
         __privateWrapper(this, _pendingResets)._++;
         __privateSet(this, _cleanupInFlight, null);
         __privateGet(this, _queuedCleanupSbns).clear();
@@ -218,6 +218,15 @@ var init_fec_worker_client = __esm({
       onError(cb) {
         __privateSet(this, _onError, cb);
       }
+      /**
+       * True once dispose() ran. A disposed client cannot decode, fill, or
+       * acknowledge anything, so routing symbols to it discards them; every
+       * command method (feedSource, feedRepair, relayBlockSig, cleanup, reset)
+       * throws rather than pretend otherwise. Callers check this first.
+       */
+      get disposed() {
+        return __privateGet(this, _disposed5);
+      }
       /**
        * Dispose the Worker. Sends dispose command then terminates.
        * Idempotent — safe to call multiple times.
@@ -920,7 +929,8 @@ var MFU_REASSEMBLY_ERROR_CODES = [
   "data-unit-identity-mismatch",
   "offset-overflow",
   "active-data-unit-limit",
-  "incomplete-terminal-fragment"
+  "incomplete-terminal-fragment",
+  "ambiguous-continuation"
 ];
 var mfuReassemblyErrorCodes = new Set(MFU_REASSEMBLY_ERROR_CODES);
 function isMfuReassemblyErrorCode(value) {
@@ -933,6 +943,11 @@ var MfuReassemblyError = class extends Error {
     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 = [];
@@ -962,15 +977,11 @@ function streamScope(fragment) {
 function isU32(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 4294967295;
 }
-function fragmentRunKey(fragment) {
-  if (!isU32(fragment.packetSequenceNumber)) {
-    throw new Error("[MFUReassembler] fragmented value has no validated packet sequence");
-  }
-  const terminalPacketSequence = (fragment.packetSequenceNumber + fragment.fragmentCounter) % 4294967296;
+function dataUnitAddress(fragment, packetSequenceNumber) {
   return JSON.stringify([
     ...streamScope(fragment),
     fragment.mpuSequenceNumber,
-    terminalPacketSequence
+    packetSequenceNumber + fragment.fragmentCounter >>> 0
   ]);
 }
 function hasAnySampleIdentityField(fragment) {
@@ -991,12 +1002,7 @@ function fragmentCounterOrder(fragment) {
 function objectKey(fragment) {
   const scope = streamScope(fragment);
   if (fragment.itemId !== void 0) {
-    return JSON.stringify([
-      ...scope,
-      fragment.mpuSequenceNumber,
-      "item",
-      fragment.itemId
-    ]);
+    return JSON.stringify([...scope, fragment.mpuSequenceNumber, "item", fragment.itemId]);
   }
   if (hasSampleIdentity(fragment)) {
     return JSON.stringify([
@@ -1013,11 +1019,7 @@ function objectKey(fragment) {
       fragment.sampleOffset
     ]);
   }
-  return JSON.stringify([
-    ...scope,
-    fragment.mpuSequenceNumber,
-    "unidentified"
-  ]);
+  return JSON.stringify([...scope, fragment.mpuSequenceNumber, "unidentified"]);
 }
 function ordersByOffset(fragments) {
   return fragments.every((fragment) => hasSampleIdentity(fragment));
@@ -1026,26 +1028,43 @@ function checkedSampleEnd(offset, byteLength) {
   const end = offset + byteLength;
   return Number.isSafeInteger(end) && end <= 4294967295 ? end : null;
 }
-var _buffers, _timeouts, _activeDataUnits, _pendingContinuations, _emitted, _emittedOrder, _timeoutMs, _maxBuffered, _MFUReassembler_instances, addAssociatedFragment_fn, parkContinuation_fn, drainPendingContinuations_fn, incompleteRunCount_fn, reject_fn, associateDataUnit_fn, tryReassemble_fn, assemble_fn, setTimeout_fn, clearPendingTimeout_fn, deletePendingRun_fn, onPendingTimeout_fn, clearTimeout_fn, markEmitted_fn, orderValue_fn, removeActiveDataUnitForBuffer_fn, onTimeout_fn, pendingDebugSamples_fn;
+var COMPLETED_ADDRESS_WINDOW_MULTIPLE = 2;
+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 use only the authored MFU DU identity. Continuations are
-    // admitted through bounded producer-profile runs keyed by physical stream,
-    // MPU, and the wrapping terminal packet sequence. This requires contiguous
-    // source-packet sequences within a fragmented DU; interleaving stays
-    // separated and incomplete. Continuations may wait in a counter-indexed queue
-    // until FI=1 supplies intrinsic identity; MMTP packet send time is never an
-    // association key.
+    // 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 — reject FEC-recovered duplicates
+    // 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,
@@ -1076,20 +1095,14 @@ var MFUReassembler = class {
       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)
-        );
+        state.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onTimeout_fn).call(this, bufferKey), Math.max(0, state.startedAt + ms - now));
       }
     }
-    for (const [runKey, pending] of __privateGet(this, _pendingContinuations)) {
+    for (const [address, pending] of __privateGet(this, _pendingContinuations)) {
       if (pending.timeoutId !== void 0) clearTimeout(pending.timeoutId);
       delete pending.timeoutId;
-      if (ms !== null && !__privateGet(this, _activeDataUnits).has(runKey)) {
-        pending.timeoutId = setTimeout(
-          () => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, runKey),
-          Math.max(0, pending.startedAt + ms - now)
-        );
+      if (ms !== null && parkedRunHoldsASlot(__privateMethod(this, _MFUReassembler_instances, openRunAt_fn).call(this, address) !== void 0, pending.fragments.size)) {
+        pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), Math.max(0, pending.startedAt + ms - now));
       }
     }
   }
@@ -1139,38 +1152,50 @@ var MFUReassembler = class {
         catalogTrackName: fragment.catalogTrackName
       };
     }
-    if (!isU32(fragment.packetSequenceNumber)) {
+    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 runKey = fragmentRunKey(fragment);
-    if (fragmentationIndicator === 1 && (hasSampleIdentity(fragment) || isU32(fragment.itemId)) && __privateGet(this, _emitted).has(objectKey(fragment))) {
-      __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, runKey);
-      return null;
-    }
+    const address = dataUnitAddress(fragment, sequence);
     if (fragmentationIndicator !== 1) {
-      const active = __privateGet(this, _activeDataUnits).get(runKey);
-      if (active !== void 0 && fragment.fragmentCounter > active.nextFragmentCounter) {
-        __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "fragment-counter-mismatch", "MFU continuation is behind the authored fragment-counter countdown");
+      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;
       }
-      if (active === void 0 || fragment.fragmentCounter < active.nextFragmentCounter) {
-        __privateMethod(this, _MFUReassembler_instances, parkContinuation_fn).call(this, runKey, fragment);
+      const [runKey2, active] = open;
+      if (active.nextFragmentCounter > fragment.fragmentCounter) {
+        __privateMethod(this, _MFUReassembler_instances, parkContinuation_fn).call(this, address, fragment);
         return null;
       }
-    } else if (__privateGet(this, _activeDataUnits).has(runKey)) {
-      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "overlapping-data-unit", "fragmented MFU overlaps an active data unit");
-    } else {
-      const pending = __privateGet(this, _pendingContinuations).get(runKey);
-      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");
+      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 pendingStartedAt = fragmentationIndicator === 1 ? __privateGet(this, _pendingContinuations).get(runKey)?.startedAt : void 0;
-    const result = __privateMethod(this, _MFUReassembler_instances, addAssociatedFragment_fn).call(this, fragment, runKey, pendingStartedAt);
-    if (fragmentationIndicator === 1) __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, runKey);
+    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, runKey);
+    return __privateMethod(this, _MFUReassembler_instances, drainPendingContinuations_fn).call(this, address, runKey);
   }
   /**
    * Flush all buffered fragments
@@ -1182,12 +1207,14 @@ var MFUReassembler = class {
     __privateGet(this, _buffers).clear();
     __privateGet(this, _timeouts).clear();
     __privateGet(this, _activeDataUnits).clear();
-    for (const runKey of __privateGet(this, _pendingContinuations).keys()) {
-      __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, runKey);
+    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) {
@@ -1205,18 +1232,15 @@ var MFUReassembler = class {
         discarded.add(key);
       }
     }
-    for (const [runKey, active] of __privateGet(this, _activeDataUnits)) {
+    for (const [objectKey2, active] of __privateGet(this, _activeDataUnits)) {
       if (active.catalogTrackName === catalogTrackName) {
         discarded.add(active.bufferKey);
-        __privateGet(this, _activeDataUnits).delete(runKey);
+        __privateGet(this, _activeDataUnits).delete(objectKey2);
       }
     }
-    for (const [runKey, pending] of __privateGet(this, _pendingContinuations)) {
-      if ([...pending.fragments.values()].some(
-        (fragment) => fragment.catalogTrackName === catalogTrackName
-      )) {
-        __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, runKey);
-      }
+    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);
@@ -1227,6 +1251,10 @@ var MFUReassembler = class {
       __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() {
@@ -1239,14 +1267,26 @@ var MFUReassembler = class {
     this.stats.outOfOrderFragments = 0;
   }
   /**
-   * Get number of pending MFUs
+   * 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() {
-    let count = __privateGet(this, _buffers).size;
-    for (const runKey of __privateGet(this, _pendingContinuations).keys()) {
-      if (!__privateGet(this, _activeDataUnits).has(runKey)) count++;
-    }
-    return count;
+    return __privateGet(this, _buffers).size + __privateMethod(this, _MFUReassembler_instances, unopenedParkedRunCount_fn).call(this);
   }
   /**
    * Get current buffer status
@@ -1273,11 +1313,14 @@ _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, startedAt) {
-  const association = __privateMethod(this, _MFUReassembler_instances, associateDataUnit_fn).call(this, fragment, runKey);
+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) {
@@ -1299,66 +1342,160 @@ addAssociatedFragment_fn = function(fragment, runKey, startedAt) {
     __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(runKey, fragment) {
-  let pending = __privateGet(this, _pendingContinuations).get(runKey);
-  if (pending === void 0) {
-    const awaitingFirst = !__privateGet(this, _activeDataUnits).has(runKey);
-    if (awaitingFirst && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
+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");
     }
-    const startedAt = Date.now();
-    pending = { fragments: /* @__PURE__ */ new Map(), startedAt };
-    if (awaitingFirst && __privateGet(this, _timeoutMs) !== null) {
-      pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, runKey), __privateGet(this, _timeoutMs));
+  }
+  let reAnchored = false;
+  if (pending === void 0) {
+    pending = {
+      fragments: /* @__PURE__ */ new Map(),
+      startedAt: Date.now(),
+      admissionSeq: open !== void 0 ? open[1].admissionSeq : __privateWrapper(this, _nextAdmissionSeq)._++
+    };
+    if (open === void 0 && __privateGet(this, _timeoutMs) !== null) {
+      pending.timeoutId = setTimeout(() => __privateMethod(this, _MFUReassembler_instances, onPendingTimeout_fn).call(this, address), __privateGet(this, _timeoutMs));
     }
-    __privateGet(this, _pendingContinuations).set(runKey, pending);
+    __privateGet(this, _pendingContinuations).set(address, pending);
+  } else if (!alreadyCharged) {
+    pending.admissionSeq = __privateWrapper(this, _nextAdmissionSeq)._++;
+    pending.startedAt = Date.now();
+    __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, address);
+    reAnchored = 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 (reAnchored) __privateMethod(this, _MFUReassembler_instances, armHeadlessPendingTimeout_fn).call(this, address);
 };
-drainPendingContinuations_fn = function(runKey) {
+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) {
-      __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, runKey);
+      if (pending?.fragments.size === 0) __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, address);
       return null;
     }
-    const pending = __privateGet(this, _pendingContinuations).get(runKey);
     const fragment = pending?.fragments.get(active.nextFragmentCounter);
-    if (fragment === void 0) return null;
+    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, runKey);
-    const result = __privateMethod(this, _MFUReassembler_instances, addAssociatedFragment_fn).call(this, fragment, runKey);
+    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) {
-      __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, runKey);
       return result;
     }
   }
 };
-incompleteRunCount_fn = function() {
-  let count = __privateGet(this, _activeDataUnits).size;
-  for (const runKey of __privateGet(this, _pendingContinuations).keys()) {
-    if (!__privateGet(this, _activeDataUnits).has(runKey)) count++;
+/** 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) {
+associateDataUnit_fn = function(fragment, runKey, address) {
   const fi = fragment.fragmentationIndicator;
   if (fi === 1) {
-    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 (!__privateGet(this, _pendingContinuations).has(runKey) && __privateMethod(this, _MFUReassembler_instances, incompleteRunCount_fn).call(this) >= __privateGet(this, _maxBuffered)) {
-      __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "active-data-unit-limit", "active MFU data-unit limit reached");
-    }
+    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;
@@ -1378,29 +1515,42 @@ associateDataUnit_fn = function(fragment, runKey) {
     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) {
-      const nextOffset = checkedSampleEnd(fragment.sampleOffset, fragment.data.byteLength);
-      if (nextOffset === null) __privateMethod(this, _MFUReassembler_instances, reject_fn).call(this, "offset-overflow", "sample byte offset overflow");
       active2 = {
+        address,
         kind: "sample",
         bufferKey,
         nextFragmentCounter: fragment.fragmentCounter - 1,
+        admissionSeq,
         movieFragmentSequenceNumber: fragment.movieFragmentSequenceNumber,
         sampleNumber: fragment.sampleNumber,
-        nextOffset,
+        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(runKey, active2);
+    __privateGet(this, _activeDataUnits).set(objectKey(fragment), active2);
     return { bufferKey, first: true, terminal: false };
   }
   const active = __privateGet(this, _activeDataUnits).get(runKey);
@@ -1506,25 +1656,49 @@ setTimeout_fn = function(bufferKey, startedAt = Date.now()) {
   }
   __privateGet(this, _timeouts).set(bufferKey, state);
 };
-clearPendingTimeout_fn = function(runKey) {
-  const pending = __privateGet(this, _pendingContinuations).get(runKey);
+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;
   }
 };
-deletePendingRun_fn = function(runKey) {
-  __privateMethod(this, _MFUReassembler_instances, clearPendingTimeout_fn).call(this, runKey);
-  __privateGet(this, _pendingContinuations).delete(runKey);
+/**
+ * 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. Both arming sites
+ * take 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(runKey) {
-  const pending = __privateGet(this, _pendingContinuations).get(runKey);
+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=${runKey} fragments=${pending.fragments.size} (continuations awaiting first fragment, discarded)`
+    `[MfuReassembler] timeout: run=${address} fragments=${pending.fragments.size} (continuations awaiting first fragment, discarded)`
   );
-  __privateGet(this, _pendingContinuations).delete(runKey);
+  __privateGet(this, _pendingContinuations).delete(address);
 };
 clearTimeout_fn = function(bufferKey) {
   const state = __privateGet(this, _timeouts).get(bufferKey);
@@ -1542,17 +1716,37 @@ markEmitted_fn = function(bufferKey) {
     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 [runKey, active] of __privateGet(this, _activeDataUnits)) {
+  for (const [objectKey2, active] of __privateGet(this, _activeDataUnits)) {
     if (active.bufferKey === bufferKey) {
-      __privateGet(this, _activeDataUnits).delete(runKey);
-      __privateMethod(this, _MFUReassembler_instances, deletePendingRun_fn).call(this, runKey);
+      __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) {
@@ -1564,9 +1758,7 @@ onTimeout_fn = function(bufferKey) {
     return;
   }
   this.stats.timedOutMFUs++;
-  console.warn(
-    `[MfuReassembler] timeout: key=${bufferKey} fragments=${fragments.length} (partial, discarded)`
-  );
+  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);
@@ -1691,15 +1883,14 @@ if (void 0) {
         rapFlag: true,
         ...identity
       });
+      expectRejection(() => reassembler.addFragment(complete({})), "missing-data-unit-identity");
       expectRejection(
-        () => reassembler.addFragment(complete({})),
-        "missing-data-unit-identity"
-      );
-      expectRejection(
-        () => reassembler.addFragment(complete({
-          movieFragmentSequenceNumber: 2,
-          sampleNumber: 1
-        })),
+        () => reassembler.addFragment(
+          complete({
+            movieFragmentSequenceNumber: 2,
+            sampleNumber: 1
+          })
+        ),
         "missing-data-unit-identity"
       );
     });
@@ -1721,18 +1912,20 @@ if (void 0) {
     });
     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.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({
@@ -1749,30 +1942,34 @@ if (void 0) {
     });
     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: 1,
-        sampleOffset: 3,
-        data: new Uint8Array([177]),
-        timestamp: 2001n,
-        rapFlag: false,
-        packetSequenceNumber: testPacketSequence(3, 1, 1)
-      })).toBeNull();
+      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,
@@ -1785,16 +1982,27 @@ if (void 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([178]),
+        data: new Uint8Array([179]),
         timestamp: 2001n,
         rapFlag: false,
-        packetSequenceNumber: testPacketSequence(3, 0, 1)
+        packetSequenceNumber: testPacketSequence(3, 0, 2)
       });
-      expect(second?.data).toEqual(new Uint8Array([177, 178]));
+      expect(second?.data).toEqual(new Uint8Array([177, 178, 179]));
       expect(second?.sampleOffset).toBe(3);
       expect(reassembler.pendingCount).toBe(0);
     });
@@ -1833,10 +2041,7 @@ if (void 0) {
         packetSequenceNumber: testPacketSequence(1, fragmentCounter)
       });
       expect(reassembler.addFragment(fragment(10, 1, 1, 16))).toBeNull();
-      expectRejection(
-        () => reassembler.addFragment(fragment(20, 1, 1, 32)),
-        "overlapping-data-unit"
-      );
+      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);
@@ -1888,15 +2093,17 @@ if (void 0) {
     });
     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.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,
@@ -1957,25 +2164,29 @@ if (void 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();
+      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,
@@ -2067,16 +2278,18 @@ if (void 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();
+      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,
@@ -2096,26 +2309,30 @@ if (void 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();
+      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,
@@ -2141,23 +2358,27 @@ if (void 0) {
         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);
+      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,
@@ -2166,33 +2387,35 @@ if (void 0) {
         data: new Uint8Array([177, 178]),
         packetSequenceNumber: testPacketSequence(0, 1)
       });
-      expect(out?.data).toEqual(
-        new Uint8Array([161, 162, 177, 178, 193, 194])
-      );
+      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();
+      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,
@@ -2211,36 +2434,42 @@ if (void 0) {
     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();
+      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,
@@ -2258,107 +2487,134 @@ if (void 0) {
     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");
+      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({
+      expectRejection(
+        () => reassembler.addFragment({
           fragmentationIndicator: 1,
           mpuSequenceNumber: 55,
           fragmentCounter: 1,
           itemId: 1,
           data: new Uint8Array([161]),
           timestamp: 22222n,
-          rapFlag: true,
-          packetSequenceNumber
-        }), "missing-packet-sequence");
+          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("fails closed when one fragmented DU has interleaved packet sequence gaps", () => {
+    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: 17,
-        movieFragmentSequenceNumber: 241,
-        sampleNumber: 1,
-        sampleOffset: 0,
-        packetSequenceNumber: 1e3,
-        data: new Uint8Array([160]),
-        timestamp,
-        rapFlag: true
-      })).toBeNull();
-      for (let i = 1; i < 17; i++) {
-        expect(reassembler.addFragment({
-          fragmentationIndicator: 2,
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
           mpuSequenceNumber: 80,
-          fragmentCounter: 17 - i,
-          packetSequenceNumber: 1e3 + i * 2,
-          data: new Uint8Array([160 + i]),
+          fragmentCounter: 3,
+          movieFragmentSequenceNumber: 241,
+          sampleNumber: 1,
+          sampleOffset: 0,
+          packetSequenceNumber: 1e3,
+          data: new Uint8Array([160]),
           timestamp,
-          rapFlag: false
-        })).toBeNull();
+          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();
       }
-      const out = reassembler.addFragment({
-        fragmentationIndicator: 3,
-        mpuSequenceNumber: 80,
-        fragmentCounter: 0,
-        packetSequenceNumber: 1040,
-        data: new Uint8Array([177]),
-        timestamp,
-        rapFlag: false
-      });
-      expect(out).toBeNull();
-      expect(reassembler.pendingCount).toBe(18);
+      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("does not combine adjacent reordered MFUs in one MPU", () => {
+    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: 3,
-        fragmentCounter: 0,
-        packetSequenceNumber: 103,
-        data: new Uint8Array([178]),
-        rapFlag: false
-      })).toBeNull();
-      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: 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,
@@ -2368,105 +2624,122 @@ if (void 0) {
         rapFlag: false
       });
       expect(earlier?.data).toEqual(new Uint8Array([161, 162]));
+      expect(earlier?.packetSequenceNumbers).toEqual([100, 101]);
       const later = reassembler.addFragment({
         ...common,
-        fragmentationIndicator: 1,
-        fragmentCounter: 1,
-        packetSequenceNumber: 102,
-        movieFragmentSequenceNumber: 241,
-        sampleNumber: 2,
-        sampleOffset: 0,
-        data: new Uint8Array([177]),
+        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]));
+      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();
+      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");
+      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,
@@ -2482,24 +2755,28 @@ if (void 0) {
     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.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,
@@ -2522,33 +2799,40 @@ if (void 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();
+      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,
@@ -2581,13 +2865,16 @@ if (void 0) {
         { 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");
+        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);
@@ -2599,23 +2886,27 @@ if (void 0) {
         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({
+      expect(
+        reassembler.addFragment({
           ...common,
-          fragmentationIndicator: 2,
-          fragmentCounter: counter,
-          data: new Uint8Array([255 - counter]),
-          packetSequenceNumber: testPacketSequence(47, counter)
-        })).toBeNull();
+          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,
@@ -2652,37 +2943,49 @@ if (void 0) {
       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();
-      expectRejection(() => reassembler.addFragment({
-        fragmentationIndicator: 3,
-        mpuSequenceNumber: 2,
-        fragmentCounter: 0,
-        data: new Uint8Array([2]),
-        timestamp: 1000n,
-        rapFlag: false,
-        packetSequenceNumber: testPacketSequence(2, 0)
-      }), "active-data-unit-limit");
-      expectRejection(() => reassembler.addFragment({
+      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([2]),
+        data: new Uint8Array([4]),
         timestamp: 1000n,
         rapFlag: true,
         packetSequenceNumber: testPacketSequence(2, 1)
-      }), "active-data-unit-limit");
-      expect(reassembler.pendingCount).toBe(1);
-      expect(reassembler.getStatus().pendingFragments).toBe(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,
@@ -2693,21 +2996,27 @@ if (void 0) {
         rapFlag: true,
         packetSequenceNumber: testPacketSequence(1, 1)
       });
-      expect(result?.data).toEqual(new Uint8Array([3, 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();
+        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);
@@ -2719,28 +3028,32 @@ if (void 0) {
       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();
+        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();
+        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);
@@ -2749,8 +3062,11 @@ if (void 0) {
         vi.useRealTimers();
       }
     });
-    test("bounds active data units and rejects a new first at maxBuffered", () => {
-      const reassembler = new MFUReassembler({ timeoutMs: 1e3, maxBuffered: 2 });
+    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,
@@ -2763,19 +3079,35 @@ if (void 0) {
           packetSequenceNumber: testPacketSequence(i, 1)
         });
       }
-      expectRejection(() => reassembler.addFragment({
-        fragmentationIndicator: 1,
-        mpuSequenceNumber: 2,
-        fragmentCounter: 1,
-        itemId: 2,
-        data: new Uint8Array([2]),
-        timestamp: 200n,
-        rapFlag: false,
-        packetSequenceNumber: testPacketSequence(2, 1)
-      }), "active-data-unit-limit");
+      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);
-      expect(reassembler.stats.evictedMemoryLimit).toBe(0);
     });
     test("should report stats correctly", () => {
       const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
@@ -2806,17 +3138,20 @@ if (void 0) {
         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");
+      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,
@@ -2844,24 +3179,28 @@ if (void 0) {
       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.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);
   });
@@ -2877,33 +3216,40 @@ if (void 0) {
       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");
+    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,
@@ -2931,57 +3277,60 @@ if (void 0) {
     });
     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"
-    );
+    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])
-    );
+    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.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);
-    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(0);
     const result = reassembler.addFragment({
       fragmentationIndicator: 1,
       mpuSequenceNumber: 43,
@@ -2993,52 +3342,60 @@ if (void 0) {
       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]));
+    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.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.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", () => {
@@ -3064,16 +3421,18 @@ if (void 0) {
       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();
+    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,
@@ -3278,6 +3637,15 @@ function trackNameOfKey(key) {
   const name = JSON.parse(key)[0];
   return name ?? void 0;
 }
+function identityOfKey(key) {
+  const [name, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber] = JSON.parse(key);
+  return {
+    catalogTrackName: name ?? void 0,
+    mpuSequenceNumber,
+    movieFragmentSequenceNumber,
+    sampleNumber
+  };
+}
 var SampleCombineError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -3285,13 +3653,14 @@ var SampleCombineError = class extends Error {
     this.name = "SampleCombineError";
   }
 };
-var _maxBuffered2, _requireAuthoredSize, _maxSegmentsPerSample, _authoredSizes, _pending, _retired, _stats, _SampleCombiner_instances, tryComplete_fn, retire_fn, evictOldestPending_fn;
+var _maxBuffered2, _requireAuthoredSize, _maxSegmentsPerSample, _onAbandon, _authoredSizes, _pending, _retired, _stats, _SampleCombiner_instances, abandon_fn, tryComplete_fn, retire_fn, evictOldestPending_fn;
 var SampleCombiner = class {
   constructor(options) {
     __privateAdd(this, _SampleCombiner_instances);
     __privateAdd(this, _maxBuffered2);
     __privateAdd(this, _requireAuthoredSize);
     __privateAdd(this, _maxSegmentsPerSample);
+    __privateAdd(this, _onAbandon);
     __privateAdd(this, _authoredSizes, /* @__PURE__ */ new Map());
     /** Map iteration is insertion-ordered, so the first key is the oldest. */
     __privateAdd(this, _pending, /* @__PURE__ */ new Map());
@@ -3307,7 +3676,7 @@ var SampleCombiner = class {
       timedOutSamples: 0,
       evictedSamples: 0
     });
-    const { maxBuffered, requireAuthoredSize, maxSegmentsPerSample } = options;
+    const { maxBuffered, requireAuthoredSize, maxSegmentsPerSample, onAbandon } = options;
     if (!Number.isInteger(maxBuffered) || maxBuffered <= 0) {
       throw new Error("[SampleCombiner] maxBuffered must be a positive integer");
     }
@@ -3317,6 +3686,7 @@ var SampleCombiner = class {
     __privateSet(this, _maxBuffered2, maxBuffered);
     __privateSet(this, _requireAuthoredSize, requireAuthoredSize);
     __privateSet(this, _maxSegmentsPerSample, maxSegmentsPerSample);
+    __privateSet(this, _onAbandon, onAbandon);
   }
   /**
    * Register the authored sample size from the host's own FT=1 parse. Per
@@ -3431,6 +3801,7 @@ var SampleCombiner = class {
         __privateGet(this, _pending).delete(key);
         __privateGet(this, _stats).timedOutSamples++;
         __privateMethod(this, _SampleCombiner_instances, retire_fn).call(this, key);
+        __privateMethod(this, _SampleCombiner_instances, abandon_fn).call(this, key);
       }
     }
   }
@@ -3477,11 +3848,17 @@ var SampleCombiner = class {
 _maxBuffered2 = new WeakMap();
 _requireAuthoredSize = new WeakMap();
 _maxSegmentsPerSample = new WeakMap();
+_onAbandon = new WeakMap();
 _authoredSizes = new WeakMap();
 _pending = new WeakMap();
 _retired = new WeakMap();
 _stats = new WeakMap();
 _SampleCombiner_instances = new WeakSet();
+/** Report one abandoned sample to the owner of any state keyed on it. */
+abandon_fn = function(key) {
+  var _a;
+  (_a = __privateGet(this, _onAbandon)) == null ? void 0 : _a.call(this, identityOfKey(key));
+};
 /**
  * Emit the sample when its held data units are byte-adjacent from zero and
  * total `size`. Completion is a protocol event, never a timer.
@@ -3536,6 +3913,7 @@ evictOldestPending_fn = function() {
   __privateGet(this, _pending).delete(oldest);
   __privateGet(this, _stats).evictedSamples++;
   __privateMethod(this, _SampleCombiner_instances, retire_fn).call(this, oldest);
+  __privateMethod(this, _SampleCombiner_instances, abandon_fn).call(this, oldest);
 };
 function fromPassthrough(mfu) {
   return {
@@ -3543,6 +3921,7 @@ function fromPassthrough(mfu) {
     movieFragmentSequenceNumber: mfu.movieFragmentSequenceNumber ?? 0,
     sampleNumber: mfu.sampleNumber ?? 0,
     data: mfu.data,
+    mmtpTimestamp: mfu.timestamp,
     timestamp: mfu.timestamp,
     rapFlag: mfu.rapFlag,
     priority: mfu.priority,
@@ -3584,6 +3963,7 @@ function fromSegments(segments, sortedOffsets) {
     movieFragmentSequenceNumber: first.movieFragmentSequenceNumber,
     sampleNumber: first.sampleNumber,
     data,
+    mmtpTimestamp: first.timestamp,
     timestamp: first.timestamp,
     rapFlag: first.rapFlag,
     priority: first.priority,
@@ -3690,6 +4070,30 @@ if (void 0) {
       expect(c.addMfu(mfu(1, 9, 17, 2, [3, 4], 1001n, false))).toBeNull();
       expect(() => c.addMfu(mfu(1, 9, 17, 4, [5, 6], 1002n, false))).toThrow(SampleCombineError);
     });
+    test("reports every abandoned sample so its per-sample state can be freed", () => {
+      const abandoned = [];
+      const c = combiner({ maxBuffered: 2, onAbandon: (s) => abandoned.push(s) });
+      c.registerAuthoredSize(void 0, 1, 9, 17, 10);
+      c.registerAuthoredSize(void 0, 1, 9, 18, 10);
+      c.registerAuthoredSize(void 0, 1, 9, 19, 10);
+      expect(c.addMfu(mfu(1, 9, 17, 0, [1, 1, 1, 1, 1], 1000n, true))).toBeNull();
+      expect(c.addMfu(mfu(1, 9, 18, 0, [2, 2, 2, 2, 2], 1001n, true))).toBeNull();
+      expect(abandoned).toEqual([]);
+      expect(c.addMfu(mfu(1, 9, 19, 0, [3, 3, 3, 3, 3], 1002n, true))).toBeNull();
+      expect(abandoned).toEqual([{
+        catalogTrackName: void 0,
+        mpuSequenceNumber: 1,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 17
+      }]);
+      c.cleanupTimeouts(-1);
+      expect(abandoned.map((s) => s.sampleNumber)).toEqual([17, 18, 19]);
+      const d = combiner({ maxBuffered: 2, onAbandon: (s) => abandoned.push(s) });
+      d.registerAuthoredSize(void 0, 1, 9, 20, 10);
+      expect(d.addMfu(mfu(1, 9, 20, 0, [4, 4, 4, 4, 4], 1003n, true))).toBeNull();
+      expect(d.addMfu(mfu(1, 9, 20, 5, [5, 5, 5, 5, 5], 1004n, false))).not.toBeNull();
+      expect(abandoned.map((s) => s.sampleNumber)).toEqual([17, 18, 19]);
+    });
     test("a full combiner evicts the oldest pending sample instead of throwing", () => {
       const c = combiner({ maxBuffered: 2 });
       c.registerAuthoredSize(void 0, 1, 9, 17, 10);
@@ -4270,7 +4674,10 @@ function detectH264Keyframe(data, options = {}) {
   return classifyH264Keyframe(data, options) === true;
 }
 function mmtpTimestampToMicros(rawTs) {
-  const ts = Number(rawTs) >>> 0;
+  const ts = typeof rawTs === "bigint" ? rawTs >= 0n && rawTs <= 0xffffffffn ? Number(rawTs) : void 0 : Number.isSafeInteger(rawTs) && rawTs >= 0 && rawTs <= 4294967295 ? rawTs : void 0;
+  if (ts === void 0) {
+    throw new RangeError(`MMTP timestamp must be an unsigned 32-bit integer, got ${String(rawTs)}`);
+  }
   if (ts === 0) return 0;
   const seconds = ts >>> 16;
   const frac = ts & 65535;
@@ -4295,6 +4702,7 @@ function isFmp4InitSegment(data) {
       size = data.byteLength - offset;
     }
     if (size < headerSize || offset + size > data.byteLength) return false;
+    if (type === "mmpu") return false;
     if (type === "ftyp") sawFtyp = true;
     if (type === "moov") {
       if (!sawFtyp) return false;
@@ -4304,6 +4712,44 @@ function isFmp4InitSegment(data) {
   }
   return offset === data.byteLength && sawFtyp && sawMoov;
 }
+function normalizeMmtpInitSegment(data) {
+  if (isFmp4InitSegment(data)) return data;
+  const parts = [];
+  let offset = 0;
+  let removedMpu = false;
+  while (offset + 8 <= data.byteLength) {
+    const view2 = new DataView(data.buffer, data.byteOffset + offset, data.byteLength - offset);
+    let size = view2.getUint32(0, false);
+    let headerSize = 8;
+    if (size === 1) {
+      if (offset + 16 > data.byteLength) return void 0;
+      const largeSize = view2.getBigUint64(8, false);
+      if (largeSize > BigInt(Number.MAX_SAFE_INTEGER)) return void 0;
+      size = Number(largeSize);
+      headerSize = 16;
+    } else if (size === 0) {
+      size = data.byteLength - offset;
+    }
+    if (size < headerSize || offset + size > data.byteLength) return void 0;
+    const type = String.fromCharCode(
+      data[offset + 4],
+      data[offset + 5],
+      data[offset + 6],
+      data[offset + 7]
+    );
+    if (type === "mmpu") removedMpu = true;
+    else parts.push(data.subarray(offset, offset + size));
+    offset += size;
+  }
+  if (!removedMpu || offset !== data.byteLength) return void 0;
+  const normalized = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+  let writeOffset = 0;
+  for (const part of parts) {
+    normalized.set(part, writeOffset);
+    writeOffset += part.byteLength;
+  }
+  return isFmp4InitSegment(normalized) ? normalized : void 0;
+}
 function hasIsoBmffMagic(data) {
   for (let i = 0; i + 8 <= data.length && i < 32; i += 4) {
     const tag = String.fromCharCode(data[i + 4], data[i + 5], data[i + 6], data[i + 7]);
@@ -7283,13 +7729,13 @@ var CmafBlockAssembler = class {
    *  is guarded by the per-frame `lastEmittedTs` check (also enforced in
    *  `#emitPerSample`). The `sbn`/`esi` parameters are kept for the call-site
    *  signature but no longer affect routing. */
-  addFrame(sbn, esi, data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance) {
+  addFrame(sbn, esi, data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber) {
     void sbn;
     void esi;
     __privateWrapper(this, _addFrameCount)._++;
     __privateMethod(this, _CmafBlockAssembler_instances, startAggregateTimer_fn).call(this);
     if (!__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) __privateMethod(this, _CmafBlockAssembler_instances, drainRecoveredUpTo_fn).call(this, timestamp);
-    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration2), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration2), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber);
     __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "addFrame-direct", [{ data, timestamp, keyframe }]);
   }
   /** Mark a block as complete (all K source symbols received or FEC recovery succeeded).
@@ -7334,9 +7780,9 @@ var CmafBlockAssembler = class {
     }
   }
   /** Emit a single frame immediately as a one-sample segment (for oversized packets bypassing FEC). */
-  addBypassFrame(data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance) {
+  addBypassFrame(data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber) {
     if (!__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) __privateMethod(this, _CmafBlockAssembler_instances, drainRecoveredUpTo_fn).call(this, timestamp);
-    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration2), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration2), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber);
   }
   /** Build and emit init segment from catalog config. */
   emitInit() {
@@ -7486,7 +7932,7 @@ unwrapTimestamp_fn = function(timestamp) {
   if (reference < 0) return timestamp;
   return timestamp + Math.round((reference - timestamp) / wrapPeriod) * wrapPeriod;
 };
-emitSample_fn = function(data, timestamp, duration, keyframe, advancesHorizon, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance) {
+emitSample_fn = function(data, timestamp, duration, keyframe, advancesHorizon, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber) {
   const scaledTiming = authoredTiming === void 0 ? null : scaleAuthoredTiming(authoredTiming, __privateGet(this, _config).timescale);
   if (authoredTiming !== void 0 && scaledTiming === null) return;
   const authoredTimestamp = scaledTiming?.timestamp ?? timestamp;
@@ -7513,6 +7959,7 @@ emitSample_fn = function(data, timestamp, duration, keyframe, advancesHorizon, c
     timestamp: unwrappedTimestamp,
     duration: authoredDuration,
     keyframe,
+    ...mmtpTimestamp === void 0 ? {} : { mmtpTimestamp },
     ...compositionTimeOffset === void 0 ? {} : { compositionTimeOffset },
     advancesHorizon,
     ...authoredTiming === void 0 ? {} : { authoredTiming },
@@ -7520,6 +7967,8 @@ emitSample_fn = function(data, timestamp, duration, keyframe, advancesHorizon, c
     ...packetSequenceNumbers === void 0 ? {} : { packetSequenceNumbers },
     ...repairedPacketSequenceNumbers === void 0 ? {} : { repairedPacketSequenceNumbers },
     ...mpuSequenceNumber === void 0 ? {} : { mpuSequenceNumber },
+    ...movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber },
+    ...sampleNumber === void 0 ? {} : { sampleNumber },
     ...catalogTrackName === void 0 ? {} : { catalogTrackName },
     ...deliveryProvenance === void 0 ? {} : { deliveryProvenance }
   });
@@ -7677,7 +8126,7 @@ emitPerSample_fn = function(frames, audioDurationOverride, advancesHorizon = fal
       duration = audioDurationOverride ?? __privateGet(this, _frameDuration2);
     }
     if (duration <= 0) duration = audioDurationOverride ?? __privateGet(this, _frameDuration2);
-    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, f.data, f.timestamp, duration, f.keyframe, advancesHorizon, f.catalogTrackName, f.mpuSequenceNumber, f.packetSequenceNumber, f.packetSequenceNumbers, f.repairedPacketSequenceNumbers, f.authoredTiming, f.deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, f.data, f.timestamp, duration, f.keyframe, advancesHorizon, f.catalogTrackName, f.mpuSequenceNumber, f.packetSequenceNumber, f.packetSequenceNumbers, f.repairedPacketSequenceNumbers, f.authoredTiming, f.deliveryProvenance, f.mmtpTimestamp, f.movieFragmentSequenceNumber, f.sampleNumber);
   }
 };
 _dumpCount = new WeakMap();
@@ -7692,8 +8141,9 @@ _aggregateTimer = new WeakMap();
 startAggregateTimer_fn = function() {
   if (__privateGet(this, _aggregateTimer)) return;
   __privateSet(this, _aggregateTimer, setInterval(() => {
+    const order = __privateGet(this, _sampleOrderStats);
     console.log(
-      `[L4-AGG-${__privateGet(this, _config).trackType}] emits=${__privateGet(this, _emitCount)} samples=${__privateGet(this, _sampleCount)} kf=${__privateGet(this, _keyframeCount)} addFrame=${__privateGet(this, _addFrameCount)} recovered=${__privateGet(this, _recoveredBlockCount)} complete=${__privateGet(this, _completeBlockCount)} fail=${__privateGet(this, _failBlockCount)} pendingBlocks=${__privateGet(this, _blocks).size} pendingFlushes=${__privateGet(this, _pendingFlush).size} armedVideo=${__privateGet(this, _armedVideo)}`
+      `[L4-AGG-${__privateGet(this, _config).trackType}] emits=${__privateGet(this, _emitCount)} samples=${__privateGet(this, _sampleCount)} kf=${__privateGet(this, _keyframeCount)} addFrame=${__privateGet(this, _addFrameCount)} recovered=${__privateGet(this, _recoveredBlockCount)} complete=${__privateGet(this, _completeBlockCount)} fail=${__privateGet(this, _failBlockCount)} pendingBlocks=${__privateGet(this, _blocks).size} pendingFlushes=${__privateGet(this, _pendingFlush).size} armedVideo=${__privateGet(this, _armedVideo)} forced=${order.forcedReleases} stale=${order.staleSamples} dup=${order.duplicateSamples} preRap=${order.preRapDeadlineDrops} noRap=${order.noRapFlushDrops}`
     );
     __privateSet(this, _emitCount, 0);
     __privateSet(this, _sampleCount, 0);
@@ -7751,7 +8201,7 @@ drainRecoveredUpTo_fn = function(horizonTs) {
   const ready = [...__privateGet(this, _pendingRecovered).values()].filter((frame) => frame.timestamp <= horizonTs).sort((a, b) => a.timestamp - b.timestamp);
   for (const frame of ready) {
     __privateGet(this, _pendingRecovered).delete(frame.timestamp);
-    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, frame.data, frame.timestamp, __privateGet(this, _frameDuration2), frame.keyframe, false, frame.catalogTrackName, frame.mpuSequenceNumber, frame.packetSequenceNumber, frame.packetSequenceNumbers, frame.repairedPacketSequenceNumbers, frame.authoredTiming, frame.deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, frame.data, frame.timestamp, __privateGet(this, _frameDuration2), frame.keyframe, false, frame.catalogTrackName, frame.mpuSequenceNumber, frame.packetSequenceNumber, frame.packetSequenceNumbers, frame.repairedPacketSequenceNumbers, frame.authoredTiming, frame.deliveryProvenance, frame.mmtpTimestamp, frame.movieFragmentSequenceNumber, frame.sampleNumber);
     __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "recovered-drain", [frame]);
   }
 };
@@ -8123,6 +8573,15 @@ function deriveFecInterleaveDepth(interleaveDepthMs, mediaUnitDurationMs) {
   }
   return Math.max(1, Math.floor(interleaveDepthMs / mediaUnitDurationMs + 0.5));
 }
+function fecBlockBudgetMs(interleaveDepthMs, reorderToleranceMs) {
+  if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0)) {
+    throw new Error(`[FEC] interleaveDepthMs must be a finite value > 0 (got ${interleaveDepthMs}ms). Fix encoder config.`);
+  }
+  if (!(reorderToleranceMs >= 0) || !Number.isFinite(reorderToleranceMs)) {
+    throw new Error(`[FEC] reorderToleranceMs must be a finite value >= 0 (got ${reorderToleranceMs}ms). It is a catalog value (fec.reorderToleranceMs), not a local default.`);
+  }
+  return Math.ceil(interleaveDepthMs + reorderToleranceMs);
+}
 function parseRepairPacket(packet) {
   const parsed = parseMoqRepairFrame(packet);
   if (!parsed)
@@ -8224,32 +8683,18 @@ function computeFecLossWindowMs(fecInterleaveMs, fecK, jitterBufferMs) {
 function computeFecDeliveryWindowMs(config) {
   const fecInterleaveMs = config.interleaveDepthMs;
   const fecK = config.sourceSymbols;
-  if (fecInterleaveMs <= 0) {
+  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
     throw new Error(
       `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
     );
   }
-  if (fecK <= 0) {
+  if (!Number.isFinite(fecK) || fecK <= 0) {
     throw new Error(
       `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
     );
   }
-  const spansMs = [fecInterleaveMs];
-  if (config.mediaUnitsPerSecond && config.mediaUnitsPerSecond > 0) {
-    const mediaUnitMs = 1e3 / config.mediaUnitsPerSecond;
-    const interleaveUnits = deriveFecInterleaveDepth(fecInterleaveMs, mediaUnitMs);
-    const deliverySymbols = fecK + Math.max(0, config.repairSymbols ?? 0);
-    spansMs.push(deliverySymbols * interleaveUnits * mediaUnitMs);
-  }
-  if (config.symbolSize && config.symbolSize > 0 && config.bandwidthBps && config.bandwidthBps > 0) {
-    const repairSymbols = Math.max(0, config.repairSymbols ?? 0);
-    spansMs.push(
-      (fecK + repairSymbols) * config.symbolSize * 8 * 1e3 / config.bandwidthBps
-    );
-  }
-  const coreMs = Math.max(...spansMs);
-  const marginMs = config.jitterBufferMs !== void 0 && config.jitterBufferMs >= 0 ? config.jitterBufferMs : fecInterleaveMs;
-  return Math.ceil(coreMs) + Math.ceil(marginMs);
+  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
+  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
 }
 function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
   if (!Number.isFinite(timestampTimescale) || timestampTimescale <= 0) {
@@ -8265,7 +8710,7 @@ function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
   }
   return deliveryWindow;
 }
-var _state, _subscription, _hysteresisTimer, _joinDeadlineTimer, _previousPrimary, _manager, _suppressFired, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_fn, suppress_fn, unsuppress_fn;
+var _state, _subscription, _hysteresisTimer, _joinDeadlineTimer, _previousPrimary, _manager, _suppressFired, _fecArmed, _TrackSession_instances, transition_fn, clearHysteresis_fn, armJoinDeadline_fn, clearJoinDeadline_fn, armFec_fn, disarmFec_fn, suppress_fn, unsuppress_fn;
 var TrackSession = class {
   constructor(config, manager) {
     __privateAdd(this, _TrackSession_instances);
@@ -8282,6 +8727,12 @@ var TrackSession = class {
     // from `failing` (exactly where a starving track sits) was re-subscribed to
     // unicast with the host's media still muted: MoQ playing into a dead sink.
     __privateAdd(this, _suppressFired, false);
+    // Single FEC authority flag: set by the fec-setup edges (joinStarted,
+    // enterUnicastFallback), cleared by the fec-teardown edge in #transition.
+    // Setup and teardown are paired by construction, so a takeover timeout that
+    // parks the session in `unicast` keeps the decoder the still-joined
+    // transport is feeding, and the later unsubscribe still tears it down.
+    __privateAdd(this, _fecArmed, false);
     this.config = config;
     __privateSet(this, _manager, manager);
   }
@@ -8356,7 +8807,7 @@ var TrackSession = class {
   joinStarted() {
     if (__privateGet(this, _state) !== "unicast") return;
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
   }
   /**
    * any non-fallback state → unicast-fallback. Used when the SSM bridge is
@@ -8377,7 +8828,7 @@ var TrackSession = class {
     __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast-fallback");
     __privateMethod(this, _TrackSession_instances, suppress_fn).call(this);
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+    __privateMethod(this, _TrackSession_instances, armFec_fn).call(this);
   }
   /**
    * unicast-fallback → unicast. Called when the SSM bridge appears mid-session
@@ -8408,7 +8859,11 @@ var TrackSession = class {
     if (__privateGet(this, _state) !== "multicast" && __privateGet(this, _state) !== "amt") return;
     __privateSet(this, _previousPrimary, __privateGet(this, _state));
     __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "failing");
-    const hysteresisMs = computeFecLossWindowMs(this.config.fecInterleaveMs, this.config.fecK);
+    const hysteresisMs = computeFecLossWindowMs(
+      this.config.fecInterleaveMs,
+      this.config.fecK,
+      this.config.fecReorderToleranceMs
+    );
     __privateSet(this, _hysteresisTimer, setTimeout(() => {
       this.hysteresisExpired();
     }, hysteresisMs));
@@ -8432,23 +8887,18 @@ var TrackSession = class {
     const prefs = this.config.preferredTransports;
     const currentIdx = current ? prefs.indexOf(current) : -1;
     const nextMode = prefs[currentIdx + 1];
-    if (nextMode) {
-      if (nextMode === "moq") {
-        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
-        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-        if (this.config.trackType === "audio") {
-          __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
-        }
-      } else {
-        __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
-        __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-      }
-    } else {
-      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    if (nextMode !== void 0 && nextMode !== "moq") {
+      __privateSet(this, _previousPrimary, nextMode);
+      __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "joining");
       __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
-      if (this.config.trackType === "audio") {
-        __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
-      }
+      return;
+    }
+    __privateSet(this, _previousPrimary, null);
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
+    __privateMethod(this, _TrackSession_instances, unsuppress_fn).call(this);
+    if (this.config.trackType === "audio") {
+      __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "reset" }, this.config);
     }
   }
   /** Hysteresis expired → failback to next transport (Claim 9g). */
@@ -8472,11 +8922,20 @@ var TrackSession = class {
   get isUnicastFallback() {
     return __privateGet(this, _state) === "unicast-fallback";
   }
+  /**
+   * True while this track owns a FEC decoder (fec-setup fired, fec-teardown
+   * not yet). Stays true across a takeover timeout that parked the session in
+   * `unicast`; SessionManager.failbackAll uses it to release such sessions.
+   */
+  get isFecArmed() {
+    return __privateGet(this, _fecArmed);
+  }
   dispose() {
     __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
     __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
     __privateSet(this, _state, "idle");
     __privateSet(this, _subscription, null);
+    __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
   }
 };
 _state = new WeakMap();
@@ -8486,20 +8945,20 @@ _joinDeadlineTimer = new WeakMap();
 _previousPrimary = new WeakMap();
 _manager = new WeakMap();
 _suppressFired = new WeakMap();
+_fecArmed = new WeakMap();
 _TrackSession_instances = new WeakSet();
 // -----------------------------------------------------------------------
 // Internal
 // -----------------------------------------------------------------------
-transition_fn = function(to) {
+transition_fn = function(to, opts) {
   const from = __privateGet(this, _state);
   if (from === to) return;
+  const joinDeadlineMs = to === "joining" ? __privateGet(this, _manager).takeoverDeadlineMs : void 0;
   __privateSet(this, _state, to);
   if (from === "joining") __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
-  if (to === "joining") __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this);
+  if (joinDeadlineMs !== void 0) __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, joinDeadlineMs);
   const fecActive = (s) => s === "joining" || s === "multicast" || s === "amt" || s === "failing" || s === "unicast-fallback";
-  if (fecActive(from) && !fecActive(to)) {
-    __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
-  }
+  if (!fecActive(to) && !opts?.retainFec) __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
   __privateGet(this, _manager).callbacks?.onStateChange?.(this.config.trackName, from, to);
 };
 clearHysteresis_fn = function() {
@@ -8508,14 +8967,13 @@ clearHysteresis_fn = function() {
     __privateSet(this, _hysteresisTimer, null);
   }
 };
-armJoinDeadline_fn = function() {
+armJoinDeadline_fn = function(deadlineMs) {
   __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
-  const deadlineMs = __privateGet(this, _manager).takeoverDeadlineMs;
-  if (deadlineMs <= 0) return;
+  if (deadlineMs === 0) return;
   __privateSet(this, _joinDeadlineTimer, setTimeout(() => {
     __privateSet(this, _joinDeadlineTimer, null);
     if (__privateGet(this, _state) !== "joining") return;
-    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast");
+    __privateMethod(this, _TrackSession_instances, transition_fn).call(this, "unicast", { retainFec: true });
     __privateGet(this, _manager).callbacks?.onTakeoverTimeout?.(this.config.trackName);
   }, deadlineMs));
 };
@@ -8525,6 +8983,18 @@ clearJoinDeadline_fn = function() {
     __privateSet(this, _joinDeadlineTimer, null);
   }
 };
+/** Fire fec-setup exactly once per FEC epoch. */
+armFec_fn = function() {
+  if (__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, true);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-setup" }, this.config);
+};
+/** Fire fec-teardown for an armed decoder; no-op when none is armed. */
+disarmFec_fn = function() {
+  if (!__privateGet(this, _fecArmed)) return;
+  __privateSet(this, _fecArmed, false);
+  __privateGet(this, _manager).mmtp?.onTrackEvent?.(this.config.trackName, { type: "fec-teardown" }, this.config);
+};
 /** Fire onSuppress(true) exactly once per suppression epoch. */
 suppress_fn = function() {
   if (__privateGet(this, _suppressFired)) return;
@@ -8537,18 +9007,14 @@ unsuppress_fn = function() {
   __privateSet(this, _suppressFired, false);
   __privateGet(this, _manager).callbacks?.onSuppress?.(this.config.trackName, false);
 };
+var MAX_TAKEOVER_DEADLINE_MS = 2147483647;
+var _takeoverDeadlineMs, _SessionManager_instances, requireTakeoverDeadlineMs_fn;
 var SessionManager = class {
   constructor(poolOptions) {
+    __privateAdd(this, _SessionManager_instances);
     this.sessions = /* @__PURE__ */ new Map();
     this.callbacks = null;
-    /**
-     * Takeover deadline (BLO-9413/D9): max time a session may sit in `joining`
-     * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
-     * MoQ is never suppressed during `joining`, so expiry is a silent abandon —
-     * playback never glitches. Hosts tune per stream (e.g. GOP length); 0
-     * disables.
-     */
-    this.takeoverDeadlineMs = 5e3;
+    __privateAdd(this, _takeoverDeadlineMs);
     this.pool = new TransportPool(poolOptions);
     this.pool.onSubscriptionFailed((sub) => {
       for (const trackName of sub.consumers) {
@@ -8557,18 +9023,56 @@ var SessionManager = class {
       }
     });
   }
+  /**
+   * Takeover deadline (BLO-9413/D9): the time a session may sit in `joining`
+   * without a RAP before returning to `unicast` and firing onTakeoverTimeout.
+   * MoQ is never suppressed during `joining`, so expiry abandons the takeover
+   * without a playback glitch. The host derives it from the catalog (RAP
+   * cadence from groupDurationTicks/timescale plus the signaled FEC delivery
+   * window or reorder tolerance) and sets it before addTrack(). There is no
+   * default: an unset value fails addTrack() closed, and reading the getter
+   * before assignment throws the same way, so no host ever holds a
+   * `number | undefined` it could coalesce back into a default.
+   * `hasTakeoverDeadline` answers whether one was admitted. A declared 0
+   * disables the deadline. The value is an integer number of milliseconds:
+   * setTimeout truncates fractions, so a host that divides ticks by a
+   * timescale must round before assigning.
+   *
+   * Assignment validates, so the diagnostic lands at the host's own call site.
+   * That is what bounds the blast radius: `joining` is entered from
+   * joinStarted(), from the transportFailed() failover branch -- itself
+   * reachable from a setTimeout via hysteresisExpired(), where no caller could
+   * catch a throw -- and from the activateMulticast()/activateAmt()/pool-failure
+   * loops, where a throw on one session would abandon its siblings mid-loop
+   * (the split-brain those loops exist to prevent). Refusing a bad value at
+   * assignment means no host mutation can make an already-admitted session
+   * throw out of a transport edge.
+   */
+  get takeoverDeadlineMs() {
+    return __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
+  }
+  set takeoverDeadlineMs(value) {
+    if (!Number.isInteger(value) || value < 0 || value > MAX_TAKEOVER_DEADLINE_MS) {
+      throw new Error(
+        `[SessionManager] takeoverDeadlineMs must be an integer from 0 to ${MAX_TAKEOVER_DEADLINE_MS} (0 disables it, larger values overflow setTimeout); got ${String(value)}`
+      );
+    }
+    __privateSet(this, _takeoverDeadlineMs, value);
+  }
+  /** True once the host has admitted a deadline; a declared 0 counts. */
+  get hasTakeoverDeadline() {
+    return __privateGet(this, _takeoverDeadlineMs) !== void 0;
+  }
   /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
   get mmtp() {
     return this.callbacks;
   }
-  // -----------------------------------------------------------------------
-  // Track management
-  // -----------------------------------------------------------------------
   /** Add a track session from catalog config. */
   addTrack(config) {
     if (this.sessions.has(config.trackName)) {
       throw new Error(`[SessionManager] Track "${config.trackName}" already exists`);
     }
+    __privateMethod(this, _SessionManager_instances, requireTakeoverDeadlineMs_fn).call(this);
     const session = new TrackSession(config, this);
     this.sessions.set(config.trackName, session);
     return session;
@@ -8592,8 +9096,9 @@ var SessionManager = class {
    * Prevents split-brain between video and audio.
    *
    * A takeover deadline can return a track from `joining` to `unicast` while
-   * the multicast socket keeps delivering packets. If a valid RAP arrives
-   * later, allow that late-RAP edge to suppress unicast and promote multicast.
+   * the multicast socket keeps delivering packets and the track keeps its FEC
+   * decoder armed. If a valid RAP arrives later, that late-RAP edge suppresses
+   * unicast and promotes multicast without a second fec-setup.
    */
   activateMulticast() {
     for (const [, session] of this.sessions) {
@@ -8625,13 +9130,17 @@ var SessionManager = class {
    * and they must drain uninterrupted across transport-state events.
    *
    * Coherence invariant (BLO-9413): after this returns, every non-fallback
-   * session is `unicast` (or `idle`) AND unsuppressed — unsubscribe() unwinds
-   * any outstanding suppression regardless of the state it tears down from
-   * (`failing` included; see TrackSession.#suppressFired).
+   * session is `unicast` (or `idle`), unsuppressed, and without a FEC decoder.
+   * unsubscribe() unwinds any outstanding suppression regardless of the state
+   * it tears down from (`failing` included; see TrackSession.#suppressFired),
+   * and a session that a takeover timeout parked in `unicast` with its decoder
+   * still armed is cycled too, because this transport edge is what releases
+   * that decoder (unsubscribe fires fec-teardown).
    */
   failbackAll() {
     for (const [, session] of this.sessions) {
-      if (session.state !== "idle" && session.state !== "unicast" && session.state !== "unicast-fallback") {
+      const parkedWithFec = session.state === "unicast" && session.isFecArmed;
+      if (parkedWithFec || session.state !== "idle" && session.state !== "unicast" && session.state !== "unicast-fallback") {
         session.unsubscribe();
         session.subscribe();
       }
@@ -8715,6 +9224,27 @@ var SessionManager = class {
     this.callbacks = null;
   }
 };
+_takeoverDeadlineMs = new WeakMap();
+_SessionManager_instances = new WeakSet();
+// -----------------------------------------------------------------------
+// Track management
+// -----------------------------------------------------------------------
+/**
+ * The admitted takeover deadline. Throws only when the host never set one,
+ * every other invalid value being refused by the setter, and returns a
+ * declared 0 as 0. The getter and addTrack() both route through it, so a
+ * session cannot exist without an admitted deadline, which is what makes
+ * the #transition() read unable to throw on an already-admitted session.
+ */
+requireTakeoverDeadlineMs_fn = function() {
+  const value = __privateGet(this, _takeoverDeadlineMs);
+  if (value === void 0) {
+    throw new Error(
+      "[SessionManager] takeoverDeadlineMs is unset; set a catalog-derived takeover deadline (0 disables it) before adding tracks"
+    );
+  }
+  return value;
+};
 
 // src/fec-manager.ts
 var MIN_INTERLEAVE_DEPTH_MS = 33;
@@ -8733,7 +9263,7 @@ function newFecCounters() {
     greenFillFrames: 0
   };
 }
-var _fecDecoders, _workerClients, _syncDecoderBlockOwners, _decoderBlockOwners, _fecK, _fecSymbolSize, _fecTimeoutMs, _trackConfigs, _fecStats, _fecTrackStats, _fecWorkerStats, _fecStatsObservers, _activeBlocks, _activeBlockDeadlinesMs, _activeBlockTimeoutOwners, _lifecycleTrace, _pendingWorkerCleanups, _pendingWorkerCleanupClients, _blockSourceCounts, _blockSourceEsis, _blockRepairRsIds, _completedBlocks, _seenSymbols, _blockPathCounts, _blockCatalogTrackNames, _startupAlignedPackets, _startupPartialBlocks, _startupRequireRepairReady, _startupRepairReadyPackets, _startupRepairBoundaryCounts, _startupRepairFailOpenPackets, _cleanlyCompletedBlocks, _repairRequestedBlocks, _repairDeadlines, _workerRecoveredBlocks, _fpsDetected, _fecFps, _fecInterleaveDepthMs, _workerErrorCounts, _repairSymbolSizeMismatchCount, _FECManager_instances, streamKey_fn, belongsToPacket_fn, belongsToStream_fn, packetIdsForStreamKeys_fn, blockKey_fn, parseBlockKey_fn, decoderForPacket_fn, workerForPacket_fn, claimDecoderBlock_fn, decoderBlockCatalogTrackName_fn, resetDecoderBlockOwners_fn, discardFecDecoderClient_fn, assertExclusiveDecoderClient_fn, statsForPacket_fn, markPathBlockComplete_fn, clearRepairDeadline_fn, requestRepair_fn, traceLifecycle_fn, defaultTrackConfig_fn, resolveTrackConfig_fn, computeTimeout_fn, repairDeadlineMs_fn, repairGraceMs_fn, armBlockTimeout_fn, upsertTrackConfig_fn, normalizeSymbolData_fn, blockKeysFor_fn, observeBlockCatalogTrackName_fn, markStartupPartial_fn, routeSyncCleanup_fn, failBlock_fn;
+var _fecDecoders, _workerClients, _syncDecoderBlockOwners, _decoderBlockOwners, _fecK, _fecSymbolSize, _fecTimeoutMs, _trackConfigs, _fecStats, _fecTrackStats, _fecWorkerStats, _fecStatsObservers, _activeBlocks, _activeBlockDeadlinesMs, _activeBlockTimeoutOwners, _lifecycleTrace, _pendingWorkerCleanups, _pendingWorkerCleanupClients, _blockSourceCounts, _blockSourceEsis, _blockRepairRsIds, _completedBlocks, _seenSymbols, _blockPathCounts, _blockCatalogTrackNames, _startupAlignedPackets, _startupPartialBlocks, _startupRequireRepairReady, _startupRepairReadyPackets, _startupRepairBoundaryCounts, _startupRepairFailOpenPackets, _cleanlyCompletedBlocks, _repairRequestedBlocks, _repairDeadlines, _workerRecoveredBlocks, _fpsDetected, _fecFps, _fecInterleaveDepthMs, _workerErrorCounts, _decoderUnavailableEvents, _repairSymbolSizeMismatchCount, _FECManager_instances, streamKey_fn, belongsToPacket_fn, belongsToStream_fn, packetIdsForStreamKeys_fn, parseStreamKey_fn, blockKey_fn, parseBlockKey_fn, decoderForPacket_fn, workerForPacket_fn, routableWorkerForPacket_fn, claimDecoderBlock_fn, decoderBlockCatalogTrackName_fn, resetDecoderBlockOwners_fn, discardFecDecoderClient_fn, assertExclusiveDecoderClient_fn, statsForPacket_fn, markPathBlockComplete_fn, clearRepairDeadline_fn, requestRepair_fn, traceLifecycle_fn, defaultTrackConfig_fn, resolveTrackConfig_fn, computeTimeout_fn, repairDeadlineMs_fn, repairGraceMs_fn, armBlockTimeout_fn, upsertTrackConfig_fn, normalizeSymbolData_fn, blockKeysFor_fn, observeBlockCatalogTrackName_fn, markStartupPartial_fn, retireWorker_fn, releaseWorkerClient_fn, settleOwedCleanup_fn, evictDisposedWorker_fn, routeSyncCleanup_fn, failBlock_fn;
 var FECManager = class {
   constructor() {
     __privateAdd(this, _FECManager_instances);
@@ -8837,6 +9367,7 @@ var FECManager = class {
     // validation harness — which caps headless warnings at 500 — fails even
     // though the errors are duplicates of a single underlying event.
     __privateAdd(this, _workerErrorCounts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _decoderUnavailableEvents, 0);
     __privateAdd(this, _repairSymbolSizeMismatchCount, 0);
     // Event callbacks — block lifecycle notifications for MmtpRouter wiring.
     // NOTE: For sync WASM path, recovery routing is handled by MmtpRouter from
@@ -8845,6 +9376,17 @@ var FECManager = class {
     this.onBlockStarted = null;
     this.onBlockComplete = null;
     this.onBlockFailed = null;
+    /**
+     * Fired once per stream when its Worker decoder stops being routable.
+     * `reason` is 'cleared' when clearFecWorker() removed it and 'disposed' when
+     * a symbol or reset found the registered client already disposed and
+     * evicted it. `fallbackDecoder` is 'sync' when a synchronous WASM decoder
+     * registered for the same stream keeps decoding its symbols, and 'none'
+     * when nothing does. Only 'none' leaves the stream unprotected: the host
+     * must then register a decoder again or leave the stream, because counting
+     * its symbols as handled would hide the loss.
+     */
+    this.onDecoderUnavailable = null;
     // D-28 on-demand repair callbacks. When onRepairNeeded is registered, each
     // block arms a one-shot repair deadline after the derived K-symbol source
     // horizon; a block still short of K when it fires requests a per-SBN MoQ
@@ -8878,6 +9420,7 @@ var FECManager = class {
       startupRepairReadyPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairReadyPackets)),
       startupRepairFailOpenPackets: __privateMethod(this, _FECManager_instances, packetIdsForStreamKeys_fn).call(this, __privateGet(this, _startupRepairFailOpenPackets)),
       pendingWorkerCleanups: __privateGet(this, _pendingWorkerCleanups).size,
+      decoderUnavailableEvents: __privateGet(this, _decoderUnavailableEvents),
       repairTrackedBlocks: __privateGet(this, _blockRepairRsIds).size,
       lifecycleTrace: __privateGet(this, _lifecycleTrace).map((entry) => ({ ...entry }))
     };
@@ -9012,8 +9555,12 @@ var FECManager = class {
         __privateMethod(this, _FECManager_instances, discardFecDecoderClient_fn).call(this, client);
       }
     }
-    for (const [key, client] of __privateGet(this, _workerClients)) {
+    for (const [key, client] of [...__privateGet(this, _workerClients)]) {
       if (!__privateMethod(this, _FECManager_instances, belongsToStream_fn).call(this, key, packetId, catalogTrackName)) continue;
+      if (client.disposed === true) {
+        __privateMethod(this, _FECManager_instances, evictDisposedWorker_fn).call(this, client);
+        continue;
+      }
       client.reset();
       clients.add(client);
     }
@@ -9233,6 +9780,12 @@ var FECManager = class {
     }
     const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
     __privateMethod(this, _FECManager_instances, assertExclusiveDecoderClient_fn).call(this, streamKey, client, __privateGet(this, _workerClients), "worker");
+    const incumbent = __privateGet(this, _workerClients).get(streamKey);
+    if (incumbent !== void 0 && incumbent !== client) {
+      throw new Error(
+        `[FECManager] stream ${streamKey} already routes to a Worker; call clearFecWorker before registering another`
+      );
+    }
     if (config) __privateMethod(this, _FECManager_instances, upsertTrackConfig_fn).call(this, packetId, config);
     const workerK = __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).k;
     __privateGet(this, _workerClients).set(streamKey, client);
@@ -9319,14 +9872,7 @@ var FECManager = class {
         const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
         return block.packetId === packetId && block.sbn === sbn && __privateGet(this, _pendingWorkerCleanupClients).get(key) === client;
       });
-      for (const key of cleanupKeys) {
-        __privateGet(this, _pendingWorkerCleanups).delete(key);
-        __privateGet(this, _pendingWorkerCleanupClients).delete(key);
-        if (__privateGet(this, _completedBlocks).has(key)) continue;
-        const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
-        __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "cleanup-ack", sbn, packetId, block.catalogTrackName);
-        __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, block.catalogTrackName);
-      }
+      for (const key of cleanupKeys) __privateMethod(this, _FECManager_instances, settleOwedCleanup_fn).call(this, key, "cleanup-ack");
     });
     client.onError((msg, code) => {
       const requestedKind = code ?? msg;
@@ -9342,6 +9888,25 @@ var FECManager = class {
       }
     });
   }
+  /**
+   * Remove a stream's Worker decoder from routing.
+   *
+   * Returns false when no Worker is registered under that exact stream key.
+   * On success every cleanup acknowledgement still owed by the client is
+   * resolved by failing its block now (a Worker that is going away cannot
+   * post it), the client's block ownership is released, and
+   * onDecoderUnavailable fires once with reason 'cleared' and the decoder
+   * that remains for the stream ('sync' or 'none'). Call this before
+   * disposing the client; a client disposed while still registered is
+   * evicted on its next symbol or reset with reason 'disposed'.
+   */
+  clearFecWorker(packetId, catalogTrackName) {
+    const streamKey = __privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName);
+    const client = __privateGet(this, _workerClients).get(streamKey);
+    if (!client) return false;
+    __privateMethod(this, _FECManager_instances, retireWorker_fn).call(this, streamKey, client, "cleared");
+    return true;
+  }
   /** Called by player when framerate is known (from decoder output). Refines FEC block timeout. */
   setFramerate(fps) {
     if (__privateGet(this, _fpsDetected) || fps <= 0) return;
@@ -9392,7 +9957,7 @@ var FECManager = class {
     const sbn = Math.floor(ssId / this.kForPacket(packetId));
     const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
     const syncBlockOwner = __privateGet(this, _syncDecoderBlockOwners).get(blockKey);
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient && !syncBlockOwner) {
       if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
       const buf = fecData.buffer.slice(
@@ -9469,7 +10034,7 @@ var FECManager = class {
     if (__privateGet(this, _repairRequestedBlocks).has(blockKey)) {
       __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, "repair-arrived", sbn, packetId, catalogTrackName, rsId);
     }
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient && !syncBlockOwner) {
       if (!__privateMethod(this, _FECManager_instances, claimDecoderBlock_fn).call(this, workerClient, sbn, catalogTrackName)) return null;
       const buf = fecData.buffer.slice(
@@ -9754,6 +10319,7 @@ _fpsDetected = new WeakMap();
 _fecFps = new WeakMap();
 _fecInterleaveDepthMs = new WeakMap();
 _workerErrorCounts = new WeakMap();
+_decoderUnavailableEvents = new WeakMap();
 _repairSymbolSizeMismatchCount = new WeakMap();
 _FECManager_instances = new WeakSet();
 streamKey_fn = function(packetId, catalogTrackName) {
@@ -9773,6 +10339,14 @@ belongsToStream_fn = function(key, packetId, catalogTrackName) {
 packetIdsForStreamKeys_fn = function(keys) {
   return [...new Set([...keys].map((key) => Number(key.split(":", 1)[0])))];
 };
+parseStreamKey_fn = function(key) {
+  const separator = key.indexOf(":");
+  if (separator < 0) return { packetId: Number(key) || 0 };
+  return {
+    packetId: Number(key.slice(0, separator)) || 0,
+    catalogTrackName: decodeURIComponent(key.slice(separator + 1))
+  };
+};
 blockKey_fn = function(sbn, packetId, catalogTrackName) {
   const base = `${packetId}:${sbn}`;
   return catalogTrackName === void 0 ? base : `${base}:${encodeURIComponent(catalogTrackName)}`;
@@ -9792,6 +10366,18 @@ decoderForPacket_fn = function(packetId, catalogTrackName) {
 workerForPacket_fn = function(packetId, catalogTrackName) {
   return __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId, catalogTrackName)) ?? __privateGet(this, _workerClients).get(__privateMethod(this, _FECManager_instances, streamKey_fn).call(this, packetId));
 };
+/**
+ * The stream's Worker client for routing, or undefined after evicting a
+ * registered client that was already disposed. A disposed client throws on
+ * every command, so it leaves routing here before a symbol reaches it and
+ * the stream reports its decoder unavailable instead.
+ */
+routableWorkerForPacket_fn = function(packetId, catalogTrackName) {
+  const client = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+  if (client === void 0 || client.disposed !== true) return client;
+  __privateMethod(this, _FECManager_instances, evictDisposedWorker_fn).call(this, client);
+  return void 0;
+};
 claimDecoderBlock_fn = function(client, sbn, catalogTrackName) {
   let blocks = __privateGet(this, _decoderBlockOwners).get(client);
   if (!blocks) {
@@ -9959,7 +10545,7 @@ armBlockTimeout_fn = function(sbn, packetId, catalogTrackName, delayMs) {
       __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, sbn, packetId, false, catalogTrackName);
       return;
     }
-    const workerClient = __privateMethod(this, _FECManager_instances, workerForPacket_fn).call(this, packetId, catalogTrackName);
+    const workerClient = __privateMethod(this, _FECManager_instances, routableWorkerForPacket_fn).call(this, packetId, catalogTrackName);
     if (workerClient) {
       __privateGet(this, _pendingWorkerCleanups).add(key);
       __privateGet(this, _pendingWorkerCleanupClients).set(key, workerClient);
@@ -10042,6 +10628,59 @@ markStartupPartial_fn = function(blockKey) {
     ));
   }
 };
+/**
+ * Take a Worker client out of routing under one stream key, fail the blocks
+ * whose completion it still owed, and report the stream's decoder
+ * unavailable together with whatever still decodes the stream.
+ */
+retireWorker_fn = function(streamKey, client, reason) {
+  __privateGet(this, _workerClients).delete(streamKey);
+  __privateMethod(this, _FECManager_instances, releaseWorkerClient_fn).call(this, client);
+  __privateWrapper(this, _decoderUnavailableEvents)._++;
+  const stream = __privateMethod(this, _FECManager_instances, parseStreamKey_fn).call(this, streamKey);
+  const fallbackDecoder = __privateMethod(this, _FECManager_instances, decoderForPacket_fn).call(this, stream.packetId, stream.catalogTrackName) ? "sync" : "none";
+  this.onDecoderUnavailable?.({
+    packetId: stream.packetId,
+    ...stream.catalogTrackName === void 0 ? {} : { catalogTrackName: stream.catalogTrackName },
+    reason,
+    fallbackDecoder
+  });
+};
+/**
+ * Fail every block whose Worker cleanup acknowledgement is owed by `client`
+ * and drop its block ownership, so no block waits on a message the Worker
+ * will never post.
+ */
+releaseWorkerClient_fn = function(client) {
+  const owed = [...__privateGet(this, _pendingWorkerCleanupClients)].filter(([, owner]) => owner === client).map(([key]) => key);
+  for (const key of owed) __privateMethod(this, _FECManager_instances, settleOwedCleanup_fn).call(this, key, "decoder-unavailable");
+  __privateGet(this, _decoderBlockOwners).delete(client);
+};
+/**
+ * Resolve one owed Worker cleanup: drop the pending entry and fail the block
+ * unless it already completed. Shared by the cleanup acknowledgement and by
+ * Worker retirement, so the two paths cannot drift in their bookkeeping.
+ */
+settleOwedCleanup_fn = function(key, event) {
+  __privateGet(this, _pendingWorkerCleanups).delete(key);
+  __privateGet(this, _pendingWorkerCleanupClients).delete(key);
+  if (__privateGet(this, _completedBlocks).has(key)) return;
+  const block = __privateMethod(this, _FECManager_instances, parseBlockKey_fn).call(this, key);
+  __privateMethod(this, _FECManager_instances, traceLifecycle_fn).call(this, event, block.sbn, block.packetId, block.catalogTrackName);
+  __privateMethod(this, _FECManager_instances, failBlock_fn).call(this, block.sbn, block.packetId, false, block.catalogTrackName);
+};
+/** Evict a disposed client under every stream key that still maps to it. */
+evictDisposedWorker_fn = function(client) {
+  for (const [key, registered] of [...__privateGet(this, _workerClients)]) {
+    if (registered !== client) continue;
+    const stream = __privateMethod(this, _FECManager_instances, parseStreamKey_fn).call(this, key);
+    const track = stream.catalogTrackName === void 0 ? "" : ` track=${stream.catalogTrackName}`;
+    console.warn(
+      `[FECManager] packetId=${stream.packetId}${track} Worker decoder was disposed while still registered; evicting it`
+    );
+    __privateMethod(this, _FECManager_instances, retireWorker_fn).call(this, key, client, "disposed");
+  }
+};
 routeSyncCleanup_fn = function(decoder, sbn, packetId) {
   let framed;
   try {
@@ -10613,13 +11252,15 @@ function sameTrack(a, b) {
 function sameSample(a, b) {
   return a.decodeTime === b.decodeTime && a.presentationTime === b.presentationTime && a.duration === b.duration && a.timescale === b.timescale && a.size === b.size && a.bytePosition === b.bytePosition;
 }
-var _track, _fragments, _pendingSamples;
+var _track, _fragments, _pendingSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, clearSlot_fn;
 var IsoBmffTimingResolver = class {
   constructor(maxPendingSamples) {
     this.maxPendingSamples = maxPendingSamples;
+    __privateAdd(this, _IsoBmffTimingResolver_instances);
     __privateAdd(this, _track, null);
     __privateAdd(this, _fragments, /* @__PURE__ */ new Map());
     __privateAdd(this, _pendingSamples, 0);
+    __privateAdd(this, _lastMovieFragmentRejection, null);
     if (!Number.isInteger(maxPendingSamples) || maxPendingSamples <= 0) {
       throw new Error("[IsoBmffTimingResolver] maxPendingSamples must be a positive integer");
     }
@@ -10627,6 +11268,10 @@ var IsoBmffTimingResolver = class {
   get pendingSampleCount() {
     return __privateGet(this, _pendingSamples);
   }
+  /** Typed reason for the most recent rejected movie fragment. */
+  get lastMovieFragmentRejection() {
+    return __privateGet(this, _lastMovieFragmentRejection);
+  }
   addInitialization(data) {
     const timing = parseIsoBmffInitializationTiming(data);
     if (!timing) return false;
@@ -10635,14 +11280,24 @@ var IsoBmffTimingResolver = class {
     return true;
   }
   addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
-    if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) return false;
-    if (!__privateGet(this, _track) || !isU322(mpuSequenceNumber)) return false;
+    __privateSet(this, _lastMovieFragmentRejection, null);
+    if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
+    if (!__privateGet(this, _track) || !isU322(mpuSequenceNumber)) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
     const parsed = parseIsoBmffMovieFragmentTiming(
       data,
       __privateGet(this, _track),
       this.maxPendingSamples
     );
-    if (!parsed) return false;
+    if (!parsed) {
+      __privateSet(this, _lastMovieFragmentRejection, "invalid");
+      return false;
+    }
     const key = fragmentKey(mpuSequenceNumber, parsed.movieFragmentSequenceNumber);
     const existing = __privateGet(this, _fragments).get(key);
     if (existing) {
@@ -10650,8 +11305,14 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
-    if (parsed.samples.length > additionalSampleLimit) return false;
-    if (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples) return false;
+    if (parsed.samples.length > additionalSampleLimit) {
+      __privateSet(this, _lastMovieFragmentRejection, "budget");
+      return false;
+    }
+    if (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples) {
+      __privateSet(this, _lastMovieFragmentRejection, "budget");
+      return false;
+    }
     __privateGet(this, _fragments).set(key, [...parsed.samples]);
     __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) + parsed.samples.length);
     return true;
@@ -10666,15 +11327,36 @@ var IsoBmffTimingResolver = class {
     return samples?.[sampleNumber - 1] ?? null;
   }
   consumeSample(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, expected) {
-    const key = fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber);
-    const samples = __privateGet(this, _fragments).get(key);
-    const index = sampleNumber - 1;
-    const sample = samples?.[index];
-    if (!samples || !sample || !sameSample(sample, expected)) return false;
-    samples[index] = null;
-    __privateWrapper(this, _pendingSamples)._--;
-    if (samples.every((value) => value === null)) __privateGet(this, _fragments).delete(key);
-    return true;
+    const samples = __privateGet(this, _fragments).get(
+      fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber)
+    );
+    const sample = samples?.[sampleNumber - 1];
+    if (!sample || !sameSample(sample, expected)) return false;
+    return __privateMethod(this, _IsoBmffTimingResolver_instances, clearSlot_fn).call(this, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber);
+  }
+  /**
+   * Free the budget slot of a sample that will never be delivered.
+   *
+   * `consumeSample` is the delivery path and is the only decrement on a
+   * healthy stream. But a sample whose data units never complete is never
+   * delivered, and without this path its slot is held until `reset()` --
+   * making `maxPendingSamples` a one-way ratchet. Once it saturates,
+   * `addMovieFragment` rejects every subsequent moof and the stream is
+   * wedged permanently: the consumer sees media stop with no error, and only
+   * a full track reset clears it.
+   *
+   * The caller is whoever abandoned the sample, so the release is driven by
+   * the abandonment itself rather than by a timer, an LRU, or an age bound --
+   * the slot is freed exactly when its sample provably cannot arrive, which
+   * is a protocol event the combiner already detects and counts.
+   *
+   * Deliberately takes no `expected` timing: the caller is discarding, not
+   * matching, and requiring it would make the release fail exactly when the
+   * timing entry is the thing being reclaimed. Returns false when the slot
+   * was already freed, so a double release cannot drive the count negative.
+   */
+  releaseSample(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
+    return __privateMethod(this, _IsoBmffTimingResolver_instances, clearSlot_fn).call(this, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber);
   }
   reset() {
     __privateSet(this, _track, null);
@@ -10685,6 +11367,22 @@ var IsoBmffTimingResolver = class {
 _track = new WeakMap();
 _fragments = new WeakMap();
 _pendingSamples = new WeakMap();
+_lastMovieFragmentRejection = new WeakMap();
+_IsoBmffTimingResolver_instances = new WeakSet();
+/** Null one slot, decrement the budget, and drop the fragment when empty. */
+clearSlot_fn = function(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
+  if (!isU322(mpuSequenceNumber) || !isU322(movieFragmentSequenceNumber) || movieFragmentSequenceNumber === 0 || !isU322(sampleNumber) || sampleNumber === 0) {
+    return false;
+  }
+  const key = fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber);
+  const samples = __privateGet(this, _fragments).get(key);
+  const index = sampleNumber - 1;
+  if (!samples || !samples[index]) return false;
+  samples[index] = null;
+  __privateWrapper(this, _pendingSamples)._--;
+  if (samples.every((value) => value === null)) __privateGet(this, _fragments).delete(key);
+  return true;
+};
 function fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber) {
   return `${mpuSequenceNumber}:${movieFragmentSequenceNumber}`;
 }
@@ -10849,7 +11547,7 @@ function isFmp4Box(data) {
   const type = String.fromCharCode(data[4], data[5], data[6], data[7]);
   return FMPU_BOX_TYPES.has(type);
 }
-var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _sequencers, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed2, _MmtpContainerParser_instances, streamKey_fn2, sampleCombinerFor_fn, dropSampleCombiner_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
+var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _rejectedMovieFragments, _sequencers, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed2, _MmtpContainerParser_instances, streamKey_fn2, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
 var _MmtpContainerParser = class _MmtpContainerParser {
   constructor(config) {
     __privateAdd(this, _MmtpContainerParser_instances);
@@ -10882,6 +11580,8 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     __privateAdd(this, _timingStreams, /* @__PURE__ */ new Map());
     __privateAdd(this, _maxPendingTimingSamples);
     __privateAdd(this, _pendingTimingSamples, 0);
+    __privateAdd(this, _reclaimedTimingSamples, 0);
+    __privateAdd(this, _rejectedMovieFragments, 0);
     __privateAdd(this, _sequencers, /* @__PURE__ */ new Map());
     __privateAdd(this, _reorderWindow, 0);
     __privateAdd(this, _reassemblyPolicy, null);
@@ -10995,6 +11695,23 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     }
     return total;
   }
+  /**
+   * Typed view of the ISO-BMFF timing-sample budget.
+   *
+   * This is the acceptance signal for the budget ratchet: `pending` walking
+   * to `capacity` while `rejectedMovieFragments` climbs is the stream wedging,
+   * and it is observable here rather than only as media silently stopping.
+   * Per repo policy this is a producer-owned counter -- never infer budget
+   * state by parsing logs.
+   */
+  get timingBudgetStats() {
+    return {
+      pending: __privateGet(this, _pendingTimingSamples),
+      capacity: __privateGet(this, _maxPendingTimingSamples),
+      reclaimed: __privateGet(this, _reclaimedTimingSamples),
+      rejectedMovieFragments: __privateGet(this, _rejectedMovieFragments)
+    };
+  }
   get reorderStats() {
     let bufferedFrames = 0;
     for (const { sequencer } of __privateGet(this, _sequencers).values()) bufferedFrames += sequencer.buffered;
@@ -11007,6 +11724,20 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     }
     return streams;
   }
+  /**
+   * Reclaim samples abandoned by the sample combiner's protocol deadline.
+   *
+   * This is deliberately driven by the parser's existing packet/lifecycle
+   * cleanup path rather than by another timer. The reassembler timeout is the
+   * same catalog/FEC-derived deadline that bounds each constituent MFU.
+   */
+  cleanupTimeouts() {
+    const timeoutMs = __privateGet(this, _reassembler).timeoutMs;
+    if (timeoutMs === null) return;
+    for (const combiner of __privateGet(this, _sampleCombiners).values()) {
+      combiner.cleanupTimeouts(timeoutMs);
+    }
+  }
   /**
    * Phase 1 of two-phase parsing. Returns structured header info for FEC feeding.
    * Call this before feed() when you need to extract FEC payload ID and feed
@@ -11037,6 +11768,7 @@ var _MmtpContainerParser = class _MmtpContainerParser {
   feed(packet, options) {
     var _a;
     if (__privateGet(this, _disposed2)) return null;
+    this.cleanupTimeouts();
     const info = this.parseHeader(packet, options);
     if (!info) return null;
     if (info.packetType !== PACKET_TYPE_MPU2) {
@@ -11064,13 +11796,15 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     const streamKey = __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn2).call(this, info.packetId, options?.catalogTrackName);
     if (fragmentType === 0) {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0) return null;
+      const normalizedInit = normalizeMmtpInitSegment(data);
+      if (!normalizedInit) return null;
       const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, true);
-      if (!resolver2?.addInitialization(data)) return null;
-      (_a = __privateGet(this, _initCb)) == null ? void 0 : _a.call(this, data, info.packetId, options?.catalogTrackName);
+      if (!resolver2?.addInitialization(normalizedInit)) return null;
+      (_a = __privateGet(this, _initCb)) == null ? void 0 : _a.call(this, normalizedInit, info.packetId, options?.catalogTrackName);
       return {
         kind: "init",
         packet: info,
-        data,
+        data: normalizedInit,
         mpuSequenceNumber: mpu.mpuSequenceNumber,
         fragmentationIndicator: mpu.fragmentationIndicator,
         fragmentCounter: mpu.fragmentCounter
@@ -11082,7 +11816,12 @@ var _MmtpContainerParser = class _MmtpContainerParser {
       if (!resolver2) return null;
       const pendingBefore = resolver2.pendingSampleCount;
       const remaining = __privateGet(this, _maxPendingTimingSamples) - __privateGet(this, _pendingTimingSamples);
-      if (!resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining)) return null;
+      if (!resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining)) {
+        if (resolver2.lastMovieFragmentRejection === "budget") {
+          __privateWrapper(this, _rejectedMovieFragments)._++;
+        }
+        return null;
+      }
       __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) + (resolver2.pendingSampleCount - pendingBefore));
       return {
         kind: "fragment",
@@ -11144,7 +11883,7 @@ var _MmtpContainerParser = class _MmtpContainerParser {
         packetId: info.packetId
       });
     } catch (error) {
-      if (!(error instanceof MfuReassemblyError)) throw error;
+      if (!isMfuReassemblyError(error)) throw error;
       console.warn(
         `[MmtpContainerParser] rejected MFU fragment: code=${error.code} mpu=${mpu.mpuSequenceNumber} fi=${mpu.fragmentationIndicator} counter=${mpu.fragmentCounter}`
       );
@@ -11368,6 +12107,8 @@ _retiredSampleCombinerStats = new WeakMap();
 _timingStreams = new WeakMap();
 _maxPendingTimingSamples = new WeakMap();
 _pendingTimingSamples = new WeakMap();
+_reclaimedTimingSamples = new WeakMap();
+_rejectedMovieFragments = new WeakMap();
 _sequencers = new WeakMap();
 _reorderWindow = new WeakMap();
 _reassemblyPolicy = new WeakMap();
@@ -11385,11 +12126,42 @@ streamKey_fn2 = function(packetId, catalogTrackName) {
 sampleCombinerFor_fn = function(streamKey) {
   let combiner = __privateGet(this, _sampleCombiners).get(streamKey);
   if (combiner === void 0) {
-    combiner = new SampleCombiner(__privateGet(this, _sampleCombinerOptions));
+    combiner = new SampleCombiner({
+      ...__privateGet(this, _sampleCombinerOptions),
+      onAbandon: (sample) => __privateMethod(this, _MmtpContainerParser_instances, releaseTimingSlot_fn).call(this, streamKey, sample)
+    });
     __privateGet(this, _sampleCombiners).set(streamKey, combiner);
   }
   return combiner;
 };
+/**
+ * Return the timing budget slot of a sample the combiner abandoned.
+ *
+ * Without this, `#pendingTimingSamples` is a one-way ratchet: it is charged
+ * for every sample a moof declares but credited only when that sample is
+ * delivered, so each sample lost to eviction or timeout permanently burns a
+ * slot. At saturation `addMovieFragment` rejects every subsequent moof and
+ * every FT=2 data unit is dropped -- media stops with no error surfaced and
+ * nothing short of a track reset recovers.
+ *
+ * The parser total is decremented only when the resolver reports it
+ * actually freed a slot, so a resolver already dropped by a track reset, or
+ * a sample released twice, cannot drive the accounting negative.
+ */
+releaseTimingSlot_fn = function(streamKey, sample) {
+  const resolver = __privateGet(this, _timingStreams).get(streamKey)?.resolver;
+  if (!resolver) return;
+  if (!resolver.releaseSample(
+    sample.mpuSequenceNumber,
+    sample.movieFragmentSequenceNumber,
+    sample.sampleNumber
+  )) return;
+  __privateWrapper(this, _pendingTimingSamples)._--;
+  __privateWrapper(this, _reclaimedTimingSamples)._++;
+  if (__privateGet(this, _pendingTimingSamples) < 0) {
+    throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");
+  }
+};
 /** Drop one stream's combiner, folding its counters into the retained
  *  totals so a reset cannot make the exposed stats run backwards. */
 dropSampleCombiner_fn = function(streamKey) {
@@ -11473,7 +12245,7 @@ validateReassemblyPolicy_fn = function(policy = __privateGet(this, _reassemblyPo
   mmtpFrameReorderWindowFrames(policy, reorderWindow);
 };
 buildFrameMeta_fn = function(assembled, packetId, seq, timing, recovered = false) {
-  const { data, timestamp: mmtpTimestamp, rapFlag, priority } = assembled;
+  const { data, rapFlag, priority } = assembled;
   if (isFmp4Box(data)) return null;
   const presentationTimestamp = mediaTicksToMicroseconds(
     timing.presentationTime,
@@ -11512,7 +12284,7 @@ buildFrameMeta_fn = function(assembled, packetId, seq, timing, recovered = false
     ...assembled.packetSequenceNumbers === void 0 ? {} : { packetSequenceNumbers: assembled.packetSequenceNumbers },
     ...assembled.repairedPacketSequenceNumbers === void 0 ? {} : { repairedPacketSequenceNumbers: assembled.repairedPacketSequenceNumbers },
     ...assembled.catalogTrackName === void 0 ? {} : { catalogTrackName: assembled.catalogTrackName },
-    mmtpTimestamp,
+    ...assembled.mmtpTimestamp === void 0 ? {} : { mmtpTimestamp: assembled.mmtpTimestamp },
     mpuSequenceNumber: assembled.mpuSequenceNumber,
     ...assembled.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: assembled.movieFragmentSequenceNumber },
     ...assembled.sampleNumber === void 0 ? {} : { sampleNumber: assembled.sampleNumber },
@@ -11527,7 +12299,7 @@ buildFrameMeta_fn = function(assembled, packetId, seq, timing, recovered = false
   }
   return meta;
 };
-sequencerFor_fn = function(packetId, _trackType, catalogTrackName) {
+sequencerFor_fn = function(packetId, _trackType2, catalogTrackName) {
   const windowSize = __privateGet(this, _reassemblyPolicy) ? mmtpFrameReorderWindowFrames(__privateGet(this, _reassemblyPolicy), __privateGet(this, _reorderWindow)) : __privateGet(this, _reorderWindow);
   if (windowSize <= 0) return null;
   const streamKey = __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn2).call(this, packetId, catalogTrackName);
@@ -11843,6 +12615,7 @@ var MmtpRouter = class {
       const isVideo = __privateMethod(this, _MmtpRouter_instances, classifyPacketId_fn).call(this, packetId) === true;
       const frameMeta = {
         timestamp: meta.timestamp,
+        ...meta.mmtpTimestamp === void 0 ? {} : { mmtpTimestamp: meta.mmtpTimestamp },
         keyframe: isVideo ? meta.keyframe : true,
         packetId,
         packetSequenceNumber: meta.packetSequenceNumber ?? __privateGet(this, _currentSeqNum),
@@ -11850,6 +12623,8 @@ var MmtpRouter = class {
         ...meta.packetSequenceNumbers === void 0 ? {} : { packetSequenceNumbers: meta.packetSequenceNumbers },
         ...meta.repairedPacketSequenceNumbers === void 0 ? {} : { repairedPacketSequenceNumbers: meta.repairedPacketSequenceNumbers },
         ...meta.mpuSequenceNumber === void 0 ? {} : { mpuSequenceNumber: meta.mpuSequenceNumber },
+        ...meta.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: meta.movieFragmentSequenceNumber },
+        ...meta.sampleNumber === void 0 ? {} : { sampleNumber: meta.sampleNumber },
         ...meta.catalogTrackName === void 0 ? {} : { catalogTrackName: meta.catalogTrackName }
       };
       if (meta.source) frameMeta.source = meta.source;
@@ -11873,7 +12648,10 @@ var MmtpRouter = class {
             frameMeta.packetSequenceNumbers,
             frameMeta.repairedPacketSequenceNumbers,
             frameMeta.authoredTiming,
-            frameMeta.deliveryProvenance
+            frameMeta.deliveryProvenance,
+            frameMeta.mmtpTimestamp,
+            frameMeta.movieFragmentSequenceNumber,
+            frameMeta.sampleNumber
           );
         } else {
           assembler.addBypassFrame(
@@ -11886,7 +12664,10 @@ var MmtpRouter = class {
             frameMeta.packetSequenceNumbers,
             frameMeta.repairedPacketSequenceNumbers,
             frameMeta.authoredTiming,
-            frameMeta.deliveryProvenance
+            frameMeta.deliveryProvenance,
+            frameMeta.mmtpTimestamp,
+            frameMeta.movieFragmentSequenceNumber,
+            frameMeta.sampleNumber
           );
         }
       }
@@ -12955,7 +13736,10 @@ isCatalogTrackUnambiguous_fn = function(packetId, catalogTrackName) {
 };
 resolveRecoveredTiming_fn = function(packetId, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, mmtpTimestamp, catalogTrackName) {
   if (movieFragmentSequenceNumber === void 0 || sampleNumber === void 0) {
-    return { timestamp: mmtpTimestampToMicros(Number(mmtpTimestamp)) };
+    return {
+      timestamp: mmtpTimestampToMicros(mmtpTimestamp),
+      mmtpTimestamp
+    };
   }
   const authoredTiming = __privateGet(this, _parser).consumeAuthoredTimingFor(
     packetId,
@@ -12967,7 +13751,7 @@ resolveRecoveredTiming_fn = function(packetId, mpuSequenceNumber, movieFragmentS
   if (authoredTiming === null) return null;
   const scaled = scaleAuthoredTiming(authoredTiming, 1e6);
   if (scaled === null) return null;
-  return { authoredTiming, timestamp: scaled.timestamp };
+  return { authoredTiming, timestamp: scaled.timestamp, mmtpTimestamp };
 };
 packetSeqKey_fn = function(packetId, packetSequenceNumber, catalogTrackName) {
   return JSON.stringify([packetId, catalogTrackName ?? null, packetSequenceNumber]);
@@ -13266,12 +14050,15 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
         frames.push({
           data: sym.fragment.data,
           timestamp: recoveredTiming.timestamp,
+          mmtpTimestamp: recoveredTiming.mmtpTimestamp,
           keyframe,
           authoredTiming: recoveredTiming.authoredTiming,
           packetSequenceNumber: sym.packetSequenceNumber,
           packetSequenceNumbers: [sym.packetSequenceNumber],
           repairedPacketSequenceNumbers: [sym.packetSequenceNumber],
           mpuSequenceNumber: sym.fragment.mpuSequenceNumber,
+          ...sym.fragment.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: sym.fragment.movieFragmentSequenceNumber },
+          ...sym.fragment.sampleNumber === void 0 ? {} : { sampleNumber: sym.fragment.sampleNumber },
           ...catalogTrackName === void 0 ? {} : { catalogTrackName },
           // A single-packet MFU needs the block verdict just as much as a
           // reassembled one. The multi-fragment branch below gets it via the
@@ -13311,7 +14098,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
             ...catalogTrackName === void 0 ? {} : { catalogTrackName }
           });
         } catch (error) {
-          if (!(error instanceof MfuReassemblyError)) throw error;
+          if (!isMfuReassemblyError(error)) throw error;
           console.warn(
             `[MmtpRouter] dropped rejected recovered MFU fragment: block=${blockId} packetId=${ownerPacketId} code=${error.code}`
           );
@@ -13329,6 +14116,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
           frames.push({
             data: assembled.data,
             timestamp: recoveredTiming.timestamp,
+            mmtpTimestamp: recoveredTiming.mmtpTimestamp,
             keyframe,
             authoredTiming: recoveredTiming.authoredTiming,
             // The singular delivery identity is the fragment that completed
@@ -13339,6 +14127,8 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
               repairedPacketSequenceNumbers: assembled.repairedPacketSequenceNumbers
             },
             mpuSequenceNumber: assembled.mpuSequenceNumber,
+            ...assembled.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: assembled.movieFragmentSequenceNumber },
+            ...assembled.sampleNumber === void 0 ? {} : { sampleNumber: assembled.sampleNumber },
             ...assembled.catalogTrackName === void 0 ? {} : { catalogTrackName: assembled.catalogTrackName },
             deliveryProvenance: assembled.deliveryProvenance
           });
@@ -13384,6 +14174,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
         if (!recoveredTiming) continue;
         __privateGet(this, _parser).routeFrame(d, {
           timestamp: recoveredTiming.timestamp,
+          mmtpTimestamp: recoveredTiming.mmtpTimestamp,
           authoredTiming: recoveredTiming.authoredTiming,
           keyframe,
           packetId: ownerPacketId,
@@ -13392,6 +14183,8 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
           packetSequenceNumbers: [sym.packetSequenceNumber],
           repairedPacketSequenceNumbers: [sym.packetSequenceNumber],
           mpuSequenceNumber: sym.fragment.mpuSequenceNumber,
+          ...sym.fragment.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: sym.fragment.movieFragmentSequenceNumber },
+          ...sym.fragment.sampleNumber === void 0 ? {} : { sampleNumber: sym.fragment.sampleNumber },
           recovered: true,
           deliveryProvenance,
           ...catalogTrackName === void 0 ? {} : { catalogTrackName }
@@ -13426,7 +14219,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
             ...catalogTrackName === void 0 ? {} : { catalogTrackName }
           });
         } catch (error) {
-          if (!(error instanceof MfuReassemblyError)) throw error;
+          if (!isMfuReassemblyError(error)) throw error;
           console.warn(
             `[MmtpRouter] dropped rejected recovered MFU fragment: block=${blockId} packetId=${ownerPacketId} code=${error.code}`
           );
@@ -13443,6 +14236,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
           if (!recoveredTiming) continue;
           __privateGet(this, _parser).routeFrame(assembled.data, {
             timestamp: recoveredTiming.timestamp,
+            mmtpTimestamp: recoveredTiming.mmtpTimestamp,
             authoredTiming: recoveredTiming.authoredTiming,
             keyframe,
             packetId: ownerPacketId,
@@ -13453,6 +14247,8 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
               repairedPacketSequenceNumbers: assembled.repairedPacketSequenceNumbers
             },
             mpuSequenceNumber: assembled.mpuSequenceNumber,
+            ...assembled.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: assembled.movieFragmentSequenceNumber },
+            ...assembled.sampleNumber === void 0 ? {} : { sampleNumber: assembled.sampleNumber },
             recovered: true,
             deliveryProvenance,
             ...assembled.catalogTrackName === void 0 ? {} : { catalogTrackName: assembled.catalogTrackName }
@@ -13470,6 +14266,7 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
       if (recoveredTiming === null) continue;
       const meta = {
         timestamp: recoveredTiming.timestamp,
+        mmtpTimestamp: recoveredTiming.mmtpTimestamp,
         authoredTiming: recoveredTiming.authoredTiming,
         keyframe: true,
         packetId: ownerPacketId,
@@ -13477,6 +14274,8 @@ routeProcessedFecSymbols_fn = function(blockId, result, ownerPacketId, catalogTr
         packetSequenceNumbers: [sym.packetSequenceNumber],
         repairedPacketSequenceNumbers: [sym.packetSequenceNumber],
         mpuSequenceNumber: sym.fragment.mpuSequenceNumber,
+        ...sym.fragment.movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber: sym.fragment.movieFragmentSequenceNumber },
+        ...sym.fragment.sampleNumber === void 0 ? {} : { sampleNumber: sym.fragment.sampleNumber },
         recovered: true,
         ...catalogTrackName === void 0 ? {} : { catalogTrackName }
       };
@@ -13684,7 +14483,7 @@ refreshStats_fn = function() {
   this.stats.reassembledMFUs = asNumber(stats.reassembled_mfus);
   this.stats.rejectedFragments = __privateGet(this, _rejectedFragments);
   this.stats.timedOutMFUs = asNumber(stats.timed_out_mfus);
-  this.stats.evictedMemoryLimit = asNumber(stats.evicted_memory_limit);
+  this.stats.evictedMemoryLimit = asNumber(stats.evicted_memory_limit) + asNumber(stats.evicted_data_units ?? 0);
   this.stats.outOfOrderFragments = asNumber(stats.out_of_order_fragments);
   stats.free?.();
 };
@@ -14065,12 +14864,22 @@ function createDefaultRepairLifecycleEvent(detail, options) {
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isRepairBlockIdentity(value) {
+function isRepairStreamIdentity(value) {
   if (!isRecord(value)) return false;
   const packetId = value["packetId"];
   const catalogTrackName = value["catalogTrackName"];
+  return Number.isSafeInteger(packetId) && packetId >= 0 && (catalogTrackName === null || typeof catalogTrackName === "string" && catalogTrackName.length > 0);
+}
+function isRepairBlockIdentity(value) {
+  if (!isRecord(value)) return false;
   const sbn = value["sbn"];
-  return Number.isSafeInteger(packetId) && packetId >= 0 && (catalogTrackName === null || typeof catalogTrackName === "string" && catalogTrackName.length > 0) && Number.isSafeInteger(sbn) && sbn >= 0;
+  return isRepairStreamIdentity(value) && Number.isSafeInteger(sbn) && sbn >= 0;
+}
+function isDecoderUnavailableReason(value) {
+  return value === "cleared" || value === "disposed";
+}
+function isFecFallbackDecoder(value) {
+  return value === "sync" || value === "none";
 }
 function isRepairLifecycleEvent(value) {
   if (!isRecord(value)) return false;
@@ -14078,7 +14887,11 @@ function isRepairLifecycleEvent(value) {
   const type = value["type"];
   const block = value["block"];
   const symbols = value["symbols"];
-  if (version !== 1 || type !== "requested" && type !== "recovered" && type !== "failed" || !isRepairBlockIdentity(block)) {
+  if (version !== 1) return false;
+  if (type === "decoder-unavailable") {
+    return isRepairStreamIdentity(value["stream"]) && isDecoderUnavailableReason(value["reason"]) && isFecFallbackDecoder(value["fallbackDecoder"]) && block === void 0 && symbols === void 0;
+  }
+  if (type !== "requested" && type !== "recovered" && type !== "failed" || !isRepairBlockIdentity(block) || value["stream"] !== void 0 || value["reason"] !== void 0 || value["fallbackDecoder"] !== void 0) {
     return false;
   }
   if (type === "requested") return symbols === void 0;
@@ -14097,22 +14910,25 @@ function forwardRepairLifecycleEvents(source, target, options = {}) {
     target.dispatchEvent(forwardedEvent);
   });
 }
-function repairBlockIdentity(packetId, sbn, catalogTrackName) {
+function repairStreamIdentity(packetId, catalogTrackName) {
   if (!Number.isSafeInteger(packetId) || packetId < 0) {
     throw new TypeError("packetId must be a non-negative safe integer");
   }
-  if (!Number.isSafeInteger(sbn) || sbn < 0) {
-    throw new TypeError("sbn must be a non-negative safe integer");
-  }
   if (catalogTrackName !== void 0 && (typeof catalogTrackName !== "string" || catalogTrackName.length === 0)) {
     throw new TypeError("catalogTrackName must be a non-empty string when provided");
   }
   return {
     packetId,
-    catalogTrackName: catalogTrackName ?? null,
-    sbn
+    catalogTrackName: catalogTrackName ?? null
   };
 }
+function repairBlockIdentity(packetId, sbn, catalogTrackName) {
+  const stream = repairStreamIdentity(packetId, catalogTrackName);
+  if (!Number.isSafeInteger(sbn) || sbn < 0) {
+    throw new TypeError("sbn must be a non-negative safe integer");
+  }
+  return { ...stream, sbn };
+}
 function assertPositiveGeometry(label, value) {
   if (value === void 0) return;
   if (!Number.isFinite(value) || value <= 0) {
@@ -14282,6 +15098,15 @@ var MulticastManager = class {
         }
       });
     };
+    __privateGet(this, _fec).onDecoderUnavailable = (event) => {
+      __privateMethod(this, _MulticastManager_instances, emitRepairLifecycle_fn).call(this, {
+        version: 1,
+        type: "decoder-unavailable",
+        stream: repairStreamIdentity(event.packetId, event.catalogTrackName),
+        reason: event.reason,
+        fallbackDecoder: event.fallbackDecoder
+      });
+    };
   }
   // ---------------------------------------------------------------------------
   // Decomposed component accessors (for new code)
@@ -14336,6 +15161,17 @@ var MulticastManager = class {
     __privateMethod(this, _MulticastManager_instances, configureTrackMapper_fn).call(this, packetId, config);
     __privateGet(this, _router).setPacketIdType(packetId, trackType);
   }
+  /**
+   * Stop routing a stream's symbols to its Worker decoder. Returns false when
+   * none is registered; on success one `decoder-unavailable` repair lifecycle
+   * event with reason 'cleared' reaches every observer, carrying whether a
+   * synchronous WASM decoder still serves the stream. The packet mapping and
+   * track type are untouched: the track still exists, it just has no Worker
+   * decoder. Call this before disposing the client.
+   */
+  clearFecWorker(packetId, catalogTrackName) {
+    return __privateGet(this, _fec).clearFecWorker(packetId, catalogTrackName);
+  }
   /** Register callback for Worker-level FecTrackStats updates. */
   setOnFecStatsUpdate(cb) {
     __privateGet(this, _fec).onFecStatsUpdate = cb;
@@ -14381,8 +15217,9 @@ var MulticastManager = class {
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
       mediaUnitsPerSecond: config.fps,
-      bandwidthBps: config.bandwidth
-    }) + (config.fecReorderToleranceMs ?? 0) : void 0;
+      bandwidthBps: config.bandwidth,
+      jitterBufferMs: config.fecReorderToleranceMs
+    }) : void 0;
     const fecConfig = {
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
@@ -14419,8 +15256,9 @@ var MulticastManager = class {
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
       mediaUnitsPerSecond: config.fps,
-      bandwidthBps: config.bandwidth
-    }) + (config.fecReorderToleranceMs ?? 0) : void 0;
+      bandwidthBps: config.bandwidth,
+      jitterBufferMs: config.fecReorderToleranceMs
+    }) : void 0;
     __privateGet(this, _fec).configure({
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
@@ -14937,11 +15775,13 @@ applyStreamGlobalFecTiming_fn = function() {
 };
 _onTrackTypeDiscovered = new WeakMap();
 emitRepairLifecycle_fn = function(event) {
-  const immutableEvent = Object.freeze({
-    ...event,
-    block: Object.freeze({ ...event.block }),
-    ...event.type === "requested" ? {} : { symbols: Object.freeze({ ...event.symbols }) }
-  });
+  const immutableEvent = Object.freeze(
+    event.type === "decoder-unavailable" ? { ...event, stream: Object.freeze({ ...event.stream }) } : {
+      ...event,
+      block: Object.freeze({ ...event.block }),
+      ...event.type === "requested" ? {} : { symbols: Object.freeze({ ...event.symbols }) }
+    }
+  );
   console.info(
     `${REPAIR_LIFECYCLE_LOG_PREFIX}${JSON.stringify(immutableEvent)}`
   );
@@ -14965,7 +15805,8 @@ async function setupFecWorkerForTrack(opts) {
     sourceSymbols: opts.fecK,
     repairSymbols: opts.fecRepairCount,
     symbolSize: opts.fecSymbolSize,
-    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs
+    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
+    jitterBufferMs: opts.fecReorderToleranceMs
   });
   const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
   const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
@@ -15011,15 +15852,23 @@ async function setupFecWorkerForTrack(opts) {
     relayBlockSigEnabled: false
   };
   client.configure(fecTrackConfig, rqWasm, altaKeyBuffer, altaWasmModule);
-  opts.multicastManager.setFecWorker(opts.packetId, client, opts.trackType, {
-    k: opts.fecK,
-    symbolSize: opts.fecSymbolSize,
-    interleaveDepthMs: opts.fecInterleaveMs,
-    // FEC timing is expressed in media units. For audio this is the access-unit
-    // cadence (for example 1024/48kHz), not a video-only framerate field.
-    fps: 1e3 / opts.mediaUnitDurationMs,
-    timeoutMs: deliveryWindowMs
-  }, opts.trackName);
+  try {
+    opts.multicastManager.setFecWorker(opts.packetId, client, opts.trackType, {
+      k: opts.fecK,
+      symbolSize: opts.fecSymbolSize,
+      interleaveDepthMs: opts.fecInterleaveMs,
+      // FEC timing is expressed in media units. For audio this is the access-unit
+      // cadence (for example 1024/48kHz), not a video-only framerate field.
+      fps: 1e3 / opts.mediaUnitDurationMs,
+      timeoutMs: deliveryWindowMs
+    }, opts.trackName);
+  } catch (e) {
+    try {
+      client.dispose();
+    } catch {
+    }
+    throw e;
+  }
   let disposed = false;
   return {
     client,
@@ -15027,6 +15876,11 @@ async function setupFecWorkerForTrack(opts) {
     dispose: () => {
       if (disposed) return;
       disposed = true;
+      if (!opts.multicastManager.clearFecWorker(opts.packetId, opts.trackName)) {
+        console.warn(
+          `[fec-worker-setup] packetId=${opts.packetId} track=${opts.trackName} Worker was not registered when disposed`
+        );
+      }
       try {
         client.dispose();
       } catch {
@@ -15910,7 +16764,7 @@ _readIndex = new WeakMap();
 _stalled = new WeakMap();
 
 // src/mmtp-decode-pipeline.ts
-var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _gateDropped, _gateEmitted, _fedObjects, _warnedNoParser, _feedOutcomes, _MmtpDecodePipeline_instances, gatedEmit_fn;
+var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _trackType, _gateDropped, _gateEmitted, _fedObjects, _warnedNoParser, _feedOutcomes, _MmtpDecodePipeline_instances, tag_fn, gatedEmit_fn;
 var MmtpDecodePipeline = class {
   constructor() {
     __privateAdd(this, _MmtpDecodePipeline_instances);
@@ -15919,7 +16773,11 @@ var MmtpDecodePipeline = class {
     __privateAdd(this, _frameCb2, null);
     __privateAdd(this, _initCb2, null);
     __privateAdd(this, _needsKeyframe, false);
-    __privateAdd(this, _codec, "");
+    __privateAdd(this, _codec, null);
+    /** Set together with #codec at configure(). Also the diagnostic label: a
+     *  player builds one pipeline per track, and codec alone does not say which
+     *  role a line belongs to at a glance. */
+    __privateAdd(this, _trackType, null);
     /** Diagnostic counters. The keyframe gate drops silently, so a parser that
      *  never marks a frame as a keyframe stalls the whole pipeline with no
      *  output anywhere: frames are fed, frames are parsed, and nothing is
@@ -15948,6 +16806,7 @@ var MmtpDecodePipeline = class {
     __privateSet(this, _warnedNoParser, false);
     __privateSet(this, _codec, config.codec);
     const trackType = isVideoCodec(config.codec) ? "video" : "audio";
+    __privateSet(this, _trackType, trackType);
     const trackInfo = {
       type: trackType,
       codec: config.codec,
@@ -15991,6 +16850,24 @@ var MmtpDecodePipeline = class {
   get reorderStats() {
     return __privateGet(this, _parser2)?.reorderStats ?? null;
   }
+  /**
+   * Feed tallies for this track. A fresh snapshot per call, not a live view.
+   *
+   * Unlike reorderStats this never returns null: the counters belong to the
+   * pipeline rather than the parser, so they survive dispose(). That is
+   * deliberate — a wedged pipeline is usually read after teardown, which is
+   * exactly when the parser is already gone.
+   */
+  get feedStats() {
+    return {
+      trackType: __privateGet(this, _trackType),
+      codec: __privateGet(this, _codec),
+      fedObjects: __privateGet(this, _fedObjects),
+      emitted: __privateGet(this, _gateEmitted),
+      gateDropped: __privateGet(this, _gateDropped),
+      outcomes: Object.fromEntries(__privateGet(this, _feedOutcomes))
+    };
+  }
   /**
    * Feed a raw MoQ object payload (one MMTP packet per MoQ object).
    * Optionally feeds source symbols to FEC client before parsing.
@@ -15999,33 +16876,37 @@ var MmtpDecodePipeline = class {
     if (!__privateGet(this, _parser2)) {
       if (!__privateGet(this, _warnedNoParser)) {
         __privateSet(this, _warnedNoParser, true);
-        console.warn("[mmtp-pipeline] feedMoqObject called with NO PARSER configured \u2014 packet dropped");
+        console.warn(`[mmtp-pipeline] feedMoqObject called with NO PARSER configured ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} \u2014 packet dropped`);
       }
       return;
     }
     __privateSet(this, _fedObjects, __privateGet(this, _fedObjects) + 1);
     if (__privateGet(this, _fedObjects) === 1) {
-      console.log(`[mmtp-pipeline] first object fed codec=${__privateGet(this, _codec)} bytes=${packet.length}`);
+      console.log(`[mmtp-pipeline] first object fed ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${packet.length}`);
     }
-    if (__privateGet(this, _fecClient)?.addSourceSymbol) {
-      const info = __privateGet(this, _parser2).parseHeader(packet);
-      if (info?.fecPayloadId) {
-        __privateGet(this, _fecClient).addSourceSymbol(info.fecPayloadId.ssId, packet);
+    let outcomeKind = "threw";
+    try {
+      if (__privateGet(this, _fecClient)?.addSourceSymbol) {
+        const info = __privateGet(this, _parser2).parseHeader(packet);
+        if (info?.fecPayloadId) {
+          __privateGet(this, _fecClient).addSourceSymbol(info.fecPayloadId.ssId, packet);
+        }
+      }
+      const record = __privateGet(this, _parser2).feed(packet);
+      outcomeKind = record?.kind ?? "null(parse-or-extract-failed)";
+    } finally {
+      const seen = (__privateGet(this, _feedOutcomes).get(outcomeKind) ?? 0) + 1;
+      __privateGet(this, _feedOutcomes).set(outcomeKind, seen);
+      if (seen === 1) {
+        console.log(
+          `[mmtp-pipeline] feed outcome FIRST '${outcomeKind}' ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} at object #${__privateGet(this, _fedObjects)} bytes=${packet.length}`
+        );
       }
-    }
-    const record = __privateGet(this, _parser2).feed(packet);
-    const kind = record?.kind ?? "null(parse-or-extract-failed)";
-    const seen = (__privateGet(this, _feedOutcomes).get(kind) ?? 0) + 1;
-    __privateGet(this, _feedOutcomes).set(kind, seen);
-    if (seen === 1) {
-      console.log(
-        `[mmtp-pipeline] feed outcome FIRST '${kind}' at object #${__privateGet(this, _fedObjects)} bytes=${packet.length}`
-      );
     }
     if (__privateGet(this, _fedObjects) % 200 === 0) {
       const hist = [...__privateGet(this, _feedOutcomes)].map(([k, v]) => `${k}=${v}`).join(" ");
       console.log(
-        `[mmtp-pipeline] feed histogram @${__privateGet(this, _fedObjects)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
+        `[mmtp-pipeline] feed histogram ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} @${__privateGet(this, _fedObjects)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
       );
     }
   }
@@ -16042,9 +16923,13 @@ var MmtpDecodePipeline = class {
   feedAssembledFrame(data, meta) {
     const frameMeta = {
       timestamp: meta.timestamp,
+      ...meta.mmtpTimestamp === void 0 ? {} : { mmtpTimestamp: meta.mmtpTimestamp },
       keyframe: meta.keyframe,
       packetId: meta.packetId,
-      trackType: isVideoCodec(__privateGet(this, _codec)) ? "video" : "audio",
+      // Same derivation as configure(), read from the field it set rather than
+      // recomputed. Pre-configure the parser is null and routeFrame below is a
+      // no-op, so the fallback is unreachable in practice.
+      trackType: __privateGet(this, _trackType) ?? "audio",
       packetSequenceNumber: meta.packetSequenceNumber
     };
     if (meta.sourceDiscontinuity) frameMeta.sourceDiscontinuity = true;
@@ -16070,7 +16955,7 @@ var MmtpDecodePipeline = class {
     const droppedFrames = (__privateGet(this, _parser2)?.reorderStats.droppedOnLiveDispose ?? droppedBefore) - droppedBefore;
     if (droppedFrames > 0) {
       console.warn(
-        `[MmtpDecodePipeline] live dispose dropped ${droppedFrames} buffered frame(s); finite inputs must use dispose({ flush: true })`
+        `[MmtpDecodePipeline] live dispose ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} dropped ${droppedFrames} buffered frame(s); finite inputs must use dispose({ flush: true })`
       );
     }
     __privateSet(this, _parser2, null);
@@ -16085,12 +16970,19 @@ _frameCb2 = new WeakMap();
 _initCb2 = new WeakMap();
 _needsKeyframe = new WeakMap();
 _codec = new WeakMap();
+_trackType = new WeakMap();
 _gateDropped = new WeakMap();
 _gateEmitted = new WeakMap();
 _fedObjects = new WeakMap();
 _warnedNoParser = new WeakMap();
 _feedOutcomes = new WeakMap();
 _MmtpDecodePipeline_instances = new WeakSet();
+/** Identity prefix for diagnostics: one pipeline per track means two
+ *  instances write to the same console, and unlabelled lines interleave into
+ *  a single unreadable stream. */
+tag_fn = function() {
+  return `track=${__privateGet(this, _trackType) ?? "unconfigured"} codec=${__privateGet(this, _codec) ?? "none"}`;
+};
 gatedEmit_fn = function(data, meta) {
   var _a;
   let sourceDiscontinuity = false;
@@ -16099,7 +16991,7 @@ gatedEmit_fn = function(data, meta) {
       __privateSet(this, _gateDropped, __privateGet(this, _gateDropped) + 1);
       if (__privateGet(this, _gateDropped) <= 3 || __privateGet(this, _gateDropped) % 200 === 0) {
         console.warn(
-          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} codec=${__privateGet(this, _codec)} bytes=${data.length} fed=${__privateGet(this, _fedObjects)} emitted=${__privateGet(this, _gateEmitted)}`
+          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length} fed=${__privateGet(this, _fedObjects)} emitted=${__privateGet(this, _gateEmitted)}`
         );
       }
       return;
@@ -16107,12 +16999,12 @@ gatedEmit_fn = function(data, meta) {
     __privateSet(this, _needsKeyframe, false);
     sourceDiscontinuity = true;
     console.log(
-      `[mmtp-pipeline] keyframe gate OPENED codec=${__privateGet(this, _codec)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects)}`
+      `[mmtp-pipeline] keyframe gate OPENED ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects)}`
     );
   }
   __privateSet(this, _gateEmitted, __privateGet(this, _gateEmitted) + 1);
   if (__privateGet(this, _gateEmitted) === 1) {
-    console.log(`[mmtp-pipeline] first frame emitted codec=${__privateGet(this, _codec)} bytes=${data.length}`);
+    console.log(`[mmtp-pipeline] first frame emitted ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length}`);
   }
   const outMeta = sourceDiscontinuity ? { ...meta, sourceDiscontinuity: true } : meta;
   (_a = __privateGet(this, _frameCb2)) == null ? void 0 : _a.call(this, data, outMeta);
@@ -16786,6 +17678,24 @@ emit_fn = function(params) {
 };
 
 // src/catalog-fec-params.ts
+var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
+function timescaleHz(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function catalogGroupDurationMs(rendition) {
+  if (!rendition) return void 0;
+  const ticks = numericField(rendition.groupDurationTicks);
+  const ms = numericField(rendition.groupDurationMs);
+  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
+  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
+    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
+  }
+  return ms;
+}
+function resolveCatalogTrackGroupDurationMs(catalog, track) {
+  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
+  return catalogGroupDurationMs(renditions?.[track.name]);
+}
 var NO_FEC = {
   fecK: 0,
   fecRepairCount: 0,
@@ -16868,8 +17778,10 @@ function catalogAmtNetworkSource(networkSource) {
 // src/repair-fetch.ts
 function wireRepairFetch(mc, opts) {
   const inFlight = /* @__PURE__ */ new Map();
+  const warnedNoTarget = /* @__PURE__ */ new Set();
   let disposed = false;
   const requestKey = (sbn, packetId, catalogTrackName) => JSON.stringify([packetId, catalogTrackName ?? null, sbn]);
+  const noTargetKey = (packetId, catalogTrackName) => JSON.stringify([packetId, catalogTrackName ?? null]);
   const removeResetObserver = mc.addTrackResetObserver(
     (packetId, catalogTrackName) => {
       for (const [key, request] of inFlight) {
@@ -16878,6 +17790,7 @@ function wireRepairFetch(mc, opts) {
           inFlight.delete(key);
         }
       }
+      warnedNoTarget.delete(noTargetKey(packetId, catalogTrackName));
     }
   );
   const timeoutFor = (sbn, packetId, catalogTrackName) => opts.timeoutMsForPacket?.(packetId) ?? mc.fecManager.repairFetchTimeoutMsForBlock(
@@ -16916,6 +17829,13 @@ function wireRepairFetch(mc, opts) {
     }
     const target = opts.resolveTarget(packetId, catalogTrackName);
     if (!target) {
+      const warnKey = noTargetKey(packetId, catalogTrackName);
+      if (!warnedNoTarget.has(warnKey)) {
+        warnedNoTarget.add(warnKey);
+        console.warn(
+          `[RepairFetch] no repair target for pid=${packetId} sbn=${sbn}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`}; releasing without a fetch`
+        );
+      }
       clearRepair(sbn, packetId, catalogTrackName);
       return;
     }
@@ -16992,6 +17912,7 @@ export {
   FecStarvationDetector,
   KEYFRAME_LOST_TIMEOUT_SLACK,
   LOCHeaderExtensionId,
+  MAX_TAKEOVER_DEADLINE_MS,
   MFUReassembler,
   MediaRouter,
   MfuReassemblyError,
@@ -17022,6 +17943,7 @@ export {
   buildVideoInitSegment,
   catalogAmtNetworkSource,
   catalogFecInterleaveMs,
+  catalogGroupDurationMs,
   classifyH264Keyframe,
   classifyPacket,
   codecStringFromAvcC,
@@ -17068,6 +17990,7 @@ export {
   isFecCatalogConfig,
   isFmp4InitSegment,
   isHevcCodec,
+  isMfuReassemblyError,
   isMulticastCatalogConfig,
   isMulticastEndpoint,
   isMulticastTrackObject,
@@ -17083,6 +18006,7 @@ export {
   multicastFromConfig,
   multicastFromEnv,
   normalizeH264SampleToAvcc,
+  normalizeMmtpInitSegment,
   parseAacFrameSamples,
   parseAacSampleRate,
   parseOpusFrameSamples,
@@ -17090,6 +18014,7 @@ export {
   reliableMoqMfuReassembly,
   removeEmulationPrevention,
   resolveCatalogTrackFec,
+  resolveCatalogTrackGroupDurationMs,
   resolveGlobalMmtWasmBindings,
   resolveGroupDurationMs,
   resolveGroupDurationTicks,