@blockcast/mmt-container 2.2.0-main.f480a7ede8b1 → 2.2.0-main.fb5c7dfbe2de

package/dist/fec-manager.js

@@ -327,6 +327,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
@@ -350,6 +359,9 @@ var IsoBlockLocator = class _IsoBlockLocator {
   #newest;
   #newestSource;
   #holes;
+  #expired;
+  #newlyExpired;
+  #closedBehind;
   static #checkedRetention(retentionBlocks) {
     if (!Number.isSafeInteger(retentionBlocks) || retentionBlocks <= 0) {
       throw new Error(
@@ -419,17 +431,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) {
@@ -485,9 +509,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
@@ -506,7 +532,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 {
@@ -574,18 +609,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));
   }
@@ -599,15 +644,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);
@@ -619,10 +666,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;
   }
@@ -630,6 +682,9 @@ 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;
@@ -1098,6 +1153,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";
 }
@@ -1191,10 +1247,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
@@ -1203,6 +1267,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
@@ -1400,7 +1467,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.
@@ -1442,6 +1512,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). */
@@ -1484,7 +1556,9 @@ var FECManager = class _FECManager {
   #pendingWorkerCleanupBounds;
   #blockSourceCounts;
   #blockSourceEsis;
+  #blockRebuiltEsis;
   #blockAuthoredLengths;
+  #isoSpanKeys;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
   #blockRsbLengths;
@@ -1551,6 +1625,7 @@ var FECManager = class _FECManager {
   #decoderUnavailableEvents;
   #repairSymbolSizeMismatchCount;
   #onUndelimitedLoss;
+  #onIsoHoleExpired;
   #encodeTrackName(catalogTrackName) {
     let encoded = this.#encodedTrackNames.get(catalogTrackName);
     if (encoded === void 0) {
@@ -2022,7 +2097,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) {
@@ -2166,8 +2244,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);
@@ -2206,7 +2290,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" && window !== 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" && window !== 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;
       }
@@ -2468,17 +2552,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);
@@ -2494,7 +2582,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;
@@ -2806,7 +2894,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);
@@ -2930,7 +3020,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);
@@ -3273,8 +3365,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);
@@ -3412,6 +3505,7 @@ 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) {
@@ -3433,17 +3527,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 = {
@@ -3464,17 +3561,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));
@@ -3493,7 +3602,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);
   }
   /**
@@ -3834,11 +3946,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;
@@ -3908,9 +4023,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);
@@ -4008,7 +4125,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);
@@ -4037,6 +4162,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
@@ -4279,7 +4472,10 @@ var FECManager = class _FECManager {
     const authoredLength = this.#blockAuthoredLengths.get(key);
     const rsbLength = this.#blockRsbLengths.get(key);
     if (authoredLength === void 0 || rsbLength === void 0) return void 0;
-    if ((this.#blockSourceCounts.get(key) ?? 0) + rsbLength >= authoredLength) 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;
@@ -4402,12 +4598,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(
@@ -4423,7 +4620,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) {
@@ -4459,6 +4657,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) {
@@ -4467,7 +4674,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);
@@ -4498,6 +4707,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
@@ -4546,6 +4768,7 @@ var FECManager = class _FECManager {
   }
   #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);
@@ -4555,6 +4778,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);
@@ -4564,7 +4788,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);
   }
   /**
@@ -4593,7 +4818,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);
@@ -4684,7 +4911,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();