@blockcast/mmt-container 2.2.0-main.75b39a2cdddf → 2.2.0-main.7e8a9d13c01c

package/dist/mmtp-router.js

@@ -8023,6 +8023,9 @@ function authoredGap(before, after) {
 function ssIdAfter(a, b) {
   return (a - b | 0) > 0;
 }
+function holdsRebuilt(stream) {
+  return stream.buf.some(({ meta }) => meta.fecSbnFirst !== void 0);
+}
 var FecReleaseSequencer = class {
   #streams = /* @__PURE__ */ new Map();
   #gate;
@@ -8085,6 +8088,7 @@ var FecReleaseSequencer = class {
       stream.lastSbn = void 0;
       stream.discontinuity = false;
       stream.rapSsId = void 0;
+      stream.sourced = false;
     }
     if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
       this.#recordStat("droppedStale");
@@ -8111,6 +8115,7 @@ var FecReleaseSequencer = class {
       if (compareFrameOrder(stream.buf[mid], frame) < 0) lo = mid + 1;
       else hi = mid;
     }
+    if (stream.buf[lo]?.passed === true) frame.passed = true;
     stream.buf.splice(lo, 0, frame);
     this.#drainUnlessDeferred(stream);
   }
@@ -8146,6 +8151,41 @@ var FecReleaseSequencer = class {
     }
     return false;
   }
+  /**
+   * These streams' sink is being replaced by one that has seen no source
+   * frame yet. First, from a stream that holds a frame the overlay rebuilt,
+   * release to the sink being replaced the frames the unanchored path had
+   * already released to it (#cursorPassed): there they waited in its queue,
+   * which its replacement flushes. A stream that holds none is not drained:
+   * it holds nothing the anchor kept back, and a drain would still force out
+   * a frame held past the hold limit, which before the anchor waited for the
+   * next push. Then treat the streams as unsourced until a source frame is
+   * released.
+   */
+  unsource(packetId, catalogTrackName) {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId === packetId && (catalogTrackName === void 0 || stream.catalogTrackName === catalogTrackName)) {
+        if (stream.draining === 0 && holdsRebuilt(stream)) {
+          if (this.#deferDepth > 0) this.#deferredStreams.add(stream);
+          else this.#drain(stream, true);
+        }
+        stream.sourced = false;
+      }
+    }
+  }
+  /**
+   * Whether a stream of `packetId` holds a frame the keyframe overlay rebuilt
+   * (FrameMeta.fecSbnFirst). Without `catalogTrackName`, every stream of the
+   * packetId.
+   */
+  holdsRebuilt(packetId, catalogTrackName) {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue;
+      if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+      if (holdsRebuilt(stream)) return true;
+    }
+    return false;
+  }
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey) {
     if (streamKey !== void 0) {
@@ -8237,16 +8277,32 @@ var FecReleaseSequencer = class {
         last: null,
         lastSbn: void 0,
         discontinuity: false,
-        rapSsId: void 0
+        rapSsId: void 0,
+        sourced: false,
+        draining: 0
       };
       this.#streams.set(streamKey, stream);
     }
     return stream;
   }
