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

package/src/mmtp-router.ts

@@ -529,22 +529,19 @@ export interface FECManagerLike {
    *  Returns recovered block bytes if recovery completes, else null.
    *
    *  `symbolData` is the complete MMTP packet without its Source FEC Payload
-   *  ID, unpadded and possibly a view into the received packet. The manager
-   *  zero-pads it to the packet's own symbol size T.
-   *
-   *  Optional `alta` carries the detached ALTA authenticator extracted from
-   *  the MMTP header-extension trailer (08-07 Path 2) — present on signed
-   *  source packets, absent on relay-reassembled / unsigned streams. When
-   *  provided, the fec-worker runs verify_detached instead of counting the
-   *  symbol as `altaPending`. */
+   *  ID, unpadded and possibly a view into the received packet. The decoder
+   *  builds the ssbg_mode1 symbol (`u16 len || packet || 00h`, zero-filled to
+   *  the packet's own symbol size T) from it; nothing pads it on the way. */
   feedSourceSymbol(
     packetId: number,
     ssId: number,
     symbolData: Uint8Array,
-    alta?: { auth: Uint8Array; payloadEnd: number },
     catalogTrackName?: string,
   ): Uint8Array | null;
 
+  /** A block's RSB_length, from one of its repair symbols (optional). */
+  noteRepairGroupLength?(sbn: number, packetId: number, rsbLength: number, catalogTrackName?: string): void;
+
   /** Feed a repair symbol to the FEC decoder for a given track.
    *  Returns recovered block bytes if recovery completes, else null. */
   feedRepairSymbol(
@@ -599,17 +596,14 @@ export interface FECManagerLike {
     catalogTrackName?: string,
   ): "pending" | "complete" | "failed" | "untracked";
 
-  /** Highest SBN seen for a stream in the current epoch. */
-  highestSbn?(packetId: number, catalogTrackName?: string): number | undefined;
-
   /** Catalog/reset epoch of a packet's streams. */
   epochFor?(packetId: number): number;
 
   /**
    * Catalog `fec.interleaveDepthMs` (§5.1 full block span) of a packetId; 0
-   * when the stream has none.
+   * when the stream has none, undefined when the packetId is unconfigured.
    */
-  interleaveDepthMsForPacket?(packetId: number): number;
+  interleaveDepthMsForPacket?(packetId: number): number | undefined;
 
   /**
    * How long a terminal block stays authoritative before it retires to
@@ -617,7 +611,7 @@ export interface FECManagerLike {
    * scan never reads a retired, delivered block as lost. Required whenever
    * blockResolution is.
    */
-  terminalRetentionMsForPacket?(packetId: number): number;
+  terminalRetentionMsForPacket?(packetId: number): number | undefined;
 
   /** Configured codec of a packetId. */
   codecFor?(packetId: number): string | undefined;
@@ -691,20 +685,17 @@ export interface FECManagerLike {
     toSsId: number,
   ): readonly number[] | null;
 
-  /** FEC source symbol count K per block. */
-  readonly k: number;
-  kForPacket?(packetId: number): number;
 
   /**
    * The longest a block stays open after its last symbol (inactivity fail
    * bound plus D-28 repair grace). With interleaveDepthMsForPacket it bounds
    * how long the router keeps a stream's duplicate ledgers.
    */
-  blockLifetimeMsForPacket?(packetId: number): number;
+  blockLifetimeMsForPacket?(packetId: number): number | undefined;
 
   /** FEC symbol size T in bytes (0 = unknown / no FEC). */
   readonly symbolSize: number;
-  symbolSizeForPacket?(packetId: number): number;
+  symbolSizeForPacket?(packetId: number): number | undefined;
 
   /** Update framerate — used to refine FEC block timeout. */
   setFramerate(fps: number): void;
@@ -961,6 +952,8 @@ export class MmtpRouter {
   // ── 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: number | (() => number) | null;
+  /** packetIds already warned for running without Phase 13 (non-FEC video only). */
+  readonly #warnedNoKeyframeLostTimeout = new Set<number>();
   /** Why the last reader evaluation left the timer unarmed; null while arming. Dedups the warning. */
   #keyframeLostUnarmedReason: string | null = null;
   /** Active keyframe loss timer handle. Single timer per video track — cleared on each rapFlag and on dispose(). */
@@ -977,6 +970,8 @@ export class MmtpRouter {
    */
   #onPublisherRestart: ((packetId: number, catalogTrackName: string) => void) | null;
   #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;
@@ -1324,17 +1319,28 @@ export class MmtpRouter {
       return NO_FEC_GEOMETRY_HORIZON;
     }
     const blockSpanMs = fec.interleaveDepthMsForPacket(packetId);
+    const blockLifetimeMs = fec.blockLifetimeMsForPacket(packetId);
+    // An unconfigured packetId has no FEC geometry (BLO-45953).
+    if (blockSpanMs === undefined || blockLifetimeMs === undefined) return NO_FEC_GEOMETRY_HORIZON;
     // FECManager reports 0 for a stream the catalog gave no block span.
     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(): number {
+    return this.#unmappedInitDeliveries;
+  }
+
   /** Publisher restarts detected on the multicast leg since construction. */
   get publisherRestartCount(): number {
     return this.#publisherRestarts;
@@ -1440,8 +1446,8 @@ export class MmtpRouter {
 
   /** Update MFU reassembly timeout. Source and FEC-recovery paths share the
    *  parser's single reassembler (BLO-8151), so one update covers both. */
-  setMfuTimeoutMs(ms: number): void {
-    if (ms <= 0) throw new Error("[MmtpRouter] mfuTimeoutMs must be > 0");
+  setMfuTimeoutMs(ms: number | null): void {
+    if (ms !== null && ms <= 0) throw new Error("[MmtpRouter] mfuTimeoutMs must be > 0");
     this.#parser.setMfuTimeoutMs(ms);
   }
 
@@ -1454,18 +1460,14 @@ export class MmtpRouter {
 
   /** 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: number, trackType: "video" | "audio"): void {
-    if (trackType === "video" && this.#keyframeLostTimeoutMs === null) {
-      console.warn(
-        "[MmtpRouter] keyframeLostTimeoutMs not configured — 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);
     // Sync track info to parser for codec-aware keyframe detection.
@@ -1533,7 +1535,15 @@ export class MmtpRouter {
     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: (data: Uint8Array) => void): void {
     this.#onInitSegment = cb;
   }
@@ -1551,20 +1561,19 @@ export class MmtpRouter {
    *  multi-sample CMAF segments instead of per-frame callbacks. */
   enableMseAssembler(
     packetId: number,
-    config: Omit<BlockAssemblerConfig, "k">,
+    config: BlockAssemblerConfig,
     catalogTrackName?: string,
   ): CmafBlockAssembler {
-    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 === undefined ? "" : ` track=${catalogTrackName}`} (K=${k}, ${config.trackType})`,
+      `[MmtpRouter] MSE assembler enabled for packetId=${packetId}${catalogTrackName === undefined ? "" : ` track=${catalogTrackName}`} (${config.trackType})`,
     );
     return assembler;
   }
@@ -1702,6 +1711,24 @@ export class MmtpRouter {
     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: number): void {
+    this.#fecMappersByPacketId.delete(packetId);
+    // Released frames reach FECManager (noteReleasedRap): defer the pokes it
+    // requests, as for every other drain, and drop this packet's.
+    this.#withDeferredFecPokes(() => {
+      this.#parser.endFecRelease(packetId);
+      for (const [key, poke] of this.#pendingFecPokes) {
+        if (poke.packetId === packetId) this.#pendingFecPokes.delete(key);
+      }
+    });
+  }
+
   registerManifestTrack(context: ManifestTrackContext): void {
     if (!this.#manifestVerifier) throw new Error("manifest verifier is not configured");
     this.#manifestVerifier.registerTrack(context);
@@ -1856,121 +1883,26 @@ export class MmtpRouter {
         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;
-
-      // NOTE: Do NOT call trackBlock for repair packets (same as multicast repair path).
-      const recovered = catalogTrackName === undefined
-        ? 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 === undefined
-          ? this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId)
-          : this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId, catalogTrackName);
-        if (catalogTrackName === undefined) {
-          this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId);
-        } else {
-          this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId, catalogTrackName);
-        }
-        if (!alreadyCompleted) {
-          this.#fecManager.countRecovery(ownerPacketId, repairSbn, catalogTrackName);
-          if (catalogTrackName === undefined) {
-            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?: number): number {
-    // Same packet-scoped rule as #deriveSbnEsi: once the packet ID is known,
-    // only its explicitly registered mapper may stand in for the FEC
-    // manager's per-packet K — never the default single-track mapper.
-    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?: number): number {
-    if (packetId != null) return this.#fecManager?.symbolSizeForPacket?.(packetId) ?? this.#fecManager?.symbolSize ?? 0;
+    // A packetId's own T only: an unconfigured one never borrows the
+    // stream-global T (BLO-45953).
+    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: number, packetId?: number): { sbn: number; esi: number } {
-    // A default mapper describes legacy single-track geometry. Once a packet
-    // ID is known, only its explicitly registered mapper may override the
-    // FECManager's packet-scoped K. Falling back to the default video mapper
-    // here maps audio source symbols with video K while repair SBNs correctly
-    // use the audio SSB_length, splitting one block across two coordinates.
-    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: number,
-    ssbLength: number,
-    packetId?: number,
-  ): number | null {
-    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: number): FecBlockProfile | undefined {
     if (this.#fecManager) return this.#fecManager.blockProfileForPacket(packetId);
@@ -1979,9 +1911,10 @@ export class MmtpRouter {
   }
 
   /**
-   * 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.
@@ -1997,8 +1930,20 @@ export class MmtpRouter {
     return profile;
   }
 
-  #isIsoPacket(packetId: number): boolean {
-    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: number,
+    catalogTrackName: string | undefined,
+    ssId: number,
+  ): { sbn: number; esi: number } | null {
+    if (this.#configuredBlockProfile(packetId) === undefined) return null;
+    return this.#fecManager?.locateIsoSource?.(packetId, catalogTrackName, ssId) ?? null;
   }
 
   /**
@@ -2023,14 +1968,12 @@ export class MmtpRouter {
   }
 
   /**
-   * 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: number | undefined, blockId: number, index: number): number {
-    return ownerPacketId !== undefined && this.#isIsoPacket(ownerPacketId)
-      ? serial32Add(blockId, index)
-      : blockId;
+  #fecAnchorForRecovered(blockStart: number, index: number): number {
+    return serial32Add(blockStart, index);
   }
 
   /**
@@ -2038,14 +1981,13 @@ export class MmtpRouter {
    * 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: number,
     catalogTrackName: string | undefined,
-    repair: { ssStart: number; ssbLength: number; rsId: number; symbolData: Uint8Array },
+    repair: { ssStart: number; ssbLength: number; rsbLength: number; rsId: number; symbolData: Uint8Array },
     source: "multicast" | "moq",
   ): void {
     const fec = this.#fecManager;
@@ -2071,6 +2013,7 @@ export class MmtpRouter {
       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,
@@ -2118,7 +2061,7 @@ export class MmtpRouter {
       }
       if (payload.oversized) continue;
       const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-      const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, undefined, catalogTrackName);
+      const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, catalogTrackName);
       if (!recovered || alreadyCompleted) continue;
       fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
       fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
@@ -2154,14 +2097,17 @@ export class MmtpRouter {
   }
 
   /** 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: number,
     data: Uint8Array,
     packetId: number,
     catalogTrackName?: string,
   ): void {
-    this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName);
+    // A Worker-recovered block arrives here whole: defer the gate's drains
+    // until all its frames are in, as the in-band recovery path does.
+    this.#withDeferredFecPokes(() => this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName));
   }
 
   /** Route a single recovered source symbol through the parser + dedup pipeline.
@@ -2637,10 +2583,21 @@ export class MmtpRouter {
   #noteEmittedKeyframe(packetId: number, keyframe: boolean): void {
     if (!keyframe) return;
     if (!this.#videoPacketIds.has(packetId)) return;
-    if (this.#keyframeLostTimeoutMs === null) return;
-    // FEC tracks resolve lost keyframes through block deadlines and the
-    // release gate's stall decision, never through this timer.
+    // FEC tracks resolve lost keyframes through block deadlines, the D-28
+    // repair FETCH and the release gate's stall decision, never through this
+    // timer, so an unconfigured timer is no loss there and is not warned.
     if (this.#isFecTrack(packetId)) return;
+    if (this.#keyframeLostTimeoutMs === null) {
+      if (!this.#warnedNoKeyframeLostTimeout.has(packetId)) {
+        this.#warnedNoKeyframeLostTimeout.add(packetId);
+        console.warn(
+          `[MmtpRouter] keyframeLostTimeoutMs not configured — 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();
   }
@@ -2655,7 +2612,10 @@ export class MmtpRouter {
   #withDeferredFecPokes(work: () => void): void {
     this.#fecPokeDepth++;
     try {
-      work();
+      // The gate's own drains wait for the packet too: a recovered block's
+      // frames are pushed one at a time, and a drain on the first would
+      // release past the others before they arrive.
+      this.#parser.deferFecRelease(work);
     } finally {
       this.#fecPokeDepth--;
       if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
@@ -2668,6 +2628,14 @@ export class MmtpRouter {
     }
   }
 
+  /**
+   * Arrival time of the earliest frame the FEC release gate holds for this
+   * stream (see FecReleaseSequencer.earliestHeldArrivalMs), or undefined.
+   */
+  fecReleaseEarliestHeldAtMs(packetId: number, catalogTrackName?: string): number | undefined {
+    return this.#parser.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
+  }
+
   #requestFecPoke(packetId: number, catalogTrackName: string | undefined): void {
     if (this.#disposed) return;
     if (this.#fecPokeDepth > 0) {
@@ -2697,37 +2665,22 @@ export class MmtpRouter {
       resolvedLoss: (packetId, catalogTrackName, fromSbn, toSbn, releasedSbn) => {
         const fec = this.#fecManager;
         if (!fec?.blockResolution) return [];
-        if (this.#isIsoPacket(packetId)) {
-          // iso-ssbg1-v1 frames are anchored by their packet's SS_ID: wait
-          // until every block that could hold the SS_IDs between the last
-          // released frame and this one is stated and resolved.
-          const head = fromSbn === releasedSbn ? toSbn : fromSbn;
-          return fec.isoSpanResolution?.(packetId, catalogTrackName, releasedSbn, head) ?? null;
-        }
-        const highest = fec.highestSbn?.(packetId, catalogTrackName);
-        const lost: number[] = [];
-        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") {
-            // releasedSbn is the block of the frame the gate last released, so
-            // its media arrived: untracked there means it resolved and retired,
-            // not that it vanished. Counting it would conceal a delivered block.
-            if (sbn === releasedSbn) continue;
-            // Not seen yet: a block at or past the stream's frontier may
-            // still start. Behind the frontier it vanished without trace.
-            if (highest === undefined || sbn > highest) return null;
-            lost.push(sbn);
-          }
-        }
-        return lost;
+        // A frame is anchored by its packet's SS_ID (iso-ssbg1-v1, C.5.2): wait
+        // until every block that could hold the SS_IDs between the last
+        // released frame and this one is stated and resolved.
+        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);
@@ -2813,9 +2766,10 @@ export class MmtpRouter {
 
   /**
    * 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: ParserFrameMeta, after: ParserFrameMeta): number | null {
     const from = before.fecSbn;
@@ -2828,12 +2782,10 @@ export class MmtpRouter {
     const numerator = BigInt(Math.ceil(interleaveMs)) * BigInt(timing.mediaTimescale);
     const denominator = BigInt(timing.durationTicks) * 1000n;
     const unitsPerBlock = (numerator + denominator - 1n) / denominator;
-    // iso-ssbg1-v1 anchors are SS_IDs: every block holds at least one, so the
+    // Anchors are SS_IDs (C.5.2): every block holds at least one, so the
     // serial SS_ID distance bounds the blocks between them.
     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);
@@ -2899,8 +2851,9 @@ export class MmtpRouter {
     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 === undefined ? "" : ` track=${catalogTrackName}`} (${data.byteLength}B)`,
@@ -2971,9 +2924,14 @@ export class MmtpRouter {
     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);
+        // A source resolves with its block coordinates (SS_Start, ESI), the
+        // pair a recovered symbol of the same block resolves with. SS_ID alone
+        // locates no block (C.5.3): until a repair states this source's block
+        // it has none, its identity stays absent, and the verifier's
+        // missing-identity policy below applies.
         const catalogTrackName = catalogTrackNameForPacket(ingress, info.packetId);
-        identity = (this.#resolveManifestIdentityForRoute
+        const coordinates = this.#locateFecSource(info.packetId, catalogTrackName, info.fecPayloadId.ssId);
+        identity = coordinates === null ? undefined : (this.#resolveManifestIdentityForRoute
           ? this.#resolveManifestIdentityForRoute({
               packetId: info.packetId,
               sbn: coordinates.sbn,
@@ -3042,92 +3000,7 @@ export class MmtpRouter {
         // NOTE: Do NOT call trackBlock for repair packets. Only source symbols
         // should count toward block completion — repair inflates blocksClean stats
         // and masks blocks that actually needed FEC recovery.
-        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;
-
-        // Repair symbols are block progress too. The deadline measures
-        // inactivity, not total block lifetime.
-        const repairCatalogTrackName = catalogTrackNameForPacket(ingress, ownerPacketId);
-        if (repairCatalogTrackName === undefined) {
-          this.#fecManager.noteBlockActivity?.(repairSbn, ownerPacketId);
-        } else {
-          this.#fecManager.noteBlockActivity?.(
-            repairSbn,
-            ownerPacketId,
-            repairCatalogTrackName,
-          );
-        }
-
-        const recovered = repairCatalogTrackName === undefined
-          ? 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 === undefined
-            ? this.#fecManager.isBlockCompleted(repairSbn, ownerPacketId)
-            : this.#fecManager.isBlockCompleted(
-                repairSbn,
-                ownerPacketId,
-                repairCatalogTrackName,
-              );
-          if (repairCatalogTrackName === undefined) {
-            this.#fecManager.cancelBlockTimeout(repairSbn, ownerPacketId);
-          } else {
-            this.#fecManager.cancelBlockTimeout(
-              repairSbn,
-              ownerPacketId,
-              repairCatalogTrackName,
-            );
-          }
-          // Skip routing if block was already completed via source path (all K sources
-          // arrived). The parser's feed() already played every frame.
-          if (!alreadyCompleted) {
-            this.#fecManager.countRecovery(ownerPacketId, repairSbn, repairCatalogTrackName);
-            if (repairCatalogTrackName === undefined) {
-              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 {
       // Drop source packets with unknown packetId — not in catalog.
@@ -3169,14 +3042,13 @@ export class MmtpRouter {
       // The FEC Payload ID FEC may read: none while the packetId has no
       // configured block profile (fecUnreadable above).
       const fecPayloadId = fecUnreadable ? null : info.fecPayloadId;
-      // iso-ssbg1-v1 locates a source by range membership in a block a repair
-      // already stated; until then it is held, unplaced (BLO-35597 iso:3).
-      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) ?? undefined
-            : this.#deriveSbnEsi(fecPayloadId.ssId, info.packetId))
+      // An FEC source is located by range membership in a block a repair
+      // already stated; until then it is held, unplaced (BLO-35597 iso:3). A
+      // readable FEC Payload ID implies a configured block profile
+      // (fecUnreadable above), and iso-ssbg1-v1 is the only one.
+      const fecSource = this.#fecManager !== null && fecPayloadId != null;
+      const coords = fecSource && fecPayloadId
+        ? this.#locateFecSource(info.packetId, catalogTrackName, fecPayloadId.ssId) ?? undefined
         : undefined;
       // Note the packet's FEC block (none without an FEC coordinate) before
       // any ledger lookup, the restart check below included.
@@ -3217,16 +3089,12 @@ export class MmtpRouter {
       }
       if (this.#fecManager && fecPayloadId && coords) {
         const fecId = fecPayloadId;
-        const symbolSize = this.#symbolSizeForPacket(info.packetId);
-
         // The mmtp-packet source symbol protects the complete MMTP packet
         // before SS_ID is appended, self-delimiting and zero-padded to T.
         const rawSymbol = packet.subarray(0, packet.length - 4);
-        // iso-ssbg1-v1 symbols carry a two-octet length (C.3.3): admission
+        // ssbg_mode1 symbols carry a two-octet length (C.3.3): admission
         // refuses length + 2 > T.
-        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);
 
         // NOTE: trackBlock() is deferred to AFTER #feedViaParser (below).
         // Reason: trackBlock synchronously fires onBlockComplete when the
@@ -3269,9 +3137,9 @@ export class MmtpRouter {
           );
           sourceSymbolTrackable = sourceSymbolAccepted;
         } else {
-          // FECManager zero-pads a short symbol to T itself and then owns that
-          // buffer outright, so it can transfer it to the FEC Worker without
-          // copying it again. Padding here as well cost a second T-byte
+          // The exact protected packet travels unpadded: the decoder builds
+          // the ssbg_mode1 symbol itself, and FECManager owns any copy it
+          // hands the FEC Worker. Padding here cost a second T-byte
           // allocation and copy per short packet (BLO-36599).
           const symbolData = rawSymbol;
 
@@ -3296,8 +3164,8 @@ export class MmtpRouter {
 
         // Compute FEC block info for the MSE assembler.
         fecInfo = { sbn: coords.sbn, esi: coords.esi, oversized };
-      } else if (isoSource && this.#fecManager && fecPayloadId) {
-        // iso-ssbg1-v1 source whose block no repair has stated yet: route its
+      } else if (fecSource && this.#fecManager && fecPayloadId) {
+        // An FEC source whose block no repair has stated yet: route its
         // media now and hold its FEC symbol until a repair places it.
         const ssId = fecPayloadId.ssId;
         if (overlapCopy) {
@@ -3340,9 +3208,8 @@ export class MmtpRouter {
         this.#feedViaParser(packet, info, fecInfo, {
           source,
           catalogTrackName,
-          ...(isoSource && info.fecPayloadId
-            ? { fecSbn: info.fecPayloadId.ssId }
-            : fecInfo === undefined ? {} : { fecSbn: fecInfo.sbn }),
+          // An FEC source frame is anchored by its own SS_ID (C.5.2).
+          ...(fecSource && fecPayloadId ? { fecSbn: fecPayloadId.ssId } : {}),
         }, parsed);
       }
       // The frame this packet completed can commit an in-place switch that
@@ -3357,15 +3224,15 @@ export class MmtpRouter {
       // → #flushBlock. Without this ordering, the K-th frame was lost on
       // every block — only K-1 frames per block were ever emitted to MSE.
       // Only first-arriving symbols count toward completion or playback.
+      // A source symbol is accepted only once placed, so it has coords.
       if (
         this.#fecManager &&
         fecPayloadId &&
+        coords &&
         sourceSymbolAccepted &&
         sourceSymbolTrackable
       ) {
-        const { sbn, esi } = isoSource && coords
-          ? coords
-          : this.#deriveSbnEsi(fecPayloadId.ssId, info.packetId);
+        const { sbn, esi } = coords;
         if (
           this.#classifyPacketId(info.packetId) !== null &&
           this.#fecManager.isTrackConfigured?.(info.packetId) !== false
@@ -3403,13 +3270,11 @@ export class MmtpRouter {
               info.packetId,
               sourceFec.ssId,
               sourceFec.symbolData,
-              undefined,
             )
           : this.#fecManager.feedSourceSymbol(
               info.packetId,
               sourceFec.ssId,
               sourceFec.symbolData,
-              undefined,
               catalogTrackName,
             );
         if (recovered) {
@@ -4051,7 +3916,6 @@ export class MmtpRouter {
     // (FI=1/2/3) of a larger MFU.  Route through the reassembler so
     // multi-packet MFUs (e.g., keyframes spanning 15+ packets) are
     // properly assembled before reaching the decoder.
-    const k = this.#kForPacket(ownerPacketId);
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === undefined) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -4064,10 +3928,8 @@ export class MmtpRouter {
       );
     }
     const symbolSize = packetSymbolSize;
-    // iso-ssbg1-v1 returns K' = SSB_length symbols; k-padded-v1 the authored
-    // prefix of a K-symbol block, walked up to K.
+    // An iso-ssbg1-v1 block decodes to K' = SSB_length ssbg_mode1 symbols.
     const result = processFecBlock(recovered, {
-      ...(blockProfile === "k-padded-v1" ? { k } : {}),
       symbolSize,
       ownerPacketId,
       blockProfile,
@@ -4163,9 +4025,6 @@ export class MmtpRouter {
         {
           ...identity,
           packetId: ownerPacketId,
-          ...(ownerPacketId !== undefined && this.#isIsoPacket(ownerPacketId)
-            ? {}
-            : { ssId: blockId * this.#kForPacket(ownerPacketId) + symbol.index }),
         },
         symbol.rawSymbol,
         () => {
@@ -4348,7 +4207,7 @@ export class MmtpRouter {
               rapFlag: sym.fragment.rapFlag,
               recovered: true,
               deliveryProvenance,
-              fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+              fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
               ...(catalogTrackName === undefined ? {} : { catalogTrackName }),
             });
             continue;
@@ -4484,7 +4343,7 @@ export class MmtpRouter {
                 ...(assembled.deliveryProvenance === undefined
                   ? {}
                   : { deliveryProvenance: assembled.deliveryProvenance }),
-                fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+                fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
                 ...(recoveredCatalogTrackName === undefined
                   ? {}
                   : { catalogTrackName: recoveredCatalogTrackName }),
@@ -4669,7 +4528,7 @@ export class MmtpRouter {
             rapFlag: sym.fragment.rapFlag,
             recovered: true,
             deliveryProvenance,
-            fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+            fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
             ...(catalogTrackName === undefined ? {} : { catalogTrackName }),
           });
         } else {
@@ -4759,7 +4618,7 @@ export class MmtpRouter {
               rapFlag: assembled.rapFlag,
               recovered: true,
               deliveryProvenance,
-              fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+              fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
               ...(assembled.catalogTrackName === undefined
                 ? {}
                 : { catalogTrackName: assembled.catalogTrackName }),
@@ -4806,7 +4665,7 @@ export class MmtpRouter {
               : { sampleNumber: sym.fragment.sampleNumber }),
             recovered: true,
             deliveryProvenance,
-            fecSbn: this.#fecAnchorForRecovered(ownerPacketId, blockId, sym.index),
+            fecSbn: this.#fecAnchorForRecovered(blockId, sym.index),
             ...(catalogTrackName === undefined ? {} : { catalogTrackName }),
           });
           continue;