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

package/dist/browser-runtime.js

@@ -87,6 +87,8 @@ var init_fec_worker_client = __esm({
       }
       /**
        * Configure the Worker with FEC parameters and WASM module.
+       * `interleaveMs: 0` is a valid no-span catalog value; in that mode the
+       * caller supplies a positive receiver-local `deliveryWindowMs`.
        * wasmModule is transferred (not neutered — WebAssembly.Module is shareable).
        * altaPublicKey is PKCS#8 SPKI DER bytes (self-describing — algorithm detected from OID).
        *   Transferred (detached from sender).
@@ -139,8 +141,7 @@ var init_fec_worker_client = __esm({
        * Caller must not access data after this call — it is detached.
        *
        * Carries the wire-level Repair FEC Payload ID fields (ISO 23008-1 §C.5.3):
-       * - ssStart:   SS_ID of first source symbol in the block (= SBN * configured K
-       *              under `k-padded-v1`; any uint32, the block key, under `iso-ssbg1-v1`)
+       * - ssStart:   SS_ID of first source symbol in the block (any uint32; the block key)
        * - ssbLength: authored source-symbol count (1..configured K)
        * - rsId:      repair symbol index within the block
        */
@@ -190,7 +191,7 @@ var init_fec_worker_client = __esm({
       }
       /**
        * Trigger cleanup after a block's inactivity deadline. `currentSbn` is the
-       * block key: the SBN under `k-padded-v1`, the SS_Start under `iso-ssbg1-v1`.
+       * block key, the block's SS_Start.
        *
        * While one queue-drain barrier is in flight, later SBNs are coalesced into
        * the next command without losing their individual acknowledgement identity.
@@ -902,8 +903,6 @@ function sourceFecPayloadIdOf(mmtpPacket, header) {
     ssId: (mmtpPacket[off] << 24 | mmtpPacket[off + 1] << 16 | mmtpPacket[off + 2] << 8 | mmtpPacket[off + 3]) >>> 0
   };
 }
-var MMTP_EXT_TYPE_ALTA_AUTH2 = MMTP_EXT_TYPE_ALTA_AUTH;
-var MMTP_EXT_TRAILER_HEADER_SIZE2 = MMTP_EXT_TRAILER_HEADER_SIZE;
 var extractAltaTrailer2 = extractAltaTrailer;
 var REPAIR_FEC_PID_SIZE = 13;
 function readRepairFecPayloadIdFields(mmtpPacket, parsedHeader) {
@@ -987,49 +986,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) {
@@ -6264,6 +6235,14 @@ var throwRepairContractError = (code, path, message) => {
 };
 function readFecBlockProfile(value, path, declaresFecInstance, fail) {
   if (value === void 0 && !declaresFecInstance) return void 0;
+  if (isFecBlockProfile(value)) return value;
+  if (typeof value === "string" && value.length > 0) {
+    return fail(
+      "track_fec_block_profile_unimplemented",
+      path,
+      `${JSON.stringify(value)} is not an implemented FEC block profile; only "iso-ssbg1-v1" is implemented`
+    );
+  }
   try {
     return parseFecBlockProfile(value, "blockProfile");
   } catch (error) {
@@ -6574,12 +6553,17 @@ function hasSwitchingSetRole(names) {
     return suffix === "base" || suffix === "delta";
   });
 }
-function isFecCatalogConfig(obj) {
+function isFecCatalogGeometry(obj) {
   if (typeof obj !== "object" || obj === null) return false;
   const o = obj;
   const algorithm = o["algorithm"];
   const symbolSize = o["symbolSize"];
-  return typeof algorithm === "string" && (algorithm === "none" || algorithm === "raptorq" || algorithm === "reed-solomon") && typeof o["sourceSymbols"] === "number" && o["sourceSymbols"] >= 1 && typeof o["repairSymbols"] === "number" && o["repairSymbols"] >= 1 && typeof symbolSize === "number" && symbolSize >= 1 && (algorithm !== "raptorq" || symbolSize % 8 === 0) && typeof o["repairTrack"] === "string" && o["repairTrack"].length > 0 && (isFecBlockProfile(o["blockProfile"]) || algorithm === "none" && o["blockProfile"] === void 0);
+  return typeof algorithm === "string" && (algorithm === "none" || algorithm === "raptorq" || algorithm === "reed-solomon") && typeof o["sourceSymbols"] === "number" && o["sourceSymbols"] >= 1 && typeof o["repairSymbols"] === "number" && o["repairSymbols"] >= 1 && typeof symbolSize === "number" && symbolSize >= 1 && (algorithm !== "raptorq" || symbolSize % 8 === 0) && typeof o["repairTrack"] === "string" && o["repairTrack"].length > 0;
+}
+function isFecCatalogConfig(obj) {
+  if (!isFecCatalogGeometry(obj)) return false;
+  const o = obj;
+  return isFecBlockProfile(o["blockProfile"]) || o["algorithm"] === "none" && o["blockProfile"] === void 0;
 }
 function isMulticastTrackObject(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -6718,7 +6702,7 @@ function validateCmsfMmtpCatalog(value) {
   const tracks = catalog["tracks"];
   const trackRecords = [];
   const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
-  const positiveNumber = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
+  const positiveNumber2 = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
     const path = `$.tracks[${index}]`;
@@ -6763,7 +6747,7 @@ function validateCmsfMmtpCatalog(value) {
     if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber2(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
     if (packaging === "fec-repair") {
@@ -6811,8 +6795,8 @@ function validateCmsfMmtpCatalog(value) {
           "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
         );
       }
-      if (config["interleaveDepthMs"] !== void 0 && !positiveInteger2(config["interleaveDepthMs"])) {
-        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive integer");
+      if (config["interleaveDepthMs"] !== void 0 && (!Number.isSafeInteger(config["interleaveDepthMs"]) || config["interleaveDepthMs"] < 0)) {
+        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a non-negative safe integer");
       }
       if (algorithm !== "none") {
         for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
@@ -8689,7 +8673,6 @@ var CmafBlockAssembler = class {
       failedBlocks: 0
     };
     this.#config = {
-      k: config.k,
       timescale: config.timescale ?? 1e6,
       trackId: config.trackId ?? 1,
       trackType: config.trackType,
@@ -9518,49 +9501,6 @@ var TransportPool = class {
 };
 
 // ../fec/dist/block-processor.js
-function hasUniformPaddingFrom(data, start) {
-  if (start >= data.length)
-    return false;
-  const pad = data[start];
-  if (pad !== 0 && pad !== 238)
-    return false;
-  for (let i = start + 1; i < data.length; i++) {
-    if (data[i] !== pad)
-      return false;
-  }
-  return true;
-}
-function maybeExtendAltaTrailer(symbolData, packetEnd) {
-  if (packetEnd + MMTP_EXT_TRAILER_HEADER_SIZE2 > symbolData.length)
-    return packetEnd;
-  const view2 = new DataView(symbolData.buffer, symbolData.byteOffset + packetEnd, symbolData.byteLength - packetEnd);
-  const extType = view2.getUint16(0, false);
-  if (extType !== MMTP_EXT_TYPE_ALTA_AUTH2)
-    return packetEnd;
-  const extLen = view2.getUint16(2, false);
-  const trailerEnd = packetEnd + MMTP_EXT_TRAILER_HEADER_SIZE2 + extLen;
-  return trailerEnd <= symbolData.length ? trailerEnd : packetEnd;
-}
-function trimDecodedSourceSymbol(symbolData) {
-  if (symbolData.length < MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2)
-    return null;
-  const headerLength = parseMMTPHeader(symbolData).headerLength;
-  if (symbolData.length < headerLength + MPU_HEADER_SIZE2)
-    return null;
-  const payload = symbolData.subarray(headerLength);
-  const mpu = parseMPUHeader(payload);
-  const trailingMpuHeaderSize = MPU_HEADER_SIZE2 - 2;
-  if (mpu.payloadLength < trailingMpuHeaderSize)
-    return null;
-  const declaredEnd = headerLength + 2 + mpu.payloadLength;
-  if (declaredEnd > symbolData.length)
-    return null;
-  const packetEnd = maybeExtendAltaTrailer(symbolData, declaredEnd);
-  if (packetEnd < symbolData.length && !hasUniformPaddingFrom(symbolData, packetEnd)) {
-    return null;
-  }
-  return symbolData.subarray(0, packetEnd);
-}
 function emptyProcessResult() {
   return {
     symbols: [],
@@ -9624,17 +9564,6 @@ function parseProtectedPacket(packetData, hdr, index, bump) {
     rawSymbol: packetData
   };
 }
-function parseKPaddedSymbol(symbolData, index, bump) {
-  const hdr = gateMpuHeader(symbolData, bump);
-  if (!hdr)
-    return null;
-  const packetData = trimDecodedSourceSymbol(symbolData);
-  if (!packetData) {
-    bump("bad_length");
-    return null;
-  }
-  return parseProtectedPacket(packetData, hdr, index, bump);
-}
 function parseSsbg1Symbol(symbolData, index, bump) {
   const packetData = trimSsbg1SourceSymbol(symbolData);
   if (!packetData) {
@@ -9647,7 +9576,7 @@ function parseSsbg1Symbol(symbolData, index, bump) {
   return parseProtectedPacket(packetData, hdr, index, bump);
 }
 function processFecSymbol(symbolData, options) {
-  const blockProfile = parseFecBlockProfile(options?.blockProfile, "processFecSymbol options.blockProfile");
+  parseFecBlockProfile(options?.blockProfile, "processFecSymbol options.blockProfile");
   const failReasons = {};
   let failedCount = 0;
   const bump = (reason) => {
@@ -9659,26 +9588,26 @@ function processFecSymbol(symbolData, options) {
   const index = options.index ?? 0;
   let parsed;
   try {
-    parsed = blockProfile === "iso-ssbg1-v1" ? parseSsbg1Symbol(symbolData, index, bump) : parseKPaddedSymbol(symbolData, index, bump);
+    parsed = parseSsbg1Symbol(symbolData, index, bump);
   } catch {
     bump("exception");
     parsed = null;
   }
   return resultFromSymbols(parsed ? [parsed] : [], failedCount, failReasons, options.ownerPacketId);
 }
-function requireSymbolSize(symbolSize, blockProfile) {
+function requireSymbolSize(symbolSize) {
   if (symbolSize === void 0) {
     throw new Error("processFecBlock options.symbolSize is required: name the catalog fec.symbolSize (T)");
   }
   if (typeof symbolSize !== "number" || !Number.isSafeInteger(symbolSize) || symbolSize <= 0) {
     throw new Error(`processFecBlock options.symbolSize must be a positive integer (got ${String(symbolSize)})`);
   }
-  if (blockProfile === "iso-ssbg1-v1" && symbolSize <= SSBG1_LENGTH_FIELD_BYTES) {
+  if (symbolSize <= SSBG1_LENGTH_FIELD_BYTES) {
     throw new Error(`processFecBlock options.symbolSize must exceed the ${SSBG1_LENGTH_FIELD_BYTES}-byte ssbg_mode1 length field (got ${symbolSize})`);
   }
   return symbolSize;
 }
-function requireSourceSymbolCount(k, blockLength, symbolSize, blockProfile) {
+function requireSourceSymbolCount(k, blockLength, symbolSize) {
   if (k === void 0) {
     if (blockLength % symbolSize !== 0) {
       throw new Error(`processFecBlock: ${blockLength} bytes is not a whole number of ${symbolSize}-byte symbols; pass options.k`);
@@ -9688,17 +9617,17 @@ function requireSourceSymbolCount(k, blockLength, symbolSize, blockProfile) {
   if (!Number.isSafeInteger(k) || k <= 0) {
     throw new Error(`processFecBlock options.k must be a positive integer (got ${k})`);
   }
-  if (blockProfile === "iso-ssbg1-v1" && blockLength !== k * symbolSize) {
+  if (blockLength !== k * symbolSize) {
     throw new Error(`processFecBlock: an iso-ssbg1-v1 block of ${k} symbols of ${symbolSize} bytes is ${k * symbolSize} bytes (got ${blockLength})`);
   }
   return k;
 }
 function processFecBlock(blockData, options) {
   const blockProfile = parseFecBlockProfile(options?.blockProfile, "processFecBlock options.blockProfile");
-  const symbolSize = requireSymbolSize(options.symbolSize, blockProfile);
+  const symbolSize = requireSymbolSize(options.symbolSize);
   if (!blockData || blockData.length === 0)
     return emptyProcessResult();
-  const k = requireSourceSymbolCount(options.k, blockData.length, symbolSize, blockProfile);
+  const k = requireSourceSymbolCount(options.k, blockData.length, symbolSize);
   const failReasons = {};
   let failedCount = 0;
   const parsed = [];
@@ -9723,7 +9652,7 @@ function processFecBlock(blockData, options) {
 // ../fec/dist/oti.js
 function catalogFecInterleaveMs(fec) {
   const ms = fec?.interleaveDepthMs;
-  return typeof ms === "number" && ms > 0 && Number.isFinite(ms) ? ms : void 0;
+  return typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0 ? ms : void 0;
 }
 function deriveFecInterleaveDepth(interleaveDepthMs, mediaUnitDurationMs) {
   if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
@@ -9756,6 +9685,8 @@ function deriveFecRetentionBlocks(deliveryWindowMs, interleaveDepthMs) {
   throw new Error(`[FEC] retention of ${Math.ceil(deliveryWindowMs / interleaveDepthMs) + 1} blocks exceeds the 255 the decoder and the ISO/IEC 23008-1 AL-FEC signaling byte accept (deliveryWindowMs=${deliveryWindowMs}ms over interleaveDepthMs=${interleaveDepthMs}ms). Fix the catalog geometry: a span this short cannot carry a window this wide.`);
 }
 var MAX_FEC_RETENTION_BLOCKS = 255;
+var LOCAL_FEC_RETENTION_BLOCKS = 2;
+var LOCAL_FEC_TIMEOUT_MS = 500;
 function tryDeriveFecRetentionBlocks(deliveryWindowMs, interleaveDepthMs) {
   if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0))
     return void 0;
@@ -9777,7 +9708,7 @@ var NO_FEC_INSTANCE = /* @__PURE__ */ Symbol("no FEC instance");
 var FecBlockMapper = class {
   /** Media units (GOPs/frames) per FEC block, recovered with positive round-half-up semantics. */
   d;
-  /** K: source symbols per block (`k-padded-v1`) or the maximum SSB_length (`iso-ssbg1-v1`). */
+  /** K: the maximum SSB_length of a block (catalog `fec.sourceSymbols`). */
   k;
   /** Block time span (ms) — used as pacing threshold */
   interleaveDepthMs;
@@ -9803,21 +9734,14 @@ var FecBlockMapper = class {
     this.d = deriveFecInterleaveDepth(config.interleaveDepthMs, config.gopDurationMs);
   }
   /**
-   * The `k-padded-v1` locator: SS_ID → (SBN, ESI) with `SBN = floor(SS_ID / K)`
-   * and `ESI = SS_ID mod K`, for MMTP over multicast UDP where the Source FEC
-   * Payload ID carries SS_ID directly.
+   * SS_ID → (SBN, ESI). Only {@link NullBlockMapper} answers: a stream with an
+   * FEC instance is `iso-ssbg1-v1`, whose blocks are located by
+   * `(SS_Start, SSB_length)` range membership and never from SS_ID alone.
    *
-   * @throws under `iso-ssbg1-v1`, where a block is located by
-   *   `(SS_Start, SSB_length)` range membership and never from SS_ID alone
+   * @throws for every stream with an FEC instance
    */
-  fromSsId(ssId) {
-    if (this.blockProfile !== "k-padded-v1") {
-      throw new Error(`fromSsId is the k-padded-v1 locator; a ${this.blockProfile ?? "non-FEC"} stream locates a block by (SS_Start, SSB_length) range membership, never from SS_ID alone`);
-    }
-    return {
-      sbn: Math.floor(ssId / this.k),
-      esi: ssId % this.k
-    };
+  fromSsId(_ssId) {
+    throw new Error(`fromSsId: a ${this.blockProfile ?? "non-FEC"} stream locates a block by (SS_Start, SSB_length) range membership, never from SS_ID alone`);
   }
   /**
    * Pacing threshold: one full block duration = interleaveDepthMs.
@@ -9901,20 +9825,22 @@ function computeFecLossWindowMs(fecInterleaveMs, fecK, jitterBufferMs) {
   });
 }
 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);
 }
 function computeFecDeliveryWindowMediaUnits(config, timestampTimescale) {
   if (!Number.isFinite(timestampTimescale) || timestampTimescale <= 0) {
@@ -10075,6 +10001,10 @@ var TrackSession = class {
   /** multicast/amt → failing: loss detected, start hysteresis timer (Claim 9f). */
   lossDetected() {
     if (this.#state !== "multicast" && this.#state !== "amt") return;
+    if (this.config.fecInterleaveMs === 0 || this.config.fecInterleaveMs === void 0) {
+      this.transportFailed();
+      return;
+    }
     this.#previousPrimary = this.#state;
     this.#transition("failing");
     const hysteresisMs = computeFecLossWindowMs(
@@ -10881,7 +10811,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",
@@ -10908,7 +10838,7 @@ function isoBlockSpanUsable(fec) {
   const block = recordOf(fec);
   if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1") return true;
   const ms = block["interleaveDepthMs"];
-  return typeof ms === "number" && Number.isFinite(ms) && ms >= MIN_INTERLEAVE_DEPTH_MS;
+  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
 }
 function requireBoolean(value, field) {
   if (typeof value !== "boolean") {
@@ -11442,7 +11372,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.
@@ -11457,10 +11386,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();
@@ -11500,10 +11428,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;
@@ -11620,14 +11548,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).
@@ -11721,7 +11651,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;
@@ -11883,7 +11816,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) {
@@ -11919,8 +11853,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
@@ -11933,6 +11868,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}.`
@@ -11946,7 +11889,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
@@ -11986,6 +11929,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);
@@ -12018,19 +11964,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) {
@@ -12064,7 +12011,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;
@@ -12099,7 +12046,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;
     }
@@ -12255,7 +12202,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);
@@ -12335,6 +12282,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";
@@ -12356,8 +12304,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.
@@ -12366,27 +12314,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);
@@ -12395,7 +12344,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 });
       }
     };
@@ -12411,9 +12360,9 @@ var FECManager = class _FECManager {
       anchorHere();
       return;
     }
-    const config = this.#resolveTrackConfig(packetId);
+    const config = this.#trackConfig(packetId);
     const window2 = this.#liveWindowBlocks(config);
-    if (!this.#blockPrecedes(previous.sbn, sbn, packetId)) {
+    if (!this.#blockPrecedes(previous.sbn, sbn)) {
       if (symbol === "source" && window2 !== null && this.#blocksBehind(sbn, previous.sbn, packetId) > window2) {
         discontinuity();
         return;
@@ -12424,15 +12373,9 @@ var FECManager = class _FECManager {
     const missing = this.#blocksBehind(previous.sbn, sbn, packetId) - 1;
     let plausible = true;
     if (window2 !== 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 = window2 + 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 <= window2 + Math.ceil((now - previous.atMs) / config.interleaveDepthMs);
       }
@@ -12444,48 +12387,31 @@ var FECManager = class _FECManager {
     }
     this.#highestSbn.set(streamKey, { sbn, atMs: now });
     anchorHere();
-    if (this.#isIso(packetId)) return;
-    if (missing <= 0 || window2 === 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) <= window2
-      );
-    }
   }
   /*
-   * 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);
@@ -12524,21 +12450,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({
@@ -12563,14 +12507,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);
   }
   /**
@@ -12598,6 +12545,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;
@@ -12612,10 +12560,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);
@@ -12631,6 +12581,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) {
@@ -12717,51 +12668,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))) {
@@ -12776,20 +12748,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)];
@@ -12850,7 +12816,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
       };
@@ -12862,7 +12828,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,
@@ -13157,15 +13123,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);
@@ -13283,14 +13254,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 });
       }
     }
@@ -13301,25 +13272,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
@@ -13337,7 +13306,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
@@ -13393,27 +13363,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. */
@@ -13424,7 +13398,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. */
@@ -13435,14 +13410,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;
@@ -13473,12 +13453,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`);
     }
@@ -13486,7 +13468,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
@@ -13547,11 +13530,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.
    */
@@ -13619,6 +13602,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 };
   }
@@ -13628,10 +13612,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);
@@ -13653,7 +13639,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,
@@ -13669,27 +13655,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 });
       }
     }