-  #drain(stream) {
+  /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
+  #drain(stream, asUnanchored = false) {
+    stream.draining++;
+    try {
+      this.#drainLoop(stream, asUnanchored);
+    } finally {
+      stream.draining--;
+    }
+  }
+  #drainLoop(stream, asUnanchored) {
     while (stream.buf.length > 0 && stream.last !== null) {
       const head = stream.buf[0];
       const last = stream.last;
+      if (compareFrameOrder(head, last) <= 0) {
+        stream.buf.shift();
+        this.#release(stream, head, void 0);
+        continue;
+      }
       if (stream.discontinuity) {
         stream.discontinuity = false;
         stream.buf.shift();
@@ -8260,9 +8316,10 @@ var FecReleaseSequencer = class {
       }
       const headSbn = head.meta.fecSbn;
       const from = stream.lastSbn ?? headSbn;
-      const to = headSbn ?? stream.lastSbn;
+      const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn;
       let lost = [];
       const unanchored = from === void 0 && to === void 0;
+      let unresolved = false;
       if (from !== void 0 && to !== void 0) {
         const resolved = this.#gate.resolvedLoss(
           stream.packetId,
@@ -8271,7 +8328,8 @@ var FecReleaseSequencer = class {
           Math.max(from, to),
           from
         );
-        if (resolved === null) {
+        unresolved = resolved === null;
+        if (unresolved && !this.#cursorPassed(stream, asUnanchored)) {
           const heldMs = performance.now() - head.arrivedAtMs;
           if (heldMs <= this.#gate.holdLimitMs(stream.packetId, stream.catalogTrackName)) return;
           this.#recordStat("forcedWindowFlushes");
@@ -8279,22 +8337,56 @@ var FecReleaseSequencer = class {
           this.#release(stream, head, this.#gate.decide(last, head, [], true));
           continue;
         }
-        lost = resolved;
+        lost = resolved ?? [];
       }
       stream.buf.shift();
       this.#release(
         stream,
         head,
-        lost.length > 0 || unanchored || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
+        lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta) ? this.#gate.decide(last, head, lost, false) : void 0
       );
     }
   }
+  /**
+   * An overlay-rebuilt frame (fecSbnFirst) waits no longer than the BLO-53342
+   * source cursor holds it unanchored, and neither does a later frame behind
+   * it. Unanchored, a frame that waits on no block (fecSbnFirst set, or no
+   * fecSbn) left the gate once every frame ahead of it had: mark it `passed`,
+   * like each frame that arrived in front of it since (stale there). The head
+   * then goes, decided as it would be unanchored, once a frame the base path
+   * delivered (a source frame, or one base FEC recovered) is buffered after a
+   * marked one: the base path has passed that one, so a frame still missing
+   * before it can only come from a repair. It also goes while no source frame
+   * has been released, when the direct path shows a recovered frame at once.
+   * And it goes at once while a staged switch decides on when frames arrive
+   * (FecReleaseGate.releaseUnanchored), and when unsource releases into a
+   * sink being replaced: unanchored, it had already reached the sink.
+   * The scan also writes: the `passed` marks it sets stay on the frames,
+   * and push marks a frame it inserts in front of a marked one from them.
+   */
+  #cursorPassed(stream, asUnanchored) {
+    let at = -1;
+    for (let i = 0; i < stream.buf.length; i++) {
+      const frame = stream.buf[i];
+      if (frame.meta.fecSbnFirst !== void 0 || frame.meta.fecSbn === void 0) {
+        frame.passed = true;
+        if (at < 0) at = i;
+      } else if (frame.passed !== true) break;
+    }
+    if (at < 0) return false;
+    return asUnanchored || !stream.sourced || this.#gate.releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at && meta.fecSbnFirst === void 0 && (meta.recovered !== true || meta.fecSbn !== void 0));
+  }
   #release(stream, frame, decision) {
+    const stale = stream.last !== null && compareFrameOrder(frame, stream.last) <= 0;
+    if (stale) this.#recordStat("droppedStale");
     if (decision) frame.meta.gapBefore = decision;
     stream.last = frame;
-    if (frame.meta.fecSbn !== void 0) stream.lastSbn = frame.meta.fecSbn;
+    if (frame.meta.fecSbn !== void 0 && (frame.meta.fecSbnFirst === void 0 || stream.lastSbn !== void 0)) {
+      stream.lastSbn = frame.meta.fecSbn;
+    }
+    if (frame.meta.recovered !== true) stream.sourced = true;
     this.#gate.onReleased?.(frame.data, frame.meta);
-    this.#emit(frame.data, frame.meta);
+    if (!stale) this.#emit(frame.data, frame.meta);
   }
 };
 var FMPU_BOX_TYPES = /* @__PURE__ */ new Set(["ftyp", "moov", "moof"]);
@@ -8620,6 +8712,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
   fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
     return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
   }
