@blockcast/mmt-container 2.1.0 → 2.2.0-main.050b52fb9b00

package/dist/mmtp-decode-pipeline.js

@@ -148,30 +148,26 @@ function isEmptyOrExactLegacyTrailer(payload, start, end) {
   const authLength = view2.getUint16(2, false);
   return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
 }
-function resolveDeclaredTrailers(payload, declaredEnd, fecType, options, rapFlag = false) {
+function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
   if (declaredEnd > payload.length)
     return null;
   if (options?.skipFecId) {
-    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false, hasOverlayFecId: false } : null;
+    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
   }
-  const overlay = options?.overlayDeclared === true && rapFlag;
   if (fecType === 1) {
-    const fecStart = payload.length - sourceFecTrailerSize(overlay);
+    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
     if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
       return null;
     }
-    return { hasFecId: true, hasOverlayFecId: overlay };
+    return { hasFecId: true };
   }
-  if (fecType !== 0 || overlay)
+  if (fecType !== 0)
     return null;
   if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
-    return { hasFecId: false, hasOverlayFecId: false };
+    return { hasFecId: false };
   }
   return null;
 }
-function sourceFecTrailerSize(overlay) {
-  return overlay ? 2 * SOURCE_FEC_PAYLOAD_ID_SIZE : SOURCE_FEC_PAYLOAD_ID_SIZE;
-}
 function planMfuExtraction(mmtpPacket, options, parsedHeader) {
   if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {
     return {
@@ -224,11 +220,11 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
   if ("rejection" in layoutResult)
     return layoutResult;
   const { layout } = layoutResult;
-  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options, header.rapFlag);
+  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
   if (!trailerLayout) {
     if (!options?.skipFecId && header.fecType === 1) {
       const observed = payload.length - layout.dataEnd;
-      const expected = sourceFecTrailerSize(options?.overlayDeclared === true && header.rapFlag);
+      const expected = SOURCE_FEC_PAYLOAD_ID_SIZE;
       if (observed !== expected) {
         return {
           rejection: {
@@ -260,13 +256,10 @@ function extractPlannedMfu(mmtpPacket, result) {
   const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE) : null;
   const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false) : null;
   const data = payload.subarray(mfuOffset, dataEnd);
-  const trailerStart = mmtpPacket.length - sourceFecTrailerSize(trailerLayout.hasOverlayFecId);
-  const ssIdAt = (offset) => ({
-    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + offset, 4).getUint32(0, false)
-  });
-  const fecPayloadId = trailerLayout.hasFecId ? ssIdAt(trailerStart) : null;
-  const overlayFecPayloadId = trailerLayout.hasOverlayFecId ? ssIdAt(trailerStart + SOURCE_FEC_PAYLOAD_ID_SIZE) : null;
-  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId, overlayFecPayloadId };
+  const fecPayloadId = trailerLayout.hasFecId ? {
+    ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, 4).getUint32(0, false)
+  } : null;
+  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
 }
 function sourceFecPayloadIdOf(mmtpPacket, header) {
   if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
@@ -4858,9 +4851,21 @@ var IsoBmffTimingResolver = class {
   }
   #track = null;
   #fragments = /* @__PURE__ */ new Map();
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = /* @__PURE__ */ new Map();
+  /**
+   * First sample and sample count of the newest fragments whose every slot was
+   * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+   * matches the combiner, since it retires an abandoned sample as well.
+   */
+  #delivered = /* @__PURE__ */ new Map();
   #pendingSamples = 0;
   #evictedSamples = 0;
   #lastMovieFragmentRejection = null;
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized() {
+    return this.#track !== null;
+  }
   get pendingSampleCount() {
     return this.#pendingSamples;
   }
@@ -4884,7 +4889,14 @@ var IsoBmffTimingResolver = class {
     this.#track = timing;
     return true;
   }
-  addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
+  /**
+   * `recovered` marks an FEC-recovered copy. A recovered block hands back
+   * every FT=1 it holds, the received ones included, so a recovered copy of a
+   * fragment whose samples are all done is a duplicate: admitting it again
+   * would charge stale timing and could displace the live MPU's. A source
+   * copy is still admitted again (a rendition switch re-arms timing that way).
+   */
+  addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
     this.#lastMovieFragmentRejection = null;
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
       this.#lastMovieFragmentRejection = "invalid";
@@ -4910,6 +4922,8 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
+    const delivered = recovered ? this.#delivered.get(key) : void 0;
+    if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
     let freed = 0;
     while (this.#fragments.size > 0 && (this.#pendingSamples + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
       freed += this.#evictOldestFragment();
@@ -4923,6 +4937,7 @@ var IsoBmffTimingResolver = class {
       return false;
     }
     this.#fragments.set(key, [...parsed.samples]);
+    this.#firstSamples.set(key, parsed.samples[0]);
     this.#pendingSamples += parsed.samples.length;
     return true;
   }
@@ -4980,6 +4995,7 @@ var IsoBmffTimingResolver = class {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     this.#fragments.delete(oldest);
+    this.#firstSamples.delete(oldest);
     this.#pendingSamples -= live;
     this.#evictedSamples += live;
     return live;
@@ -4995,12 +5011,23 @@ var IsoBmffTimingResolver = class {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     this.#pendingSamples--;
-    if (samples.every((value) => value === null)) this.#fragments.delete(key);
+    if (samples.every((value) => value === null)) {
+      this.#fragments.delete(key);
+      const first = this.#firstSamples.get(key);
+      this.#firstSamples.delete(key);
+      this.#delivered.delete(key);
+      this.#delivered.set(key, { first, sampleCount: samples.length });
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value);
+      }
+    }
     return true;
   }
   reset() {
     this.#track = null;
     this.#fragments.clear();
+    this.#firstSamples.clear();
+    this.#delivered.clear();
     this.#pendingSamples = 0;
   }
 };
@@ -5170,6 +5197,9 @@ function authoredGap(before, after) {
 function ssIdAfter(a, b) {
   return (a - b | 0) > 0;
 }
+function holdsRebuilt(stream) {
+  return stream.buf.some(({ meta }) => meta.fecSbnFirst !== void 0);
+}
 var FecReleaseSequencer = class {
   #streams = /* @__PURE__ */ new Map();
   #gate;
@@ -5232,6 +5262,7 @@ var FecReleaseSequencer = class {
       stream.lastSbn = void 0;
       stream.discontinuity = false;
       stream.rapSsId = void 0;
+      stream.sourced = false;
     }
     if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
       this.#recordStat("droppedStale");
@@ -5258,6 +5289,7 @@ var FecReleaseSequencer = class {
       if (compareFrameOrder(stream.buf[mid], frame) < 0) lo = mid + 1;
       else hi = mid;
     }
+    if (stream.buf[lo]?.passed === true) frame.passed = true;
     stream.buf.splice(lo, 0, frame);
     this.#drainUnlessDeferred(stream);
   }
@@ -5293,6 +5325,41 @@ var FecReleaseSequencer = class {
     }
     return false;
   }
+  /**
+   * These streams' sink is being replaced by one that has seen no source
+   * frame yet. First, from a stream that holds a frame the overlay rebuilt,
+   * release to the sink being replaced the frames the unanchored path had
+   * already released to it (#cursorPassed): there they waited in its queue,
+   * which its replacement flushes. A stream that holds none is not drained:
+   * it holds nothing the anchor kept back, and a drain would still force out
+   * a frame held past the hold limit, which before the anchor waited for the
+   * next push. Then treat the streams as unsourced until a source frame is
+   * released.
+   */
+  unsource(packetId, catalogTrackName) {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId === packetId && (catalogTrackName === void 0 || stream.catalogTrackName === catalogTrackName)) {
+        if (stream.draining === 0 && holdsRebuilt(stream)) {
+          if (this.#deferDepth > 0) this.#deferredStreams.add(stream);
+          else this.#drain(stream, true);
+        }
+        stream.sourced = false;
+      }
+    }
+  }
+  /**
+   * Whether a stream of `packetId` holds a frame the keyframe overlay rebuilt
+   * (FrameMeta.fecSbnFirst). Without `catalogTrackName`, every stream of the
+   * packetId.
+   */
+  holdsRebuilt(packetId, catalogTrackName) {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue;
+      if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+      if (holdsRebuilt(stream)) return true;
+    }
+    return false;
+  }
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey) {
     if (streamKey !== void 0) {
@@ -5384,16 +5451,32 @@ var FecReleaseSequencer = class {
         last: null,
         lastSbn: void 0,
         discontinuity: false,
-        rapSsId: void 0
+        rapSsId: void 0,
+        sourced: false,
+        draining: 0
       };
       this.#streams.set(streamKey, stream);
     }
     return stream;
   }
