@blockcast/mmt-container 0.5.0-main.ed11aec88d91 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcast/mmt-container",
-  "version": "0.5.0-main.ed11aec88d91",
+  "version": "0.5.0",
   "description": "MMTP/LOC container parsing for MMT over MoQ and SSM",
   "type": "module",
   "main": "dist/index.js",
@@ -141,7 +141,8 @@
     "./catalog.schema.json": "./schemas/catalog.schema.json",
     "./test-vectors/catalog-validation.json": "./test-vectors/catalog-validation.json",
     "./test-vectors/align.json": "./test-vectors/align.json",
-    "./test-vectors/catalog-timing.json": "./test-vectors/catalog-timing.json"
+    "./test-vectors/catalog-timing.json": "./test-vectors/catalog-timing.json",
+    "./test-vectors/repair-policy-v1.json": "./test-vectors/repair-policy-v1.json"
   },
   "files": [
     "dist",
@@ -164,10 +165,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@blockcast/fec-worker": "0.5.0-main.ed11aec88d91",
-    "@blockcast/mmt-base": "0.5.0-main.ed11aec88d91",
-    "@blockcast/mmt-fec": "0.5.0-main.ed11aec88d91",
-    "@blockcast/mmt-manifest-verify": "0.5.0-main.ed11aec88d91",
+    "@blockcast/fec-worker": "^0.5.0",
+    "@blockcast/mmt-base": "^0.5.0",
+    "@blockcast/mmt-fec": "^0.5.0",
+    "@blockcast/mmt-manifest-verify": "^0.5.0",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
     "ajv": "^8.17.1",

package/src/fec-manager.ts

@@ -3706,6 +3706,9 @@ export class FECManager {
           if (this.#refusedRecoveries.size > 1000) dropOldest(this.#refusedRecoveries, 500)
         }
         if (esi >= meta.ssbLength! - 1) {
+          // Safe to forget the block here: the Worker never re-emits a
+          // terminal block (packages/fec-worker/src/fec-worker.ts guards
+          // source and repair feeds with isTerminalBlock).
           this.#workerRecoveredNextEsi.delete(blockKey)
         } else {
           this.#workerRecoveredNextEsi.set(blockKey, esi + 1)

package/src/index.ts

@@ -649,6 +649,7 @@ export {
   type RepairPriorityReason,
   type RepairSendMeasurement,
   type RepairSkipReason,
+  type RepairStopReason,
   type RepairSubscribeCallback,
   type WireRepairFetchOptions,
 } from './repair-fetch.js'

package/src/mmtp-container-parser.ts

@@ -234,6 +234,14 @@ export interface FecReleaseGate {
   ): FrameGapDecision
   /** Every frame released in order from a gated stream. */
   onReleased?(data: Uint8Array, meta: FrameMeta): void
+  /**
+   * Whether a complete frame is a RAP (draft-ramadan-moq-fec 11.4.2). Asked
+   * for each video frame with a Source FEC Payload ID that enters the gate,
+   * held or released; absent, no frame counts as a RAP.
+   */
+  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
 }
 
 /** Typed ISO-BMFF timing-sample budget counters. See `timingBudgetStats`. */
@@ -692,6 +700,15 @@ function authoredGap(before: FrameMeta, after: FrameMeta): boolean {
   return b.decodeTime > a.decodeTime + BigInt(a.durationTicks)
 }
 
+/**
+ * Serial-number order on the uint32 SS_ID (RFC 1982 style): `a` follows `b`
+ * within half the space, so a 2^32 wrap does not read a post-wrap block as
+ * below a pre-wrap RAP.
+ */
+function ssIdAfter(a: number, b: number): boolean {
+  return ((a - b) | 0) > 0
+}
+
 interface GatedFrame extends PendingFrame {
   /** performance.now() at push; measures the hold against the gate's limit. */
   arrivedAtMs: number
@@ -704,6 +721,8 @@ interface GatedStream {
   last: PendingFrame | null
   lastSbn: number | undefined
   discontinuity: boolean
+  /** Latest (serial order) SS_ID of a complete RAP that entered the gate since the last reset. */
+  rapSsId: number | undefined
 }
 
 /**
@@ -797,11 +816,17 @@ class FecReleaseSequencer {
       stream.last = null
       stream.lastSbn = undefined
       stream.discontinuity = false
+      stream.rapSsId = undefined
     }
     if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
       this.#recordStat('droppedStale')
       return
     }
+    const ssId = meta.fecSbn
+    if (meta.trackType === 'video' && ssId !== undefined && this.#gate.isRap?.(data, meta) === true) {
+      if (stream.rapSsId === undefined || ssIdAfter(ssId, stream.rapSsId)) stream.rapSsId = ssId
+      this.#gate.onRap?.(stream.packetId, stream.catalogTrackName, ssId)
+    }
     if (stream.last === null) {
       // The first release establishes decoder sync: video must start on a
       // RAP; earlier deltas are undecodable and are dropped.
@@ -841,6 +866,23 @@ class FecReleaseSequencer {
     return earliest
   }
 
+  /**
+   * Whether a complete RAP above SS_ID `ssId` entered the gate of a stream of
+   * `packetId` (draft-ramadan-moq-fec 11.4.2: repair of a block below it is
+   * moot). Its SS_ID is the one its frame completed in; a frame's packets
+   * hold consecutive SS_IDs in authored order, so a complete RAP with a
+   * packet above `ssId` has every packet of it at or above the first SS_ID
+   * any loss at or below `ssId` could have taken.
+   */
+  rapAbove(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue
+      if (catalogTrackName !== undefined && stream.catalogTrackName !== catalogTrackName) continue
+      if (stream.rapSsId !== undefined && ssIdAfter(stream.rapSsId, ssId)) return true
+    }
+    return false
+  }
+
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey?: string): void {
     if (streamKey !== undefined) {
@@ -946,6 +988,7 @@ class FecReleaseSequencer {
         last: null,
         lastSbn: undefined,
         discontinuity: false,
+        rapSsId: undefined,
       }
       this.#streams.set(streamKey, stream)
     }
@@ -1346,6 +1389,11 @@ export class MmtpContainerParser {
     return this.#fecSequencer?.earliestHeldArrivalMs(packetId, catalogTrackName)
   }
 
+  /** See FecReleaseSequencer.rapAbove; false when no stream is FEC-gated. */
+  fecReleaseRapAbove(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean {
+    return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false
+  }
+
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId?: number, catalogTrackName?: string): void {
     if (!this.#fecSequencer) return

package/src/mmtp-router.ts

@@ -1011,6 +1011,7 @@ export class MmtpRouter {
     | null = null;
   /** Typed observer of every gap decision the release gate makes. */
   readonly #onFrameGap: ((decision: FrameGapDecision) => void) | null;
+  readonly #fecRapObservers = new Set<(packetId: number, catalogTrackName: string | undefined, ssId: number) => void>();
   // Pokes requested while a packet is being processed are deferred to its
   // end: a synchronous recovery completes its block BEFORE routing the
   // recovered frames, and releasing a held gap in between would strand them.
@@ -3165,6 +3166,28 @@ export class MmtpRouter {
     return this.#parser.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
   }
 
+  /**
+   * Whether a complete RAP above SS_ID `ssId` entered this stream's FEC
+   * release gate (see FecReleaseSequencer.rapAbove).
+   */
+  fecReleaseRapAbove(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean {
+    return this.#parser.fecReleaseRapAbove(packetId, catalogTrackName, ssId);
+  }
+
+  /**
+   * Observe each complete RAP entering an FEC release gate, with the SS_ID
+   * its frame completed in. Called synchronously from the frame push: an
+   * observer that drives FEC state must defer that work.
+   */
+  addFecRapObserver(
+    observer: (packetId: number, catalogTrackName: string | undefined, ssId: number) => void,
+  ): () => void {
+    this.#fecRapObservers.add(observer);
+    return () => {
+      this.#fecRapObservers.delete(observer);
+    };
+  }
+
   #requestFecPoke(packetId: number, catalogTrackName: string | undefined): void {
     if (this.#disposed) return;
     if (this.#fecPokeDepth > 0) {
@@ -3215,6 +3238,10 @@ export class MmtpRouter {
         this.#onFrameGap?.(decision);
         return decision;
       },
+      isRap: (data, meta) => this.#isRapForGap(data, meta),
+      onRap: (packetId, catalogTrackName, ssId) => {
+        for (const observer of this.#fecRapObservers) observer(packetId, catalogTrackName, ssId);
+      },
       onReleased: (data, meta) => {
         if (meta.trackType !== "video" || meta.mpuSequenceNumber === undefined) return;
         const timing = meta.authoredTiming;

package/src/multicast-manager.ts

@@ -38,6 +38,7 @@ import type {
   RepairPriorityReason,
   RepairSendMeasurement,
   RepairSkipReason,
+  RepairStopReason,
   RepairSubscribeCallback,
 } from "./repair-fetch.js";
 import {
@@ -358,6 +359,9 @@ interface RepairSymbolCounts {
  *   the deadline) so a harness reads the budget instead of inferring it.
  * - `repair-preempted` / `repair-deferred`: the scheduler aborted a delta
  *   repair for keyframe work, or never ran it before its block resolved.
+ * - `repair-stopped`: the scheduler ended a running repair FETCH (its
+ *   transport cancels it on the wire) and why; `moot` is a RAP above the
+ *   block that arrived complete first (draft-ramadan-moq-fec 11.4.2).
  * - `repair-priority`: the catalog could not supply the SUBSCRIBER_PRIORITY a
  *   repair FETCH must carry (draft-ramadan-moq-fec §11.4.5), so the FETCH was
  *   sent without the parameter (`omitted`, keyframe/unknown blocks) or not
@@ -435,6 +439,12 @@ export type RepairLifecycleEvent =
       readonly rttMs: number | null;
       readonly budgetMs: number;
     }
+  | {
+      readonly version: 2;
+      readonly type: "repair-stopped";
+      readonly block: RepairBlockIdentity;
+      readonly reason: RepairStopReason;
+    }
   | {
       readonly version: 2;
       readonly type: "repair-priority";
@@ -510,6 +520,13 @@ export interface BlockPolicyStats {
    * it (sources + RSB_length < K'), so no FETCH was sent.
    */
   repairsSkippedGroupCannotComplete: number;
+  /**
+   * `repairsSkipped` by reason: a keyframe-bearing block lay below a RAP
+   * that had already arrived complete (draft-ramadan-moq-fec 11.4.2).
+   */
+  repairsSkippedMootRap: number;
+  /** Running repair FETCHes the scheduler stopped, by reason (`repair-stopped`). */
+  repairStops: Record<RepairStopReason, number>;
   /**
    * The most recent skip: its reason, the measured RTT (null when
    * unmeasured), the time that was left to the deadline, and the request's
@@ -572,6 +589,8 @@ function newBlockPolicyStats(
     repairsSkippedPresentationDelayUnavailable: 0,
     repairsSkippedRangeNoAnchor: 0,
     repairsSkippedGroupCannotComplete: 0,
+    repairsSkippedMootRap: 0,
+    repairStops: { preempted: 0, reprioritized: 0, expired: 0, resolved: 0, reset: 0, disposed: 0, moot: 0 },
     lastRepairSkip: null,
     keyframeRepairFetchesSent: 0,
     rangeRepairFetchesSent: 0,
@@ -726,6 +745,16 @@ const REPAIR_SKIP_REASONS: ReadonlySet<unknown> = new Set([
   "presentation-delay-unavailable",
   "range-no-anchor",
   "group-cannot-complete",
+  "moot-rap",
+]);
+const REPAIR_STOP_REASONS: ReadonlySet<unknown> = new Set([
+  "preempted",
+  "reprioritized",
+  "expired",
+  "resolved",
+  "reset",
+  "disposed",
+  "moot",
 ]);
 const REPAIR_DEADLINE_BOUNDS: ReadonlySet<unknown> = new Set(["wait", "presentation", "keyframe", "retention"]);
 const GAP_REASONS: Readonly<Record<string, "stall" | "conceal">> = {
@@ -840,6 +869,12 @@ export function isRepairLifecycleEvent(
         isNullableNonNegative(value["rttMs"]) &&
         isFiniteNumber(value["budgetMs"])
       );
+    case "repair-stopped":
+      return (
+        hasExactKeys(value, ["version", "type", "block", "reason"]) &&
+        isRepairBlockIdentity(block) &&
+        REPAIR_STOP_REASONS.has(value["reason"])
+      );
     case "repair-priority": {
       const blockClass = value["blockClass"];
       const action = value["action"];
@@ -3097,6 +3132,7 @@ export class MulticastManager {
     else if (reason === "rtt-exceeds-budget") stats.repairsSkippedRttExceedsBudget++;
     else if (reason === "range-no-anchor") stats.repairsSkippedRangeNoAnchor++;
     else if (reason === "group-cannot-complete") stats.repairsSkippedGroupCannotComplete++;
+    else if (reason === "moot-rap") stats.repairsSkippedMootRap++;
     else stats.repairsSkippedPresentationDelayUnavailable++;
     stats.lastRepairSkip = {
       reason,
@@ -3178,6 +3214,37 @@ export class MulticastManager {
     });
   }
 
+  /** Record a running repair FETCH the scheduler stopped, and why. */
+  noteRepairStopped(
+    reason: RepairStopReason,
+    sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): void {
+    this.#statsFor(packetId, catalogTrackName).repairStops[reason]++;
+    this.#emitRepairLifecycle({
+      version: 2,
+      type: "repair-stopped",
+      block: repairBlockIdentity(packetId, sbn, catalogTrackName),
+      reason,
+    });
+  }
+
+  /**
+   * Whether a complete RAP above SS_ID `ssId` reached the stream's in-order
+   * release gate (draft-ramadan-moq-fec 11.4.2: repair below it is moot).
+   */
+  rapCompleteAbove(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean {
+    return this.#router.fecReleaseRapAbove(packetId, catalogTrackName, ssId);
+  }
+
+  /** Observe each complete RAP reaching a release gate (synchronous: defer FEC work). */
+  addRapCompleteObserver(
+    observer: (packetId: number, catalogTrackName: string | undefined, ssId: number) => void,
+  ): () => void {
+    return this.#router.addFecRapObserver(observer);
+  }
+
   /** Catalog/reset epoch of a packet's streams; gap decisions carry it. */
   epochFor(packetId: number): number {
     return this.#fec.epochFor(packetId);
@@ -3194,6 +3261,7 @@ export class MulticastManager {
       if (stats.epoch !== this.#fec.epochFor(stats.packetId)) continue;
       out[key] = {
         ...stats,
+        repairStops: { ...stats.repairStops },
         lastRepairSkip: stats.lastRepairSkip === null ? null : { ...stats.lastRepairSkip },
       };
     }

package/src/repair-fetch.ts

@@ -22,15 +22,23 @@
  * everything.
  *
  * Priority (from the block's class, see `repairPriorityForClass`):
- *   - P0 (keyframe / unknown) and P1 (audio) dispatch as soon as they are
- *     enqueued, with no cap. Each has its own fail deadline, and a cap would
- *     turn a recoverable protected block into a stall; their number is
- *     already bounded by the blocks one fail window can hold.
- *   - P2 (delta) dispatches only while no P0/P1 is queued or in flight,
- *     earliest absolute fail deadline first. Enqueuing a P0/P1 aborts every
- *     in-flight P2 (`repair-preempted`), which returns to the queue while its
- *     block is unresolved. A P2 that never ran before its block resolved is
- *     reported as `repair-deferred`.
+ *   - P0 (keyframe / unknown) dispatches as soon as it is enqueued, with no
+ *     cap. Each has its own fail deadline, and a cap would turn a
+ *     recoverable protected block into a stall; their number is already
+ *     bounded by the blocks one fail window can hold. A P0 block that lies
+ *     below a RAP the receiver already holds complete is not requested at
+ *     all (`moot-rap`), and a P0 FETCH still running when such a RAP
+ *     arrives is cancelled (`repair-stopped`, `moot`): the receiver resumes
+ *     from that RAP (draft-ramadan-moq-fec §11.4.2).
+ *   - P1 (audio) dispatches, uncapped, while no P0 is queued or in flight;
+ *     P2 (delta) only while no P0/P1 is, earliest absolute fail deadline
+ *     first (§11.4.5 item 3).
+ *   - Only a P0 FETCH the scheduler actually sends aborts the in-flight P1
+ *     and P2 FETCHes (`repair-preempted`), which return to the queue while
+ *     their blocks are unresolved: a keyframe request that is refused, moot
+ *     or otherwise never sent cancels nothing (§11.4.5 item 3), and an audio
+ *     request never preempts. A P2 that never ran before its block resolved
+ *     is reported as `repair-deferred`.
  *   - A block reclassified to a higher class while its P2 fetch is in flight
  *     is re-issued at once under the new class's wire priority: the running
  *     FETCH is aborted (FETCH_CANCEL) and a new one sent.
@@ -401,6 +409,11 @@ export type RepairSkipReason =
    * only duplicates (BLO-50082).
    */
   | 'group-cannot-complete'
+  /**
+   * The keyframe-bearing block lies below a RAP the receiver already holds
+   * complete, so its repair would be moot (draft-ramadan-moq-fec §11.4.2).
+   */
+  | 'moot-rap'
 
 /**
  * Which term set a FETCH's deadline (BLO-33597): the multicast wait, the
@@ -513,6 +526,23 @@ export interface RepairFetchHost {
     packetId: number,
     catalogTrackName?: string,
   ): void
+  /** A running FETCH the scheduler stopped, and why (optional). */
+  noteRepairStopped?(
+    reason: RepairStopReason,
+    sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): void
+  /**
+   * Whether a complete RAP above SS_ID `ssId` already reached the stream
+   * (optional; absent, none ever has). Under the bc-provenance profile only
+   * an admitted RAP counts (multicast-01 §7.2.7).
+   */
+  rapCompleteAbove?(packetId: number, catalogTrackName: string | undefined, ssId: number): boolean
+  /** Observe each complete RAP reaching a stream (optional; called synchronously). */
+  addRapCompleteObserver?(
+    observer: (packetId: number, catalogTrackName: string | undefined, ssId: number) => void,
+  ): () => void
   /**
    * A FETCH the scheduler admitted and handed to the transport (optional):
    * every attempt, a retry or a reprioritised restart included.
@@ -526,7 +556,22 @@ export interface RepairFetchHost {
   ): void
 }
 
-type StopReason = 'preempted' | 'reprioritized' | 'expired' | 'resolved' | 'reset' | 'disposed'
+/**
+ * Why the scheduler ended a running FETCH (the transport cancels it on the
+ * wire): preempted by a sent keyframe FETCH, reissued at a new class's
+ * priority, past its deadline, its block resolved, track reset or a newer
+ * request for the block, dispose, or `moot` (a RAP above the block arrived
+ * complete first, draft-ramadan-moq-fec §11.4.2).
+ */
+export type RepairStopReason =
+  | 'preempted'
+  | 'reprioritized'
+  | 'expired'
+  | 'resolved'
+  | 'reset'
+  | 'disposed'
+  | 'moot'
+type StopReason = RepairStopReason
 
 interface FetchRun {
   readonly controller: AbortController
@@ -639,9 +684,43 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     entry.running = null
     run.stopped = reason
     run.controller.abort()
-    // A preempted delta returns to the queue; until it runs again nothing is
+    // A preempted request returns to the queue; until it runs again nothing is
     // in flight that could land, so the block goes back to its multicast wait.
     if (reason === 'preempted') releaseHold(entry)
+    mc.noteRepairStopped?.(reason, entry.sbn, entry.packetId, entry.catalogTrackName)
+  }
+
+  /** The last SS_ID the entry covers, or undefined while its block is undelimited. */
+  const lastSsId = (entry: RepairEntry): number | undefined => {
+    if (entry.range) return entry.sbn + entry.range.holeLength - 1
+    const length = symbolCounts(entry.sbn, entry.packetId, entry.catalogTrackName)?.authoredLength
+    return length === undefined ? undefined : entry.sbn + length - 1
+  }
+
+  /** A keyframe request whose whole block lies below a RAP already held complete. */
+  const moot = (entry: RepairEntry): boolean => {
+    if (entry.priority !== 0) return false
+    const last = lastSsId(entry)
+    if (last === undefined) return false
+    try {
+      return mc.rapCompleteAbove?.(entry.packetId, entry.catalogTrackName, last) === true
+    } catch {
+      return false
+    }
+  }
+
+  /** Drop a request no FETCH will be sent for, and say why. */
+  const skip = (entry: RepairEntry, reason: RepairSkipReason, rttMs: number | null, budgetMs: number): void => {
+    retire(entry)
+    releaseHold(entry)
+    clearEntry(entry)
+    mc.noteRepairSkipped(
+      reason,
+      { rttMs, budgetMs, priority: entry.priority },
+      entry.sbn,
+      entry.packetId,
+      entry.catalogTrackName,
+    )
   }
 
   /** The keyframe budget for a P0 block, or null: absent, throwing or not positive. */
@@ -683,16 +762,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
             ? null
             : 'rtt-exceeds-budget'
     if (reason === null) return rttMs
-    retire(entry)
-    releaseHold(entry)
-    clearEntry(entry)
-    mc.noteRepairSkipped(
-      reason,
-      { rttMs, budgetMs, priority: entry.priority },
-      entry.sbn,
-      entry.packetId,
-      entry.catalogTrackName,
-    )
+    skip(entry, reason, rttMs, budgetMs)
     return null
   }
 
@@ -701,16 +771,21 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     if (entry.expiry !== undefined) clearTimeout(entry.expiry)
   }
 
-  const urgentOutstanding = (): boolean => {
+  /** Whether any entry of priority below `priority` is queued or in flight. */
+  const outstandingBelow = (priority: RepairPriority): boolean => {
     for (const entry of entries.values()) {
-      if (entry.priority < 2) return true
+      if (entry.priority < priority) return true
     }
     return false
   }
 
-  const preemptDeltas = (): void => {
+  /**
+   * A keyframe FETCH is being sent: cancel every in-flight audio and delta
+   * FETCH (§11.4.5 item 3). Called only for a FETCH actually sent.
+   */
+  const preemptBestEffort = (): void => {
     for (const entry of entries.values()) {
-      if (entry.priority !== 2 || !entry.running) continue
+      if (entry.priority === 0 || !entry.running) continue
       stop(entry, 'preempted')
       note('repair-preempted', entry)
     }
@@ -740,8 +815,14 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
   /** `counted` is false for a reprioritisation restart, which is no retry. */
   const start = (entry: RepairEntry, counted = true): void => {
     const now = performance.now()
+    if (moot(entry)) {
+      skip(entry, 'moot-rap', readRtt(), entry.deadlineAt - now)
+      return
+    }
     const rttMs = admit(entry, now)
     if (rttMs === null) return
+    // Before the transport sees this request, so the cancels go out first.
+    if (entry.priority === 0) preemptBestEffort()
     if (counted) entry.attempts++
     mc.noteRepairFetchSent?.(entry.priority, entry.sbn, entry.packetId, entry.catalogTrackName, {
       rttMs,
@@ -775,7 +856,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         // A fetch still running at its block's fail bound can no longer land
         // in time. Cancel it here rather than trust the transport or the FEC
         // layer's resolution to end it: a hung P0/P1 left running would keep
-        // urgentOutstanding() true and gate every P2 for the session.
+        // outstandingBelow() true and gate every P1/P2 for the session.
         if (entry.deadlineAt <= now) {
           stop(entry, 'expired')
           retire(entry)
@@ -794,9 +875,13 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       queued.push(entry)
     }
     for (const entry of queued) {
-      if (entry.priority < 2) start(entry)
+      if (entry.priority === 0) start(entry)
     }
-    if (urgentOutstanding()) return
+    if (outstandingBelow(1)) return
+    for (const entry of queued) {
+      if (entry.priority === 1) start(entry)
+    }
+    if (outstandingBelow(2)) return
     queued
       .filter((entry) => entry.priority === 2)
       .sort((a, b) => a.deadlineAt - b.deadlineAt || a.order - b.order)
@@ -980,7 +1065,6 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         stop(entry, 'reprioritized')
         start(entry, false)
       }
-      preemptDeltas()
       dispatch()
       return
     }
@@ -1156,7 +1240,6 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
     entries.set(key, entry)
     noteBudget(entry, deadline.extensionMs)
-    if (entry.priority < 2) preemptDeltas()
     dispatch()
   })
 
@@ -1245,16 +1328,33 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       }
       entries.set(entry.key, entry)
       entry.expiry = setTimeout(dispatch, Math.max(0, entry.deadlineAt - performance.now()) + 1)
-      preemptDeltas()
       dispatch()
     })
   }
 
+  // A RAP arrived complete: a keyframe FETCH below it is moot (§11.4.2). The
+  // observer runs inside the frame push, so the cancel waits for a microtask
+  // rather than re-entering the FEC layer through the hold release.
+  const removeRapObserver = mc.addRapCompleteObserver?.((packetId) => {
+    queueMicrotask(() => {
+      if (disposed) return
+      for (const entry of [...entries.values()]) {
+        if (entry.packetId !== packetId || !entry.running || !moot(entry)) continue
+        stop(entry, 'moot')
+        retire(entry)
+        releaseHold(entry)
+        clearEntry(entry)
+      }
+      dispatch()
+    })
+  })
+
   return () => {
     disposed = true
     mc.setUnicastRepair?.(false)
     removeResetObserver()
     removeLifecycleObserver()
+    removeRapObserver?.()
     for (const entry of [...entries.values()]) {
       clearEntry(entry)
       if (entry.running) releaseHold(entry)

package/test-vectors/catalog/negative/multicast-auth-padded-key.json

@@ -20,7 +20,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg=",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-reused-track-format.json

@@ -30,7 +30,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-root-dotted-key.json

@@ -30,7 +30,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg",
     "keyId": "2026-08",

package/test-vectors/catalog/negative/multicast-auth-trailing-pad-bits.json

@@ -20,7 +20,6 @@
   ],
   "multicast.auth": {
     "scheme": "bc-provenance",
-    "hash": "blake3",
     "sig": "ed25519",
     "publicKey": "A6EHv_POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbh",
     "keyId": "2026-08",