@blockcast/mmt-container 0.3.0-main.dd5b3a8dcbc8 → 0.3.0-main.e4bf1a9cc227

package/dist/browser-runtime.js

@@ -87,6 +87,8 @@ var init_fec_worker_client = __esm({
       }
       /**
        * Configure the Worker with FEC parameters and WASM module.
+       * `interleaveMs: 0` is a valid no-span catalog value; in that mode the
+       * caller supplies a positive receiver-local `deliveryWindowMs`.
        * wasmModule is transferred (not neutered — WebAssembly.Module is shareable).
        * altaPublicKey is PKCS#8 SPKI DER bytes (self-describing — algorithm detected from OID).
        *   Transferred (detached from sender).
@@ -6700,7 +6702,7 @@ function validateCmsfMmtpCatalog(value) {
   const tracks = catalog["tracks"];
   const trackRecords = [];
   const positiveInteger2 = (input) => Number.isSafeInteger(input) && input > 0;
-  const positiveNumber = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
+  const positiveNumber2 = (input) => typeof input === "number" && Number.isFinite(input) && input > 0;
   for (let index = 0; index < tracks.length; index++) {
     const raw = tracks[index];
     const path = `$.tracks[${index}]`;
@@ -6745,7 +6747,7 @@ function validateCmsfMmtpCatalog(value) {
     if (groupDurationTicks !== void 0 && !positiveInteger2(groupDurationTicks)) {
       catalogError("track_group_duration_ticks", `${path}.groupDurationTicks`, "must be a positive integer");
     }
-    if (keyframeIntervalMs !== void 0 && !positiveNumber(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
+    if (keyframeIntervalMs !== void 0 && !positiveNumber2(keyframeIntervalMs) || keyframeIntervalTicks !== void 0 && !positiveInteger2(keyframeIntervalTicks)) {
       catalogError("track_keyframe_interval", path, "keyframe interval fields must be positive numbers");
     }
     if (packaging === "fec-repair") {
@@ -6793,8 +6795,8 @@ function validateCmsfMmtpCatalog(value) {
           "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
         );
       }
-      if (config["interleaveDepthMs"] !== void 0 && !positiveInteger2(config["interleaveDepthMs"])) {
-        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive integer");
+      if (config["interleaveDepthMs"] !== void 0 && (!Number.isSafeInteger(config["interleaveDepthMs"]) || config["interleaveDepthMs"] < 0)) {
+        catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a non-negative safe integer");
       }
       if (algorithm !== "none") {
         for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
@@ -9651,7 +9653,7 @@ function processFecBlock(blockData, options) {
 // ../fec/dist/oti.js
 function catalogFecInterleaveMs(fec) {
   const ms = fec?.interleaveDepthMs;
-  return typeof ms === "number" && ms > 0 && Number.isFinite(ms) ? ms : void 0;
+  return typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0 ? ms : void 0;
 }
 function deriveFecInterleaveDepth(interleaveDepthMs, mediaUnitDurationMs) {
   if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
@@ -9684,6 +9686,8 @@ function deriveFecRetentionBlocks(deliveryWindowMs, interleaveDepthMs) {
   throw new Error(`[FEC] retention of ${Math.ceil(deliveryWindowMs / interleaveDepthMs) + 1} blocks exceeds the 255 the decoder and the ISO/IEC 23008-1 AL-FEC signaling byte accept (deliveryWindowMs=${deliveryWindowMs}ms over interleaveDepthMs=${interleaveDepthMs}ms). Fix the catalog geometry: a span this short cannot carry a window this wide.`);
 }
 var MAX_FEC_RETENTION_BLOCKS = 255;
+var LOCAL_FEC_RETENTION_BLOCKS = 2;
+var LOCAL_FEC_TIMEOUT_MS = 500;
 function tryDeriveFecRetentionBlocks(deliveryWindowMs, interleaveDepthMs) {
   if (!Number.isFinite(interleaveDepthMs) || !(interleaveDepthMs > 0))
     return void 0;
@@ -9996,6 +10000,10 @@ var TrackSession = class {
   /** multicast/amt → failing: loss detected, start hysteresis timer (Claim 9f). */
   lossDetected() {
     if (this.#state !== "multicast" && this.#state !== "amt") return;
+    if (this.config.fecInterleaveMs === 0 || this.config.fecInterleaveMs === void 0) {
+      this.transportFailed();
+      return;
+    }
     this.#previousPrimary = this.#state;
     this.#transition("failing");
     const hysteresisMs = computeFecLossWindowMs(
@@ -10802,7 +10810,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",
@@ -10829,7 +10837,7 @@ function isoBlockSpanUsable(fec) {
   const block = recordOf(fec);
   if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1") return true;
   const ms = block["interleaveDepthMs"];
-  return typeof ms === "number" && Number.isFinite(ms) && ms >= MIN_INTERLEAVE_DEPTH_MS;
+  return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
 }
 function requireBoolean(value, field) {
   if (typeof value !== "boolean") {
@@ -11380,8 +11388,8 @@ var FECManager = class _FECManager {
     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();
@@ -11857,6 +11865,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}.`
@@ -11870,7 +11886,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
@@ -11910,6 +11926,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);
@@ -12023,7 +12042,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;
     }
@@ -12179,7 +12198,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);
@@ -12259,6 +12278,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";
@@ -12385,7 +12405,9 @@ var FECManager = class _FECManager {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
     if (this.#blockResolutionFor(key) !== "untracked") return;
     this.#materializedBlocks.add(key);
-    this.#classifierFor(packetId, catalogTrackName).touch(sbn);
+    if (this.#hasCatalogTimingForPacket(packetId)) {
+      this.#classifierFor(packetId, catalogTrackName).touch(sbn);
+    }
     this.onBlockVanished?.(sbn, packetId, catalogTrackName);
     if (repairable) {
       this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
@@ -12436,9 +12458,23 @@ var FECManager = class _FECManager {
   #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) {
+    return _FECManager.#hasCatalogTiming(this.#resolveTrackConfig(packetId));
+  }
   #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({
@@ -12463,14 +12499,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);
   }
   /**
@@ -12498,6 +12537,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;
@@ -12512,10 +12552,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);
@@ -12531,6 +12573,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) {
@@ -12617,13 +12660,19 @@ 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 previous = previousTrack ?? this.#defaultTrackConfig();
     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`);
     }
@@ -12633,33 +12682,44 @@ var FECManager = class _FECManager {
         `[FECManager] packetId=${packetId}: fec.blockProfile is required ("iso-ssbg1-v1"); configure the track from its catalog`
       );
     }
-    const ownInterleaveDepthMs = config.interleaveDepthMs ?? this.#trackConfigs.get(packetId)?.interleaveDepthMs;
-    if (ownInterleaveDepthMs === void 0 || !Number.isFinite(ownInterleaveDepthMs) || ownInterleaveDepthMs < MIN_INTERLEAVE_DEPTH_MS) {
+    const ownInterleaveDepthMs = config.interleaveDepthMs ?? previousTrack?.interleaveDepthMs ?? 0;
+    if (!Number.isSafeInteger(ownInterleaveDepthMs) || ownInterleaveDepthMs !== 0 && 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`
+        `[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,
+      interleaveDepthMs: ownInterleaveDepthMs,
       fps: config.fps ?? previous.fps,
       timeoutMs: config.timeoutMs ?? (timingChanged ? 0 : previous.timeoutMs),
       ...(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);
     }
+    const timingPolicyChanged = _FECManager.#hasCatalogTiming(previous) !== 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))) {
@@ -12674,8 +12734,9 @@ 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());
       }
     }
@@ -13303,10 +13364,11 @@ var FECManager = class _FECManager {
    * 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);
@@ -13374,11 +13436,12 @@ var FECManager = class _FECManager {
    */
   #isoRetentionBlocks(packetId) {
     const config = this.#trackConfigs.get(packetId);
-    if (config?.blockProfile === void 0 || !(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`
       );
     }
+    if (!_FECManager.#hasCatalogTiming(config)) return LOCAL_FEC_RETENTION_BLOCKS;
     const blocks = Math.ceil(this.terminalRetentionMsForPacket(packetId) / 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`);
@@ -13520,6 +13583,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 };
   }
@@ -13529,10 +13593,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);
@@ -13554,7 +13620,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,
@@ -13570,18 +13636,27 @@ var FECManager = class _FECManager {
   // -----------------------------------------------------------------------
   /** Configure FEC parameters. */
   configure(config) {
+    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) this.#fecK = 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) {
+    } 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 = computeFecDeliveryWindowMs({
         interleaveDepthMs: config.interleaveDepthMs,
         sourceSymbols: this.#fecK,
@@ -13590,7 +13665,7 @@ var FECManager = class _FECManager {
       });
     }
     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 });
       }
     }
