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

package/src/repair-fetch.ts

@@ -41,6 +41,18 @@
  *     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 hole walked over the one-Group transport (no `rangeTransport`) is
+ *     repair the run gets before its FEC deadline (`walkHole`). On a video
+ *     track it is keyframe repair (class `unknown`): P0, and no audio or
+ *     delta FETCH is issued while one of its Group FETCHes is outstanding
+ *     (fec-multicast-00 rule 3). It reaches no FEC deadline, so it preempts
+ *     nothing and holds back no audio or delta request: one that comes due
+ *     cancels the walk's Group FETCH and goes out at once, and the walk asks
+ *     for that Group again after it (`yieldVideoWalks`). On an audio track
+ *     it is audio repair: P1 at the audio wire priority, one Group per FETCH,
+ *     and like any audio request it waits while keyframe repair is
+ *     outstanding, stopping before its next Group, and is preempted by a
+ *     keyframe FETCH sent.
  *   - 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.
@@ -100,21 +112,35 @@
  * gate behind it) past that deadline.
  */
 
-import { parseFecBlockProfile, type FecBlockProfile } from '@blockcast/mmt-base'
+import {
+  extractRepairFecPayloadId,
+  parseFecBlockProfile,
+  serial32Add,
+  serial32Distance,
+  type FecBlockProfile,
+} from '@blockcast/mmt-base'
 import { extendSsId, repairFetchRange, type RepairFetchRange } from '@blockcast/mmt-fec'
 import {
   repairPriorityForClass,
   type BlockClass,
   type ClassifierMode,
   type RepairPriority,
+  type TrackKind,
 } from './block-policy.js'
-import type { UndelimitedIsoLoss } from './fec-manager.js'
+import type { ExpiredIsoHole, UndelimitedIsoLoss } from './fec-manager.js'
 import type { RepairLifecycleObserver } from './multicast-manager.js'
 import { REPAIR_PRIORITY_MIN } from './repair-layers.js'
 
 /** The MoQ Transport priority scale: 0..255, a lower value is delivered first. */
 const MOQT_PRIORITY_MAX = 255
 
+/**
+ * How long before the span a walked hole leaves asks for its repair (D-28)
+ * the walk ends: past the deadline timer's 1 ms slack and one timer tick, so
+ * the span's request timer is armed before it is due (walkDeadlineAt).
+ */
+const WALK_LEAD_MS = 3
+
 /**
  * The highest value in the Source Media priority range of
  * draft-ramadan-moq-fec §10 (64..191): one below the repair range, which
@@ -370,10 +396,14 @@ export interface WireRepairFetchOptions {
   keyframeRepairBudgetMs?: (packetId: number, catalogTrackName?: string) => number
   /**
    * Range repair for a lost SS_ID whose block no repair delimited
-   * (draft-ramadan-moq-fec §7.5), optional. Given, the host keeps such a gap
-   * as a pending hole and the scheduler FETCHes `repairFetchRange(x, K,
-   * anchor)` for it under the same admission, priority and abort rules as a
-   * block request (class `unknown`, P0). Requires `repairEpochReference`.
+   * (draft-ramadan-moq-fec §7.5), optional. A host that can keep such a gap as
+   * a pending hole gets range repair either way, under the same admission,
+   * priority and abort rules as a block request (class `unknown`, P0). Given,
+   * the scheduler FETCHes `repairFetchRange(x, K, anchor)` over it, and
+   * requires `repairEpochReference`. Absent, it walks the hole over
+   * `transport` one Group at a time from the hole's start, whose Group is a
+   * block's, each repair stating where the next block starts (BLO-52085),
+   * under the class of the hole's track (see the module note).
    */
   rangeTransport?: RepairRangeFetchTransport
   /**
@@ -475,6 +505,12 @@ export interface RepairFetchHost {
     ): boolean
     /** The admitted FETCH ended without delivering: back to the multicast wait. */
     releaseRepairHold(sbn: number, packetId: number, catalogTrackName?: string): void
