@blockcast/mmt-container 2.2.0-main.a16efba1d85a → 2.2.0-main.a5b276c121d4

package/dist/browser-runtime.js

@@ -851,6 +851,17 @@ function readRepairFecPayloadIdFields(mmtpPacket, parsedHeader) {
     dataOffset: off + REPAIR_FEC_PID_SIZE
   };
 }
+function extractRepairFecPayloadId(mmtpPacket) {
+  const fields = readRepairFecPayloadIdFields(mmtpPacket);
+  if (!fields)
+    return null;
+  return {
+    ssStart: fields.ssStart,
+    rsbLength: fields.rsbLength,
+    rsId: fields.rsId,
+    ssbLength: fields.ssbLength
+  };
+}
 function parseMoqRepairFrame(frame) {
   return moqRepairFrameFrom(frame, readRepairFecPayloadIdFields(frame));
 }
@@ -8625,9 +8636,9 @@ async function openSubscription(rx, openedPromise, options, packetIds) {
   } catch (error) {
     throw new MulticastError("subscription-failed", "MulticastReceiver did not open", error);
   }
-  if (rx.integrityScheme !== INTEGRITY_SCHEME) {
+  if (opened.integrityScheme !== INTEGRITY_SCHEME) {
     await rx.close();
-    throw unsupported(`integrity scheme ${String(rx.integrityScheme)} is not ${INTEGRITY_SCHEME}`);
+    throw unsupported(`integrity scheme ${String(opened.integrityScheme)} is not ${INTEGRITY_SCHEME}`);
   }
   const events = new EventTarget();
   let state = "connected";
@@ -12435,6 +12446,7 @@ var TrackSession = class {
     this.#state = "idle";
     this.#subscription = null;
     this.#disarmFec();
+    this.#unsuppress();
   }
   // -----------------------------------------------------------------------
   // Internal
@@ -12928,6 +12940,15 @@ var IsoBlockLocator = class _IsoBlockLocator {
     this.#heldEvicted = 0;
     /** Pending holes (see `deferIncompleteGaps`): unstated, sources still held. */
     this.#holes = [];
+    /** Holes the horizon passed while pending: sources held until closed. */
+    this.#expired = [];
+    /** Of `#expired`, those `takeExpiredHoles` has not handed out yet. */
+    this.#newlyExpired = [];
+    /**
+     * Spans closed from expired holes: behind the horizon, so kept only for
+     * `locate` while their sources are fed, until the next retirement.
+     */
+    this.#closedBehind = [];
     /**
      * Keep a gap that is missing a source as a pending hole rather than a span,
      * so a repair FETCHed for it (draft-ramadan-moq-fec §7.5) can still state
@@ -12949,7 +12970,11 @@ var IsoBlockLocator = class _IsoBlockLocator {
   #retentionBlocks;
   #heldEvicted;
   #newest;
+  #newestSource;
   #holes;
+  #expired;
+  #newlyExpired;
+  #closedBehind;
   static #checkedRetention(retentionBlocks) {
     if (!Number.isSafeInteger(retentionBlocks) || retentionBlocks <= 0) {
       throw new Error(
@@ -12986,6 +13011,21 @@ var IsoBlockLocator = class _IsoBlockLocator {
   observe(position) {
     if (this.#newest === void 0 || serial32Precedes(this.#newest, position)) this.#newest = position;
   }
+  /**
+   * The newest source SS_ID noted with `noteSource` (RFC 1982 order). Unlike
+   * `newest`, a repair never moves it: a repair can run ahead of its sources,
+   * a source cannot run ahead of the sources sent before it except by
+   * reordering.
+   */
+  get newestSource() {
+    return this.#newestSource;
+  }
+  /** Note a received source's SS_ID; true when it is the newest one yet. */
+  noteSource(ssId) {
+    if (this.#newestSource !== void 0 && !serial32Precedes(this.#newestSource, ssId)) return false;
+    this.#newestSource = ssId;
+    return true;
+  }
   /** Held sources evicted by `heldCapacity` (never by the horizon itself). */
   get heldEvicted() {
     return this.#heldEvicted;
@@ -13004,17 +13044,29 @@ var IsoBlockLocator = class _IsoBlockLocator {
   }
   /** The known block or span containing `ssId`, with its ESI. */
   locate(ssId) {
-    for (let i = this.#blocks.length - 1; i >= 0; i--) {
-      const block = this.#blocks[i];
-      if (isoBlockContains(block.start, block.length, ssId)) {
-        return { block, esi: serial32Distance(block.start, ssId) };
+    for (const blocks of [this.#blocks, this.#closedBehind]) {
+      for (let i = blocks.length - 1; i >= 0; i--) {
+        const block = blocks[i];
+        if (isoBlockContains(block.start, block.length, ssId)) {
+          return { block, esi: serial32Distance(block.start, ssId) };
+        }
       }
     }
     return null;
   }
-  /** Number of pending holes. */
+  /** Number of holes not closed yet, pending or past the horizon. */
   get holeCount() {
-    return this.#holes.length;
+    return this.#holes.length + this.#expired.length;
+  }
+  /**
+   * The pending holes the horizon has passed since the last call, in the
+   * order it passed them. Each is no longer pending: no repair states a block
+   * in it (that repair is `stale`, as for a span the horizon retired) and the
+   * release gate does not wait for it. Its owner must close it
+   * (`closeHolesWithin`), which turns it into a span that is not kept here.
+   */
+  takeExpiredHoles() {
+    return this.#newlyExpired.splice(0);
   }
   /** The stated block (never a span) ending exactly at `end`. */
   blockEndingAt(end) {
@@ -13070,9 +13122,11 @@ var IsoBlockLocator = class _IsoBlockLocator {
   /**
    * Apply one repair symbol's `(SS_Start, SSB_length)`. The first repair of a
    * block states its range and places every held source in it; later repair
-   * symbols of the same block change nothing. A range that contradicts a
-   * known block (a different length, or an overlap with another block or a
-   * span) fails closed: the repair symbol is dropped and no block changes.
+   * symbols of the same block change nothing. A repair whose range is exactly
+   * a repair-less span states that span's one block. A range that contradicts
+   * a known block (a different length, or an overlap with another block or
+   * with part of a span) fails closed: the repair symbol is dropped and no
+   * block changes.
    * A newly stated block retires behind its SS_Start (see the class note).
    * A block so far past `newest` that stating it would retire the position
    * `newest` is refused as `ahead`. When `newest` is a placed block's SS_Start
@@ -13091,7 +13145,16 @@ var IsoBlockLocator = class _IsoBlockLocator {
     const known = this.blockAt(start);
     if (known !== void 0) {
       if (known.span) {
-        return { status: "overlap", reason: `repair block ${start}+${length} falls inside a repair-less span` };
+        if (known.length === length) {
+          const block2 = { start, length, span: false };
+          this.#blocks[this.#blocks.indexOf(known)] = block2;
+          return { status: "placed", block: block2, placed: [] };
+        }
+        return length < known.length ? {
+          status: "overlap",
+          reason: `repair block ${start}+${length} is only the first block of repair-less span ${known.start}+${known.length}`,
+          ofSpan: known
+        } : { status: "overlap", reason: `repair block ${start}+${length} runs past repair-less span ${known.start}+${known.length}` };
       }
       if (known.length !== length) {
         return {
@@ -13159,18 +13222,28 @@ var IsoBlockLocator = class _IsoBlockLocator {
     return span === void 0 ? { status: "placed", block, placed } : { status: "placed", block, placed, span };
   }
   /**
-   * Turn every pending hole inside `[start, start + length)` into a
-   * repair-less span, claiming its held sources: its range FETCH ended, so
-   * nothing more will state its blocks. Returns the spans, in SS_ID order.
+   * Turn every hole inside `[start, start + length)` into a repair-less span,
+   * claiming its held sources: its range FETCH ended, so nothing more will
+   * state its blocks. A hole the horizon passed (`takeExpiredHoles`) leaves a
+   * span that is not kept among the blocks, as the horizon would retire it at
+   * once; only `locate` finds it, until the next retirement, so its sources
+   * can be fed. Returns the spans, in SS_ID order.
    */
   closeHolesWithin(start, length) {
     const closed = [];
-    for (const hole of [...this.#holes]) {
-      if (!isoBlockContains(start, length, hole.start)) continue;
-      this.#holes.splice(this.#holes.indexOf(hole), 1);
-      const spanBlock = { start: hole.start, length: hole.length, span: true };
-      closed.push({ block: spanBlock, placed: this.#claim(spanBlock) });
-      this.#blocks.push(spanBlock);
+    for (const holes of [this.#holes, this.#expired]) {
+      for (const hole of [...holes]) {
+        if (!isoBlockContains(start, length, hole.start)) continue;
+        holes.splice(holes.indexOf(hole), 1);
+        const spanBlock = { start: hole.start, length: hole.length, span: true };
+        closed.push({ block: spanBlock, placed: this.#claim(spanBlock) });
+        if (holes === this.#holes) {
+          this.#blocks.push(spanBlock);
+        } else {
+          this.#closedBehind.push(spanBlock);
+          if (this.#newlyExpired.includes(hole)) this.#newlyExpired.splice(this.#newlyExpired.indexOf(hole), 1);
+        }
+      }
     }
     return closed.sort((x, y) => serial32Distance(start, x.block.start) - serial32Distance(start, y.block.start));
   }
@@ -13184,15 +13257,17 @@ var IsoBlockLocator = class _IsoBlockLocator {
     return void 0;
   }
   /**
-   * Retire every block and span whose last SS_ID, and every held source,
-   * lies more than `retentionBlocks` blocks behind `position`, with the shared
-   * lower-bound metric (`isoBlocksBehindLowerBound`) every ISO interleave
-   * horizon uses. Returns the retired block starts.
+   * Retire every block and span whose last SS_ID, and every held source
+   * outside a hole, lies more than `retentionBlocks` blocks behind
+   * `position`, with the shared lower-bound metric (`isoBlocksBehindLowerBound`)
+   * every ISO interleave horizon uses; a pending hole so far behind expires
+   * (`takeExpiredHoles`). Returns the retired block starts.
    */
   retireBehind(position) {
     this.observe(position);
     const horizon = this.#retentionBlocks;
     const retired = [];
+    this.#closedBehind.length = 0;
     for (let i = this.#blocks.length - 1; i >= 0; i--) {
       const block = this.#blocks[i];
       const last = serial32Add(block.start, block.length - 1);
@@ -13204,10 +13279,15 @@ var IsoBlockLocator = class _IsoBlockLocator {
     for (let i = this.#holes.length - 1; i >= 0; i--) {
       const hole = this.#holes[i];
       const last = serial32Add(hole.start, hole.length - 1);
-      if (isoBlocksBehindLowerBound(last, position, this.#kMax) > horizon) this.#holes.splice(i, 1);
+      if (isoBlocksBehindLowerBound(last, position, this.#kMax) <= horizon) continue;
+      this.#holes.splice(i, 1);
+      this.#expired.push(hole);
+      this.#newlyExpired.push(hole);
     }
     for (const ssId of [...this.#held.keys()]) {
-      if (isoBlocksBehindLowerBound(ssId, position, this.#kMax) > horizon) this.#held.delete(ssId);
+      if (isoBlocksBehindLowerBound(ssId, position, this.#kMax) > horizon && !this.#holes.some((hole) => isoBlockContains(hole.start, hole.length, ssId)) && !this.#expired.some((hole) => isoBlockContains(hole.start, hole.length, ssId))) {
+        this.#held.delete(ssId);
+      }
     }
     return retired;
   }
@@ -13215,9 +13295,13 @@ var IsoBlockLocator = class _IsoBlockLocator {
   reset() {
     this.#blocks.length = 0;
     this.#holes.length = 0;
+    this.#expired.length = 0;
+    this.#newlyExpired.length = 0;
+    this.#closedBehind.length = 0;
     this.#held.clear();
     this.#coverageEnd = void 0;
     this.#newest = void 0;
+    this.#newestSource = void 0;
   }
   #claim(block) {
     const placed = [];
@@ -13837,6 +13921,7 @@ var WORKER_ERROR_LOG_CAP = 5;
 var WORKER_ERROR_KIND_CAP = 32;
 var WORKER_ERROR_OVERFLOW_KIND = "other";
 var STARTUP_REPAIR_WAIT_SOURCE_BOUNDARIES = 2;
+var NOT_TAKEN = Object.freeze({ taken: false, recovered: null });
 function isMulticastSymbolDelivery(value) {
   return value === "datagram" || value === "ordered-relay";
 }
@@ -13930,10 +14015,18 @@ var FECManager = class _FECManager {
     // 'pending' forever, which would park every later frame of its stream in
     // the in-order release gate. Each entry owns its handle; the callback
     // checks it still owns the key, so a settled or reset key is never touched.
+    /**
+     * Per owed Worker cleanup: the bound on its acknowledgement, when its block
+     * was due, and when its cleanup was asked for (see `onCleanupComplete`).
+     */
     this.#pendingWorkerCleanupBounds = /* @__PURE__ */ new Map();
     // Source symbol count per track-scoped block — marks complete when K symbols arrive.
     this.#blockSourceCounts = /* @__PURE__ */ new Map();
     this.#blockSourceEsis = /* @__PURE__ */ new Map();
+    // Source ESIs per block that another FEC instance rebuilt and fed in
+    // (feedRebuiltSourceSymbol). Kept apart from #blockSourceEsis: they are
+    // not network arrivals and never make a block clean.
+    this.#blockRebuiltEsis = /* @__PURE__ */ new Map();
     // Authored SSB_length per block (ISO/IEC 23008-1 §C.5.3), learned from the
     // first repair symbol. The FFmpeg moq_mmt publisher closes a block every D
     // media units, usually before it holds K symbols; under iso-ssbg1-v1
@@ -13942,6 +14035,9 @@ var FECManager = class _FECManager {
     // SSB_length source arrivals and recoverable from SSB_length received
     // symbols; waiting for K fails every one of them.
     this.#blockAuthoredLengths = /* @__PURE__ */ new Map();
+    // Keys whose authored length is a repair-less span's (#openIsoSpan), until
+    // a repair states the block there or the span resolves.
+    this.#isoSpanKeys = /* @__PURE__ */ new Set();
     this.#ssbLengthConflictCount = 0;
     this.#blockRepairRsIds = /* @__PURE__ */ new Map();
     // RSB_length per block (C.5.3 Repair FEC Payload ID): how many repair
@@ -14139,7 +14235,10 @@ var FECManager = class _FECManager {
     // arrives via onBlockRecovered callback.
     this.onBlockStarted = null;
     this.onBlockComplete = null;
-    /** A block reached its fail bound. `blockClass` is its class at failure. */
+    /**
+     * A block reached its fail bound. `blockClass` is its class at failure.
+     * `span` is set when what failed is a repair-less span starting at `sbn`.
+     */
     this.onBlockFailed = null;
     /**
      * Fired once per stream when its Worker decoder stops being routable.
@@ -14181,6 +14280,8 @@ var FECManager = class _FECManager {
      * for it, which it must be.
      */
     this.#onUndelimitedLoss = null;
+    /** Set with the loss handler: true takes an expired hole to close (`closeIsoHoles`). */
+    this.#onIsoHoleExpired = null;
     /** A block every symbol of which vanished was created by SBN evidence. */
     this.onBlockVanished = null;
     /** A block reached a terminal state (completed, recovered, or failed). */
@@ -14223,7 +14324,9 @@ var FECManager = class _FECManager {
   #pendingWorkerCleanupBounds;
   #blockSourceCounts;
   #blockSourceEsis;
+  #blockRebuiltEsis;
   #blockAuthoredLengths;
+  #isoSpanKeys;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
   #blockRsbLengths;
@@ -14290,6 +14393,7 @@ var FECManager = class _FECManager {
   #decoderUnavailableEvents;
   #repairSymbolSizeMismatchCount;
   #onUndelimitedLoss;
+  #onIsoHoleExpired;
   #encodeTrackName(catalogTrackName) {
     let encoded = this.#encodedTrackNames.get(catalogTrackName);
     if (encoded === void 0) {
@@ -14761,7 +14865,10 @@ var FECManager = class _FECManager {
       timer.handle = null;
       this.#requestRepair(sbn, packetId, catalogTrackName);
     };
-    timer.handle = setTimeout(onFire, Math.max(0, deadlineMs - performance.now()));
+    timer.handle = setTimeout(
+      onFire,
+      this.#receiptAtMs === void 0 ? Math.max(0, deadlineMs - performance.now()) : this.#receiptTimerDelayMs(deadlineMs, 0)
+    );
     this.#repairDeadlines.set(key, timer);
   }
   #requestRepair(sbn, packetId, catalogTrackName, settledByOrder = false) {
@@ -14905,8 +15012,14 @@ var FECManager = class _FECManager {
    * Vanished blocks are not enumerated here: their starts are unknown until a
    * repair states them. The SS_IDs between two stated blocks become one
    * repair-less span when the later block's repair arrives (placeIsoRepair).
+   *
+   * A `held` source arrived before its block was known and is fed only now
+   * that a repair, a span or a closed hole placed it: how far its block start
+   * then lies behind the frontier measures how long the receiver held it, not
+   * where the stream was, so only its SS_ID and packet_sequence_number judge
+   * it (BLO-52085).
    */
-  #noteSbnSeen(sbn, packetId, catalogTrackName, symbol, packetSequenceNumber, ssId = sbn) {
+  #noteSbnSeen(sbn, packetId, catalogTrackName, symbol, packetSequenceNumber, ssId = sbn, held = false) {
     const streamKey = this.#streamKey(packetId, catalogTrackName);
     const now = performance.now();
     const previous = (symbol === "source" ? this.#sourceFrontiers : this.#highestSbn).get(streamKey);
@@ -14945,7 +15058,7 @@ var FECManager = class _FECManager {
       return sent <= 2147483647 && serial32Distance(from.ssId, to.ssId) <= sent + config.k;
     };
     if (!this.#blockPrecedes(previous.sbn, sbn)) {
-      if (symbol === "source" && window2 !== null && this.#blockPrecedes(sbn, previous.sbn) && (this.#blocksBehind(sbn, previous.sbn, packetId) > this.#isoRetentionBlocks(packetId) || psn !== void 0 && anchor !== void 0 && serial32Precedes(ssId, anchor.ssId) && psn !== anchor.psn && !sentInOrder({ ssId, psn }, anchor))) {
+      if (symbol === "source" && window2 !== null && this.#blockPrecedes(sbn, previous.sbn) && (!held && this.#blocksBehind(sbn, previous.sbn, packetId) > this.#isoRetentionBlocks(packetId) || psn !== void 0 && anchor !== void 0 && serial32Precedes(ssId, anchor.ssId) && psn !== anchor.psn && !sentInOrder({ ssId, psn }, anchor))) {
         discontinuity();
         return;
       }
@@ -15207,17 +15320,21 @@ var FECManager = class _FECManager {
       this.#blockWaitDeadlinesMs.delete(key);
       this.#repairHoldUntilMs.delete(key);
       this.#traceLifecycle("timeout-queued", sbn, packetId, catalogTrackName);
-      this.#finalizeExpiredBlock(sbn, packetId, catalogTrackName);
+      this.#finalizeExpiredBlock(sbn, packetId, catalogTrackName, currentDeadlineMs ?? firedAtMs);
     };
-    timer.handle = setTimeout(onFire, Math.max(1, Math.ceil(deadlineMs - nowMs)));
+    timer.handle = setTimeout(
+      onFire,
+      this.#receiptAtMs === void 0 ? Math.max(1, Math.ceil(deadlineMs - nowMs)) : this.#receiptTimerDelayMs(deadlineMs, 1)
+    );
     this.#activeBlocks.set(key, timer);
     this.#indexBlockKey(key, sbn, packetId);
   }
   /**
    * Hand a block whose delivery is over to its decoder for finalization: the
-   * datagram deadline fired, or the ordered relay moved past it.
+   * datagram deadline fired, or the ordered relay moved past it. `dueAtMs`
+   * is when it was due: its deadline, or now.
    */
-  #finalizeExpiredBlock(sbn, packetId, catalogTrackName) {
+  #finalizeExpiredBlock(sbn, packetId, catalogTrackName, dueAtMs = performance.now()) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
     if (this.#materializedBlocks.has(key) && !this.#blockPathCounts.has(key)) {
       this.#failBlock(sbn, packetId, catalogTrackName);
@@ -15233,7 +15350,7 @@ var FECManager = class _FECManager {
     if (workerClient) {
       this.#pendingWorkerCleanups.add(key);
       this.#pendingWorkerCleanupClients.set(key, workerClient);
-      this.#boundOwedCleanup(key, packetId, workerClient);
+      this.#boundOwedCleanup(key, packetId, workerClient, dueAtMs);
       workerClient.cleanup(sbn);
     } else {
       const decoder = this.#decoderForPacket(packetId, catalogTrackName)?.client;
@@ -15545,7 +15662,9 @@ var FECManager = class _FECManager {
     }
     resetMap(this.#blockSourceCounts);
     resetMap(this.#blockSourceEsis);
+    resetMap(this.#blockRebuiltEsis);
     resetMap(this.#blockAuthoredLengths);
+    resetSet(this.#isoSpanKeys);
     resetMap(this.#blockRepairRsIds);
     resetMap(this.#blockRsbLengths);
     resetMap(this.#heldLayerStates);
@@ -15669,7 +15788,9 @@ var FECManager = class _FECManager {
     dropMap(this.#pendingWorkerCleanupClients);
     dropMap(this.#blockSourceCounts);
     dropMap(this.#blockSourceEsis);
+    dropMap(this.#blockRebuiltEsis);
     dropMap(this.#blockAuthoredLengths);
+    dropSet(this.#isoSpanKeys);
     dropMap(this.#blockRepairRsIds);
     dropMap(this.#blockRsbLengths);
     dropMap(this.#blockPathCounts);
@@ -15831,6 +15952,9 @@ var FECManager = class _FECManager {
         this.#unindexBlockKey(key);
       }
     }
+    if (isSourceSymbol && source === "multicast") {
+      this.#noteMulticastSource(this.#isoLocatorFor(packetId, catalogTrackName), sbn + esi >>> 0, packetId, catalogTrackName);
+    }
     return true;
   }
   #observeBlockCatalogTrackName(blockKey, sbn, packetId, catalogTrackName) {
@@ -16009,8 +16133,9 @@ var FECManager = class _FECManager {
     return true;
   }
   /**
-   * Drop a block's repair hold: its FETCH ended without delivering. The block
-   * falls back to its multicast wait, which may already have passed.
+   * Drop a block's repair hold: its FETCH ended without delivering, or brought
+   * back only a repair that cannot complete it. The block falls back to its
+   * multicast wait, which may already have passed.
    */
   releaseRepairHold(sbn, packetId, catalogTrackName) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
@@ -16148,6 +16273,8 @@ var FECManager = class _FECManager {
     const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName);
     const evictedBefore = locator.heldEvicted;
     const held = locator.hold(ssId, source);
+    this.#settleExpiredIsoHoles(locator, packetId, catalogTrackName);
+    if (held && source.source === "multicast") this.#noteMulticastSource(locator, ssId, packetId, catalogTrackName);
     const evicted = locator.heldEvicted - evictedBefore;
     if (evicted > 0) {
       const before = this.#isoHeldEvictedCount;
@@ -16168,17 +16295,20 @@ var FECManager = class _FECManager {
    * contradicts a known block is refused (counted) and must be dropped.
    */
   placeIsoRepair(packetId, catalogTrackName, ssStart, ssbLength) {
-    const placement = this.#growingIsoLocatorFor(packetId, catalogTrackName).placeRepair(ssStart, ssbLength);
+    const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName);
+    const placement = locator.placeRepair(ssStart, ssbLength);
+    this.#settleExpiredIsoHoles(locator, packetId, catalogTrackName);
     if (placement.status !== "placed") {
       this.#isoRepairRefusedCount++;
       if (this.#isoRepairRefusedCount <= 5 || this.#isoRepairRefusedCount % 100 === 0) {
         console.warn(`[FECManager] packetId=${packetId} iso-ssbg1-v1 repair refused (${placement.status}): ${placement.reason}`);
       }
+      if (placement.ofSpan !== void 0) this.releaseRepairHold(placement.ofSpan.start, packetId, catalogTrackName);
       return placement;
     }
+    this.#isoSpanKeys.delete(this.#blockKey(placement.block.start, packetId, catalogTrackName));
     if (placement.span !== void 0) this.#openIsoSpan(placement.span, packetId, catalogTrackName);
     if (placement.hole !== void 0) {
-      const locator = this.#isoLocatorFor(packetId, catalogTrackName);
       const hole = placement.hole.block;
       const previous = locator.blockEndingAt(hole.start);
       const loss = {
@@ -16199,17 +16329,29 @@ var FECManager = class _FECManager {
    * `handler`, instead of a repair-less span; null restores spans. Set by the
    * range repair scheduler; applies to every stream from its next gap. The
    * handler and the deferral are one setting, so no hole is ever created with
-   * nobody to close it.
+   * nobody to close it. `onExpired` is told of each pending hole the stream
+   * runs past the locator's horizon (BLO-52085): returning true, it closes
+   * the hole (`closeIsoHoles`), so the span it leaves still fails and is
+   * reported; otherwise the hole is discarded with its sources.
    */
-  setUndelimitedLossHandler(handler) {
+  setUndelimitedLossHandler(handler, onExpired = null) {
     this.#onUndelimitedLoss = handler;
+    this.#onIsoHoleExpired = handler === null ? null : onExpired;
     this.#deferIsoGaps = handler !== null;
     for (const locator of this.#isoLocators.values()) locator.deferIncompleteGaps = this.#deferIsoGaps;
   }
+  /** Hand each hole the locator's horizon passed to its owner, or discard it (setUndelimitedLossHandler). */
+  #settleExpiredIsoHoles(locator, packetId, catalogTrackName) {
+    for (const hole of locator.takeExpiredHoles()) {
+      const expired = { packetId, catalogTrackName, holeStart: hole.start, holeLength: hole.length };
+      if (this.#onIsoHoleExpired?.(expired) !== true) locator.closeHolesWithin(hole.start, hole.length);
+    }
+  }
   /**
-   * The range repair for a hole ended: every hole still pending inside
-   * `[start, start + length)` becomes a repair-less span. Returns those spans
-   * with the held sources they placed, for the caller to feed (MmtpRouter).
+   * The range repair for a hole ended: every hole inside `[start, start +
+   * length)`, pending or expired, becomes a repair-less span. Returns those
+   * spans with the held sources they placed, for the caller to feed
+   * (MmtpRouter).
    */
   closeIsoHoles(packetId, catalogTrackName, start, length) {
     const locator = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName));
@@ -16228,7 +16370,10 @@ var FECManager = class _FECManager {
    */
   #openIsoSpan(span, packetId, catalogTrackName) {
     const key = this.#blockKey(span.block.start, packetId, catalogTrackName);
-    if (!this.#blockAuthoredLengths.has(key)) this.#blockAuthoredLengths.set(key, span.block.length);
+    if (!this.#blockAuthoredLengths.has(key)) {
+      this.#blockAuthoredLengths.set(key, span.block.length);
+      this.#isoSpanKeys.add(key);
+    }
     if (span.placed.length === 0) this.#materializeBlock(span.block.start, packetId, catalogTrackName, true);
   }
   /**
@@ -16569,11 +16714,14 @@ var FECManager = class _FECManager {
     });
     client.onCleanupComplete((sbn) => {
       if (this.#releasedWorkerClients.has(client)) return;
-      const cleanupKeys = [...this.#pendingWorkerCleanups].filter((key) => {
+      const owed = [...this.#pendingWorkerCleanups].filter((key) => this.#pendingWorkerCleanupClients.get(key) === client);
+      const cleanupKeys = owed.filter((key) => {
         const block = this.#parseBlockKey(key);
-        return block.packetId === packetId && block.sbn === sbn && this.#pendingWorkerCleanupClients.get(key) === client;
+        return block.packetId === packetId && block.sbn === sbn;
       });
-      for (const key of cleanupKeys) this.#settleOwedCleanup(key, "cleanup-ack");
+      const askedAtMs = Math.max(...cleanupKeys.map((key) => this.#pendingWorkerCleanupBounds.get(key)?.askedAtMs ?? -Infinity));
+      const due = owed.filter((key) => !cleanupKeys.includes(key) && (this.#pendingWorkerCleanupBounds.get(key)?.dueAtMs ?? Infinity) <= askedAtMs);
+      for (const key of [...cleanupKeys, ...due]) this.#settleOwedCleanup(key, "cleanup-ack");
     });
     client.onError((msg, code) => {
       const requestedKind = code ?? msg;
@@ -16643,9 +16791,11 @@ var FECManager = class _FECManager {
    * fail deadline already passed, so failing it is the decision that deadline
    * made. A late ack then finds nothing owed and is a no-op.
    */
-  #boundOwedCleanup(key, packetId, client) {
+  #boundOwedCleanup(key, packetId, client, dueAtMs) {
     this.#clearOwedCleanupBound(key);
     const bound = {
+      dueAtMs,
+      askedAtMs: performance.now(),
       handle: setTimeout(() => {
         if (this.#pendingWorkerCleanupBounds.get(key) !== bound) return;
         this.#pendingWorkerCleanupBounds.delete(key);
@@ -16743,7 +16893,15 @@ var FECManager = class _FECManager {
       this.#isoSourceOversizeCount++;
       return null;
     }
-    const sbn = located.block.start;
+    return this.#feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, located.block.start);
+  }
+  /**
+   * Hand one placed source symbol to the stream's decoder: its Worker, which
+   * answers through onFrame (null here), or its synchronous decoder, whose
+   * recovered block is returned. `sbn` is the SS_Start of the block a repair
+   * stated for `ssId`.
+   */
+  #feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, sbn) {
     const blockKey = this.#blockKey(sbn, packetId, catalogTrackName);
     const syncBlockOwner = this.#syncDecoderBlockOwners.get(blockKey);
     const workerClient = this.#routableWorkerForPacket(packetId, catalogTrackName);
@@ -16772,6 +16930,74 @@ var FECManager = class _FECManager {
     }
     return recovered;
   }
+  /**
+   * Feed a source symbol of this stream that another FEC instance over the
+   * same packets rebuilt: a keyframe overlay recovery whose base SS_ID the
+   * caller determined (draft-ramadan-moq-mmt-02 7.1, 7.4.4; joint decoding,
+   * BLO-52085). It joins its block's decoder as a received source would, so
+   * it reduces the erasures the block still has to solve, but it is not a
+   * network arrival: no transport accounting, no classification evidence,
+   * no deadline refresh, and it never makes a block clean.
+   *
+   * Only a block a repair stated takes one (a repair-less span has no
+   * decoder block). A block that is terminal, or already holds that source,
+   * does not. The symbol is the exact protected packet, unpadded, as
+   * feedSourceSymbol takes it.
+   *
+   * `recovered` is the block the synchronous decoder completed with it; the
+   * caller routes it and completes the block, as for any recovery. When
+   * every source of the block is then present, received or rebuilt, and no
+   * decoder returned it (a Worker answers asynchronously, and reports such a
+   * block as clean on its own side), the block is completed here as
+   * recovered, with nothing left to route.
+   */
+  feedRebuiltSourceSymbol(packetId, ssId, symbolData, catalogTrackName) {
+    if (!this.#hasBlockProfile(packetId)) return NOT_TAKEN;
+    const located = this.#isoLocatorFor(packetId, catalogTrackName).locate(ssId);
+    if (located === null || located.block.span) return NOT_TAKEN;
+    if (!ssbg1FitsSymbol(symbolData.byteLength, this.#trackConfig(packetId).symbolSize)) return NOT_TAKEN;
+    const sbn = located.block.start;
+    const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    if (this.#completedBlocks.has(key) || this.#blockSourceEsis.get(key)?.has(located.esi)) return NOT_TAKEN;
+    let rebuilt = this.#blockRebuiltEsis.get(key);
+    if (rebuilt?.has(located.esi)) return NOT_TAKEN;
+    if (rebuilt === void 0) {
+      rebuilt = /* @__PURE__ */ new Set();
+      this.#blockRebuiltEsis.set(key, rebuilt);
+    }
+    const config = this.#trackConfigs.get(packetId);
+    const wasShort = config !== void 0 && this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config) !== void 0;
+    rebuilt.add(located.esi);
+    const recovered = this.#feedDecoderSource(packetId, ssId, symbolData, catalogTrackName, sbn);
+    if (recovered === null && !this.#completeWhenSourcesPresent(key, sbn, located.block.length, packetId, catalogTrackName)) {
+      if (wasShort && this.#activeBlocks.has(key) && this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config) === void 0) {
+        this.#armBlockTimeout(sbn, packetId, catalogTrackName, this.#multicastWaitMs(config));
+      }
+    }
+    return { taken: true, recovered };
+  }
+  /**
+   * A block that holds every one of its `length` sources, received or
+   * rebuilt by another instance, with at least one rebuilt, is recovered:
+   * every packet of it was delivered, by its own arrival or by the instance
+   * that rebuilt it, so nothing is routed. Returns whether it completed it.
+   */
+  #completeWhenSourcesPresent(key, sbn, length, packetId, catalogTrackName) {
+    const rebuilt = this.#blockRebuiltEsis.get(key);
+    if (rebuilt === void 0 || this.#completedBlocks.has(key)) return false;
+    let present = rebuilt.size;
+    for (const esi of this.#blockSourceEsis.get(key) ?? []) if (!rebuilt.has(esi)) present++;
+    if (present < length) return false;
+    this.#traceLifecycle("recovered", sbn, packetId, catalogTrackName);
+    this.countRecovery(packetId, sbn, catalogTrackName);
+    this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
+    if (catalogTrackName === void 0) {
+      this.onBlockComplete?.(sbn, packetId);
+    } else {
+      this.onBlockComplete?.(sbn, packetId, catalogTrackName);
+    }
+    return true;
+  }
   /**
    * fec-01 4.5: a reed-solomon repair packet whose SSB_length + RSB_length
    * exceeds 255, or whose RS_ID is not below RSB_length, is discarded with the
@@ -16974,8 +17200,75 @@ var FECManager = class _FECManager {
       this.#completeCleanBlock(blockKey, sbn, packetId, catalogTrackName);
       return null;
     }
+    if (recovered === null) this.#shortenUnrecoverableWait(blockKey, sbn, packetId, catalogTrackName);
     return recovered;
   }
+  /**
+   * A first-arrival multicast source, held or placed. A datagram flow keeps
+   * its sources in send order, so one that moves the stream's newest source
+   * position past a block leaves the sources that block still misses
+   * reordered behind it at best: it shortens the wait of every block it
+   * passed that only a late source can complete. MoQ is left out: its streams
+   * can overtake one another, so a MoQ source shows nothing about the sources
+   * sent before it.
+   */
+  #noteMulticastSource(locator, ssId, packetId, catalogTrackName) {
+    const previous = locator.newestSource;
+    if (!locator.noteSource(ssId) || previous === void 0) return;
+    for (const block of locator.blocksBetween(previous - 1 >>> 0, ssId)) {
+      if (block.span || !serial32Precedes(serial32Add(block.start, block.length - 1), ssId)) continue;
+      this.#shortenUnrecoverableWait(
+        this.#blockKey(block.start, packetId, catalogTrackName),
+        block.start,
+        packetId,
+        catalogTrackName
+      );
+    }
+  }
+  /**
+   * The wait of a block that only a late source can complete (BLO-52085): a
+   * repair stated it, its received sources plus every symbol its repair group
+   * carries (RSB_length) are short of K' (the repair scheduler's
+   * group-cannot-complete), and a later source of the stream has arrived, so
+   * a source it misses is lost or reordered behind that one. The span, which
+   * covers repair symbols paced after its sources, buys it nothing: it waits
+   * the late-symbol allowance alone, the multicast wait less the span (the
+   * catalog tolerance or the measured delivery gap). Undefined for any other
+   * block.
+   */
+  #lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config) {
+    const authoredLength = this.#blockAuthoredLengths.get(key);
+    const rsbLength = this.#blockRsbLengths.get(key);
+    if (authoredLength === void 0 || rsbLength === void 0) return void 0;
+    let present = this.#blockSourceCounts.get(key) ?? 0;
+    const received = this.#blockSourceEsis.get(key);
+    for (const esi of this.#blockRebuiltEsis.get(key) ?? []) if (!received?.has(esi)) present++;
+    if (present + rsbLength >= authoredLength) return void 0;
+    const newestSource = this.#isoLocators.get(this.#streamKey(packetId, catalogTrackName))?.newestSource;
+    if (newestSource === void 0 || !serial32Precedes(serial32Add(sbn, authoredLength - 1), newestSource)) {
+      return void 0;
+    }
+    return this.#multicastWaitMs(config) - config.interleaveDepthMs;
+  }
+  /**
+   * Bring an open block's wait in to its late-source wait, when it has one.
+   * Never later than it is armed: only a source can complete such a block,
+   * so a repair of its group (paced across the span) must not keep it open.
+   */
+  #shortenUnrecoverableWait(key, sbn, packetId, catalogTrackName) {
+    if (!this.#activeBlocks.has(key)) return;
+    const config = this.#trackConfigs.get(packetId);
+    if (config === void 0) return;
+    const waitMs = this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, config);
+    if (waitMs === void 0) return;
+    const armedAtMs = this.#blockWaitDeadlinesMs.get(key);
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      armedAtMs === void 0 ? waitMs : Math.min(waitMs, armedAtMs - this.#receiptNow())
+    );
+  }
   /**
    * Record a block's authored SSB_length from a repair symbol. Returns false,
    * leaving the block unchanged, when the symbol contradicts the block: a
@@ -17073,12 +17366,13 @@ var FECManager = class _FECManager {
    * the inactivity deadline on each symbol, records the symbol's in-band
    * classification evidence, and marks the block clean when all of its
    * authored source symbols arrived: the SSB_length a repair symbol declared,
-   * otherwise K.
+   * otherwise K. `held` marks a source held unplaced since it arrived and
+   * placed only now (see #noteSbnSeen).
    *
    * Throws for a packetId that was never configured, so a classified block
    * never reads the manager-global K or timeout.
    */
-  trackBlock(sbn, packetId, catalogTrackName, esi, evidence) {
+  trackBlock(sbn, packetId, catalogTrackName, esi, evidence, held = false) {
     const trackConfig = this.#trackConfigs.get(packetId);
     if (trackConfig === void 0) {
       throw new Error(
@@ -17094,7 +17388,8 @@ var FECManager = class _FECManager {
       catalogTrackName,
       "source",
       evidence.packetSequenceNumber,
-      Number.isInteger(esi) ? sbn + esi >>> 0 : sbn
+      Number.isInteger(esi) ? sbn + esi >>> 0 : sbn,
+      held
     );
     const authoredLength = this.#blockAuthoredLengths.get(key) ?? k;
     if (Number.isInteger(esi) && esi >= authoredLength) {
@@ -17130,6 +17425,15 @@ var FECManager = class _FECManager {
       this.#completeCleanBlock(key, sbn, packetId, catalogTrackName);
       return;
     }
+    if (this.#blockRebuiltEsis.has(key) && this.#completeWhenSourcesPresent(
+      key,
+      sbn,
+      this.#isoLocatorFor(packetId, catalogTrackName).blockAt(sbn)?.length ?? authoredLength,
+      packetId,
+      catalogTrackName
+    )) {
+      return;
+    }
     this.noteBlockActivity(sbn, packetId, catalogTrackName, true);
   }
   #completeCleanBlock(key, sbn, packetId, catalogTrackName) {
@@ -17138,7 +17442,9 @@ var FECManager = class _FECManager {
     this.cancelBlockTimeout(sbn, packetId, catalogTrackName);
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
+    this.#isoSpanKeys.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
     this.#markTerminal(key, sbn, packetId, true);
@@ -17169,6 +17475,19 @@ var FECManager = class _FECManager {
   #receiptNow() {
     return this.#receiptAtMs ?? performance.now();
   }
+  /**
+   * The whole-ms delay of a timer for `deadlineMs` armed inside a receipt
+   * scope: counted from the receipt time, as the timer of a symbol fed when
+   * it was received was, less the whole ms since. So it fires on the tick
+   * that timer would have, never later than a delay counted from now, and
+   * its handler still re-arms a timer that fires before its deadline.
+   * Counted from now, a deadline set from the receipt time is rounded up
+   * from another fraction of a ms (BLO-52085).
+   */
+  #receiptTimerDelayMs(deadlineMs, minMs) {
+    const receivedAtMs = this.#receiptAtMs;
+    return Math.max(minMs, Math.ceil(deadlineMs - receivedAtMs) - Math.ceil(performance.now() - receivedAtMs));
+  }
   /**
    * A held packet admitted late arms from its (earlier) receipt time; that
    * never pulls in a deadline later activity already armed. Outside a
@@ -17204,10 +17523,20 @@ var FECManager = class _FECManager {
         this.#repairDeadlineMs(trackConfig)
       );
     }
-    this.#armBlockTimeout(sbn, packetId, catalogTrackName, timeoutMs);
+    if (!sourceProgress && this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) !== void 0) {
+      this.#shortenUnrecoverableWait(key, sbn, packetId, catalogTrackName);
+      return;
+    }
+    this.#armBlockTimeout(
+      sbn,
+      packetId,
+      catalogTrackName,
+      this.#lateSourceWaitMs(key, sbn, packetId, catalogTrackName, trackConfig) ?? timeoutMs
+    );
   }
   #failBlock(sbn, packetId, catalogTrackName) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
+    const span = this.#isoSpanKeys.delete(key) ? { length: this.#blockAuthoredLengths.get(key) ?? 0, sources: this.#blockSourceCounts.get(key) ?? 0 } : void 0;
     this.#traceLifecycle("failed", sbn, packetId, catalogTrackName);
     this.#clearRepairDeadline(key);
     this.#clearBlockTimer(key);
@@ -17217,6 +17546,7 @@ var FECManager = class _FECManager {
     }
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -17226,7 +17556,8 @@ var FECManager = class _FECManager {
     this.#markPathBlockComplete(sbn, packetId, catalogTrackName);
     this.#fecStats.blocksFailed++;
     this.#statsForPacket(packetId).blocksFailed++;
-    this.onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+    if (span === void 0) this.onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass);
+    else this.onBlockFailed?.(sbn, packetId, catalogTrackName, blockClass, span);
     this.onBlockResolved?.(sbn, packetId, catalogTrackName);
   }
   /**
@@ -17255,7 +17586,9 @@ var FECManager = class _FECManager {
     this.#retireBlockClass(key, block.sbn, block.packetId, block.catalogTrackName);
     this.#blockSourceCounts.delete(key);
     this.#blockSourceEsis.delete(key);
+    this.#blockRebuiltEsis.delete(key);
     this.#blockAuthoredLengths.delete(key);
+    this.#isoSpanKeys.delete(key);
     this.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
     this.#clearBlockTimer(key);
@@ -17346,7 +17679,9 @@ var FECManager = class _FECManager {
     this.#blockKeysBySbn.clear();
     this.#blockSourceCounts.clear();
     this.#blockSourceEsis.clear();
+    this.#blockRebuiltEsis.clear();
     this.#blockAuthoredLengths.clear();
+    this.#isoSpanKeys.clear();
     this.#blockRepairRsIds.clear();
     this.#blockRsbLengths.clear();
     this.#heldLayerStates.clear();
@@ -18248,6 +18583,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;
@@ -18310,6 +18648,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");
@@ -18336,6 +18675,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);
   }
@@ -18371,6 +18711,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) {
@@ -18462,16 +18837,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();
@@ -18485,9 +18876,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,
@@ -18496,7 +18888,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");
@@ -18504,22 +18897,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 at2 = -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 (at2 < 0) at2 = i;
+      } else if (frame.passed !== true) break;
+    }
+    if (at2 < 0) return false;
+    return asUnanchored || !stream.sourced || this.#gate.releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at2 && 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"]);
@@ -18780,11 +19207,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
   /**
    * Typed view of the ISO-BMFF timing-sample budget.
    *
-   * This is the acceptance signal for the budget ratchet: `pending` walking
-   * to `capacity` while `rejectedMovieFragments` climbs is the stream wedging,
-   * and it is observable here rather than only as media silently stopping.
-   * Per repo policy this is a producer-owned counter -- never infer budget
-   * state by parsing logs.
+   * Each stream admits timing against its own window of `capacity` slots
+   * (BLO-52085). A stream at capacity displaces its own oldest timing to
+   * admit the moof in hand, and `evicted` counts the slots so displaced:
+   * timing a stream declared and never delivered shows up there. `pending`
+   * sums every stream, so it can exceed `capacity`. Per repo policy this is
+   * a producer-owned counter -- never infer budget state by parsing logs.
    */
   get timingBudgetStats() {
     return {
@@ -18844,6 +19272,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;
@@ -19097,7 +19533,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
       if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
-      const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
+      const remaining = this.#maxPendingTimingSamples - resolver2.pendingSampleCount;
       const admitted = resolver2.addMovieFragment(
         mpu.mpuSequenceNumber,
         data,
@@ -19170,7 +19606,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);
       }
@@ -19263,7 +19700,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);
@@ -19283,7 +19721,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,
@@ -19300,6 +19738,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,
@@ -22805,7 +23244,18 @@ function keyframeOverlaySsId(header) {
   if (ext?.type !== KEYFRAME_OVERLAY_EXTENSION_TYPE || ext.data.length !== 4) return void 0;
   return new DataView(ext.data.buffer, ext.data.byteOffset, 4).getUint32(0);
 }
+function overlayBaseSsId(anchor, overlaySsId, restoredPsn, headerPsn) {
+  if (anchor.baseSsId === void 0 || headerPsn !== restoredPsn) return void 0;
+  return serial32Add(anchor.baseSsId, overlaySsId - anchor.overlaySsId | 0);
+}
+function unstampedBaseSsId(offset, unstampedOffset, headerPsn) {
+  if (offset === void 0 || offset !== unstampedOffset) return void 0;
+  return headerPsn + offset >>> 0;
+}
+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) {
@@ -22916,6 +23366,7 @@ var MmtpRouter = class {
   #provenance = /* @__PURE__ */ new Map();
   #onFlowProtected = null;
   #unadmittedListedDrops = 0;
+  #admittedSourceDatagrams = 0;
   #unlistedRepairSetAside = 0;
   #assistBlocks = /* @__PURE__ */ new Map();
   #assistFailures = /* @__PURE__ */ new Map();
@@ -22972,6 +23423,26 @@ var MmtpRouter = class {
    * sequence is its SS_ID minus this; see #routeProcessedFecSymbols.
    */
   #ssIdSeqOffsetByStream = /* @__PURE__ */ new Map();
+  /**
+   * Per stream, the SS_ID offset at which a base recovery last showed the
+   * sender's own packet_sequence_number: a recovered packet's header psn
+   * equal to its SS_ID minus that offset. While it equals the stream's
+   * current offset, no hop re-stamps the stream, and a packet's protected psn
+   * names its base SS_ID within unstampedBaseSsId's limits (joint decoding of
+   * 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
@@ -23041,7 +23512,9 @@ var MmtpRouter = class {
     recovered: 0,
     restarts: 0,
     unsequencedDropped: 0,
-    protectedDropped: 0
+    protectedDropped: 0,
+    baseFed: 0,
+    baseUndetermined: 0
   };
   /** Callback fired when a delta-track FEC block completes or fails. */
   #onDeltaBlockCompleteCb = null;
@@ -23214,7 +23687,7 @@ var MmtpRouter = class {
     const cb = this.#getFrameCallback(packetId);
     if (isVideo && !assembler) {
       if (frameMeta.recovered) {
-        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb);
+        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb, meta.fecSbn);
       } else {
         this.#routeDirectSourceVideo(packetId, data, frameMeta, cb);
       }
@@ -23247,13 +23720,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);
+        }
       };
     }
   }
@@ -23298,8 +23776,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;
@@ -23478,6 +23957,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();
@@ -23628,7 +24108,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 () => {
@@ -23658,12 +24139,18 @@ var MmtpRouter = class {
    */
   resetKeyframeOverlays(sourcePacketId, catalogTrackName) {
     for (const inst of this.#overlaysForSource(sourcePacketId, catalogTrackName)) this.#resetOverlay(inst);
+    for (const [name, stream] of this.#streams.get(sourcePacketId) ?? []) {
+      if (catalogTrackName !== void 0 && name !== catalogTrackName) continue;
+      stream.overlayToBase.routed.clear();
+      stream.overlayToBase.pending.clear();
+    }
   }
   #resetOverlay(inst) {
     inst.fec.resetTrack(inst.repairPacketId, inst.streamName);
     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));
@@ -23714,18 +24201,33 @@ var MmtpRouter = class {
    * A source packet that carries a 0x8B01 overlay SS_ID is also a symbol of
    * every overlay installed for its source, at that SS_ID, with the bytes the
    * base protects: the packet minus its 4-byte SS_ID trailer, extension
-   * included (7.1, 7.4.3).
-   */
-  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source) {
+   * 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);
-        inst.offsets.set(identity.mpuSequenceNumber, ssId - sequenceNumber >>> 0);
+        inst.offsets.set(identity.mpuSequenceNumber, {
+          psnOffset: ssId - sequenceNumber >>> 0,
+          overlaySsId: ssId,
+          ...baseSsId === void 0 ? {} : { baseSsId }
+        });
         if (inst.offsets.size > OVERLAY_OFFSET_MPUS) inst.offsets.delete(inst.offsets.keys().next().value);
       }
       const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -23747,6 +24249,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);
@@ -23780,11 +24290,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;
@@ -23804,22 +24319,139 @@ var MmtpRouter = class {
     const streamKey = this.#mediaStreamKey(sourcePacketId, sourceName);
     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 offset = inst.offsets.get(sym.fragment.mpuSequenceNumber);
-      if (offset !== void 0) {
-        const packetSequenceNumber = serial32Add(blockStart, sym.index) - offset >>> 0;
+      const overlaySsId = serial32Add(blockStart, sym.index);
+      const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
+      if (anchor !== void 0) {
+        const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
         restored.add(packetSequenceNumber);
-        return [{ ...sym, packetSequenceNumber }];
+        const out = { ...sym, packetSequenceNumber };
+        const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
+        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 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];
       }
-      if (!restamped) 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, 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 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.
+   * A base block no repair has stated yet takes it when one does
+   * (#feedPendingRebuilt).
+   *
+   * The overlay route already handled each packet fed (delivered it, or
+   * held an untimed head for its FT=1), so a base recovery routes none of
+   * them again (#routeVerifiedFecSymbols): a second recovered copy of a
+   * held head would wait in the parser for timing its first copy consumed.
+   * Only an overlay block decoded from multicast symbols alone is fed: with
+   * a MoQ symbol in it, the base block's recovery would depend on bytes
+   * that crossed no multicast socket, which the provenance counted from the
+   * block's own arrivals cannot show.
+   */
+  #feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds) {
+    const fec = this.#fecManager;
+    const owner = inst.leg.sourcePacketId;
+    const name = inst.leg.sourceCatalogTrackName;
+    if (!fec?.feedRebuiltSourceSymbol || inst.moqBlocks.has(blockStart)) return;
+    if (this.#classifyPacketId(owner) === null || fec.isTrackConfigured?.(owner) === false) return;
+    const { duplicates, overlayToBase: { routed } } = this.#stream(owner, name);
+    const feeds = [];
+    for (const sym of symbols) {
+      if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
+      const ssId = baseSsIds.get(sym.index);
+      if (ssId === void 0) {
+        this.#overlayStats.baseUndetermined++;
+        continue;
+      }
+      routed.delete(ssId);
+      routed.add(ssId);
+      if (routed.size > OVERLAY_ROUTED_LIMIT) routed.delete(routed.values().next().value);
+      feeds.push([ssId, sym.rawSymbol]);
+    }
+    for (const [ssId, symbolData] of feeds) {
+      if (this.#classifyPacketId(owner) === null) return;
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
+  }
+  /** Feed one rebuilt source to its base block, or keep it until a repair states that block. */
+  #feedRebuiltToBase(owner, name, ssId, symbolData) {
+    const fec = this.#fecManager;
+    if (!fec?.feedRebuiltSourceSymbol) return;
+    const coords = fec.locateIsoSource?.(owner, name, ssId);
+    if (coords == null) {
+      const pending = this.#stream(owner, name).overlayToBase.pending;
+      pending.delete(ssId);
+      pending.set(ssId, symbolData.slice());
+      if (pending.size > OVERLAY_PENDING_LIMIT) pending.delete(pending.keys().next().value);
+      return;
+    }
+    const fed = fec.feedRebuiltSourceSymbol(owner, ssId, symbolData, name);
+    if (!fed.taken) return;
+    this.#overlayStats.baseFed++;
+    if (fed.recovered === null) return;
+    const sbn = coords.sbn;
+    this.#routeRecoveredBlock(sbn, fed.recovered, owner, name, () => {
+      fec.cancelBlockTimeout(sbn, owner, name);
+      fec.countRecovery(owner, sbn, name);
+      fec.markBlockCompleted(sbn, owner, name);
+    });
+  }
+  /** A repair stated `block`: the rebuilt sources that waited for it join it now. */
+  #feedPendingRebuilt(owner, name, block) {
+    const pending = this.#streams.get(owner)?.get(name)?.overlayToBase.pending;
+    if (pending === void 0 || pending.size === 0) return;
+    for (const [ssId, symbolData] of [...pending]) {
+      if (this.#classifyPacketId(owner) === null) return;
+      if (serial32Distance(block.start, ssId) >= block.length) continue;
+      pending.delete(ssId);
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
   }
   /** fec-multicast-00 §6.6: report each base block whose RAP MFU fragments
    *  the overlay restored, when the keyframe's FT=0 and FT=1 are held too. A
@@ -23959,6 +24591,10 @@ var MmtpRouter = class {
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
+  /** Source datagrams (multicast or MoQ) a protected flow's bc-provenance v2 receiver released: admitted at once or held, then admitted by a record. Repair symbols and user-agent-admitted datagrams are not counted. Counted at release, before this router's own track checks: a released datagram those drop, which only a track change between hold and release can cause, still counts, so this is not a count of routed media. */
+  get admittedSourceDatagramCount() {
+    return this.#admittedSourceDatagrams;
+  }
   /** MoQ repair symbols of an unlisted track kept out of a governed FEC instance (7.2.7 step 2). */
   get unlistedRepairSetAsideCount() {
     return this.#unlistedRepairSetAside;
@@ -24445,6 +25081,8 @@ var MmtpRouter = class {
     )) return;
     fec.noteBlockActivity?.(blockStart, ownerPacketId, catalogTrackName);
     fec.noteRepairGroupLength?.(blockStart, ownerPacketId, repair.rsbLength, catalogTrackName);
+    this.#feedPendingRebuilt(ownerPacketId, catalogTrackName, placement.block);
+    if (this.#classifyPacketId(ownerPacketId) === null) return;
     const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
     const recovered = fec.feedRepairSymbol(
       ownerPacketId,
@@ -24495,7 +25133,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;
@@ -24582,6 +25220,8 @@ var MmtpRouter = class {
     this.#droppedPreSyncVideo.delete(streamKey);
     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);
@@ -24708,6 +25348,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
@@ -24758,6 +25404,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;
@@ -24840,7 +25489,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) {
@@ -24992,12 +25651,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);
       }
     }
   }
@@ -25075,6 +25738,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;
@@ -25216,6 +25887,7 @@ var MmtpRouter = class {
     const parsed = this.#parser.parsePacket(packet);
     if (!parsed) return;
     const info = parsed.info;
+    if (manifestAdmitted && !info.isRepair && ingress?.admittedBy !== USER_AGENT_VERIFIED) this.#admittedSourceDatagrams++;
     if (source === "multicast" && !manifestAdmitted) {
       this.#fecManager?.noteMulticastArrival?.(info.packetId, info.sequenceNumber);
     }
@@ -25497,7 +26169,8 @@ var MmtpRouter = class {
           parsed.header,
           info.sequenceNumber,
           info.rapFlag,
-          source
+          source,
+          fecPayloadId?.ssId
         );
       }
     }
@@ -25523,7 +26196,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);
@@ -25647,7 +26321,8 @@ var MmtpRouter = class {
     if (stream === void 0) {
       stream = {
         key: JSON.stringify([packetId, catalogTrackName ?? null]),
-        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId))
+        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId)),
+        overlayToBase: { routed: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Map() }
       };
       byName.set(catalogTrackName, stream);
     }
@@ -25762,8 +26437,16 @@ var MmtpRouter = class {
     this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
     this.#emitDirectVideo(packetId, data, meta, cb);
   }
-  #routeDirectRecoveredVideo(packetId, data, meta, cb) {
+  #routeDirectRecoveredVideo(packetId, data, meta, cb, fecSbn) {
     const streamKey = this.#mediaStreamKey(packetId, meta.catalogTrackName);
+    if (this.#isFecTrack(packetId)) {
+      const high = this.#deliveredVideoHighWaterByStream.get(streamKey);
+      if (fecSbn !== void 0 || high !== void 0 && authoredAdjacent(high, meta)) {
+        this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
+        this.#emitDirectVideo(packetId, data, meta, cb);
+        return;
+      }
+    }
     this.#enqueueDirectRecoveredVideo(packetId, data, meta);
     const lastSourceTs = this.#lastDirectSourceVideoTsByStream.get(streamKey);
     this.#drainDirectRecoveredVideo(
@@ -25917,6 +26600,13 @@ var MmtpRouter = class {
    * frames by epoch only if pre-protection input ever matters.
    */
   #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
+    const overlayRouted = ownerPacketId == null ? void 0 : this.#streams.get(ownerPacketId)?.get(catalogTrackName)?.overlayToBase.routed;
+    if (overlayRouted !== void 0 && overlayRouted.size > 0) {
+      result = {
+        ...result,
+        symbols: result.symbols.filter((sym) => !overlayRouted.has(this.#fecAnchorForRecovered(blockId, sym.index)))
+      };
+    }
     const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
     const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
     const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
@@ -25973,7 +26663,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) {
@@ -25981,7 +26676,10 @@ var MmtpRouter = class {
         ...result,
         symbols: result.symbols.map((sym) => {
           const wire = this.#fecAnchorForRecovered(blockId, sym.index) - ssIdSeqOffset >>> 0;
-          if (wire === sym.packetSequenceNumber) return sym;
+          if (wire === sym.packetSequenceNumber) {
+            this.#unstampedSsIdSeqOffsetByStream.set(streamKey, ssIdSeqOffset);
+            return sym;
+          }
           this.#restampedRecoveredSeqs++;
           this.#restampedStreams.add(streamKey);
           return { ...sym, packetSequenceNumber: wire };
@@ -27766,6 +28464,12 @@ function isNonNegativeSafeInteger(value) {
 function isSymbolCounts(value) {
   return isRecord(value) && hasExactKeys(value, ["multicast", "moq"]) && isNonNegativeSafeInteger(value["multicast"]) && isNonNegativeSafeInteger(value["moq"]);
 }
+function isSpanFailure(value) {
+  if (!isRecord(value) || !hasExactKeys(value, ["length", "sources"])) return false;
+  const length = value["length"];
+  const sources = value["sources"];
+  return Number.isSafeInteger(length) && length > 0 && isNonNegativeSafeInteger(sources) && sources < length;
+}
 function isNullableNonNegative(value) {
   return value === null || typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
@@ -27785,7 +28489,10 @@ function isRepairLifecycleEvent(value) {
     case "recovered":
       return hasExactKeys(value, ["version", "type", "block", "blockClass", "via", "symbols"]) && isRepairBlockIdentity(block) && BLOCK_CLASSES.has(value["blockClass"]) && (value["via"] === "inband" || value["via"] === "quic") && isSymbolCounts(value["symbols"]);
     case "failed":
-      return hasExactKeys(value, ["version", "type", "block", "blockClass", "symbols"]) && isRepairBlockIdentity(block) && BLOCK_CLASSES.has(value["blockClass"]) && isSymbolCounts(value["symbols"]);
+      return hasExactKeys(
+        value,
+        "span" in value ? ["version", "type", "block", "blockClass", "symbols", "span"] : ["version", "type", "block", "blockClass", "symbols"]
+      ) && isRepairBlockIdentity(block) && BLOCK_CLASSES.has(value["blockClass"]) && isSymbolCounts(value["symbols"]) && (!("span" in value) || isSpanFailure(value["span"]));
     case "repair-preempted":
     case "repair-deferred":
       return hasExactKeys(value, ["version", "type", "block"]) && isRepairBlockIdentity(block);
@@ -27994,6 +28701,8 @@ var MulticastManager = class {
   /** Live joinRepairEndpoints() releases → the repair owners they registered,
    *  re-applied after configureMultiTrack() clears catalog-derived owners. */
   #repairReleases = /* @__PURE__ */ new Map();
+  /** Protected repair flows owned by each live repair-endpoint release. */
+  #repairProvenanceFlows = /* @__PURE__ */ new Map();
   /** Each source's catalog keyframe overlay, from its `ok` binding. */
   #overlayBindings = /* @__PURE__ */ new Map();
   /** Installed overlay decoders (`setKeyframeOverlayDecoder`), by source. */
@@ -28051,7 +28760,7 @@ var MulticastManager = class {
       onPublisherRestart: (packetId, catalogTrackName) => {
         this.#resetStreamOutsideRouter(packetId, catalogTrackName);
       },
-      onBlockFailed: (sbn, packetId, catalogTrackName, blockClass) => {
+      onBlockFailed: (sbn, packetId, catalogTrackName, blockClass, span) => {
         const pathCount = this.#fec.blockPathCount(
           sbn,
           packetId,
@@ -28069,7 +28778,8 @@ var MulticastManager = class {
           symbols: {
             multicast: pathCount?.multicastSymbols ?? 0,
             moq: pathCount?.moqSymbols ?? 0
-          }
+          },
+          ...span === void 0 ? {} : { span }
         });
       },
       onFrameGap: (decision) => {
@@ -28659,6 +29369,9 @@ var MulticastManager = class {
     this.#transport.onFailback((reason) => {
       const joined = this.#provenanceJoin;
       if (joined !== null) this.#router.unprotectProvenanceFlow(joined.flow);
+      for (const flows of this.#repairProvenanceFlows.values()) {
+        for (const flow of flows) this.#router.unprotectProvenanceFlow(flow);
+      }
       this.#onFailback?.(reason);
     });
   }
@@ -28693,6 +29406,12 @@ var MulticastManager = class {
         "[MulticastManager] join: provenance flow (S, G, port) must match sourceAddress ?? senderAddress, groupAddress and port"
       );
     }
+    if (provenanceFlow !== void 0) {
+      const flow = multicastProvenanceFlowKey(provenanceFlow);
+      if ([...this.#repairProvenanceFlows.values()].some((flows) => flows.includes(flow))) {
+        throw new TypeError(`[MulticastManager] join: provenance flow already registered by a repair endpoint: ${flow}`);
+      }
+    }
     const staged = this.#renditionSwitch;
     if (staged !== null) this.#endRenditionSwitch(staged, { reason: "superseded" }, false);
     this.configureFec(config);
@@ -28700,8 +29419,8 @@ var MulticastManager = class {
     const selectedPacketIds = config.packetIds?.length ? new Set(config.packetIds) : null;
     const catalogTracks = config.tracks?.filter(({ packetId }) => selectedPacketIds === null || selectedPacketIds.has(packetId));
     const ingressTracks = catalogTracks ? catalogTracks : selectedPacketIds === null ? void 0 : [...selectedPacketIds].map((packetId) => ({ name: "", packetId }));
-    this.#releaseProvenanceJoin();
     const provenance = config.provenance;
+    this.#releaseProvenanceJoin();
     const protectedTracks = ingressTracks ?? provenance?.flow.tracks;
     const ingress = protectedTracks === void 0 ? void 0 : {
       tracks: Object.freeze(
@@ -28754,8 +29473,13 @@ var MulticastManager = class {
    * feeds the flow's receiver; media datagrams are held until one admits them.
    */
   #joinProvenance(provenance, ingress) {
+    this.#router.registerProvenanceFlow(ingress, this.#provenanceReceiver(provenance));
+    this.#hookFailback();
+    this.#provenanceJoin = { flow: ingress.flow };
+  }
+  #provenanceReceiver(provenance) {
     const { flow, auth } = provenance;
-    const receiver = new BcProvenanceV2Receiver({
+    return new BcProvenanceV2Receiver({
       ...provenance.receiver,
       // The caller's ctx when it passes one, else the catalog's: an explicit
       // `catalogCtx: undefined` must not switch off the 7.2.4 ctx check.
@@ -28772,9 +29496,6 @@ var MulticastManager = class {
       maxAuthDelayMs: flow.maxAuthDelayMs,
       manifestTimerMs: flow.manifestTimerMs
     });
-    this.#router.registerProvenanceFlow(ingress, receiver);
-    this.#hookFailback();
-    this.#provenanceJoin = { flow: ingress.flow };
   }
   /** Un-protect: drop the flow's hold queues (no expiry counted). */
   #releaseProvenanceJoin() {
@@ -28805,8 +29526,25 @@ var MulticastManager = class {
    * callback delivers must come from a subscription opened on
    * `options.gateway`. A callback that also merges another source (a MoQ or
    * WebSocket repair feed) must not name a native provider here.
+   *
+   * An endpoint's `provenance` makes its group a protected flow of its own
+   * (multicast-02 7.2.7), registered here and released with the group; its
+   * records ride in band on the group's port. On the user-agent path a
+   * flow-less repair group of a protected track is set aside, never read, so
+   * a player joining a protected catalog's repair groups passes it.
    */
   joinRepairEndpoints(endpoints, provider, options) {
+    for (const { provenance, flow, source, group, port: port2 } of endpoints) {
+      if (provenance === void 0) continue;
+      if (flow !== void 0) {
+        throw new TypeError("[MulticastManager] joinRepairEndpoints: an endpoint names provenance or flow, never both");
+      }
+      if (!sameIpAddress(source, provenance.flow.source) || !sameIpAddress(group, provenance.flow.groupAddress) || port2 !== provenance.flow.port) {
+        throw new RangeError(
+          "[MulticastManager] joinRepairEndpoints: provenance flow (S, G, port) must match the endpoint's source, group and port"
+        );
+      }
+    }
     const releases = [];
     let released = false;
     const safely = (each) => {
@@ -28816,17 +29554,36 @@ var MulticastManager = class {
         console.warn("[MulticastManager] repair group release failed", error);
       }
     };
+    const usedFlows = /* @__PURE__ */ new Set();
+    const preparedProvenance = endpoints.map((endpoint) => {
+      if (endpoint.provenance === void 0) return void 0;
+      const flow = multicastProvenanceFlowKey(endpoint.provenance.flow);
+      if (usedFlows.has(flow) || this.#provenanceJoin?.flow === flow || [...this.#repairProvenanceFlows.values()].some((flows) => flows.includes(flow))) {
+        throw new TypeError(`[MulticastManager] joinRepairEndpoints: provenance flow already registered: ${flow}`);
+      }
+      usedFlows.add(flow);
+      return { flow, receiver: this.#provenanceReceiver(endpoint.provenance) };
+    });
+    const provenanceFlows = [];
     const repairOwners = endpoints.flatMap((endpoint) => endpoint.repairOwners.map((owner) => owner.instance !== "keyframe" ? owner : {
       ...owner,
       ownerTrackName: endpoint.tracks.find((t) => t.packetId === owner.ownerPacketId)?.name,
       repairTrackName: endpoint.tracks.find((t) => t.packetId === owner.packetId)?.name
     }));
     this.#applyRepairOwners(repairOwners);
-    for (const endpoint of endpoints) {
+    for (const [index, endpoint] of endpoints.entries()) {
+      const flow = endpoint.provenance === void 0 ? endpoint.flow : multicastProvenanceFlowKey(endpoint.provenance.flow);
       const ingress = {
         tracks: Object.freeze(endpoint.tracks.map(({ name, packetId }) => Object.freeze({ name, packetId }))),
-        ...endpoint.flow === void 0 ? {} : { flow: endpoint.flow }
+        ...flow === void 0 ? {} : { flow }
       };
+      if (endpoint.provenance !== void 0) {
+        const prepared = preparedProvenance[index];
+        if (prepared === void 0) throw new Error("[MulticastManager] repair provenance preparation missing");
+        this.#router.registerProvenanceFlow(ingress, prepared.receiver);
+        provenanceFlows.push(prepared.flow);
+        releases.push(() => this.#router.releaseProvenanceFlow(flow));
+      }
       let sender;
       const feed = (packet, sourceAddress, ingressToFeed) => {
         if (released) return;
@@ -28856,7 +29613,7 @@ var MulticastManager = class {
         packetIds: endpoint.packetIds,
         tracks: endpoint.tracks.map(({ name, packetId }) => ({ name, packetId })),
         // A protected repair group's records ride in band on its port (7.2.3).
-        ...endpoint.flow === void 0 ? {} : { protected: true }
+        ...flow === void 0 ? {} : { protected: true }
       }, ingress).then((joined) => {
         if (!joined && !released) fail(transport.lastJoinOutcome);
       });
@@ -28865,9 +29622,12 @@ var MulticastManager = class {
       if (released) return;
       released = true;
       this.#repairReleases.delete(release);
+      this.#repairProvenanceFlows.delete(release);
       for (const each of releases.splice(0)) safely(each);
     };
     this.#repairReleases.set(release, repairOwners);
+    this.#repairProvenanceFlows.set(release, provenanceFlows);
+    if (provenanceFlows.length) this.#hookFailback();
     return release;
   }
   #applyRepairOwners(owners) {
@@ -29449,10 +30209,12 @@ var MulticastManager = class {
    * Register the range repair scheduler (draft-ramadan-moq-fec §7.5): from now
    * on an iso-ssbg1-v1 gap missing a source and every repair is kept as a
    * pending hole and reported here, and `closeIsoHoles` must be called for it
-   * once its range FETCH ends (or none is sent).
+   * once its range FETCH ends (or none is sent). `onExpired` is told of a
+   * pending hole the stream runs past the locator's horizon: returning true,
+   * the caller closes it (`closeIsoHoles`); otherwise it is discarded.
    */
-  onUndelimitedLoss(cb) {
-    this.#fec.setUndelimitedLossHandler(cb);
+  onUndelimitedLoss(cb, onExpired) {
+    this.#fec.setUndelimitedLossHandler(cb, onExpired ?? null);
   }
   /**
    * Report each stream whose FEC fails closed at runtime (fec-01 6.3.9), e.g.
@@ -29688,7 +30450,8 @@ var MulticastManager = class {
       "stream" in event ? { ...event, stream: Object.freeze({ ...event.stream }) } : {
         ...event,
         block: Object.freeze({ ...event.block }),
-        ..."symbols" in event ? { symbols: Object.freeze({ ...event.symbols }) } : {}
+        ..."symbols" in event ? { symbols: Object.freeze({ ...event.symbols }) } : {},
+        ..."span" in event && event.span !== void 0 ? { span: Object.freeze({ ...event.span }) } : {}
       }
     );
     if (this.#logRepairLifecycle) {
@@ -32360,6 +33123,7 @@ var RepairLayerSubscriptions = class {
 
 // src/repair-fetch.ts
 var MOQT_PRIORITY_MAX = 255;
+var WALK_LEAD_MS = 3;
 var SOURCE_MEDIA_PRIORITY_MAX = REPAIR_PRIORITY_MIN - 1;
 function isMoqtPriority(value) {
   return Number.isSafeInteger(value) && value >= 0 && value <= MOQT_PRIORITY_MAX;
@@ -32410,8 +33174,17 @@ function wireRepairFetch(mc, opts) {
     mc.noteRepairScheduling(type, entry.sbn, entry.packetId, entry.catalogTrackName);
   };
   const clearEntry = (entry) => {
-    if (entry.range) mc.closeIsoHoles(entry.packetId, entry.catalogTrackName, entry.sbn, entry.range.holeLength);
-    else clearRepair(entry.sbn, entry.packetId, entry.catalogTrackName);
+    const { range } = entry;
+    if (range) {
+      atReport(range, () => mc.closeIsoHoles(entry.packetId, entry.catalogTrackName, entry.sbn, range.holeLength));
+    } else {
+      clearRepair(entry.sbn, entry.packetId, entry.catalogTrackName);
+    }
+  };
+  const atReport = (range, work) => {
+    const fec = mc.fecManager;
+    if (range.groups !== null || fec.withReceiptTime === void 0) work();
+    else fec.withReceiptTime(range.reportedAt, work);
   };
   const releaseHold = (entry) => {
     if (entry.range) return;
@@ -32478,21 +33251,42 @@ function wireRepairFetch(mc, opts) {
   const admit = (entry, now) => {
     const budgetMs = entry.deadlineAt - now;
     const rttMs = readRtt();
-    const reason = !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName) ? "group-cannot-complete" : rttMs === null ? "rtt-unmeasured" : rttMs < budgetMs ? null : "rtt-exceeds-budget";
+    const reason = refusal(entry, now, rttMs);
     if (reason === null) return rttMs;
     skip(entry, reason, rttMs, budgetMs);
     return null;
   };
+  const refusal = (entry, now, rttMs) => !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName) ? "group-cannot-complete" : rttMs === null ? "rtt-unmeasured" : rttMs < entry.deadlineAt - now ? null : "rtt-exceeds-budget";
   const retire = (entry) => {
     if (entries.get(entry.key) === entry) entries.delete(entry.key);
     if (entry.expiry !== void 0) clearTimeout(entry.expiry);
   };
-  const outstandingBelow = (priority) => {
+  const holdsBack = (entry, priority, videoWalks = true) => {
+    if (entry.priority >= priority) return false;
+    const { walk } = entry;
+    if (walk === void 0) return true;
+    if (entry.priority !== 0 || !videoWalks) return false;
+    return entry.running === null || walk.group !== null && !walk.group.controller.signal.aborted;
+  };
+  const outstandingBelow = (priority, videoWalks = true) => {
     for (const entry of entries.values()) {
-      if (entry.priority < priority) return true;
+      if (holdsBack(entry, priority, videoWalks)) return true;
     }
     return false;
   };
+  const yieldVideoWalks = (queued) => {
+    const now = performance.now();
+    const rttMs = readRtt();
+    const due = queued.some((entry) => entry.priority !== 0 && entry.walk === void 0 && !outstandingBelow(entry.priority, false) && refusal(entry, now, rttMs) === null);
+    if (!due) return;
+    for (const entry of entries.values()) {
+      const walk = entry.walk;
+      if (entry.priority !== 0 || walk === void 0 || walk.group === null) continue;
+      if (walk.group.controller.signal.aborted) continue;
+      walk.yielded = true;
+      walk.group.controller.abort();
+    }
+  };
   const preemptBestEffort = () => {
     for (const entry of entries.values()) {
       if (entry.priority === 0 || !entry.running) continue;
@@ -32521,7 +33315,8 @@ function wireRepairFetch(mc, opts) {
     }
     const rttMs = admit(entry, now);
     if (rttMs === null) return;
-    if (entry.priority === 0) preemptBestEffort();
+    if (entry.priority === 0 && entry.walk === void 0) preemptBestEffort();
+    if (entry.range === void 0) leaveWalkedGroup(entry);
     if (counted) entry.attempts++;
     mc.noteRepairFetchSent?.(entry.priority, entry.sbn, entry.packetId, entry.catalogTrackName, {
       rttMs,
@@ -32543,6 +33338,14 @@ function wireRepairFetch(mc, opts) {
     }
     void execute(entry, run);
   };
+  const leaveWalkedGroup = (block) => {
+    for (const entry of entries.values()) {
+      const group = entry.walk?.group;
+      if (group?.sbn === block.sbn && entry.packetId === block.packetId && entry.catalogTrackName === block.catalogTrackName) {
+        group.controller.abort();
+      }
+    }
+  };
   const dispatch = () => {
     if (disposed) return;
     const now = performance.now();
@@ -32567,6 +33370,7 @@ function wireRepairFetch(mc, opts) {
     for (const entry of queued) {
       if (entry.priority === 0) start(entry);
     }
+    yieldVideoWalks(queued);
     if (outstandingBelow(1)) return;
     for (const entry of queued) {
       if (entry.priority === 1) start(entry);
@@ -32593,6 +33397,16 @@ function wireRepairFetch(mc, opts) {
     }
     return counts.sources + counts.repairGroupLength >= counts.authoredLength;
   };
+  const groupServed = (sbn, packetId, catalogTrackName) => {
+    if (mc.fecManager.blockSymbolCounts === void 0) return false;
+    const counts = symbolCounts(sbn, packetId, catalogTrackName);
+    if (counts === void 0 || counts.authoredLength === void 0) return true;
+    return counts.sources + counts.repairs >= counts.authoredLength || !groupCanComplete(sbn, packetId, catalogTrackName);
+  };
+  const statedEnd = (sbn, packetId, catalogTrackName) => {
+    const length = symbolCounts(sbn, packetId, catalogTrackName)?.authoredLength;
+    return length === void 0 ? void 0 : serial32Add(sbn, length);
+  };
   const finish = (entry, run, fed, error) => {
     if (run.stopped !== null || entry.running !== run || entries.get(entry.key) !== entry) {
       return;
@@ -32637,27 +33451,81 @@ function wireRepairFetch(mc, opts) {
       signal: run.controller.signal,
       subscriberPriority: entry.subscriberPriority
     };
+    const { range } = entry;
+    const feed = (packet) => {
+      if (entry.catalogTrackName === void 0) {
+        mc.processRepairFromMoQ(packet, entry.packetId);
+      } else {
+        mc.processRepairFromMoQ(packet, entry.packetId, entry.catalogTrackName);
+      }
+    };
     try {
-      const packets = entry.range ? opts.rangeTransport({
+      const packets = range === void 0 ? opts.transport({ ...common, sbn: entry.sbn }) : entry.walk !== void 0 ? walkHole(entry, entry.walk, range, common) : opts.rangeTransport({
         ...common,
-        startGroup: entry.range.startGroup,
-        endGroup: entry.range.endGroup,
-        lostSsId: entry.range.lostSsId
-      }) : opts.transport({ ...common, sbn: entry.sbn });
+        startGroup: range.groups.startGroup,
+        endGroup: range.groups.endGroup,
+        lostSsId: range.lostSsId
+      });
       for await (const packet of packets) {
         if (run.stopped !== null || entry.running !== run) break;
         fed++;
-        if (entry.catalogTrackName === void 0) {
-          mc.processRepairFromMoQ(packet, entry.packetId);
-        } else {
-          mc.processRepairFromMoQ(packet, entry.packetId, entry.catalogTrackName);
-        }
+        if (range === void 0) feed(packet);
+        else atReport(range, () => feed(packet));
       }
       finish(entry, run, fed, void 0);
     } catch (error) {
       finish(entry, run, fed, error ?? new Error("repair transport rejected"));
     }
   };
+  async function* walkHole(entry, walk, hole, common) {
+    const lostAt = serial32Distance(entry.sbn, hole.lostSsId);
+    for (let first = true; !common.signal.aborted; first = false) {
+      if (!first && entry.priority !== 0 && outstandingBelow(1)) {
+        stop(entry, "preempted");
+        note("repair-preempted", entry);
+        return;
+      }
+      if (!first && entry.priority === 0) {
+        dispatch();
+        if (common.signal.aborted) return;
+      }
+      const sbn = walk.next;
+      let next;
+      if (entries.get(requestKey(sbn, entry.packetId, entry.catalogTrackName))?.running == null) {
+        const rsIds = /* @__PURE__ */ new Set();
+        const group = new AbortController();
+        const cancel = () => group.abort();
+        common.signal.addEventListener("abort", cancel, { once: true });
+        walk.group = { sbn, controller: group };
+        try {
+          for await (const packet of opts.transport({ ...common, sbn, signal: group.signal })) {
+            yield packet;
+            const id = extractRepairFecPayloadId(packet);
+            if (id === null || id.ssStart !== sbn || id.ssbLength === 0) continue;
+            next ??= serial32Add(sbn, id.ssbLength);
+            rsIds.add(id.rsId);
+            if (rsIds.size >= id.rsbLength || groupServed(sbn, entry.packetId, entry.catalogTrackName)) {
+              group.abort();
+              break;
+            }
+          }
+        } catch (error) {
+          if (!group.signal.aborted || common.signal.aborted) throw error;
+        } finally {
+          common.signal.removeEventListener("abort", cancel);
+          walk.group = null;
+        }
+        if (walk.yielded) {
+          walk.yielded = false;
+          continue;
+        }
+      }
+      next ??= statedEnd(sbn, entry.packetId, entry.catalogTrackName);
+      if (next === void 0) return;
+      if (serial32Distance(entry.sbn, next) > lostAt) return;
+      walk.next = next;
+    }
+  }
   const removeResetObserver = mc.addTrackResetObserver((packetId, catalogTrackName) => {
     for (const entry of [...entries.values()]) {
       if (entry.packetId !== packetId || entry.catalogTrackName !== catalogTrackName) continue;
@@ -32853,7 +33721,37 @@ function wireRepairFetch(mc, opts) {
       throw error;
     }
   };
-  if (opts.rangeTransport !== void 0) {
+  const trackKind = (packetId) => {
+    try {
+      return mc.fecManager.trackKindFor?.(packetId);
+    } catch {
+      return void 0;
+    }
+  };
+  const walkDeadlineAt = (packetId, now, deadlineAt) => {
+    let repairDeadlineMs;
+    try {
+      repairDeadlineMs = mc.fecManager.repairDeadlineMsForPacket?.(packetId);
+    } catch {
+      repairDeadlineMs = void 0;
+    }
+    if (repairDeadlineMs === void 0 || !Number.isFinite(repairDeadlineMs)) return deadlineAt;
+    return Math.min(deadlineAt, now + repairDeadlineMs - WALK_LEAD_MS);
+  };
+  const onHoleExpired = (hole) => {
+    if (disposed) return false;
+    const entry = [...entries.values()].find((candidate) => candidate.walk !== void 0 && candidate.packetId === hole.packetId && candidate.catalogTrackName === hole.catalogTrackName && serial32Distance(candidate.sbn, hole.holeStart) < candidate.range.holeLength);
+    if (entry === void 0) return false;
+    queueMicrotask(() => {
+      if (entries.get(entry.key) !== entry) return;
+      retire(entry);
+      stop(entry, "expired");
+      clearEntry(entry);
+      dispatch();
+    });
+    return true;
+  };
+  if (mc.onUndelimitedLoss !== void 0 && mc.closeIsoHoles !== void 0) {
     mc.onUndelimitedLoss((loss) => {
       const { packetId, catalogTrackName, holeStart, holeLength } = loss;
       const close = () => mc.closeIsoHoles(packetId, catalogTrackName, holeStart, holeLength);
@@ -32861,9 +33759,11 @@ function wireRepairFetch(mc, opts) {
       const blockProfile = blockProfileOf(packetId);
       const target = opts.resolveTarget(packetId, catalogTrackName);
       if (!target) return close();
-      const priority = repairPriorityForClass("unknown");
-      const range = rangeFor(loss, target.repairTrack);
-      if (range === null) {
+      const walked = opts.rangeTransport === void 0;
+      const holeClass = walked && trackKind(packetId) === "audio" ? "audio" : "unknown";
+      const priority = repairPriorityForClass(holeClass);
+      const groups = walked ? null : rangeFor(loss, target.repairTrack);
+      if (!walked && groups === null) {
         close();
         mc.noteRepairSkipped("range-no-anchor", { rttMs: readRtt(), budgetMs: 0, priority }, holeStart, packetId, catalogTrackName);
         return;
@@ -32874,8 +33774,10 @@ function wireRepairFetch(mc, opts) {
         packetId,
         ...catalogTrackName === void 0 ? {} : { catalogTrackName }
       };
-      const wire = wirePriority(identity, "unknown");
-      const deadline = presentationDeadlineAt(holeStart, packetId, catalogTrackName, performance.now(), "unknown");
+      const wire = wirePriority(identity, holeClass);
+      if (wire === null) return close();
+      const now = performance.now();
+      const deadline = presentationDeadlineAt(holeStart, packetId, catalogTrackName, now, holeClass);
       if (deadline === null) {
         close();
         mc.noteRepairSkipped(
@@ -32887,6 +33789,7 @@ function wireRepairFetch(mc, opts) {
         );
         return;
       }
+      const deadlineAt = walked ? walkDeadlineAt(packetId, now, deadline.deadlineAt) : deadline.deadlineAt;
       const entry = {
         key: JSON.stringify(["range", packetId, catalogTrackName ?? null, holeStart]),
         ...identity,
@@ -32894,15 +33797,16 @@ function wireRepairFetch(mc, opts) {
         blockProfile,
         priority,
         subscriberPriority: wire.subscriberPriority,
-        deadlineAt: deadline.deadlineAt,
-        playoutDeadlineAt: deadline.deadlineAt - deadline.extensionMs,
+        deadlineAt,
+        playoutDeadlineAt: deadlineAt - deadline.extensionMs,
         anchorAt: deadline.anchorAt,
         delayMs: deadline.delayMs,
         bound: deadline.bound,
         order: enqueueOrder++,
         attempts: 0,
         running: null,
-        range: { ...range, lostSsId: loss.lostSsId, holeLength }
+        range: { lostSsId: loss.lostSsId, holeLength, groups, reportedAt: now },
+        ...walked ? { walk: { next: holeStart, group: null, yielded: false } } : {}
       };
       const previous = entries.get(entry.key);
       if (previous) {
@@ -32912,7 +33816,7 @@ function wireRepairFetch(mc, opts) {
       entries.set(entry.key, entry);
       entry.expiry = setTimeout(dispatch, Math.max(0, entry.deadlineAt - performance.now()) + 1);
       dispatch();
-    });
+    }, onHoleExpired);
   }
   const removeRapObserver = mc.addRapCompleteObserver?.((packetId) => {
     queueMicrotask(() => {