+  /** See FecReleaseSequencer.unsource. */
+  unsourceFecRelease(packetId, catalogTrackName) {
+    this.#fecSequencer?.unsource(packetId, catalogTrackName);
+  }
+  /** See FecReleaseSequencer.holdsRebuilt. */
+  fecReleaseHoldsRebuilt(packetId, catalogTrackName) {
+    return this.#fecSequencer?.holdsRebuilt(packetId, catalogTrackName) ?? false;
+  }
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId, catalogTrackName) {
     if (!this.#fecSequencer) return;
@@ -8946,7 +9046,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
           info,
           resolver,
           options?.recovered === true,
-          options?.fecSbn
+          options?.fecSbn,
+          options?.fecSbnFirst
         );
         if (deferred.record === void 0) this.#countDeferredOutcome(deferred.reason);
       }
@@ -9039,7 +9140,8 @@ var MmtpContainerParser = class _MmtpContainerParser {
       info,
       resolver,
       options?.recovered === true,
-      options?.fecSbn
+      options?.fecSbn,
+      options?.fecSbnFirst
     );
     if (outcome.record !== void 0) return outcome.record;
     return this.#drop(outcome.reason);
@@ -9059,7 +9161,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
    * attribution exists to keep readable. Leaving the choice at the call site
    * is what keeps both true.
    */
-  #emitCombinedSample(combined, info, resolver, recovered, fecSbn) {
+  #emitCombinedSample(combined, info, resolver, recovered, fecSbn, fecSbnFirst) {
     const timing = resolver.sampleTiming(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -9076,6 +9178,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     );
     if (!meta) return { reason: "combined-meta-build-failed" };
     if (fecSbn !== void 0) meta.fecSbn = fecSbn;
