@blockcast/mmt-container 2.2.0-main.da2e7cd1dd5d → 2.2.0-main.f480a7ede8b1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcast/mmt-container",
-  "version": "2.2.0-main.da2e7cd1dd5d",
+  "version": "2.2.0-main.f480a7ede8b1",
   "description": "MMTP/LOC container parsing for MMT over MoQ and SSM",
   "type": "module",
   "main": "dist/index.js",
@@ -169,10 +169,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@blockcast/fec-worker": "2.2.0-main.da2e7cd1dd5d",
-    "@blockcast/mmt-base": "2.2.0-main.da2e7cd1dd5d",
-    "@blockcast/mmt-fec": "2.2.0-main.da2e7cd1dd5d",
-    "@blockcast/mmt-manifest-verify": "2.2.0-main.da2e7cd1dd5d",
+    "@blockcast/fec-worker": "2.2.0-main.f480a7ede8b1",
+    "@blockcast/mmt-base": "2.2.0-main.f480a7ede8b1",
+    "@blockcast/mmt-fec": "2.2.0-main.f480a7ede8b1",
+    "@blockcast/mmt-manifest-verify": "2.2.0-main.f480a7ede8b1",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
     "ajv": "^8.17.1",

package/src/fec-manager.ts

@@ -22,6 +22,7 @@ import {
   isoBlockContains,
   isoBlocksBehindLowerBound,
   parseFecBlockProfile,
+  serial32Add,
   serial32Distance,
   serial32Precedes,
   ssbg1FitsSymbol,
@@ -2891,6 +2892,10 @@ export class FECManager {
       }
     }
 
+    if (isSourceSymbol && source === 'multicast') {
+      this.#noteMulticastSource(this.#isoLocatorFor(packetId, catalogTrackName), (sbn + esi) >>> 0, packetId, catalogTrackName)
+    }
+
     return true
   }
 
@@ -3263,6 +3268,7 @@ export class FECManager {
     const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName)
     const evictedBefore = locator.heldEvicted
     const held = locator.hold(ssId, source)
+    if (held && source.source === 'multicast') this.#noteMulticastSource(locator, ssId, packetId, catalogTrackName)
     const evicted = locator.heldEvicted - evictedBefore
     if (evicted > 0) {
       const before = this.#isoHeldEvictedCount
@@ -4364,9 +4370,95 @@ export class FECManager {
       this.#completeCleanBlock(blockKey, sbn, packetId, catalogTrackName)
       return null
     }
+    // Its K' is known now: a block this repair shows short of it waits less.
+    if (recovered === null) this.#shortenUnrecoverableWait(blockKey, sbn, packetId, catalogTrackName)
     return recovered
   }
 