@@ -13870,7 +13945,7 @@ var FECManager = class _FECManager {
     if (this.#fpsDetected || fps <= 0) return;
     this.#fpsDetected = true;
     this.#fecFps = fps;
-    if (this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
+    if (Number.isSafeInteger(this.#fecInterleaveDepthMs) && this.#fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS) {
       this.#fecTimeoutMs = computeFecDeliveryWindowMs({
         interleaveDepthMs: this.#fecInterleaveDepthMs,
         sourceSymbols: this.#fecK,
@@ -13879,7 +13954,7 @@ var FECManager = class _FECManager {
       });
     }
     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,
@@ -14143,11 +14218,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);
@@ -14206,7 +14283,7 @@ var FECManager = class _FECManager {
       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,
@@ -17353,7 +17430,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.
@@ -20031,22 +20108,22 @@ var MoqFecAlgorithm;
   MoqFecAlgorithm2[MoqFecAlgorithm2["RaptorQ"] = 2] = "RaptorQ";
 })(MoqFecAlgorithm || (MoqFecAlgorithm = {}));
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-alta-parse/dist/index.js
+// node_modules/@blockcast/mmt-alta-parse/dist/index.js
 var MPU_HEADER_SIZE3 = 8;
 var MPU_LENGTH_FIELD_SIZE3 = 2;
 var MPU_HEADER_REMAINDER_SIZE3 = MPU_HEADER_SIZE3 - MPU_LENGTH_FIELD_SIZE3;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/mmtp.js
+// node_modules/@blockcast/mmt-base/dist/mmtp.js
 var MPU_HEADER_SIZE4 = 8;
 var MPU_LENGTH_FIELD_SIZE4 = 2;
 var MPU_HEADER_REMAINDER_SIZE4 = MPU_HEADER_SIZE4 - MPU_LENGTH_FIELD_SIZE4;
 var MMTP_SIGNALING_PACKET_ID2 = 0;
 var MMTP_PACKET_ID_MAX2 = 65535;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/net-constants.js
+// node_modules/@blockcast/mmt-base/dist/net-constants.js
 var DEFAULT_AMT_RELAY_PORT2 = 2268;
 
-// node_modules/@blockcast/mmt-transport/node_modules/@blockcast/mmt-base/dist/ntp-short.js
+// node_modules/@blockcast/mmt-base/dist/ntp-short.js
 var NTP_SHORT_BITS2 = 32;
 var NTP_SHORT_MODULUS2 = 2 ** NTP_SHORT_BITS2;
 var NTP_SHORT_HALF_RANGE2 = 2 ** (NTP_SHORT_BITS2 - 1);
@@ -20067,7 +20144,7 @@ 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([
   "iso-ssbg1-v1"
 ]);
@@ -20460,10 +20537,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;
@@ -20530,6 +20609,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).
@@ -21569,7 +21669,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
@@ -21874,14 +21974,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)));
     }
