@blockcast/mmt-container 2.2.0-main.75b39a2cdddf → 2.2.0-main.7e8a9d13c01c

package/src/iso-block-locator.ts

@@ -14,9 +14,10 @@
  * between are one or more blocks whose every repair symbol was lost: they are
  * kept as one repair-less span, which completes clean once all of its SS_IDs
  * arrived (C.5.2 makes a gap in consecutive SS_IDs directly visible) and
- * otherwise resolves through its catalog-derived deadline. That is the only
- * way a block without repair completes: on the next block's SS_Start, never on
- * a count of K source symbols.
+ * otherwise resolves through its catalog-derived deadline. A block without
+ * repair completes that way, on the next block's SS_Start, never on a count of
+ * K source symbols, unless a repair that arrives later (a FETCH of the span's
+ * first group) states exactly the span's range: the span was that one block.
  */
 import {
   isoBlockContains,
@@ -58,14 +59,29 @@ export type IsoRepairPlacement<T> =
        */
       readonly hole?: { readonly block: IsoBlockRange; readonly lostSsId: number }
     }
-  /** Not a block this stream can use; the repair symbol is dropped. */
-  | { readonly status: 'conflict' | 'overlap' | 'stale' | 'ahead'; readonly reason: string }
+  /**
+   * Not a block this stream can use; the repair symbol is dropped. `ofSpan` is
+   * set when the repair stated only the first block of that repair-less span:
+   * the span holds more than one block, so no single repair group completes it.
+   */
+  | {
+      readonly status: 'conflict' | 'overlap' | 'stale' | 'ahead'
+      readonly reason: string
+      readonly ofSpan?: IsoBlockRange
+    }
 
 /**
  * Retention: the locator is never without one. Every call that can grow it
  * (`hold`, `placeRepair`) retires, behind the position it just saw, every
  * block, span and held source more than `retentionBlocks` blocks back, by the
- * one ISO horizon metric (`isoBlocksBehindLowerBound`). A block is measured
+ * one ISO horizon metric (`isoBlocksBehindLowerBound`). A held source stays
+ * while a pending hole holding it does: the hole's repair FETCH may still
+ * state its block, and closing the hole places it, so the span it leaves
+ * counts every source it received (BLO-52085). A pending hole the horizon
+ * passes stops being pending (its blocks can no longer be stated, and the
+ * release gate no longer waits for it), but keeps its sources until its
+ * owner closes it (`takeExpiredHoles`), so it still fails as the span it
+ * is. A block is measured
  * from its last SS_ID, so it stays while any SS_ID of it is inside the
  * horizon: a repair-less span has no length bound, and one measured from its
  * start could be retired the moment it is created, before the sources it
@@ -88,6 +104,15 @@ export class IsoBlockLocator<T> {
   #newestSource: number | undefined
   /** Pending holes (see `deferIncompleteGaps`): unstated, sources still held. */
   readonly #holes: IsoBlockRange[] = []
