@blockcast/mmt-container 2.1.0 → 2.2.0-main.050b52fb9b00

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
@@ -348,7 +357,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(
@@ -385,6 +398,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;
@@ -403,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) {
@@ -469,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
@@ -490,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 {
@@ -558,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));
   }
@@ -583,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);
@@ -603,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;
   }
@@ -614,9 +682,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 = [];
@@ -1081,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";
 }
@@ -1174,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
@@ -1186,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
@@ -1306,6 +1390,10 @@ var FECManager = class _FECManager {
     // ── Keyframe-protected repair policy (block-policy.ts) ──
     // One classifier per physical stream, built from that stream's geometry.
     this.#classifiers = /* @__PURE__ */ new Map();
+    // A stream without catalog timing has no classifier, so the last RAP it
+    // released stands in for one: "an MPU boundary bounds its RAPs" holds until
+    // a second RAP is released inside one MPU (BLO-52085).
+    this.#noSpanRaps = /* @__PURE__ */ new Map();
     // Geometry a stream-scoped configuration gave one stream (streamKey). ABR
     // rungs can share a packetId with a different framerate or GOP, so the
     // packet-level geometry is only the geometry of a packet whose streams
@@ -1379,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.
@@ -1421,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). */
@@ -1463,7 +1556,9 @@ var FECManager = class _FECManager {
   #pendingWorkerCleanupBounds;
   #blockSourceCounts;
   #blockSourceEsis;
+  #blockRebuiltEsis;
   #blockAuthoredLengths;
+  #isoSpanKeys;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
   #blockRsbLengths;
@@ -1505,6 +1600,7 @@ var FECManager = class _FECManager {
   #orderedFrontiers;
   #orderedPendingBlocks;
   #classifiers;
+  #noSpanRaps;
   #streamGeometries;
   #failedBlocks;
   #resolvedBlockClasses;
@@ -1529,6 +1625,7 @@ var FECManager = class _FECManager {
   #decoderUnavailableEvents;
   #repairSymbolSizeMismatchCount;
   #onUndelimitedLoss;
+  #onIsoHoleExpired;
   #encodeTrackName(catalogTrackName) {
     let encoded = this.#encodedTrackNames.get(catalogTrackName);
     if (encoded === void 0) {
@@ -2000,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) {
@@ -2144,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);
@@ -2166,6 +2272,7 @@ var FECManager = class _FECManager {
     };
     const discontinuity = () => {
       this.#classifiers.get(streamKey)?.noteSourceDiscontinuity();
+      this.#noSpanRaps.delete(streamKey);
       this.#highestSbn.set(streamKey, { sbn, atMs: now });
       this.#sourceFrontiers.set(streamKey, { sbn, atMs: now });
       if (psn === void 0) this.#sourceAnchors.delete(streamKey);
@@ -2183,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;
       }
@@ -2445,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);
@@ -2471,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;
@@ -2578,6 +2689,9 @@ var FECManager = class _FECManager {
     }
     if (policyChanged) {
       this.#bumpEpoch(packetId);
+      for (const key of [...this.#noSpanRaps.keys()]) {
+        if (this.#belongsToPacket(key, packetId)) this.#noSpanRaps.delete(key);
+      }
       for (const [key, classifier] of [...this.#classifiers]) {
         if (!this.#belongsToPacket(key, packetId)) continue;
         const stream = this.#parseStreamKey(key);
@@ -2780,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);
@@ -2813,6 +2929,7 @@ var FECManager = class _FECManager {
     resetMap(this.#isoLocators);
     resetMap(this.#sourceAnchors);
     this.#classifiers.delete(this.#streamKey(packetId, catalogTrackName));
+    this.#noSpanRaps.delete(this.#streamKey(packetId, catalogTrackName));
     this.#bumpEpoch(packetId);
     for (const [sbn, keys] of this.#blockKeysBySbn) {
       for (const key of keys.keys()) {
@@ -2903,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);
@@ -2919,6 +3038,7 @@ var FECManager = class _FECManager {
     dropMap(this.#isoLocators);
     dropMap(this.#sourceAnchors);
     dropMap(this.#classifiers);
+    dropMap(this.#noSpanRaps);
     dropMap(this.#streamGeometries);
     dropSet(this.#pendingWorkerCleanups);
     dropSet(this.#completedBlocks);
@@ -3064,6 +3184,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) {
@@ -3242,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);
@@ -3381,6 +3505,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;
@@ -3401,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 = {
@@ -3432,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));
@@ -3461,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);
   }
   /**
@@ -3549,11 +3693,14 @@ var FECManager = class _FECManager {
   /**
    * Whether an MPU boundary still bounds this stream's RAPs (see
    * `BlockClassifier.mpuBoundsRaps`). Gap decisions drop MPU evidence once
-   * it does not. A stream with no classifier yet has shown nothing against it.
+   * it does not. A stream with no classifier yet has shown nothing against it,
+   * and neither has a stream without catalog timing until it releases two
+   * RAPs inside one MPU.
    */
   mpuBoundsRapsFor(packetId, catalogTrackName) {
-    if (!this.#hasCatalogTimingForPacket(packetId)) return false;
-    return this.#classifiers.get(this.#streamKey(packetId, catalogTrackName))?.mpuBoundsRaps ?? true;
+    const streamKey = this.#streamKey(packetId, catalogTrackName);
+    if (!this.#hasCatalogTimingForPacket(packetId)) return this.#noSpanRaps.get(streamKey)?.inside !== true;
+    return this.#classifiers.get(streamKey)?.mpuBoundsRaps ?? true;
   }
   /** A block's class now, or frozen at its resolution. */
   blockClassFor(sbn, packetId, catalogTrackName) {
@@ -3579,7 +3726,14 @@ var FECManager = class _FECManager {
    * invariant (consecutive MPUs exactly one keyframe interval apart).
    */
   noteReleasedRap(packetId, catalogTrackName, mpu, presentationTime, mediaTimescale) {
-    if (!this.#trackConfigs.has(packetId) || !this.#hasCatalogTimingForPacket(packetId)) return;
+    if (!this.#trackConfigs.has(packetId)) return;
+    if (!this.#hasCatalogTimingForPacket(packetId)) {
+      const streamKey = this.#streamKey(packetId, catalogTrackName);
+      const last = this.#noSpanRaps.get(streamKey);
+      const inside = last?.inside === true || last?.mpu === mpu && last.presentationTime !== presentationTime;
+      this.#noSpanRaps.set(streamKey, { mpu, presentationTime, inside });
+      return;
+    }
     this.#applyClassifierChanges(
       packetId,
       catalogTrackName,
@@ -3792,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;
@@ -3866,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);
@@ -3966,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);
@@ -3995,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
@@ -4197,8 +4432,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
@@ -4296,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(
@@ -4317,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) {
@@ -4353,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) {
@@ -4361,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);
@@ -4392,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
@@ -4427,10 +4755,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);
@@ -4440,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);
@@ -4449,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);
   }
   /**
@@ -4478,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);
@@ -4569,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();
@@ -4594,6 +4938,7 @@ var FECManager = class _FECManager {
     this.#blockAnchorsMs.clear();
     this.#blockCatalogTrackNames.clear();
     this.#classifiers.clear();
+    this.#noSpanRaps.clear();
     this.#streamGeometries.clear();
     this.#failedBlocks.clear();
     this.#resolvedBlockClasses.clear();