@@ -22207,7 +22313,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"
       );
@@ -22217,7 +22324,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));
@@ -22276,6 +22383,23 @@ function resolveCatalogTrackGroupDurationMs(catalog, track) {
   const renditions = track.type === "audio" ? catalog?.audio?.renditions : catalog?.video?.renditions;
   return catalogGroupDurationMs(renditions?.[track.name]);
 }
+function positiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function catalogKeyframeCadenceMs(rendition) {
+  if (!rendition) return void 0;
+  const timescale = positiveNumber(rendition.timescale);
+  const ticksToMs = (ticks) => {
+    const value = positiveNumber(ticks);
+    return value !== void 0 && timescale !== void 0 ? value * 1e3 / timescale : void 0;
+  };
+  return ticksToMs(rendition.keyframeIntervalTicks) ?? positiveNumber(rendition.keyframeIntervalMs) ?? ticksToMs(rendition.keyframeDurationTicks) ?? positiveNumber(rendition.keyframeDurationMs) ?? ticksToMs(rendition.gopDurationTicks) ?? positiveNumber(rendition.gopDurationMs);
+}
+function catalogFecMediaUnitsPerSecond(type, rendition, endpointSampleRate) {
+  if (type === "video") return positiveNumber(rendition?.framerate);
+  const sampleRate = positiveNumber(endpointSampleRate ?? rendition?.sampleRate ?? rendition?.timescale);
+  return sampleRate === void 0 ? void 0 : sampleRate / 1024;
+}
 var NO_FEC = {
   fecK: 0,
   fecRepairCount: 0,
@@ -22406,6 +22530,11 @@ function catalogRepairTarget(catalog, source) {
   const sourceName = typeof source === "string" ? source : source.name;
   const msf = msfTracks(catalog);
   const entry = msf?.tracks.find((t) => t["name"] === sourceName);
+  const hang = catalog;
+  const roles = typeof source === "string" ? ["video", "audio"] : source.type === "video" ? ["video"] : source.type === "audio" ? ["audio"] : ["video", "audio"];
+  const rendition = roles.map((role) => hang[role]?.renditions?.[sourceName]).find((r) => recordOf2(r) !== void 0);
+  const fec = rendition === void 0 ? recordOf2(entry?.["fec"]) : recordOf2(rendition.fec);
+  if (!fec || !(catalogFecInterleaveMs(fec) ?? 0)) return null;
   const sourcePriority = entry === void 0 ? null : moqtPriority2(entry["priority"]);
   return { repairTrack: layerZero.repairTrackName, sourcePriority, repairPriority: layerZero.priority };
 }
@@ -22440,17 +22569,10 @@ function blockProfileUnavailable(value, path, declaresFecInstance) {
 }
 function isoSpanUnavailable(fec, path, declaresFecInstance) {
   if (!declaresFecInstance || isoBlockSpanUsable(fec)) return void 0;
-  if (fec["interleaveDepthMs"] === void 0) {
-    return Object.freeze({
-      code: "track_fec_block_span",
-      path,
-      message: `[repair-layers:track_fec_block_span] ${path}: is absent; iso-ssbg1-v1 requires a declared block span, which bounds its block location`
-    });
-  }
   return Object.freeze({
     code: "track_fec",
     path,
-    message: `[repair-layers:track_fec] ${path}: iso-ssbg1-v1 requires a block span of at least ${MIN_INTERLEAVE_DEPTH_MS} ms, which bounds its block location`
+    message: `[repair-layers:track_fec] ${path}: must be a non-negative safe integer in milliseconds`
   });
 }
 function catalogFecUnavailable(fec, fecPath) {
@@ -22487,9 +22609,7 @@ function fecParams(catalog, track, rendition, fps, sampleRate) {
     // The wire RSB_length: every base layer's packets carry the base total (§7.1).
     fecTotalRepairCount: repair?.totalBaseRepairSymbols ?? fec.repairSymbols ?? 0,
     fecSymbolSize: fec.symbolSize ?? 0,
-    // interleaveDepthMs is the FEC block span in MILLISECONDS (§5.1) — the
-    // only interleave key the catalog carries post-BLO-14526. Receivers
-    // derive D by positive round-half-up of span / GOP duration where needed.
+    // Zero/absence leaves the elapsed deadline unknown; geometry stays in-band.
     fecInterleaveMs: catalogFecInterleaveMs(fec) ?? 0,
     // Additive, never a multiplier on the span: jitter belongs to the network
     // path and the span belongs to the encoder, so scaling one by the other
@@ -22867,6 +22987,7 @@ function repairTrackNamesBySource(tracks) {
 var MulticastManager = class {
   #fec;
   #router;
+  #hostMfuTimeoutMs;
   #transport;
   #reportedFecDiagnosticsFailure = false;
   // ── Stream-global FEC timing reduction ──
@@ -22965,6 +23086,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);
     });
@@ -23181,7 +23303,6 @@ var MulticastManager = class {
       ...this.#streamFecBaseline ? [this.#streamFecBaseline] : [],
       ...this.#trackFecTiming.values()
     ];
-    if (contributions.length === 0) return;
     let deliveryWindowMs;
     let minimumFailbackWindowMs;
     let mfuTimeoutMs;
@@ -23213,15 +23334,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
@@ -23248,9 +23363,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(
@@ -23258,7 +23373,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);
@@ -23274,8 +23392,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,
@@ -23284,10 +23402,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
@@ -23296,7 +23414,7 @@ var MulticastManager = class {
       blockProfile,
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs,
       ...trackKind === void 0 ? {} : { trackKind },
@@ -23307,7 +23425,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,
@@ -23316,6 +23434,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(
@@ -23327,7 +23449,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,
@@ -23338,13 +23460,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,
@@ -23393,6 +23515,7 @@ var MulticastManager = class {
   }
   setMfuTimeoutMs(ms) {
     this.#router.setMfuTimeoutMs(ms);
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
   }
   setTrackCodec(packetId, codec) {
     this.#router.setTrackCodec(packetId, codec);
@@ -23749,7 +23872,9 @@ 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);
   }
@@ -23989,7 +24114,7 @@ var MulticastManager = class {
               blockProfile,
               k: fecCfg.sourceSymbols,
               symbolSize: fecCfg.symbolSize,
-              interleaveDepthMs: fecCfg.interleaveDepthMs,
+              interleaveDepthMs: fecCfg.interleaveDepthMs ?? 0,
               fps: track.framerate,
               trackKind: "video"
             },
@@ -24000,7 +24125,7 @@ var MulticastManager = class {
             blockProfile,
             k: fecCfg.sourceSymbols,
             symbolSize: fecCfg.symbolSize,
-            interleaveDepthMs: fecCfg.interleaveDepthMs,
+            interleaveDepthMs: fecCfg.interleaveDepthMs ?? 0,
             fps: track.framerate
           });
           this.#router.setPacketIdType(track.packetId, "video");
@@ -24013,8 +24138,8 @@ var MulticastManager = class {
    * 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
-   * `iso-ssbg1-v1` span it cannot use (`track_fec_block_span` when absent,
-   * `track_fec` when declared but unusable). The same reason the hang
+   * 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.
@@ -24236,32 +24361,63 @@ var MulticastManager = class {
 
 // src/fec-worker-setup.ts
 async function setupFecWorkerForTrack(opts) {
-  if (!Number.isFinite(opts.fecInterleaveMs) || opts.fecInterleaveMs <= 0) {
+  if (!Number.isFinite(opts.fecInterleaveMs) || !Number.isSafeInteger(opts.fecInterleaveMs) || opts.fecInterleaveMs < 0) {
     throw new Error(
-      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be finite and > 0 (got ${opts.fecInterleaveMs})`
+      `[FEC] interleaveDepthMs (opts.fecInterleaveMs) must be a finite non-negative integer (got ${opts.fecInterleaveMs})`
     );
   }
-  if (!Number.isFinite(opts.mediaUnitDurationMs) || opts.mediaUnitDurationMs <= 0) {
+  if (opts.fecReorderToleranceMs !== void 0 && (!Number.isFinite(opts.fecReorderToleranceMs) || opts.fecReorderToleranceMs < 0)) {
     throw new Error(
-      `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${opts.mediaUnitDurationMs})`
+      `[FEC] fecReorderToleranceMs must be finite and >= 0 (got ${opts.fecReorderToleranceMs})`
+    );
+  }
+  const hasCatalogTiming = opts.fecInterleaveMs > 0;
+  const validateWorkerGeometry = () => {
+    if (!Number.isSafeInteger(opts.fecK) || opts.fecK <= 0) {
+      throw new Error(`[FEC] fecK must be a finite positive integer (got ${opts.fecK})`);
+    }
+    if (!Number.isSafeInteger(opts.fecSymbolSize) || opts.fecSymbolSize <= 0 || opts.fecSymbolSize % 8 !== 0) {
+      throw new Error(
+        `[FEC] fecSymbolSize must be a positive 8-byte-aligned integer (got ${opts.fecSymbolSize})`
+      );
+    }
+    if (!Number.isSafeInteger(opts.fecRepairCount) || opts.fecRepairCount <= 0) {
+      throw new Error(
+        `[FEC] fecRepairCount must be a finite positive integer (got ${opts.fecRepairCount})`
+      );
+    }
+  };
+  let deliveryWindowMs;
+  let interleaveDepthBlocks;
+  if (!hasCatalogTiming) {
+    validateWorkerGeometry();
+    deliveryWindowMs = LOCAL_FEC_TIMEOUT_MS;
+    interleaveDepthBlocks = LOCAL_FEC_RETENTION_BLOCKS;
+  } else {
+    const mediaUnitDurationMs = opts.mediaUnitDurationMs;
+    if (typeof mediaUnitDurationMs !== "number" || !Number.isFinite(mediaUnitDurationMs) || mediaUnitDurationMs <= 0) {
+      throw new Error(
+        `[FEC] mediaUnitDurationMs must be finite and > 0 (got ${mediaUnitDurationMs})`
+      );
+    }
+    validateWorkerGeometry();
+    deliveryWindowMs = computeFecDeliveryWindowMs({
+      interleaveDepthMs: opts.fecInterleaveMs,
+      sourceSymbols: opts.fecK,
+      repairSymbols: opts.fecRepairCount,
+      symbolSize: opts.fecSymbolSize,
+      mediaUnitsPerSecond: 1e3 / mediaUnitDurationMs,
+      jitterBufferMs: opts.fecReorderToleranceMs
+    });
+    interleaveDepthBlocks = deriveFecRetentionBlocks(
+      deliveryWindowMs,
+      opts.fecInterleaveMs
     );
   }
   const blockProfile = parseFecBlockProfile(
     opts.fecBlockProfile,
     `[FEC] ${opts.trackName} fec.blockProfile`
   );
-  const deliveryWindowMs = computeFecDeliveryWindowMs({
-    interleaveDepthMs: opts.fecInterleaveMs,
-    sourceSymbols: opts.fecK,
-    repairSymbols: opts.fecRepairCount,
-    symbolSize: opts.fecSymbolSize,
-    mediaUnitsPerSecond: 1e3 / opts.mediaUnitDurationMs,
-    jitterBufferMs: opts.fecReorderToleranceMs
-  });
-  const interleaveDepthBlocks = deriveFecRetentionBlocks(
-    deliveryWindowMs,
-    opts.fecInterleaveMs
-  );
   const origin = typeof location !== "undefined" && location.origin ? location.origin : "http://localhost";
   const workerUrl = new URL(opts.assetUrls.fecWorker, origin);
   const FecWorkerCtor = await Promise.resolve().then(() => (init_dist(), dist_exports));
@@ -24315,9 +24471,10 @@ async function setupFecWorkerForTrack(opts) {
       k: opts.fecK,
       symbolSize: opts.fecSymbolSize,
       interleaveDepthMs: opts.fecInterleaveMs,
-      // FEC timing is expressed in media units. For audio this is the access-unit
-      // cadence (for example 1024/48kHz), not a video-only framerate field.
-      fps: 1e3 / opts.mediaUnitDurationMs,
+      // No-span tracks have no catalog media cadence. The manager still gets
+      // the local cleanup budget, but it must not use a guessed fps for timing
+      // or classification.
+      ...hasCatalogTiming ? { fps: 1e3 / opts.mediaUnitDurationMs } : {},
       timeoutMs: deliveryWindowMs
     }, opts.trackName);
   } catch (e) {
@@ -24357,6 +24514,28 @@ var TrackSourceConflictError = class extends Error {
 };
 var DEFAULT_CROSSFADE_FRAMES = 10;
 var DEFAULT_MAX_OVERLAY_BUFFER = 128;
+function assertDeltaFallbackConfig(cfg, prefix) {
+  if (!isPositiveFinite2(cfg.framerate)) throw new Error(`${prefix}: framerate required and must be > 0`);
+  if (!isPositiveFinite2(cfg.sourceSymbols))
+    throw new Error(`${prefix}: sourceSymbols (K_delta) required and must be > 0`);
+  if (!isPositiveFinite2(cfg.repairSymbols))
+    throw new Error(`${prefix}: repairSymbols (P_delta) required and must be > 0`);
+  if (cfg.deltaFailWindowBlocks !== void 0 && !(Number.isInteger(cfg.deltaFailWindowBlocks) && cfg.deltaFailWindowBlocks > 0)) {
+    throw new Error(`${prefix}: deltaFailWindowBlocks must be a positive integer when present`);
+  }
+  if (cfg.deltaProbeIntervalMs !== void 0 && !isPositiveFinite2(cfg.deltaProbeIntervalMs))
+    throw new Error(`${prefix}: deltaProbeIntervalMs must be > 0 when present`);
+  if (cfg.interleaveDepthMs !== void 0 && !isPositiveFinite2(cfg.interleaveDepthMs))
+    throw new Error(`${prefix}: interleaveDepthMs must be > 0 when present`);
+  if (cfg.deltaProbeIntervalMs === void 0 && cfg.interleaveDepthMs === void 0) {
+    throw new Error(
+      `${prefix}: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation`
+    );
+  }
+}
+function isPositiveFinite2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 var MediaRouter = class {
   #active = "moq";
   #multicastVideoKeyed = false;
@@ -24518,20 +24697,7 @@ var MediaRouter = class {
    * Calling again resets deltaActive=true and clears the window buffer (stream restart).
    */
   configureDelta(cfg) {
-    if (typeof cfg.framerate !== "number" || !Number.isFinite(cfg.framerate) || cfg.framerate <= 0) {
-      throw new Error("[MediaRouter] configureDelta: framerate required and must be > 0");
-    }
-    if (typeof cfg.sourceSymbols !== "number" || cfg.sourceSymbols <= 0) {
-      throw new Error("[MediaRouter] configureDelta: sourceSymbols (K_delta) required and must be > 0");
-    }
-    if (typeof cfg.repairSymbols !== "number" || cfg.repairSymbols <= 0) {
-      throw new Error("[MediaRouter] configureDelta: repairSymbols (P_delta) required and must be > 0");
-    }
-    if (cfg.deltaProbeIntervalMs === void 0 && cfg.interleaveDepthMs === void 0) {
-      throw new Error(
-        "[MediaRouter] configureDelta: either deltaProbeIntervalMs or interleaveDepthMs required for probe interval derivation"
-      );
-    }
+    assertDeltaFallbackConfig(cfg, "[MediaRouter] configureDelta");
     this.#deltaWindowSize = cfg.deltaFailWindowBlocks ?? Math.ceil(cfg.framerate);
     this.#deltaFailThresholdRatio = cfg.repairSymbols / cfg.sourceSymbols;
     this.#deltaRecoverThresholdRatio = this.#deltaFailThresholdRatio / 2;
@@ -24908,6 +25074,35 @@ var MediaRouter = class {
   }
 };
 
+// src/delta-fallback-config.ts
+function resolveDeltaFallback(base, delta) {
+  const repair = base.fec?.repairTrack;
+  if (!repair) throw new Error(`[delta-fallback] base track "${base.name}" missing fec.repairTrack`);
+  const deltaFec = delta.fec;
+  if (!deltaFec?.repairTrack) throw new Error(`[delta-fallback] delta track "${delta.name}" missing fec.repairTrack`);
+  if (deltaFec.repairTrack !== repair)
+    throw new Error(
+      `[delta-fallback] inconsistent repair tracks: ${base.name} references "${repair}" but ${delta.name} references "${deltaFec.repairTrack}"`
+    );
+  if (!(typeof base.framerate === "number" && Number.isFinite(base.framerate) && base.framerate > 0))
+    throw new Error(`[delta-fallback] base track "${base.name}" missing positive framerate`);
+  if (!(isPositive(deltaFec.sourceSymbols) && isPositive(deltaFec.repairSymbols)))
+    throw new Error(`[delta-fallback] delta track "${delta.name}" missing positive fec.sourceSymbols/repairSymbols`);
+  const config = {
+    framerate: base.framerate,
+    sourceSymbols: deltaFec.sourceSymbols,
+    repairSymbols: deltaFec.repairSymbols,
+    deltaFailWindowBlocks: base.fec?.deltaFailWindowBlocks ?? deltaFec.deltaFailWindowBlocks,
+    deltaProbeIntervalMs: base.fec?.deltaProbeIntervalMs ?? deltaFec.deltaProbeIntervalMs,
+    interleaveDepthMs: base.fec?.interleaveDepthMs ?? deltaFec.interleaveDepthMs
+  };
+  assertDeltaFallbackConfig(config, `[delta-fallback] group ${base.name}/${delta.name}`);
+  return { repairTrackName: repair, config };
+}
+function isPositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
 // src/align.ts
 function secondsFromTicks(ticks, timescale) {
   if (!Number.isFinite(ticks)) {
@@ -26333,8 +26528,10 @@ export {
   catalogAmtNetworkSource,
   catalogDeclaresFec,
   catalogFecInterleaveMs,
+  catalogFecMediaUnitsPerSecond,
   catalogFecUnavailable,
   catalogGroupDurationMs,
+  catalogKeyframeCadenceMs,
   catalogRepairTarget,
   classifyH264Keyframe,
   classifyHevcKeyframe,
@@ -26432,6 +26629,7 @@ export {
   repairReachability,
   resolveCatalogTrackFec,
   resolveCatalogTrackGroupDurationMs,
+  resolveDeltaFallback,
   resolveFecState,
   resolveGlobalMmtWasmBindings,
   resolveGroupDurationMs,