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

package/dist/multicast-manager.js

@@ -1,78 +1,17 @@
-// ../mmt-alta-parse/dist/index.js
+// ../mmt-base/dist/mmtp.js
 var MMTP_HEADER_SIZE = 12;
 var MPU_HEADER_SIZE = 8;
-var MPU_LENGTH_FIELD_SIZE = 2;
-var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
-var TIMED_MFU_DU_HEADER_SIZE = 14;
-var NONTIMED_MFU_DU_HEADER_SIZE = 4;
-var PACKET_TYPE_MPU = 0;
-var MMTP_EXT_TYPE_ALTA_AUTH = 61601;
-var MMTP_EXT_TRAILER_HEADER_SIZE = 4;
-function extractAltaTrailer(mmtpPacket, options) {
-  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
-    return null;
-  const packetType = mmtpPacket[1] & 63;
-  if (packetType !== PACKET_TYPE_MPU)
-    return null;
-  const fecType = mmtpPacket[0] >> 3 & 3;
-  let headerLength = MMTP_HEADER_SIZE;
-  if (fecType < 2 && (mmtpPacket[0] & 32) !== 0)
-    headerLength += 4;
-  if (fecType < 2 && (mmtpPacket[0] & 2) !== 0) {
-    if (headerLength + 4 > mmtpPacket.length)
-      return null;
-    const extensionLength = new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + headerLength + 2, 2).getUint16(0, false);
-    headerLength += 4 + extensionLength;
-  }
-  if (headerLength + MPU_HEADER_SIZE > mmtpPacket.length)
-    return null;
-  const payload = mmtpPacket.subarray(headerLength);
-  const payloadLength = payload[0] << 8 | payload[1];
-  const flagsByte = payload[2];
-  const fragmentType = flagsByte >> 4 & 15;
-  const timed = (flagsByte >> 3 & 1) === 1;
-  const fragmentationIndicator = flagsByte >> 1 & 3;
-  if (fragmentType !== 2)
-    return null;
-  const dataUnitHeaderSize = fragmentationIndicator <= 1 ? timed ? TIMED_MFU_DU_HEADER_SIZE : NONTIMED_MFU_DU_HEADER_SIZE : 0;
-  if (payloadLength <= MPU_HEADER_REMAINDER_SIZE + dataUnitHeaderSize)
-    return null;
-  if (fecType > 1)
-    return null;
-  const hasFecId = !options?.skipFecId && fecType === 1;
-  const payloadEnd = hasFecId ? payload.length - 4 : payload.length;
-  const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength;
-  if (declaredEnd > payloadEnd)
-    return null;
-  if (declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE > payloadEnd)
-    return null;
-  const extType = payload[declaredEnd] << 8 | payload[declaredEnd + 1];
-  if (extType !== MMTP_EXT_TYPE_ALTA_AUTH)
-    return null;
-  const extLen = payload[declaredEnd + 2] << 8 | payload[declaredEnd + 3];
-  const authStart = declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE;
-  if (authStart + extLen !== payloadEnd)
-    return null;
-  return {
-    auth: payload.subarray(authStart, payloadEnd),
-    signedEnd: headerLength + declaredEnd
-  };
-}
-
-// ../mmt-base/dist/mmtp.js
-var MMTP_HEADER_SIZE2 = 12;
-var MPU_HEADER_SIZE2 = 8;
 var MFU_DU_HEADER_SIZE_TIMED = 14;
 var MFU_DU_HEADER_SIZE_NONTIMED = 4;
-var MPU_LENGTH_FIELD_SIZE2 = 2;
-var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
 var SOURCE_FEC_PAYLOAD_ID_SIZE = 4;
