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

package/src/multicast-manager.ts

@@ -77,9 +77,11 @@ import {
   parseTrackRole,
   validateSwitchingSet,
   isFecCatalogConfig,
+  isFecCatalogGeometry,
   type FecCatalogConfig,
   type TrackRole,
 } from "./carp-catalog.js";
+import { catalogFecUnavailable, type TrackFecUnavailable } from "./catalog-fec-params.js";
 
 export interface MulticastEndpointConfig {
   sourceAddress: string;
@@ -87,11 +89,9 @@ export interface MulticastEndpointConfig {
   port: number;
   /** Explicit gateway transport policy. Omitted means gateway-selected auto mode. */
   mode?: 'auto' | 'native' | 'tunnel';
-  /** AMT relay hostname/IP from catalog endpoint. */
-  relayAddress?: string;
   /** AMT relay port from catalog endpoint. */
   relayPort?: number;
-  /** AMT relay hostname/IP from player/UI overrides. Wins over `relayAddress`. */
+  /** AMT relay hostname/IP: the player/UI override, or the catalog's `multicast.networkSource` AMT relay. */
   amtRelay?: string;
   /** AMT relay port from player/UI overrides. Wins over `relayPort`. */
   amtRelayPort?: number;
@@ -100,8 +100,9 @@ export interface MulticastEndpointConfig {
   /** Exact catalog tracks carried by this physical multicast endpoint. */
   tracks?: MmtpIngressContext["tracks"];
   /**
-   * The catalog `fec.blockProfile` (BLO-35597): `k-padded-v1` or
-   * `iso-ssbg1-v1`. Required for per-track FEC configuration; never defaulted.
+   * The catalog `fec.blockProfile` (BLO-35597): `iso-ssbg1-v1`, the only
+   * profile (the retired `k-padded-v1` token is refused). Required for
+   * per-track FEC configuration; never defaulted.
    */
   fecBlockProfile?: FecBlockProfile;
   fecK?: number;
@@ -417,6 +418,33 @@ export interface BlockPolicyStats {
   deltaRepairsDeferred: number;
   /** Repair requests sent no FETCH (see the `repair-skipped` event). */
   repairsSkipped: number;
+  /** `repairsSkipped` by reason: the reliable path offered no RTT. */
+  repairsSkippedRttUnmeasured: number;
+  /** `repairsSkipped` by reason: the RTT did not fit the time left to the deadline. */
+  repairsSkippedRttExceedsBudget: number;
+  /** `repairsSkipped` by reason: the player gave no presentation delay. */
+  repairsSkippedPresentationDelayUnavailable: number;
+  /**
+   * The most recent skip: its reason, the measured RTT (null when
+   * unmeasured), the time that was left to the deadline, and the request's
+   * repair priority (0 keyframe/unknown, 1 audio, 2 delta; null when the
+   * scheduler did not say). Null until a request is skipped.
+   */
+  lastRepairSkip: {
+    readonly reason: RepairSkipReason;
+    readonly rttMs: number | null;
+    readonly budgetMs: number;
+    readonly priority: RepairPriority | null;
+  } | null;
+  /** Repair FETCHes sent for keyframe/unknown (P0) blocks, every attempt counted. */
+  keyframeRepairFetchesSent: number;
+  /**
+   * Requests the keyframe late-repair budget extended past the presentation
+   * deadline (each one can hold the stream behind its block that long).
+   */
+  keyframeBudgetHolds: number;
+  /** Sum of those extensions in ms: the most video the budget could hold. */
+  keyframeBudgetHoldMs: number;
   deltaBlocksFailed: number;
   audioBlocksRecoveredInband: number;
   audioBlocksRecoveredQuic: number;
@@ -451,6 +479,13 @@ function newBlockPolicyStats(
     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,
@@ -932,7 +967,10 @@ function projectFecDiagnosticBlock(block: FecBlockSnapshot) {
     lastSymbolTs: block.lastSymbolTs,
     ...(block.completedTs === undefined ? {} : { 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,
   };
 }
@@ -963,7 +1001,6 @@ function projectFecDiagnosticConfig(config: FecTrackConfig) {
     interleaveMs: config.interleaveMs,
     fecMode: config.fecMode,
     ...(config.repairTrack === undefined ? {} : { repairTrack: config.repairTrack }),
-    altaEnabled: config.altaEnabled,
     relayBlockSigEnabled: config.relayBlockSigEnabled,
   };
 }
@@ -1042,13 +1079,14 @@ function repairTrackNamesBySource(
     bySource.set(source, names);
   };
   for (const track of tracks) {
-    if (
-      track.fec !== undefined &&
-      isFecCatalogConfig(track.fec) &&
-      track.fec.repairTrack
-    ) {
-      add(track.name, track.fec.repairTrack);
-    }
+    // The explicit pointer counts whether or not the source's FEC config is
+    // usable (an unimplemented block profile leaves the track without FEC,
+    // not without its repair track): ownership is membership, not
+    // decodability, so no isFecCatalogConfig gate here.
+    const repairTrack = typeof track.fec === "object" && track.fec !== null
+      ? (track.fec as { readonly repairTrack?: unknown }).repairTrack
+      : undefined;
+    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);
     }
@@ -1059,6 +1097,7 @@ function repairTrackNamesBySource(
 export class MulticastManager {
   readonly #fec: FECManager;
   readonly #router: MmtpRouter;
+  #hostMfuTimeoutMs: number | null;
   readonly #transport: MulticastTransport<MmtpIngressContext>;
   #reportedFecDiagnosticsFailure = false;
 
@@ -1170,6 +1209,7 @@ export class MulticastManager {
         this.#emitRepairLifecycle(decision);
       },
     });
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
     this.#transport = new MulticastTransport<MmtpIngressContext>((packet, ingress) => {
       this.#router.feedPacket(packet, "multicast", undefined, ingress);
     });
@@ -1434,7 +1474,6 @@ export class MulticastManager {
       ...(this.#streamFecBaseline ? [this.#streamFecBaseline] : []),
       ...this.#trackFecTiming.values(),
     ];
-    if (contributions.length === 0) return;
 
     let deliveryWindowMs: number | undefined;
     let minimumFailbackWindowMs: number | undefined;
@@ -1451,11 +1490,7 @@ export class MulticastManager {
           c.minimumFailbackWindowMs,
         );
       }
-      // Only a valid §5.1 ms interleave may drive router timing. A sub-floor
-      // value is a raw frame count (no fps to convert with) and would collapse
-      // the MFU timeout to ~0 and the reorder window to a single frame; skip
-      // the derivation rather than clamp it, leaving previously-configured
-      // router timing untouched.
+      // Only a positive catalog span contributes elapsed FEC timing.
       const interleaveOk =
         c.interleaveDepthMs !== undefined &&
         c.interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS;
@@ -1479,15 +1514,11 @@ export class MulticastManager {
       deliveryWindowMs === undefined
         ? minimumFailbackWindowMs
         : Math.max(deliveryWindowMs, minimumFailbackWindowMs ?? 0);
-    if (failbackWindowMs !== undefined) {
-      this.#transport.setFailbackWindowMs(failbackWindowMs);
-    }
-    if (mfuTimeoutMs !== undefined) {
-      this.#router.setMfuTimeoutMs(mfuTimeoutMs);
-    }
-    if (reorderWindowFrames !== undefined) {
-      this.#router.setReorderWindow(reorderWindowFrames);
-    }
+    // Without a positive span or host failback floor, disable the silence watchdog.
+    this.#transport.setFailbackWindowMs(failbackWindowMs ?? null);
+    // No FEC deadline: restore the host's independent reassembly policy.
+    this.#router.setMfuTimeoutMs(mfuTimeoutMs ?? this.#hostMfuTimeoutMs);
+    this.#router.setReorderWindow(reorderWindowFrames ?? 0);
   }
 
   /**
@@ -1535,10 +1566,10 @@ export class MulticastManager {
         `[MulticastManager] configureTrackFec(${packetId}) catalogTrackName must be non-empty when given`,
       );
     }
-    if (config.fecK === undefined || config.fecInterleaveDepthMs === undefined) {
+    if (config.fecK === undefined) {
       throw new Error(
-        `[MulticastManager] configureTrackFec(${packetId}) requires fecK and ` +
-          "fecInterleaveDepthMs. Derive the per-track FEC geometry from the " +
+        `[MulticastManager] configureTrackFec(${packetId}) requires fecK. ` +
+          "Derive the per-track FEC geometry from the " +
           "stream catalog.",
       );
     }
@@ -1547,7 +1578,10 @@ export class MulticastManager {
       `[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);
@@ -1578,9 +1612,9 @@ export class MulticastManager {
     // (configureTrack/timeoutMsForPacket); it just never had the repair-symbol
     // and bandwidth inputs needed to compute one.
     const deliveryWindowMs =
-      config.fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
+      interleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
         ? computeFecDeliveryWindowMs({
-            interleaveDepthMs: config.fecInterleaveDepthMs,
+            interleaveDepthMs,
             sourceSymbols: config.fecK,
             repairSymbols: config.fecRepairSymbols,
             symbolSize: config.fecSymbolSize,
@@ -1593,12 +1627,12 @@ export class MulticastManager {
     // The block classifier's geometry comes from the raw catalog cadence
     // fields; a track whose media kind is not known yet classifies fail-closed.
     const trackKind = config.trackKind ?? this.#router.trackKindFor(packetId);
-    const geometry = trackKind === undefined
+    const geometry = trackKind === undefined || interleaveDepthMs === 0
       ? undefined
       : deriveBlockClassifierGeometry({
           trackKind,
           framerate: config.fps,
-          interleaveDepthMs: config.fecInterleaveDepthMs,
+          interleaveDepthMs,
           timescale: config.timescale,
           keyframeIntervalTicks: config.keyframeIntervalTicks,
           keyframeIntervalMs: config.keyframeIntervalMs,
@@ -1607,7 +1641,7 @@ export class MulticastManager {
       blockProfile,
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs,
       ...(trackKind === undefined ? {} : { trackKind }),
@@ -1619,7 +1653,7 @@ export class MulticastManager {
 
     this.#trackFecTiming.set(packetId, {
       deliveryWindowMs,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       k: config.fecK,
       repairSymbols: config.fecRepairSymbols,
@@ -1642,6 +1676,10 @@ export class MulticastManager {
       | "minimumFailbackWindowMs"
     >,
   ) {
+    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 !== undefined &&
@@ -1671,7 +1709,7 @@ export class MulticastManager {
       config.fecInterleaveDepthMs &&
       config.fecInterleaveDepthMs >= MIN_INTERLEAVE_DEPTH_MS
         ? computeFecDeliveryWindowMs({
-            interleaveDepthMs: config.fecInterleaveDepthMs,
+            interleaveDepthMs,
             sourceSymbols: config.fecK,
             repairSymbols: config.fecRepairSymbols,
             symbolSize: config.fecSymbolSize,
@@ -1683,7 +1721,7 @@ export class MulticastManager {
     this.#fec.configure({
       k: config.fecK,
       symbolSize: config.fecSymbolSize,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       timeoutMs: deliveryWindowMs,
     });
@@ -1698,28 +1736,28 @@ export class MulticastManager {
     // narrow them below what this baseline already guarantees.
     this.#streamFecBaseline = {
       deliveryWindowMs,
-      interleaveDepthMs: config.fecInterleaveDepthMs,
+      interleaveDepthMs,
       fps: config.fps,
       k: config.fecK,
       repairSymbols: config.fecRepairSymbols,
       minimumFailbackWindowMs,
     };
     this.#applyStreamGlobalFecTiming();
-    // Wire FecBlockMapper to MmtpRouter so SBN/ESI derivation works for FEC recovery.
+    // Wire the stream-global FecBlockMapper to MmtpRouter. Under iso-ssbg1-v1
+    // (the only profile) the mapper locates no source symbol: a source is
+    // placed only once a repair states its block (SS_Start, SSB_length), and
+    // FecBlockMapper.fromSsId refuses every FEC stream. The router reads the
+    // mapper only for the stream's block profile and K_max when no FEC
+    // manager answers for the packet.
     //
-    // gopDurationMs MUST be the per-frame interval (1000/fps), NOT the
-    // interleaveDepthMs. Passing interleaveDepthMs collapses D to 1, which
-    // makes the mapper math equivalent to the no-mapper fallback
-    // (floor(ssId/k), ssId%k) and breaks SBN/ESI derivation for any interleaved
-    // FEC. Surfaced by BLO-3323 L14 (pim-multicast-gateway run 26373805710):
-    // with K=32 + interleaveDepthMs=1000ms but gopDurationMs=1000ms, blocks
-    // completed with only ~8 source + ~8 repair symbols (out of 40 expected at
-    // 25-30fps), so the WASM decoder failed to recover any block at 10% loss.
+    // gopDurationMs is the per-frame interval (1000/fps), never the
+    // interleaveDepthMs: the mapper derives its interleave depth D from their
+    // ratio, and passing interleaveDepthMs collapses D to 1 (BLO-3323 L14).
     const k = config.fecK;
     const interleaveMs = config.fecInterleaveDepthMs;
     const fps = config.fps;
-    // The stream-global mapper is the k-padded-v1 SS_ID locator; it exists
-    // only for a stream whose catalog names that profile.
+    // The stream-global mapper exists only for a stream whose catalog names a
+    // block profile; parseFecBlockProfile refuses the retired k-padded-v1.
     const blockProfile = config.fecBlockProfile === undefined
       ? undefined
       : parseFecBlockProfile(config.fecBlockProfile, "[MulticastManager] configureFec fecBlockProfile");
@@ -1771,6 +1809,7 @@ export class MulticastManager {
 
   setMfuTimeoutMs(ms: number): void {
     this.#router.setMfuTimeoutMs(ms);
+    this.#hostMfuTimeoutMs = this.#router.reassembler.timeoutMs;
   }
 
   setTrackCodec(packetId: number, codec: string) {
@@ -1798,6 +1837,7 @@ export class MulticastManager {
   onTrackPacket(packetId: number, cb: TrackPacketCallback) {
     this.#router.onTrackPacket(packetId, cb);
   }
+  /** @deprecated Use onTrackInit(packetId, cb); see MmtpRouter.onInitSegment. */
   onInitSegment(cb: (data: Uint8Array) => void) {
     this.#router.onInitSegment(cb);
   }
@@ -1821,7 +1861,7 @@ export class MulticastManager {
 
   enableMseAssembler(
     packetId: number,
-    config: Omit<BlockAssemblerConfig, "k">,
+    config: BlockAssemblerConfig,
     catalogTrackName?: string,
   ) {
     return this.#router.enableMseAssembler(packetId, config, catalogTrackName);
@@ -1906,21 +1946,11 @@ export class MulticastManager {
             ),
           ),
         };
-    // Precedence between two sources, not a tolerant alias. BOTH operands can
-    // carry a catalog-declared relay, so neither one is "the" inlet:
-    //   `amtRelay`     — the player/UI override, AND the post-migration catalog
-    //                    path: `endpointToMulticastConfig` (packages/transport
-    //                    multicast-catalog-policy.ts) resolves
-    //                    `multicast.networkSource[{type:"amt"}]` into it
-    //                    through `findAmtRelay`.
-    //   `relayAddress` — the pre-migration per-endpoint relay, retained so a
-    //                    catalog published before BLO-37834 still joins.
-    // The override/networkSource value wins, else the legacy endpoint value.
-    // `??`, not `||`, so precedence is deliberately NOT trim-aware: a player
-    // clearing its override field means "no AMT", not "fall back to the legacy
-    // relay". Blank is absent for the port decision below but present here.
-    // Retiring `relayAddress` is the legacy cut (BLO-38068), not this branch.
-    const amtRelay = config.amtRelay ?? config.relayAddress;
+    // The single relay inlet: the player/UI override, or the catalog's
+    // `multicast.networkSource[{type:"amt"}]` relay, which
+    // `endpointToMulticastConfig` (packages/transport
+    // multicast-catalog-policy.ts) resolves into `amtRelay` via `findAmtRelay`.
+    const amtRelay = config.amtRelay;
     const transportConfig = {
       sourceAddress: config.sourceAddress,
       groupAddress: config.groupAddress,
@@ -1933,9 +1963,8 @@ export class MulticastManager {
       // 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
@@ -2210,7 +2239,10 @@ export class MulticastManager {
     }
   }
 
-  /** 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: MmtpStreamIdentity): void {
     // Repair transports abort I/O for a stream on a reset notice
     // (wireRepairFetch); a retired stream's repair fetches end with it.
@@ -2232,10 +2264,10 @@ export class MulticastManager {
     for (const [key, stats] of [...this.#blockPolicyStats]) {
       if (stats.packetId === stream.packetId) this.#blockPolicyStats.delete(key);
     }
-    // The retired track stops contributing to the stream-global FEC timing;
-    // the deadlines already applied stay until the next configuration
-    // re-reduces them, which only ever errs toward the wider window.
-    this.#trackFecTiming.delete(stream.packetId);
+    if (this.#trackFecTiming.delete(stream.packetId)) {
+      this.#applyStreamGlobalFecTiming();
+    }
+    this.#multiTrackFecTracks.delete(stream.packetId);
     this.#fec.releasePacket(stream.packetId);
   }
 
@@ -2302,6 +2334,21 @@ export class MulticastManager {
    * 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.
@@ -2325,6 +2372,44 @@ export class MulticastManager {
     // mis-roled or rejected on its name, and would land in its own altGroup
     // rather than its owner's.
     const repairNamesBySource = repairTrackNamesBySource(catalog.tracks);
+    // §5.1: classify each media track's FEC before roles are resolved. A track
+    // whose FEC is unavailable still names its layer 0 by `fec.repairTrack`;
+    // that pointer is a catalog fact about the leg, not about the profile, so
+    // the leg stays roled `repair` in its owner's group rather than falling
+    // through to its name. It is never given an owner below.
+    const declaredRepairNames = new Set<string>();
+    for (const names of repairNamesBySource.values()) {
+      for (const name of names) declaredRepairNames.add(name);
+    }
+    const fecUnavailableByTrack = new Map<string, TrackFecUnavailable>();
+    for (let i = 0; i < catalog.tracks.length; i++) {
+      const track = catalog.tracks[i]!;
+      if (
+        track.fec === undefined ||
+        track.packaging === "fec-repair" ||
+        declaredRepairNames.has(track.name)
+      ) {
+        continue;
+      }
+      const fecUnavailable = catalogFecUnavailable(track.fec, `$.tracks[${i}].fec`);
+      if (fecUnavailable === undefined) continue;
+      fecUnavailableByTrack.set(track.name, fecUnavailable);
+      const layerZero = (track.fec as { repairTrack?: unknown }).repairTrack;
+      if (typeof layerZero === "string" && layerZero.length > 0) {
+        const names = repairNamesBySource.get(track.name) ?? new Set<string>();
+        names.add(layerZero);
+        repairNamesBySource.set(track.name, names);
+      }
+    }
+    // Every repair leg of a source without FEC goes unowned, including one a
+    // source with FEC also names: the router could not tell the two sources'
+    // symbols apart on it, and the unavailable source's must reach no decoder.
+    const unownedRepairNames = new Set<string>();
+    for (const sourceName of fecUnavailableByTrack.keys()) {
+      for (const repairName of repairNamesBySource.get(sourceName) ?? []) {
+        unownedRepairNames.add(repairName);
+      }
+    }
     const repairOwnerGroup = new Map<string, string>();
     const repairOwnerAltGroup = new Map<string, number | undefined>();
     for (const track of catalog.tracks) {
@@ -2390,11 +2475,15 @@ export class MulticastManager {
     for (let i = 0; i < catalog.tracks.length; i++) {
       const track = catalog.tracks[i]!;
       if (resolvedRoles[i] === "repair" || track.fec === undefined) continue;
-      if (!isFecCatalogConfig(track.fec)) {
+      // Malformed geometry fails the call whatever the profile says; an
+      // unavailable profile or span only costs this track its FEC (§5.1).
+      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 !== undefined) fecTrackIndexes.push(i);
     }
 
@@ -2424,10 +2513,32 @@ export class MulticastManager {
       }
     }
 
-    // Reset switching-set index and repair packetId set.
+    // Reset switching-set index, repair packetId set and FEC availability.
     this.#switchingSets.clear();
     this.#repairPacketIds.clear();
     this.#router.clearRepairPacketIdOwners();
+    // FEC a previous call configured that this one does not (the source is
+    // gone, lost its `fec`, or its FEC is now unavailable) must not stay
+    // installed: its symbols would still be read as block coordinates and
+    // held for repair legs that no longer have an owner. FEC a caller wired
+    // by hand is not this call's to release.
+    const fecPacketIds = new Set([...fecDecoders.keys()].map((i) => catalog.tracks[i]!.packetId));
+    // The record survives a throw below: a packet this call configures again
+    // is overwritten by its set(), and a released one is dropped by
+    // #releaseRetiredStream.
+    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] as const),
     );
@@ -2460,8 +2571,9 @@ export class MulticastManager {
         continue;
       }
 
-      // D-07: Apply per-track FEC config for non-repair tracks.
-      if (track.fec !== undefined) {
+      // D-07: Apply per-track FEC config for non-repair tracks. A track whose
+      // FEC is unavailable (§5.1) is consumed like a track without `fec`.
+      if (track.fec !== undefined && !fecUnavailableByTrack.has(track.name)) {
         const fecCfg = track.fec as FecCatalogConfig;
         // Every repair layer and the keyframe overlay route to this source's
         // decoder, not only layer 0. A layer whose packetId had no registered
@@ -2469,6 +2581,7 @@ export class MulticastManager {
         // two sources whose RS_ID ranges overlap would be indistinguishable.
         if (track.packetId !== undefined) {
           for (const repairName of repairNamesBySource.get(track.name) ?? []) {
+            if (unownedRepairNames.has(repairName)) continue;
             const repairTrack = catalogTracksByName.get(repairName);
             if (repairTrack?.packetId !== undefined) {
               this.#router.setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
@@ -2493,17 +2606,18 @@ export class MulticastManager {
               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");
@@ -2512,6 +2626,27 @@ export class MulticastManager {
     }
   }
 
+  /**
+   * 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: string): TrackFecUnavailable | undefined {
+    return this.#fecUnavailableByTrack.get(trackName);
+  }
+
+  /** Per-track FEC availability from the last `configureMultiTrack` call. */
+  readonly #fecUnavailableByTrack = new Map<string, TrackFecUnavailable>();
+
+  /** packetId → catalog track name of the FEC the last `configureMultiTrack` installed. */
+  readonly #multiTrackFecTracks = new Map<number, string>();
+
   /**
    * Return the track names belonging to the given altGroup switching set.
    * D-17: altGroup groups base+delta+repair into one switching set.
@@ -2570,12 +2705,22 @@ export class MulticastManager {
   /** Record a repair request the scheduler sent no FETCH for. */
   noteRepairSkipped(
     reason: RepairSkipReason,
-    measurement: { readonly rttMs: number | null; readonly budgetMs: number },
+    measurement: { readonly rttMs: number | null; readonly budgetMs: number; readonly priority?: RepairPriority },
     sbn: number,
     packetId: number,
     catalogTrackName?: string,
   ): void {
-    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",
@@ -2586,6 +2731,37 @@ export class MulticastManager {
     });
   }
 
+  /**
+   * 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: number, catalogTrackName?: string): number | undefined {
+    return this.#router.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
+  }
+
+  /** Record a keyframe late-repair budget the scheduler granted a block. */
+  noteKeyframeBudgetGranted(
+    extensionMs: number,
+    _sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): void {
+    const stats = this.#statsFor(packetId, catalogTrackName);
+    stats.keyframeBudgetHolds++;
+    stats.keyframeBudgetHoldMs += extensionMs;
+  }
+
+  /** Record a repair FETCH the scheduler admitted and sent. */
+  noteRepairFetchSent(
+    priority: RepairPriority,
+    _sbn: number,
+    packetId: number,
+    catalogTrackName?: string,
+  ): void {
+    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.
@@ -2620,7 +2796,10 @@ export class MulticastManager {
     const out: Record<string, BlockPolicyStats> = {};
     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;
   }