-  #drain(stream) {
+  /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
+  #drain(stream, asUnanchored = false) {
+    stream.draining++;
+    try {
+      this.#drainLoop(stream, asUnanchored);
+    } finally {
+      stream.draining--;
+    }
+  }
+  #drainLoop(stream, asUnanchored) {
     while (stream.buf.length > 0 && stream.last !== null) {
       const head = stream.buf[0];
       const last = stream.last;
+      if (compareFrameOrder(head, last) <= 0) {
+        stream.buf.shift();
+        this.#release(stream, head, void 0);
+        continue;
+      }
       if (stream.discontinuity) {
         stream.discontinuity = false;
         stream.buf.shift();
@@ -5407,9 +5490,10 @@ var FecReleaseSequencer = class {
       }
       const headSbn = head.meta.fecSbn;
       const from = stream.lastSbn ?? headSbn;
-      const to = headSbn ?? stream.lastSbn;
+      const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn;
       let lost = [];
       const unanchored = from === void 0 && to === void 0;
+      let unresolved = false;
       if (from !== void 0 && to !== void 0) {
         const resolved = this.#gate.resolvedLoss(
           stream.packetId,
@@ -5418,7 +5502,8 @@ var FecReleaseSequencer = class {
           Math.max(from, to),
           from
         );
-        if (resolved === null) {
+        unresolved = resolved === null;
+        if (unresolved && !this.#cursorPassed(stream, asUnanchored)) {
           const heldMs = performance.now() - head.arrivedAtMs;
           if (heldMs <= this.#gate.holdLimitMs(stream.packetId, stream.catalogTrackName)) return;
           this.#recordStat("forcedWindowFlushes");
@@ -5426,22 +5511,56 @@ var FecReleaseSequencer = class {
           this.#release(stream, head, this.#gate.decide(last, head, [], true));
           continue;
         }
-        lost = resolved;
+        lost = resolved ?? [];
       }
       stream.buf.shift();
       this.#release(
         stream,
         head,
-        lost.length > 0 || unanchored || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
+        lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
       );
     }
   }
+  /**
+   * An overlay-rebuilt frame (fecSbnFirst) waits no longer than the BLO-53342
+   * source cursor holds it unanchored, and neither does a later frame behind
+   * it. Unanchored, a frame that waits on no block (fecSbnFirst set, or no
+   * fecSbn) left the gate once every frame ahead of it had: mark it `passed`,
+   * like each frame that arrived in front of it since (stale there). The head
+   * then goes, decided as it would be unanchored, once a frame the base path
+   * delivered (a source frame, or one base FEC recovered) is buffered after a
+   * marked one: the base path has passed that one, so a frame still missing
+   * before it can only come from a repair. It also goes while no source frame
+   * has been released, when the direct path shows a recovered frame at once.
+   * And it goes at once while a staged switch decides on when frames arrive
+   * (FecReleaseGate.releaseUnanchored), and when unsource releases into a
+   * sink being replaced: unanchored, it had already reached the sink.
+   * The scan also writes: the `passed` marks it sets stay on the frames,
+   * and push marks a frame it inserts in front of a marked one from them.
+   */
+  #cursorPassed(stream, asUnanchored) {
+    let at = -1;
+    for (let i = 0; i < stream.buf.length; i++) {
+      const frame = stream.buf[i];
+      if (frame.meta.fecSbnFirst !== void 0 || frame.meta.fecSbn === void 0) {
+        frame.passed = true;
+        if (at < 0) at = i;
+      } else if (frame.passed !== true) break;
+    }
+    if (at < 0) return false;
+    return asUnanchored || !stream.sourced || this.#gate.releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at && meta.fecSbnFirst === void 0 && (meta.recovered !== true || meta.fecSbn !== void 0));
+  }
   #release(stream, frame, decision) {
+    const stale = stream.last !== null && compareFrameOrder(frame, stream.last) <= 0;
+    if (stale) this.#recordStat("droppedStale");
     if (decision) frame.meta.gapBefore = decision;
     stream.last = frame;
-    if (frame.meta.fecSbn !== void 0) stream.lastSbn = frame.meta.fecSbn;
+    if (frame.meta.fecSbn !== void 0 && (frame.meta.fecSbnFirst === void 0 || stream.lastSbn !== void 0)) {
+      stream.lastSbn = frame.meta.fecSbn;
+    }
+    if (frame.meta.recovered !== true) stream.sourced = true;
     this.#gate.onReleased?.(frame.data, frame.meta);
-    this.#emit(frame.data, frame.meta);
+    if (!stale) this.#emit(frame.data, frame.meta);
   }
 };
 var FMPU_BOX_TYPES = /* @__PURE__ */ new Set(["ftyp", "moov", "moof"]);