-var PACKET_TYPE_MPU2 = 0;
+var PACKET_TYPE_MPU = 0;
 var PACKET_TYPE_REPAIR = 3;
 var MMTP_SIGNALING_PACKET_ID = 0;
 var MMTP_PACKET_ID_MAX = 65535;
 function parseMMTPHeader(buffer) {
-  if (buffer.length < MMTP_HEADER_SIZE2) {
+  if (buffer.length < MMTP_HEADER_SIZE) {
     throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
   }
   const view2 = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -128,12 +67,12 @@ function parseMMTPHeader(buffer) {
   };
 }
 function readMMTPPacketId(buffer) {
-  if (buffer.length < MMTP_HEADER_SIZE2)
+  if (buffer.length < MMTP_HEADER_SIZE)
     return null;
   const flags = buffer[0];
   if ((flags >> 6 & 3) !== 0)
     return null;
-  let offset = MMTP_HEADER_SIZE2;
+  let offset = MMTP_HEADER_SIZE;
   if ((flags & 32) !== 0) {
     if (offset + 4 > buffer.length)
       return null;
@@ -149,7 +88,7 @@ function readMMTPPacketId(buffer) {
   return buffer[2] << 8 | buffer[3];
 }
 function parseMPUHeader(payload) {
-  if (payload.length < MPU_HEADER_SIZE2) {
+  if (payload.length < MPU_HEADER_SIZE) {
     throw new Error(`Payload too small for MPU header: ${payload.length} bytes`);
   }
   const view2 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
@@ -182,15 +121,15 @@ function parseTimedMfuDuHeader(payload, offset) {
   };
 }
 function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
-  if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE2) {
+  if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE) {
     return {
       rejection: {
         gate: "mpu-payload-length-below-header-remainder",
-        detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE2}`
+        detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE}`
       }
     };
   }
-  const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + mpu.payloadLength;
+  const declaredEnd = MPU_LENGTH_FIELD_SIZE + mpu.payloadLength;
   if (declaredEnd > payload.length) {
     return {
       rejection: {
@@ -201,7 +140,7 @@ function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
   }
   const hasHeader = fragmentType === 2 && mpu.fragmentationIndicator <= 1;
   const mfuHeaderSize = mpu.timedFlag ? MFU_DU_HEADER_SIZE_TIMED : MFU_DU_HEADER_SIZE_NONTIMED;
-  const mfuOffset = MPU_HEADER_SIZE2 + (hasHeader ? mfuHeaderSize : 0);
+  const mfuOffset = MPU_HEADER_SIZE + (hasHeader ? mfuHeaderSize : 0);
   if (mfuOffset >= declaredEnd) {
     return {
       rejection: {
@@ -218,44 +157,46 @@ function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
     }
   };
 }
-function isEmptyOrExactAltaTrailer(payload, start, end) {
+var LEGACY_TRAILER_EXT_TYPE = 61601;
+var LEGACY_TRAILER_HEADER_SIZE = 4;
+function isEmptyOrExactLegacyTrailer(payload, start, end) {
   if (start === end)
     return true;
-  if (start < 0 || end > payload.length || start + MMTP_EXT_TRAILER_HEADER_SIZE > end) {
+  if (start < 0 || end > payload.length || start + LEGACY_TRAILER_HEADER_SIZE > end) {
     return false;
   }
   const view2 = new DataView(payload.buffer, payload.byteOffset + start, end - start);
-  if (view2.getUint16(0, false) !== MMTP_EXT_TYPE_ALTA_AUTH)
+  if (view2.getUint16(0, false) !== LEGACY_TRAILER_EXT_TYPE)
     return false;
   const authLength = view2.getUint16(2, false);
-  return start + MMTP_EXT_TRAILER_HEADER_SIZE + authLength === end;
+  return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
 }
 function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
   if (declaredEnd > payload.length)
     return null;
   if (options?.skipFecId) {
-    return isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
+    return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
   }
   if (fecType === 1) {
     const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
-    if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {
+    if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
       return null;
     }
     return { hasFecId: true };
   }
   if (fecType !== 0)
     return null;
-  if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {
+  if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
     return { hasFecId: false };
   }
   return null;
 }
 function planMfuExtraction(mmtpPacket, options, parsedHeader) {
-  if (mmtpPacket.length < MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2) {
+  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {
     return {
       rejection: {
         gate: "packet-shorter-than-mmtp-plus-mpu-header",
-        detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2}`
+        detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE + MPU_HEADER_SIZE}`
       }
     };
   }
@@ -274,7 +215,7 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
       };
     }
   }
-  if (header.packetType !== PACKET_TYPE_MPU2) {
+  if (header.packetType !== PACKET_TYPE_MPU) {
     return {
       rejection: {
         gate: "not-an-mpu-packet",
@@ -283,11 +224,11 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
     };
   }
   const payload = mmtpPacket.subarray(header.headerLength);
-  if (payload.length < MPU_HEADER_SIZE2) {
+  if (payload.length < MPU_HEADER_SIZE) {
     return {
       rejection: {
         gate: "payload-shorter-than-mpu-header",
-        detail: `${payload.length} bytes < ${MPU_HEADER_SIZE2}`
+        detail: `${payload.length} bytes < ${MPU_HEADER_SIZE}`
       }
     };
   }
@@ -318,7 +259,7 @@ function planMfuExtraction(mmtpPacket, options, parsedHeader) {
     return {
       rejection: {
         gate: "declared-trailers-unresolved",
-        detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact ALTA trailer (fecType=${header.fecType})`
+        detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact legacy authenticator trailer (fecType=${header.fecType})`
       }
     };
   }
@@ -334,8 +275,8 @@ function extractPlannedMfu(mmtpPacket, result) {
   const mfuDuHeaderPresent = layout.hasMfuDuHeader;
   const mfuOffset = layout.mfuOffset;
   const dataEnd = layout.dataEnd;
-  const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE2) : null;
-  const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE2, 4).getUint32(0, false) : null;
+  const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE) : null;
+  const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false) : null;
   const data = payload.subarray(mfuOffset, dataEnd);
   const fecPayloadId = trailerLayout.hasFecId ? {
     ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, SOURCE_FEC_PAYLOAD_ID_SIZE).getUint32(0, false)
@@ -343,17 +284,17 @@ function extractPlannedMfu(mmtpPacket, result) {
   return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
 }
 function sourceFecPayloadIdOf(mmtpPacket, header) {
-  if (mmtpPacket.length < MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2)
+  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
     return null;
-  if (header.packetType !== PACKET_TYPE_MPU2)
+  if (header.packetType !== PACKET_TYPE_MPU)
     return null;
   const payload = mmtpPacket.subarray(header.headerLength);
-  if (payload.length < MPU_HEADER_SIZE2)
+  if (payload.length < MPU_HEADER_SIZE)
     return null;
   const payloadLength = payload[0] << 8 | payload[1];
-  if (payloadLength < MPU_HEADER_REMAINDER_SIZE2)
+  if (payloadLength < MPU_HEADER_REMAINDER_SIZE)
     return null;
-  const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + payloadLength;
+  const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength;
   if (!resolveDeclaredTrailers(payload, declaredEnd, header.fecType)?.hasFecId)
     return null;
   const off = mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
@@ -361,7 +302,6 @@ function sourceFecPayloadIdOf(mmtpPacket, header) {
     ssId: (mmtpPacket[off] << 24 | mmtpPacket[off + 1] << 16 | mmtpPacket[off + 2] << 8 | mmtpPacket[off + 3]) >>> 0
   };
 }
-var extractAltaTrailer2 = extractAltaTrailer;
 var REPAIR_FEC_PID_SIZE = 13;
 function readRepairFecPayloadIdFields(mmtpPacket, parsedHeader) {
   let header;
@@ -441,49 +381,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) {
@@ -508,20 +420,22 @@ function isoBlocksBehindLowerBound(a, b, kMax) {
 // src/track-session.ts
 import { fecBlockBudgetMs } from "@blockcast/mmt-fec";
 function computeFecDeliveryWindowMs(config) {
-  const fecInterleaveMs = config.interleaveDepthMs;
   const fecK = config.sourceSymbols;
-  if (!Number.isFinite(fecInterleaveMs) || fecInterleaveMs <= 0) {
+  if (!Number.isFinite(fecK) || fecK <= 0) {
     throw new Error(
-      `[TrackSession] fecInterleaveMs=${fecInterleaveMs}. Derive a positive FEC interleave window from the stream catalog.`
+      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
     );
   }
-  if (!Number.isFinite(fecK) || fecK <= 0) {
+  return fecSpanDeliveryWindowMs(config.interleaveDepthMs, config.jitterBufferMs);
+}
+function fecSpanDeliveryWindowMs(interleaveDepthMs, jitterBufferMs) {
+  if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
     throw new Error(
-      `[TrackSession] fecK=${fecK}. Derive a positive FEC source-symbol count from the stream catalog.`
+      `[TrackSession] fecInterleaveMs=${interleaveDepthMs}. Derive a positive FEC interleave window from the stream catalog.`
     );
   }
-  if (config.jitterBufferMs === void 0) return Math.ceil(fecInterleaveMs);
-  return fecBlockBudgetMs(fecInterleaveMs, config.jitterBufferMs);
+  if (jitterBufferMs === void 0) return Math.ceil(interleaveDepthMs);
+  return fecBlockBudgetMs(interleaveDepthMs, jitterBufferMs);
 }
 
 // src/delivery-gap.ts
@@ -613,7 +527,9 @@ var DeliveryGapEstimator = class {
 import {
   deriveFecInterleaveDepth as deriveFecInterleaveDepth2,
   deriveFecRetentionBlocks,
-  tryDeriveFecRetentionBlocks
+  tryDeriveFecRetentionBlocks,
+  LOCAL_FEC_RETENTION_BLOCKS,
+  LOCAL_FEC_TIMEOUT_MS
 } from "@blockcast/mmt-fec";
 
 // src/iso-block-locator.ts
@@ -847,7 +763,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",
@@ -858,6 +774,15 @@ var INACTIVE = Object.freeze({
   "reliable-moq": Object.freeze({ state: "inactive", reason: "reliable-moq" }),
   "no-multicast-bridge": Object.freeze({ state: "inactive", reason: "no-multicast-bridge" })
 });
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function isoBlockSpanUsable(fec) {
+  const block = recordOf(fec);
+  if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1") return true;
+  const ms = block["interleaveDepthMs"];
+  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
+}
 
 // src/block-policy.ts
 import { deriveFecInterleaveDepth } from "@blockcast/mmt-fec";
@@ -1366,7 +1291,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.
@@ -1381,10 +1305,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();
@@ -1424,14 +1347,17 @@ 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;
     this.#blockRepairRsIds = /* @__PURE__ */ new Map();
+    // RSB_length per block (C.5.3 Repair FEC Payload ID): how many repair
+    // symbols its repair group carries. Same lifecycle as #blockRepairRsIds.
+    this.#blockRsbLengths = /* @__PURE__ */ new Map();
     // Blocks already recovered — prevents late source symbols from restarting timeouts.
     // WASM removes blocks after recovery; late symbols create empty blocks returning null,
     // which would falsely start new timeouts without this guard.
@@ -1544,14 +1470,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).
@@ -1645,7 +1573,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;
@@ -1667,6 +1598,7 @@ var FECManager = class _FECManager {
   #blockAuthoredLengths;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
+  #blockRsbLengths;
   #completedBlocks;
   #terminalExpiryMs;
   #terminalQueues;
@@ -1807,7 +1739,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) {
@@ -1843,8 +1776,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
@@ -1857,6 +1791,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}.`
@@ -1870,7 +1812,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
@@ -1910,6 +1852,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);
@@ -1942,19 +1887,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) {
@@ -1988,7 +1934,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;
@@ -2023,7 +1969,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;
     }
@@ -2179,7 +2125,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);
@@ -2259,6 +2205,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";
@@ -2280,8 +2227,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.
@@ -2290,27 +2237,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);
@@ -2319,7 +2267,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 });
       }
     };
@@ -2335,9 +2283,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;
@@ -2348,15 +2296,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);
       }
@@ -2368,48 +2310,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.
+   * 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, 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;
+  #blockPrecedes(a, b) {
+    return serial32Precedes(a, b);
   }
-  /** Blocks `a` lies behind `b` (0 when it does not precede it). */
+  /**
+   * Blocks `a` lies behind `b` (0 when it does not precede it). Blocks vary
+   * in length (K' = SSB_length <= K), so only a lower bound is known: the one
+   * metric the decoder and the worker retire by too.
+   */
   #blocksBehind(a, 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);
-  }
-  /** 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;
+    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);
@@ -2448,21 +2373,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({
@@ -2487,14 +2430,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);
   }
   /**
@@ -2522,6 +2468,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;
@@ -2536,10 +2483,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);
@@ -2555,6 +2504,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) {
@@ -2641,51 +2591,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))) {
@@ -2700,20 +2671,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)];
@@ -2774,7 +2739,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
       };
@@ -2786,7 +2751,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,
@@ -2799,7 +2764,6 @@ var FECManager = class _FECManager {
         },
         blocks: stats.blocks.map((block) => ({ ...block })),
         decoder: stats.decoder ? { ...stats.decoder } : void 0,
-        altaFailedDetails: stats.altaFailedDetails?.map((detail) => ({ ...detail })),
         packetId
       })),
       repairSymbolSizeMismatches: this.#repairSymbolSizeMismatchCount,
@@ -2906,6 +2870,7 @@ var FECManager = class _FECManager {
     resetMap(this.#blockSourceEsis);
     resetMap(this.#blockAuthoredLengths);
     resetMap(this.#blockRepairRsIds);
+    resetMap(this.#blockRsbLengths);
     resetMap(this.#blockPathCounts);
     resetMap(this.#blockAnchorsMs);
     resetMap(this.#blockCatalogTrackNames);
@@ -3023,6 +2988,7 @@ var FECManager = class _FECManager {
     dropMap(this.#blockSourceEsis);
     dropMap(this.#blockAuthoredLengths);
     dropMap(this.#blockRepairRsIds);
+    dropMap(this.#blockRsbLengths);
     dropMap(this.#blockPathCounts);
     dropMap(this.#blockAnchorsMs);
     dropMap(this.#blockCatalogTrackNames);
@@ -3081,15 +3047,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);
@@ -3207,14 +3178,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 });
       }
     }
@@ -3225,25 +3196,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
@@ -3261,7 +3230,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
@@ -3273,6 +3243,31 @@ var FECManager = class _FECManager {
       windowMs: this.#deliveryGaps.windowMs
     };
   }
+  /**
+   * An open block's accepted sources, distinct repair RS_IDs, authored K'
+   * (SSB_length) and RSB_length (each undefined until a repair stated it).
+   * Undefined for a block that is not open.
+   */
+  blockSymbolCounts(sbn, packetId, catalogTrackName) {
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (!this.#activeBlocks.has(key)) return void 0;
+    return {
+      sources: this.#blockSourceCounts.get(key) ?? 0,
+      repairs: this.#blockRepairRsIds.get(key)?.size ?? 0,
+      authoredLength: this.#blockAuthoredLengths.get(key),
+      repairGroupLength: this.#blockRsbLengths.get(key)
+    };
+  }
+  /**
+   * Record a block's RSB_length from one of its repair symbols (the router
+   * parses it from the Repair FEC Payload ID). The largest stated value wins.
+   */
+  noteRepairGroupLength(sbn, packetId, rsbLength, catalogTrackName) {
+    if (!Number.isSafeInteger(rsbLength) || rsbLength <= 0) return;
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (!this.#activeBlocks.has(key)) return;
+    if ((this.#blockRsbLengths.get(key) ?? 0) < rsbLength) this.#blockRsbLengths.set(key, rsbLength);
+  }
   /**
    * Receiver-local time of a block's first accepted symbol, or undefined for
    * a block no symbol reached (one materialized because a later SBN arrived).
@@ -3317,27 +3312,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. */
@@ -3348,7 +3347,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. */
@@ -3359,14 +3359,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;
@@ -3397,12 +3402,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`);
     }
@@ -3410,7 +3417,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
@@ -3471,11 +3479,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.
    */
@@ -3543,6 +3551,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 };
   }
@@ -3552,10 +3561,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);
@@ -3577,7 +3588,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,
@@ -3593,27 +3604,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 });
       }
     }