+    /** Run `fn` with `receivedAtMs` as the receipt time of what it feeds (optional). */
+    withReceiptTime?(receivedAtMs: number, fn: () => void): void
+    /** The configured media kind of a packetId (optional; absent reads as video). */
+    trackKindFor?(packetId: number): TrackKind | undefined
+    /** The stream's D-28 repair deadline: how long after a block's sources it asks for repair (optional). */
+    repairDeadlineMsForPacket?(packetId: number): number | undefined
   }
   onRepairSubscribe(cb: RepairSubscribeCallback): void
   /**
@@ -493,8 +529,17 @@ export interface RepairFetchHost {
   ): void
   addRepairLifecycleObserver(observer: RepairLifecycleObserver): () => void
   addTrackResetObserver(observer: (packetId: number, catalogTrackName: string) => void): () => void
-  /** Register for lost SS_IDs in undelimited spans (required with `rangeTransport`). */
-  onUndelimitedLoss?(cb: (loss: UndelimitedIsoLoss) => void): void
+  /**
+   * Register for lost SS_IDs in undelimited spans (required with
+   * `rangeTransport`). A host that offers it and `closeIsoHoles` keeps such a
+   * gap as a pending hole for the scheduler to repair. `onExpired` is told of
+   * a pending hole the stream ran past the locator's horizon; returning true,
+   * the scheduler closes it (`closeIsoHoles`), otherwise the host discards it.
+   */
+  onUndelimitedLoss?(
+    cb: (loss: UndelimitedIsoLoss) => void,
+    onExpired?: (hole: ExpiredIsoHole) => boolean,
+  ): void
   /** A hole's range repair ended, or none is sent: feed what was not stated. */
   closeIsoHoles?(packetId: number, catalogTrackName: string | undefined, start: number, length: number): void
   clearRepairForBlock(sbn: number, packetId: number, catalogTrackName?: string): void
@@ -624,9 +669,26 @@ interface RepairEntry {
   attempts: number
   running: FetchRun | null
   /** A range request for a pending hole `[sbn, sbn + holeLength)`. */
-  readonly range?: RepairFetchRange & { readonly lostSsId: number; readonly holeLength: number }
+  readonly range?: {
+    readonly lostSsId: number
+    readonly holeLength: number
+    /** The §7.7 Group range for `rangeTransport`; null walks the hole over `transport`. */
+    readonly groups: RepairFetchRange | null
+    /** When the hole was reported: what it states keeps the deadline a span opened then would have. */
+    readonly reportedAt: number
+  }
   /** A range request's deadline timer (see the module note). */
   expiry?: ReturnType<typeof setTimeout>
+  /**
+   * A hole walked over `transport` (walkHole): the Group its next FETCH asks
+   * for, and the Group FETCH it has outstanding, if any.
+   */
+  walk?: {
+    next: number
+    group: { readonly sbn: number; readonly controller: AbortController } | null
+    /** Its Group FETCH was cancelled for best-effort repair: ask for that Group again. */
+    yielded: boolean
+  }
 }
 
 interface ResolvedDeadline {
@@ -686,8 +748,26 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
 
   /** Whatever ends an entry: a block's repair slot, or a hole's pending state. */
   const clearEntry = (entry: RepairEntry): void => {
-    if (entry.range) mc.closeIsoHoles!(entry.packetId, entry.catalogTrackName, entry.sbn, entry.range.holeLength)
-    else clearRepair(entry.sbn, entry.packetId, entry.catalogTrackName)
+    const { range } = entry
+    if (range) {
+      atReport(range, () => mc.closeIsoHoles!(entry.packetId, entry.catalogTrackName, entry.sbn, range.holeLength))
+    } else {
+      clearRepair(entry.sbn, entry.packetId, entry.catalogTrackName)
+    }
+  }
+
+  /**
+   * Run what a hole's walk states, or the rest of the hole it leaves as
+   * spans, at the time the hole was reported: the blocks start their
+   * deadlines from there, as the one repair-less span a host without holes
+   * opened then would have, so the walk never holds a frame later than that
+   * span did. A §7.7 range FETCH feeds at its own receipt time, as a host
+   * with `rangeTransport` always has.
+   */
+  const atReport = (range: NonNullable<RepairEntry['range']>, work: () => void): void => {
+    const fec = mc.fecManager
+    if (range.groups !== null || fec.withReceiptTime === undefined) work()
+    else fec.withReceiptTime(range.reportedAt, work)
   }
 
   const releaseHold = (entry: RepairEntry): void => {
@@ -781,32 +861,78 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
   const admit = (entry: RepairEntry, now: number): number | null => {
     const budgetMs = entry.deadlineAt - now
     const rttMs = readRtt()
-    const reason: RepairSkipReason | null =
-      !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName)
-        ? 'group-cannot-complete'
-        : rttMs === null
-          ? 'rtt-unmeasured'
-          : rttMs < budgetMs
-            ? null
-            : 'rtt-exceeds-budget'
+    const reason = refusal(entry, now, rttMs)
     if (reason === null) return rttMs
     skip(entry, reason, rttMs, budgetMs)
     return null
   }
 
+  /** Why admission refuses `entry` at `now` with round trip `rttMs`, or null when it admits it. */
+  const refusal = (entry: RepairEntry, now: number, rttMs: number | null): RepairSkipReason | null =>
+    !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName)
+      ? 'group-cannot-complete'
+      : rttMs === null
+        ? 'rtt-unmeasured'
+        : rttMs < entry.deadlineAt - now
+          ? null
+          : 'rtt-exceeds-budget'
+
   const retire = (entry: RepairEntry): void => {
     if (entries.get(entry.key) === entry) entries.delete(entry.key)
     if (entry.expiry !== undefined) clearTimeout(entry.expiry)
   }
 