@@ -5482,6 +5601,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
     this.#reclaimedTimingSamples = 0;
     this.#evictedTimingSamples = 0;
     this.#rejectedMovieFragments = 0;
+    this.#recoveredHeadsAwaitingTiming = {
+      held: 0,
+      expired: 0,
+      discarded: 0,
+      superseded: 0
+    };
     this.#sequencers = /* @__PURE__ */ new Map();
     this.#fecGate = null;
     this.#fecSequencer = null;
@@ -5590,6 +5715,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
   #reclaimedTimingSamples;
   #evictedTimingSamples;
   #rejectedMovieFragments;
+  #recoveredHeadsAwaitingTiming;
   #sequencers;
   #fecGate;
   #fecSequencer;
@@ -5695,11 +5821,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
   /**
    * 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.
+   * Each stream admits timing against its own window of `capacity` slots
+   * (BLO-52085). A stream at capacity displaces its own oldest timing to
+   * admit the moof in hand, and `evicted` counts the slots so displaced:
+   * timing a stream declared and never delivered shows up there. `pending`
+   * sums every stream, so it can exceed `capacity`. Per repo policy this is
+   * a producer-owned counter -- never infer budget state by parsing logs.
    */
   get timingBudgetStats() {
     return {
@@ -5710,6 +5837,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
       rejectedMovieFragments: this.#rejectedMovieFragments
     };
   }
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming() {
+    let pending = 0;
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+    }
+    return { ...this.#recoveredHeadsAwaitingTiming, pending };
+  }
   get reorderStats() {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0;
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered;
@@ -5751,6 +5886,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
   fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
     return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
   }