@@ -13748,7 +13741,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) => {
@@ -13928,7 +13921,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);
   }
@@ -13969,16 +13962,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,
@@ -14010,35 +13998,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(
@@ -14061,7 +14042,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);
@@ -14080,7 +14061,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) {
@@ -14091,18 +14073,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);
@@ -14140,8 +14116,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);
@@ -14208,7 +14185,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 {
@@ -14253,11 +14230,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);
@@ -14301,6 +14280,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;
@@ -14310,13 +14290,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,
@@ -14386,6 +14366,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);
     }
@@ -15422,6 +15403,21 @@ var FecReleaseSequencer = class {
       this.#streams.delete(key);
     }
   }
+  /**
+   * The packet's FEC ended, so no block will resolve a held gap: release its
+   * frames in order, each gap stalled as a discontinuity, and forget its
+   * streams, so FEC configured on it again starts from a fresh one.
+   */
+  endPacket(packetId) {
+    for (const [key, stream] of this.#streams) {
+      if (stream.packetId !== packetId) continue;
+      while (stream.buf.length > 0 && stream.last !== null) {
+        stream.discontinuity = true;
+        this.#drain(stream);
+      }
+      this.#streams.delete(key);
+    }
+  }
   discardPacket(packetId) {
     for (const [key, stream] of this.#streams) {
       if (stream.packetId !== packetId) continue;
@@ -15804,6 +15800,13 @@ var MmtpContainerParser = class _MmtpContainerParser {
   markFecDiscontinuity(packetId, catalogTrackName) {
     this.#fecSequencer?.markDiscontinuity(this.#streamKey(packetId, catalogTrackName));
   }
+  /**
+   * The FEC of a packet ID ended: release the frames the FEC release gate
+   * holds for it in order, each gap stalled, and forget its gated streams.
+   */
+  endFecRelease(packetId) {
+    this.#fecSequencer?.endPacket(packetId);
+  }
   /**
    * MPU and data-unit identity of one MMTP packet, parsed in place (no copy,
    * no reassembly). Null for non-MPU packets and packets that do not parse.
@@ -17137,6 +17140,8 @@ var MmtpRouter = class {
    */
   #onPublisherRestart;
   #publisherRestarts = 0;
+  /** Inits delivered with no onTrackInit handler for their packetId (MOQT-01). */
+  #unmappedInitDeliveries = 0;
   // FEC Payload IDs left unread because their (owner) packetId had no
   // configured fec.blockProfile (see #noteUnreadableFecPayloadId).
   #fecPayloadIdsWithoutProfile = 0;
@@ -17333,15 +17338,24 @@ var MmtpRouter = class {
       return NO_FEC_GEOMETRY_HORIZON;
     }
     const blockSpanMs = fec.interleaveDepthMsForPacket(packetId);
+    const blockLifetimeMs = fec.blockLifetimeMsForPacket(packetId);
+    if (blockSpanMs === void 0 || blockLifetimeMs === void 0) return NO_FEC_GEOMETRY_HORIZON;
     if (blockSpanMs === 0) return NO_BLOCK_SPAN_HORIZON;
     return {
       kind: "fec-horizon",
-      retentionMs: duplicateRetentionMs({
-        blockSpanMs,
-        blockLifetimeMs: fec.blockLifetimeMsForPacket(packetId)
-      })
+      retentionMs: duplicateRetentionMs({ blockSpanMs, blockLifetimeMs })
     };
   }
+  /**
+   * Init segments delivered for a packetId with no `onTrackInit` handler
+   * since construction, whether the deprecated aggregate `onInitSegment`
+   * callback then received them or nothing did. A supported deployment reads
+   * 0 here; a non-zero value is the evidence that blocks removing the
+   * aggregate callback (MOQT-01, BLO-21181).
+   */
+  get unmappedInitDeliveryCount() {
+    return this.#unmappedInitDeliveries;
+  }
   /** Publisher restarts detected on the multicast leg since construction. */
   get publisherRestartCount() {
     return this.#publisherRestarts;
@@ -17429,7 +17443,7 @@ var MmtpRouter = class {
   /** Update MFU reassembly timeout. Source and FEC-recovery paths share the
    *  parser's single reassembler (BLO-8151), so one update covers both. */
   setMfuTimeoutMs(ms) {
-    if (ms <= 0) throw new Error("[MmtpRouter] mfuTimeoutMs must be > 0");
+    if (ms !== null && ms <= 0) throw new Error("[MmtpRouter] mfuTimeoutMs must be > 0");
     this.#parser.setMfuTimeoutMs(ms);
   }
   /** Update parser frame reordering for unordered multicast delivery.
@@ -17499,7 +17513,15 @@ var MmtpRouter = class {
   onTrackPacket(packetId, cb) {
     this.#trackPacketCallbacks.set(packetId, cb);
   }
-  /** Register an init segment callback (ftyp+moov from MMTP MPU metadata). */
+  /**
+   * Register an init segment callback (ftyp+moov from MMTP MPU metadata).
+   * Receives an init only for a packetId with no `onTrackInit` handler.
+   *
+   * @deprecated Use onTrackInit(packetId, cb). Still delivered as a fallback;
+   * removed in the 1.0.0 major, no earlier than one minor release after this
+   * deprecation reaches the `latest` dist-tag (BLO-21181). Count fallback
+   * deliveries with `unmappedInitDeliveryCount`.
+   */
   onInitSegment(cb) {
     this.#onInitSegment = cb;
   }
@@ -17513,17 +17535,16 @@ var MmtpRouter = class {
    *  When active, source frames are buffered per FEC block and emitted as
    *  multi-sample CMAF segments instead of per-frame callbacks. */
   enableMseAssembler(packetId, config, catalogTrackName) {
-    const k = this.#kForPacket(packetId);
     const assemblerKey = this.#mseAssemblerKey(packetId, catalogTrackName);
     const previous = this.#mseAssemblers.get(assemblerKey);
     if (previous) {
       previous.flush();
       previous.dispose();
     }
-    const assembler = new CmafBlockAssembler({ ...config, k });
+    const assembler = new CmafBlockAssembler(config);
     this.#mseAssemblers.set(assemblerKey, assembler);
     console.log(
-      `[MmtpRouter] MSE assembler enabled for packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`} (K=${k}, ${config.trackType})`
+      `[MmtpRouter] MSE assembler enabled for packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`} (${config.trackType})`
     );
     return assembler;
   }
@@ -17632,6 +17653,21 @@ var MmtpRouter = class {
     }
     this.#fecMappersByPacketId.set(packetId, mapper);
   }
+  /**
+   * Release the router side of a packetId whose FEC is ending: drop its block
+   * mapper and end its FEC release gating. Frames the gate holds are released
+   * in order, each gap stalled (no block will resolve it), not stranded. Call
+   * before FECManager.releasePacket, while the gate can still read its blocks.
+   */
+  releaseFecPacket(packetId) {
+    this.#fecMappersByPacketId.delete(packetId);
+    this.#withDeferredFecPokes(() => {
+      this.#parser.endFecRelease(packetId);
+      for (const [key, poke] of this.#pendingFecPokes) {
+        if (poke.packetId === packetId) this.#pendingFecPokes.delete(key);
+      }
+    });
+  }
   registerManifestTrack(context) {
     if (!this.#manifestVerifier) throw new Error("manifest verifier is not configured");
     this.#manifestVerifier.registerTrack(context);
@@ -17751,87 +17787,21 @@ var MmtpRouter = class {
         this.#noteUnreadableFecPayloadId(ownerPacketId, "repair");
         return;
       }
-      if (this.#isIsoPacket(ownerPacketId)) {
-        this.#handleIsoRepair(ownerPacketId, catalogTrackName, parsed, "moq");
-        return;
-      }
-      const repairSbn = this.#deriveRepairSbn(parsed.ssStart, parsed.ssbLength, ownerPacketId);
-      if (repairSbn === null) return;
-      const repairEsi = this.#kForPacket(ownerPacketId) + parsed.rsId;
-      if (!this.#feedFecTransportSymbol(
-        ownerPacketId,
-        repairSbn,
-        repairEsi,
-        parsed.symbolData,
-        "moq",
-        catalogTrackName
-      )) return;
-      const recovered = catalogTrackName === void 0 ? this.#fecManager.feedRepairSymbol(
-        ownerPacketId,
-        parsed.ssStart,
-        parsed.ssbLength,
-        parsed.rsId,
-        parsed.symbolData
-      ) : this.#fecManager.feedRepairSymbol(
-        ownerPacketId,
-        parsed.ssStart,
-        parsed.ssbLength,
-        parsed.rsId,
-        parsed.symbolData,
-        catalogTrackName
-      );
-      if (recovered) {
-        const alreadyCompleted = catalogTrackName === void 0 ? this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId) : this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId, catalogTrackName);
-        if (catalogTrackName === void 0) {
-          this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId);
-        } else {
-          this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId, catalogTrackName);
-        }
-        if (!alreadyCompleted) {
-          this.#fecManager.countRecovery(ownerPacketId, repairSbn, catalogTrackName);
-          if (catalogTrackName === void 0) {
-            this.#fecManager.markBlockCompleted(repairSbn, ownerPacketId);
-          } else {
-            this.#fecManager.markBlockCompleted(repairSbn, ownerPacketId, catalogTrackName);
-          }
-          this.#routeRecoveredBlock(
-            repairSbn,
-            recovered,
-            ownerPacketId,
-            catalogTrackName
-          );
-        }
-      }
+      this.#handleIsoRepair(ownerPacketId, catalogTrackName, parsed, "moq");
     }
   }
-  // ── SBN/ESI derivation ──────────────────────────────────────────
-  #kForPacket(packetId) {
-    if (packetId != null)
-      return this.#fecManager?.kForPacket?.(packetId) ?? this.#fecMappersByPacketId.get(packetId)?.k ?? this.#fecManager?.k ?? 4;
-    return this.#defaultFecMapper?.k ?? this.#fecManager?.k ?? 4;
-  }
+  // ── Packet FEC geometry and block profile ───────────────────────
   #symbolSizeForPacket(packetId) {
-    if (packetId != null) return this.#fecManager?.symbolSizeForPacket?.(packetId) ?? this.#fecManager?.symbolSize ?? 0;
+    if (packetId != null) return this.#fecManager?.symbolSizeForPacket?.(packetId) ?? 0;
     return this.#fecManager?.symbolSize ?? 0;
   }