-  /** Whether any entry of priority below `priority` is queued or in flight. */
-  const outstandingBelow = (priority: RepairPriority): boolean => {
+  /**
+   * Whether `entry` holds back a request of `priority`: no audio or delta
+   * repair FETCH is issued while a keyframe repair FETCH is outstanding
+   * (fec-multicast-00 rule 3), and no delta one while audio repair is. A
+   * walk (walkHole) is repair a run gets before it reaches its FEC deadline:
+   * on a video track it is keyframe repair while one of its Group FETCHes is
+   * outstanding and between two Groups holds nothing back; on an audio track
+   * it holds nothing back (BLO-52085). `videoWalks` false leaves video walks
+   * out: they yield to a request that is no walk (`yieldVideoWalks`).
+   */
+  const holdsBack = (entry: RepairEntry, priority: RepairPriority, videoWalks = true): boolean => {
+    if (entry.priority >= priority) return false
+    const { walk } = entry
+    if (walk === undefined) return true
+    if (entry.priority !== 0 || !videoWalks) return false
+    return entry.running === null || (walk.group !== null && !walk.group.controller.signal.aborted)
+  }
+
+  /** Whether any entry holds back a request of `priority` (see `holdsBack`). */
+  const outstandingBelow = (priority: RepairPriority, videoWalks = true): boolean => {
     for (const entry of entries.values()) {
-      if (entry.priority < priority) return true
+      if (holdsBack(entry, priority, videoWalks)) return true
     }
     return false
   }
 
+  /**
+   * A video walk reaches no FEC deadline, so it holds back no audio or delta
+   * request that came due (one of `queued` that is no walk), that nothing
+   * else holds back and that admission takes (`admit`): it cancels its outstanding Group FETCH first, so no
+   * keyframe repair FETCH is outstanding when that request is issued
+   * (fec-multicast-00 rule 3), and asks for that Group again after it
+   * (walkHole). Audio and delta repair so goes out when it would with no
+   * walk at all (BLO-52085).
+   */
+  const yieldVideoWalks = (queued: readonly RepairEntry[]): void => {
+    const now = performance.now()
+    const rttMs = readRtt()
+    const due = queued.some((entry) =>
+      entry.priority !== 0 && entry.walk === undefined && !outstandingBelow(entry.priority, false) &&
+      refusal(entry, now, rttMs) === null)
+    if (!due) return
+    for (const entry of entries.values()) {
+      const walk = entry.walk
+      if (entry.priority !== 0 || walk === undefined || walk.group === null) continue
+      if (walk.group.controller.signal.aborted) continue
+      walk.yielded = true
+      walk.group.controller.abort()
+    }
+  }
+
   /**
    * 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.
@@ -849,8 +975,12 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
     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()
+    // Before the transport sees this request, so the cancels go out first. A
+    // walk reaches no FEC deadline, so it cancels nothing (rule 3).
+    if (entry.priority === 0 && entry.walk === undefined) preemptBestEffort()
+    // fec-multicast-00 rule 1: one FETCH per block and repair layer. A walk
+    // reading this block's Group leaves it to this request.
+    if (entry.range === undefined) leaveWalkedGroup(entry)
     if (counted) entry.attempts++
     mc.noteRepairFetchSent?.(entry.priority, entry.sbn, entry.packetId, entry.catalogTrackName, {
       rttMs,
@@ -875,6 +1005,20 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     void execute(entry, run)
   }
 
+  /** End any walk's FETCH of `block`'s Group, cancelling it, before the block's own goes out. */
+  const leaveWalkedGroup = (block: RepairEntry): void => {
+    for (const entry of entries.values()) {
+      const group = entry.walk?.group
+      if (
+        group?.sbn === block.sbn &&
+        entry.packetId === block.packetId &&
+        entry.catalogTrackName === block.catalogTrackName
+      ) {
+        group.controller.abort()
+      }
+    }
+  }
+
   const dispatch = (): void => {
     if (disposed) return
     const now = performance.now()
@@ -905,6 +1049,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     for (const entry of queued) {
       if (entry.priority === 0) start(entry)
     }
+    yieldVideoWalks(queued)
     if (outstandingBelow(1)) return
     for (const entry of queued) {
       if (entry.priority === 1) start(entry)
@@ -954,6 +1099,25 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
     return counts.sources + counts.repairGroupLength >= counts.authoredLength
   }
+  /**
+   * Whether the block a walked Group states can use none of the Group's other
+   * repair symbols: the host holds as many of its symbols as its K' (complete,
+   * or decoding), its group cannot complete it, or it no longer tracks it
+   * (resolved). A relay may hold only part of a Group, or keep its FETCH open,
+   * so the walk does not wait for the rest. False when the host reports no
+   * counts: the walk then takes the whole Group.
+   */
+  const groupServed = (sbn: number, packetId: number, catalogTrackName: string | undefined): boolean => {
+    if (mc.fecManager.blockSymbolCounts === undefined) return false
+    const counts = symbolCounts(sbn, packetId, catalogTrackName)
+    if (counts === undefined || counts.authoredLength === undefined) return true
+    return counts.sources + counts.repairs >= counts.authoredLength || !groupCanComplete(sbn, packetId, catalogTrackName)
+  }
+  /** Where the next block starts after the open block `sbn`, when a repair stated it. */
+  const statedEnd = (sbn: number, packetId: number, catalogTrackName: string | undefined): number | undefined => {
+    const length = symbolCounts(sbn, packetId, catalogTrackName)?.authoredLength
+    return length === undefined ? undefined : serial32Add(sbn, length)
+  }
 
   const finish = (entry: RepairEntry, run: FetchRun, fed: number, error: unknown): void => {
     if (run.stopped !== null || entry.running !== run || entries.get(entry.key) !== entry) {
@@ -1019,23 +1183,30 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       signal: run.controller.signal,
       subscriberPriority: entry.subscriberPriority,
     }
+    const { range } = entry
+    const feed = (packet: Uint8Array): void => {
+      if (entry.catalogTrackName === undefined) {
+        mc.processRepairFromMoQ(packet, entry.packetId)
+      } else {
+        mc.processRepairFromMoQ(packet, entry.packetId, entry.catalogTrackName)
+      }
+    }
     try {
-      const packets = entry.range
-        ? opts.rangeTransport!({
-            ...common,
-            startGroup: entry.range.startGroup,
-            endGroup: entry.range.endGroup,
-            lostSsId: entry.range.lostSsId,
-          })
-        : opts.transport({ ...common, sbn: entry.sbn })
+      const packets = range === undefined
+        ? opts.transport({ ...common, sbn: entry.sbn })
+        : entry.walk !== undefined
+          ? walkHole(entry, entry.walk, range, common)
+          : opts.rangeTransport!({
+              ...common,
+              startGroup: range.groups!.startGroup,
+              endGroup: range.groups!.endGroup,
+              lostSsId: range.lostSsId,
+            })
       for await (const packet of packets) {
         if (run.stopped !== null || entry.running !== run) break
         fed++
-        if (entry.catalogTrackName === undefined) {
-          mc.processRepairFromMoQ(packet, entry.packetId)
-        } else {
-          mc.processRepairFromMoQ(packet, entry.packetId, entry.catalogTrackName)
-        }
+        if (range === undefined) feed(packet)
+        else atReport(range, () => feed(packet))
       }
       finish(entry, run, fed, undefined)
     } catch (error) {
@@ -1043,6 +1214,86 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
   }
 
+  /**
+   * The §7.7 range FETCH of a hole over a transport that FETCHes one Group.
+   * A hole starts where a stated block ends, so ext(hole start) is a block's
+   * Group; the repair of each Group states its block, and that block's end is
+   * the next block's Group. Walks to the block holding the hole's highest
+   * lost SS_ID (everything after it arrived) and stops early when a Group
+   * names no block and none is stated there. A Group is done when it ends,
+   * when it held its RSB_length repair symbols, or once the block it states
+   * can use none of the rest (`groupServed`): a relay may keep the FETCH open
+   * past its last object (BLO-52085 D2 80601), or hold only part of the
+   * Group. Each Group is its own FETCH with its own signal, aborted once the
+   * walk leaves it, so the transport cancels it on the wire, and never one
+   * the block's own FETCH reads (fec-multicast-00 rule 1: `leaveWalkedGroup`
+   * takes it over). Between two Groups the walk honours rule 3 (see
+   * `holdsBack`): an audio walk that finds keyframe repair outstanding goes
+   * back to the queue and resumes at `walk.next`; a video walk first
+   * dispatches what came due, and asks again for a Group whose FETCH it
+   * cancelled for audio or delta repair (`yieldVideoWalks`). Every packet is
+   * fed before the walk reads the host's counts: the consumer feeds what it
+   * yields before asking for more.
+   */
+  async function* walkHole(
+    entry: RepairEntry,
+    walk: NonNullable<RepairEntry['walk']>,
+    hole: NonNullable<RepairEntry['range']>,
+    common: Omit<RepairFetchRequest, 'sbn'>,
+  ): AsyncGenerator<Uint8Array> {
+    const lostAt = serial32Distance(entry.sbn, hole.lostSsId)
+    for (let first = true; !common.signal.aborted; first = false) {
+      if (!first && entry.priority !== 0 && outstandingBelow(1)) {
+        stop(entry, 'preempted')
+        note('repair-preempted', entry)
+        return
+      }
+      if (!first && entry.priority === 0) {
+        dispatch()
+        if (common.signal.aborted) return
+      }
+      const sbn = walk.next
+      let next: number | undefined
+      if (entries.get(requestKey(sbn, entry.packetId, entry.catalogTrackName))?.running == null) {
+        const rsIds = new Set<number>()
+        const group = new AbortController()
+        const cancel = (): void => group.abort()
+        common.signal.addEventListener('abort', cancel, { once: true })
+        walk.group = { sbn, controller: group }
+        try {
+          for await (const packet of opts.transport({ ...common, sbn, signal: group.signal })) {
+            yield packet
+            const id = extractRepairFecPayloadId(packet)
+            if (id === null || id.ssStart !== sbn || id.ssbLength === 0) continue
+            next ??= serial32Add(sbn, id.ssbLength)
+            rsIds.add(id.rsId)
+            // Aborted before the loop lets go of the transport, whose own
+            // cleanup may stop listening for the abort.
+            if (rsIds.size >= id.rsbLength || groupServed(sbn, entry.packetId, entry.catalogTrackName)) {
+              group.abort()
+              break
+            }
+          }
+        } catch (error) {
+          // The Group was taken over or yielded: the walk goes on.
+          if (!group.signal.aborted || common.signal.aborted) throw error
+        } finally {
+          common.signal.removeEventListener('abort', cancel)
+          walk.group = null
+        }
+        if (walk.yielded) {
+          walk.yielded = false
+          continue
+        }
+      }
+      next ??= statedEnd(sbn, entry.packetId, entry.catalogTrackName)
+      if (next === undefined) return
+      // Past the highest lost SS_ID, which lies in the hole: done.
+      if (serial32Distance(entry.sbn, next) > lostAt) return
+      walk.next = next
+    }
+  }
+
   const removeResetObserver = mc.addTrackResetObserver((packetId, catalogTrackName) => {
     for (const entry of [...entries.values()]) {
       if (entry.packetId !== packetId || entry.catalogTrackName !== catalogTrackName) continue
@@ -1300,17 +1551,75 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
     }
   }
 
-  if (opts.rangeTransport !== undefined) {
-    mc.onUndelimitedLoss!((loss) => {
+  const trackKind = (packetId: number): TrackKind | undefined => {
+    try {
+      return mc.fecManager.trackKindFor?.(packetId)
+    } catch {
+      return undefined
+    }
+  }
+
+  /**
+   * Where a walk of a hole reported `now` ends: WALK_LEAD_MS before the span
+   * it leaves asks for its repair (D-28 from the report, as the span a host
+   * without holes opened then did), so that span's request is armed before
+   * it is due and goes out at the same time; never later than `deadlineAt`.
+   */
+  const walkDeadlineAt = (packetId: number, now: number, deadlineAt: number): number => {
+    let repairDeadlineMs: number | undefined
+    try {
+      repairDeadlineMs = mc.fecManager.repairDeadlineMsForPacket?.(packetId)
+    } catch {
+      repairDeadlineMs = undefined
+    }
+    if (repairDeadlineMs === undefined || !Number.isFinite(repairDeadlineMs)) return deadlineAt
+    return Math.min(deadlineAt, now + repairDeadlineMs - WALK_LEAD_MS)
+  }
+
+  /**
+   * The stream ran past the locator's horizon behind a hole: no repair can
+   * state its blocks any more. A walking hole's walk ends and the hole closes
+   * as at its deadline, so the span it leaves fails, and is reported, as the
+   * span opened at its report would have (BLO-52085); the host discards any
+   * other. Called from inside the stream's packet handling, so the walk ends
+   * once that returns, as for a RAP (below).
+   */
+  const onHoleExpired = (hole: ExpiredIsoHole): boolean => {
+    if (disposed) return false
+    const entry = [...entries.values()].find((candidate) =>
+      candidate.walk !== undefined &&
+      candidate.packetId === hole.packetId &&
+      candidate.catalogTrackName === hole.catalogTrackName &&
+      serial32Distance(candidate.sbn, hole.holeStart) < candidate.range!.holeLength)
+    if (entry === undefined) return false
+    queueMicrotask(() => {
+      if (entries.get(entry.key) !== entry) return
+      retire(entry)
+      stop(entry, 'expired')
+      clearEntry(entry)
+      dispatch()
+    })
+    return true
+  }
+
+  // A host that can keep a hole gets range repair: the §7.7 range over
+  // `rangeTransport`, or else a walk of the hole's Groups over `transport`.
+  if (mc.onUndelimitedLoss !== undefined && mc.closeIsoHoles !== undefined) {
+    mc.onUndelimitedLoss((loss) => {
       const { packetId, catalogTrackName, holeStart, holeLength } = loss
       const close = (): void => mc.closeIsoHoles!(packetId, catalogTrackName, holeStart, holeLength)
       if (disposed) return close()
       const blockProfile = blockProfileOf(packetId)
       const target = opts.resolveTarget(packetId, catalogTrackName)
       if (!target) return close()
-      const priority = repairPriorityForClass('unknown')
-      const range = rangeFor(loss, target.repairTrack)
-      if (range === null) {
+      // The run's class (fec-multicast-00 Block Classification, Audio
+      // Blocks): walked, a hole on an audio track is audio repair, one Group
+      // per FETCH; any other is of unknown class, so keyframe repair.
+      const walked = opts.rangeTransport === undefined
+      const holeClass: BlockClass = walked && trackKind(packetId) === 'audio' ? 'audio' : 'unknown'
+      const priority = repairPriorityForClass(holeClass)
+      const groups = walked ? null : rangeFor(loss, target.repairTrack)
+      if (!walked && groups === null) {
         close()
         mc.noteRepairSkipped('range-no-anchor', { rttMs: readRtt(), budgetMs: 0, priority }, holeStart, packetId, catalogTrackName)
         return
@@ -1321,12 +1630,15 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         packetId,
         ...(catalogTrackName === undefined ? {} : { catalogTrackName }),
       }
-      // `unknown` is P0, whose request is never declined (omitted at worst).
-      const wire = wirePriority(identity, 'unknown')!
+      // `unknown` is P0, whose request is never declined (omitted at worst);
+      // an audio FETCH the catalog gives no priority for is not sent.
+      const wire = wirePriority(identity, holeClass)
+      if (wire === null) return close()
       // The hole is no tracked block: no anchor, so this is the multicast
       // wait (`bound: 'wait'`), by intent. A hole holds the release gate, so it
       // must not wait out a presentation delay on top.
-      const deadline = presentationDeadlineAt(holeStart, packetId, catalogTrackName, performance.now(), 'unknown')
+      const now = performance.now()
+      const deadline = presentationDeadlineAt(holeStart, packetId, catalogTrackName, now, holeClass)
       if (deadline === null) {
         close()
         mc.noteRepairSkipped(
@@ -1338,6 +1650,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         )
         return
       }
+      const deadlineAt = walked ? walkDeadlineAt(packetId, now, deadline.deadlineAt) : deadline.deadlineAt
       const entry: RepairEntry = {
         key: JSON.stringify(['range', packetId, catalogTrackName ?? null, holeStart]),
         ...identity,
@@ -1345,15 +1658,16 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
         blockProfile,
         priority,
         subscriberPriority: wire.subscriberPriority,
-        deadlineAt: deadline.deadlineAt,
-        playoutDeadlineAt: deadline.deadlineAt - deadline.extensionMs,
+        deadlineAt,
+        playoutDeadlineAt: deadlineAt - deadline.extensionMs,
         anchorAt: deadline.anchorAt,
         delayMs: deadline.delayMs,
         bound: deadline.bound,
         order: enqueueOrder++,
         attempts: 0,
         running: null,
-        range: { ...range, lostSsId: loss.lostSsId, holeLength },
+        range: { lostSsId: loss.lostSsId, holeLength, groups, reportedAt: now },
+        ...(walked ? { walk: { next: holeStart, group: null, yielded: false } } : {}),
       }
       const previous = entries.get(entry.key)
       if (previous) {
@@ -1363,7 +1677,7 @@ export function wireRepairFetch(mc: RepairFetchHost, opts: WireRepairFetchOption
       entries.set(entry.key, entry)
       entry.expiry = setTimeout(dispatch, Math.max(0, entry.deadlineAt - performance.now()) + 1)
       dispatch()
-    })
+    }, onHoleExpired)
   }
 
   // A RAP arrived complete: a keyframe FETCH below it is moot (§11.4.2). The