@blockcast/mmt-container 0.3.0 → 0.4.0-main.1cd3cdea89da

package/src/fec-manager.ts

@@ -9,20 +9,18 @@
  * MMTP packet parsing and frame routing.
  */
 
-import { computeFecDeliveryWindowMs } from './track-session.js'
+import { computeFecDeliveryWindowMs, fecSpanDeliveryWindowMs } from './track-session.js'
 import { DeliveryGapEstimator } from './delivery-gap.js'
 import {
   deriveFecInterleaveDepth,
   deriveFecRetentionBlocks,
   tryDeriveFecRetentionBlocks,
+  LOCAL_FEC_RETENTION_BLOCKS,
+  LOCAL_FEC_TIMEOUT_MS,
 } from '@blockcast/mmt-fec'
 import {
-  isKStrideBlock,
   isoBlockContains,
   isoBlocksBehindLowerBound,
-  kStrideBlockPrecedes,
-  kStrideBlocksBehind,
-  kStrideNextBlock,
   parseFecBlockProfile,
   serial32Distance,
   serial32Precedes,
@@ -86,7 +84,7 @@ export type WasmFecDecoder = {
   configure(oti: Uint8Array): void
   cleanup(current_time: number): Uint8Array
   /** Retire the named blocks from the decoder (last-chance decode + stats). */
-  cleanup_blocks_detailed(sbns: Uint32Array): unknown
+  cleanup_blocks_detailed(ss_starts: Uint32Array): unknown
   /**
    * iso-ssbg1-v1 only: retire the source symbols the decoder holds before a
    * repair states their block, once no repair can place them any more, by the
@@ -112,7 +110,8 @@ export interface FecStats {
   blocksComplete: number
   mixedPathBlocks: number
   recentBlockPathCounts: FecBlockPathCount[]
-  k: number
+  /** The stream-global K a configure() call stated; undefined when none did. Per-track K is tracks[].k. */
+  k: number | undefined
   /** Of blocks with loss, what percentage were recovered (0-100). */
   recoveryRate: number
   /** What percentage of blocks had any loss (0-100). */
@@ -136,7 +135,8 @@ export interface FecPacketStats {
   blocksRecovered: number
   blocksFailed: number
   blocksComplete: number
-  k: number
+  /** The track's configured K; undefined for a packetId never configured (it does no FEC work). */
+  k: number | undefined
   recoveryRate: number
   packetLossRate: number
 }
@@ -217,10 +217,11 @@ type FecLifecycleTrace = {
 export interface FECManagerConfig {
   /**
    * The catalog `fec.blockProfile` of the track (BLO-35597). Required for every
-   * configured track: there is no default, and nothing infers it.
-   * `k-padded-v1` keeps the legacy K-stride geometry; `iso-ssbg1-v1` is
-   * ISO/IEC 23008-1 ssbg_mode1 with K' = SSB_length blocks located by
-   * `(SS_Start, SSB_length)` range membership, `k` being only their maximum.
+   * configured track: there is no default, and nothing infers it. The only
+   * profile is `iso-ssbg1-v1`: ISO/IEC 23008-1 ssbg_mode1 with K' = SSB_length
+   * blocks keyed by SS_Start and located by `(SS_Start, SSB_length)` range
+   * membership, `k` being only their maximum. The retired `k-padded-v1` token
+   * is refused.
    */
   blockProfile?: FecBlockProfile
   k?: number
@@ -373,7 +374,6 @@ export interface FecDecoderUnavailableEvent {
 export class FECManager {
   // Per-track WASM RaptorQ decoders, keyed by physical stream identity.
   #fecDecoders = new Map<string, { client: WasmFecDecoder; k: number }>()
-  /** @deprecated Use setFecDecoder(packetId, ...). Backwards-compat shim. */
 
   // Per-track Worker-backed FEC decoders, keyed by physical stream identity.
   // Worker-backed tracks use async decode — recovered frames arrive via onFrame callback,
@@ -393,9 +393,12 @@ export class FECManager {
     conflicted: boolean
   }>>()
 
-  #fecK = 4
+  // The stream-global K a configure() call stated, reported as fecStats.k.
+  // It never resolves a packetId: a packetId has only its own track config
+  // (BLO-45953), and K does not feed the delivery-window math.
+  #streamK: number | undefined
   #fecSymbolSize = 0
-  #fecTimeoutMs = 500 // default 500ms; refined by setFramerate() when fps known
+  #fecTimeoutMs = LOCAL_FEC_TIMEOUT_MS // local default; refined by setFramerate() when fps known
   #trackConfigs = new Map<number, ResolvedFECTrackConfig>()
   #fecStats = newFecCounters()
   #fecTrackStats = new Map<number, MutableFecCounters>()
@@ -436,14 +439,17 @@ export class FECManager {
   #blockSourceEsis = new Map<string, Set<number>>()
   // Authored SSB_length per block (ISO/IEC 23008-1 §C.5.3), learned from the
   // first repair symbol. The FFmpeg moq_mmt publisher closes a block every D
-  // media units, usually before it holds K symbols, and fec-raptorq
-  // force_complete() encodes it as a K-symbol RaptorQ block whose ESIs
-  // SSB_length..K-1 are zero padding that is never sent. Such a block is clean
-  // at SSB_length source arrivals and recoverable from SSB_length received
+  // media units, usually before it holds K symbols; under iso-ssbg1-v1
+  // (ssbg_mode1) that block is K' = SSB_length symbols, its repair ESIs start
+  // at SSB_length, and K is only the maximum. Such a block is clean at
+  // SSB_length source arrivals and recoverable from SSB_length received
   // symbols; waiting for K fails every one of them.
   #blockAuthoredLengths = new Map<string, number>()
   #ssbLengthConflictCount = 0
   #blockRepairRsIds = new Map<string, Set<number>>()
+  // RSB_length per block (C.5.3 Repair FEC Payload ID): how many repair
+  // symbols its repair group carries. Same lifecycle as #blockRepairRsIds.
+  #blockRsbLengths = new Map<string, number>()
   // Blocks already recovered — prevents late source symbols from restarting timeouts.
   // WASM removes blocks after recovery; late symbols create empty blocks returning null,
   // which would falsely start new timeouts without this guard.
@@ -558,14 +564,16 @@ export class FECManager {
   #resolvedBlockClasses = new Map<string, BlockClass>()
   // Blocks already reported through onBlockRepaired (once per block).
   #repairedBlocks = new Set<string>()
-  // Blocks created without any symbol because every symbol vanished.
+  // Blocks created before any symbol of theirs was tracked: the repair-less
+  // spans placeIsoRepair materializes (onBlockVanished).
   #materializedBlocks = new Set<string>()
   // packetIds whose ordered-relay horizon became underivable and fell back to
   // the datagram deadline. Bounds the warn in #derivableOrderedHorizon to once
   // per stream. Not only throws: the ordinary out-of-range case is detected by
   // arithmetic and never throws at all.
   #orderedHorizonWarnedFor = new Set<number>()
-  // Highest SBN seen per stream and when, for vanished-block detection.
+  // Newest block start (SS_Start) seen per stream and when: the frontier for
+  // source-discontinuity detection and isoSpanResolution.
   #highestSbn = new Map<string, { sbn: number; atMs: number }>()
   // iso-ssbg1-v1 block location per stream (streamKey). A source belongs to a
   // block only once a repair symbol stated the block's (SS_Start, SSB_length).
@@ -829,7 +837,8 @@ export class FECManager {
     this.#completedBlocks.add(key)
     if (clean) this.#cleanlyCompletedBlocks.add(key)
     this.#indexBlockKey(key, sbn, packetId)
-    const expiresAtMs = nowMs + this.terminalRetentionMsForPacket(packetId)
+    const config = this.#trackConfig(packetId)
+    const expiresAtMs = nowMs + config.interleaveDepthMs + 2 * this.#blockLifetimeMs(config)
     this.#terminalExpiryMs.set(key, expiresAtMs)
     let queue = this.#terminalQueues.get(packetId)
     if (!queue) {
@@ -877,8 +886,9 @@ export class FECManager {
    * retention the Worker and the WASM decoder are configured with, because it
    * comes from the same function they do (`deriveFecRetentionBlocks`, over the
    * block's delivery window and its span). The decoder retires every block
-   * more than this many SBNs behind the newest one it saw (`cleanup_by_sbn`),
-   * so settling earlier than this would decide a block the decoder would still
+   * more than this many blocks behind the newest SS_Start it saw, counted
+   * from below by `isoBlocksBehindLowerBound` (`cleanup_by_ss_start`), so
+   * settling earlier than this would decide a block the decoder would still
    * have recovered.
    *
    * This used to call `deriveFecInterleaveDepth`, which returns D -- MEDIA
@@ -891,6 +901,18 @@ export class FECManager {
    * derivation; do not re-derive a horizon at either call site.
    */
   #orderedHorizonBlocksFor(packetId: number, config: ResolvedFECTrackConfig): number {
+    // An absent/zero catalog span has no elapsed-time horizon. Ordered relay
+    // still needs a bounded local cleanup distance, so use the shared local
+    // count without treating it as a catalog-derived deadline.
+    if (config.interleaveDepthMs === 0) {
+      if (Number.isFinite(config.timeoutMs) && config.timeoutMs > 0) {
+        return LOCAL_FEC_RETENTION_BLOCKS
+      }
+      throw new Error(
+        `[FECManager] packetId=${packetId}: local FEC cleanup requires a positive timeout ` +
+          `(got ${config.timeoutMs})`,
+      )
+    }
     if (!FECManager.#hasOrderedGeometry(config)) {
       throw new Error(
         `[FECManager] packetId=${packetId}: ordered-relay settlement derives the ` +
@@ -913,7 +935,7 @@ export class FECManager {
    */
   static #hasOrderedGeometry(config: ResolvedFECTrackConfig): boolean {
     return (
-      config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS &&
+      FECManager.#hasCatalogTiming(config) &&
       // `fps` is no longer an input to the horizon, but it still gates WHICH
       // streams settle by stream order at all: a track with no usable
       // media-unit rate fell back to datagram semantics before this and must
@@ -960,6 +982,11 @@ export class FECManager {
    * argument: narrower IS the failing direction.
    */
   #derivableOrderedHorizon(config: ResolvedFECTrackConfig, packetId: number): number | undefined {
+    if (config.interleaveDepthMs === 0) {
+      return Number.isFinite(config.timeoutMs) && config.timeoutMs > 0
+        ? LOCAL_FEC_RETENTION_BLOCKS
+        : undefined
+    }
     if (!FECManager.#hasOrderedGeometry(config)) return undefined
     try {
       // `tryDeriveFecRetentionBlocks`, not the throwing variant: this is the
@@ -1016,19 +1043,20 @@ export class FECManager {
   /**
    * The stream's interleave horizon, or undefined when its geometry cannot
    * define one. Two different streams reach that case, with different causes:
-   * a packetId that was never configured, and so resolves to the manager
-   * defaults (explicitly configured tracks are refused an underivable geometry
+   * a packetId that was never configured, which has no geometry at all
+   * (explicitly configured tracks are refused an underivable geometry
    * at config time — #upsertTrackConfig, setMulticastSymbolDelivery); or a
    * configured track whose timeoutMs was later widened past the 255-block
    * ceiling without re-validating, which #derivableOrderedHorizon catches
    * rather than throwing from the packet-feed path. Either way the stream
-   * keeps datagram semantics instead of throwing. The manager defaults can
+   * keeps datagram semantics instead of throwing. A track's configuration can
    * also change under a stream that already holds blocks, so a caller cannot
    * assume a horizon that was defined when a block was held is still defined
    * (see #advanceOrderedFrontier).
    */
   #orderedHorizonBlocks(packetId: number): number | undefined {
-    return this.#derivableOrderedHorizon(this.#resolveTrackConfig(packetId), packetId)
+    const config = this.#trackConfigs.get(packetId)
+    return config === undefined ? undefined : this.#derivableOrderedHorizon(config, packetId)
   }
 
   /** True while a block of an ordered-relay stream can still receive symbols. */
@@ -1073,7 +1101,7 @@ export class FECManager {
     catalogTrackName?: string,
   ): void {
     const previous = this.#orderedFrontiers.get(streamKey)
-    const frontier = previous === undefined || this.#blockPrecedes(previous, sbn, packetId)
+    const frontier = previous === undefined || this.#blockPrecedes(previous, sbn)
       ? sbn
       : previous
     if (frontier !== previous) this.#orderedFrontiers.set(streamKey, frontier)
@@ -1081,10 +1109,9 @@ export class FECManager {
     if (!pending) return
     const blocks = this.#orderedHorizonBlocks(packetId)
     if (blocks === undefined) {
-      // Either an unconfigured stream (it resolves to the manager defaults,
-      // and configure() accepts a sub-floor interleaveDepthMs) or a configured
-      // one whose timeoutMs was widened past the 255-block ceiling after
-      // validation (#derivableOrderedHorizon). Stream
+      // A configured stream whose timeoutMs was widened past the 255-block
+      // ceiling after validation (#derivableOrderedHorizon); an unconfigured
+      // one never gets here (feedSymbolFromSource refuses it). Stream
       // order can no longer settle its held blocks, so hand them to the
       // datagram deadline -- as setMulticastSymbolDelivery('datagram') does --
       // rather than settle them a horizon early or hold them with no timer.
@@ -1130,6 +1157,7 @@ export class FECManager {
       (this.#blockSourceCounts.get(key) ?? 0) +
       (this.#blockRepairRsIds.get(key)?.size ?? 0)
     if (
+      this.#hasCatalogTimingForPacket(packetId) &&
       this.onRepairNeeded &&
       (authoredLength === undefined || received < authoredLength)
     ) {
@@ -1343,6 +1371,7 @@ export class FECManager {
     const key = this.#blockKey(sbn, packetId, catalogTrackName)
     if (
       this.#completedBlocks.has(key) ||
+      !this.#hasCatalogTimingForPacket(packetId) ||
       !this.onRepairNeeded ||
       this.#repairRequestedBlocks.has(key)
     ) return
@@ -1450,6 +1479,7 @@ export class FECManager {
 
   /** A block's live class without creating classifier state for the stream. */
   #peekClass(sbn: number, packetId: number, catalogTrackName?: string): BlockClass {
+    if (!this.#hasCatalogTimingForPacket(packetId)) return 'unknown'
     const classifier = this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))
     if (classifier) return classifier.classOf(sbn)
     return this.#geometryFor(packetId, catalogTrackName).trackKind === 'audio' ? 'audio' : 'unknown'
@@ -1479,8 +1509,8 @@ export class FECManager {
   // Deliberately one block tighter than deriveFecRetentionBlocks over the same
   // inputs (that function's `+ 1`). Different question: the retention horizon
   // asks how long the decoder still ACCEPTS symbols for a block, this asks how
-  // far back a block that vanished entirely may still be repairable (see
-  // #noteSbnSeen).
+  // many blocks a stream can live behind (or ahead of) its frontier before a
+  // source symbol there is a discontinuity rather than loss (see #noteSbnSeen).
   // The extra block of retention is slack for a block still being fed; a block
   // nothing has been heard from does not get it. Not the units defect — but it
   // is the next place the two can drift, so change both or neither.
@@ -1490,27 +1520,28 @@ export class FECManager {
   }
 
   /**
-   * Record that a symbol for block `sbn` arrived and materialise any blocks
-   * that vanished entirely between the stream's highest SBN and this one.
+   * Record that a symbol for block `sbn` (the block's SS_Start) arrived and
+   * advance the stream's frontier, the newest block start seen.
    *
-   * The newest ceil(timeoutMs / interleaveDepthMs) vanished blocks may still
-   * be repairable, so they get the normal repair and fail deadlines, armed
-   * from now. Older ones are already past their fail bound and fail now, as
-   * class `unknown`. A SOURCE symbol whose SBN goes back further than one
-   * live window, or jumps further than the stream could have produced since
-   * its last symbol, is a source discontinuity, not loss. A repair symbol can
-   * only advance the frontier: a D-28 fetch legitimately answers for an old
-   * block, so it never signals a discontinuity.
+   * A SOURCE symbol whose block goes back further than one live window, or
+   * jumps further than the stream could have produced since its last symbol,
+   * is a source discontinuity, not loss. A repair symbol can only advance the
+   * frontier: a D-28 fetch legitimately answers for an old block, so it never
+   * signals a discontinuity.
    *
    * The producer closes a block at its Dth media-unit boundary OR when K
-   * source symbols filled it, so one interleave span can start several
-   * blocks (every large keyframe does). What bounds a forward jump is
-   * therefore packet evidence, not a block rate: with the MMTP
-   * packet_sequence_number (contiguous per packet_id, ISO/IEC 23008-1) of
-   * both source symbols, every block strictly between them holds at least one
-   * of the packets sent strictly between them, and K-closes can add at most
-   * one block per K of those packets on top of the D-closes elapsed time
-   * allows. Without it, only the D-close rate is known.
+   * source symbols filled it, so one interleave span can start several blocks
+   * (every large keyframe does). What bounds a forward jump is therefore
+   * packet evidence, not a block rate: SS_ID advances by one per FEC source
+   * packet (ISO/IEC 23008-1 C.5.2) and the MMTP packet_sequence_number by one
+   * per packet of the packet_id, so with both source symbols'
+   * packet_sequence_number a block start can move at most the packets sent
+   * between them plus the anchor's own offset into its block (< K). Without
+   * it, only the D-close rate is known.
+   *
+   * Vanished blocks are not enumerated here: their starts are unknown until a
+   * repair states them. The SS_IDs between two stated blocks become one
+   * repair-less span when the later block's repair arrives (placeIsoRepair).
    */
   #noteSbnSeen(
     sbn: number,
@@ -1531,7 +1562,7 @@ export class FECManager {
       ? packetSequenceNumber
       : undefined
     const anchorHere = (): void => {
-      if (psn !== undefined && (anchor === undefined || !this.#blockPrecedes(sbn, anchor.sbn, packetId))) {
+      if (psn !== undefined && (anchor === undefined || !this.#blockPrecedes(sbn, anchor.sbn))) {
         this.#sourceAnchors.set(streamKey, { sbn, psn, atMs: now })
       }
     }
@@ -1549,9 +1580,9 @@ export class FECManager {
       anchorHere()
       return
     }
-    const config = this.#resolveTrackConfig(packetId)
+    const config = this.#trackConfig(packetId)
     const window = this.#liveWindowBlocks(config)
-    if (!this.#blockPrecedes(previous.sbn, sbn, packetId)) {
+    if (!this.#blockPrecedes(previous.sbn, sbn)) {
       if (symbol === 'source' && window !== null &&
           this.#blocksBehind(sbn, previous.sbn, packetId) > window) {
         discontinuity()
@@ -1566,30 +1597,16 @@ export class FECManager {
       // A packet_sequence_number that did not advance says nothing (a
       // producer that does not maintain it); only then is the D-close rate
       // the whole bound.
-      if (this.#isIso(packetId) && psn !== undefined && anchor !== undefined &&
-          this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
-        // iso-ssbg1-v1: SS_ID advances by one per FEC source packet (C.5.2)
-        // and packet_sequence_number by one per packet of the packet_id, so a
-        // block start can move at most the packets sent since the anchor,
-        // plus the anchor's own offset into its block (< K).
+      if (psn !== undefined && anchor !== undefined &&
+          this.#blockPrecedes(anchor.sbn, sbn) && psn !== anchor.psn) {
+        // A block start can move at most the packets sent since the anchor,
+        // plus the anchor's own offset into its block (< K). Packets sent
+        // from the anchor packet to this one, serial arithmetic (RFC 1982):
+        // more than half the space means it went backwards.
         const sent = (psn - anchor.psn) >>> 0
         plausible =
           sent <= 0x7fff_ffff &&
           serial32Distance(anchor.sbn, sbn) <= sent + config.k
-      } else if (psn !== undefined && anchor !== undefined &&
-          this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
-        // Packets sent from the anchor packet to this one, serial arithmetic
-        // (RFC 1982): more than half the space means it went backwards.
-        const sent = (psn - anchor.psn) >>> 0
-        const between = this.#blocksBehind(anchor.sbn, sbn, packetId) - 1
-        const dCloses = window + Math.ceil((now - anchor.atMs) / config.interleaveDepthMs)
-        // Each K-close consumes K of the packets sent; with K unknown,
-        // every packet may have closed one.
-        const kCloses = config.k > 0 ? Math.ceil(sent / config.k) : sent
-        plausible =
-          sent <= 0x7fff_ffff &&
-          between <= sent - 1 &&
-          between <= dCloses + kCloses
       } else {
         plausible = missing <= window + Math.ceil((now - previous.atMs) / config.interleaveDepthMs)
       }
@@ -1601,53 +1618,25 @@ export class FECManager {
     }
     this.#highestSbn.set(streamKey, { sbn, atMs: now })
     anchorHere()
-    // iso-ssbg1-v1 cannot enumerate vanished blocks by key: their starts are
-    // unknown. The SS_IDs between two stated blocks become one repair-less
-    // span when the later block's repair arrives (placeIsoRepair).
-    if (this.#isIso(packetId)) return
-    if (missing <= 0 || window === null) return
-    let vanished = previous.sbn
-    for (let i = 0; i < missing; i++) {
-      vanished = this.#nextBlock(vanished, packetId)
-      this.#materializeBlock(
-        vanished,
-        packetId,
-        catalogTrackName,
-        this.#blocksBehind(vanished, sbn, packetId) <= window,
-      )
-    }
   }
 
   /*
-   * Block order for one stream (BLO-35597 iso:5). SS_ID is a 32-bit serial
-   * number (ISO/IEC 23008-1 C.5.2), so blocks are ordered by RFC 1982
-   * comparison of their first SS_ID (sbn * K mod 2^32). That is identical to
-   * comparing SBNs with < for every stream that has not wrapped SS_ID; only
-   * the order across the wrap changes. A block outside K-stride geometry has
-   * no SS_ID position, so it keeps the SBN order it always had.
+   * Block order for one stream (BLO-35597 iso:5). A block is keyed by its
+   * SS_Start and SS_ID is a 32-bit serial number (ISO/IEC 23008-1 C.5.2), so
+   * blocks are ordered by RFC 1982 comparison of their starts. Only configured
+   * streams hold blocks: every entry point refuses an unconfigured packetId.
    */
-  #blockPrecedes(a: number, b: number, packetId: number): boolean {
-    // iso-ssbg1-v1 keys a block by its SS_Start: plain RFC 1982 order.
-    if (this.#isIso(packetId)) return serial32Precedes(a, b)
-    const k = this.kForPacket(packetId)
-    return isKStrideBlock(a, k) && isKStrideBlock(b, k) ? kStrideBlockPrecedes(a, b, k) : a < b
+  #blockPrecedes(a: number, b: number): boolean {
+    return serial32Precedes(a, b)
   }
 
-  /** Blocks `a` lies behind `b` (0 when it does not precede it). */
+  /**
+   * Blocks `a` lies behind `b` (0 when it does not precede it). Blocks vary
+   * in length (K' = SSB_length <= K), so only a lower bound is known: the one
+   * metric the decoder and the worker retire by too.
+   */
   #blocksBehind(a: number, b: number, packetId: number): number {
-    // iso-ssbg1-v1 blocks vary in length, so only a lower bound is known: the
-    // one metric the decoder and the worker retire by too.
-    if (this.#isIso(packetId)) return isoBlocksBehindLowerBound(a, b, this.kForPacket(packetId))
-    const k = this.kForPacket(packetId)
-    return isKStrideBlock(a, k) && isKStrideBlock(b, k)
-      ? kStrideBlocksBehind(a, b, k)
-      : Math.max(0, b - a)
-  }
-
-  /** The block after `sbn`, stepping to block 0 where SS_ID wraps. */
-  #nextBlock(sbn: number, packetId: number): number {
-    const k = this.kForPacket(packetId)
-    return isKStrideBlock(sbn, k) ? kStrideNextBlock(sbn, k) : sbn + 1
+    return isoBlocksBehindLowerBound(a, b, this.#trackConfig(packetId).k)
   }
 
   #materializeBlock(
@@ -1659,7 +1648,9 @@ export class FECManager {
     const key = this.#blockKey(sbn, packetId, catalogTrackName)
     if (this.#blockResolutionFor(key) !== 'untracked') return
     this.#materializedBlocks.add(key)
-    this.#classifierFor(packetId, catalogTrackName).touch(sbn)
+    if (this.#hasCatalogTimingForPacket(packetId)) {
+      this.#classifierFor(packetId, catalogTrackName).touch(sbn)
+    }
     this.onBlockVanished?.(sbn, packetId, catalogTrackName)
     if (repairable) {
       this.noteBlockActivity(sbn, packetId, catalogTrackName, true)
@@ -1723,18 +1714,37 @@ export class FECManager {
     if (this.#lifecycleTrace.length > 64) this.#lifecycleTrace.splice(0, 32)
   }
 
-  #defaultTrackConfig(): ResolvedFECTrackConfig {
-    return {
-      k: this.#fecK,
-      symbolSize: this.#fecSymbolSize,
-      interleaveDepthMs: this.#fecInterleaveDepthMs,
-      fps: this.#fecFps,
-      timeoutMs: this.#fecTimeoutMs,
+  /**
+   * A configured packetId's track config. There is no manager-wide default
+   * (BLO-45953): an unconfigured packetId does no FEC work, so every caller
+   * here is reached only behind a configuration gate and this throw marks a
+   * broken invariant, never a packet-path outcome.
+   */
+  #trackConfig(packetId: number): ResolvedFECTrackConfig {
+    const config = this.#trackConfigs.get(packetId)
+    if (config === undefined) {
+      throw new Error(
+        `[FECManager] packetId=${packetId} was never configured; ` +
+          'configure the track from its catalog (configureTrack/setFecWorker/setFecDecoder) first',
+      )
     }
+    return config
   }
 
-  #resolveTrackConfig(packetId: number): ResolvedFECTrackConfig {
-    return this.#trackConfigs.get(packetId) ?? this.#defaultTrackConfig()
+  /**
+   * Whether this track has the catalog's elapsed-time FEC policy. A zero span
+   * is a deliberate no-deadline signal; it still leaves the wire geometry
+   * usable for in-band decode, but it cannot drive classification, repair
+   * fetches or layer adaptation.
+   */
+  static #hasCatalogTiming(config: Pick<ResolvedFECTrackConfig, 'interleaveDepthMs'>): boolean {
+    return Number.isSafeInteger(config.interleaveDepthMs) &&
+      config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
+  }
+
+  #hasCatalogTimingForPacket(packetId: number): boolean {
+    const config = this.#trackConfigs.get(packetId)
+    return config !== undefined && FECManager.#hasCatalogTiming(config)
   }
 
   #computeTimeout(config: {
@@ -1743,11 +1753,15 @@ export class FECManager {
     fps?: number
     timeoutMs?: number
   }): number {
-    if (config.timeoutMs && config.timeoutMs > 0) return config.timeoutMs
-    // Only a valid §5.1 ms interleave (>= MIN_INTERLEAVE_DEPTH_MS) drives the
-    // timeout. A sub-floor value is a raw frame count (no fps to convert with);
-    // fall back to the established #fecTimeoutMs rather than collapse to ~0.
-    if (config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+    if (typeof config.timeoutMs === 'number' && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0) {
+      return config.timeoutMs
+    }
+    // Only a valid non-negative integer §5.1 ms interleave drives the timeout;
+    // zero has no catalog deadline, so retain the local manager default.
+    if (
+      Number.isSafeInteger(config.interleaveDepthMs) &&
+      config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
+    ) {
       return Math.max(
         this.#fecTimeoutMs,
         computeFecDeliveryWindowMs({
@@ -1773,14 +1787,17 @@ export class FECManager {
    */
   #refreshDeliveryGapWindow(): void {
     let windowMs: number | undefined
-    const consider = (geometry: BlockClassifierGeometry | undefined): void => {
+    const consider = (geometry: BlockClassifierGeometry | undefined, packetId: number): void => {
+      if (!this.#hasCatalogTimingForPacket(packetId)) return
       if (geometry?.trackKind !== 'video' || geometry.mode !== 'classifying') return
       const { ticks, timescale } = geometry.keyframeInterval
       const ms = (ticks / timescale) * 1000
       if (Number.isFinite(ms) && ms > 0 && (windowMs === undefined || ms > windowMs)) windowMs = ms
     }
-    for (const geometry of this.#streamGeometries.values()) consider(geometry)
-    for (const config of this.#trackConfigs.values()) consider(config.geometry)
+    for (const [streamKey, geometry] of this.#streamGeometries) {
+      consider(geometry, this.#parseStreamKey(streamKey).packetId)
+    }
+    for (const [packetId, config] of this.#trackConfigs) consider(config.geometry, packetId)
     this.#deliveryGaps.setWindowMs(windowMs)
   }
 
@@ -1815,6 +1832,10 @@ export class FECManager {
     config: ResolvedFECTrackConfig,
     waitMs = this.#multicastWaitMs(config),
   ): number {
+    // No catalog span means no D-28 repair deadline. The local timeout still
+    // bounds cleanup, and returning the whole wait makes the derived grace
+    // zero (rather than exposing half of a local timeout as a repair budget).
+    if (!FECManager.#hasCatalogTiming(config)) return waitMs
     const halfFailBoundMs = Math.ceil(waitMs / 2)
     if (
       config.k > 0 &&
@@ -1836,10 +1857,12 @@ export class FECManager {
 
   /**
    * One block lifetime: the inactivity fail bound plus the D-28 repair grace,
-   * at the widest wait the catalog allows (#maxMulticastWaitMs). Everything
-   * derived from it (terminal retention, the release gate's hold ceiling, the
-   * duplicate ledgers, the owed-cleanup bound) is compared across time, so it
-   * must not follow the live measurement.
+   * at the widest wait the catalog allows (#maxMulticastWaitMs). For a track
+   * without a catalog span this is receiver-local cleanup time only; no repair
+   * grace is added. Everything derived from it (terminal retention, the
+   * release gate's hold ceiling, the duplicate ledgers, the owed-cleanup
+   * bound) is compared across time, so it must not follow the live
+   * measurement.
    */
   #blockLifetimeMs(config: ResolvedFECTrackConfig): number {
     const waitMs = this.#maxMulticastWaitMs(config)
@@ -1857,6 +1880,7 @@ export class FECManager {
   }
 
   #repairGraceMs(config: ResolvedFECTrackConfig, waitMs: number): number {
+    if (!FECManager.#hasCatalogTiming(config)) return 0
     return Math.max(1, waitMs - this.#repairDeadlineMs(config, waitMs))
   }
 
@@ -1977,7 +2001,15 @@ export class FECManager {
     config: FECManagerConfig,
     catalogTrackName?: string,
   ): ResolvedFECTrackConfig {
-    const previous = this.#trackConfigs.get(packetId) ?? this.#defaultTrackConfig()
+    const previousTrack = this.#trackConfigs.get(packetId)
+    const k = config.k ?? previousTrack?.k
+    if (k === undefined || !Number.isSafeInteger(k) || k <= 0) {
+      throw new Error(
+        `[FECManager] packetId=${packetId}: fec.k=${String(k)} must be a positive integer; ` +
+          'configure the track from its catalog',
+      )
+    }
+    const previous: Partial<ResolvedFECTrackConfig> = previousTrack ?? {}
     const streamScopedGeometry =
       catalogTrackName !== undefined && config.geometry !== undefined ? config.geometry : undefined
     if (streamScopedGeometry !== undefined) {
@@ -1988,6 +2020,14 @@ export class FECManager {
       config.k !== undefined ||
       config.interleaveDepthMs !== undefined ||
       config.fps !== undefined
+    if (
+      config.timeoutMs !== undefined &&
+      (!Number.isFinite(config.timeoutMs) || config.timeoutMs < 0)
+    ) {
+      throw new Error(
+        `[FECManager] packetId=${packetId}: timeoutMs=${config.timeoutMs} must be a finite non-negative cleanup budget`,
+      )
+    }
     if (config.blockProfile !== undefined) {
       parseFecBlockProfile(config.blockProfile, `packetId=${packetId} fec.blockProfile`)
     }
@@ -1995,38 +2035,35 @@ export class FECManager {
     if (blockProfile === undefined) {
       throw new Error(
         `[FECManager] packetId=${packetId}: fec.blockProfile is required ` +
-          '("k-padded-v1" or "iso-ssbg1-v1"); configure the track from its catalog',
+          '("iso-ssbg1-v1"); configure the track from its catalog',
       )
     }
-    if (blockProfile === 'iso-ssbg1-v1') {
-      // iso-ssbg1-v1 block location keeps what it holds for a horizon derived
-      // from this packet's catalog block span (#isoRetentionBlocks): without
-      // one the locator would grow for the life of the session. The span is
-      // this packet's own; the manager-wide default is never borrowed.
-      const ownInterleaveDepthMs =
-        config.interleaveDepthMs ?? this.#trackConfigs.get(packetId)?.interleaveDepthMs
-      if (
-        ownInterleaveDepthMs === undefined ||
-        !Number.isFinite(ownInterleaveDepthMs) ||
-        ownInterleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS
-      ) {
-        throw new Error(
-          `[FECManager] packetId=${packetId}: iso-ssbg1-v1 requires the catalog fec.interleaveDepthMs ` +
-            `(>= ${MIN_INTERLEAVE_DEPTH_MS} ms; got ${String(ownInterleaveDepthMs)}): it bounds how long ` +
-            'block location keeps stated blocks and held sources',
-        )
-      }
+    // iso-ssbg1-v1 block location keeps what it holds for a horizon derived
+    // from this packet's own catalog span, or from a fixed receiver-local
+    // count when the catalog has no elapsed-time span. The manager-wide span
+    // is never borrowed by a track whose catalog omitted it.
+    const ownInterleaveDepthMs =
+      config.interleaveDepthMs ?? previousTrack?.interleaveDepthMs ?? 0
+    if (
+      !Number.isSafeInteger(ownInterleaveDepthMs) ||
+      (ownInterleaveDepthMs !== 0 && ownInterleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS)
+    ) {
+      throw new Error(
+        `[FECManager] packetId=${packetId}: fec.interleaveDepthMs must be absent, 0, or ` +
+          `a finite value >= ${MIN_INTERLEAVE_DEPTH_MS} ms (got ${String(ownInterleaveDepthMs)})`,
+      )
     }
+    const hasCatalogTiming = FECManager.#hasCatalogTiming({ interleaveDepthMs: ownInterleaveDepthMs })
     const next: ResolvedFECTrackConfig = {
       blockProfile,
-      k: config.k ?? previous.k,
+      k,
       symbolSize:
         config.symbolSize != null && config.symbolSize > 0
           ? config.symbolSize
-          : previous.symbolSize,
-      interleaveDepthMs: config.interleaveDepthMs ?? previous.interleaveDepthMs,
-      fps: config.fps ?? previous.fps,
-      timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs),
+          : previousTrack?.symbolSize ?? 0,
+      interleaveDepthMs: ownInterleaveDepthMs,
+      fps: config.fps ?? previous.fps ?? this.#fecFps,
+      timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs ?? 0),
       ...((config.trackKind ?? previous.trackKind) === undefined
         ? {}
         : { trackKind: config.trackKind ?? previous.trackKind }),
@@ -2037,24 +2074,44 @@ export class FECManager {
         ? {}
         : { geometry: config.geometry ?? previous.geometry }),
     }
-    next.timeoutMs = this.#computeTimeout(next)
+    if (!hasCatalogTiming) {
+      // A missing/zero span has no catalog deadline. Keep an explicitly
+      // supplied local cleanup budget, preserve a prior local budget on a
+      // metadata-only update, and otherwise use the manager's fixed local
+      // default. A positive catalog track's timeout must never leak here.
+      next.timeoutMs = config.timeoutMs !== undefined && config.timeoutMs > 0
+        ? config.timeoutMs
+        : previousTrack !== undefined && previousTrack.interleaveDepthMs === 0
+          ? previousTrack.timeoutMs
+          : LOCAL_FEC_TIMEOUT_MS
+    } else {
+      next.timeoutMs = this.#computeTimeout(next)
+    }
     if (this.#multicastSymbolDelivery === 'ordered-relay') {
       // Error on bad init: an ordered-relay stream settles its blocks by the
       // decoder's interleave horizon, which this geometry must define.
       this.#orderedHorizonBlocksFor(packetId, next)
     }
-    if (
-      previous.blockProfile !== undefined &&
-      (previous.blockProfile !== blockProfile || (blockProfile === 'iso-ssbg1-v1' && previous.k !== next.k))
-    ) {
-      // A different profile, or a different maximum K under iso-ssbg1-v1, is
-      // a different block geometry: the stream's blocks must not be read
-      // under the old one's rules.
+    const timingPolicyChanged =
+      FECManager.#hasCatalogTiming({ interleaveDepthMs: previous.interleaveDepthMs ?? 0 }) !== hasCatalogTiming
+    if (timingPolicyChanged && !hasCatalogTiming) {
+      // A D-28 timer belongs to the positive catalog timing policy. Once a
+      // track becomes local-only, cancel it instead of merely relying on the
+      // request callback's policy guard; the local cleanup timer is the only
+      // deadline allowed to remain armed for the block.
+      for (const key of [...this.#repairDeadlines.keys()]) {
+        if (this.#belongsToPacket(key, packetId)) this.#clearRepairDeadline(key)
+      }
+    }
+    if (previous.blockProfile !== undefined && previous.k !== next.k) {
+      // A different maximum K is a different block geometry: the stream's
+      // blocks must not be read under the old one's rules.
       this.#dropIsoLocators(packetId)
     }
     this.#trackConfigs.set(packetId, next)
     this.#refreshDeliveryGapWindow()
     let policyChanged =
+      timingPolicyChanged ||
       (config.geometry !== undefined &&
         JSON.stringify(config.geometry) !== JSON.stringify(previous.geometry)) ||
       (config.trackKind !== undefined && config.trackKind !== previous.trackKind)
@@ -2077,8 +2134,12 @@ export class FECManager {
         if (!this.#belongsToPacket(key, packetId)) continue
         const stream = this.#parseStreamKey(key)
         const geometry = this.#geometryFor(stream.packetId, stream.catalogTrackName)
-        if (JSON.stringify(geometry) === JSON.stringify(classifier.geometry)) continue
+        if (
+          hasCatalogTiming &&
+          JSON.stringify(geometry) === JSON.stringify(classifier.geometry)
+        ) continue
         this.#classifiers.delete(key)
+        if (!hasCatalogTiming) continue
         // Blocks still unresolved lose the evidence their class rested on:
         // under the fresh classifier they read `unknown`. Say so, so a queued
         // or running P2 repair for a former delta block is promoted to P0
@@ -2089,14 +2150,6 @@ export class FECManager {
     return next
   }
 
-  #normalizeSymbolData(packetId: number, data: Uint8Array): Uint8Array {
-    const symbolSize = this.symbolSizeForPacket(packetId)
-    if (symbolSize <= 0 || data.byteLength === symbolSize) return data
-    const normalized = new Uint8Array(symbolSize)
-    normalized.set(data.subarray(0, symbolSize))
-    return normalized
-  }
-
   #blockKeysFor(sbn: number, packetId?: number, catalogTrackName?: string): string[] {
     if (packetId != null && catalogTrackName !== undefined) {
       return [this.#blockKey(sbn, packetId, catalogTrackName)]
@@ -2169,7 +2222,7 @@ export class FECManager {
           ...stats,
           packetId,
           blocksComplete: trackTotal,
-          k: this.#resolveTrackConfig(packetId).k,
+          k: this.#trackConfigs.get(packetId)?.k,
           recoveryRate: trackAffected > 0
             ? (stats.blocksRecovered / trackAffected) * 100
             : 100,
@@ -2183,7 +2236,7 @@ export class FECManager {
         (block) => block.multicastSymbols > 0 && block.moqSymbols > 0,
       ).length,
       recentBlockPathCounts: Array.from(this.#blockPathCounts.values()).slice(-24),
-      k: this.#fecK,
+      k: this.#streamK,
       // True recovery rate: of blocks that HAD loss, how many were recovered?
       recoveryRate: affected > 0 ? (s.blocksRecovered / affected) * 100 : 100,
       packetLossRate: total > 0 ? (affected / total) * 100 : 0,
@@ -2198,7 +2251,6 @@ export class FECManager {
           },
           blocks: stats.blocks.map((block) => ({ ...block })),
           decoder: stats.decoder ? { ...stats.decoder } : undefined,
-          altaFailedDetails: stats.altaFailedDetails?.map((detail) => ({ ...detail })),
           packetId,
         })),
       repairSymbolSizeMismatches: this.#repairSymbolSizeMismatchCount,
@@ -2322,6 +2374,7 @@ export class FECManager {
     resetMap(this.#blockSourceEsis)
     resetMap(this.#blockAuthoredLengths)
     resetMap(this.#blockRepairRsIds)
+    resetMap(this.#blockRsbLengths)
     resetMap(this.#blockPathCounts)
     resetMap(this.#blockAnchorsMs)
     resetMap(this.#blockCatalogTrackNames)
@@ -2447,6 +2500,7 @@ export class FECManager {
     dropMap(this.#blockSourceEsis)
     dropMap(this.#blockAuthoredLengths)
     dropMap(this.#blockRepairRsIds)
+    dropMap(this.#blockRsbLengths)
     dropMap(this.#blockPathCounts)
     dropMap(this.#blockAnchorsMs)
     dropMap(this.#blockCatalogTrackNames)
@@ -2521,7 +2575,12 @@ export class FECManager {
     }
   }
 
-  /** Record a transport symbol and reject later duplicates of the same packetId/SBN/ESI. */
+  /**
+   * Record a transport symbol and reject later duplicates of the same
+   * packetId/SBN/ESI. `sbn` is the block's SS_Start. A packetId with no
+   * configured block profile has no block geometry: its symbol is refused
+   * (false) and no block state is created for it.
+   */
   feedSymbolFromSource(
     packetId: number,
     sbn: number,
@@ -2530,6 +2589,7 @@ export class FECManager {
     source: FecSymbolSource,
     catalogTrackName?: string,
   ): boolean {
+    if (!this.#hasBlockProfile(packetId)) return false
     const blockKey = this.#blockKey(sbn, packetId, catalogTrackName)
     const streamKey = this.#streamKey(packetId, catalogTrackName)
     if (source === 'multicast' && this.#multicastSymbolDelivery === 'ordered-relay') {
@@ -2537,12 +2597,10 @@ export class FECManager {
       // one refused below as a join partial or a duplicate.
       this.#advanceOrderedFrontier(streamKey, sbn, packetId, catalogTrackName)
     }
-    const k = this.kForPacket(packetId)
-    // iso-ssbg1-v1 repair ESIs start at the block's own SSB_length (K'), which
-    // its locator states; k-padded-v1 repair ESIs start at K.
-    const sourceSymbols = this.#isIso(packetId)
-      ? this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? k
-      : k
+    // Repair ESIs start at the block's own SSB_length (K'), which its locator
+    // states once a repair placed it; before that, K is the only bound.
+    const sourceSymbols =
+      this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? this.#trackConfig(packetId).k
     const isSourceSymbol = esi >= 0 && esi < sourceSymbols
     const isStartupPartial = this.#startupPartialBlocks.has(blockKey)
     const isReadyMulticastRepair =
@@ -2711,7 +2769,7 @@ export class FECManager {
     for (const [key] of this.#activeBlocks) {
       const { packetId, sbn } = this.#parseBlockKey(key);
       const count = this.#blockSourceCounts.get(key) ?? 0;
-      const k = this.#blockAuthoredLengths.get(key) ?? this.kForPacket(packetId);
+      const k = this.#blockAuthoredLengths.get(key) ?? this.#trackConfig(packetId).k;
       blocks.push({ sbn, packetId, state: 'collecting', sourceCount: count, k, progress: k > 0 ? Math.min(count / k, 1) : 0 });
     }
     // Recently completed blocks (last 16)
@@ -2719,7 +2777,7 @@ export class FECManager {
     for (const key of completed) {
       const { packetId, sbn } = this.#parseBlockKey(key);
       if (!this.#activeBlocks.has(key)) {
-        const k = this.kForPacket(packetId);
+        const k = this.#trackConfig(packetId).k;
         blocks.push({ sbn, packetId, state: 'complete', sourceCount: k, k, progress: 1 });
       }
     }
@@ -2732,14 +2790,16 @@ export class FECManager {
     return this.#fecDecoders.values().next().value?.client ?? null
   }
 
-  get k(): number { return this.#fecK }
-  kForPacket(packetId: number): number { return this.#resolveTrackConfig(packetId).k }
+  /** A configured packetId's K; undefined for an unconfigured one (no FEC work). */
+  kForPacket(packetId: number): number | undefined { return this.#trackConfigs.get(packetId)?.k }
   /** FEC symbol size in bytes. */
   get symbolSize(): number { return this.#fecSymbolSize }
-  symbolSizeForPacket(packetId: number): number { return this.#resolveTrackConfig(packetId).symbolSize }
+  symbolSizeForPacket(packetId: number): number | undefined { return this.#trackConfigs.get(packetId)?.symbolSize }
   /** FEC block span in milliseconds (0 = no interleaving). */
   get interleaveDepthMs(): number { return this.#fecInterleaveDepthMs }
-  interleaveDepthMsForPacket(packetId: number): number { return this.#resolveTrackConfig(packetId).interleaveDepthMs }
+  interleaveDepthMsForPacket(packetId: number): number | undefined {
+    return this.#trackConfigs.get(packetId)?.interleaveDepthMs
+  }
   /**
    * Record one multicast MMTP packet arrival (every packet of the leg, FEC
    * symbol or not) for the delivery-gap measurement. `packetSequenceNumber`
@@ -2755,8 +2815,9 @@ export class FECManager {
    * Resolved per-track multicast late-symbol wait in milliseconds: the span
    * plus the larger of the catalog tolerance and the measured delivery gap.
    */
-  timeoutMsForPacket(packetId: number): number {
-    return this.#multicastWaitMs(this.#resolveTrackConfig(packetId))
+  timeoutMsForPacket(packetId: number): number | undefined {
+    const config = this.#trackConfigs.get(packetId)
+    return config === undefined ? undefined : this.#multicastWaitMs(config)
   }
   /**
    * Largest multicast delivery gap measured over the current window (ms), and
@@ -2768,6 +2829,40 @@ export class FECManager {
       windowMs: this.#deliveryGaps.windowMs,
     }
   }
+  /**
+   * An open block's accepted sources, distinct repair RS_IDs, authored K'
+   * (SSB_length) and RSB_length (each undefined until a repair stated it).
+   * Undefined for a block that is not open.
+   */
+  blockSymbolCounts(
+    sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): {
+    readonly sources: number
+    readonly repairs: number
+    readonly authoredLength: number | undefined
+    readonly repairGroupLength: number | undefined
+  } | undefined {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName)
+    if (!this.#activeBlocks.has(key)) return undefined
+    return {
+      sources: this.#blockSourceCounts.get(key) ?? 0,
+      repairs: this.#blockRepairRsIds.get(key)?.size ?? 0,
+      authoredLength: this.#blockAuthoredLengths.get(key),
+      repairGroupLength: this.#blockRsbLengths.get(key),
+    }
+  }
+  /**
+   * Record a block's RSB_length from one of its repair symbols (the router
+   * parses it from the Repair FEC Payload ID). The largest stated value wins.
+   */
+  noteRepairGroupLength(sbn: number, packetId: number, rsbLength: number, catalogTrackName?: string): void {
+    if (!Number.isSafeInteger(rsbLength) || rsbLength <= 0) return
+    const key = this.#blockKey(sbn, packetId, catalogTrackName)
+    if (!this.#activeBlocks.has(key)) return
+    if ((this.#blockRsbLengths.get(key) ?? 0) < rsbLength) this.#blockRsbLengths.set(key, rsbLength)
+  }
   /**
    * Receiver-local time of a block's first accepted symbol, or undefined for
    * a block no symbol reached (one materialized because a later SBN arrived).
@@ -2817,28 +2912,32 @@ export class FECManager {
     this.#applyBlockDeadline(key, sbn, packetId, catalogTrackName)
   }
   /** Resolved per-track D-28 repair request deadline in milliseconds. */
-  repairDeadlineMsForPacket(packetId: number): number {
-    return this.#repairDeadlineMs(this.#resolveTrackConfig(packetId))
+  repairDeadlineMsForPacket(packetId: number): number | undefined {
+    const config = this.#trackConfigs.get(packetId)
+    return config === undefined ? undefined : this.#repairDeadlineMs(config)
   }
   /**
    * One block lifetime: the longest a block stays open after its last symbol
    * (inactivity fail bound plus D-28 repair grace).
    */
-  blockLifetimeMsForPacket(packetId: number): number {
-    return this.#blockLifetimeMs(this.#resolveTrackConfig(packetId))
+  blockLifetimeMsForPacket(packetId: number): number | undefined {
+    const config = this.#trackConfigs.get(packetId)
+    return config === undefined ? undefined : this.#blockLifetimeMs(config)
   }
   /**
    * How long a terminal (clean, recovered or failed) block stays authoritative,
    * for late symbols and for the in-order release gate. It is also the gate's
    * hold ceiling (MmtpRouter's holdLimitMs): a retired block reads back as
    * untracked, which the gate counts as lost, so no frame may still be waiting
-   * on a block that can retire. The window is one interleave depth for a gap's
-   * last block to finish arriving, one block lifetime to fail it, and one more
-   * for an owed Worker cleanup that can keep a failing block pending. Every
-   * term comes from the track's catalog geometry; there is no separate cap.
+   * on a block that can retire. With a positive catalog span the window is one
+   * interleave depth for a gap's last block to finish arriving, one block
+   * lifetime to fail it, and one more for an owed Worker cleanup. With an
+   * absent/zero span it is a receiver-local cleanup bound only; it creates no
+   * catalog FEC deadline.
    */
-  terminalRetentionMsForPacket(packetId: number): number {
-    const config = this.#resolveTrackConfig(packetId)
+  terminalRetentionMsForPacket(packetId: number): number | undefined {
+    const config = this.#trackConfigs.get(packetId)
+    if (config === undefined) return undefined
     return config.interleaveDepthMs + 2 * this.#blockLifetimeMs(config)
   }
   /** Remaining fetch budget for a specific repair-requested block. */
@@ -2846,14 +2945,15 @@ export class FECManager {
     sbn: number,
     packetId: number,
     catalogTrackName?: string,
-  ): number {
+  ): number | undefined {
     const deadlineMs = this.#activeBlockDeadlinesMs.get(
       this.#blockKey(sbn, packetId, catalogTrackName),
     )
     if (deadlineMs !== undefined) {
       return Math.max(1, Math.ceil(deadlineMs - performance.now()))
     }
-    const trackConfig = this.#resolveTrackConfig(packetId)
+    const trackConfig = this.#trackConfigs.get(packetId)
+    if (trackConfig === undefined) return undefined
     return Math.max(1, trackConfig.timeoutMs - this.#repairDeadlineMs(trackConfig))
   }
 
@@ -2867,15 +2967,20 @@ export class FECManager {
     return this.#trackConfigs.get(packetId)?.blockProfile
   }
 
-  #isIso(packetId: number): boolean {
-    return this.#trackConfigs.get(packetId)?.blockProfile === 'iso-ssbg1-v1'
+  /**
+   * Whether a packetId has a configured block geometry. iso-ssbg1-v1 is the
+   * only profile, so every configured track has it; a packetId never
+   * configured (or released) has none and gets no FEC block tracking.
+   */
+  #hasBlockProfile(packetId: number): boolean {
+    return this.#trackConfigs.get(packetId)?.blockProfile !== undefined
   }
 
   #isoLocatorFor(packetId: number, catalogTrackName?: string): IsoBlockLocator<IsoHeldSource> {
     const streamKey = this.#streamKey(packetId, catalogTrackName)
     let locator = this.#isoLocators.get(streamKey)
     if (!locator) {
-      locator = new IsoBlockLocator<IsoHeldSource>(this.kForPacket(packetId), this.#isoRetentionBlocks(packetId))
+      locator = new IsoBlockLocator<IsoHeldSource>(this.#trackConfig(packetId).k, this.#isoRetentionBlocks(packetId))
       this.#isoLocators.set(streamKey, locator)
     }
     return locator
@@ -2909,12 +3014,14 @@ export class FECManager {
    */
   #isoRetentionBlocks(packetId: number): number {
     const config = this.#trackConfigs.get(packetId)
-    if (config?.blockProfile !== 'iso-ssbg1-v1' || !(config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS)) {
+    if (config?.blockProfile === undefined) {
       throw new Error(
-        `[FECManager] packetId=${packetId} has no iso-ssbg1-v1 block span to derive block-location retention from`,
+        `[FECManager] packetId=${packetId} has no configured iso-ssbg1-v1 block profile`,
       )
     }
-    const blocks = Math.ceil(this.terminalRetentionMsForPacket(packetId) / config.interleaveDepthMs) + 1
+    if (!FECManager.#hasCatalogTiming(config)) return LOCAL_FEC_RETENTION_BLOCKS
+    const terminalRetentionMs = config.interleaveDepthMs + 2 * this.#blockLifetimeMs(config)
+    const blocks = Math.ceil(terminalRetentionMs / config.interleaveDepthMs) + 1
     if (!Number.isSafeInteger(blocks) || blocks <= 0) {
       throw new Error(`[FECManager] packetId=${packetId} iso-ssbg1-v1 retention of ${blocks} blocks is not derivable`)
     }
@@ -2923,7 +3030,8 @@ export class FECManager {
 
   /** Whether an iso-ssbg1-v1 protected packet fits one ssbg_mode1 symbol (len + 2 <= T). */
   isoSourceFits(packetId: number, packetLength: number): boolean {
-    return ssbg1FitsSymbol(packetLength, this.symbolSizeForPacket(packetId))
+    const symbolSize = this.#trackConfigs.get(packetId)?.symbolSize
+    return symbolSize !== undefined && ssbg1FitsSymbol(packetLength, symbolSize)
   }
 
   /**
@@ -3010,11 +3118,11 @@ export class FECManager {
    * that could hold them is pending or not yet stated by a repair, else the
    * starts of the blocks that failed or vanished.
    *
-   * `untracked` reads exactly as in the k-padded-v1 release gate
-   * (MmtpRouter #createFecReleaseGate): a block holding either released
-   * frame's SS_ID (`fromSsId` or `toSsId`) delivered that frame, so untracked
-   * there means it resolved and retired; a block starting after the stream's frontier (`highestSbn`,
-   * an SS_Start here) may still be heard from; a block at or behind the
+   * `untracked` reads as the release gate reads it (MmtpRouter
+   * #createFecReleaseGate): a block holding either released frame's SS_ID
+   * (`fromSsId` or `toSsId`) delivered that frame, so untracked there means it
+   * resolved and retired; a block starting after the stream's frontier
+   * (`highestSbn`, an SS_Start) may still be heard from; a block at or behind the
    * frontier that no symbol of this manager ever reached vanished, and its
    * media is lost.
    */
@@ -3107,6 +3215,10 @@ export class FECManager {
     packetId: number,
     catalogTrackName?: string,
   ): { mode: ClassifierMode; reason: ClassifierReason | null } {
+    // A no-span stream has no catalog timing with which to classify blocks.
+    // Keep the existing fail-closed shape for callers that still query this
+    // accessor, while the span sentinel tells them this mode is local-only.
+    if (!this.#hasCatalogTimingForPacket(packetId)) return { mode: 'all-protected', reason: null }
     const classifier = this.#classifierFor(packetId, catalogTrackName)
     return { mode: classifier.mode, reason: classifier.reason }
   }
@@ -3117,11 +3229,13 @@ export class FECManager {
    * it does not. A stream with no classifier yet has shown nothing against it.
    */
   mpuBoundsRapsFor(packetId: number, catalogTrackName?: string): boolean {
+    if (!this.#hasCatalogTimingForPacket(packetId)) return false
     return this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.mpuBoundsRaps ?? true
   }
 
   /** A block's class now, or frozen at its resolution. */
   blockClassFor(sbn: number, packetId: number, catalogTrackName?: string): BlockClass {
+    if (!this.#hasCatalogTimingForPacket(packetId)) return 'unknown'
     const frozen = this.#resolvedBlockClasses.get(this.#blockKey(sbn, packetId, catalogTrackName))
     if (frozen !== undefined) return frozen
     return this.#peekClass(sbn, packetId, catalogTrackName)
@@ -3152,7 +3266,7 @@ export class FECManager {
     presentationTime: bigint,
     mediaTimescale: number,
   ): void {
-    if (!this.#trackConfigs.has(packetId)) return
+    if (!this.#trackConfigs.has(packetId) || !this.#hasCatalogTimingForPacket(packetId)) return
     this.#applyClassifierChanges(
       packetId,
       catalogTrackName,
@@ -3170,36 +3284,56 @@ export class FECManager {
 
   /** Configure FEC parameters. */
   configure(config: FECManagerConfig): void {
-    if (config.k != null) this.#fecK = config.k
+    // Validate timing before changing any manager-global field. A malformed
+    // value must not leave a partially applied configuration (especially an
+    // infinite local cleanup budget, which would never expire).
+    if (
+      config.interleaveDepthMs != null &&
+      (!Number.isSafeInteger(config.interleaveDepthMs) || config.interleaveDepthMs < 0)
+    ) {
+      throw new Error(
+        `[FECManager] interleaveDepthMs=${config.interleaveDepthMs} must be a non-negative safe integer in milliseconds`,
+      )
+    }
+    if (
+      config.timeoutMs != null &&
+      (!Number.isFinite(config.timeoutMs) || config.timeoutMs < 0)
+    ) {
+      throw new Error(
+        `[FECManager] timeoutMs=${config.timeoutMs} must be a finite non-negative cleanup budget`,
+      )
+    }
+    if (config.k != null && (!Number.isSafeInteger(config.k) || config.k <= 0)) {
+      throw new Error(`[FECManager] k=${config.k} must be a positive integer`)
+    }
+    if (config.k != null) this.#streamK = config.k
     if (config.symbolSize != null && config.symbolSize > 0) this.#fecSymbolSize = config.symbolSize
     if (config.interleaveDepthMs != null) this.#fecInterleaveDepthMs = config.interleaveDepthMs
     if (config.fps != null && Number.isFinite(config.fps) && config.fps > 0) {
       this.#fecFps = config.fps
     }
-    // interleaveDepthMs is in milliseconds per spec §5.1.
-    // Valid range: 33ms (interactive/gaming) to 10000ms (broadcast ATSC 3.0).
-    // Warn if value looks like frame count instead of ms (common misconfiguration).
-    if (config.interleaveDepthMs != null && config.interleaveDepthMs > 0 && config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) {
-      console.warn(`[FECManager] interleaveDepthMs=${config.interleaveDepthMs} looks like frame count, not milliseconds (§5.1 requires ms). Expected range: ${MIN_INTERLEAVE_DEPTH_MS}-10000ms.`)
-    }
     if (config.timeoutMs != null && config.timeoutMs > 0) {
       this.#fecTimeoutMs = config.timeoutMs
+    } else if (config.interleaveDepthMs === 0) {
+      // An explicit zero span removes the catalog deadline. Reset the global
+      // budget to the bounded receiver-local fallback unless this call also
+      // supplied an explicit positive local timeout above.
+      this.#fecTimeoutMs = LOCAL_FEC_TIMEOUT_MS
     } else if (
       config.interleaveDepthMs != null &&
+      Number.isSafeInteger(config.interleaveDepthMs) &&
       config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
     ) {
-      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
-        interleaveDepthMs: config.interleaveDepthMs,
-        sourceSymbols: this.#fecK,
-        symbolSize: this.#fecSymbolSize,
-        mediaUnitsPerSecond: config.fps,
-      })
+      // The stream has no K (a K is per track, BLO-45953); none feeds the window.
+      this.#fecTimeoutMs = fecSpanDeliveryWindowMs(config.interleaveDepthMs)
     }
     // A shared multicast parser receives every packetId. Keep existing track
     // deadlines at least as wide as the selected video delivery envelope so a
     // short audio interleave cannot expire during browser/AMT scheduling gaps.
     for (const [packetId, track] of this.#trackConfigs) {
-      if (track.timeoutMs < this.#fecTimeoutMs) {
+      // A track without a positive catalog span owns only its receiver-local
+      // cleanup budget; never widen it with another track's catalog timing.
+      if (FECManager.#hasCatalogTiming(track) && track.timeoutMs < this.#fecTimeoutMs) {
         this.#trackConfigs.set(packetId, { ...track, timeoutMs: this.#fecTimeoutMs })
       }
     }
@@ -3277,7 +3411,7 @@ export class FECManager {
       )
     }
     if (config) this.#upsertTrackConfig(packetId, config, catalogTrackName)
-    const workerK = this.#resolveTrackConfig(packetId).k
+    const workerK = this.#trackConfig(packetId).k
     this.#workerClients.set(streamKey, client)
     this.#releasedWorkerClients.delete(client)
 
@@ -3289,7 +3423,8 @@ export class FECManager {
         // ESI-less event as recovered would report healthy FEC while dropping
         // the media. Enforce the Worker contract before any recovery metric.
         // The Worker names the recovered block's authored SSB_length; ESIs
-        // SSB_length..K-1 are encoder padding and are never emitted.
+        // at or past it are not source symbols of the block and are never
+        // emitted.
         if (
           !Number.isInteger(meta.ssbLength) ||
           meta.ssbLength! <= 0 ||
@@ -3520,7 +3655,7 @@ export class FECManager {
           return
         }
         this.#settleOwedCleanup(key, 'cleanup-ack-timeout')
-      }, Math.ceil(this.#liveBlockLifetimeMs(this.#resolveTrackConfig(packetId)))),
+      }, Math.ceil(this.#liveBlockLifetimeMs(this.#trackConfig(packetId)))),
     }
     this.#pendingWorkerCleanupBounds.set(key, bound)
   }
@@ -3568,18 +3703,20 @@ export class FECManager {
     if (this.#fpsDetected || fps <= 0) return
     this.#fpsDetected = true
     this.#fecFps = fps
-    // Only a valid §5.1 ms interleave refines the timeout; a sub-floor value is
-    // a raw frame count and would collapse it (see MIN_INTERLEAVE_DEPTH_MS).
-    if (this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
-      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
-        interleaveDepthMs: this.#fecInterleaveDepthMs,
-        sourceSymbols: this.#fecK,
-        symbolSize: this.#fecSymbolSize,
-        mediaUnitsPerSecond: fps,
-      })
+    // Only a valid non-negative integer §5.1 ms interleave refines the
+    // timeout; zero is the no-deadline sentinel.
+    if (
+      Number.isSafeInteger(this.#fecInterleaveDepthMs) &&
+      this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
+    ) {
+      this.#fecTimeoutMs = fecSpanDeliveryWindowMs(this.#fecInterleaveDepthMs)
     }
     for (const [packetId, config] of this.#trackConfigs) {
-      if (config.fps !== undefined || config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) continue
+      if (
+        config.fps !== undefined ||
+        !Number.isSafeInteger(config.interleaveDepthMs) ||
+        config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS
+      ) continue
       this.#trackConfigs.set(packetId, {
         ...config,
         fps,
@@ -3614,36 +3751,31 @@ export class FECManager {
     packetId: number,
     ssId: number,
     symbolData: Uint8Array,
-    alta?: { auth: Uint8Array; payloadEnd: number },
     catalogTrackName?: string,
   ): Uint8Array | null {
     this.#fecStats.sourcePackets++
     this.#statsForPacket(packetId).sourcePackets++
-    let sbn: number
-    let fecData: Uint8Array
-    if (this.#isIso(packetId)) {
-      // iso-ssbg1-v1: the decoder builds the ssbg_mode1 symbol from the exact
-      // protected packet, so the packet travels unpadded. Its block must
-      // already be stated (MmtpRouter holds a source until a repair places it).
-      const locator = this.#isoLocatorFor(packetId, catalogTrackName)
-      const located = locator.locate(ssId)
-      if (located === null) {
-        throw new Error(
-          `[FECManager] iso-ssbg1-v1 source SS_ID=${ssId} (packetId=${packetId}) has no stated block; ` +
-            'hold it until a repair places it (placeIsoRepair)',
-        )
-      }
-      locator.observe(ssId)
-      if (!ssbg1FitsSymbol(symbolData.byteLength, this.symbolSizeForPacket(packetId))) {
-        this.#isoSourceOversizeCount++
-        return null
-      }
-      sbn = located.block.start
-      fecData = symbolData
-    } else {
-      fecData = this.#normalizeSymbolData(packetId, symbolData)
-      sbn = Math.floor(ssId / this.kForPacket(packetId))
+    // A packetId with no configured block profile has no block geometry and
+    // no decoder (setFecDecoder/setFecWorker configure the track): nothing to
+    // decode.
+    if (!this.#hasBlockProfile(packetId)) return null
+    // The decoder builds the ssbg_mode1 symbol from the exact protected
+    // packet, so the packet travels unpadded. Its block must already be
+    // stated (MmtpRouter holds a source until a repair places it).
+    const locator = this.#isoLocatorFor(packetId, catalogTrackName)
+    const located = locator.locate(ssId)
+    if (located === null) {
+      throw new Error(
+        `[FECManager] iso-ssbg1-v1 source SS_ID=${ssId} (packetId=${packetId}) has no stated block; ` +
+          'hold it until a repair places it (placeIsoRepair)',
+      )
     }
+    locator.observe(ssId)
+    if (!ssbg1FitsSymbol(symbolData.byteLength, this.#trackConfig(packetId).symbolSize)) {
+      this.#isoSourceOversizeCount++
+      return null
+    }
+    const sbn = located.block.start
     const blockKey = this.#blockKey(sbn, packetId, catalogTrackName)
     const syncBlockOwner = this.#syncDecoderBlockOwners.get(blockKey)
 
@@ -3651,36 +3783,19 @@ export class FECManager {
     const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName)
     if (workerClient && !syncBlockOwner) {
       if (!this.#claimDecoderBlock(workerClient, sbn, catalogTrackName)) return null
-      // Transfer an ArrayBuffer nothing else references. A symbol this manager
-      // just zero-padded to T already is one; copying it again cost a second
-      // T-byte allocation per short packet (BLO-36599). A caller's buffer may
-      // be a view into a larger packet, so it is copied first (T-03-06).
-      const buf = fecData !== symbolData
-        ? fecData.buffer as ArrayBuffer
-        : fecData.buffer.slice(
-            fecData.byteOffset,
-            fecData.byteOffset + fecData.byteLength,
-          ) as ArrayBuffer
-      // Pass the flat SS_ID through to the worker. The WASM decoder derives
-      // SBN/ESI internally per ISO 23008-1 §C.5.2; the WASM add_source
+      // Transfer an ArrayBuffer nothing else references. The source travels
+      // unpadded, and a caller's buffer may be a view into a larger packet,
+      // so it is copied first (T-03-06).
+      const buf = symbolData.buffer.slice(
+        symbolData.byteOffset,
+        symbolData.byteOffset + symbolData.byteLength,
+      ) as ArrayBuffer
+      // Pass the flat SS_ID through to the worker. The WASM decoder places
+      // the source in its block by SS_ID (ISO 23008-1 §C.5.2); the WASM add_source
       // signature is (ss_id, data, timestamp) — pre-computing sbn/esi on this
       // side produces wrong WASM argument alignment and silently breaks
       // block assembly.
-      if (alta) {
-        // Copy auth into a fresh ArrayBuffer to transfer zero-copy. The
-        // underlying buffer of the parsed trailer view belongs to the wire
-        // packet, which may be transferred separately or reused.
-        const authBuf = alta.auth.buffer.slice(
-          alta.auth.byteOffset,
-          alta.auth.byteOffset + alta.auth.byteLength,
-        ) as ArrayBuffer
-        workerClient.feedSource(ssId, buf, performance.now(), {
-          auth: authBuf,
-          payloadEnd: alta.payloadEnd,
-        })
-      } else {
-        workerClient.feedSource(ssId, buf, performance.now())
-      }
+      workerClient.feedSource(ssId, buf, performance.now())
       return null
     }
 
@@ -3693,7 +3808,7 @@ export class FECManager {
 
     let recovered: Uint8Array | null = null
     try {
-      recovered = client.add_source(ssId, fecData, performance.now())
+      recovered = client.add_source(ssId, symbolData, performance.now())
     } catch {
       // WASM RefCell panic — decoder instance shared with multicast repair path
     }
@@ -3722,7 +3837,10 @@ export class FECManager {
   ): Uint8Array | null {
     this.#fecStats.repairPackets++
     this.#statsForPacket(packetId).repairPackets++
-    const symbolSize = this.symbolSizeForPacket(packetId)
+    // A packetId with no configured block profile has no block geometry: its
+    // repair names no block this manager can track or decode.
+    if (!this.#hasBlockProfile(packetId)) return null
+    const symbolSize = this.#trackConfig(packetId).symbolSize
     if (symbolSize > 0 && repairData.byteLength !== symbolSize) {
       this.#repairSymbolSizeMismatchCount++
       if (this.#repairSymbolSizeMismatchCount <= 5 || this.#repairSymbolSizeMismatchCount % 100 === 0) {
@@ -3734,25 +3852,17 @@ export class FECManager {
     }
     const fecData = repairData
 
-    // SSB_length is the authored source-symbol count in this block, not the
-    // decoder's configured block width. Short authored blocks are padded to
-    // the configured K, so all internal keys and lifecycle coordinates use K.
-    // Keep the wire tuple unchanged when calling the decoder below.
-    const k = this.kForPacket(packetId)
-    let sbn: number
-    if (this.#isIso(packetId)) {
-      // iso-ssbg1-v1 (C.5.3): the block is [SS_Start, SS_Start + SSB_length),
-      // K' = SSB_length, and the catalog K is only its maximum. MmtpRouter
-      // placed the block before feeding its repair (placeIsoRepair).
-      const block = this.#isoLocatorFor(packetId, catalogTrackName).blockAt(ssStart)
-      if (ssbLength <= 0 || ssbLength > k || block === undefined || block.span || block.length !== ssbLength) {
-        return null
-      }
-      sbn = ssStart
-    } else {
-      if (ssbLength <= 0 || ssbLength > k || ssStart % k !== 0) return null
-      sbn = Math.floor(ssStart / k)
+    // ISO/IEC 23008-1 C.5.3: the block is [SS_Start, SS_Start + SSB_length),
+    // K' = SSB_length, and the catalog K is only its maximum. The block is
+    // keyed by its SS_Start. MmtpRouter placed the block before feeding its
+    // repair (placeIsoRepair). Keep the wire tuple unchanged when calling the
+    // decoder below.
+    const k = this.#trackConfig(packetId).k
+    const block = this.#isoLocatorFor(packetId, catalogTrackName).blockAt(ssStart)
+    if (ssbLength <= 0 || ssbLength > k || block === undefined || block.span || block.length !== ssbLength) {
+      return null
     }
+    const sbn = ssStart
     this.#noteSbnSeen(sbn, packetId, catalogTrackName, 'repair')
 
     // Repair symbols are block activity: refresh the inactivity fail bound so
@@ -3802,8 +3912,9 @@ export class FECManager {
    * Record a block's authored SSB_length from a repair symbol. Returns false,
    * leaving the block unchanged, when the symbol contradicts the block: a
    * different SSB_length than an earlier repair symbol declared is dropped,
-   * and an SSB_length that places an already-received source ESI inside the
-   * zero padding fails the block, since its geometry can no longer be trusted.
+   * and an SSB_length that places an already-received source ESI at or past
+   * the block's end fails the block, since its geometry can no longer be
+   * trusted.
    */
   #noteAuthoredLength(
     blockKey: string,
@@ -3910,7 +4021,7 @@ export class FECManager {
     packetId: number,
     catalogTrackName: string | undefined,
   ): void {
-    if (!this.#isIso(packetId)) return
+    if (!this.#hasBlockProfile(packetId)) return
     const newest = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newest
     if (newest === undefined) return
     try {
@@ -3963,19 +4074,21 @@ export class FECManager {
 
     this.#noteSbnSeen(sbn, packetId, catalogTrackName, 'source', evidence.packetSequenceNumber)
 
-    // A source ESI inside the zero padding contradicts the block's authored
-    // SSB_length; its geometry can no longer be trusted, so fail it closed.
+    // A source ESI at or past the block's authored SSB_length contradicts it;
+    // its geometry can no longer be trusted, so fail it closed.
     const authoredLength = this.#blockAuthoredLengths.get(key) ?? k
     if (Number.isInteger(esi) && esi! >= authoredLength) {
       this.#failBlock(sbn, packetId, catalogTrackName)
       return
     }
 
-    this.#applyClassifierChanges(
-      packetId,
-      catalogTrackName,
-      this.#classifierFor(packetId, catalogTrackName).observe(sbn, evidence),
-    )
+    if (FECManager.#hasCatalogTiming(trackConfig)) {
+      this.#applyClassifierChanges(
+        packetId,
+        catalogTrackName,
+        this.#classifierFor(packetId, catalogTrackName).observe(sbn, evidence),
+      )
+    }
 
     // Count source symbols per block
     const count = (this.#blockSourceCounts.get(key) ?? 0) + 1
@@ -4024,6 +4137,7 @@ export class FECManager {
     this.#blockSourceEsis.delete(key)
     this.#blockAuthoredLengths.delete(key)
     this.#blockRepairRsIds.delete(key)
+    this.#blockRsbLengths.delete(key)
     // BLO-3323 L15: track which SBNs reached K source-symbol arrivals so the
     // worker recovery suppression can distinguish "block completed by source"
     // (legitimately suppress duplicate recovery) from "block touched by any
@@ -4049,6 +4163,9 @@ export class FECManager {
     catalogTrackName?: string,
     sourceProgress = false,
   ): void {
+    // An unconfigured packetId does no FEC work: no deadline is armed at an
+    // assumed geometry (BLO-45953).
+    if (!this.#trackConfigs.has(packetId)) return
     const key = this.#blockKey(sbn, packetId, catalogTrackName)
 
     // Late symbols must not resurrect a block that already completed or failed.
@@ -4070,7 +4187,7 @@ export class FECManager {
       return
     }
 
-    const trackConfig = this.#resolveTrackConfig(packetId)
+    const trackConfig = this.#trackConfig(packetId)
     const timeoutMs = this.#multicastWaitMs(trackConfig)
     // #computeTimeout never yields <= 0 (computeFecDeliveryWindowMs throws on
     // a non-positive interleave or K). Returning here would leave a block
@@ -4087,6 +4204,7 @@ export class FECManager {
     // most K+P accepted symbols can move the wait, so the block stays bounded.
     const repairDeadline = this.#repairDeadlines.get(key)
     if (
+      this.#hasCatalogTimingForPacket(packetId) &&
       this.onRepairNeeded &&
       !repairRequested &&
       (repairDeadline === undefined || sourceProgress)
@@ -4120,6 +4238,7 @@ export class FECManager {
     this.#blockSourceEsis.delete(key)
     this.#blockAuthoredLengths.delete(key)
     this.#blockRepairRsIds.delete(key)
+    this.#blockRsbLengths.delete(key)
     this.#syncDecoderBlockOwners.delete(key)
     this.#markTerminal(key, sbn, packetId, false)
     this.#failedBlocks.add(key)
@@ -4158,6 +4277,7 @@ export class FECManager {
     this.#blockSourceEsis.delete(key)
     this.#blockAuthoredLengths.delete(key)
     this.#blockRepairRsIds.delete(key)
+    this.#blockRsbLengths.delete(key)
     this.#clearBlockTimer(key)
     this.onBlockResolved?.(block.sbn, block.packetId, block.catalogTrackName)
   }
@@ -4169,6 +4289,8 @@ export class FECManager {
 
   /** Mark a block as completed externally (e.g., after routing recovered data). */
   markBlockCompleted(sbn: number, packetId?: number, catalogTrackName?: string): void {
+    // An unconfigured packetId has no FEC blocks to complete (BLO-45953).
+    if (packetId != null && !this.#trackConfigs.has(packetId)) return
     for (const key of this.#blockKeysFor(sbn, packetId, catalogTrackName)) {
       this.#resolveCompleted(key)
     }
@@ -4263,6 +4385,7 @@ export class FECManager {
     this.#blockSourceEsis.clear()
     this.#blockAuthoredLengths.clear()
     this.#blockRepairRsIds.clear()
+    this.#blockRsbLengths.clear()
     this.#completedBlocks.clear()
     this.#cleanlyCompletedBlocks.clear()
     this.#repairRequestedBlocks.clear()