@@ -3672,7 +3690,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) => {
@@ -3852,7 +3870,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);
   }
@@ -3893,16 +3911,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,
@@ -3931,51 +3944,33 @@ var FECManager = class _FECManager {
    *          Caller is responsible for routing recovered data and updating
    *          block completion state via `markBlockCompleted()`.
    */
-  feedSourceSymbol(packetId, ssId, symbolData, alta, catalogTrackName) {
+  feedSourceSymbol(packetId, ssId, symbolData, 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(
-          alta.auth.byteOffset,
-          alta.auth.byteOffset + alta.auth.byteLength
-        );
-        workerClient.feedSource(ssId, buf, performance.now(), {
-          auth: authBuf,
-          payloadEnd: alta.payloadEnd
-        });
-      } else {
-        workerClient.feedSource(ssId, buf, performance.now());
-      }
+      workerClient.feedSource(ssId, buf, performance.now());
       return null;
     }
     const entry = this.#decoderForPacket(packetId, catalogTrackName);
@@ -3985,7 +3980,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);
@@ -4004,7 +3999,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) {
@@ -4015,18 +4011,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);
@@ -4064,8 +4054,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);
@@ -4132,7 +4123,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 {
@@ -4177,11 +4168,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);
@@ -4214,6 +4207,7 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
+    this.#blockRsbLengths.delete(key);
     this.#markTerminal(key, sbn, packetId, true);
     this.#markPathBlockComplete(sbn, packetId, catalogTrackName);
     if (catalogTrackName === void 0) {
@@ -4225,6 +4219,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;
@@ -4234,13 +4229,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,
@@ -4264,6 +4259,7 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
+    this.#blockRsbLengths.delete(key);
     this.#syncDecoderBlockOwners.delete(key);
     this.#markTerminal(key, sbn, packetId, false);
     this.#failedBlocks.add(key);
@@ -4301,6 +4297,7 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
+    this.#blockRsbLengths.delete(key);
     this.#clearBlockTimer(key);
     this.onBlockResolved?.(block.sbn, block.packetId, block.catalogTrackName);
   }