+  /** See FecReleaseSequencer.unsource. */
+  unsourceFecRelease(packetId, catalogTrackName) {
+    this.#fecSequencer?.unsource(packetId, catalogTrackName);
+  }
+  /** See FecReleaseSequencer.holdsRebuilt. */
+  fecReleaseHoldsRebuilt(packetId, catalogTrackName) {
+    return this.#fecSequencer?.holdsRebuilt(packetId, catalogTrackName) ?? false;
+  }
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId, catalogTrackName) {
     if (!this.#fecSequencer) return;
@@ -5883,7 +6026,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const now = Date.now();
     for (const { awaitingTiming } of this.#timingStreams.values()) {
       while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-        awaitingTiming.shift();
+        this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
       }
     }
   }
@@ -6001,11 +6144,16 @@ var MmtpContainerParser = class _MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop("fragment-unexpected-fragmentation");
       const resolver2 = this.#timingResolver(streamKey, info.packetId, false);
-      if (!resolver2) return this.#drop("fragment-no-resolver");
+      if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
-      const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
-      const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+      const remaining = this.#maxPendingTimingSamples - resolver2.pendingSampleCount;
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       this.#pendingTimingSamples += resolver2.pendingSampleCount - pendingBefore;
       this.#evictedTimingSamples += resolver2.evictedSampleCount - evictedBefore;
       if (!admitted) {
@@ -6025,7 +6173,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
       };
     }
     if (fragmentType !== 2) return this.#drop("unknown-fragment-type");