-  /** Derive SBN/ESI from SS_ID using packet-scoped FEC geometry. */
-  #deriveSbnEsi(ssId, packetId) {
-    const mapper = packetId == null ? this.#defaultFecMapper : this.#fecMappersByPacketId.get(packetId) ?? null;
-    if (mapper) return mapper.fromSsId(ssId);
-    const k = this.#kForPacket(packetId);
-    return { sbn: Math.floor(ssId / k), esi: ssId % k };
-  }
-  #deriveRepairSbn(ssStart, ssbLength, packetId) {
-    const k = this.#kForPacket(packetId);
-    if (ssbLength <= 0 || ssbLength > k || ssStart % k !== 0) return null;
-    return Math.floor(ssStart / k);
-  }
   /**
    * The configured block profile of a packetId, or undefined while it is
    * unconfigured. With an FEC manager its per-packet configuration is the
    * only source. A router without one still recovers symbols through its
    * registered mapper, built with the catalog's explicit profile: the
-   * packet's own mapper, else the default one (the #deriveSbnEsi rule).
+   * packet's own mapper, else the default one. A NullBlockMapper (a stream
+   * without an FEC instance) states none.
    */
   #configuredBlockProfile(packetId) {
     if (this.#fecManager) return this.#fecManager.blockProfileForPacket(packetId);
@@ -17839,9 +17809,10 @@ var MmtpRouter = class {
     return mapper?.blockProfile ?? void 0;
   }
   /**
-   * The block profile an FEC coordinate of `packetId` is read under. Throws
-   * while none is configured: the two profiles carry identical wire tuples
-   * with different block math, so there is no default to fall back to.
+   * The block profile an FEC coordinate of `packetId` is read under:
+   * `iso-ssbg1-v1`, the only one (`k-padded-v1` is retired and refused).
+   * Throws while none is configured: such a packet has no FEC geometry, and
+   * nothing is inferred from the wire or defaulted.
    * Packet ingress leaves such a packet's FEC Payload ID unread first
    * (#noteUnreadableFecPayloadId); a throw here is a wiring fault on a path
    * that cannot hold an unconfigured packet.
@@ -17855,8 +17826,16 @@ var MmtpRouter = class {
     }
     return profile;
   }
-  #isIsoPacket(packetId) {
-    return this.#blockProfileFor(packetId) === "iso-ssbg1-v1";
+  /**
+   * The block coordinates (SS_Start, ESI) of an FEC source: range membership
+   * in a block a repair already stated (ISO/IEC 23008-1 C.5.3). Null while no
+   * repair has stated its block, while its packetId has no configured block
+   * profile, and without an FEC manager: SS_ID alone locates no block, so
+   * nothing is derived from it.
+   */
+  #locateFecSource(packetId, catalogTrackName, ssId) {
+    if (this.#configuredBlockProfile(packetId) === void 0) return null;
+    return this.#fecManager?.locateIsoSource?.(packetId, catalogTrackName, ssId) ?? null;
   }
   /**
    * Explicit refusal to read an FEC Payload ID: its (owner) packetId has no
@@ -17875,21 +17854,20 @@ var MmtpRouter = class {
     }
   }
   /**
-   * The release-gate anchor of a recovered symbol: its block (SBN) under
-   * k-padded-v1, its own SS_ID under iso-ssbg1-v1, where a frame is gated by
-   * the SS_IDs between it and the last released frame.
+   * The release-gate anchor of a recovered symbol: its own SS_ID, SS_Start +
+   * ESI modulo 2^32 (C.5.2), where a frame is gated by the SS_IDs between it
+   * and the last released frame.
    */
-  #fecAnchorForRecovered(ownerPacketId, blockId, index) {
-    return ownerPacketId !== void 0 && this.#isIsoPacket(ownerPacketId) ? serial32Add(blockId, index) : blockId;
+  #fecAnchorForRecovered(blockStart, index) {
+    return serial32Add(blockStart, index);
   }
   /**
    * One iso-ssbg1-v1 repair symbol (ISO/IEC 23008-1 C.5.3). It states the
    * block `[SS_Start, SS_Start + SSB_length)`; repair ESI = SSB_length +
    * RS_ID (K' = SSB_length). The held sources it placed (and those of a
    * repair-less span in front of it) are fed as first-arrival sources, then
-   * the repair, the order they had on the wire, so a loss-free block is clean
-   * on its repair exactly as under k-padded-v1. A repair contradicting a known
-   * block is dropped.
+   * the repair, the order they had on the wire, so a loss-free block completes
+   * clean on its repair. A repair contradicting a known block is dropped.
    */
   #handleIsoRepair(ownerPacketId, catalogTrackName, repair, source) {
     const fec = this.#fecManager;
@@ -17981,7 +17959,8 @@ var MmtpRouter = class {
     return null;
   }
   /** Route a recovered FEC block through the parser + dedup pipeline.
-   *  Sync WASM decoders return K fixed-width source symbols concatenated. */
+   *  Sync WASM decoders return the block's K' = SSB_length fixed-width
+   *  ssbg_mode1 source symbols concatenated. */
   routeRecoveredBlock(blockId, data, packetId, catalogTrackName) {
     this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName);
   }
