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

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;
@@ -1192,6 +1247,10 @@ 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();
@@ -1208,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
@@ -1405,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.
@@ -1447,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). */
@@ -1491,6 +1558,7 @@ var FECManager = class _FECManager {
   #blockSourceEsis;
   #blockRebuiltEsis;
   #blockAuthoredLengths;
+  #isoSpanKeys;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
   #blockRsbLengths;
@@ -1557,6 +1625,7 @@ var FECManager = class _FECManager {
   #decoderUnavailableEvents;
   #repairSymbolSizeMismatchCount;
   #onUndelimitedLoss;
+  #onIsoHoleExpired;
   #encodeTrackName(catalogTrackName) {
     let encoded = this.#encodedTrackNames.get(catalogTrackName);
     if (encoded === void 0) {
@@ -2028,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) {
@@ -2172,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);
@@ -2212,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;
       }
@@ -2474,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);
@@ -2500,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;
@@ -2814,6 +2896,7 @@ var FECManager = class _FECManager {
     resetMap(this.#blockSourceEsis);
     resetMap(this.#blockRebuiltEsis);
     resetMap(this.#blockAuthoredLengths);
+    resetSet(this.#isoSpanKeys);
     resetMap(this.#blockRepairRsIds);
     resetMap(this.#blockRsbLengths);
     resetMap(this.#heldLayerStates);
@@ -2939,6 +3022,7 @@ var FECManager = class _FECManager {
     dropMap(this.#blockSourceEsis);
     dropMap(this.#blockRebuiltEsis);
     dropMap(this.#blockAuthoredLengths);
+    dropSet(this.#isoSpanKeys);
     dropMap(this.#blockRepairRsIds);
     dropMap(this.#blockRsbLengths);
     dropMap(this.#blockPathCounts);
@@ -3281,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);
@@ -3420,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) {
@@ -3441,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 = {
@@ -3472,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));
@@ -3501,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);
   }
   /**
@@ -3842,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;
@@ -3916,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);
@@ -4489,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(
@@ -4510,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) {
@@ -4565,6 +4676,7 @@ var FECManager = class _FECManager {
     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);
@@ -4595,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
@@ -4643,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);
@@ -4662,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);
   }
   /**
@@ -4693,6 +4820,7 @@ var FECManager = class _FECManager {
     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);
@@ -4785,6 +4913,7 @@ var FECManager = class _FECManager {
     this.#blockSourceEsis.clear();
     this.#blockRebuiltEsis.clear();
     this.#blockAuthoredLengths.clear();
+    this.#isoSpanKeys.clear();
     this.#blockRepairRsIds.clear();
     this.#blockRsbLengths.clear();
     this.#heldLayerStates.clear();