@@ -4310,6 +4307,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);
     }
@@ -4390,6 +4388,7 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis.clear();
     this.#blockAuthoredLengths.clear();
     this.#blockRepairRsIds.clear();
+    this.#blockRsbLengths.clear();
     this.#completedBlocks.clear();
     this.#cleanlyCompletedBlocks.clear();
     this.#repairRequestedBlocks.clear();
@@ -8526,7 +8525,6 @@ var CmafBlockAssembler = class {
       failedBlocks: 0
     };
     this.#config = {
-      k: config.k,
       timescale: config.timescale ?? 1e6,
       trackId: config.trackId ?? 1,
       trackType: config.trackType,
@@ -10627,6 +10625,42 @@ var FecReleaseSequencer = class {
     for (const stream of this.#streams.values()) total += stream.buf.length;
     return total;
   }
+  #deferDepth = 0;
+  #deferredStreams = /* @__PURE__ */ new Set();
+  /**
+   * Run `work` with the drains its pushes would run deferred to its end. A
+   * recovered FEC block is routed one frame at a time, and its block is
+   * already resolved when the first frame is pushed: draining on that push
+   * would release past the gap before the block's other recovered frames
+   * arrive (deciding a conceal or stall for media that is about to land),
+   * and those frames would then be dropped as stale. Nests.
+   */
+  defer(work) {
+    this.#deferDepth++;
+    let threw = true;
+    try {
+      work();
+      threw = false;
+    } finally {
+      this.#deferDepth--;
+      if (this.#deferDepth === 0 && this.#deferredStreams.size > 0) {
+        const streams = [...this.#deferredStreams];
+        this.#deferredStreams.clear();
+        if (!threw) {
+          for (const stream of streams) this.#drain(stream);
+        } else {
+          try {
+            for (const stream of streams) this.#drain(stream);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  #drainUnlessDeferred(stream) {
+    if (this.#deferDepth > 0) this.#deferredStreams.add(stream);
+    else this.#drain(stream);
+  }
   push(streamKey, data, meta, seq) {
     const frame = { data, meta: { ...meta }, seq, arrivedAtMs: performance.now() };
     const stream = this.#streamFor(streamKey, meta);
@@ -10648,7 +10682,7 @@ var FecReleaseSequencer = class {
         return;
       }
       this.#release(stream, frame, void 0);
-      this.#drain(stream);
+      this.#drainUnlessDeferred(stream);
       return;
     }
     let lo = 0;
@@ -10659,7 +10693,23 @@ var FecReleaseSequencer = class {
       else hi = mid;
     }
     stream.buf.splice(lo, 0, frame);
-    this.#drain(stream);
+    this.#drainUnlessDeferred(stream);
+  }
+  /**
+   * Arrival time of the earliest frame a stream of `packetId` holds behind a
+   * gap (the gate forces it out `holdLimitMs` after that), or undefined when
+   * none is held. Without `catalogTrackName`, every stream of the packetId.
+   */
+  earliestHeldArrivalMs(packetId, catalogTrackName) {
+    let earliest;
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue;
+      if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+      for (const frame of stream.buf) {
+        if (earliest === void 0 || frame.arrivedAtMs < earliest) earliest = frame.arrivedAtMs;
+      }
+    }
+    return earliest;
   }
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey) {
@@ -10712,6 +10762,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;
@@ -11080,6 +11145,22 @@ var MmtpContainerParser = class _MmtpContainerParser {
       }
     ) : null;
   }
+  /**
+   * Run `work` with the FEC release gate's drains deferred to its end, so
+   * every frame it pushes is in place before any held gap is decided (see
+   * FecReleaseSequencer.defer).
+   */
+  deferFecRelease(work) {
+    if (!this.#fecSequencer) {
+      work();
+      return;
+    }
+    this.#fecSequencer.defer(work);
+  }
+  /** See FecReleaseSequencer.earliestHeldArrivalMs. */
+  fecReleaseEarliestHeldAtMs(packetId, catalogTrackName) {
+    return this.#fecSequencer?.earliestHeldArrivalMs(packetId, catalogTrackName);
+  }
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId, catalogTrackName) {
     if (!this.#fecSequencer) return;
@@ -11094,6 +11175,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.
@@ -11274,7 +11362,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const parsed = preParsed !== void 0 && preParsed.skipFecPayloadId === (options?.skipFecPayloadId === true) ? preParsed : this.parsePacket(packet, options);
     if (!parsed) return this.#drop("header-parse-failed");
     const info = parsed.info;
-    if (info.packetType !== PACKET_TYPE_MPU2) {
+    if (info.packetType !== PACKET_TYPE_MPU) {
       return {
         kind: info.isRepair ? "repair" : "non-media",
         packet: info,
@@ -11283,10 +11371,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
     }
     if (info.fecPayloadId !== null && this.#sourceSymbolCb) {
       const rawSymbol = packet.subarray(0, packet.length - 4);
-      const altaTrailer = extractAltaTrailer2(packet);
-      const alta = altaTrailer ? { auth: altaTrailer.auth, payloadEnd: altaTrailer.signedEnd } : void 0;
       try {
-        this.#sourceSymbolCb(info.packetId, info.fecPayloadId.ssId, rawSymbol, alta);
+        this.#sourceSymbolCb(info.packetId, info.fecPayloadId.ssId, rawSymbol);
       } catch {
       }
     }
@@ -12411,6 +12497,8 @@ var MmtpRouter = class {
   // ── Keyframe loss detection state ───────────────────────────────
   /** Catalog-derived keyframe loss timeout (ms), or a reader evaluated at each arm. null = not configured (warns on video track registration; Phase-13 keyframe repair stays off). */
   #keyframeLostTimeoutMs;
+  /** packetIds already warned for running without Phase 13 (non-FEC video only). */
+  #warnedNoKeyframeLostTimeout = /* @__PURE__ */ new Set();
   /** Why the last reader evaluation left the timer unarmed; null while arming. Dedups the warning. */
   #keyframeLostUnarmedReason = null;
   /** Active keyframe loss timer handle. Single timer per video track — cleared on each rapFlag and on dispose(). */
@@ -12426,6 +12514,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;
@@ -12622,15 +12712,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;
@@ -12718,7 +12817,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.
@@ -12729,15 +12828,14 @@ var MmtpRouter = class {
   }
   /** Register MMTP packetId → track type mapping.
    *  Call BEFORE packets arrive to ensure correct routing from the first packet.
-   *  If keyframeLostTimeoutMs is not provided, Phase 13 keyframe repair is
-   *  disabled (video still routes/decodes normally). framerate is OPTIONAL per
-   *  draft-ietf-moq-catalogformat-01 §3.2.23, so we can't require the timeout. */
+   *  Without keyframeLostTimeoutMs a track WITHOUT FEC has no Phase 13
+   *  keyframe repair (video still routes/decodes normally); that is warned at
+   *  its first keyframe, once the FEC configuration is known (see
+   *  #noteEmittedKeyframe). Nothing is warned here: an FEC track never uses
+   *  the timer, and at registration the FEC configuration may not be applied
+   *  yet. framerate is OPTIONAL per draft-ietf-moq-catalogformat-01 §3.2.23,
+   *  so we can't require the timeout. */
   setPacketIdType(packetId, trackType) {
-    if (trackType === "video" && this.#keyframeLostTimeoutMs === null) {
-      console.warn(
-        "[MmtpRouter] keyframeLostTimeoutMs not configured \u2014 Phase 13 keyframe repair disabled for this track. Set it via setKeyframeLostTimeoutMs() or provide in constructor config to enable: Math.ceil(groupDurationMs * KEYFRAME_LOST_TIMEOUT_SLACK)."
-      );
-    }
     if (trackType === "video") this.#videoPacketIds.add(packetId);
     else this.#audioPacketIds.add(packetId);
     const codec = this.#trackCodecs.get(packetId) ?? "";
@@ -12788,7 +12886,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;
   }
@@ -12802,17 +12908,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;
   }
@@ -12921,6 +13026,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);
@@ -13040,87 +13160,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);
@@ -13128,9 +13182,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.
@@ -13144,8 +13199,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
@@ -13164,21 +13227,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;
@@ -13204,6 +13266,7 @@ var MmtpRouter = class {
       catalogTrackName
     )) return;
     fec.noteBlockActivity?.(blockStart, ownerPacketId, catalogTrackName);
+    fec.noteRepairGroupLength?.(blockStart, ownerPacketId, repair.rsbLength, catalogTrackName);
     const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
     const recovered = fec.feedRepairSymbol(
       ownerPacketId,
@@ -13245,7 +13308,7 @@ var MmtpRouter = class {
       }
       if (payload.oversized) continue;
       const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-      const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, void 0, catalogTrackName);
+      const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, catalogTrackName);
       if (!recovered || alreadyCompleted) continue;
       fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
       fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
@@ -13270,9 +13333,10 @@ 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);
+    this.#withDeferredFecPokes(() => this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName));
   }
   /** Route a single recovered source symbol through the parser + dedup pipeline.
    *  Worker-backed decoders emit one padded source symbol per frame event. */
@@ -13686,8 +13750,16 @@ var MmtpRouter = class {
   #noteEmittedKeyframe(packetId, keyframe) {
     if (!keyframe) return;
     if (!this.#videoPacketIds.has(packetId)) return;
-    if (this.#keyframeLostTimeoutMs === null) return;
     if (this.#isFecTrack(packetId)) return;
+    if (this.#keyframeLostTimeoutMs === null) {
+      if (!this.#warnedNoKeyframeLostTimeout.has(packetId)) {
+        this.#warnedNoKeyframeLostTimeout.add(packetId);
+        console.warn(
+          `[MmtpRouter] keyframeLostTimeoutMs not configured \u2014 Phase 13 keyframe repair disabled for packetId=${packetId}, a video track without FEC. Set it via setKeyframeLostTimeoutMs() or provide in constructor config to enable.`
+        );
+      }
+      return;
+    }
     this.#lastKeyframeGroupId++;
     this.#armKeyframeLostTimer();
   }
@@ -13699,7 +13771,7 @@ var MmtpRouter = class {
   #withDeferredFecPokes(work) {
     this.#fecPokeDepth++;
     try {
-      work();
+      this.#parser.deferFecRelease(work);
     } finally {
       this.#fecPokeDepth--;
       if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
@@ -13711,6 +13783,13 @@ var MmtpRouter = class {
       }
     }
   }
+  /**
+   * Arrival time of the earliest frame the FEC release gate holds for this
+   * stream (see FecReleaseSequencer.earliestHeldArrivalMs), or undefined.
+   */
+  fecReleaseEarliestHeldAtMs(packetId, catalogTrackName) {
+    return this.#parser.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
+  }
   #requestFecPoke(packetId, catalogTrackName) {
     if (this.#disposed) return;
     if (this.#fecPokeDepth > 0) {
@@ -13738,29 +13817,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);
@@ -13822,9 +13891,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;
@@ -13837,7 +13907,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);
@@ -13887,8 +13957,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)`
@@ -13930,9 +14001,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,
@@ -13984,79 +14055,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;
@@ -14080,8 +14079,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++;
@@ -14096,9 +14095,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(
@@ -14133,7 +14131,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);
@@ -14167,12 +14165,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,
@@ -14193,13 +14192,11 @@ var MmtpRouter = class {
         const recovered = catalogTrackName === void 0 ? this.#fecManager.feedSourceSymbol(
           info.packetId,
           sourceFec.ssId,
-          sourceFec.symbolData,
-          void 0
+          sourceFec.symbolData
         ) : this.#fecManager.feedSourceSymbol(
           info.packetId,
           sourceFec.ssId,
           sourceFec.symbolData,
-          void 0,
           catalogTrackName
         );
         if (recovered) {
@@ -14606,7 +14603,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");
@@ -14619,7 +14615,6 @@ var MmtpRouter = class {
     }
     const symbolSize = packetSymbolSize;
     const result = processFecBlock(recovered, {
-      ...blockProfile === "k-padded-v1" ? { k } : {},
       symbolSize,
       ownerPacketId,
       blockProfile
@@ -14699,8 +14694,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,
         () => {
@@ -14803,7 +14797,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;
@@ -14915,7 +14909,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;
@@ -15052,7 +15046,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 {
@@ -15131,7 +15125,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 }
             });
           }
@@ -15166,7 +15160,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;
@@ -15217,22 +15211,17 @@ var MoqFecAlgorithm;
   MoqFecAlgorithm2[MoqFecAlgorithm2["RaptorQ"] = 2] = "RaptorQ";
 })(MoqFecAlgorithm || (MoqFecAlgorithm = {}));
 
-// node_modules/@blockcast/mmt-transport/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
-var MPU_HEADER_SIZE4 = 8;
-var MPU_LENGTH_FIELD_SIZE4 = 2;
-var MPU_HEADER_REMAINDER_SIZE4 = MPU_HEADER_SIZE4 - MPU_LENGTH_FIELD_SIZE4;
+// node_modules/@blockcast/mmt-base/dist/mmtp.js
+var MPU_HEADER_SIZE2 = 8;
+var MPU_LENGTH_FIELD_SIZE2 = 2;
+var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
 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);
@@ -15253,9 +15242,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"
 ]);
 
@@ -15647,10 +15635,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;
@@ -15717,6 +15707,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).
@@ -16756,7 +16767,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
@@ -17061,14 +17072,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)));
     }
@@ -17394,7 +17411,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"
       );
@@ -17404,7 +17422,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));
@@ -17438,6 +17456,35 @@ var BASE64URL_DECODE_TABLE = (() => {
   return table;
 })();
 
+// src/repair-layers.ts
+var RepairContractError = class extends Error {
+  constructor(code, path, message) {
+    super(`[repair-layers:${code}] ${path}: ${message}`);
+    this.code = code;
+    this.path = path;
+    this.name = "RepairContractError";
+  }
+};
+var throwRepairContractError = (code, path, message) => {
+  throw new RepairContractError(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) {
+    return fail("track_fec_block_profile", path, error.message);
+  }
+}
+
 // src/carp-catalog.ts
 var VALID_ROLE_SUFFIXES = /* @__PURE__ */ new Set(["base", "delta", "repair"]);
 function parseTrackRole(trackName) {
@@ -17477,12 +17524,49 @@ 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;
+}
+
+// src/catalog-fec-params.ts
+import { catalogFecInterleaveMs } from "@blockcast/mmt-fec";
+var MAX_SAFE_TICKS_PER_HZ = Number.MAX_SAFE_INTEGER / 1e3;
+function recordOf2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : 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);
 }
 
 // src/multicast-manager.ts
@@ -17516,6 +17600,13 @@ function newBlockPolicyStats(packetId, catalogTrackName, epoch) {
     deltaRepairsPreempted: 0,
     deltaRepairsDeferred: 0,
     repairsSkipped: 0,
+    repairsSkippedRttUnmeasured: 0,
+    repairsSkippedRttExceedsBudget: 0,
+    repairsSkippedPresentationDelayUnavailable: 0,
+    lastRepairSkip: null,
+    keyframeRepairFetchesSent: 0,
+    keyframeBudgetHolds: 0,
+    keyframeBudgetHoldMs: 0,
     deltaBlocksFailed: 0,
     audioBlocksRecoveredInband: 0,
     audioBlocksRecoveredQuic: 0,
@@ -17728,7 +17819,10 @@ function projectFecDiagnosticBlock(block) {
     lastSymbolTs: block.lastSymbolTs,
     ...block.completedTs === void 0 ? {} : { completedTs: block.completedTs },
     deadlineTs: block.deadlineTs,
-    altaVerified: block.altaVerified,
+    // ponytail: the per-packet authenticator is gone, so this is always 0. It
+    // stays only because pim-multicast-gateway's normalizeSubscriptionDiagnostics
+    // still requires a number here; drop it once that validator stops asking.
+    altaVerified: 0,
     relayBlockSigValid: block.relayBlockSigValid
   };
 }
@@ -17748,7 +17842,6 @@ function projectFecDiagnosticConfig(config) {
     interleaveMs: config.interleaveMs,
     fecMode: config.fecMode,
     ...config.repairTrack === void 0 ? {} : { repairTrack: config.repairTrack },
-    altaEnabled: config.altaEnabled,
     relayBlockSigEnabled: config.relayBlockSigEnabled
   };
 }
@@ -17795,9 +17888,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);
     }
@@ -17807,6 +17899,7 @@ function repairTrackNamesBySource(tracks) {
 var MulticastManager = class {
   #fec;
   #router;
+  #hostMfuTimeoutMs;
   #transport;
   #reportedFecDiagnosticsFailure = false;
   // ── Stream-global FEC timing reduction ──
@@ -17905,6 +17998,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);
     });
@@ -18121,7 +18215,6 @@ var MulticastManager = class {
       ...this.#streamFecBaseline ? [this.#streamFecBaseline] : [],
       ...this.#trackFecTiming.values()
     ];
-    if (contributions.length === 0) return;
     let deliveryWindowMs;
     let minimumFailbackWindowMs;
     let mfuTimeoutMs;
@@ -18153,15 +18246,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
@@ -18188,9 +18275,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(
@@ -18198,7 +18285,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);
@@ -18214,8 +18304,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,
@@ -18224,10 +18314,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
@@ -18236,7 +18326,7 @@ var MulticastManager = class {
       blockProfile,
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs,
       ...trackKind === void 0 ? {} : { trackKind },
@@ -18247,7 +18337,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,
@@ -18256,6 +18346,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(
@@ -18267,7 +18361,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,
@@ -18278,13 +18372,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,
@@ -18333,6 +18427,7 @@ var MulticastManager = class {
   }
   setMfuTimeoutMs(ms) {
     this.#router.setMfuTimeoutMs(ms);
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
   }
   setTrackCodec(packetId, codec) {
     this.#router.setTrackCodec(packetId, codec);
@@ -18355,6 +18450,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);
   }
@@ -18427,7 +18523,7 @@ var MulticastManager = class {
         )
       )
     };
-    const amtRelay = config.amtRelay ?? config.relayAddress;
+    const amtRelay = config.amtRelay;
     const transportConfig = {
       sourceAddress: config.sourceAddress,
       groupAddress: config.groupAddress,
@@ -18440,9 +18536,8 @@ var MulticastManager = class {
       // endpoint-config.ts) deliberately has no implicit relay port — it throws
       // and `MulticastTransport.join` resolves false — so the default is
       // resolved HERE and arrives there explicit, exactly as the two catalog
-      // readers do it. This is the last of the three readers: the `relayAddress`
-      // half cannot supply a port at all (the pre-migration wire shape has no
-      // port field), and `resolveNetworkSource` emits the same port-less shape.
+      // readers do it. This is the last of the three readers: `resolveNetworkSource`
+      // emits a port-less relay shape.
       // Keyed on the resolved relay, so a DRIAD entry — which pins no relay —
       // never has a port manufactured for it. Blank counts as no relay, the
       // same test `catalogAmtNetworkSource` applies (it trims, then skips) and
@@ -18666,7 +18761,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 {
@@ -18685,7 +18783,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).
@@ -18730,12 +18831,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) {
@@ -18788,11 +18930,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();
@@ -18821,6 +18965,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])
     );
@@ -18842,10 +19000,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);
@@ -18866,17 +19025,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");
@@ -18884,6 +19044,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.
@@ -18931,7 +19109,17 @@ var MulticastManager = class {
   }
   /** Record a repair request the scheduler sent no FETCH for. */
   noteRepairSkipped(reason, measurement, sbn, packetId, catalogTrackName) {
-    this.#statsFor(packetId, catalogTrackName).repairsSkipped++;
+    const stats = this.#statsFor(packetId, catalogTrackName);
+    stats.repairsSkipped++;
+    if (reason === "rtt-unmeasured") stats.repairsSkippedRttUnmeasured++;
+    else if (reason === "rtt-exceeds-budget") stats.repairsSkippedRttExceedsBudget++;
+    else stats.repairsSkippedPresentationDelayUnavailable++;
+    stats.lastRepairSkip = {
+      reason,
+      rttMs: measurement.rttMs,
+      budgetMs: measurement.budgetMs,
+      priority: measurement.priority ?? null
+    };
     this.#emitRepairLifecycle({
       version: 2,
       type: "repair-skipped",
@@ -18941,6 +19129,24 @@ var MulticastManager = class {
       budgetMs: measurement.budgetMs
     });
   }
+  /**
+   * Arrival time of the earliest frame the in-order release gate holds for
+   * the stream: the gate releases it as a discontinuity once
+   * `terminalRetentionMsForPacket` has passed since then.
+   */
+  earliestGatedFrameAtMs(packetId, catalogTrackName) {
+    return this.#router.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
+  }
+  /** Record a keyframe late-repair budget the scheduler granted a block. */
+  noteKeyframeBudgetGranted(extensionMs, _sbn, packetId, catalogTrackName) {
+    const stats = this.#statsFor(packetId, catalogTrackName);
+    stats.keyframeBudgetHolds++;
+    stats.keyframeBudgetHoldMs += extensionMs;
+  }
+  /** Record a repair FETCH the scheduler admitted and sent. */
+  noteRepairFetchSent(priority, _sbn, packetId, catalogTrackName) {
+    if (priority === 0) this.#statsFor(packetId, catalogTrackName).keyframeRepairFetchesSent++;
+  }
   /**
    * Record a repair-scheduler decision about a delta block: preempted for
    * keyframe/audio work, or never dispatched before its block resolved.
@@ -18968,7 +19174,10 @@ var MulticastManager = class {
     const out = {};
     for (const [key, stats] of this.#blockPolicyStats) {
       if (stats.epoch !== this.#fec.epochFor(stats.packetId)) continue;
-      out[key] = { ...stats };
+      out[key] = {
+        ...stats,
+        lastRepairSkip: stats.lastRepairSkip === null ? null : { ...stats.lastRepairSkip }
+      };
     }
     return out;
   }