+  /**
+   * A first-arrival multicast source, held or placed. A datagram flow keeps
+   * its sources in send order, so one that moves the stream's newest source
+   * position past a block leaves the sources that block still misses
+   * reordered behind it at best: it shortens the wait of every block it
+   * passed that only a late source can complete. MoQ is left out: its streams
+   * can overtake one another, so a MoQ source shows nothing about the sources
+   * sent before it.
+   */
+  #noteMulticastSource(
+    locator: IsoBlockLocator<IsoHeldSource>,
+    ssId: number,
+    packetId: number,
+    catalogTrackName: string | undefined,
+  ): void {
+    const previous = locator.newestSource
+    if (!locator.noteSource(ssId) || previous === undefined) return
+    // The blocks whose last SS_ID lies in [previous, ssId): this source
+    // passed them and the previous newest one had not.
+    for (const block of locator.blocksBetween((previous - 1) >>> 0, ssId)) {
+      if (block.span || !serial32Precedes(serial32Add(block.start, block.length - 1), ssId)) continue
+      this.#shortenUnrecoverableWait(
+        this.#blockKey(block.start, packetId, catalogTrackName),
+        block.start,
+        packetId,
+        catalogTrackName,
+      )
+    }
+  }
+
+  /**
+   * The wait of a block that only a late source can complete (BLO-52085): a
+   * repair stated it, its received sources plus every symbol its repair group
+   * carries (RSB_length) are short of K' (the repair scheduler's
+   * group-cannot-complete), and a later source of the stream has arrived, so
+   * a source it misses is lost or reordered behind that one. The span, which
+   * covers repair symbols paced after its sources, buys it nothing: it waits
+   * the late-symbol allowance alone, the multicast wait less the span (the
+   * catalog tolerance or the measured delivery gap). Undefined for any other
+   * block.
+   */
+  #lateSourceWaitMs(
+    key: string,
+    sbn: number,
+    packetId: number,
+    catalogTrackName: string | undefined,
+    config: ResolvedFECTrackConfig,
+  ): number | undefined {
+    const authoredLength = this.#blockAuthoredLengths.get(key)
+    const rsbLength = this.#blockRsbLengths.get(key)
+    if (authoredLength === undefined || rsbLength === undefined) return undefined
+    if ((this.#blockSourceCounts.get(key) ?? 0) + rsbLength >= authoredLength) return undefined
+    const newestSource = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newestSource
+    if (newestSource === undefined || !serial32Precedes(serial32Add(sbn, authoredLength - 1), newestSource)) {
+      return undefined
+    }
+    return this.#multicastWaitMs(config) - config.interleaveDepthMs
+  }
+
+  /**
+   * Bring an open block's wait in to its late-source wait, when it has one.
+   * Never later than it is armed: only a source can complete such a block,
+   * so a repair of its group (paced across the span) must not keep it open.
+   */
+  #shortenUnrecoverableWait(
+    key: string,
+    sbn: number,
+    packetId: number,
+    catalogTrackName: string | undefined,
+  ): void {
+    if (!this.#activeBlocks.has(key)) return
+    const config = this.#trackConfigs.get(packetId)
+    if (config === undefined) return
+    const waitMs = this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config)
+    if (waitMs === undefined) return
+    const armedAtMs = this.#blockWaitDeadlinesMs.get(key)
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      armedAtMs === undefined ? waitMs : Math.min(waitMs, armedAtMs - this.#receiptNow()),
+    )
+  }
+
   /**
    * Record a block's authored SSB_length from a repair symbol. Returns false,
    * leaving the block unchanged, when the symbol contradicts the block: a
@@ -4714,7 +4806,18 @@ export class FECManager {
       )
     }
 
-    this.#armBlockTimeout(sbn, packetId, catalogTrackName, timeoutMs)
+    // A block only a late source can complete waits the late-symbol
+    // allowance from its own sources' activity; nothing else moves it later.
+    if (!sourceProgress && this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) !== undefined) {
+      this.#shortenUnrecoverableWait(key, sbn, packetId, catalogTrackName)
+      return
+    }
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) ?? timeoutMs,
+    )
   }
 
   #failBlock(

package/src/index.ts

@@ -299,6 +299,7 @@ export {
   type MmtpFeedOutcomeKey,
   type TrackInfo,
   type MmtpReorderStats,
+  type MmtpRecoveredHeadTimingStats,
   type MmtpReorderFrameDiagnostics,
   type MmtpReorderStreamDiagnostics,
   type FrameMeta as ParserFrameMeta,

package/src/iso-block-locator.ts

@@ -85,6 +85,7 @@ export class IsoBlockLocator<T> {
   #retentionBlocks: number
   #heldEvicted = 0
   #newest: number | undefined
+  #newestSource: number | undefined
   /** Pending holes (see `deferIncompleteGaps`): unstated, sources still held. */
   readonly #holes: IsoBlockRange[] = []
   /**
@@ -152,6 +153,23 @@ export class IsoBlockLocator<T> {
     if (this.#newest === undefined || serial32Precedes(this.#newest, position)) this.#newest = position
   }
 
+  /**
+   * The newest source SS_ID noted with `noteSource` (RFC 1982 order). Unlike
+   * `newest`, a repair never moves it: a repair can run ahead of its sources,
+   * a source cannot run ahead of the sources sent before it except by
+   * reordering.
+   */
+  get newestSource(): number | undefined {
+    return this.#newestSource
+  }
+
+  /** Note a received source's SS_ID; true when it is the newest one yet. */
+  noteSource(ssId: number): boolean {
+    if (this.#newestSource !== undefined && !serial32Precedes(this.#newestSource, ssId)) return false
+    this.#newestSource = ssId
+    return true
+  }
+
   /** Held sources evicted by `heldCapacity` (never by the horizon itself). */
   get heldEvicted(): number {
     return this.#heldEvicted
@@ -412,6 +430,7 @@ export class IsoBlockLocator<T> {
     this.#held.clear()
     this.#coverageEnd = undefined
     this.#newest = undefined
+    this.#newestSource = undefined
   }
 
   #claim(block: IsoBlockRange): IsoPlacedSource<T>[] {

package/src/iso-bmff-timing.ts

@@ -581,6 +581,14 @@ type PendingMovieFragment = Array<IsoBmffSampleTiming | null>
 export class IsoBmffTimingResolver {
   #track: IsoBmffTrackTiming | null = null
   #fragments = new Map<string, PendingMovieFragment>()
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = new Map<string, IsoBmffSampleTiming>()
+  /**
+   * 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 = new Map<string, { first: IsoBmffSampleTiming, sampleCount: number }>()
   #pendingSamples = 0
   #evictedSamples = 0
   #lastMovieFragmentRejection: IsoBmffMovieFragmentRejection | null = null
@@ -591,6 +599,11 @@ export class IsoBmffTimingResolver {
     }
   }
 
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized(): boolean {
+    return this.#track !== null
+  }
+
   get pendingSampleCount(): number {
     return this.#pendingSamples
   }
@@ -618,10 +631,18 @@ export class IsoBmffTimingResolver {
     return true
   }
 
+  /**
+   * `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: number,
     data: Uint8Array,
     additionalSampleLimit = this.maxPendingSamples,
+    recovered = false,
   ): boolean {
     this.#lastMovieFragmentRejection = null
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
@@ -648,6 +669,9 @@ export class IsoBmffTimingResolver {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index]!),
       )
     }
+    const delivered = recovered ? this.#delivered.get(key) : undefined
+    if (delivered && delivered.sampleCount === parsed.samples.length &&
+        sameSample(delivered.first, parsed.samples[0]!)) return true
     // Sliding window, not a one-way ratchet. `consumeSample` and
     // `releaseSample` between them cover every sample some component observed
     // -- but a sample whose data units never arrive at all is observed by
@@ -683,6 +707,7 @@ export class IsoBmffTimingResolver {
       return false
     }
     this.#fragments.set(key, [...parsed.samples])
+    this.#firstSamples.set(key, parsed.samples[0]!)
     this.#pendingSamples += parsed.samples.length
     return true
   }
@@ -758,6 +783,7 @@ export class IsoBmffTimingResolver {
     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
@@ -779,13 +805,26 @@ export class IsoBmffTimingResolver {
     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 })
+      // ponytail: the dedupe memory is as wide as the timing budget, in fragments;
+      // a recovered copy older than that is admitted again, as before.
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value!)
+      }
+    }
     return true
   }
 
   reset(): void {
     this.#track = null
     this.#fragments.clear()
+    this.#firstSamples.clear()
+    this.#delivered.clear()
     this.#pendingSamples = 0
   }
 }

package/src/mmtp-container-parser.ts

@@ -365,10 +365,19 @@ export type MmtpFeedDropReason =
   /** No timing resolver, or it refused the initialization segment. */
   | 'init-timing-refused'
   | 'fragment-unexpected-fragmentation'
+  /** FT=1 before an FT=0 has bound the stream's timing track. */
   | 'fragment-no-resolver'
   /** addMovieFragment refused — includes the pending-timing-sample budget. */
   | 'fragment-timing-refused'
   | 'unknown-fragment-type'
+  /** Stable code, no longer produced: an FT=2 with no timing (before the
+   *  stream's first FT=0, or after setTrack dropped it) now waits for its
+   *  timing like one whose FT=1 has not arrived. A head counts as
+   *  `drop:mfu-sample-timing-missing` (parked) and a FI=2/FI=3 continuation
+   *  as the `pending` record. A continuation that completes a head the
+   *  reassembler buffered before the timing was dropped counts as
+   *  `drop:assembled-timing-missing`. A panel keyed on this code reads zero:
+   *  a re-attribution, not lost coverage. Re-key on both drop codes. */
   | 'mfu-no-resolver'
   | 'mfu-empty-payload'
   | 'mfu-du-header-missing'
@@ -679,7 +688,10 @@ class FrameSequencer {
 // ── FecReleaseSequencer ─────────────────────────────────────────────
 
 /** Authored decode-time adjacency: the next frame starts where this one ends. */
-function authoredAdjacent(before: FrameMeta, after: FrameMeta): boolean {
+export function authoredAdjacent(
+  before: Pick<FrameMeta, 'authoredTiming'>,
+  after: Pick<FrameMeta, 'authoredTiming'>,
+): boolean {
   const a = before.authoredTiming
   const b = after.authoredTiming
   if (!a || !b || a.mediaTimescale !== b.mediaTimescale) return false
@@ -1089,9 +1101,30 @@ interface AwaitingTimingHead {
   mpuSequenceNumber: number
   movieFragmentSequenceNumber: number
   sampleNumber: number
+  /** MMTP packet sequence number; a recovered copy carries its source's. */
+  sequenceNumber: number
   arrivedAt: number
 }
 
+/** FEC-recovered heads that went through the awaiting-timing queue. Every
+ * count but `pending` is cumulative. A held head is pending or has left the
+ * queue exactly once, so `held - expired - discarded - superseded - pending`
+ * is the number fed again once their FT=1 landed. That feed can still refuse
+ * one (size, offset, dispose from a frame callback); the refusal is counted in
+ * `feedStats.deferredOutcomes`, not here. */
+export interface MmtpRecoveredHeadTimingStats {
+  /** Held because their sample's FT=1 had not arrived yet. */
+  held: number
+  /** Left without timing: the reassembler-timeout deadline, or pushed out by the queue's capacity. */
+  expired: number
+  /** Dropped with their stream (track reconfigure, reset or retire) or by dispose(). */
+  discarded: number
+  /** Gave way to their arriving source copy, which takes their place in the queue. */
+  superseded: number
+  /** In the queue now; current occupancy, not cumulative. */
+  pending: number
+}
+
 const MAX_AWAITING_TIMING_HEADS = 8
 
 // ── MmtpContainerParser ─────────────────────────────────────────────
@@ -1129,6 +1162,9 @@ export class MmtpContainerParser {
   #reclaimedTimingSamples = 0
   #evictedTimingSamples = 0
   #rejectedMovieFragments = 0
+  #recoveredHeadsAwaitingTiming: Omit<MmtpRecoveredHeadTimingStats, 'pending'> = {
+    held: 0, expired: 0, discarded: 0, superseded: 0,
+  }
   #sequencers = new Map<string, { packetId: number; sequencer: FrameSequencer }>()
   #fecGate: FecReleaseGate | null = null
   #fecSequencer: FecReleaseSequencer | null = null
@@ -1346,6 +1382,15 @@ export class MmtpContainerParser {
     }
   }
 
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming(): Readonly<MmtpRecoveredHeadTimingStats> {
+    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(): Readonly<MmtpReorderStats> {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered
@@ -1541,7 +1586,7 @@ export 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')
       }
     }
   }
@@ -1711,11 +1756,16 @@ export class MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop('fragment-unexpected-fragmentation')
       const resolver = this.#timingResolver(streamKey, info.packetId, false)
-      if (!resolver) return this.#drop('fragment-no-resolver')
+      if (!resolver?.initialized) return this.#drop('fragment-no-resolver')
       const pendingBefore = resolver.pendingSampleCount
       const evictedBefore = resolver.evictedSampleCount
       const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples
-      const admitted = resolver.addMovieFragment(mpu.mpuSequenceNumber, data, remaining)
+      const admitted = resolver.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true,
+      )
       // Sync on BOTH paths: the resolver can displace stale timing and still
       // refuse the fragment in hand, and a global count that missed those
       // freed slots would keep refusing on a budget that is no longer full.
@@ -1739,7 +1789,11 @@ export class MmtpContainerParser {
     }
     if (fragmentType !== 2) return this.#drop('unknown-fragment-type')
 
-    const resolver = this.#timingResolver(streamKey, info.packetId, false)
+    // An FT=2 before the stream's first FT=0 (a join, a track reset) is taken
+    // like one whose FT=1 has not arrived: a head waits for its timing, a
+    // continuation parks in the reassembler, and a later or FEC-recovered
+    // FT=0/FT=1 can still time them.
+    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')
@@ -1761,6 +1815,7 @@ export class MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now(),
         })
         return this.#drop('mfu-sample-timing-missing')
@@ -2228,6 +2283,9 @@ export 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()
@@ -2253,10 +2311,27 @@ export class MmtpContainerParser {
   }
 
   #awaitTiming(streamKey: string, head: AwaitingTimingHead): void {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming
-    if (!awaitingTiming) return
+    const state = this.#timingStreams.get(streamKey)
+    if (!state) return
+    // The source copy of a held recovered head takes its place, so the frame
+    // is delivered with source provenance once FT=1 lands.
+    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: AwaitingTimingHead, outcome: 'expired' | 'discarded'): void {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++
   }
 
   /**
@@ -2286,6 +2361,7 @@ export 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')

package/src/mmtp-router.ts

@@ -48,10 +48,12 @@ import {
 } from "./cmaf-block-assembler.js";
 import {
   MmtpContainerParser,
+  authoredAdjacent,
   isMfuKeyframeMetadata,
   type FecReleaseGate,
   type FrameMeta as ParserFrameMeta,
   type ParsedMmtpPacket,
+  type MmtpRecoveredHeadTimingStats,
 } from "./mmtp-container-parser.js";
 import { type TrackRole } from "./carp-catalog.js";
 import {
@@ -511,6 +513,9 @@ export type RoutedPacketMeta = {
   mmtpTimestamp: bigint;
   /**
    * The MMTP header RAP flag: the packet starts a random access point. On a
+   * track under a keyframe overlay it is also set on the FT=0 and FT=1 data
+   * units that govern a covered keyframe (draft-ramadan-moq-mmt-02 7.4.2), so
+   * it can precede the keyframe's first MFU fragment. On a
    * `recovered` packet it is read from the FEC-reconstructed header, which is
    * byte-exact outside packet_sequence_number, so it is the flag the
    * publisher sent. The router's own gap decisions deliberately ignore it for
@@ -1400,7 +1405,7 @@ export class MmtpRouter {
     const cb = this.#getFrameCallback(packetId);
     if (isVideo && !assembler) {
       if (frameMeta.recovered) {
-        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb);
+        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb, meta.fecSbn);
       } else {
         this.#routeDirectSourceVideo(packetId, data, frameMeta, cb);
       }
@@ -1915,6 +1920,11 @@ export class MmtpRouter {
     return { ...this.#overlayStats };
   }
 
+  /** Recovered FT=2 heads held for their FT=1, and how each left the wait (BLO-53369). */
+  get recoveredHeadsAwaitingTiming(): Readonly<MmtpRecoveredHeadTimingStats> {
+    return this.#parser.recoveredHeadsAwaitingTiming;
+  }
+
   #isOverlayRepair(repairPacketId: number, repairTrackName?: string): boolean {
     return this.#overlayLegs.has(repairPacketId) ||
       (repairTrackName !== undefined && this.#overlayRepairNames.has(repairTrackName));
@@ -4817,8 +4827,28 @@ export class MmtpRouter {
     data: Uint8Array,
     meta: RoutedFrameMeta,
     cb: FrameCallback | null,
+    /** The base SS_ID the FEC release gate ordered the frame by, if any. */
+    fecSbn: number | undefined,
   ): void {
     const streamKey = this.#mediaStreamKey(packetId, meta.catalogTrackName);
+    // The FEC release gate let this frame out in order: only once every
+    // block between it and the frame before it resolved, or because it
+    // starts where that frame ended. Nothing still in flight can precede it
+    // then, so it plays now, as a source frame does; holding it for the next
+    // intact frame cost every repaired burst its length in decoder input
+    // (BLO-52085). An overlay recovery names no base block for the gate to
+    // wait on, so past a gap it may be ahead of frames still in flight (an
+    // overlay that outran the wire, BLO-53342): it keeps waiting for the
+    // source cursor below, unless it starts where the last emitted frame
+    // ended (on this direct path, the delivered high water).
+    if (this.#isFecTrack(packetId)) {
+      const high = this.#deliveredVideoHighWaterByStream.get(streamKey);
+      if (fecSbn !== undefined || (high !== undefined && authoredAdjacent(high, meta))) {
+        this.#drainDirectRecoveredVideo(streamKey, packetId, frame => frame.timestamp <= meta.timestamp, cb);
+        this.#emitDirectVideo(packetId, data, meta, cb);
+        return;
+      }
+    }
     this.#enqueueDirectRecoveredVideo(packetId, data, meta);
     const lastSourceTs = this.#lastDirectSourceVideoTsByStream.get(streamKey);
     this.#drainDirectRecoveredVideo(
@@ -5209,23 +5239,39 @@ export class MmtpRouter {
     // A recovered head whose sample FT=1 has not named yet (an overlay that
     // outran the source path) would complete its data unit untimed: the unit
     // is dropped, marked completed, and the timed source copy is then refused
-    // (BLO-53342). Leave it out; its recovered continuations park and complete
-    // with the source head. A head that is truly lost ends as it did before.
-    result = {
-      ...result,
-      symbols: result.symbols.filter((sym) =>
-        sym.fragmentType !== 2 ||
-        sym.fragment.fragmentationIndicator !== 1 ||
-        sym.fragment.movieFragmentSequenceNumber === undefined ||
-        sym.fragment.sampleNumber === undefined ||
-        this.#parser.hasAuthoredTimingFor(
-          ownerPacketId,
-          sym.fragment.mpuSequenceNumber,
-          sym.fragment.movieFragmentSequenceNumber,
-          sym.fragment.sampleNumber,
-          catalogTrackName,
-        )),
-    };
+    // (BLO-53342). Hand it to the parser instead, which holds it in its
+    // awaiting-timing queue and feeds it again when FT=1 lands; its recovered
+    // continuations park in the reassembler meanwhile. If the source path
+    // lost the head, this held copy is the keyframe (BLO-53369).
+    const untimedHead = (sym: (typeof result.symbols)[number]): boolean =>
+      sym.fragmentType === 2 &&
+      sym.fragment.fragmentationIndicator === 1 &&
+      sym.fragment.movieFragmentSequenceNumber !== undefined &&
+      sym.fragment.sampleNumber !== undefined &&
+      !this.#parser.hasAuthoredTimingFor(
+        ownerPacketId,
+        sym.fragment.mpuSequenceNumber,
+        sym.fragment.movieFragmentSequenceNumber,
+        sym.fragment.sampleNumber,
+        catalogTrackName,
+      );
+    for (const sym of result.symbols) {
+      if (!untimedHead(sym) ||
+        this.#sourceSeqReceived(ownerPacketId, sym.packetSequenceNumber, catalogTrackName)) continue;
+      this.#feedViaParser(
+        sym.rawSymbol,
+        { packetId: ownerPacketId, sequenceNumber: sym.packetSequenceNumber },
+        undefined,
+        {
+          skipFecPayloadId: true,
+          recovered: true,
+          deliveryProvenance,
+          ...fecSbnOf(sym.index),
+          ...(catalogTrackName === undefined ? {} : { catalogTrackName }),
+        },
+      );
+    }
+    result = { ...result, symbols: result.symbols.filter((sym) => !untimedHead(sym)) };
 
     // MSE assembler path: route recovered block as pre-assembled frames (skip FT=0)
     // BLO-3035 layer 3: recovered symbols are RAW MFU fragments, not complete