@blockcast/mmt-container 2.2.0-main.da2e7cd1dd5d → 2.2.0-main.e75bbd7576a6

package/dist/browser-runtime.js

@@ -8746,6 +8746,7 @@ var MOQT_PUBLISHER_PRIORITY = Object.freeze({
 });
 
 // node_modules/@blockcast/mmt-transport/dist/amt-gateway.js
+var MAX_PENDING_PACKETS = 256;
 var AMTGatewayManager = class {
   subscriptions = /* @__PURE__ */ new Map();
   messageHandler;
@@ -8869,7 +8870,7 @@ var AMTGatewayManager = class {
     if (!subscription.handshakeComplete) {
       const queue = this.pendingPackets.get(subscriptionId);
       const packetData2 = data;
-      if (queue) {
+      if (queue && queue.length < MAX_PENDING_PACKETS) {
         queue.push({
           data: packetData2.data,
           remoteAddress: packetData2.remoteAddress,
@@ -12948,6 +12949,7 @@ var IsoBlockLocator = class _IsoBlockLocator {
   #retentionBlocks;
   #heldEvicted;
   #newest;
+  #newestSource;
   #holes;
   static #checkedRetention(retentionBlocks) {
     if (!Number.isSafeInteger(retentionBlocks) || retentionBlocks <= 0) {
@@ -12985,6 +12987,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;
@@ -13217,6 +13234,7 @@ var IsoBlockLocator = class _IsoBlockLocator {
     this.#held.clear();
     this.#coverageEnd = void 0;
     this.#newest = void 0;
+    this.#newestSource = void 0;
   }
   #claim(block) {
     const placed = [];
@@ -13836,6 +13854,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";
 }
@@ -13933,6 +13952,10 @@ var FECManager = class _FECManager {
     // 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
@@ -14222,6 +14245,7 @@ var FECManager = class _FECManager {
   #pendingWorkerCleanupBounds;
   #blockSourceCounts;
   #blockSourceEsis;
+  #blockRebuiltEsis;
   #blockAuthoredLengths;
   #ssbLengthConflictCount;
   #blockRepairRsIds;
@@ -15544,6 +15568,7 @@ var FECManager = class _FECManager {
     }
     resetMap(this.#blockSourceCounts);
     resetMap(this.#blockSourceEsis);
+    resetMap(this.#blockRebuiltEsis);
     resetMap(this.#blockAuthoredLengths);
     resetMap(this.#blockRepairRsIds);
     resetMap(this.#blockRsbLengths);
@@ -15668,6 +15693,7 @@ var FECManager = class _FECManager {
     dropMap(this.#pendingWorkerCleanupClients);
     dropMap(this.#blockSourceCounts);
     dropMap(this.#blockSourceEsis);
+    dropMap(this.#blockRebuiltEsis);
     dropMap(this.#blockAuthoredLengths);
     dropMap(this.#blockRepairRsIds);
     dropMap(this.#blockRsbLengths);
@@ -15830,6 +15856,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) {
@@ -16147,6 +16176,7 @@ var FECManager = class _FECManager {
     const locator = this.#growingIsoLocatorFor(packetId, catalogTrackName);
     const evictedBefore = locator.heldEvicted;
     const held = locator.hold(ssId, source);
+    if (held && source.source === "multicast") this.#noteMulticastSource(locator, ssId, packetId, catalogTrackName);
     const evicted = locator.heldEvicted - evictedBefore;
     if (evicted > 0) {
       const before = this.#isoHeldEvictedCount;
@@ -16742,7 +16772,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);
@@ -16771,6 +16809,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
@@ -16973,8 +17079,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
@@ -17129,6 +17302,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) {
@@ -17137,6 +17319,7 @@ 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.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -17203,7 +17386,16 @@ 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);
@@ -17216,6 +17408,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);
@@ -17254,6 +17447,7 @@ 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.#blockRepairRsIds.delete(key);
     this.#blockRsbLengths.delete(key);
@@ -17345,6 +17539,7 @@ var FECManager = class _FECManager {
     this.#blockKeysBySbn.clear();
     this.#blockSourceCounts.clear();
     this.#blockSourceEsis.clear();
+    this.#blockRebuiltEsis.clear();
     this.#blockAuthoredLengths.clear();
     this.#blockRepairRsIds.clear();
     this.#blockRsbLengths.clear();
@@ -17901,9 +18096,21 @@ var IsoBmffTimingResolver = class {
   }
   #track = null;
   #fragments = /* @__PURE__ */ new Map();
+  /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+  #firstSamples = /* @__PURE__ */ new Map();
+  /**
+   * First sample and sample count of the newest fragments whose every slot was
+   * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+   * matches the combiner, since it retires an abandoned sample as well.
+   */
+  #delivered = /* @__PURE__ */ new Map();
   #pendingSamples = 0;
   #evictedSamples = 0;
   #lastMovieFragmentRejection = null;
+  /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+  get initialized() {
+    return this.#track !== null;
+  }
   get pendingSampleCount() {
     return this.#pendingSamples;
   }
@@ -17927,7 +18134,14 @@ var IsoBmffTimingResolver = class {
     this.#track = timing;
     return true;
   }
-  addMovieFragment(mpuSequenceNumber2, data, additionalSampleLimit = this.maxPendingSamples) {
+  /**
+   * `recovered` marks an FEC-recovered copy. A recovered block hands back
+   * every FT=1 it holds, the received ones included, so a recovered copy of a
+   * fragment whose samples are all done is a duplicate: admitting it again
+   * would charge stale timing and could displace the live MPU's. A source
+   * copy is still admitted again (a rendition switch re-arms timing that way).
+   */
+  addMovieFragment(mpuSequenceNumber2, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
     this.#lastMovieFragmentRejection = null;
     if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
       this.#lastMovieFragmentRejection = "invalid";
@@ -17953,6 +18167,8 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
+    const delivered = recovered ? this.#delivered.get(key) : void 0;
+    if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
     let freed = 0;
     while (this.#fragments.size > 0 && (this.#pendingSamples + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
       freed += this.#evictOldestFragment();
@@ -17966,6 +18182,7 @@ var IsoBmffTimingResolver = class {
       return false;
     }
     this.#fragments.set(key, [...parsed.samples]);
+    this.#firstSamples.set(key, parsed.samples[0]);
     this.#pendingSamples += parsed.samples.length;
     return true;
   }
@@ -18023,6 +18240,7 @@ var IsoBmffTimingResolver = class {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     this.#fragments.delete(oldest);
+    this.#firstSamples.delete(oldest);
     this.#pendingSamples -= live;
     this.#evictedSamples += live;
     return live;
@@ -18038,12 +18256,23 @@ var IsoBmffTimingResolver = class {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     this.#pendingSamples--;
-    if (samples.every((value) => value === null)) this.#fragments.delete(key);
+    if (samples.every((value) => value === null)) {
+      this.#fragments.delete(key);
+      const first = this.#firstSamples.get(key);
+      this.#firstSamples.delete(key);
+      this.#delivered.delete(key);
+      this.#delivered.set(key, { first, sampleCount: samples.length });
+      if (this.#delivered.size > this.maxPendingSamples) {
+        this.#delivered.delete(this.#delivered.keys().next().value);
+      }
+    }
     return true;
   }
   reset() {
     this.#track = null;
     this.#fragments.clear();
+    this.#firstSamples.clear();
+    this.#delivered.clear();
     this.#pendingSamples = 0;
   }
 };
@@ -18525,6 +18754,12 @@ var MmtpContainerParser = class _MmtpContainerParser {
     this.#reclaimedTimingSamples = 0;
     this.#evictedTimingSamples = 0;
     this.#rejectedMovieFragments = 0;
+    this.#recoveredHeadsAwaitingTiming = {
+      held: 0,
+      expired: 0,
+      discarded: 0,
+      superseded: 0
+    };
     this.#sequencers = /* @__PURE__ */ new Map();
     this.#fecGate = null;
     this.#fecSequencer = null;
@@ -18633,6 +18868,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
   #reclaimedTimingSamples;
   #evictedTimingSamples;
   #rejectedMovieFragments;
+  #recoveredHeadsAwaitingTiming;
   #sequencers;
   #fecGate;
   #fecSequencer;
@@ -18753,6 +18989,14 @@ var MmtpContainerParser = class _MmtpContainerParser {
       rejectedMovieFragments: this.#rejectedMovieFragments
     };
   }
+  /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+  get recoveredHeadsAwaitingTiming() {
+    let pending = 0;
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+    }
+    return { ...this.#recoveredHeadsAwaitingTiming, pending };
+  }
   get reorderStats() {
     let bufferedFrames = this.#fecSequencer?.buffered ?? 0;
     for (const { sequencer } of this.#sequencers.values()) bufferedFrames += sequencer.buffered;
@@ -18926,7 +19170,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const now = Date.now();
     for (const { awaitingTiming } of this.#timingStreams.values()) {
       while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-        awaitingTiming.shift();
+        this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
       }
     }
   }
@@ -19044,11 +19288,16 @@ var MmtpContainerParser = class _MmtpContainerParser {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return this.#drop("fragment-unexpected-fragmentation");
       const resolver2 = this.#timingResolver(streamKey, info.packetId, false);
-      if (!resolver2) return this.#drop("fragment-no-resolver");
+      if (!resolver2?.initialized) return this.#drop("fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
       const remaining = this.#maxPendingTimingSamples - this.#pendingTimingSamples;
-      const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       this.#pendingTimingSamples += resolver2.pendingSampleCount - pendingBefore;
       this.#evictedTimingSamples += resolver2.evictedSampleCount - evictedBefore;
       if (!admitted) {
@@ -19068,7 +19317,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
       };
     }
     if (fragmentType !== 2) return this.#drop("unknown-fragment-type");
-    const resolver = this.#timingResolver(streamKey, info.packetId, false);
+    const resolver = this.#timingResolver(streamKey, info.packetId, true);
     if (!resolver) return this.#drop("mfu-no-resolver");
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return this.#drop("mfu-empty-payload");
@@ -19089,6 +19338,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return this.#drop("mfu-sample-timing-missing");
@@ -19477,6 +19727,9 @@ var MmtpContainerParser = class _MmtpContainerParser {
     for (const { sequencer } of this.#sequencers.values()) sequencer.discard();
     this.#sequencers.clear();
     this.#fecSequencer?.discard();
+    for (const { awaitingTiming } of this.#timingStreams.values()) {
+      for (const head of awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
+    }
     this.#timingStreams.clear();
     this.#pendingTimingSamples = 0;
     this.#reliableMoqStartupGate.clear();
@@ -19495,10 +19748,23 @@ var MmtpContainerParser = class _MmtpContainerParser {
     return resolver;
   }
   #awaitTiming(streamKey, head) {
-    const awaitingTiming = this.#timingStreams.get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = this.#timingStreams.get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      this.#recoveredHeadsAwaitingTiming.superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming.held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      this.#leaveAwaitingTiming(awaitingTiming.shift(), "expired");
+    }
+  }
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  #leaveAwaitingTiming(head, outcome) {
+    if (head.options?.recovered) this.#recoveredHeadsAwaitingTiming[outcome]++;
   }
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -19526,6 +19792,7 @@ var MmtpContainerParser = class _MmtpContainerParser {
     const state = this.#timingStreams.get(streamKey);
     if (!state) return;
     this.#timingStreams.delete(streamKey);
+    for (const head of state.awaitingTiming) this.#leaveAwaitingTiming(head, "discarded");
     this.#pendingTimingSamples -= state.resolver.pendingSampleCount;
     if (this.#pendingTimingSamples < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");
@@ -22732,6 +22999,16 @@ function keyframeOverlaySsId(header) {
   if (ext?.type !== KEYFRAME_OVERLAY_EXTENSION_TYPE || ext.data.length !== 4) return void 0;
   return new DataView(ext.data.buffer, ext.data.byteOffset, 4).getUint32(0);
 }
+function overlayBaseSsId(anchor, overlaySsId, restoredPsn, headerPsn) {
+  if (anchor.baseSsId === void 0 || headerPsn !== restoredPsn) return void 0;
+  return serial32Add(anchor.baseSsId, overlaySsId - anchor.overlaySsId | 0);
+}
+function unstampedBaseSsId(offset, unstampedOffset, headerPsn) {
+  if (offset === void 0 || offset !== unstampedOffset) return void 0;
+  return headerPsn + offset >>> 0;
+}
+var OVERLAY_ROUTED_LIMIT = 1024;
+var OVERLAY_PENDING_LIMIT = 256;
 var OVERLAY_OFFSET_MPUS = 16;
 var OVERLAY_MOQ_HORIZON_BLOCKS = 64;
 function assertStreamIdentity(role, stream) {
@@ -22843,6 +23120,7 @@ var MmtpRouter = class {
   #provenance = /* @__PURE__ */ new Map();
   #onFlowProtected = null;
   #unadmittedListedDrops = 0;
+  #admittedSourceDatagrams = 0;
   #unlistedRepairSetAside = 0;
   #assistBlocks = /* @__PURE__ */ new Map();
   #assistFailures = /* @__PURE__ */ new Map();
@@ -22899,6 +23177,15 @@ var MmtpRouter = class {
    * sequence is its SS_ID minus this; see #routeProcessedFecSymbols.
    */
   #ssIdSeqOffsetByStream = /* @__PURE__ */ new Map();
+  /**
+   * Per stream, the SS_ID offset at which a base recovery last showed the
+   * sender's own packet_sequence_number: a recovered packet's header psn
+   * equal to its SS_ID minus that offset. While it equals the stream's
+   * current offset, no hop re-stamps the stream, and a packet's protected psn
+   * names its base SS_ID within unstampedBaseSsId's limits (joint decoding of
+   * an MPU no member of which arrived).
+   */
+  #unstampedSsIdSeqOffsetByStream = /* @__PURE__ */ new Map();
   /**
    * Streams whose multicast leg delivered a RAP-flagged source packet that was
    * not parsed, typically because its overlap copy was parsed first
@@ -22968,7 +23255,9 @@ var MmtpRouter = class {
     recovered: 0,
     restarts: 0,
     unsequencedDropped: 0,
-    protectedDropped: 0
+    protectedDropped: 0,
+    baseFed: 0,
+    baseUndetermined: 0
   };
   /** Callback fired when a delta-track FEC block completes or fails. */
   #onDeltaBlockCompleteCb = null;
@@ -23141,7 +23430,7 @@ var MmtpRouter = class {
     const cb = this.#getFrameCallback(packetId);
     if (isVideo && !assembler) {
       if (frameMeta.recovered) {
-        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb);
+        this.#routeDirectRecoveredVideo(packetId, data, frameMeta, cb, meta.fecSbn);
       } else {
         this.#routeDirectSourceVideo(packetId, data, frameMeta, cb);
       }
@@ -23531,6 +23820,10 @@ var MmtpRouter = class {
   get keyframeOverlayStats() {
     return { ...this.#overlayStats };
   }
+  /** Recovered FT=2 heads held for their FT=1, and how each left the wait (BLO-53369). */
+  get recoveredHeadsAwaitingTiming() {
+    return this.#parser.recoveredHeadsAwaitingTiming;
+  }
   #isOverlayRepair(repairPacketId, repairTrackName) {
     return this.#overlayLegs.has(repairPacketId) || repairTrackName !== void 0 && this.#overlayRepairNames.has(repairTrackName);
   }
@@ -23581,6 +23874,11 @@ var MmtpRouter = class {
    */
   resetKeyframeOverlays(sourcePacketId, catalogTrackName) {
     for (const inst of this.#overlaysForSource(sourcePacketId, catalogTrackName)) this.#resetOverlay(inst);
+    for (const [name, stream] of this.#streams.get(sourcePacketId) ?? []) {
+      if (catalogTrackName !== void 0 && name !== catalogTrackName) continue;
+      stream.overlayToBase.routed.clear();
+      stream.overlayToBase.pending.clear();
+    }
   }
   #resetOverlay(inst) {
     inst.fec.resetTrack(inst.repairPacketId, inst.streamName);
@@ -23637,9 +23935,10 @@ var MmtpRouter = class {
    * A source packet that carries a 0x8B01 overlay SS_ID is also a symbol of
    * every overlay installed for its source, at that SS_ID, with the bytes the
    * base protects: the packet minus its 4-byte SS_ID trailer, extension
-   * included (7.1, 7.4.3).
+   * included (7.1, 7.4.3). `baseSsId` is that trailer's SS_ID, when the base
+   * FEC reads it.
    */
-  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source) {
+  #feedOverlaySource(packetId, catalogTrackName, packet, header, sequenceNumber, rapFlag, source, baseSsId) {
     if (this.#overlays.size === 0) return;
     const ssId = keyframeOverlaySsId(header);
     if (ssId === void 0) return;
@@ -23648,7 +23947,11 @@ var MmtpRouter = class {
       const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
       if (identity !== null) {
         inst.offsets.delete(identity.mpuSequenceNumber);
-        inst.offsets.set(identity.mpuSequenceNumber, ssId - sequenceNumber >>> 0);
+        inst.offsets.set(identity.mpuSequenceNumber, {
+          psnOffset: ssId - sequenceNumber >>> 0,
+          overlaySsId: ssId,
+          ...baseSsId === void 0 ? {} : { baseSsId }
+        });
         if (inst.offsets.size > OVERLAY_OFFSET_MPUS) inst.offsets.delete(inst.offsets.keys().next().value);
       }
       const { fec, repairPacketId: pid, streamName: name } = inst;
@@ -23727,14 +24030,27 @@ var MmtpRouter = class {
     const streamKey = this.#mediaStreamKey(sourcePacketId, sourceName);
     const restamped = this.#restampedStreams.has(streamKey);
     const restored = /* @__PURE__ */ new Set();
+    const baseSsIds = /* @__PURE__ */ new Map();
     const symbols = result.symbols.flatMap((sym) => {
-      const offset = inst.offsets.get(sym.fragment.mpuSequenceNumber);
-      if (offset !== void 0) {
-        const packetSequenceNumber = serial32Add(blockStart, sym.index) - offset >>> 0;
+      const anchor = inst.offsets.get(sym.fragment.mpuSequenceNumber);
+      if (anchor !== void 0) {
+        const overlaySsId = serial32Add(blockStart, sym.index);
+        const packetSequenceNumber = overlaySsId - anchor.psnOffset >>> 0;
         restored.add(packetSequenceNumber);
-        return [{ ...sym, packetSequenceNumber }];
+        const out = { ...sym, packetSequenceNumber };
+        const baseSsId = overlayBaseSsId(anchor, overlaySsId, packetSequenceNumber, sym.packetSequenceNumber);
+        if (baseSsId !== void 0) baseSsIds.set(out, baseSsId);
+        return [out];
+      }
+      if (!restamped) {
+        const baseSsId = unstampedBaseSsId(
+          this.#ssIdSeqOffsetByStream.get(streamKey),
+          this.#unstampedSsIdSeqOffsetByStream.get(streamKey),
+          sym.packetSequenceNumber
+        );
+        if (baseSsId !== void 0) baseSsIds.set(sym, baseSsId);
+        return [sym];
       }
-      if (!restamped) return [sym];
       this.#overlayStats.unsequencedDropped++;
       return [];
     });
@@ -23743,6 +24059,85 @@ var MmtpRouter = class {
       deliveryProvenance: inst.moqBlocks.has(blockStart) ? "mixed" : "multicast"
     });
     this.#noteOverlayRecoveredRaps(sourcePacketId, sourceName, streamKey, symbols.filter((sym) => restored.has(sym.packetSequenceNumber)));
+    this.#feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds);
+  }
+  /**
+   * Joint decoding (BLO-52085). A packet the overlay rebuilt is a source of
+   * its base block too, once its base SS_ID is determined (overlayBaseSsId,
+   * from a received member of its MPU, else unstampedBaseSsId),
+   * so it is fed to the base decoder as a rebuilt source
+   * (FECManager.feedRebuiltSourceSymbol): the base block has one erasure
+   * fewer to solve, and its repair can recover the block's other packets.
+   * A base block no repair has stated yet takes it when one does
+   * (#feedPendingRebuilt).
+   *
+   * The overlay route already handled each packet fed (delivered it, or
+   * held an untimed head for its FT=1), so a base recovery routes none of
+   * them again (#routeVerifiedFecSymbols): a second recovered copy of a
+   * held head would wait in the parser for timing its first copy consumed.
+   * Only an overlay block decoded from multicast symbols alone is fed: with
+   * a MoQ symbol in it, the base block's recovery would depend on bytes
+   * that crossed no multicast socket, which the provenance counted from the
+   * block's own arrivals cannot show.
+   */
+  #feedOverlayRecoveredToBase(inst, blockStart, symbols, baseSsIds) {
+    const fec = this.#fecManager;
+    const owner = inst.leg.sourcePacketId;
+    const name = inst.leg.sourceCatalogTrackName;
+    if (!fec?.feedRebuiltSourceSymbol || inst.moqBlocks.has(blockStart)) return;
+    if (this.#classifyPacketId(owner) === null || fec.isTrackConfigured?.(owner) === false) return;
+    const { duplicates, overlayToBase: { routed } } = this.#stream(owner, name);
+    const feeds = [];
+    for (const sym of symbols) {
+      if (duplicates.sourceSeqs.has(sym.packetSequenceNumber)) continue;
+      const ssId = baseSsIds.get(sym);
+      if (ssId === void 0) {
+        this.#overlayStats.baseUndetermined++;
+        continue;
+      }
+      routed.delete(ssId);
+      routed.add(ssId);
+      if (routed.size > OVERLAY_ROUTED_LIMIT) routed.delete(routed.values().next().value);
+      feeds.push([ssId, sym.rawSymbol]);
+    }
+    for (const [ssId, symbolData] of feeds) {
+      if (this.#classifyPacketId(owner) === null) return;
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
+  }
+  /** Feed one rebuilt source to its base block, or keep it until a repair states that block. */
+  #feedRebuiltToBase(owner, name, ssId, symbolData) {
+    const fec = this.#fecManager;
+    if (!fec?.feedRebuiltSourceSymbol) return;
+    const coords = fec.locateIsoSource?.(owner, name, ssId);
+    if (coords == null) {
+      const pending = this.#stream(owner, name).overlayToBase.pending;
+      pending.delete(ssId);
+      pending.set(ssId, symbolData.slice());
+      if (pending.size > OVERLAY_PENDING_LIMIT) pending.delete(pending.keys().next().value);
+      return;
+    }
+    const fed = fec.feedRebuiltSourceSymbol(owner, ssId, symbolData, name);
+    if (!fed.taken) return;
+    this.#overlayStats.baseFed++;
+    if (fed.recovered === null) return;
+    const sbn = coords.sbn;
+    this.#routeRecoveredBlock(sbn, fed.recovered, owner, name, () => {
+      fec.cancelBlockTimeout(sbn, owner, name);
+      fec.countRecovery(owner, sbn, name);
+      fec.markBlockCompleted(sbn, owner, name);
+    });
+  }
+  /** A repair stated `block`: the rebuilt sources that waited for it join it now. */
+  #feedPendingRebuilt(owner, name, block) {
+    const pending = this.#streams.get(owner)?.get(name)?.overlayToBase.pending;
+    if (pending === void 0 || pending.size === 0) return;
+    for (const [ssId, symbolData] of [...pending]) {
+      if (this.#classifyPacketId(owner) === null) return;
+      if (serial32Distance(block.start, ssId) >= block.length) continue;
+      pending.delete(ssId);
+      this.#feedRebuiltToBase(owner, name, ssId, symbolData);
+    }
   }
   /** fec-multicast-00 §6.6: report each base block whose RAP MFU fragments
    *  the overlay restored, when the keyframe's FT=0 and FT=1 are held too. A
@@ -23882,6 +24277,10 @@ var MmtpRouter = class {
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
+  /** Source datagrams (multicast or MoQ) a protected flow's bc-provenance v2 receiver released: admitted at once or held, then admitted by a record. Repair symbols and user-agent-admitted datagrams are not counted. Counted at release, before this router's own track checks: a released datagram those drop, which only a track change between hold and release can cause, still counts, so this is not a count of routed media. */
+  get admittedSourceDatagramCount() {
+    return this.#admittedSourceDatagrams;
+  }
   /** MoQ repair symbols of an unlisted track kept out of a governed FEC instance (7.2.7 step 2). */
   get unlistedRepairSetAsideCount() {
     return this.#unlistedRepairSetAside;
@@ -24368,6 +24767,8 @@ var MmtpRouter = class {
     )) return;
     fec.noteBlockActivity?.(blockStart, ownerPacketId, catalogTrackName);
     fec.noteRepairGroupLength?.(blockStart, ownerPacketId, repair.rsbLength, catalogTrackName);
+    this.#feedPendingRebuilt(ownerPacketId, catalogTrackName, placement.block);
+    if (this.#classifyPacketId(ownerPacketId) === null) return;
     const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
     const recovered = fec.feedRepairSymbol(
       ownerPacketId,
@@ -24505,6 +24906,7 @@ var MmtpRouter = class {
     this.#droppedPreSyncVideo.delete(streamKey);
     this.#latestVideoSeqByStream.delete(streamKey);
     this.#ssIdSeqOffsetByStream.delete(streamKey);
+    this.#unstampedSsIdSeqOffsetByStream.delete(streamKey);
     this.#multicastRapTwinByStream.delete(streamKey);
     this.#lastDirectSourceVideoTsByStream.delete(streamKey);
     this.#lastDirectEmittedVideoTsByStream.delete(streamKey);
@@ -25139,6 +25541,7 @@ var MmtpRouter = class {
     const parsed = this.#parser.parsePacket(packet);
     if (!parsed) return;
     const info = parsed.info;
+    if (manifestAdmitted && !info.isRepair && ingress?.admittedBy !== USER_AGENT_VERIFIED) this.#admittedSourceDatagrams++;
     if (source === "multicast" && !manifestAdmitted) {
       this.#fecManager?.noteMulticastArrival?.(info.packetId, info.sequenceNumber);
     }
@@ -25420,7 +25823,8 @@ var MmtpRouter = class {
           parsed.header,
           info.sequenceNumber,
           info.rapFlag,
-          source
+          source,
+          fecPayloadId?.ssId
         );
       }
     }
@@ -25570,7 +25974,8 @@ var MmtpRouter = class {
     if (stream === void 0) {
       stream = {
         key: JSON.stringify([packetId, catalogTrackName ?? null]),
-        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId))
+        duplicates: new StreamDuplicateLedgers(() => this.duplicateHorizonFor(packetId)),
+        overlayToBase: { routed: /* @__PURE__ */ new Set(), pending: /* @__PURE__ */ new Map() }
       };
       byName.set(catalogTrackName, stream);
     }
@@ -25685,8 +26090,16 @@ var MmtpRouter = class {
     this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
     this.#emitDirectVideo(packetId, data, meta, cb);
   }
-  #routeDirectRecoveredVideo(packetId, data, meta, cb) {
+  #routeDirectRecoveredVideo(packetId, data, meta, cb, fecSbn) {
     const streamKey = this.#mediaStreamKey(packetId, meta.catalogTrackName);
+    if (this.#isFecTrack(packetId)) {
+      const high = this.#deliveredVideoHighWaterByStream.get(streamKey);
+      if (fecSbn !== void 0 || high !== void 0 && authoredAdjacent(high, meta)) {
+        this.#drainDirectRecoveredVideo(streamKey, packetId, (frame) => frame.timestamp <= meta.timestamp, cb);
+        this.#emitDirectVideo(packetId, data, meta, cb);
+        return;
+      }
+    }
     this.#enqueueDirectRecoveredVideo(packetId, data, meta);
     const lastSourceTs = this.#lastDirectSourceVideoTsByStream.get(streamKey);
     this.#drainDirectRecoveredVideo(
@@ -25840,6 +26253,13 @@ var MmtpRouter = class {
    * frames by epoch only if pre-protection input ever matters.
    */
   #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete, assisted = false) {
+    const overlayRouted = ownerPacketId == null ? void 0 : this.#streams.get(ownerPacketId)?.get(catalogTrackName)?.overlayToBase.routed;
+    if (overlayRouted !== void 0 && overlayRouted.size > 0) {
+      result = {
+        ...result,
+        symbols: result.symbols.filter((sym) => !overlayRouted.has(this.#fecAnchorForRecovered(blockId, sym.index)))
+      };
+    }
     const entry = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
     const receiver = entry === void 0 || entry === "ambiguous" ? entry : entry.receiver;
     const userAgent = !assisted && entry !== void 0 && entry !== "ambiguous" && entry.protected === true && entry.userAgent === true;
@@ -25904,7 +26324,10 @@ var MmtpRouter = class {
         ...result,
         symbols: result.symbols.map((sym) => {
           const wire = this.#fecAnchorForRecovered(blockId, sym.index) - ssIdSeqOffset >>> 0;
-          if (wire === sym.packetSequenceNumber) return sym;
+          if (wire === sym.packetSequenceNumber) {
+            this.#unstampedSsIdSeqOffsetByStream.set(streamKey, ssIdSeqOffset);
+            return sym;
+          }
           this.#restampedRecoveredSeqs++;
           this.#restampedStreams.add(streamKey);
           return { ...sym, packetSequenceNumber: wire };
@@ -25940,16 +26363,29 @@ var MmtpRouter = class {
         }
       );
     }
-    result = {
-      ...result,
-      symbols: result.symbols.filter((sym) => sym.fragmentType !== 2 || sym.fragment.fragmentationIndicator !== 1 || sym.fragment.movieFragmentSequenceNumber === void 0 || sym.fragment.sampleNumber === void 0 || this.#parser.hasAuthoredTimingFor(
-        ownerPacketId,
-        sym.fragment.mpuSequenceNumber,
-        sym.fragment.movieFragmentSequenceNumber,
-        sym.fragment.sampleNumber,
-        catalogTrackName
-      ))
-    };
+    const untimedHead = (sym) => sym.fragmentType === 2 && sym.fragment.fragmentationIndicator === 1 && sym.fragment.movieFragmentSequenceNumber !== void 0 && sym.fragment.sampleNumber !== void 0 && !this.#parser.hasAuthoredTimingFor(
+      ownerPacketId,
+      sym.fragment.mpuSequenceNumber,
+      sym.fragment.movieFragmentSequenceNumber,
+      sym.fragment.sampleNumber,
+      catalogTrackName
+    );
+    for (const sym of result.symbols) {
+      if (!untimedHead(sym) || this.#sourceSeqReceived(ownerPacketId, sym.packetSequenceNumber, catalogTrackName)) continue;
+      this.#feedViaParser(
+        sym.rawSymbol,
+        { packetId: ownerPacketId, sequenceNumber: sym.packetSequenceNumber },
+        void 0,
+        {
+          skipFecPayloadId: true,
+          recovered: true,
+          deliveryProvenance,
+          ...fecSbnOf(sym.index),
+          ...catalogTrackName === void 0 ? {} : { catalogTrackName }
+        }
+      );
+    }
+    result = { ...result, symbols: result.symbols.filter((sym) => !untimedHead(sym)) };
     const gated = this.#isFecTrack(ownerPacketId);
     const assembler = this.#mseAssemblerFor(ownerPacketId, catalogTrackName);
     if (assembler) {