+    if (fecSbnFirst !== void 0) meta.fecSbnFirst = fecSbnFirst;
     if (!resolver.consumeSample(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -9926,6 +10029,7 @@ function unstampedBaseSsId(offset, unstampedOffset, headerPsn) {
 var OVERLAY_ROUTED_LIMIT = 1024;
 var OVERLAY_PENDING_LIMIT = 256;
 var OVERLAY_OFFSET_MPUS = 16;
+var OVERLAY_REBUILT_LIMIT = 256;
 var OVERLAY_MOQ_HORIZON_BLOCKS = 64;
 function assertStreamIdentity(role, stream) {
   if (stream === void 0 || !Number.isInteger(stream.packetId) || stream.packetId <= MMTP_SIGNALING_PACKET_ID || typeof stream.catalogTrackName !== "string" || stream.catalogTrackName.length === 0) {
@@ -10102,6 +10206,17 @@ var MmtpRouter = class {
    * an MPU no member of which arrived).
    */
   #unstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
+  /**
+   * The same, shown by the overlay alone, before any base recovery did: a
+   * packet it rebuilt whose base copy carries its protected psn
+   * (#feedOverlaySource), or whose protected psn passes overlayBaseSsId's
+   * test at that offset (#routeOverlayRecovered). A base SS_ID placed by it
+   * anchors the release gate only (BLO-52085 D3): fed to the base, it would
+   * make the base drop a late base copy of a keyframe the overlay never
+   * finished, and lift a block's late-source cut, which nothing before
+   * this offset did.
+   */
+  #overlayUnstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
   /**
    * Streams whose multicast leg delivered a RAP-flagged source packet that was
    * not parsed, typically because its overlap copy was parsed first
@@ -10379,13 +10494,18 @@ var MmtpRouter = class {
           this.#onDeltaBlockCompleteCb?.(packetId, false);
         }
       };
-      this.#fecManager.onBlockFailed = (sbn, packetId, catalogTrackName, blockClass) => {
+      this.#fecManager.onBlockFailed = (sbn, packetId, catalogTrackName, blockClass, span) => {
         this.#mseAssemblerFor(packetId, catalogTrackName)?.failBlock(sbn);
         if (this.#isCatalogTrackUnambiguous(packetId, catalogTrackName) && this.#packetIdRoles.get(packetId) === "delta") {
           this.#onDeltaBlockCompleteCb?.(packetId, true);
         }
-        onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
-        this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+        if (span === void 0) {
+          onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+          this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+        } else {
+          onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass, span);
+          this.#onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass, span);
+        }
       };
     }
   }
@@ -10430,8 +10550,9 @@ var MmtpRouter = class {
   }
   /**
    * FEC-recovered source symbols whose reconstructed header named a
-   * packet_sequence_number other than the wire sequence their SS_ID maps to:
-   * a hop re-stamped the sequence after the sender protected the packet.
+   * packet_sequence_number other than the wire sequence their SS_ID maps to,
+   * or, rebuilt by the overlay, than their base copy carries: a hop
+   * re-stamped the sequence after the sender protected the packet.
    */
   get restampedRecoveredSequenceCount() {
     return this.#restampedRecoveredSeqs;
@@ -10610,6 +10731,7 @@ var MmtpRouter = class {
   enableMseAssembler(packetId, config, catalogTrackName) {
     const assemblerKey = this.#mseAssemblerKey(packetId, catalogTrackName);
     const previous = this.#mseAssemblers.get(assemblerKey);
+    this.#parser.unsourceFecRelease(packetId, catalogTrackName);
     if (previous) {
       previous.flush();
       previous.dispose();
@@ -10760,7 +10882,8 @@ var MmtpRouter = class {
       fec,
       k,
       offsets: /* @__PURE__ */ new Map(),
-      moqBlocks: /* @__PURE__ */ new Set()
+      moqBlocks: /* @__PURE__ */ new Set(),
+      rebuilt: /* @__PURE__ */ new Map()
     };
     this.#overlays.set(repairPacketId, inst);
     return () => {
@@ -10801,6 +10924,7 @@ var MmtpRouter = class {
     inst.last = void 0;
     inst.offsets.clear();
     inst.moqBlocks.clear();
+    inst.rebuilt.clear();
   }
   #overlaysForSource(sourcePacketId, catalogTrackName) {
     return [...this.#overlays.values()].filter(({ leg }) => leg.sourcePacketId === sourcePacketId && (catalogTrackName === void 0 || leg.sourceCatalogTrackName === void 0 || leg.sourceCatalogTrackName === catalogTrackName));
@@ -10853,13 +10977,23 @@ var MmtpRouter = class {
    * base protects: the packet minus its 4-byte SS_ID trailer, extension
    * included (7.1, 7.4.3). `baseSsId` is that trailer's SS_ID, when the base
    * FEC reads it.
+   *
+   * The base copy of a packet an overlay rebuilt with no base SS_ID shows
+   * what a base recovery of it would (#routeProcessedFecSymbols, BLO-52085):
+   * its wire packet_sequence_number equal to the protected one rebuilt shows
+   * the stream unstamped at the SS_ID offset it states, for the release gate
+   * (#overlayUnstampedSsIdSeqOffsetByStream); any other shows a hop that
+   * re-stamps it, which is counted (restampedRecoveredSequenceCount).
    */
   #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source, baseSsId) {
     if (this.#overlays.size === 0) return;
     const ssId = keyframeOverlaySsId(header);
     if (ssId === void 0) return;
+    let rebuiltPsn;
     for (const inst of this.#overlaysForSource(packetId, catalogTrackName)) {
       this.#noteOverlaySsId(inst, ssId, sequenceNumber);
+      rebuiltPsn ??= inst.rebuilt.get(ssId);
+      inst.rebuilt.delete(ssId);
       const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
       if (identity !== null) {
         inst.offsets.delete(identity.mpuSequenceNumber);
@@ -10889,6 +11023,14 @@ var MmtpRouter = class {
       const recovered = fec.feedSourceSymbol(pid, ssId, symbolData, name);
       if (recovered && !alreadyCompleted) this.#routeOverlayRecovered(inst, coords.sbn, recovered);
     }
+    if (rebuiltPsn === void 0 || this.#classifyPacketId(packetId) === null) return;
+    const streamKey = this.#mediaStreamKey(packetId, catalogTrackName);
+    if (rebuiltPsn !== sequenceNumber) {
+      this.#restampedRecoveredSeqs++;
+    } else if (baseSsId !== void 0) {
+      const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
+      if (offset === baseSsId - sequenceNumber >>> 0) this.#overlayUnstampedSsIdSeqOffsetByStream.set(streamKey, offset);
+    }
   }
   #noteOverlayMoqBlock(inst, blockStart) {
     inst.moqBlocks.add(blockStart);
@@ -10922,11 +11064,16 @@ var MmtpRouter = class {
   }
   /**
    * Route an overlay-recovered block's packets as source media of the
-   * overlay's source (7.2: an overlay coordinate yields no base SS_ID). No
-   * base-SS_ID derivation runs: no release-gate anchor, no parse ledger, no
-   * base re-stamp, no block advance. Each packet's wire sequence is restored
-   * from its keyframe's own offset; without one, a stream the base never
-   * re-stamped keeps the header's sequence and any other drops the packet.
+   * overlay's source (7.2: an overlay coordinate yields no base SS_ID). A
+   * packet whose base SS_ID is determined independently (overlayBaseSsId,
+   * unstampedBaseSsId) enters the release gate at that SS_ID, as a packet
+   * base FEC recovered does, so it waits behind base frames still in flight,
+   * though not for its own MPU's packets (FrameMeta.fecSbnFirst) and no
+   * longer than unanchored; one whose base SS_ID is undetermined has no
+   * release-gate anchor. No parse ledger, no base re-stamp, no block
+   * advance. Each packet's wire sequence is restored from its keyframe's own
+   * offset; without one, a stream the base never re-stamped keeps the
+   * header's sequence and any other drops the packet.
    */
   #routeOverlayRecovered(inst, blockStart, recovered) {
     const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -10947,40 +11094,65 @@ var MmtpRouter = class {
     const restamped = this.#restampedStreams.has(streamKey);
     const restored = /* @__PURE__ */ new Set();
     const baseSsIds = /* @__PURE__ */ new Map();
+    const gateOnly = /* @__PURE__ */ new Set();
     const symbols = result.symbols.flatMap((sym) => {
+      const overlaySsId = serial32Add(blockStart, sym.index);
       const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
       if (anchor !== void 0) {
-        const overlaySsId = serial32Add(blockStart, sym.index);
         const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
         restored.add(packetSequenceNumber);
         const out = { ...sym, packetSequenceNumber };
         const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
-        if (baseSsId !== void 0) baseSsIds.set(out, baseSsId);
+        if (baseSsId !== void 0) {
+          baseSsIds.set(sym.index, baseSsId);
+          const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
+          if (!this.#sourceSeqReceived(sourcePacketId, packetSequenceNumber, sourceName) && offset === baseSsId - packetSequenceNumber >>> 0) {
+            this.#overlayUnstampedSsIdSeqOffsetByStream.set(streamKey, offset);
+          }
+        }
         return [out];
       }
       if (!restamped) {
-        const baseSsId = unstampedBaseSsId(
-          this.#ssIdSeqOffsetByStream.get(streamKey),
-          this.#unstampedSsIdSeqOffsetByStream.get(streamKey),
-          sym.packetSequenceNumber
-        );
-        if (baseSsId !== void 0) baseSsIds.set(sym, baseSsId);
+        const offset = this.#ssIdSeqOffsetByStream.get(streamKey);
+        const fedSsId = unstampedBaseSsId(offset, this.#unstampedSsIdSeqOffsetByStream.get(streamKey), sym.packetSequenceNumber);
+        const baseSsId = fedSsId ?? unstampedBaseSsId(offset, this.#overlayUnstampedSsIdSeqOffsetByStream.get(streamKey), sym.packetSequenceNumber);
+        if (baseSsId !== void 0) {
+          baseSsIds.set(sym.index, baseSsId);
+          if (fedSsId === void 0) gateOnly.add(sym.index);
+        } else {
+          inst.rebuilt.set(overlaySsId, sym.packetSequenceNumber);
+          if (inst.rebuilt.size > OVERLAY_REBUILT_LIMIT) inst.rebuilt.delete(inst.rebuilt.keys().next().value);
+        }
         return [sym];
       }
       this.#overlayStats.unsequencedDropped++;
       return [];
     });
     this.#overlayStats.recovered++;
+    const mpuFirst = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      const ssId = baseSsIds.get(sym.index);
+      const mpu = sym.fragment.mpuSequenceNumber;
+      const first = mpuFirst.get(mpu);
+      if (ssId !== void 0 && (first === void 0 || serial32Precedes(ssId, first))) mpuFirst.set(mpu, ssId);
+    }
+    const firstSsIds = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      if (baseSsIds.has(sym.index)) firstSsIds.set(sym.index, mpuFirst.get(sym.fragment.mpuSequenceNumber));
+    }
     this.#routeProcessedFecSymbols(blockStart, { ...result, symbols }, sourcePacketId, sourceName, {
-      deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast"
+      deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast",
+      baseSsIds,
+      firstSsIds
     });
     this.#noteOverlayRecoveredRaps(sourcePacketId, sourceName, streamKey, symbols.filter((sym) => restored.has(sym.packetSequenceNumber)));
-    this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds);
+    this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, gateOnly.size === 0 ? baseSsIds : new Map([...baseSsIds].filter(([index]) => !gateOnly.has(index))));
   }
   /**
    * Joint decoding (BLO-52085). A packet the overlay rebuilt is a source of
    * its base block too, once its base SS_ID is determined (overlayBaseSsId,
-   * from a received member of its MPU, else unstampedBaseSsId),
+   * from a received member of its MPU, else unstampedBaseSsId at an offset a
+   * base recovery showed; `baseSsIds` holds no other),
    * so it is fed to the base decoder as a rebuilt source
    * (FECManager.feedRebuiltSourceSymbol): the base block has one erasure
    * fewer to solve, and its repair can recover the block's other packets.
@@ -11006,7 +11178,7 @@ var MmtpRouter = class {
     const feeds = [];
     for (const sym of symbols) {
       if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
-      const ssId = baseSsIds.get(sym);
+      const ssId = baseSsIds.get(sym.index);
       if (ssId === void 0) {
         this.#overlayStats.baseUndetermined++;
         continue;
@@ -11735,7 +11907,7 @@ var MmtpRouter = class {
         catalogTrackName
       )) continue;
       if (fec.isTrackConfigured?.(ownerPacketId) !== false) {
-        fec.trackBlock(blockStart, ownerPacketId, catalogTrackName, esi, payload.evidence);
+        fec.trackBlock(blockStart, ownerPacketId, catalogTrackName, esi, payload.evidence, true);
         this.#requestFecPoke(ownerPacketId, catalogTrackName);
       }
       if (payload.oversized) continue;
@@ -11823,6 +11995,7 @@ var MmtpRouter = class {
     this.#latestVideoSeqByStream.delete(streamKey);
     this.#ssIdSeqOffsetByStream.delete(streamKey);
     this.#unstampedSsIdSeqOffsetByStream.delete(streamKey);
+    this.#overlayUnstampedSsIdSeqOffsetByStream.delete(streamKey);
     this.#multicastRapTwinByStream.delete(streamKey);
     this.#lastDirectSourceVideoTsByStream.delete(streamKey);
     this.#lastDirectEmittedVideoTsByStream.delete(streamKey);
@@ -11949,6 +12122,12 @@ var MmtpRouter = class {
    *   the outgoing stream stops. The hold is bounded by the incoming stream's
    *   own RAP cadence, so no timer is involved.
    *
+   * While the switch is staged, the FEC release gate lets a keyframe the
+   * overlay rebuilt reach it, on either side, when the keyframe did before
+   * the gate anchored it (FecReleaseGate.releaseUnanchored): the switch
+   * decides on what each side delivered, and the commit discards the gate's
+   * frames of the outgoing stream.
+   *
    * The commit is one synchronous transition inside the frame path: the
    * outgoing stream's already-admitted frames are released (its queued FEC
    * gap fills only up to the RAP, since recovery can queue a frame ahead of
@@ -11999,6 +12178,9 @@ var MmtpRouter = class {
       droppedIncomingFrames: 0
     };
     this.#staged = state;
+    if (this.#parser.fecReleaseHoldsRebuilt(from.packetId, from.catalogTrackName)) {
+      this.#requestFecPoke(from.packetId, from.catalogTrackName);
+    }
     return {
       cancel: () => {
         if (this.#staged !== state) return false;
@@ -12081,7 +12263,17 @@ var MmtpRouter = class {
    */
   #routeParsedFrame(data, meta) {
     if (this.#classifyPacketId(meta.packetId) === null) return;
-    if (this.#staged !== null && this.#interceptSwitchFrame(data, meta)) return;
+    if (this.#staged !== null) {
+      let consumed = false;
+      this.#fecPokeDepth++;
+      try {
+        consumed = this.#interceptSwitchFrame(data, meta);
+      } finally {
+        this.#fecPokeDepth--;
+        this.#flushPendingFecPokes();
+      }
+      if (consumed) return;
+    }
     this.#deliverParsedFrame(data, meta);
   }
   #commitStreamSwitch(state, rap, reason) {
@@ -12233,12 +12425,16 @@ var MmtpRouter = class {
       this.#parser.deferFecRelease(work);
     } finally {
       this.#fecPokeDepth--;
-      if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
-        const pokes = [...this.#pendingFecPokes.values()];
-        this.#pendingFecPokes.clear();
-        for (const poke of pokes) {
-          this.#parser.pokeFecRelease(poke.packetId, poke.catalogTrackName);
-        }
+      this.#flushPendingFecPokes();
+    }
+  }
+  /** Run the pokes requested while #fecPokeDepth was raised, once it is 0. */
+  #flushPendingFecPokes() {
+    if (this.#fecPokeDepth === 0 && this.#pendingFecPokes.size > 0 && !this.#disposed) {
+      const pokes = [...this.#pendingFecPokes.values()];
+      this.#pendingFecPokes.clear();
+      for (const poke of pokes) {
+        this.#parser.pokeFecRelease(poke.packetId, poke.catalogTrackName);
       }
     }
   }
@@ -12316,6 +12512,14 @@ var MmtpRouter = class {
       onRap: (packetId, catalogTrackName, ssId) => {
         for (const observer of this.#fecRapObservers) observer(packetId, catalogTrackName, ssId);
       },
+      // A staged switch commits on when each side's frames reach it
+      // (#interceptSwitchFrame): both sides' overlay keyframes reach it when
+      // they did unanchored.
+      releaseUnanchored: (packetId, catalogTrackName) => {
+        const staged = this.#staged;
+        const stream = { packetId, ...catalogTrackName === void 0 ? {} : { catalogTrackName } };
+        return staged !== null && (isStream(stream, staged.from) || isStream(stream, staged.to));
+      },
       onReleased: (data, meta) => {
         if (meta.trackType !== "video" || meta.mpuSequenceNumber === void 0) return;
         const timing = meta.authoredTiming;
@@ -12766,7 +12970,8 @@ var MmtpRouter = class {
         source: parserOptions?.source,
         deliveryProvenance: parserOptions?.deliveryProvenance,
         catalogTrackName: parserOptions?.catalogTrackName,
-        ...parserOptions?.fecSbn === void 0 ? {} : { fecSbn: parserOptions.fecSbn }
+        ...parserOptions?.fecSbn === void 0 ? {} : { fecSbn: parserOptions.fecSbn },
+        ...parserOptions?.fecSbnFirst === void 0 ? {} : { fecSbnFirst: parserOptions.fecSbnFirst }
       };
       if (parsed) this.#parser.feedParsed(packet, parsed, feedOptions);
       else this.#parser.feed(packet, feedOptions);
@@ -13232,7 +13437,12 @@ var MmtpRouter = class {
   #routeProcessedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, overlay) {
     if (ownerPacketId == null) return;
     if (this.#classifyPacketId(ownerPacketId) === null) return;
-    const fecSbnOf = (index) => overlay ? {} : { fecSbn: this.#fecAnchorForRecovered(blockId, index) };
+    const fecSbnOf = (index) => {
+      if (!overlay) return { fecSbn: this.#fecAnchorForRecovered(blockId, index) };
+      const fecSbn = overlay.baseSsIds.get(index);
+      const fecSbnFirst = overlay.firstSsIds.get(index);
+      return fecSbn === void 0 || fecSbnFirst === void 0 ? {} : { fecSbn, fecSbnFirst };
+    };
     const streamKey = this.#mediaStreamKey(ownerPacketId, catalogTrackName);
     const ssIdSeqOffset = overlay ? void 0 : this.#ssIdSeqOffsetByStream.get(streamKey);
     if (ssIdSeqOffset !== void 0) {