-    const resolver = this.#timingResolver(streamKey, info.packetId, false);
+    const resolver = this.#timingResolver(streamKey, info.packetId, true);
     if (!resolver) return this.#drop("mfu-no-resolver");
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return this.#drop("mfu-empty-payload");
@@ -6046,6 +6194,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return this.#drop("mfu-sample-timing-missing");
@@ -6071,7 +6220,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
           info,
           resolver,
           options?.recovered === true,
-          options?.fecSbn
+          options?.fecSbn,
+          options?.fecSbnFirst
         );
         if (deferred.record === void 0) this.#countDeferredOutcome(deferred.reason);
       }
@@ -6164,7 +6314,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
       info,
       resolver,
       options?.recovered === true,
-      options?.fecSbn
+      options?.fecSbn,
+      options?.fecSbnFirst
     );
     if (outcome.record !== void 0) return outcome.record;
     return this.#drop(outcome.reason);
@@ -6184,7 +6335,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
    * attribution exists to keep readable. Leaving the choice at the call site
    * is what keeps both true.
    */
-  #emitCombinedSample(combined, info, resolver, recovered, fecSbn) {
+  #emitCombinedSample(combined, info, resolver, recovered, fecSbn, fecSbnFirst) {
     const timing = resolver.sampleTiming(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -6201,6 +6352,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     );
     if (!meta) return { reason: "combined-meta-build-failed" };
     if (fecSbn !== void 0) meta.fecSbn = fecSbn;
+    if (fecSbnFirst !== void 0) meta.fecSbnFirst = fecSbnFirst;
     if (!resolver.consumeSample(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -6369,6 +6521,10 @@ var MmtpContainerParser = class _MmtpContainerParser {
     }
     this.#emitFrame(data, meta);
   }
+  /** Whether FT=1 metadata already names this sample, without claiming it. */
+  hasAuthoredTimingFor(packetId, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, catalogTrackName) {
+    return this.#timingResolver(this.#streamKey(packetId, catalogTrackName), packetId, false)?.sampleTiming(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) != null;
+  }
   /**
    * Claim and return the authored timing for a recovered sample. Recovery does
    * not pass through the ordinary `feed()` completion path, so it must retire
@@ -6430,6 +6586,9 @@ var MmtpContainerParser = class _MmtpContainerParser {
     for (const { sequencer } of this.#sequencers.values()) sequencer.discard();
     this.#sequencers.clear();
     this.#fecSequencer?.discard();
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
+    }
     this.#timingStreams.clear();
     this.#pendingTimingSamples = 0;
     this.#reliableMoqStartupGate.clear();
@@ -6448,10 +6607,23 @@ var MmtpContainerParser = class _MmtpContainerParser {
     return resolver;
   }
   #awaitTiming(streamKey, head) {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = this.#timingStreams.get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      this.#recoveredHeadsAwaitingTiming.superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming.held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
+    }
+  }
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  #leaveAwaitingTiming(head, outcome) {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++;
   }
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -6479,6 +6651,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const state = this.#timingStreams.get(streamKey);
     if (!state) return;
     this.#timingStreams.delete(streamKey);
+    for (const head of state.awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
     this.#pendingTimingSamples -= state.resolver.pendingSampleCount;
     if (this.#pendingTimingSamples < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");