+  /** Holes the horizon passed while pending: sources held until closed. */
+  readonly #expired: IsoBlockRange[] = []
+  /** Of `#expired`, those `takeExpiredHoles` has not handed out yet. */
+  readonly #newlyExpired: IsoBlockRange[] = []
+  /**
+   * Spans closed from expired holes: behind the horizon, so kept only for
+   * `locate` while their sources are fed, until the next retirement.
+   */
+  readonly #closedBehind: IsoBlockRange[] = []
   /**
    * Keep a gap that is missing a source as a pending hole rather than a span,
    * so a repair FETCHed for it (draft-ramadan-moq-fec §7.5) can still state
@@ -192,18 +217,31 @@ export class IsoBlockLocator<T> {
 
   /** The known block or span containing `ssId`, with its ESI. */
   locate(ssId: number): { block: IsoBlockRange; esi: number } | null {
-    for (let i = this.#blocks.length - 1; i >= 0; i--) {
-      const block = this.#blocks[i]!
-      if (isoBlockContains(block.start, block.length, ssId)) {
-        return { block, esi: serial32Distance(block.start, ssId) }
+    for (const blocks of [this.#blocks, this.#closedBehind]) {
+      for (let i = blocks.length - 1; i >= 0; i--) {
+        const block = blocks[i]!
+        if (isoBlockContains(block.start, block.length, ssId)) {
+          return { block, esi: serial32Distance(block.start, ssId) }
+        }
       }
     }
     return null
   }
 
-  /** Number of pending holes. */
+  /** Number of holes not closed yet, pending or past the horizon. */
   get holeCount(): number {
-    return this.#holes.length
+    return this.#holes.length + this.#expired.length
+  }
+
+  /**
+   * The pending holes the horizon has passed since the last call, in the
+   * order it passed them. Each is no longer pending: no repair states a block
+   * in it (that repair is `stale`, as for a span the horizon retired) and the
+   * release gate does not wait for it. Its owner must close it
+   * (`closeHolesWithin`), which turns it into a span that is not kept here.
+   */
+  takeExpiredHoles(): IsoBlockRange[] {
+    return this.#newlyExpired.splice(0)
   }
 
   /** The stated block (never a span) ending exactly at `end`. */
@@ -268,9 +306,11 @@ export class IsoBlockLocator<T> {
   /**
    * Apply one repair symbol's `(SS_Start, SSB_length)`. The first repair of a
    * block states its range and places every held source in it; later repair
-   * symbols of the same block change nothing. A range that contradicts a
-   * known block (a different length, or an overlap with another block or a
-   * span) fails closed: the repair symbol is dropped and no block changes.
+   * symbols of the same block change nothing. A repair whose range is exactly
+   * a repair-less span states that span's one block. A range that contradicts
+   * a known block (a different length, or an overlap with another block or
+   * with part of a span) fails closed: the repair symbol is dropped and no
+   * block changes.
    * A newly stated block retires behind its SS_Start (see the class note).
    * A block so far past `newest` that stating it would retire the position
    * `newest` is refused as `ahead`. When `newest` is a placed block's SS_Start
@@ -289,7 +329,25 @@ export class IsoBlockLocator<T> {
     const known = this.blockAt(start)
     if (known !== undefined) {
       if (known.span) {
-        return { status: 'overlap', reason: `repair block ${start}+${length} falls inside a repair-less span` }
+        // A span is no accepted block: it is the whole blocks between two
+        // stated ones whose repair never came (blocks are consecutive), so a
+        // repair whose range is exactly the span states its one block and
+        // contradicts nothing (draft-ramadan-moq-fec-core-00 5.4). Its sources
+        // were placed at these same ESIs when the span closed. A FETCH of the
+        // span's Group ext(SS_Start) returns just this when one block lost
+        // every multicast repair (a join).
+        if (known.length === length) {
+          const block: IsoBlockRange = { start, length, span: false }
+          this.#blocks[this.#blocks.indexOf(known)] = block
+          return { status: 'placed', block, placed: [] }
+        }
+        return length < known.length
+          ? {
+              status: 'overlap',
+              reason: `repair block ${start}+${length} is only the first block of repair-less span ${known.start}+${known.length}`,
+              ofSpan: known,
+            }
+          : { status: 'overlap', reason: `repair block ${start}+${length} runs past repair-less span ${known.start}+${known.length}` }
       }
       if (known.length !== length) {
         return {
@@ -367,18 +425,28 @@ export class IsoBlockLocator<T> {
   }
 
   /**
-   * Turn every pending hole inside `[start, start + length)` into a
-   * repair-less span, claiming its held sources: its range FETCH ended, so
-   * nothing more will state its blocks. Returns the spans, in SS_ID order.
+   * Turn every hole inside `[start, start + length)` into a repair-less span,
+   * claiming its held sources: its range FETCH ended, so nothing more will
+   * state its blocks. A hole the horizon passed (`takeExpiredHoles`) leaves a
+   * span that is not kept among the blocks, as the horizon would retire it at
+   * once; only `locate` finds it, until the next retirement, so its sources
+   * can be fed. Returns the spans, in SS_ID order.
    */
   closeHolesWithin(start: number, length: number): { block: IsoBlockRange; placed: IsoPlacedSource<T>[] }[] {
     const closed: { block: IsoBlockRange; placed: IsoPlacedSource<T>[] }[] = []
-    for (const hole of [...this.#holes]) {
-      if (!isoBlockContains(start, length, hole.start)) continue
-      this.#holes.splice(this.#holes.indexOf(hole), 1)
-      const spanBlock: IsoBlockRange = { start: hole.start, length: hole.length, span: true }
-      closed.push({ block: spanBlock, placed: this.#claim(spanBlock) })
-      this.#blocks.push(spanBlock)
+    for (const holes of [this.#holes, this.#expired]) {
+      for (const hole of [...holes]) {
+        if (!isoBlockContains(start, length, hole.start)) continue
+        holes.splice(holes.indexOf(hole), 1)
+        const spanBlock: IsoBlockRange = { start: hole.start, length: hole.length, span: true }
+        closed.push({ block: spanBlock, placed: this.#claim(spanBlock) })
+        if (holes === this.#holes) {
+          this.#blocks.push(spanBlock)
+        } else {
+          this.#closedBehind.push(spanBlock)
+          if (this.#newlyExpired.includes(hole)) this.#newlyExpired.splice(this.#newlyExpired.indexOf(hole), 1)
+        }
+      }
     }
     return closed.sort((x, y) => serial32Distance(start, x.block.start) - serial32Distance(start, y.block.start))
   }
@@ -395,15 +463,17 @@ export class IsoBlockLocator<T> {
   }
 
   /**
-   * Retire every block and span whose last SS_ID, and every held source,
-   * lies more than `retentionBlocks` blocks behind `position`, with the shared
-   * lower-bound metric (`isoBlocksBehindLowerBound`) every ISO interleave
-   * horizon uses. Returns the retired block starts.
+   * Retire every block and span whose last SS_ID, and every held source
+   * outside a hole, lies more than `retentionBlocks` blocks behind
+   * `position`, with the shared lower-bound metric (`isoBlocksBehindLowerBound`)
+   * every ISO interleave horizon uses; a pending hole so far behind expires
+   * (`takeExpiredHoles`). Returns the retired block starts.
    */
   retireBehind(position: number): number[] {
     this.observe(position)
     const horizon = this.#retentionBlocks
     const retired: number[] = []
+    this.#closedBehind.length = 0
     for (let i = this.#blocks.length - 1; i >= 0; i--) {
       const block = this.#blocks[i]!
       const last = serial32Add(block.start, block.length - 1)
@@ -415,10 +485,20 @@ export class IsoBlockLocator<T> {
     for (let i = this.#holes.length - 1; i >= 0; i--) {
       const hole = this.#holes[i]!
       const last = serial32Add(hole.start, hole.length - 1)
-      if (isoBlocksBehindLowerBound(last, position, this.#kMax) > horizon) this.#holes.splice(i, 1)
+      if (isoBlocksBehindLowerBound(last, position, this.#kMax) <= horizon) continue
+      this.#holes.splice(i, 1)
+      this.#expired.push(hole)
+      this.#newlyExpired.push(hole)
     }
+    // A held source stays while a hole holding it does (class note).
     for (const ssId of [...this.#held.keys()]) {
-      if (isoBlocksBehindLowerBound(ssId, position, this.#kMax) > horizon) this.#held.delete(ssId)
+      if (
+        isoBlocksBehindLowerBound(ssId, position, this.#kMax) > horizon &&
+        !this.#holes.some((hole) => isoBlockContains(hole.start, hole.length, ssId)) &&
+        !this.#expired.some((hole) => isoBlockContains(hole.start, hole.length, ssId))
+      ) {
+        this.#held.delete(ssId)
+      }
     }
     return retired
   }
@@ -427,6 +507,9 @@ export class IsoBlockLocator<T> {
   reset(): void {
     this.#blocks.length = 0
     this.#holes.length = 0
+    this.#expired.length = 0
+    this.#newlyExpired.length = 0
+    this.#closedBehind.length = 0
     this.#held.clear()
     this.#coverageEnd = undefined
     this.#newest = undefined

package/src/mmtp-container-parser.ts

@@ -173,6 +173,15 @@ export interface FrameMeta {
    * on FEC-gated streams.
    */
   fecSbn?: number
+  /**
+   * Set on a frame the keyframe overlay rebuilt (draft-ramadan-moq-mmt-02
+   * 7.4) whose base SS_IDs are determined: the lowest base SS_ID of its
+   * MPU's packets in that decode, its FT=0 when the decode holds it. The
+   * release gate waits only for the blocks before it, and stops waiting once
+   * a base frame after this one arrived. `fecSbn` stays the SS_ID the frame
+   * completed in.
+   */
+  fecSbnFirst?: number
   /**
    * Set on the first frame released after a gap: the blocks between it and
    * the previous release resolved with lost media, or authored decode time
@@ -242,6 +251,12 @@ export interface FecReleaseGate {
   isRap?(data: Uint8Array, meta: FrameMeta): boolean
   /** A complete RAP entered the gate at SS_ID `ssId` (see `isRap`). */
   onRap?(packetId: number, catalogTrackName: string | undefined, ssId: number): void
+  /**
+   * Whether what reads this stream decides on when its frames arrive (a
+   * staged stream switch): the gate then releases a held overlay-rebuilt
+   * frame when it did unanchored (#cursorPassed).
+   */
+  releaseUnanchored?(packetId: number, catalogTrackName: string | undefined): boolean
 }
 
 /** Typed ISO-BMFF timing-sample budget counters. See `timingBudgetStats`. */
@@ -520,6 +535,8 @@ export interface ParseHeaderOptions {
   deliveryProvenance?: MmtpDeliveryProvenance
   /** FEC source block this packet belongs to (FEC-protected packets only). */
   fecSbn?: number
+  /** See FrameMeta.fecSbnFirst. */
+  fecSbnFirst?: number
 }
 
 // ── FrameSequencer ──────────────────────────────────────────────────
@@ -733,9 +750,19 @@ function ssIdAfter(a: number, b: number): boolean {
   return ((a - b) | 0) > 0
 }
 
+/** The stream holds a frame the keyframe overlay rebuilt (FrameMeta.fecSbnFirst). */
+function holdsRebuilt(stream: GatedStream): boolean {
+  return stream.buf.some(({ meta }) => meta.fecSbnFirst !== undefined)
+}
+
 interface GatedFrame extends PendingFrame {
   /** performance.now() at push; measures the hold against the gate's limit. */
   arrivedAtMs: number
+  /**
+   * The unanchored path's gate is done with this frame (see #cursorPassed):
+   * it released it, or dropped it as stale.
+   */
+  passed?: boolean
 }
 
 interface GatedStream {
@@ -747,6 +774,10 @@ interface GatedStream {
   discontinuity: boolean
   /** Latest (serial order) SS_ID of a complete RAP that entered the gate since the last reset. */
   rapSsId: number | undefined
+  /** A frame that was not FEC-recovered was released since the last reset. */
+  sourced: boolean
+  /** Drains of this stream in progress: a release calls out, and back in (a stream switch's onCommit). */
+  draining: number
 }
 
 /**
@@ -755,9 +786,11 @@ interface GatedStream {
  * to the last released frame is released immediately. A frame after a gap
  * waits until every block between the last released frame's block and its
  * own has resolved; a D-28 repair or a late in-band recovery can therefore
- * still fill the gap. When the resolved blocks lost media, or authored decode
- * time shows a missing sample, the release carries the gate's stall/conceal
- * decision as `gapBefore`.
+ * still fill the gap. A frame the keyframe overlay rebuilt waits only for the
+ * blocks before its MPU (FrameMeta.fecSbnFirst), and no longer than the
+ * source cursor would hold it unanchored (#cursorPassed). When the resolved
+ * blocks lost media, or authored decode time shows a missing sample, the
+ * release carries the gate's stall/conceal decision as `gapBefore`.
  *
  * The wait is bounded here, not by the blocks: a frame held longer than the
  * gate's `holdLimitMs` since it arrived is released with the gate's
@@ -841,6 +874,7 @@ class FecReleaseSequencer {
       stream.lastSbn = undefined
       stream.discontinuity = false
       stream.rapSsId = undefined
+      stream.sourced = false
     }
     if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
       this.#recordStat('droppedStale')
@@ -869,6 +903,8 @@ class FecReleaseSequencer {
       if (compareFrameOrder(stream.buf[mid]!, frame) < 0) lo = mid + 1
       else hi = mid
     }
+    // In front of a frame the unanchored path released, it was stale there.
+    if (stream.buf[lo]?.passed === true) frame.passed = true
     stream.buf.splice(lo, 0, frame)
     this.#drainUnlessDeferred(stream)
   }
@@ -907,6 +943,54 @@ class FecReleaseSequencer {
     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: number, catalogTrackName: string | undefined): void {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId === packetId && (catalogTrackName === undefined || stream.catalogTrackName === catalogTrackName)) {
+        // From inside this stream's own drain (a sink replaced from a frame
+        // callback, as a stream switch's onCommit can), the drain under way
+        // releases the rest, in order, once the frame it is delivering is
+        // done (a commit delivers its held GOP and RAP after onCommit):
+        // released here, they would go ahead of them. Inside a deferral
+        // scope (a protected flow's record admits frames of several streams
+        // in one), the scope's drain does, for the same reason, into the
+        // replacement. With the stream unsourced, that drain lets a rebuilt
+        // frame go as unanchored did until it releases a source frame; a
+        // rebuilt frame behind that one waits for the blocks before it, as an
+        // anchored frame does (the record may hold the base frames it needs).
+        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: number, catalogTrackName: string | undefined): boolean {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue
+      if (catalogTrackName !== undefined && stream.catalogTrackName !== catalogTrackName) continue
+      if (holdsRebuilt(stream)) return true
+    }
+    return false
+  }
+
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey?: string): void {
     if (streamKey !== undefined) {
@@ -1013,16 +1097,34 @@ class FecReleaseSequencer {
         lastSbn: undefined,
         discontinuity: false,
         rapSsId: undefined,
+        sourced: false,
+        draining: 0,
       }
       this.#streams.set(streamKey, stream)
     }
     return stream
   }
 
-  #drain(stream: GatedStream): void {
+  /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
+  #drain(stream: GatedStream, asUnanchored = false): void {
+    stream.draining++
+    try {
+      this.#drainLoop(stream, asUnanchored)
+    } finally {
+      stream.draining--
+    }
+  }
+
+  #drainLoop(stream: GatedStream, asUnanchored: boolean): void {
     while (stream.buf.length > 0 && stream.last !== null) {
       const head = stream.buf[0]!
       const last = stream.last
+      // A second held copy of the frame just released waits on nothing.
+      if (compareFrameOrder(head, last) <= 0) {
+        stream.buf.shift()
+        this.#release(stream, head, undefined)
+        continue
+      }
       if (stream.discontinuity) {
         stream.discontinuity = false
         stream.buf.shift()
@@ -1036,13 +1138,19 @@ class FecReleaseSequencer {
       }
       const headSbn = head.meta.fecSbn
       const from = stream.lastSbn ?? headSbn
-      const to = headSbn ?? stream.lastSbn
+      // An overlay-rebuilt frame waits only for the blocks before its MPU's
+      // first packet in that decode (fecSbnFirst): the overlay delivered the
+      // packets from there on.
+      const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn
       let lost: readonly number[] = []
       // Neither side carries a Source FEC Payload ID: on a catalog-declared
       // FEC track that is the trailer-stripped profile violation, and there
       // are no blocks to wait on. The gap is still a gap: never release across
       // it undecided (fail closed), let the gate decide with no known blocks.
       const unanchored = from === undefined && to === undefined
+      // The source cursor released it (#cursorPassed) across blocks that have
+      // not resolved: nothing sized that gap either, so it is decided too.
+      let unresolved = false
       if (from !== undefined && to !== undefined) {
         const resolved = this.#gate.resolvedLoss(
           stream.packetId,
@@ -1051,7 +1159,8 @@ class FecReleaseSequencer {
           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
           // Past the point where these blocks must have resolved: nothing
@@ -1061,7 +1170,7 @@ class FecReleaseSequencer {
           this.#release(stream, head, this.#gate.decide(last, head, [], true))
           continue
         }
-        lost = resolved
+        lost = resolved ?? []
       }
       stream.buf.shift()
       // Every gap in the frame sequence gets a decision, not only one whose
@@ -1072,19 +1181,67 @@ class FecReleaseSequencer {
       this.#release(
         stream,
         head,
-        lost.length > 0 || unanchored || authoredGap(last.meta, head.meta)
+        lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta)
           ? this.#gate.decide(last, head, lost, false)
           : undefined,
       )
     }
   }
 
+  /**
+   * 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: GatedStream, asUnanchored: boolean): boolean {
+    let at = -1
+    for (let i = 0; i < stream.buf.length; i++) {
+      const frame = stream.buf[i]!
+      if (frame.meta.fecSbnFirst !== undefined || frame.meta.fecSbn === undefined) {
+        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 === undefined && (meta.recovered !== true || meta.fecSbn !== undefined))
+  }
+
   #release(stream: GatedStream, frame: PendingFrame, decision: FrameGapDecision | undefined): void {
+    // Two copies of one frame were held (its base copy and the overlay's
+    // rebuild) and the other went out: this one is stale, as a copy pushed
+    // after its frame was released is. It still moves the state as a release
+    // does: only the second emission is dropped.
+    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 !== undefined) stream.lastSbn = frame.meta.fecSbn
+    // An overlay-rebuilt frame (fecSbnFirst) released before any base frame
+    // since the last reset leaves lastSbn unset, as it did unanchored: the
+    // base frame after it then waits for nothing, not for the frames between.
+    if (frame.meta.fecSbn !== undefined && (frame.meta.fecSbnFirst === undefined || stream.lastSbn !== undefined)) {
+      stream.lastSbn = frame.meta.fecSbn
+    }
+    if (frame.meta.recovered !== true) stream.sourced = true
+    // A stale copy of the frame just released (equal order) repeats an
+    // onReleased call already made: noteReleasedRap ignores a second RAP of
+    // an MPU it has anchored (the same MPU and presentation time).
     this.#gate.onReleased?.(frame.data, frame.meta)
-    this.#emit(frame.data, frame.meta)
+    if (!stale) this.#emit(frame.data, frame.meta)
   }
 }
 
@@ -1452,6 +1609,16 @@ export class MmtpContainerParser {
     return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false
   }
 
+  /** See FecReleaseSequencer.unsource. */
+  unsourceFecRelease(packetId: number, catalogTrackName?: string): void {
+    this.#fecSequencer?.unsource(packetId, catalogTrackName)
+  }
+
+  /** See FecReleaseSequencer.holdsRebuilt. */
+  fecReleaseHoldsRebuilt(packetId: number, catalogTrackName?: string): boolean {
+    return this.#fecSequencer?.holdsRebuilt(packetId, catalogTrackName) ?? false
+  }
+
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId?: number, catalogTrackName?: string): void {
     if (!this.#fecSequencer) return
@@ -1876,6 +2043,7 @@ export class MmtpContainerParser {
           resolver,
           options?.recovered === true,
           options?.fecSbn,
+          options?.fecSbnFirst,
         )
         if (deferred.record === undefined) this.#countDeferredOutcome(deferred.reason)
       }
@@ -1987,6 +2155,7 @@ export class MmtpContainerParser {
       resolver,
       options?.recovered === true,
       options?.fecSbn,
+      options?.fecSbnFirst,
     )
     if (outcome.record !== undefined) return outcome.record
     return this.#drop(outcome.reason)
@@ -2013,6 +2182,7 @@ export class MmtpContainerParser {
     resolver: IsoBmffTimingResolver,
     recovered: boolean,
     fecSbn: number | undefined,
+    fecSbnFirst: number | undefined,
   ): CombinedSampleOutcome {
     const timing = resolver.sampleTiming(
       combined.mpuSequenceNumber,
@@ -2034,6 +2204,7 @@ export class MmtpContainerParser {
     )
     if (!meta) return { reason: 'combined-meta-build-failed' }
     if (fecSbn !== undefined) meta.fecSbn = fecSbn
+    if (fecSbnFirst !== undefined) meta.fecSbnFirst = fecSbnFirst
     if (!resolver.consumeSample(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,