@blockcast/mmt-container 0.3.0 → 0.4.0-main.d6f2737828fc

package/dist/fec-manager.js

@@ -1,20 +1,22 @@
 // src/track-session.ts
 import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
 function computeFecDeliveryWindowMs(config) {
-  const fecInterleaveMs = config.interleaveDepthMs;
   const fecK = config.sourceSymbols;
-  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+  if (!Number.isFinite(fecK) || fecK <= 0) {
     throw new Error(
-      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
     );
   }
-  if (!Number.isFinite(fecK) || fecK <= 0) {
+  return fecSpanDeliveryWindowMs(config.interleaveDepthMs, config.jitterBufferMs);
+}
+function fecSpanDeliveryWindowMs(interleaveDepthMs, jitterBufferMs) {
+  if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
     throw new Error(
-      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+      `[TrackSession] fecInterleaveMs=${interleaveDepthMs}. Derive a positive FEC interleave window from the stream catalog.`
     );
   }
-  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
-  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+  if (jitterBufferMs === void 0) return Math.ceil(interleaveDepthMs);
+  return fecBlockBudgetMs(interleaveDepthMs, jitterBufferMs);
 }
 
 // src/delivery-gap.ts
@@ -106,7 +108,9 @@ var DeliveryGapEstimator = class {
 import {
   deriveFecInterleaveDepth as deriveFecInterleaveDepth2,
   deriveFecRetentionBlocks,
-  tryDeriveFecRetentionBlocks
+  tryDeriveFecRetentionBlocks,
+  LOCAL_FEC_RETENTION_BLOCKS,
+  LOCAL_FEC_TIMEOUT_MS
 } from "@blockcast/mmt-fec";
 
 // ../mmt-alta-parse/dist/index.js
@@ -146,49 +150,21 @@ function serial32Precedes(a, b) {
   const distance = serial32Distance(a, b);
   return distance !== 0 && distance < SERIAL32_HALF;
 }
-function kStrideBlockStart(sbn, k) {
-  assertUint32(sbn, "sbn");
-  if (!Number.isInteger(k) || k < 1 || k >= SERIAL32_HALF) {
-    throw new RangeError(`k must be a positive integer below 2^31 (got ${k})`);
-  }
-  const high = Math.floor(sbn / 65536);
-  const low = sbn % 65536;
-  return (high * k % SERIAL32_SPAN * 65536 + low * k) % SERIAL32_SPAN;
-}
-function kStrideBlockPrecedes(a, b, k) {
-  return serial32Precedes(kStrideBlockStart(a, k), kStrideBlockStart(b, k));
-}
-function kStrideBlocksBehind(a, b, k) {
-  const from = kStrideBlockStart(a, k);
-  const to = kStrideBlockStart(b, k);
-  if (!serial32Precedes(from, to))
-    return 0;
-  return Math.ceil(serial32Distance(from, to) / k);
-}
-function isKStrideBlock(sbn, k) {
-  return Number.isInteger(sbn) && sbn >= 0 && sbn < SERIAL32_SPAN && Number.isInteger(k) && k >= 1 && k < SERIAL32_HALF;
-}
-function kStrideNextBlock(sbn, k) {
-  assertUint32(sbn, "sbn");
-  kStrideBlockStart(sbn, k);
-  return (sbn + 1) * k >= SERIAL32_SPAN ? 0 : sbn + 1;
-}
 
 // ../mmt-base/dist/fec-block-profile.js
 var FEC_BLOCK_PROFILES = Object.freeze([
-  "k-padded-v1",
   "iso-ssbg1-v1"
 ]);
 function isFecBlockProfile(value) {
-  return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+  return value === "iso-ssbg1-v1";
 }
 function parseFecBlockProfile(value, where) {
   if (isFecBlockProfile(value))
     return value;
   if (value === void 0) {
-    throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+    throw new Error(`${where} is required: name the FEC block profile ("iso-ssbg1-v1")`);
   }
-  throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+  throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
 }
 var SSBG1_LENGTH_FIELD_BYTES = 2;
 function ssbg1MaxPacketLength(symbolSize) {
@@ -441,7 +417,7 @@ var IsoBlockLocator = class _IsoBlockLocator {
 };
 
 // src/fec-state.ts
-var MIN_INTERLEAVE_DEPTH_MS = 33;
+var MIN_INTERLEAVE_DEPTH_MS = 1;
 var FEC_INACTIVE_REASONS = Object.freeze([
   "no-catalog-fec",
   "reliable-moq",
@@ -836,7 +812,6 @@ var FECManager = class _FECManager {
   constructor() {
     // Per-track WASM RaptorQ decoders, keyed by physical stream identity.
     this.#fecDecoders = /* @__PURE__ */ new Map();
-    /** @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,
     // not synchronous return from feedSourceSymbol/feedRepairSymbol.
@@ -851,10 +826,9 @@ var FECManager = class _FECManager {
     // source/repair symbols do not split across two RaptorQ states.
     this.#syncDecoderBlockOwners = /* @__PURE__ */ new Map();
     this.#decoderBlockOwners = /* @__PURE__ */ new WeakMap();
-    this.#fecK = 4;
     this.#fecSymbolSize = 0;
-    this.#fecTimeoutMs = 500;
-    // default 500ms; refined by setFramerate() when fps known
+    this.#fecTimeoutMs = LOCAL_FEC_TIMEOUT_MS;
+    // local default; refined by setFramerate() when fps known
     this.#trackConfigs = /* @__PURE__ */ new Map();
     this.#fecStats = newFecCounters();
     this.#fecTrackStats = /* @__PURE__ */ new Map();
@@ -894,10 +868,10 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis = /* @__PURE__ */ new Map();
     // 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.
     this.#blockAuthoredLengths = /* @__PURE__ */ new Map();
     this.#ssbLengthConflictCount = 0;
@@ -1014,14 +988,16 @@ var FECManager = class _FECManager {
     this.#resolvedBlockClasses = /* @__PURE__ */ new Map();
     // Blocks already reported through onBlockRepaired (once per block).
     this.#repairedBlocks = /* @__PURE__ */ new Set();
-    // 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).
     this.#materializedBlocks = /* @__PURE__ */ new Set();
     // 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.
     this.#orderedHorizonWarnedFor = /* @__PURE__ */ new Set();
-    // 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.
     this.#highestSbn = /* @__PURE__ */ new Map();
     // 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).
@@ -1115,7 +1091,10 @@ var FECManager = class _FECManager {
   #releasedWorkerClients;
   #syncDecoderBlockOwners;
   #decoderBlockOwners;
-  #fecK;
+  // 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;
   #fecSymbolSize;
   #fecTimeoutMs;
   #trackConfigs;
@@ -1277,7 +1256,8 @@ var FECManager = 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) {
@@ -1313,8 +1293,9 @@ var FECManager = 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
@@ -1327,6 +1308,14 @@ var FECManager = class _FECManager {
    * derivation; do not re-derive a horizon at either call site.
    */
   #orderedHorizonBlocksFor(packetId, config) {
+    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 decoder's interleave horizon from the catalog interleaveDepthMs (>= ${MIN_INTERLEAVE_DEPTH_MS}ms), the media-unit rate and the block delivery window; got interleaveDepthMs=${config.interleaveDepthMs} fps=${String(config.fps)} timeoutMs=${config.timeoutMs}.`
@@ -1340,7 +1329,7 @@ var FECManager = class _FECManager {
    * two can never disagree about which streams settle by stream order.
    */
   static #hasOrderedGeometry(config) {
-    return config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS && // `fps` is no longer an input to the horizon, but it still gates WHICH
+    return _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
     // keep doing so. Removing this widens ordered-relay settlement to streams
@@ -1380,6 +1369,9 @@ var FECManager = class _FECManager {
    * argument: narrower IS the failing direction.
    */
   #derivableOrderedHorizon(config, packetId) {
+    if (config.interleaveDepthMs === 0) {
+      return Number.isFinite(config.timeoutMs) && config.timeoutMs > 0 ? LOCAL_FEC_RETENTION_BLOCKS : void 0;
+    }
     if (!_FECManager.#hasOrderedGeometry(config)) return void 0;
     try {
       const blocks = tryDeriveFecRetentionBlocks(config.timeoutMs, config.interleaveDepthMs);
@@ -1412,19 +1404,20 @@ var FECManager = 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) {
-    return this.#derivableOrderedHorizon(this.#resolveTrackConfig(packetId), packetId);
+    const config = this.#trackConfigs.get(packetId);
+    return config === void 0 ? void 0 : this.#derivableOrderedHorizon(config, packetId);
   }
   /** True while a block of an ordered-relay stream can still receive symbols. */
   #withinOrderedHorizon(key) {
@@ -1458,7 +1451,7 @@ var FECManager = class _FECManager {
    */
   #advanceOrderedFrontier(streamKey, sbn, packetId, catalogTrackName) {
     const previous = this.#orderedFrontiers.get(streamKey);
-    const frontier = previous === void 0 || this.#blockPrecedes(previous, sbn, packetId) ? sbn : previous;
+    const frontier = previous === void 0 || this.#blockPrecedes(previous, sbn) ? sbn : previous;
     if (frontier !== previous) this.#orderedFrontiers.set(streamKey, frontier);
     const pending = this.#orderedPendingBlocks.get(streamKey);
     if (!pending) return;
@@ -1493,7 +1486,7 @@ var FECManager = class _FECManager {
     if (this.#completedBlocks.has(key) || this.#pendingWorkerCleanups.has(key) || this.#repairRequestedBlocks.has(key)) return;
     const authoredLength = this.#blockAuthoredLengths.get(key);
     const received = (this.#blockSourceCounts.get(key) ?? 0) + (this.#blockRepairRsIds.get(key)?.size ?? 0);
-    if (this.onRepairNeeded && (authoredLength === void 0 || received < authoredLength)) {
+    if (this.#hasCatalogTimingForPacket(packetId) && this.onRepairNeeded && (authoredLength === void 0 || received < authoredLength)) {
       this.#requestRepair(sbn, packetId, catalogTrackName, true);
       return;
     }
@@ -1649,7 +1642,7 @@ var FECManager = class _FECManager {
   }
   #requestRepair(sbn, packetId, catalogTrackName, settledByOrder = false) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
-    if (this.#completedBlocks.has(key) || !this.onRepairNeeded || this.#repairRequestedBlocks.has(key)) return;
+    if (this.#completedBlocks.has(key) || !this.#hasCatalogTimingForPacket(packetId) || !this.onRepairNeeded || this.#repairRequestedBlocks.has(key)) return;
     const deadline = this.#repairDeadlines.get(key);
     if (deadline?.handle != null) clearTimeout(deadline.handle);
     this.#repairDeadlines.set(key, null);
@@ -1729,6 +1722,7 @@ var FECManager = class _FECManager {
   }
   /** A block's live class without creating classifier state for the stream. */
   #peekClass(sbn, packetId, catalogTrackName) {
+    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";
@@ -1750,8 +1744,8 @@ var FECManager = 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.
@@ -1760,27 +1754,28 @@ var FECManager = class _FECManager {
     return Math.ceil(config.timeoutMs / config.interleaveDepthMs);
   }
   /**
-   * 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, packetId, catalogTrackName, symbol, packetSequenceNumber) {
     const streamKey = this.#streamKey(packetId, catalogTrackName);
@@ -1789,7 +1784,7 @@ var FECManager = class _FECManager {
     const anchor = this.#sourceAnchors.get(streamKey);
     const psn = symbol === "source" && packetSequenceNumber !== void 0 && Number.isSafeInteger(packetSequenceNumber) && packetSequenceNumber >= 0 && packetSequenceNumber <= 4294967295 ? packetSequenceNumber : void 0;
     const anchorHere = () => {
-      if (psn !== void 0 && (anchor === void 0 || !this.#blockPrecedes(sbn, anchor.sbn, packetId))) {
+      if (psn !== void 0 && (anchor === void 0 || !this.#blockPrecedes(sbn, anchor.sbn))) {
         this.#sourceAnchors.set(streamKey, { sbn, psn, atMs: now });
       }
     };
@@ -1805,9 +1800,9 @@ var FECManager = 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();
         return;
@@ -1818,15 +1813,9 @@ var FECManager = class _FECManager {
     const missing = this.#blocksBehind(previous.sbn, sbn, packetId) - 1;
     let plausible = true;
     if (window !== null) {
-      if (this.#isIso(packetId) && psn !== void 0 && anchor !== void 0 && this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
+      if (psn !== void 0 && anchor !== void 0 && this.#blockPrecedes(anchor.sbn, sbn) && psn !== anchor.psn) {
         const sent = psn - anchor.psn >>> 0;
         plausible = sent <= 2147483647 && serial32Distance(anchor.sbn, sbn) <= sent + config.k;
-      } else if (psn !== void 0 && anchor !== void 0 && this.#blockPrecedes(anchor.sbn, sbn, packetId) && psn !== anchor.psn) {
-        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);
-        const kCloses = config.k > 0 ? Math.ceil(sent / config.k) : sent;
-        plausible = sent <= 2147483647 && between <= sent - 1 && between <= dCloses + kCloses;
       } else {
         plausible = missing <= window + Math.ceil((now - previous.atMs) / config.interleaveDepthMs);
       }
@@ -1838,48 +1827,31 @@ var FECManager = class _FECManager {
     }
     this.#highestSbn.set(streamKey, { sbn, atMs: now });
     anchorHere();
-    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.
-   */
-  #blockPrecedes(a, b, packetId) {
-    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;
-  }
-  /** Blocks `a` lies behind `b` (0 when it does not precede it). */
-  #blocksBehind(a, b, packetId) {
-    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);
+   * 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, b) {
+    return serial32Precedes(a, b);
   }
-  /** The block after `sbn`, stepping to block 0 where SS_ID wraps. */
-  #nextBlock(sbn, packetId) {
-    const k = this.kForPacket(packetId);
-    return isKStrideBlock(sbn, k) ? kStrideNextBlock(sbn, k) : sbn + 1;
+  /**
+   * 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, b, packetId) {
+    return isoBlocksBehindLowerBound(a, b, this.#trackConfig(packetId).k);
   }
   #materializeBlock(sbn, packetId, catalogTrackName, repairable) {
     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);
@@ -1918,21 +1890,39 @@ var FECManager = class _FECManager {
     });
     if (this.#lifecycleTrace.length > 64) this.#lifecycleTrace.splice(0, 32);
   }
-  #defaultTrackConfig() {
-    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) {
+    const config = this.#trackConfigs.get(packetId);
+    if (config === void 0) {
+      throw new Error(
+        `[FECManager] packetId=${packetId} was never configured; configure the track from its catalog (configureTrack/setFecWorker/setFecDecoder) first`
+      );
+    }
+    return config;
   }
-  #resolveTrackConfig(packetId) {
-    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) {
+    return Number.isSafeInteger(config.interleaveDepthMs) && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS;
+  }
+  #hasCatalogTimingForPacket(packetId) {
+    const config = this.#trackConfigs.get(packetId);
+    return config !== void 0 && _FECManager.#hasCatalogTiming(config);
   }
   #computeTimeout(config) {
-    if (config.timeoutMs && config.timeoutMs > 0) return config.timeoutMs;
-    if (config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+    if (typeof config.timeoutMs === "number" && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0) {
+      return config.timeoutMs;
+    }
+    if (Number.isSafeInteger(config.interleaveDepthMs) && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
       return Math.max(
         this.#fecTimeoutMs,
         computeFecDeliveryWindowMs({
@@ -1957,14 +1947,17 @@ var FECManager = class _FECManager {
    */
   #refreshDeliveryGapWindow() {
     let windowMs;
-    const consider = (geometry) => {
+    const consider = (geometry, packetId) => {
+      if (!this.#hasCatalogTimingForPacket(packetId)) return;
       if (geometry?.trackKind !== "video" || geometry.mode !== "classifying") return;
       const { ticks, timescale } = geometry.keyframeInterval;
       const ms = ticks / timescale * 1e3;
       if (Number.isFinite(ms) && ms > 0 && (windowMs === void 0 || 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);
   }
   /**
@@ -1992,6 +1985,7 @@ var FECManager = class _FECManager {
     return Math.max(config.timeoutMs, Math.ceil(config.interleaveDepthMs + gapMs));
   }
   #repairDeadlineMs(config, waitMs = this.#multicastWaitMs(config)) {
+    if (!_FECManager.#hasCatalogTiming(config)) return waitMs;
     const halfFailBoundMs = Math.ceil(waitMs / 2);
     if (config.k > 0 && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS && config.fps !== void 0 && Number.isFinite(config.fps) && config.fps > 0) {
       const mediaUnitMs = 1e3 / config.fps;
@@ -2006,10 +2000,12 @@ var FECManager = 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) {
     const waitMs = this.#maxMulticastWaitMs(config);
@@ -2025,6 +2021,7 @@ var FECManager = class _FECManager {
     return Math.min(waitMs + this.#repairGraceMs(config, waitMs), this.#blockLifetimeMs(config));
   }
   #repairGraceMs(config, waitMs) {
+    if (!_FECManager.#hasCatalogTiming(config)) return 0;
     return Math.max(1, waitMs - this.#repairDeadlineMs(config, waitMs));
   }
   #armBlockTimeout(sbn, packetId, catalogTrackName, delayMs) {
@@ -2111,51 +2108,72 @@ var FECManager = class _FECManager {
    * stream; every other field stays per packetId.
    */
   #upsertTrackConfig(packetId, config, catalogTrackName) {
-    const previous = this.#trackConfigs.get(packetId) ?? this.#defaultTrackConfig();
+    const previousTrack = this.#trackConfigs.get(packetId);
+    const k = config.k ?? previousTrack?.k;
+    if (k === void 0 || !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 = previousTrack ?? {};
     const streamScopedGeometry = catalogTrackName !== void 0 && config.geometry !== void 0 ? config.geometry : void 0;
     if (streamScopedGeometry !== void 0) {
       const { geometry: _streamGeometry, ...packetLevel } = config;
       config = packetLevel;
     }
     const timingChanged = config.k !== void 0 || config.interleaveDepthMs !== void 0 || config.fps !== void 0;
+    if (config.timeoutMs !== void 0 && (!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 !== void 0) {
       parseFecBlockProfile(config.blockProfile, `packetId=${packetId} fec.blockProfile`);
     }
     const blockProfile = config.blockProfile ?? previous.blockProfile;
     if (blockProfile === void 0) {
       throw new Error(
-        `[FECManager] packetId=${packetId}: fec.blockProfile is required ("k-padded-v1" or "iso-ssbg1-v1"); configure the track from its catalog`
+        `[FECManager] packetId=${packetId}: fec.blockProfile is required ("iso-ssbg1-v1"); configure the track from its catalog`
       );
     }
-    if (blockProfile === "iso-ssbg1-v1") {
-      const ownInterleaveDepthMs = config.interleaveDepthMs ?? this.#trackConfigs.get(packetId)?.interleaveDepthMs;
-      if (ownInterleaveDepthMs === void 0 || !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`
-        );
-      }
+    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 = {
       blockProfile,
-      k: config.k ?? previous.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),
+      k,
+      symbolSize: config.symbolSize != null && config.symbolSize > 0 ? config.symbolSize : previousTrack?.symbolSize ?? 0,
+      interleaveDepthMs: ownInterleaveDepthMs,
+      fps: config.fps ?? previous.fps ?? this.#fecFps,
+      timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs ?? 0),
       ...(config.trackKind ?? previous.trackKind) === void 0 ? {} : { trackKind: config.trackKind ?? previous.trackKind },
       ...(config.codec ?? previous.codec) === void 0 ? {} : { codec: config.codec ?? previous.codec },
       ...(config.geometry ?? previous.geometry) === void 0 ? {} : { geometry: config.geometry ?? previous.geometry }
     };
-    next.timeoutMs = this.#computeTimeout(next);
+    if (!hasCatalogTiming) {
+      next.timeoutMs = config.timeoutMs !== void 0 && config.timeoutMs > 0 ? config.timeoutMs : previousTrack !== void 0 && previousTrack.interleaveDepthMs === 0 ? previousTrack.timeoutMs : LOCAL_FEC_TIMEOUT_MS;
+    } else {
+      next.timeoutMs = this.#computeTimeout(next);
+    }
     if (this.#multicastSymbolDelivery === "ordered-relay") {
       this.#orderedHorizonBlocksFor(packetId, next);
     }
-    if (previous.blockProfile !== void 0 && (previous.blockProfile !== blockProfile || blockProfile === "iso-ssbg1-v1" && previous.k !== next.k)) {
+    const timingPolicyChanged = _FECManager.#hasCatalogTiming({ interleaveDepthMs: previous.interleaveDepthMs ?? 0 }) !== hasCatalogTiming;
+    if (timingPolicyChanged && !hasCatalogTiming) {
+      for (const key of [...this.#repairDeadlines.keys()]) {
+        if (this.#belongsToPacket(key, packetId)) this.#clearRepairDeadline(key);
+      }
+    }
+    if (previous.blockProfile !== void 0 && previous.k !== next.k) {
       this.#dropIsoLocators(packetId);
     }
     this.#trackConfigs.set(packetId, next);
     this.#refreshDeliveryGapWindow();
-    let policyChanged = config.geometry !== void 0 && JSON.stringify(config.geometry) !== JSON.stringify(previous.geometry) || config.trackKind !== void 0 && config.trackKind !== previous.trackKind;
+    let policyChanged = timingPolicyChanged || config.geometry !== void 0 && JSON.stringify(config.geometry) !== JSON.stringify(previous.geometry) || config.trackKind !== void 0 && config.trackKind !== previous.trackKind;
     if (streamScopedGeometry !== void 0) {
       const streamKey = this.#streamKey(packetId, catalogTrackName);
       if (JSON.stringify(streamScopedGeometry) !== JSON.stringify(this.#streamGeometries.get(streamKey))) {
@@ -2170,20 +2188,14 @@ var FECManager = 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;
         this.#applyClassifierChanges(stream.packetId, stream.catalogTrackName, classifier.retire());
       }
     }
     return next;
   }
-  #normalizeSymbolData(packetId, data) {
-    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, packetId, catalogTrackName) {
     if (packetId != null && catalogTrackName !== void 0) {
       return [this.#blockKey(sbn, packetId, catalogTrackName)];
@@ -2244,7 +2256,7 @@ var FECManager = 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,
         packetLossRate: trackTotal > 0 ? trackAffected / trackTotal * 100 : 0
       };
@@ -2256,7 +2268,7 @@ var FECManager = 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,
@@ -2551,15 +2563,20 @@ var FECManager = 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, sbn, esi, _data, source, catalogTrackName) {
+    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") {
       this.#advanceOrderedFrontier(streamKey, sbn, packetId, catalogTrackName);
     }
-    const k = this.kForPacket(packetId);
-    const sourceSymbols = this.#isIso(packetId) ? this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? k : k;
+    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 = this.#startupRequireRepairReady && source === "multicast" && !isSourceSymbol && this.#startupRepairReadyPackets.has(streamKey);
@@ -2677,14 +2694,14 @@ var FECManager = 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 });
     }
     const completed = [...this.#completedBlocks].slice(-16);
     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 });
       }
     }
@@ -2695,25 +2712,23 @@ var FECManager = class _FECManager {
   get wasmDecoder() {
     return this.#fecDecoders.values().next().value?.client ?? null;
   }
-  get k() {
-    return this.#fecK;
-  }
+  /** A configured packetId's K; undefined for an unconfigured one (no FEC work). */
   kForPacket(packetId) {
-    return this.#resolveTrackConfig(packetId).k;
+    return this.#trackConfigs.get(packetId)?.k;
   }
   /** FEC symbol size in bytes. */
   get symbolSize() {
     return this.#fecSymbolSize;
   }
   symbolSizeForPacket(packetId) {
-    return this.#resolveTrackConfig(packetId).symbolSize;
+    return this.#trackConfigs.get(packetId)?.symbolSize;
   }
   /** FEC block span in milliseconds (0 = no interleaving). */
   get interleaveDepthMs() {
     return this.#fecInterleaveDepthMs;
   }
   interleaveDepthMsForPacket(packetId) {
-    return this.#resolveTrackConfig(packetId).interleaveDepthMs;
+    return this.#trackConfigs.get(packetId)?.interleaveDepthMs;
   }
   /**
    * Record one multicast MMTP packet arrival (every packet of the leg, FEC
@@ -2731,7 +2746,8 @@ var FECManager = class _FECManager {
    * plus the larger of the catalog tolerance and the measured delivery gap.
    */
   timeoutMsForPacket(packetId) {
-    return this.#multicastWaitMs(this.#resolveTrackConfig(packetId));
+    const config = this.#trackConfigs.get(packetId);
+    return config === void 0 ? void 0 : this.#multicastWaitMs(config);
   }
   /**
    * Largest multicast delivery gap measured over the current window (ms), and
@@ -2787,27 +2803,31 @@ var FECManager = class _FECManager {
   }
   /** Resolved per-track D-28 repair request deadline in milliseconds. */
   repairDeadlineMsForPacket(packetId) {
-    return this.#repairDeadlineMs(this.#resolveTrackConfig(packetId));
+    const config = this.#trackConfigs.get(packetId);
+    return config === void 0 ? void 0 : 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) {
-    return this.#blockLifetimeMs(this.#resolveTrackConfig(packetId));
+    const config = this.#trackConfigs.get(packetId);
+    return config === void 0 ? void 0 : 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) {
-    const config = this.#resolveTrackConfig(packetId);
+    const config = this.#trackConfigs.get(packetId);
+    if (config === void 0) return void 0;
     return config.interleaveDepthMs + 2 * this.#blockLifetimeMs(config);
   }
   /** Remaining fetch budget for a specific repair-requested block. */
@@ -2818,7 +2838,8 @@ var FECManager = class _FECManager {
     if (deadlineMs !== void 0) {
       return Math.max(1, Math.ceil(deadlineMs - performance.now()));
     }
-    const trackConfig = this.#resolveTrackConfig(packetId);
+    const trackConfig = this.#trackConfigs.get(packetId);
+    if (trackConfig === void 0) return void 0;
     return Math.max(1, trackConfig.timeoutMs - this.#repairDeadlineMs(trackConfig));
   }
   /** True once configureTrack/setFecDecoder/setFecWorker configured this packetId. */
@@ -2829,14 +2850,19 @@ var FECManager = class _FECManager {
   blockProfileForPacket(packetId) {
     return this.#trackConfigs.get(packetId)?.blockProfile;
   }
-  #isIso(packetId) {
-    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) {
+    return this.#trackConfigs.get(packetId)?.blockProfile !== void 0;
   }
   #isoLocatorFor(packetId, catalogTrackName) {
     const streamKey = this.#streamKey(packetId, catalogTrackName);
     let locator = this.#isoLocators.get(streamKey);
     if (!locator) {
-      locator = new IsoBlockLocator(this.kForPacket(packetId), this.#isoRetentionBlocks(packetId));
+      locator = new IsoBlockLocator(this.#trackConfig(packetId).k, this.#isoRetentionBlocks(packetId));
       this.#isoLocators.set(streamKey, locator);
     }
     return locator;
@@ -2867,12 +2893,14 @@ var FECManager = class _FECManager {
    */
   #isoRetentionBlocks(packetId) {
     const config = this.#trackConfigs.get(packetId);
-    if (config?.blockProfile !== "iso-ssbg1-v1" || !(config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS)) {
+    if (config?.blockProfile === void 0) {
       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`);
     }
@@ -2880,7 +2908,8 @@ var FECManager = class _FECManager {
   }
   /** Whether an iso-ssbg1-v1 protected packet fits one ssbg_mode1 symbol (len + 2 <= T). */
   isoSourceFits(packetId, packetLength) {
-    return ssbg1FitsSymbol(packetLength, this.symbolSizeForPacket(packetId));
+    const symbolSize = this.#trackConfigs.get(packetId)?.symbolSize;
+    return symbolSize !== void 0 && ssbg1FitsSymbol(packetLength, symbolSize);
   }
   /**
    * Locate an iso-ssbg1-v1 source by range membership in a block a repair
@@ -2941,11 +2970,11 @@ var FECManager = 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.
    */
@@ -3013,6 +3042,7 @@ var FECManager = class _FECManager {
   }
   /** Current classifier mode of a stream. */
   classifierModeFor(packetId, catalogTrackName) {
+    if (!this.#hasCatalogTimingForPacket(packetId)) return { mode: "all-protected", reason: null };
     const classifier = this.#classifierFor(packetId, catalogTrackName);
     return { mode: classifier.mode, reason: classifier.reason };
   }
@@ -3022,10 +3052,12 @@ var FECManager = class _FECManager {
    * it does not. A stream with no classifier yet has shown nothing against it.
    */
   mpuBoundsRapsFor(packetId, catalogTrackName) {
+    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, packetId, catalogTrackName) {
+    if (!this.#hasCatalogTimingForPacket(packetId)) return "unknown";
     const frozen = this.#resolvedBlockClasses.get(this.#blockKey(sbn, packetId, catalogTrackName));
     if (frozen !== void 0) return frozen;
     return this.#peekClass(sbn, packetId, catalogTrackName);
@@ -3047,7 +3079,7 @@ var FECManager = class _FECManager {
    * invariant (consecutive MPUs exactly one keyframe interval apart).
    */
   noteReleasedRap(packetId, catalogTrackName, mpu, presentationTime, mediaTimescale) {
-    if (!this.#trackConfigs.has(packetId)) return;
+    if (!this.#trackConfigs.has(packetId) || !this.#hasCatalogTimingForPacket(packetId)) return;
     this.#applyClassifierChanges(
       packetId,
       catalogTrackName,
@@ -3063,27 +3095,34 @@ var FECManager = class _FECManager {
   // -----------------------------------------------------------------------
   /** Configure FEC parameters. */
   configure(config) {
-    if (config.k != null) this.#fecK = config.k;
+    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;
     }
-    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 (\xA75.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 != null && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
-      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
-        interleaveDepthMs: config.interleaveDepthMs,
-        sourceSymbols: this.#fecK,
-        symbolSize: this.#fecSymbolSize,
-        mediaUnitsPerSecond: config.fps
-      });
+    } else if (config.interleaveDepthMs === 0) {
+      this.#fecTimeoutMs = LOCAL_FEC_TIMEOUT_MS;
+    } else if (config.interleaveDepthMs != null && Number.isSafeInteger(config.interleaveDepthMs) && config.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+      this.#fecTimeoutMs = fecSpanDeliveryWindowMs(config.interleaveDepthMs);
     }
     for (const [packetId, track] of this.#trackConfigs) {
-      if (track.timeoutMs < this.#fecTimeoutMs) {
+      if (_FECManager.#hasCatalogTiming(track) && track.timeoutMs < this.#fecTimeoutMs) {
         this.#trackConfigs.set(packetId, { ...track, timeoutMs: this.#fecTimeoutMs });
       }
     }
@@ -3142,7 +3181,7 @@ var FECManager = 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);
     client.onFrame((data, meta) => {
@@ -3322,7 +3361,7 @@ var FECManager = 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);
   }
@@ -3363,16 +3402,11 @@ var FECManager = class _FECManager {
     if (this.#fpsDetected || fps <= 0) return;
     this.#fpsDetected = true;
     this.#fecFps = fps;
-    if (this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
-      this.#fecTimeoutMs = computeFecDeliveryWindowMs({
-        interleaveDepthMs: this.#fecInterleaveDepthMs,
-        sourceSymbols: this.#fecK,
-        symbolSize: this.#fecSymbolSize,
-        mediaUnitsPerSecond: fps
-      });
+    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 !== void 0 || config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) continue;
+      if (config.fps !== void 0 || !Number.isSafeInteger(config.interleaveDepthMs) || config.interleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) continue;
       this.#trackConfigs.set(packetId, {
         ...config,
         fps,
@@ -3404,35 +3438,28 @@ var FECManager = class _FECManager {
   feedSourceSymbol(packetId, ssId, symbolData, alta, catalogTrackName) {
     this.#fecStats.sourcePackets++;
     this.#statsForPacket(packetId).sourcePackets++;
-    let sbn;
-    let fecData;
-    if (this.#isIso(packetId)) {
-      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));
+    if (!this.#hasBlockProfile(packetId)) return null;
+    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);
     const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
     if (workerClient && !syncBlockOwner) {
       if (!this.#claimDecoderBlock(workerClient, sbn, catalogTrackName)) return null;
-      const buf = fecData !== symbolData ? fecData.buffer : fecData.buffer.slice(
-        fecData.byteOffset,
-        fecData.byteOffset + fecData.byteLength
+      const buf = symbolData.buffer.slice(
+        symbolData.byteOffset,
+        symbolData.byteOffset + symbolData.byteLength
       );
       if (alta) {
         const authBuf = alta.auth.buffer.slice(
@@ -3455,7 +3482,7 @@ var FECManager = class _FECManager {
     this.#syncDecoderBlockOwners.set(blockKey, client);
     let recovered = null;
     try {
-      recovered = client.add_source(ssId, fecData, performance.now());
+      recovered = client.add_source(ssId, symbolData, performance.now());
     } catch {
     }
     this.#retireIsoUnplaced(client, packetId, catalogTrackName);
@@ -3474,7 +3501,8 @@ var FECManager = class _FECManager {
   feedRepairSymbol(packetId, ssStart, ssbLength, rsId, repairData, catalogTrackName) {
     this.#fecStats.repairPackets++;
     this.#statsForPacket(packetId).repairPackets++;
-    const symbolSize = this.symbolSizeForPacket(packetId);
+    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) {
@@ -3485,18 +3513,12 @@ var FECManager = class _FECManager {
       return null;
     }
     const fecData = repairData;
-    const k = this.kForPacket(packetId);
-    let sbn;
-    if (this.#isIso(packetId)) {
-      const block = this.#isoLocatorFor(packetId, catalogTrackName).blockAt(ssStart);
-      if (ssbLength <= 0 || ssbLength > k || block === void 0 || 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);
+    const k = this.#trackConfig(packetId).k;
+    const block = this.#isoLocatorFor(packetId, catalogTrackName).blockAt(ssStart);
+    if (ssbLength <= 0 || ssbLength > k || block === void 0 || block.span || block.length !== ssbLength) {
+      return null;
     }
+    const sbn = ssStart;
     this.#noteSbnSeen(sbn, packetId, catalogTrackName, "repair");
     this.noteBlockActivity(sbn, packetId, catalogTrackName);
     const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
@@ -3534,8 +3556,9 @@ var FECManager = 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, sbn, packetId, ssbLength, catalogTrackName) {
     const known = this.#blockAuthoredLengths.get(blockKey);
@@ -3602,7 +3625,7 @@ var FECManager = class _FECManager {
    * a sweep tied to expiry alone would never run there.
    */
   #retireIsoUnplaced(decoder, packetId, catalogTrackName) {
-    if (!this.#isIso(packetId)) return;
+    if (!this.#hasBlockProfile(packetId)) return;
     const newest = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newest;
     if (newest === void 0) return;
     try {
@@ -3647,11 +3670,13 @@ var FECManager = class _FECManager {
       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)
+      );
+    }
     const count = (this.#blockSourceCounts.get(key) ?? 0) + 1;
     this.#blockSourceCounts.set(key, count);
     if (count === 1) this.#indexBlockKey(key, sbn, packetId);
@@ -3695,6 +3720,7 @@ var FECManager = class _FECManager {
   }
   /** Refresh deadlines after accepted block activity. */
   noteBlockActivity(sbn, packetId, catalogTrackName, sourceProgress = false) {
+    if (!this.#trackConfigs.has(packetId)) return;
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
     if (this.#completedBlocks.has(key)) return;
     if (this.#pendingWorkerCleanups.has(key)) return;
@@ -3704,13 +3730,13 @@ var FECManager = class _FECManager {
       this.#holdForOrderedSettlement(key, sbn, packetId, catalogTrackName);
       return;
     }
-    const trackConfig = this.#resolveTrackConfig(packetId);
+    const trackConfig = this.#trackConfig(packetId);
     const timeoutMs = this.#multicastWaitMs(trackConfig);
     if (!(timeoutMs > 0)) {
       throw new Error(`[FECManager] packetId=${packetId} has no positive fail bound (timeoutMs=${timeoutMs})`);
     }
     const repairDeadline = this.#repairDeadlines.get(key);
-    if (this.onRepairNeeded && !repairRequested && (repairDeadline === void 0 || sourceProgress)) {
+    if (this.#hasCatalogTimingForPacket(packetId) && this.onRepairNeeded && !repairRequested && (repairDeadline === void 0 || sourceProgress)) {
       this.#armRepairDeadline(
         key,
         sbn,
@@ -3780,6 +3806,7 @@ var FECManager = class _FECManager {
   }
   /** Mark a block as completed externally (e.g., after routing recovered data). */
   markBlockCompleted(sbn, packetId, catalogTrackName) {
+    if (packetId != null && !this.#trackConfigs.has(packetId)) return;
     for (const key of this.#blockKeysFor(sbn, packetId, catalogTrackName)) {
       this.#resolveCompleted(key);
     }