@@ -18449,29 +18428,19 @@ var MmtpRouter = class {
       resolvedLoss: (packetId, catalogTrackName, fromSbn, toSbn, releasedSbn) => {
         const fec = this.#fecManager;
         if (!fec?.blockResolution) return [];
-        if (this.#isIsoPacket(packetId)) {
-          const head = fromSbn === releasedSbn ? toSbn : fromSbn;
-          return fec.isoSpanResolution?.(packetId, catalogTrackName, releasedSbn, head) ?? null;
-        }
-        const highest = fec.highestSbn?.(packetId, catalogTrackName);
-        const lost = [];
-        for (let sbn = fromSbn; sbn <= toSbn; sbn++) {
-          const resolution = fec.blockResolution(sbn, packetId, catalogTrackName);
-          if (resolution === "pending") return null;
-          if (resolution === "failed") {
-            lost.push(sbn);
-          } else if (resolution === "untracked") {
-            if (sbn === releasedSbn) continue;
-            if (highest === void 0 || sbn > highest) return null;
-            lost.push(sbn);
-          }
-        }
-        return lost;
+        const head = fromSbn === releasedSbn ? toSbn : fromSbn;
+        return fec.isoSpanResolution?.(packetId, catalogTrackName, releasedSbn, head) ?? null;
       },
       // The retention window itself: a frame is never still held when a block
       // it waits on retires. Only consulted while resolvedLoss holds a gap,
       // which needs blockResolution, so the check above guarantees the method.
-      holdLimitMs: (packetId) => this.#fecManager?.terminalRetentionMsForPacket?.(packetId) ?? Infinity,
+      // A packetId the manager no longer has configured (released) has no
+      // block left to wait on: release its frames now (BLO-45953).
+      holdLimitMs: (packetId) => {
+        const fec = this.#fecManager;
+        if (!fec?.terminalRetentionMsForPacket) return Infinity;
+        return fec.terminalRetentionMsForPacket(packetId) ?? 0;
+      },
       decide: (before, after, lostBlocks, discontinuity) => {
         const decision = this.#decideGap(before, after, lostBlocks, discontinuity);
         this.#onFrameGap?.(decision);
@@ -18533,9 +18502,10 @@ var MmtpRouter = class {
   }
   /**
    * The most media units a gap between two released frames can hold: the
-   * FEC blocks from `before`'s SBN to `after`'s, times D, the media units one
-   * block touches (ceil(interleaveDepthMs / unit duration), §5.1). Null when
-   * either SBN, the unit duration or the catalog interleave is unknown.
+   * FEC blocks between `before`'s anchor and `after`'s, times D, the media
+   * units one block touches (ceil(interleaveDepthMs / unit duration), §5.1).
+   * Null when either anchor, the unit duration or the catalog interleave is
+   * unknown.
    */
   #maxMissingUnits(before, after) {
     const from = before.fecSbn;
@@ -18548,7 +18518,7 @@ var MmtpRouter = class {
     const denominator = BigInt(timing.durationTicks) * 1000n;
     const unitsPerBlock = (numerator + denominator - 1n) / denominator;
     const blocks = BigInt(
-      (this.#isIsoPacket(after.packetId) ? serial32Precedes(from, to) ? serial32Distance(from, to) : serial32Distance(to, from) : Math.abs(to - from)) + 1
+      (serial32Precedes(from, to) ? serial32Distance(from, to) : serial32Distance(to, from)) + 1
     );
     const bound = unitsPerBlock * blocks;
     return bound > BigInt(Number.MAX_SAFE_INTEGER) ? null : Number(bound);
@@ -18598,8 +18568,9 @@ var MmtpRouter = class {
     const cb = this.#trackInitCallbacks.get(packetId);
     if (cb) {
       cb(data);
-    } else if (this.#onInitSegment) {
-      this.#onInitSegment(data);
+    } else {
+      this.#unmappedInitDeliveries++;
+      this.#onInitSegment?.(data);
     }
     console.log(
       `[MmtpRouter] Init delivered for packetId=${packetId}${catalogTrackName === void 0 ? "" : ` track=${catalogTrackName}`} (${data.byteLength}B)`
@@ -18641,9 +18612,9 @@ var MmtpRouter = class {
     if (!info.isRepair && this.#manifestVerifier && !manifestAdmitted) {
       let identity = manifestIdentity;
       if (!identity && info.fecPayloadId && !fecUnreadable && (this.#resolveManifestIdentityForRoute || this.#resolveManifestIdentity)) {
-        const coordinates = this.#deriveSbnEsi(info.fecPayloadId.ssId, info.packetId);
         const catalogTrackName = catalogTrackNameForPacket(ingress, info.packetId);
-        identity = (this.#resolveManifestIdentityForRoute ? this.#resolveManifestIdentityForRoute({
+        const coordinates = this.#locateFecSource(info.packetId, catalogTrackName, info.fecPayloadId.ssId);
+        identity = coordinates === null ? void 0 : (this.#resolveManifestIdentityForRoute ? this.#resolveManifestIdentityForRoute({
           packetId: info.packetId,
           sbn: coordinates.sbn,
           esi: coordinates.esi,
@@ -18695,79 +18666,7 @@ var MmtpRouter = class {
           this.#noteUnreadableFecPayloadId(ownerPacketId, "repair");
           return;
         }
-        if (this.#isIsoPacket(ownerPacketId)) {
-          this.#handleIsoRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair, source);
-          return;
-        }
-        const repairSbn = this.#deriveRepairSbn(repair.ssStart, repair.ssbLength, ownerPacketId);
-        if (repairSbn === null) return;
-        const repairEsi = this.#kForPacket(ownerPacketId) + repair.rsId;
-        if (!this.#feedFecTransportSymbol(
-          ownerPacketId,
-          repairSbn,
-          repairEsi,
-          repair.symbolData,
-          source,
-          catalogTrackNameForPacket(ingress, ownerPacketId)
-        )) return;
-        const repairCatalogTrackName = catalogTrackNameForPacket(ingress, ownerPacketId);
-        if (repairCatalogTrackName === void 0) {
-          this.#fecManager.noteBlockActivity?.(repairSbn, ownerPacketId);
-        } else {
-          this.#fecManager.noteBlockActivity?.(
-            repairSbn,
-            ownerPacketId,
-            repairCatalogTrackName
-          );
-        }
-        const recovered = repairCatalogTrackName === void 0 ? this.#fecManager.feedRepairSymbol(
-          ownerPacketId,
-          repair.ssStart,
-          repair.ssbLength,
-          repair.rsId,
-          repair.symbolData
-        ) : this.#fecManager.feedRepairSymbol(
-          ownerPacketId,
-          repair.ssStart,
-          repair.ssbLength,
-          repair.rsId,
-          repair.symbolData,
-          repairCatalogTrackName
-        );
-        if (recovered) {
-          const alreadyCompleted = repairCatalogTrackName === void 0 ? this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId) : this.#fecManager.isBlockCompleted(
-            repairSbn,
-            ownerPacketId,
-            repairCatalogTrackName
-          );
-          if (repairCatalogTrackName === void 0) {
-            this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId);
-          } else {
-            this.#fecManager.cancelBlockTimeout(
-              repairSbn,
-              ownerPacketId,
-              repairCatalogTrackName
-            );
-          }
-          if (!alreadyCompleted) {
-            this.#fecManager.countRecovery(ownerPacketId, repairSbn, repairCatalogTrackName);
-            if (repairCatalogTrackName === void 0) {
-              this.#fecManager.markBlockCompleted(repairSbn, ownerPacketId);
-            } else {
-              this.#fecManager.markBlockCompleted(
-                repairSbn,
-                ownerPacketId,
-                repairCatalogTrackName
-              );
-            }
-            this.#routeRecoveredBlock(
-              repairSbn,
-              recovered,
-              ownerPacketId,
-              catalogTrackNameForPacket(ingress, ownerPacketId)
-            );
-          }
-        }
+        this.#handleIsoRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair, source);
       }
     } else {
       if (this.#classifyPacketId(info.packetId) === null) return;
@@ -18791,8 +18690,8 @@ var MmtpRouter = class {
       }
       const duplicates = this.#stream(info.packetId, catalogTrackName).duplicates;
       const fecPayloadId = fecUnreadable ? null : info.fecPayloadId;
-      const isoSource = this.#fecManager !== null && fecPayloadId != null && this.#isIsoPacket(info.packetId);
-      const coords = this.#fecManager && fecPayloadId ? isoSource ? this.#fecManager.locateIsoSource?.(info.packetId, catalogTrackName, fecPayloadId.ssId) ?? void 0 : this.#deriveSbnEsi(fecPayloadId.ssId, info.packetId) : void 0;
+      const fecSource = this.#fecManager !== null && fecPayloadId != null;
+      const coords = fecSource && fecPayloadId ? this.#locateFecSource(info.packetId, catalogTrackName, fecPayloadId.ssId) ?? void 0 : void 0;
       duplicates.advance(coords?.sbn);
       if (source === "multicast" && !overlapCopy && !releasedFromQuarantine && catalogTrackName !== void 0 && duplicates.predatesHorizon(info.sequenceNumber, fecPayloadId?.ssId)) {
         this.#publisherRestarts++;
@@ -18807,9 +18706,8 @@ var MmtpRouter = class {
       }
       if (this.#fecManager && fecPayloadId && coords) {
         const fecId = fecPayloadId;
-        const symbolSize = this.#symbolSizeForPacket(info.packetId);
         const rawSymbol = packet.subarray(0, packet.length - 4);
-        const oversized = isoSource ? !(this.#fecManager.isoSourceFits?.(info.packetId, rawSymbol.length) ?? false) : symbolSize > 0 && rawSymbol.length > symbolSize;
+        const oversized = !(this.#fecManager.isoSourceFits?.(info.packetId, rawSymbol.length) ?? false);
         let overlapBlockCompleted = false;
         if (overlapCopy) {
           overlapBlockCompleted = catalogTrackName === void 0 ? this.#fecManager.isBlockCompleted(coords.sbn, info.packetId) : this.#fecManager.isBlockCompleted(
@@ -18844,7 +18742,7 @@ var MmtpRouter = class {
         }
         parseSourceSymbol = (overlapCopy ? !overlapBlockCompleted : sourceSymbolAccepted) && !duplicates.parsedSymbols.has(fecId.ssId);
         fecInfo = { sbn: coords.sbn, esi: coords.esi, oversized };
-      } else if (isoSource && this.#fecManager && fecPayloadId) {
+      } else if (fecSource && this.#fecManager && fecPayloadId) {
         const ssId = fecPayloadId.ssId;
         if (overlapCopy) {
           parseSourceSymbol = !duplicates.parsedSymbols.has(ssId);
@@ -18878,12 +18776,13 @@ var MmtpRouter = class {
         this.#feedViaParser(packet, info, fecInfo, {
           source,
           catalogTrackName,
-          ...isoSource && info.fecPayloadId ? { fecSbn: info.fecPayloadId.ssId } : fecInfo === void 0 ? {} : { fecSbn: fecInfo.sbn }
+          // An FEC source frame is anchored by its own SS_ID (C.5.2).
+          ...fecSource && fecPayloadId ? { fecSbn: fecPayloadId.ssId } : {}
         }, parsed);
       }
       if (this.#classifyPacketId(info.packetId) === null) return;
-      if (this.#fecManager && fecPayloadId && sourceSymbolAccepted && sourceSymbolTrackable) {
-        const { sbn, esi } = isoSource && coords ? coords : this.#deriveSbnEsi(fecPayloadId.ssId, info.packetId);
+      if (this.#fecManager && fecPayloadId && coords && sourceSymbolAccepted && sourceSymbolTrackable) {
+        const { sbn, esi } = coords;
         if (this.#classifyPacketId(info.packetId) !== null && this.#fecManager.isTrackConfigured?.(info.packetId) !== false) {
           this.#fecManager.trackBlock(
             sbn,
@@ -19317,7 +19216,6 @@ var MmtpRouter = class {
   // ── Private: FEC recovery routing ───────────────────────────────
   /** Route WASM-recovered block through appropriate path based on container kind. */
   #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName) {
-    const k = this.#kForPacket(ownerPacketId);
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === void 0) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -19330,7 +19228,6 @@ var MmtpRouter = class {
     }
     const symbolSize = packetSymbolSize;
     const result = processFecBlock(recovered, {
-      ...blockProfile === "k-padded-v1" ? { k } : {},
       symbolSize,
       ownerPacketId,
       blockProfile
@@ -19410,8 +19307,7 @@ var MmtpRouter = class {
       const admission = verifier.admitObject(
         {
           ...identity,
-          packetId: ownerPacketId,
-          ...ownerPacketId !== void 0 && this.#isIsoPacket(ownerPacketId) ? {} : { ssId: blockId * this.#kForPacket(ownerPacketId) + symbol.index }
+          packetId: ownerPacketId
         },
         symbol.rawSymbol,
         () => {
@@ -19514,7 +19410,7 @@ var MmtpRouter = class {
               rapFlag: sym.fragment.rapFlag,
               recovered: true,
               deliveryProvenance,
-              fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+              fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
               ...catalogTrackName === void 0 ? {} : { catalogTrackName }
             });
             continue;
@@ -19626,7 +19522,7 @@ var MmtpRouter = class {
                 rapFlag: assembled.rapFlag,
                 recovered: true,
                 ...assembled.deliveryProvenance === void 0 ? {} : { deliveryProvenance: assembled.deliveryProvenance },
-                fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+                fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
                 ...recoveredCatalogTrackName === void 0 ? {} : { catalogTrackName: recoveredCatalogTrackName }
               });
               continue;
@@ -19763,7 +19659,7 @@ var MmtpRouter = class {
             rapFlag: sym.fragment.rapFlag,
             recovered: true,
             deliveryProvenance,
-            fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+            fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
             ...catalogTrackName === void 0 ? {} : { catalogTrackName }
           });
         } else {
@@ -19842,7 +19738,7 @@ var MmtpRouter = class {
               rapFlag: assembled.rapFlag,
               recovered: true,
               deliveryProvenance,
-              fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+              fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
               ...assembled.catalogTrackName === void 0 ? {} : { catalogTrackName: assembled.catalogTrackName }
             });
           }
@@ -19877,7 +19773,7 @@ var MmtpRouter = class {
             ...sym.fragment.sampleNumber === void 0 ? {} : { sampleNumber: sym.fragment.sampleNumber },
             recovered: true,
             deliveryProvenance,
-            fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+            fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
             ...catalogTrackName === void 0 ? {} : { catalogTrackName }
           });
           continue;
@@ -20225,22 +20121,22 @@ var MoqFecAlgorithm;
   MoqFecAlgorithm2[MoqFecAlgorithm2["RaptorQ"] = 2] = "RaptorQ";
 })(MoqFecAlgorithm || (MoqFecAlgorithm = {}));
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-alta-parse/dist/index.js
+// node_modules/@blockcast/mmt-alta-parse/dist/index.js
 var MPU_HEADER_SIZE3 = 8;
 var MPU_LENGTH_FIELD_SIZE3 = 2;
 var MPU_HEADER_REMAINDER_SIZE3 = MPU_HEADER_SIZE3 - MPU_LENGTH_FIELD_SIZE3;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/mmtp.js
+// node_modules/@blockcast/mmt-base/dist/mmtp.js
 var MPU_HEADER_SIZE4 = 8;
 var MPU_LENGTH_FIELD_SIZE4 = 2;
 var MPU_HEADER_REMAINDER_SIZE4 = MPU_HEADER_SIZE4 - MPU_LENGTH_FIELD_SIZE4;
 var MMTP_SIGNALING_PACKET_ID2 = 0;
 var MMTP_PACKET_ID_MAX2 = 65535;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/net-constants.js
+// node_modules/@blockcast/mmt-base/dist/net-constants.js
 var DEFAULT_AMT_RELAY_PORT2 = 2268;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/ntp-short.js
+// node_modules/@blockcast/mmt-base/dist/ntp-short.js
 var NTP_SHORT_BITS2 = 32;
 var NTP_SHORT_MODULUS2 = 2 ** NTP_SHORT_BITS2;
 var NTP_SHORT_HALF_RANGE2 = 2 ** (NTP_SHORT_BITS2 - 1);
@@ -20261,9 +20157,8 @@ function compareNtpShort(a, b) {
   return "unordered";
 }
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
+// node_modules/@blockcast/mmt-base/dist/fec-block-profile.js
 var FEC_BLOCK_PROFILES2 = Object.freeze([
-  "k-padded-v1",
   "iso-ssbg1-v1"
 ]);
 
@@ -20655,10 +20550,12 @@ var MulticastOrchestrator = class {
   }
   onGoodput(sample) {
     const bitrate = sample.bitrate;
-    if (!this.#current || this.options.adaptive === false)
+    if (!this.#current)
       return void 0;
     if (this.#state === "joining")
       return this.poll();
+    if (this.options.adaptive === false)
+      return void 0;
     if (bitrate === void 0 || !Number.isFinite(bitrate))
       return void 0;
     this.#estimate = bitrate;
@@ -20725,6 +20622,27 @@ var MulticastOrchestrator = class {
     this.#favored = void 0;
     return { kind: "join-target", current: this.#current, target: desired };
   }
+  /**
+   * Join `target` because the viewer selected it, not because goodput or
+   * headroom ranked it. It runs whether or not the orchestrator adapts, and
+   * takes the path an adaptive join takes: commit on the target's RAP at or
+   * beyond the high-water mark, abandon at the join deadline. While it is
+   * pending nothing re-ranks the ladder; goodput only advances the deadline.
+   *
+   * Returns undefined, changing nothing, while another join is pending (cancel
+   * it first), when `target` is the current tier, or when it carries no media.
+   */
+  select(target) {
+    if (!this.#current || this.#state === "joining" || !carriesMedia(target))
+      return void 0;
+    if (endpointKey(target) === endpointKey(this.#current))
+      return void 0;
+    this.#state = "joining";
+    this.#target = target;
+    this.#joinStartedAt = this.#now();
+    this.#favored = void 0;
+    return { kind: "join-target", current: this.#current, target };
+  }
   /**
    * Feed a packet from the active tier (to advance the high-water mark) or
    * from the in-flight target (to find a committable RAP).
@@ -21764,7 +21682,7 @@ var MulticastTransport = class _MulticastTransport {
   // inside the window, instead of a clear+set pair on every packet.
   #watchdog = null;
   #lastPacketAtMs = 0;
-  #failbackWindowMs = null;
+  #failbackWindowMs;
   #onTakeover = null;
   #onFailback = null;
   // Data-plane-live edge: the first packet this join accepted. Everything
@@ -22069,14 +21987,20 @@ var MulticastTransport = class _MulticastTransport {
     return this.#dataPlaneLive;
   }
   setFailbackWindowMs(windowMs) {
-    if (!Number.isFinite(windowMs) || windowMs <= 0) {
+    if (windowMs !== null && (!Number.isFinite(windowMs) || windowMs <= 0)) {
       throw new Error(
         `[MulticastTransport] failbackWindowMs=${windowMs}. Derive a positive failback window from the stream catalog.`
       );
     }
     this.#failbackWindowMs = windowMs;
-    if (this.#watchdog !== null) {
-      clearTimeout(this.#watchdog);
+    if (windowMs === null) {
+      if (this.#watchdog !== null) clearTimeout(this.#watchdog);
+      this.#watchdog = null;
+      return;
+    }
+    if (this.#watchdog !== null) clearTimeout(this.#watchdog);
+    this.#watchdog = null;
+    if (this.#dataPlaneLive && this.#onFailback) {
       const silentMs = performance.now() - this.#lastPacketAtMs;
       this.#armWatchdog(Math.max(0, Math.ceil(windowMs - silentMs)));
     }
@@ -22402,7 +22326,8 @@ var MulticastTransport = class _MulticastTransport {
     }
     if (this.#watchdog !== null) return;
     if (!this.#onFailback) return;
-    if (this.#failbackWindowMs === null) {
+    if (this.#failbackWindowMs === null) return;
+    if (this.#failbackWindowMs === void 0) {
       throw new Error(
         "[MulticastTransport] Failback watchdog requires a catalog-derived window"
       );
@@ -22412,7 +22337,7 @@ var MulticastTransport = class _MulticastTransport {
   #armWatchdog(delayMs) {
     this.#watchdog = setTimeout(() => {
       this.#watchdog = null;
-      if (this.#disposed || !this.#onFailback || this.#failbackWindowMs === null) return;
+      if (this.#disposed || !this.#onFailback || this.#failbackWindowMs == null) return;
       const silentMs = performance.now() - this.#lastPacketAtMs;
       if (silentMs < this.#failbackWindowMs) {
         this.#armWatchdog(Math.ceil(this.#failbackWindowMs - silentMs));
@@ -22452,18 +22377,320 @@ function catalogAmtNetworkSource(networkSource) {
   return void 0;
 }
 
-// src/multicast-manager.ts
-function freezeIngress(tracks) {
-  return Object.freeze({
-    tracks: Object.freeze(
-      [...tracks].map(({ name, packetId }) => Object.freeze({ name, packetId }))
-    )
-  });
+// src/catalog-fec-params.ts
+var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
+function timescaleHz(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
 }
-function sameIdSet(a, b) {
-  if (a.size !== b.size) return false;
-  for (const id of a) if (!b.has(id)) return false;
-  return true;
+function catalogGroupDurationMs(rendition) {
+  if (!rendition) return void 0;
+  const ticks = numericField(rendition.groupDurationTicks);
+  const ms = numericField(rendition.groupDurationMs);
+  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
+  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
+    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
+  }
+  return ms;
+}
+function resolveCatalogTrackGroupDurationMs(catalog, track) {
+  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
+  return catalogGroupDurationMs(renditions?.[track.name]);
+}
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function catalogKeyframeCadenceMs(rendition) {
+  if (!rendition) return void 0;
+  const timescale = positiveNumber(rendition.timescale);
+  const ticksToMs = (ticks) => {
+    const value = positiveNumber(ticks);
+    return value !== void 0 && timescale !== void 0 ? value * 1e3 / timescale : void 0;
+  };
+  return ticksToMs(rendition.keyframeIntervalTicks) ?? positiveNumber(rendition.keyframeIntervalMs) ?? ticksToMs(rendition.keyframeDurationTicks) ?? positiveNumber(rendition.keyframeDurationMs) ?? ticksToMs(rendition.gopDurationTicks) ?? positiveNumber(rendition.gopDurationMs);
+}
+function catalogFecMediaUnitsPerSecond(type, rendition, endpointSampleRate) {
+  if (type === "video") return positiveNumber(rendition?.framerate);
+  const sampleRate = positiveNumber(endpointSampleRate ?? rendition?.sampleRate ?? rendition?.timescale);
+  return sampleRate === void 0 ? void 0 : sampleRate / 1024;
+}
+var NO_FEC = {
+  fecK: 0,
+  fecRepairCount: 0,
+  fecTotalRepairCount: 0,
+  fecSymbolSize: 0,
+  fecInterleaveMs: 0
+};
+function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
+  const layers = params.repairLayers;
+  if (layers === void 0 || layers.length === 0) return params.fecRepairCount;
+  const joined = new Set(joinedRepairTrackNames);
+  let total = 0;
+  for (const layer of layers) {
+    if (joined.has(layer.repairTrackName)) total += layer.repairSymbols;
+  }
+  return total;
+}
+function recordOf2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function msfTracks(catalog) {
+  const raw = catalog.tracks;
+  if (!Array.isArray(raw)) return void 0;
+  return { tracks: raw.map((t) => recordOf2(t) ?? {}) };
+}
+function resolveRepairLayers(catalog, source) {
+  if (!catalog) return void 0;
+  const sourceName = typeof source === "string" ? source : source.name;
+  const hang = catalog;
+  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "audio" ? ["audio"] : source.type === "video" ? ["video"] : ["video", "audio"];
+  const role = roles.find((r) => recordOf2(hang[r]?.renditions?.[sourceName]) !== void 0);
+  if (role !== void 0) {
+    const renditionPath = `$.${role}.renditions[${JSON.stringify(sourceName)}]`;
+    const rendition = recordOf2(hang[role].renditions[sourceName]);
+    rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
+    const repairRenditions = recordOf2(hang.repair?.renditions) ?? {};
+    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
+      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
+      const fields = recordOf2(entry);
+      if (fields === void 0) {
+        throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
+      }
+      rejectRepairTrackGeometry(path, fields, throwRepairContractError);
+      return describeRepairTrack(name, path, fields);
+    });
+    const fecOfRendition = (entry) => {
+      const fec2 = recordOf2(recordOf2(entry)?.["fec"]);
+      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
+    };
+    const mediaRenditions = [
+      ...Object.values(recordOf2(hang.video?.renditions) ?? {}),
+      ...Object.values(recordOf2(hang.audio?.renditions) ?? {})
+    ];
+    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf2(entry)?.["fec"]));
+    for (const d of descriptors2) {
+      validateRepairTrackFields(d, throwRepairContractError);
+      assertRepairTrackReachable(d, reachability2, throwRepairContractError);
+      const target = dependsTarget(d);
+      if (target === void 0) continue;
+      const targetFec = fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
+      if (targetFec === void 0) {
+        throwRepairContractError(
+          "track_repair_depends",
+          `${d.path}.depends`,
+          `${JSON.stringify(target)} is not a video or audio rendition with FEC`
+        );
+      }
+    }
+    const layers2 = assembleRepairLayers(
+      geometryOf(sourceName, `${renditionPath}.fec`, recordOf2(rendition["fec"])),
+      descriptors2,
+      throwRepairContractError
+    );
+    return catalogFecUnavailable(rendition["fec"], `${renditionPath}.fec`) === void 0 ? layers2 : void 0;
+  }
+  const msf = msfTracks(catalog);
+  const msfIndex = msf ? msf.tracks.findIndex((t) => t["name"] === sourceName) : -1;
+  if (!msf || msfIndex < 0) return void 0;
+  const track = msf.tracks[msfIndex];
+  const fec = recordOf2(track["fec"]);
+  const packagingOf = (t) => t["packaging"];
+  const fecOfTrack = (t) => {
+    const trackFec = recordOf2(t?.["fec"]);
+    return trackFec !== void 0 && trackFec["algorithm"] !== "none" ? trackFec : void 0;
+  };
+  const descriptors = [];
+  const mediaTracks = [];
+  msf.tracks.forEach((t, i) => {
+    const path = `$.tracks[${i}]`;
+    if (packagingOf(t) === "fec-repair") {
+      rejectRepairTrackGeometry(path, t, throwRepairContractError);
+      if (typeof t["name"] === "string") descriptors.push(describeRepairTrack(t["name"], path, t));
+      return;
+    }
+    rejectRepairFieldsOnMediaTrack(path, t, throwRepairContractError);
+    mediaTracks.push(t);
+  });
+  const reachability = repairReachability(mediaTracks.map((t) => t["fec"]));
+  for (const d of descriptors) {
+    validateRepairTrackFields(d, throwRepairContractError);
+    assertRepairTrackReachable(d, reachability, throwRepairContractError);
+    const target = dependsTarget(d);
+    if (target === void 0) continue;
+    const targetTrack = msf.tracks.find((t) => t["name"] === target);
+    if (targetTrack === void 0 || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === void 0) {
+      throwRepairContractError(
+        "track_repair_depends",
+        `${d.path}.depends`,
+        `${JSON.stringify(target)} is not an mmtp track with FEC`
+      );
+    }
+  }
+  const layers = assembleRepairLayers(
+    geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec),
+    descriptors,
+    throwRepairContractError,
+    { layerZeroMustBeDeclared: true }
+  );
+  return catalogFecUnavailable(fec, `$.tracks[${msfIndex}].fec`) === void 0 ? layers : void 0;
+}
+function moqtPriority2(value) {
+  return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
+}
+function catalogRepairTarget(catalog, source) {
+  const repair = resolveRepairLayers(catalog, source);
+  const layerZero = repair?.baseLayers[0];
+  if (!catalog || !layerZero) return null;
+  const sourceName = typeof source === "string" ? source : source.name;
+  const msf = msfTracks(catalog);
+  const entry = msf?.tracks.find((t) => t["name"] === sourceName);
+  const hang = catalog;
+  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "video" ? ["video"] : source.type === "audio" ? ["audio"] : ["video", "audio"];
+  const rendition = roles.map((role) => hang[role]?.renditions?.[sourceName]).find((r) => recordOf2(r) !== void 0);
+  const fec = rendition === void 0 ? recordOf2(entry?.["fec"]) : recordOf2(rendition.fec);
+  if (!fec || !(catalogFecInterleaveMs(fec) ?? 0)) return null;
+  const sourcePriority = entry === void 0 ? null : moqtPriority2(entry["priority"]);
+  return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
+}
+function geometryOf(name, path, fec) {
+  return {
+    name,
+    path,
+    algorithm: fec?.["algorithm"],
+    sourceSymbols: fec?.["sourceSymbols"],
+    repairSymbols: fec?.["repairSymbols"],
+    repairTrack: fec?.["repairTrack"]
+  };
+}
+function numericField(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function nonNegativeField(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function blockProfileUnavailable(value, path, declaresFecInstance) {
+  try {
+    readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
+    return void 0;
+  } catch (error) {
+    if (!(error instanceof RepairContractError) || error.code !== "track_fec_block_profile" && error.code !== "track_fec_block_profile_unimplemented") {
+      throw error;
+    }
+    return Object.freeze({ code: error.code, path: error.path, message: error.message });
+  }
+}
+function isoSpanUnavailable(fec, path, declaresFecInstance) {
+  if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
+  return Object.freeze({
+    code: "track_fec",
+    path,
+    message: `[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`
+  });
+}
+function catalogFecUnavailable(fec, fecPath) {
+  const block = recordOf2(fec);
+  if (block === void 0) return void 0;
+  const declaresFecInstance = block["algorithm"] !== "none";
+  return blockProfileUnavailable(block["blockProfile"], `${fecPath}.blockProfile`, declaresFecInstance) ?? isoSpanUnavailable(block, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
+}
+function fecParams(catalog, track, rendition, fps, sampleRate) {
+  const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
+  const fec = rendition?.fec;
+  if (!fec || !track) return { ...NO_FEC, ...mediaRate };
+  const repair = resolveRepairLayers(catalog, track);
+  const fecPath = `$.${track.type}.renditions[${JSON.stringify(track.name)}].fec`;
+  if (!catalogDeclaresFec(fec)) {
+    const declaresFecInstance = fec.algorithm !== "none";
+    const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
+    const tValid = Number.isSafeInteger(fec.symbolSize) && (fec.symbolSize ?? 0) > 0;
+    if (declaresFecInstance && !(kValid && tValid)) {
+      throwRepairContractError(
+        "track_fec",
+        `${fecPath}.${kValid ? "symbolSize" : "sourceSymbols"}`,
+        "must be a positive integer"
+      );
+    }
+    const fecUnavailable = catalogFecUnavailable(fec, fecPath);
+    return fecUnavailable === void 0 ? { ...NO_FEC, ...mediaRate } : { ...NO_FEC, ...mediaRate, fecUnavailable };
+  }
+  const fecBlockProfile = readFecBlockProfile(fec.blockProfile, `${fecPath}.blockProfile`, true, throwRepairContractError);
+  return {
+    fecK: fec.sourceSymbols ?? 0,
+    fecBlockProfile,
+    fecRepairCount: fec.repairSymbols ?? 0,
+    // The wire RSB_length: every base layer's packets carry the base total (§7.1).
+    fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
+    fecSymbolSize: fec.symbolSize ?? 0,
+    // Zero/absence leaves the elapsed deadline unknown; geometry stays in-band.
+    fecInterleaveMs: catalogFecInterleaveMs(fec) ?? 0,
+    // Additive, never a multiplier on the span: jitter belongs to the network
+    // path and the span belongs to the encoder, so scaling one by the other
+    // hands one network different slack per track. `numericField` rejects 0,
+    // so it cannot be reused here — a declared 0 is a legitimate value.
+    fecReorderToleranceMs: nonNegativeField(fec.reorderToleranceMs),
+    repairTrackName: fec.repairTrack,
+    repairLayers: repair?.baseLayers,
+    repairOverlays: repair?.overlays,
+    ...mediaRate
+  };
+}
+function resolveCatalogTrackFec(catalog, tracks) {
+  const videoTrackName = tracks.find((t) => t.type === "video")?.name;
+  const audioTrackName = tracks.find((t) => t.type === "audio")?.name;
+  const videoRenditions = catalog?.video?.renditions;
+  const audioRenditions = catalog?.audio?.renditions;
+  const video = videoTrackName ? videoRenditions?.[videoTrackName] : void 0;
+  const audio = audioTrackName ? audioRenditions?.[audioTrackName] : void 0;
+  const catalogFps = numericField(video?.framerate);
+  const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
+  const audioFps = sampleRate ? sampleRate / 1024 : void 0;
+  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, video, catalogFps);
+  const audioParams = fecParams(
+    catalog,
+    audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
+    audio,
+    audioFps,
+    sampleRate
+  );
+  const forTrack = (track) => {
+    if (track.type === "audio") {
+      if (track.name === audioTrackName) return audioParams;
+      const rendition2 = audioRenditions?.[track.name];
+      if (!rendition2) return { ...NO_FEC };
+      const rate = numericField(rendition2.sampleRate ?? rendition2.samplerate);
+      return fecParams(catalog, { name: track.name, type: "audio" }, rendition2, rate ? rate / 1024 : void 0, rate);
+    }
+    if (track.name === videoTrackName) return videoParams;
+    const rendition = videoRenditions?.[track.name];
+    if (!rendition) return { ...NO_FEC };
+    return fecParams(catalog, { name: track.name, type: "video" }, rendition, numericField(rendition.framerate));
+  };
+  return {
+    videoTrackName,
+    audioTrackName,
+    missingVideoRendition: videoTrackName && videoRenditions && !video ? videoTrackName : void 0,
+    missingAudioRendition: audioTrackName && audioRenditions && !audio ? audioTrackName : void 0,
+    videoForKeyframeRepair: video,
+    catalogFps,
+    video: videoParams,
+    audio: audioParams,
+    forTrack
+  };
+}
+
+// src/multicast-manager.ts
+function freezeIngress(tracks) {
+  return Object.freeze({
+    tracks: Object.freeze(
+      [...tracks].map(({ name, packetId }) => Object.freeze({ name, packetId }))
+    )
+  });
+}
+function sameIdSet(a, b) {
+  if (a.size !== b.size) return false;
+  for (const id of a) if (!b.has(id)) return false;
+  return true;
 }
 function newBlockPolicyStats(packetId, catalogTrackName, epoch) {
   return {
@@ -22762,9 +22989,8 @@ function repairTrackNamesBySource(tracks) {
     bySource.set(source, names);
   };
   for (const track of tracks) {
-    if (track.fec !== void 0 && isFecCatalogConfig(track.fec) && track.fec.repairTrack) {
-      add(track.name, track.fec.repairTrack);
-    }
+    const repairTrack = typeof track.fec === "object" && track.fec !== null ? track.fec.repairTrack : void 0;
+    if (typeof repairTrack === "string") add(track.name, repairTrack);
     if (track.packaging === "fec-repair" && Array.isArray(track.depends) && track.depends.length === 1) {
       add(track.depends[0], track.name);
     }
@@ -22774,6 +23000,7 @@ function repairTrackNamesBySource(tracks) {
 var MulticastManager = class {
   #fec;
   #router;
+  #hostMfuTimeoutMs;
   #transport;
   #reportedFecDiagnosticsFailure = false;
   // ── Stream-global FEC timing reduction ──
@@ -22872,6 +23099,7 @@ var MulticastManager = class {
         this.#emitRepairLifecycle(decision);
       }
     });
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
     this.#transport = new MulticastTransport((packet, ingress) => {
       this.#router.feedPacket(packet, "multicast", void 0, ingress);
     });
@@ -23088,7 +23316,6 @@ var MulticastManager = class {
       ...this.#streamFecBaseline ? [this.#streamFecBaseline] : [],
       ...this.#trackFecTiming.values()
     ];
-    if (contributions.length === 0) return;
     let deliveryWindowMs;
     let minimumFailbackWindowMs;
     let mfuTimeoutMs;
@@ -23120,15 +23347,9 @@ var MulticastManager = class {
       }
     }
     const failbackWindowMs = deliveryWindowMs === void 0 ? minimumFailbackWindowMs : Math.max(deliveryWindowMs, minimumFailbackWindowMs ?? 0);
-    if (failbackWindowMs !== void 0) {
-      this.#transport.setFailbackWindowMs(failbackWindowMs);
-    }
-    if (mfuTimeoutMs !== void 0) {
-      this.#router.setMfuTimeoutMs(mfuTimeoutMs);
-    }
-    if (reorderWindowFrames !== void 0) {
-      this.#router.setReorderWindow(reorderWindowFrames);
-    }
+    this.#transport.setFailbackWindowMs(failbackWindowMs ?? null);
+    this.#router.setMfuTimeoutMs(mfuTimeoutMs ?? this.#hostMfuTimeoutMs);
+    this.#router.setReorderWindow(reorderWindowFrames ?? 0);
   }
   /**
    * Configure one track's FEC geometry, block mapper, and block-inactivity
@@ -23155,9 +23376,9 @@ var MulticastManager = class {
         `[MulticastManager] configureTrackFec(${packetId}) catalogTrackName must be non-empty when given`
       );
     }
-    if (config.fecK === void 0 || config.fecInterleaveDepthMs === void 0) {
+    if (config.fecK === void 0) {
       throw new Error(
-        `[MulticastManager] configureTrackFec(${packetId}) requires fecK and fecInterleaveDepthMs. Derive the per-track FEC geometry from the stream catalog.`
+        `[MulticastManager] configureTrackFec(${packetId}) requires fecK. Derive the per-track FEC geometry from the stream catalog.`
       );
     }
     const blockProfile = parseFecBlockProfile(
@@ -23165,7 +23386,10 @@ var MulticastManager = class {
       `[MulticastManager] configureTrackFec(${packetId}) fecBlockProfile`
     );
     assertPositiveGeometry("fecK", config.fecK);
-    assertPositiveGeometry("fecInterleaveDepthMs", config.fecInterleaveDepthMs);
+    const interleaveDepthMs = config.fecInterleaveDepthMs ?? 0;
+    if (!Number.isSafeInteger(interleaveDepthMs) || interleaveDepthMs < 0) {
+      throw new Error("[MulticastManager] fecInterleaveDepthMs must be a non-negative safe integer");
+    }
     assertPositiveGeometry("fecSymbolSize", config.fecSymbolSize);
     assertPositiveGeometry("fps", config.fps);
     assertPositiveGeometry("bandwidth", config.bandwidth);
@@ -23181,8 +23405,8 @@ var MulticastManager = class {
       "fecReorderToleranceMs",
       config.fecReorderToleranceMs
     );
-    const deliveryWindowMs = config.fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS ? computeFecDeliveryWindowMs({
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+    const deliveryWindowMs = interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS ? computeFecDeliveryWindowMs({
+      interleaveDepthMs,
       sourceSymbols: config.fecK,
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
@@ -23191,10 +23415,10 @@ var MulticastManager = class {
       jitterBufferMs: config.fecReorderToleranceMs
     }) : void 0;
     const trackKind = config.trackKind ?? this.#router.trackKindFor(packetId);
-    const geometry = trackKind === void 0 ? void 0 : deriveBlockClassifierGeometry({
+    const geometry = trackKind === void 0 || interleaveDepthMs === 0 ? void 0 : deriveBlockClassifierGeometry({
       trackKind,
       framerate: config.fps,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       timescale: config.timescale,
       keyframeIntervalTicks: config.keyframeIntervalTicks,
       keyframeIntervalMs: config.keyframeIntervalMs
@@ -23203,7 +23427,7 @@ var MulticastManager = class {
       blockProfile,
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs,
       ...trackKind === void 0 ? {} : { trackKind },
@@ -23214,7 +23438,7 @@ var MulticastManager = class {
     this.#configureTrackMapper(packetId, fecConfig);
     this.#trackFecTiming.set(packetId, {
       deliveryWindowMs,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       k: config.fecK,
       repairSymbols: config.fecRepairSymbols,
@@ -23223,6 +23447,10 @@ var MulticastManager = class {
     this.#applyStreamGlobalFecTiming();
   }
   configureFec(config) {
+    const interleaveDepthMs = config.fecInterleaveDepthMs ?? 0;
+    if (!Number.isSafeInteger(interleaveDepthMs) || interleaveDepthMs < 0) {
+      throw new Error("[MulticastManager] fecInterleaveDepthMs must be a non-negative safe integer");
+    }
     const minimumFailbackWindowMs = config.minimumFailbackWindowMs;
     if (minimumFailbackWindowMs !== void 0 && (!Number.isFinite(minimumFailbackWindowMs) || minimumFailbackWindowMs <= 0)) {
       throw new Error(
@@ -23234,7 +23462,7 @@ var MulticastManager = class {
       config.fecReorderToleranceMs
     );
     const deliveryWindowMs = config.fecK && config.fecK > 0 && config.fecInterleaveDepthMs && config.fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS ? computeFecDeliveryWindowMs({
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       sourceSymbols: config.fecK,
       repairSymbols: config.fecRepairSymbols,
       symbolSize: config.fecSymbolSize,
@@ -23245,13 +23473,13 @@ var MulticastManager = class {
     this.#fec.configure({
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs
     });
     this.#streamFecBaseline = {
       deliveryWindowMs,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       k: config.fecK,
       repairSymbols: config.fecRepairSymbols,
@@ -23300,6 +23528,7 @@ var MulticastManager = class {
   }
   setMfuTimeoutMs(ms) {
     this.#router.setMfuTimeoutMs(ms);
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
   }
   setTrackCodec(packetId, codec) {
     this.#router.setTrackCodec(packetId, codec);
@@ -23322,6 +23551,7 @@ var MulticastManager = class {
   onTrackPacket(packetId, cb) {
     this.#router.onTrackPacket(packetId, cb);
   }
+  /** @deprecated Use onTrackInit(packetId, cb); see MmtpRouter.onInitSegment. */
   onInitSegment(cb) {
     this.#router.onInitSegment(cb);
   }
@@ -23633,7 +23863,10 @@ var MulticastManager = class {
       console.warn("[MulticastManager] rendition switch onCancel failed", error);
     }
   }
-  /** Release what the manager and FEC hold for a stream whose packet ID the router retired. */
+  /**
+   * Release what the manager and FEC hold for a stream whose packet ID the
+   * router retired, or whose FEC a catalog reconfiguration no longer configures.
+   */
   #releaseRetiredStream(stream) {
     for (const observer of this.#trackResetObservers) {
       try {
@@ -23652,7 +23885,10 @@ var MulticastManager = class {
     for (const [key, stats] of [...this.#blockPolicyStats]) {
       if (stats.packetId === stream.packetId) this.#blockPolicyStats.delete(key);
     }
-    this.#trackFecTiming.delete(stream.packetId);
+    if (this.#trackFecTiming.delete(stream.packetId)) {
+      this.#applyStreamGlobalFecTiming();
+    }
+    this.#multiTrackFecTracks.delete(stream.packetId);
     this.#fec.releasePacket(stream.packetId);
   }
   /** Feed a raw packet from an external source (AMT tunnel, ASM subscription).
@@ -23697,12 +23933,53 @@ var MulticastManager = class {
    * D-17: Builds altGroup → track-name index for getSwitchingSet().
    * D-26: Registers packetId → TrackRole on MmtpRouter for block-complete fanout.
    *
+   * FEC availability is per track (draft-ramadan-moq-fec §5.1). A media track
+   * whose `fec` names no implemented `blockProfile` (only `iso-ssbg1-v1` is
+   * implemented; the retired `k-padded-v1` is not), or an `iso-ssbg1-v1` span
+   * it cannot use, is consumed without FEC: it gets no decoder, and none of
+   * its repair tracks (layer 0 by `fec.repairTrack`, further layers and the
+   * overlay by `depends`) is given an owner, so the router drops their packets
+   * before any decoder. Those legs keep the `repair` role and their owner's
+   * switching set. Neither the call nor any other track's FEC fails on that
+   * account; `trackFecUnavailable(name)` reports the reason. FEC a previous
+   * call configured on a packetId this call does not is released
+   * (FECManager.releasePacket); frames its release gate held are delivered in
+   * order, each gap stalled. FEC wired by hand (setFecDecoder) is left alone.
+   * Geometry a decoder could not configure (K, P, T, `repairTrack`,
+   * algorithm) still throws.
+   *
    * @param catalog - Multi-track catalog (tracks array with name, altGroup, fec, packetId).
    * @param wasmDecoderSource - One WASM FEC decoder for a single FEC stream, or
    *                            a factory returning a distinct decoder per stream.
    */
   configureMultiTrack(catalog, wasmDecoderSource) {
     const repairNamesBySource = repairTrackNamesBySource(catalog.tracks);
+    const declaredRepairNames = /* @__PURE__ */ new Set();
+    for (const names of repairNamesBySource.values()) {
+      for (const name of names) declaredRepairNames.add(name);
+    }
+    const fecUnavailableByTrack = /* @__PURE__ */ new Map();
+    for (let i = 0; i < catalog.tracks.length; i++) {
+      const track = catalog.tracks[i];
+      if (track.fec === void 0 || track.packaging === "fec-repair" || declaredRepairNames.has(track.name)) {
+        continue;
+      }
+      const fecUnavailable = catalogFecUnavailable(track.fec, `$.tracks[${i}].fec`);
+      if (fecUnavailable === void 0) continue;
+      fecUnavailableByTrack.set(track.name, fecUnavailable);
+      const layerZero = track.fec.repairTrack;
+      if (typeof layerZero === "string" && layerZero.length > 0) {
+        const names = repairNamesBySource.get(track.name) ?? /* @__PURE__ */ new Set();
+        names.add(layerZero);
+        repairNamesBySource.set(track.name, names);
+      }
+    }
+    const unownedRepairNames = /* @__PURE__ */ new Set();
+    for (const sourceName of fecUnavailableByTrack.keys()) {
+      for (const repairName of repairNamesBySource.get(sourceName) ?? []) {
+        unownedRepairNames.add(repairName);
+      }
+    }
     const repairOwnerGroup = /* @__PURE__ */ new Map();
     const repairOwnerAltGroup = /* @__PURE__ */ new Map();
     for (const track of catalog.tracks) {
@@ -23755,11 +24032,13 @@ var MulticastManager = class {
     for (let i = 0; i < catalog.tracks.length; i++) {
       const track = catalog.tracks[i];
       if (resolvedRoles[i] === "repair" || track.fec === void 0) continue;
-      if (!isFecCatalogConfig(track.fec)) {
+      const unavailable = fecUnavailableByTrack.has(track.name);
+      if (!(unavailable ? isFecCatalogGeometry(track.fec) : isFecCatalogConfig(track.fec))) {
         throw new Error(
           `[MulticastManager] invalid fec config for track '${track.name}'`
         );
       }
+      if (unavailable) continue;
       if (track.packetId !== void 0) fecTrackIndexes.push(i);
     }
     const fecDecoders = /* @__PURE__ */ new Map();
@@ -23788,6 +24067,20 @@ var MulticastManager = class {
     this.#switchingSets.clear();
     this.#repairPacketIds.clear();
     this.#router.clearRepairPacketIdOwners();
+    const fecPacketIds = new Set([...fecDecoders.keys()].map((i) => catalog.tracks[i].packetId));
+    for (const [packetId, catalogTrackName] of this.#multiTrackFecTracks) {
+      if (fecPacketIds.has(packetId)) continue;
+      if (!this.#fec.isTrackConfigured(packetId)) {
+        this.#multiTrackFecTracks.delete(packetId);
+        continue;
+      }
+      this.#router.releaseFecPacket(packetId);
+      this.#releaseRetiredStream({ packetId, catalogTrackName });
+    }
+    this.#fecUnavailableByTrack.clear();
+    for (const [name, reason] of fecUnavailableByTrack) {
+      this.#fecUnavailableByTrack.set(name, reason);
+    }
     const catalogTracksByName = new Map(
       catalog.tracks.map((track) => [track.name, track])
     );
@@ -23809,10 +24102,11 @@ var MulticastManager = class {
         }
         continue;
       }
-      if (track.fec !== void 0) {
+      if (track.fec !== void 0 && !fecUnavailableByTrack.has(track.name)) {
         const fecCfg = track.fec;
         if (track.packetId !== void 0) {
           for (const repairName of repairNamesBySource.get(track.name) ?? []) {
+            if (unownedRepairNames.has(repairName)) continue;
             const repairTrack = catalogTracksByName.get(repairName);
             if (repairTrack?.packetId !== void 0) {
               this.#router.setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
@@ -23833,17 +24127,18 @@ var MulticastManager = class {
               blockProfile,
               k: fecCfg.sourceSymbols,
               symbolSize: fecCfg.symbolSize,
-              interleaveDepthMs: fecCfg.interleaveDepthMs,
+              interleaveDepthMs: fecCfg.interleaveDepthMs ?? 0,
               fps: track.framerate,
               trackKind: "video"
             },
             track.name
           );
+          this.#multiTrackFecTracks.set(track.packetId, track.name);
           this.#configureTrackMapper(track.packetId, {
             blockProfile,
             k: fecCfg.sourceSymbols,
             symbolSize: fecCfg.symbolSize,
-            interleaveDepthMs: fecCfg.interleaveDepthMs,
+            interleaveDepthMs: fecCfg.interleaveDepthMs ?? 0,
             fps: track.framerate
           });
           this.#router.setPacketIdType(track.packetId, "video");
@@ -23851,6 +24146,24 @@ var MulticastManager = class {
       }
     }
   }
+  /**
+   * Why `configureMultiTrack` consumes the named catalog track without FEC
+   * although its `fec` block declares one (draft-ramadan-moq-fec §5.1): no
+   * implemented `blockProfile` (`track_fec_block_profile_unimplemented`, e.g.
+   * the retired `k-padded-v1`; `track_fec_block_profile` when absent), or an
+   * invalid `iso-ssbg1-v1` span (`track_fec`). Absent/zero spans keep in-band
+   * decoding enabled. The same reason the hang
+   * resolver reports (`catalogFecUnavailable`). Undefined for every other
+   * track, and for every track before the first call; each call replaces the
+   * previous call's answers.
+   */
+  trackFecUnavailable(trackName) {
+    return this.#fecUnavailableByTrack.get(trackName);
+  }
+  /** Per-track FEC availability from the last `configureMultiTrack` call. */
+  #fecUnavailableByTrack = /* @__PURE__ */ new Map();
+  /** packetId → catalog track name of the FEC the last `configureMultiTrack` installed. */
+  #multiTrackFecTracks = /* @__PURE__ */ new Map();
   /**
    * Return the track names belonging to the given altGroup switching set.
    * D-17: altGroup groups base+delta+repair into one switching set.
@@ -24061,31 +24374,62 @@ var MulticastManager = class {
 
 // src/fec-worker-setup.ts
 async function setupFecWorkerForTrack(opts) {
-  if (!Number.isFinite(opts.fecInterleaveMs) || opts.fecInterleaveMs <= 0) {
+  if (!Number.isFinite(opts.fecInterleaveMs) || !Number.isSafeInteger(opts.fecInterleaveMs) || opts.fecInterleaveMs < 0) {
     throw new Error(
-      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be finite and > 0 (got ${opts.fecInterleaveMs})`
+      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be a finite non-negative integer (got ${opts.fecInterleaveMs})`
     );
   }
-  if (!Number.isFinite(opts.mediaUnitDurationMs) || opts.mediaUnitDurationMs <= 0) {
+  if (opts.fecReorderToleranceMs !== void 0 && (!Number.isFinite(opts.fecReorderToleranceMs) || opts.fecReorderToleranceMs < 0)) {
     throw new Error(
-      `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${opts.mediaUnitDurationMs})`
+      `[FEC] fecReorderToleranceMs must be finite and >= 0 (got ${opts.fecReorderToleranceMs})`
+    );
+  }
+  const hasCatalogTiming = opts.fecInterleaveMs > 0;
+  const validateWorkerGeometry = () => {
+    if (!Number.isSafeInteger(opts.fecK) || opts.fecK <= 0) {
+      throw new Error(`[FEC] fecK must be a finite positive integer (got ${opts.fecK})`);
+    }
+    if (!Number.isSafeInteger(opts.fecSymbolSize) || opts.fecSymbolSize <= 0 || opts.fecSymbolSize % 8 !== 0) {
+      throw new Error(
+        `[FEC] fecSymbolSize must be a positive 8-byte-aligned integer (got ${opts.fecSymbolSize})`
+      );
+    }
+    if (!Number.isSafeInteger(opts.fecRepairCount) || opts.fecRepairCount <= 0) {
+      throw new Error(
+        `[FEC] fecRepairCount must be a finite positive integer (got ${opts.fecRepairCount})`
+      );
+    }
+  };
+  let deliveryWindowMs;
+  let interleaveDepthBlocks;
+  if (!hasCatalogTiming) {
+    validateWorkerGeometry();
+    deliveryWindowMs = LOCAL_FEC_TIMEOUT_MS;
+    interleaveDepthBlocks = LOCAL_FEC_RETENTION_BLOCKS;
+  } else {
+    const mediaUnitDurationMs = opts.mediaUnitDurationMs;
+    if (typeof mediaUnitDurationMs !== "number" || !Number.isFinite(mediaUnitDurationMs) || mediaUnitDurationMs <= 0) {
+      throw new Error(
+        `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${mediaUnitDurationMs})`
+      );
+    }
+    validateWorkerGeometry();
+    deliveryWindowMs = computeFecDeliveryWindowMs({
+      interleaveDepthMs: opts.fecInterleaveMs,
+      sourceSymbols: opts.fecK,
+      repairSymbols: opts.fecRepairCount,
+      symbolSize: opts.fecSymbolSize,
+      mediaUnitsPerSecond: 1e3 / mediaUnitDurationMs,
+      jitterBufferMs: opts.fecReorderToleranceMs
+    });
+    interleaveDepthBlocks = deriveFecRetentionBlocks(
+      deliveryWindowMs,
+      opts.fecInterleaveMs
     );
   }
   const blockProfile = parseFecBlockProfile(
     opts.fecBlockProfile,
-    `[FEC] ${opts.trackName} fec.blockProfile`
-  );
-  const deliveryWindowMs = computeFecDeliveryWindowMs({
-    interleaveDepthMs: opts.fecInterleaveMs,
-    sourceSymbols: opts.fecK,
-    repairSymbols: opts.fecRepairCount,
-    symbolSize: opts.fecSymbolSize,
-    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
-    jitterBufferMs: opts.fecReorderToleranceMs
-  });
-  const interleaveDepthBlocks = deriveFecRetentionBlocks(
-    deliveryWindowMs,
-    opts.fecInterleaveMs
+    `[FEC] ${opts.trackName} fec.blockProfile`
   );
   const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
   const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
@@ -24140,9 +24484,10 @@ async function setupFecWorkerForTrack(opts) {
       k: opts.fecK,
       symbolSize: opts.fecSymbolSize,
       interleaveDepthMs: opts.fecInterleaveMs,
-      // FEC timing is expressed in media units. For audio this is the access-unit
-      // cadence (for example 1024/48kHz), not a video-only framerate field.
-      fps: 1e3 / opts.mediaUnitDurationMs,
+      // No-span tracks have no catalog media cadence. The manager still gets
+      // the local cleanup budget, but it must not use a guessed fps for timing
+      // or classification.
+      ...hasCatalogTiming ? { fps: 1e3 / opts.mediaUnitDurationMs } : {},
       timeoutMs: deliveryWindowMs
     }, opts.trackName);
   } catch (e) {
@@ -24182,6 +24527,28 @@ var TrackSourceConflictError = class extends Error {
 };
 var DEFAULT_CROSSFADE_FRAMES = 10;
 var DEFAULT_MAX_OVERLAY_BUFFER = 128;
+function assertDeltaFallbackConfig(cfg, prefix) {
+  if (!isPositiveFinite2(cfg.framerate)) throw new Error(`${prefix}: framerate required and must be > 0`);
+  if (!isPositiveFinite2(cfg.sourceSymbols))
+    throw new Error(`${prefix}: sourceSymbols (K_delta) required and must be > 0`);
+  if (!isPositiveFinite2(cfg.repairSymbols))
+    throw new Error(`${prefix}: repairSymbols (P_delta) required and must be > 0`);
+  if (cfg.deltaFailWindowBlocks !== void 0 && !(Number.isInteger(cfg.deltaFailWindowBlocks) && cfg.deltaFailWindowBlocks > 0)) {
+    throw new Error(`${prefix}: deltaFailWindowBlocks must be a positive integer when present`);
+  }
+  if (cfg.deltaProbeIntervalMs !== void 0 && !isPositiveFinite2(cfg.deltaProbeIntervalMs))
+    throw new Error(`${prefix}: deltaProbeIntervalMs must be > 0 when present`);
+  if (cfg.interleaveDepthMs !== void 0 && !isPositiveFinite2(cfg.interleaveDepthMs))
+    throw new Error(`${prefix}: interleaveDepthMs must be > 0 when present`);
+  if (cfg.deltaProbeIntervalMs === void 0 && cfg.interleaveDepthMs === void 0) {
+    throw new Error(
+      `${prefix}: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation`
+    );
+  }
+}
+function isPositiveFinite2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 var MediaRouter = class {
   #active = "moq";
   #multicastVideoKeyed = false;
@@ -24341,22 +24708,21 @@ var MediaRouter = class {
    * CLAUDE.md: error on bad init — throws if required inputs are absent.
    *
    * Calling again resets deltaActive=true and clears the window buffer (stream restart).
+   * Pass null on teardown or when a replacement catalog cannot configure this policy.
    */
   configureDelta(cfg) {
-    if (typeof cfg.framerate !== "number" || !Number.isFinite(cfg.framerate) || cfg.framerate <= 0) {
-      throw new Error("[MediaRouter] configureDelta: framerate required and must be > 0");
-    }
-    if (typeof cfg.sourceSymbols !== "number" || cfg.sourceSymbols <= 0) {
-      throw new Error("[MediaRouter] configureDelta: sourceSymbols (K_delta) required and must be > 0");
-    }
-    if (typeof cfg.repairSymbols !== "number" || cfg.repairSymbols <= 0) {
-      throw new Error("[MediaRouter] configureDelta: repairSymbols (P_delta) required and must be > 0");
-    }
-    if (cfg.deltaProbeIntervalMs === void 0 && cfg.interleaveDepthMs === void 0) {
-      throw new Error(
-        "[MediaRouter] configureDelta: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation"
-      );
+    if (cfg === null) {
+      this.#deltaConfigured = false;
+      this.#deltaActive = true;
+      this.#deltaWindow = [];
+      this.#deltaWindowSize = 0;
+      this.#deltaFailThresholdRatio = 0;
+      this.#deltaRecoverThresholdRatio = 0;
+      this.#deltaProbeIntervalMs = 0;
+      this.#lastProbeAt = 0;
+      return;
     }
+    assertDeltaFallbackConfig(cfg, "[MediaRouter] configureDelta");
     this.#deltaWindowSize = cfg.deltaFailWindowBlocks ?? Math.ceil(cfg.framerate);
     this.#deltaFailThresholdRatio = cfg.repairSymbols / cfg.sourceSymbols;
     this.#deltaRecoverThresholdRatio = this.#deltaFailThresholdRatio / 2;
@@ -24692,6 +25058,7 @@ var MediaRouter = class {
   /** Dispose timers and per-track sources. Call on teardown to prevent
    *  stale timer callbacks firing into garbage-collected closures (WR-03). */
   dispose() {
+    this.configureDelta(null);
     if (this.#audioFallbackTimer) {
       clearTimeout(this.#audioFallbackTimer);
       this.#audioFallbackTimer = null;
@@ -24733,6 +25100,35 @@ var MediaRouter = class {
   }
 };
 
+// src/delta-fallback-config.ts
+function resolveDeltaFallback(base, delta) {
+  const repair = base.fec?.repairTrack;
+  if (!repair) throw new Error(`[delta-fallback] base track "${base.name}" missing fec.repairTrack`);
+  const deltaFec = delta.fec;
+  if (!deltaFec?.repairTrack) throw new Error(`[delta-fallback] delta track "${delta.name}" missing fec.repairTrack`);
+  if (deltaFec.repairTrack !== repair)
+    throw new Error(
+      `[delta-fallback] inconsistent repair tracks: ${base.name} references "${repair}" but ${delta.name} references "${deltaFec.repairTrack}"`
+    );
+  if (!(typeof base.framerate === "number" && Number.isFinite(base.framerate) && base.framerate > 0))
+    throw new Error(`[delta-fallback] base track "${base.name}" missing positive framerate`);
+  if (!(isPositive(deltaFec.sourceSymbols) && isPositive(deltaFec.repairSymbols)))
+    throw new Error(`[delta-fallback] delta track "${delta.name}" missing positive fec.sourceSymbols/repairSymbols`);
+  const config = {
+    framerate: base.framerate,
+    sourceSymbols: deltaFec.sourceSymbols,
+    repairSymbols: deltaFec.repairSymbols,
+    deltaFailWindowBlocks: base.fec?.deltaFailWindowBlocks ?? deltaFec.deltaFailWindowBlocks,
+    deltaProbeIntervalMs: base.fec?.deltaProbeIntervalMs ?? deltaFec.deltaProbeIntervalMs,
+    interleaveDepthMs: base.fec?.interleaveDepthMs ?? deltaFec.interleaveDepthMs
+  };
+  assertDeltaFallbackConfig(config, `[delta-fallback] group ${base.name}/${delta.name}`);
+  return { repairTrackName: repair, config };
+}
+function isPositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
 // src/align.ts
 function secondsFromTicks(ticks, timescale) {
   if (!Number.isFinite(ticks)) {
@@ -25625,400 +26021,131 @@ var CmcdProducer = class {
     this.#onCmcdParams = options.onCmcdParams;
     this.#onCmcdPost = options.onCmcdPost;
   }
-  /** Update the stored transport state. Called by player wiring layer. */
-  updateTransport(snapshot) {
-    this.#transport = snapshot;
-  }
-  /**
-   * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
-   * snapshots. Throws on any value outside {'full','base-only','single-track'}
-   * (CLAUDE.md: error on bad init).
-   */
-  updatePlayMode(mode) {
-    if (typeof mode !== "string" || !PLAY_MODES.includes(mode)) {
-      throw new Error(
-        `[CmcdProducer] invalid play-mode "${String(mode)}"; expected one of: ${PLAY_MODES.join(", ")}`
-      );
-    }
-    this.#playMode = mode;
-  }
-  /**
-   * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
-   * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
-   * Omitted on single-track streams.
-   */
-  updateDeltaFailRate(rate) {
-    if (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0 || rate > 1) {
-      throw new Error(
-        `[CmcdProducer] invalid delta-fail-rate "${String(rate)}"; expected a finite number in [0, 1]`
-      );
-    }
-    this.#deltaFailRate = rate;
-  }
-  /**
-   * Bump the cumulative switching-set misalignment counter. Emitted as
-   * `x-bc-switch-miscount` on snapshots when the counter is > 0.
-   */
-  incrementSwitchMiscount() {
-    this.#switchMiscount += 1;
-  }
-  updateManifestVerification(stats) {
-    this.#manifestStats = stats;
-  }
-  /**
-   * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
-   * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
-   * include the drift key until the next emitSwitchDrift(). Mirrors the
-   * existing onTransition() pattern.
-   */
-  emitSwitchDrift(driftUs) {
-    if (typeof driftUs !== "number" || !Number.isFinite(driftUs) || driftUs < 0) {
-      throw new Error(
-        `[CmcdProducer] invalid drift-us "${String(driftUs)}"; expected a non-negative finite number`
-      );
-    }
-    const params = {};
-    if (this.#lastStats) Object.assign(params, buildFecParams(this.#lastStats));
-    Object.assign(params, buildTransportParams(this.#transport));
-    if (this.#switchMiscount > 0) params["x-bc-switch-miscount"] = this.#switchMiscount;
-    params["x-bc-switch-drift-us"] = driftUs;
-    this.#emit(params);
-  }
-  /**
-   * Process a FecTrackStats snapshot. Finds the video track, builds
-   * x-bc-* vendor keys, and fires both delivery callbacks.
-   */
-  onSnapshot(data) {
-    const videoTrack = data.tracks.find((t) => t.config.trackType === "video");
-    if (!videoTrack) return;
-    this.#lastStats = videoTrack;
-    const params = {
-      ...buildFecParams(videoTrack),
-      ...buildTransportParams(this.#transport)
-    };
-    if (this.#playMode !== null) {
-      params["x-bc-play-mode"] = this.#playMode;
-    }
-    if (this.#playMode !== null && this.#playMode !== "single-track" && this.#deltaFailRate !== null) {
-      params["x-bc-delta-fail-rate"] = parseFloat(this.#deltaFailRate.toFixed(4));
-    }
-    if (this.#switchMiscount > 0) {
-      params["x-bc-switch-miscount"] = this.#switchMiscount;
-    }
-    if (this.#manifestStats) {
-      params["x-bc-manifest-verified"] = this.#manifestStats.verified > 0;
-      params["x-bc-manifest-failures"] = Object.values(this.#manifestStats.failures).reduce((total, count) => total + count, 0);
-    }
-    this.#emit(params);
-  }
-  /**
-   * Emit transport state without inventing FEC metrics. Cadence is owned by
-   * the caller because only the transport integration knows when state changed.
-   */
-  onTransportSnapshot(data) {
-    if (!Number.isFinite(data.timestampMs) || data.timestampMs < 0) {
-      throw new Error("[CmcdProducer] transport snapshot timestamp must be a non-negative finite number");
-    }
-    if (data.playMode !== void 0) this.updatePlayMode(data.playMode);
-    if (data.switchMiscount !== void 0 && (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0)) {
-      throw new Error("[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer");
-    }
-    this.#transport = data.transport;
-    const params = buildTransportParams(data.transport);
-    if (this.#playMode !== null) params["x-bc-play-mode"] = this.#playMode;
-    const switchMiscount = data.switchMiscount ?? this.#switchMiscount;
-    if (switchMiscount > 0) params["x-bc-switch-miscount"] = switchMiscount;
-    this.#emit(params);
-  }
-  /**
-   * Signal a transport transition event. Fires an immediate out-of-band
-   * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
-   * x-bc-ct (one-shot).
-   */
-  onTransition(event) {
-    const params = {};
-    if (this.#lastStats) {
-      Object.assign(params, buildFecParams(this.#lastStats));
-    }
-    Object.assign(params, buildTransportParams(this.#transport));
-    params["x-bc-ct"] = event;
-    this.#emit(params);
-  }
-  /** Fire both delivery callbacks with the given params. */
-  #emit(params) {
-    this.#onCmcdParams?.(params);
-    this.#onCmcdPost?.(formatQueryString(params));
-  }
-};
-
-// src/catalog-fec-params.ts
-var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
-function timescaleHz(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
-}
-function catalogGroupDurationMs(rendition) {
-  if (!rendition) return void 0;
-  const ticks = numericField(rendition.groupDurationTicks);
-  const ms = numericField(rendition.groupDurationMs);
-  const timescale = timescaleHz(rendition.container?.kind === "mmtp" ? rendition.container.timescale : void 0) ?? timescaleHz(rendition.timescale);
-  if (ticks !== void 0 && timescale !== void 0 && Number.isSafeInteger(ticks) && ticks <= timescale * MAX_SAFE_TICKS_PER_HZ) {
-    return resolveGroupDurationMs({ groupDurationTicks: ticks }, timescale);
-  }
-  return ms;
-}
-function resolveCatalogTrackGroupDurationMs(catalog, track) {
-  const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
-  return catalogGroupDurationMs(renditions?.[track.name]);
-}
-var NO_FEC = {
-  fecK: 0,
-  fecRepairCount: 0,
-  fecTotalRepairCount: 0,
-  fecSymbolSize: 0,
-  fecInterleaveMs: 0
-};
-function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
-  const layers = params.repairLayers;
-  if (layers === void 0 || layers.length === 0) return params.fecRepairCount;
-  const joined = new Set(joinedRepairTrackNames);
-  let total = 0;
-  for (const layer of layers) {
-    if (joined.has(layer.repairTrackName)) total += layer.repairSymbols;
-  }
-  return total;
-}
-function recordOf2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function msfTracks(catalog) {
-  const raw = catalog.tracks;
-  if (!Array.isArray(raw)) return void 0;
-  return { tracks: raw.map((t) => recordOf2(t) ?? {}) };
-}
-function resolveRepairLayers(catalog, source) {
-  if (!catalog) return void 0;
-  const sourceName = typeof source === "string" ? source : source.name;
-  const hang = catalog;
-  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "audio" ? ["audio"] : source.type === "video" ? ["video"] : ["video", "audio"];
-  const role = roles.find((r) => recordOf2(hang[r]?.renditions?.[sourceName]) !== void 0);
-  if (role !== void 0) {
-    const renditionPath = `$.${role}.renditions[${JSON.stringify(sourceName)}]`;
-    const rendition = recordOf2(hang[role].renditions[sourceName]);
-    rejectRepairFieldsOnMediaTrack(renditionPath, rendition, throwRepairContractError);
-    const repairRenditions = recordOf2(hang.repair?.renditions) ?? {};
-    const descriptors2 = Object.entries(repairRenditions).map(([name, entry]) => {
-      const path = `$.repair.renditions[${JSON.stringify(name)}]`;
-      const fields = recordOf2(entry);
-      if (fields === void 0) {
-        throwRepairContractError("track_repair_layer", path, "a repair rendition must be an object");
-      }
-      rejectRepairTrackGeometry(path, fields, throwRepairContractError);
-      return describeRepairTrack(name, path, fields);
-    });
-    const fecOfRendition = (entry) => {
-      const fec2 = recordOf2(recordOf2(entry)?.["fec"]);
-      return fec2 !== void 0 && fec2["algorithm"] !== "none" ? fec2 : void 0;
-    };
-    const mediaRenditions = [
-      ...Object.values(recordOf2(hang.video?.renditions) ?? {}),
-      ...Object.values(recordOf2(hang.audio?.renditions) ?? {})
-    ];
-    const reachability2 = repairReachability(mediaRenditions.map((entry) => recordOf2(entry)?.["fec"]));
-    for (const d of descriptors2) {
-      validateRepairTrackFields(d, throwRepairContractError);
-      assertRepairTrackReachable(d, reachability2, throwRepairContractError);
-      const target = dependsTarget(d);
-      if (target === void 0) continue;
-      const targetFec = fecOfRendition(hang.video?.renditions?.[target]) ?? fecOfRendition(hang.audio?.renditions?.[target]);
-      if (targetFec === void 0) {
-        throwRepairContractError(
-          "track_repair_depends",
-          `${d.path}.depends`,
-          `${JSON.stringify(target)} is not a video or audio rendition with FEC`
-        );
-      }
-    }
-    return assembleRepairLayers(
-      geometryOf(sourceName, `${renditionPath}.fec`, recordOf2(rendition["fec"])),
-      descriptors2,
-      throwRepairContractError
-    );
-  }
-  const msf = msfTracks(catalog);
-  const msfIndex = msf ? msf.tracks.findIndex((t) => t["name"] === sourceName) : -1;
-  if (!msf || msfIndex < 0) return void 0;
-  const track = msf.tracks[msfIndex];
-  const fec = recordOf2(track["fec"]);
-  const packagingOf = (t) => t["packaging"];
-  const fecOfTrack = (t) => {
-    const trackFec = recordOf2(t?.["fec"]);
-    return trackFec !== void 0 && trackFec["algorithm"] !== "none" ? trackFec : void 0;
-  };
-  const descriptors = [];
-  const mediaTracks = [];
-  msf.tracks.forEach((t, i) => {
-    const path = `$.tracks[${i}]`;
-    if (packagingOf(t) === "fec-repair") {
-      rejectRepairTrackGeometry(path, t, throwRepairContractError);
-      if (typeof t["name"] === "string") descriptors.push(describeRepairTrack(t["name"], path, t));
-      return;
+  /** Update the stored transport state. Called by player wiring layer. */
+  updateTransport(snapshot) {
+    this.#transport = snapshot;
+  }
+  /**
+   * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
+   * snapshots. Throws on any value outside {'full','base-only','single-track'}
+   * (CLAUDE.md: error on bad init).
+   */
+  updatePlayMode(mode) {
+    if (typeof mode !== "string" || !PLAY_MODES.includes(mode)) {
+      throw new Error(
+        `[CmcdProducer] invalid play-mode "${String(mode)}"; expected one of: ${PLAY_MODES.join(", ")}`
+      );
     }
-    rejectRepairFieldsOnMediaTrack(path, t, throwRepairContractError);
-    mediaTracks.push(t);
-  });
-  const reachability = repairReachability(mediaTracks.map((t) => t["fec"]));
-  for (const d of descriptors) {
-    validateRepairTrackFields(d, throwRepairContractError);
-    assertRepairTrackReachable(d, reachability, throwRepairContractError);
-    const target = dependsTarget(d);
-    if (target === void 0) continue;
-    const targetTrack = msf.tracks.find((t) => t["name"] === target);
-    if (targetTrack === void 0 || packagingOf(targetTrack) !== "mmtp" || fecOfTrack(targetTrack) === void 0) {
-      throwRepairContractError(
-        "track_repair_depends",
-        `${d.path}.depends`,
-        `${JSON.stringify(target)} is not an mmtp track with FEC`
+    this.#playMode = mode;
+  }
+  /**
+   * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
+   * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
+   * Omitted on single-track streams.
+   */
+  updateDeltaFailRate(rate) {
+    if (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0 || rate > 1) {
+      throw new Error(
+        `[CmcdProducer] invalid delta-fail-rate "${String(rate)}"; expected a finite number in [0, 1]`
       );
     }
+    this.#deltaFailRate = rate;
   }
-  return assembleRepairLayers(geometryOf(sourceName, `$.tracks[${msfIndex}].fec`, fec), descriptors, throwRepairContractError, {
-    layerZeroMustBeDeclared: true
-  });
-}
-function moqtPriority2(value) {
-  return Number.isSafeInteger(value) && value >= 0 && value <= 255 ? value : null;
-}
-function catalogRepairTarget(catalog, source) {
-  const repair = resolveRepairLayers(catalog, source);
-  const layerZero = repair?.baseLayers[0];
-  if (!catalog || !layerZero) return null;
-  const sourceName = typeof source === "string" ? source : source.name;
-  const msf = msfTracks(catalog);
-  const entry = msf?.tracks.find((t) => t["name"] === sourceName);
-  const sourcePriority = entry === void 0 ? null : moqtPriority2(entry["priority"]);
-  return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
-}
-function geometryOf(name, path, fec) {
-  return {
-    name,
-    path,
-    algorithm: fec?.["algorithm"],
-    sourceSymbols: fec?.["sourceSymbols"],
-    repairSymbols: fec?.["repairSymbols"],
-    repairTrack: fec?.["repairTrack"]
-  };
-}
-function numericField(value) {
-  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
-  return Number.isFinite(n) && n > 0 ? n : void 0;
-}
-function nonNegativeField(value) {
-  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
-  return Number.isFinite(n) && n >= 0 ? n : void 0;
-}
-function blockProfileUnavailable(value, path, declaresFecInstance) {
-  try {
-    readFecBlockProfile(value, path, declaresFecInstance, throwRepairContractError);
-    return void 0;
-  } catch (error) {
-    if (!(error instanceof RepairContractError) || error.code !== "track_fec_block_profile") throw error;
-    return Object.freeze({ code: "track_fec_block_profile", path: error.path, message: error.message });
+  /**
+   * Bump the cumulative switching-set misalignment counter. Emitted as
+   * `x-bc-switch-miscount` on snapshots when the counter is > 0.
+   */
+  incrementSwitchMiscount() {
+    this.#switchMiscount += 1;
   }
-}
-function isoSpanUnavailable(fec, path, declaresFecInstance) {
-  if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
-  return Object.freeze({
-    code: "track_fec",
-    path,
-    message: `[repair-layers:track_fec] ${path}: iso-ssbg1-v1 requires a block span of at least ${MIN_INTERLEAVE_DEPTH_MS} ms, which bounds its block location`
-  });
-}
-function fecParams(catalog, track, rendition, fps, sampleRate) {
-  const mediaRate = sampleRate === void 0 ? { fps } : { fps, sampleRate };
-  const fec = rendition?.fec;
-  if (!fec || !track) return { ...NO_FEC, ...mediaRate };
-  const repair = resolveRepairLayers(catalog, track);
-  const fecPath = `$.${track.type}.renditions[${JSON.stringify(track.name)}].fec`;
-  if (!catalogDeclaresFec(fec)) {
-    const declaresFecInstance = fec.algorithm !== "none";
-    const kValid = Number.isSafeInteger(fec.sourceSymbols) && (fec.sourceSymbols ?? 0) > 0;
-    const tValid = Number.isSafeInteger(fec.symbolSize) && (fec.symbolSize ?? 0) > 0;
-    if (declaresFecInstance && !(kValid && tValid)) {
-      throwRepairContractError(
-        "track_fec",
-        `${fecPath}.${kValid ? "symbolSize" : "sourceSymbols"}`,
-        "must be a positive integer"
+  updateManifestVerification(stats) {
+    this.#manifestStats = stats;
+  }
+  /**
+   * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
+   * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
+   * include the drift key until the next emitSwitchDrift(). Mirrors the
+   * existing onTransition() pattern.
+   */
+  emitSwitchDrift(driftUs) {
+    if (typeof driftUs !== "number" || !Number.isFinite(driftUs) || driftUs < 0) {
+      throw new Error(
+        `[CmcdProducer] invalid drift-us "${String(driftUs)}"; expected a non-negative finite number`
       );
     }
-    const fecUnavailable = blockProfileUnavailable(fec.blockProfile, `${fecPath}.blockProfile`, declaresFecInstance) ?? isoSpanUnavailable(fec, `${fecPath}.interleaveDepthMs`, declaresFecInstance);
-    return fecUnavailable === void 0 ? { ...NO_FEC, ...mediaRate } : { ...NO_FEC, ...mediaRate, fecUnavailable };
+    const params = {};
+    if (this.#lastStats) Object.assign(params, buildFecParams(this.#lastStats));
+    Object.assign(params, buildTransportParams(this.#transport));
+    if (this.#switchMiscount > 0) params["x-bc-switch-miscount"] = this.#switchMiscount;
+    params["x-bc-switch-drift-us"] = driftUs;
+    this.#emit(params);
   }
-  const fecBlockProfile = readFecBlockProfile(fec.blockProfile, `${fecPath}.blockProfile`, true, throwRepairContractError);
-  return {
-    fecK: fec.sourceSymbols ?? 0,
-    fecBlockProfile,
-    fecRepairCount: fec.repairSymbols ?? 0,
-    // The wire RSB_length: every base layer's packets carry the base total (§7.1).
-    fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
-    fecSymbolSize: fec.symbolSize ?? 0,
-    // interleaveDepthMs is the FEC block span in MILLISECONDS (§5.1) — the
-    // only interleave key the catalog carries post-BLO-14526. Receivers
-    // derive D by positive round-half-up of span / GOP duration where needed.
-    fecInterleaveMs: catalogFecInterleaveMs(fec) ?? 0,
-    // Additive, never a multiplier on the span: jitter belongs to the network
-    // path and the span belongs to the encoder, so scaling one by the other
-    // hands one network different slack per track. `numericField` rejects 0,
-    // so it cannot be reused here — a declared 0 is a legitimate value.
-    fecReorderToleranceMs: nonNegativeField(fec.reorderToleranceMs),
-    repairTrackName: fec.repairTrack,
-    repairLayers: repair?.baseLayers,
-    repairOverlays: repair?.overlays,
-    ...mediaRate
-  };
-}
-function resolveCatalogTrackFec(catalog, tracks) {
-  const videoTrackName = tracks.find((t) => t.type === "video")?.name;
-  const audioTrackName = tracks.find((t) => t.type === "audio")?.name;
-  const videoRenditions = catalog?.video?.renditions;
-  const audioRenditions = catalog?.audio?.renditions;
-  const video = videoTrackName ? videoRenditions?.[videoTrackName] : void 0;
-  const audio = audioTrackName ? audioRenditions?.[audioTrackName] : void 0;
-  const catalogFps = numericField(video?.framerate);
-  const sampleRate = numericField(audio?.sampleRate ?? audio?.samplerate);
-  const audioFps = sampleRate ? sampleRate / 1024 : void 0;
-  const videoParams = fecParams(catalog, videoTrackName ? { name: videoTrackName, type: "video" } : void 0, video, catalogFps);
-  const audioParams = fecParams(
-    catalog,
-    audioTrackName ? { name: audioTrackName, type: "audio" } : void 0,
-    audio,
-    audioFps,
-    sampleRate
-  );
-  const forTrack = (track) => {
-    if (track.type === "audio") {
-      if (track.name === audioTrackName) return audioParams;
-      const rendition2 = audioRenditions?.[track.name];
-      if (!rendition2) return { ...NO_FEC };
-      const rate = numericField(rendition2.sampleRate ?? rendition2.samplerate);
-      return fecParams(catalog, { name: track.name, type: "audio" }, rendition2, rate ? rate / 1024 : void 0, rate);
+  /**
+   * Process a FecTrackStats snapshot. Finds the video track, builds
+   * x-bc-* vendor keys, and fires both delivery callbacks.
+   */
+  onSnapshot(data) {
+    const videoTrack = data.tracks.find((t) => t.config.trackType === "video");
+    if (!videoTrack) return;
+    this.#lastStats = videoTrack;
+    const params = {
+      ...buildFecParams(videoTrack),
+      ...buildTransportParams(this.#transport)
+    };
+    if (this.#playMode !== null) {
+      params["x-bc-play-mode"] = this.#playMode;
     }
-    if (track.name === videoTrackName) return videoParams;
-    const rendition = videoRenditions?.[track.name];
-    if (!rendition) return { ...NO_FEC };
-    return fecParams(catalog, { name: track.name, type: "video" }, rendition, numericField(rendition.framerate));
-  };
-  return {
-    videoTrackName,
-    audioTrackName,
-    missingVideoRendition: videoTrackName && videoRenditions && !video ? videoTrackName : void 0,
-    missingAudioRendition: audioTrackName && audioRenditions && !audio ? audioTrackName : void 0,
-    videoForKeyframeRepair: video,
-    catalogFps,
-    video: videoParams,
-    audio: audioParams,
-    forTrack
-  };
-}
+    if (this.#playMode !== null && this.#playMode !== "single-track" && this.#deltaFailRate !== null) {
+      params["x-bc-delta-fail-rate"] = parseFloat(this.#deltaFailRate.toFixed(4));
+    }
+    if (this.#switchMiscount > 0) {
+      params["x-bc-switch-miscount"] = this.#switchMiscount;
+    }
+    if (this.#manifestStats) {
+      params["x-bc-manifest-verified"] = this.#manifestStats.verified > 0;
+      params["x-bc-manifest-failures"] = Object.values(this.#manifestStats.failures).reduce((total, count) => total + count, 0);
+    }
+    this.#emit(params);
+  }
+  /**
+   * Emit transport state without inventing FEC metrics. Cadence is owned by
+   * the caller because only the transport integration knows when state changed.
+   */
+  onTransportSnapshot(data) {
+    if (!Number.isFinite(data.timestampMs) || data.timestampMs < 0) {
+      throw new Error("[CmcdProducer] transport snapshot timestamp must be a non-negative finite number");
+    }
+    if (data.playMode !== void 0) this.updatePlayMode(data.playMode);
+    if (data.switchMiscount !== void 0 && (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0)) {
+      throw new Error("[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer");
+    }
+    this.#transport = data.transport;
+    const params = buildTransportParams(data.transport);
+    if (this.#playMode !== null) params["x-bc-play-mode"] = this.#playMode;
+    const switchMiscount = data.switchMiscount ?? this.#switchMiscount;
+    if (switchMiscount > 0) params["x-bc-switch-miscount"] = switchMiscount;
+    this.#emit(params);
+  }
+  /**
+   * Signal a transport transition event. Fires an immediate out-of-band
+   * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
+   * x-bc-ct (one-shot).
+   */
+  onTransition(event) {
+    const params = {};
+    if (this.#lastStats) {
+      Object.assign(params, buildFecParams(this.#lastStats));
+    }
+    Object.assign(params, buildTransportParams(this.#transport));
+    params["x-bc-ct"] = event;
+    this.#emit(params);
+  }
+  /** Fire both delivery callbacks with the given params. */
+  #emit(params) {
+    this.#onCmcdParams?.(params);
+    this.#onCmcdPost?.(formatQueryString(params));
+  }
+};
 
 // src/repair-fetch.ts
 var MOQT_PRIORITY_MAX = 255;
@@ -26201,7 +26328,7 @@ function wireRepairFetch(mc, opts) {
     if (profile === void 0) {
       throw new Error(`[RepairFetch] packetId=${packetId} has no configured fec.blockProfile`);
     }
-    return profile;
+    return parseFecBlockProfile(profile, `[RepairFetch] packetId=${packetId} fec.blockProfile`);
   };
   const execute = async (entry, run) => {
     let fed = 0;
@@ -26268,7 +26395,9 @@ function wireRepairFetch(mc, opts) {
     dispatch();
   });
   const presentationDeadlineAt = (sbn, packetId, catalogTrackName, now) => {
-    const waitDeadlineAt = now + mc.fecManager.repairFetchTimeoutMsForBlock(sbn, packetId, catalogTrackName);
+    const waitMs = mc.fecManager.repairFetchTimeoutMsForBlock(sbn, packetId, catalogTrackName);
+    if (waitMs === void 0) return null;
+    const waitDeadlineAt = now + waitMs;
     const anchor = mc.fecManager.blockAnchorAtMs(sbn, packetId, catalogTrackName);
     if (anchor === void 0) return waitDeadlineAt;
     let delayMs;
@@ -26278,7 +26407,9 @@ function wireRepairFetch(mc, opts) {
       return null;
     }
     if (!(Number.isFinite(delayMs) && delayMs > 0)) return null;
-    const ceilingAt = anchor + mc.fecManager.terminalRetentionMsForPacket(packetId);
+    const retentionMs = mc.fecManager.terminalRetentionMsForPacket(packetId);
+    if (retentionMs === void 0) return null;
+    const ceilingAt = anchor + retentionMs;
     return Math.max(waitDeadlineAt, Math.min(anchor + delayMs, ceilingAt));
   };
   mc.onRepairSubscribe((sbn, packetId, catalogTrackName, blockClass) => {
@@ -26427,7 +26558,10 @@ export {
   catalogAmtNetworkSource,
   catalogDeclaresFec,
   catalogFecInterleaveMs,
+  catalogFecMediaUnitsPerSecond,
+  catalogFecUnavailable,
   catalogGroupDurationMs,
+  catalogKeyframeCadenceMs,
   catalogRepairTarget,
   classifyH264Keyframe,
   classifyHevcKeyframe,
@@ -26483,6 +26617,7 @@ export {
   isCompleteFmp4DataUnit,
   isFecBlockProfile,
   isFecCatalogConfig,
+  isFecCatalogGeometry,
   isFmp4InitSegment,
   isHevcCodec,
   isHevcIrapNalUnitType,
@@ -26524,6 +26659,7 @@ export {
   repairReachability,
   resolveCatalogTrackFec,
   resolveCatalogTrackGroupDurationMs,
+  resolveDeltaFallback,
   resolveFecState,
   resolveGlobalMmtWasmBindings,
   resolveGroupDurationMs,