@blockcast/mmt-container 0.5.0-main.dd44e35d4e29 → 0.5.0-main.e4c61672f9de

package/dist/browser-runtime.js

@@ -13555,6 +13555,11 @@ var FECManager = class _FECManager {
     // Worker-recovered blocks a recovered packet of which admission refused,
     // until the decode's final symbol (7.2.7: the block is unrecovered).
     this.#refusedRecoveries = /* @__PURE__ */ new Set();
+    // Worker-recovered blocks: the next ESI the decode's ordered emit owes. The
+    // Worker emits every ESI 0..SSB_length-1 in order and drops only a symbol it
+    // refuses (a malformed ssbg_mode1 symbol), so a skipped ESI is a dropped
+    // recovered packet and the decode recovered nothing.
+    this.#workerRecoveredNextEsi = /* @__PURE__ */ new Map();
     // How the multicast leg delivers symbols (see MulticastSymbolDelivery). The
     // provider declares it per transport join; absence keeps datagram semantics.
     this.#multicastSymbolDelivery = "datagram";
@@ -13764,6 +13769,7 @@ var FECManager = class _FECManager {
   #repairDeadlineAtMs;
   #workerRecoveredBlocks;
   #refusedRecoveries;
+  #workerRecoveredNextEsi;
   #multicastSymbolDelivery;
   #orderedFrontiers;
   #orderedPendingBlocks;
@@ -13904,6 +13910,7 @@ var FECManager = class _FECManager {
       this.#cleanlyCompletedBlocks.delete(record.key);
       this.#workerRecoveredBlocks.delete(record.key);
       this.#refusedRecoveries.delete(record.key);
+      this.#workerRecoveredNextEsi.delete(record.key);
       this.#failedBlocks.delete(record.key);
       this.#resolvedBlockClasses.delete(record.key);
       this.#repairedBlocks.delete(record.key);
@@ -15059,6 +15066,7 @@ var FECManager = class _FECManager {
     resetSet(this.#repairRequestedBlocks);
     resetSet(this.#workerRecoveredBlocks);
     resetSet(this.#refusedRecoveries);
+    resetMap(this.#workerRecoveredNextEsi);
     resetSet(this.#startupAlignedPackets);
     resetSet(this.#startupPartialBlocks);
     resetSet(this.#startupRepairReadyPackets);
@@ -15186,6 +15194,7 @@ var FECManager = class _FECManager {
     dropSet(this.#repairRequestedBlocks);
     dropSet(this.#workerRecoveredBlocks);
     dropSet(this.#refusedRecoveries);
+    dropMap(this.#workerRecoveredNextEsi);
     dropSet(this.#startupAlignedPackets);
     dropSet(this.#startupPartialBlocks);
     dropSet(this.#startupRepairReadyPackets);
@@ -15973,6 +15982,16 @@ var FECManager = class _FECManager {
         if (!this.#claimDecoderBlock(client, meta.sbn, recoveredCatalogTrackName)) return;
         const blockKey = this.#blockKey(meta.sbn, packetId, recoveredCatalogTrackName);
         const cleanlyCompleted = this.#cleanlyCompletedBlocks.has(blockKey);
+        if (esi !== (this.#workerRecoveredNextEsi.get(blockKey) ?? 0)) {
+          this.#refusedRecoveries.add(blockKey);
+          if (this.#refusedRecoveries.size > 1e3) dropOldest(this.#refusedRecoveries, 500);
+        }
+        if (esi >= meta.ssbLength - 1) {
+          this.#workerRecoveredNextEsi.delete(blockKey);
+        } else {
+          this.#workerRecoveredNextEsi.set(blockKey, esi + 1);
+          if (this.#workerRecoveredNextEsi.size > 1e3) dropOldest(this.#workerRecoveredNextEsi, 500);
+        }
         if (!cleanlyCompleted) {
           const symbolKey = `${blockKey}:${esi}`;
           if (!this.#seenSymbols.has(symbolKey)) {
@@ -16782,6 +16801,7 @@ var FECManager = class _FECManager {
     this.#repairRequestedBlocks.clear();
     this.#workerRecoveredBlocks.clear();
     this.#refusedRecoveries.clear();
+    this.#workerRecoveredNextEsi.clear();
     this.#syncDecoderBlockOwners.clear();
     this.#startupAlignedPackets.clear();
     this.#startupPartialBlocks.clear();
@@ -17635,6 +17655,9 @@ function authoredGap(before, after) {
   if (!a || !b || a.mediaTimescale !== b.mediaTimescale) return false;
   return b.decodeTime > a.decodeTime + BigInt(a.durationTicks);
 }
+function ssIdAfter(a, b) {
+  return (a - b | 0) > 0;
+}
 var FecReleaseSequencer = class {
   #streams = /* @__PURE__ */ new Map();
   #gate;
@@ -17696,11 +17719,17 @@ var FecReleaseSequencer = class {
       stream.last = null;
       stream.lastSbn = void 0;
       stream.discontinuity = false;
+      stream.rapSsId = void 0;
     }
     if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
       this.#recordStat("droppedStale");
       return;
     }
+    const ssId = meta.fecSbn;
+    if (meta.trackType === "video" && ssId !== void 0 && this.#gate.isRap?.(data, meta) === true) {
+      if (stream.rapSsId === void 0 || ssIdAfter(ssId, stream.rapSsId)) stream.rapSsId = ssId;
+      this.#gate.onRap?.(stream.packetId, stream.catalogTrackName, ssId);
+    }
     if (stream.last === null) {
       if (meta.trackType === "video" && !meta.keyframe) {
         this.#recordStat("droppedBeforeStartupKeyframe");
@@ -17736,6 +17765,22 @@ var FecReleaseSequencer = class {
     }
     return earliest;
   }
+  /**
+   * Whether a complete RAP above SS_ID `ssId` entered the gate of a stream of
+   * `packetId` (draft-ramadan-moq-fec 11.4.2: repair of a block below it is
+   * moot). Its SS_ID is the one its frame completed in; a frame's packets
+   * hold consecutive SS_IDs in authored order, so a complete RAP with a
+   * packet above `ssId` has every packet of it at or above the first SS_ID
+   * any loss at or below `ssId` could have taken.
+   */
+  rapAbove(packetId, catalogTrackName, ssId) {
+    for (const stream of this.#streams.values()) {
+      if (stream.packetId !== packetId) continue;
+      if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+      if (stream.rapSsId !== void 0 && ssIdAfter(stream.rapSsId, ssId)) return true;
+    }
+    return false;
+  }
   /** Re-evaluate held gaps after FEC state changed. */
   poke(streamKey) {
     if (streamKey !== void 0) {
@@ -17826,7 +17871,8 @@ var FecReleaseSequencer = class {
         buf: [],
         last: null,
         lastSbn: void 0,
-        discontinuity: false
+        discontinuity: false,
+        rapSsId: void 0
       };
       this.#streams.set(streamKey, stream);
     }
@@ -18189,6 +18235,10 @@ var MmtpContainerParser = class _MmtpContainerParser {
   fecReleaseEarliestHeldAtMs(packetId, catalogTrackName) {
     return this.#fecSequencer?.earliestHeldArrivalMs(packetId, catalogTrackName);
   }
+  /** See FecReleaseSequencer.rapAbove; false when no stream is FEC-gated. */
+  fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
+    return this.#fecSequencer?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
+  }
   /** Re-evaluate held gaps after FEC block state changed. */
   pokeFecRelease(packetId, catalogTrackName) {
     if (!this.#fecSequencer) return;
@@ -19459,6 +19509,10 @@ var NO_BLOCK_SPAN_HORIZON = Object.freeze({
   reason: "no-block-span"
 });
 var DIRECT_RECOVERED_VIDEO_QUEUE_LIMIT = 512;
+var ASSIST_BLOCK_LIMIT = 64;
+var ASSIST_FAILURE_LEDGER_LIMIT = 4 * ASSIST_BLOCK_LIMIT;
+var ASSIST_FAILED_DECODES_MAX = 2;
+var assistKey = (ownerPacketId, catalogTrackName, blockStart) => `${ownerPacketId}/${catalogTrackName ?? ""}/${blockStart}`;
 var DIRECT_RECOVERED_AUDIO_QUEUE_LIMIT = 512;
 function sourceSymbolEvidence(packet, header, rapFlag, packetSequenceNumber) {
   const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
@@ -19483,6 +19537,12 @@ var MmtpRouter = class {
   #provenance = /* @__PURE__ */ new Map();
   #onFlowProtected = null;
   #unadmittedListedDrops = 0;
+  #unlistedRepairSetAside = 0;
+  #assistBlocks = /* @__PURE__ */ new Map();
+  #assistFailures = /* @__PURE__ */ new Map();
+  #scratchDecoderFactory = null;
+  #unlistedAssistedRecoveries = 0;
+  #unlistedAssistedRefusals = 0;
   /** The ingress a held datagram arrived with; the receiver returns the same bytes on release. */
   #heldIngress = /* @__PURE__ */ new WeakMap();
   #unicastRepair = false;
@@ -19575,6 +19635,7 @@ var MmtpRouter = class {
   #onBlockFailed = null;
   /** Typed observer of every gap decision the release gate makes. */
   #onFrameGap;
+  #fecRapObservers = /* @__PURE__ */ new Set();
   // Pokes requested while a packet is being processed are deferred to its
   // end: a synchronous recovery completes its block BEFORE routing the
   // recovered frames, and releasing a held gap in between would strand them.
@@ -20198,14 +20259,13 @@ var MmtpRouter = class {
   updateProvenanceFlowIngress(ingress) {
     const entry = this.#provenance.get(ingress.flow);
     if (!entry) return;
+    const added = entry.protected ? ingress.tracks.filter(({ name, packetId }) => name && !entry.ingress.tracks.some((t) => t.name === name && t.packetId === packetId)) : [];
+    const governed = added.map(({ packetId }) => [...this.#repairOwnersByPacketId.get(packetId) ?? [packetId]].some((owner) => this.#governs(owner)));
     this.#provenance.set(ingress.flow, { ...entry, ingress });
-    if (entry.protected) {
-      for (const { name, packetId } of ingress.tracks) {
-        if (name && !entry.ingress.tracks.some((t) => t.name === name && t.packetId === packetId)) {
-          this.#fecManager?.resetTrack?.(packetId, name);
-        }
-      }
-    }
+    added.forEach(({ name, packetId }, i) => {
+      if (governed[i]) for (const block of this.#assistBlocks.values()) block.pooled.clear();
+      else this.#fecManager?.resetTrack?.(packetId, name);
+    });
   }
   /**
    * Called once per protection of a flow: at the admission that makes this
@@ -20226,11 +20286,154 @@ var MmtpRouter = class {
     if (!entry) return;
     entry.receiver.release();
     entry.protected = false;
+    this.#assistBlocks.clear();
+    this.#assistFailures.clear();
   }
   /** MoQ packets of a track a protected flow lists, dropped on its unicast path: duplicate, overflow, or listed by more than one flow. */
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
+  /** MoQ repair symbols of an unlisted track kept out of a governed FEC instance (7.2.7 step 2). */
+  get unlistedRepairSetAsideCount() {
+    return this.#unlistedRepairSetAside;
+  }
+  /** Governed blocks recovered with the help of unlisted repair (7.2.7 step 2). */
+  get unlistedAssistedRecoveryCount() {
+    return this.#unlistedAssistedRecoveries;
+  }
+  /** Unlisted-assisted decodes refused because two already failed for the block (7.2.7 step 2). */
+  get unlistedAssistedRefusalCount() {
+    return this.#unlistedAssistedRefusals;
+  }
+  /** Unlisted repair symbols pooled now, across every governed block (7.2.7 step 2). */
+  get unlistedPoolSymbolCount() {
+    let n = 0;
+    for (const block of this.#assistBlocks.values()) n += block.pooled.size;
+    return n;
+  }
+  /**
+   * Wire the decoder an unlisted-assisted decode runs in: a fresh, configured
+   * decoder of the owner's track, used once and discarded, never the live one.
+   * Without it unlisted repair on a governed instance is set aside and dropped.
+   */
+  setScratchFecDecoderFactory(factory) {
+    this.#scratchDecoderFactory = factory;
+    if (!factory) {
+      this.#assistBlocks.clear();
+      this.#assistFailures.clear();
+    }
+  }
+  /** Whether a protected flow lists `ownerPacketId`: its FEC instance is governed (7.2.7). */
+  #governs(ownerPacketId) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.protected && ingressHasPacketId(entry.ingress, ownerPacketId)) return true;
+    }
+    return false;
+  }
+  /**
+   * A MoQ repair symbol no protected flow lists, owned by a source track one
+   * does: its FEC instance is governed (7.2.7 step 2) and takes only admitted
+   * symbols, so the symbol is set aside: pooled for an unlisted-assisted
+   * decode of a block admitted repair already delimits, else dropped. It
+   * never states a block, so the live locator and decoder are unchanged.
+   * Un-listing needs no hook: an unprotected or released flow lists nothing.
+   */
+  #setAsideUnlistedRepair(ownerPacketId, catalogTrackName, repair) {
+    if (!this.#governs(ownerPacketId)) return false;
+    this.#unlistedRepairSetAside++;
+    const key = assistKey(ownerPacketId, catalogTrackName, repair.ssStart);
+    const block = this.#assistBlocks.get(key);
+    if (block !== void 0 && block.ssbLength === repair.ssbLength && !block.repairs.has(repair.rsId) && block.pooled.size < block.ssbLength && repair.symbolData.byteLength === this.#symbolSizeForPacket(ownerPacketId) && this.#fecManager?.admitRepairBlockLength?.(ownerPacketId, repair.ssbLength, repair.rsbLength, repair.rsId) !== false) {
+      block.pooled.set(repair.rsId, repair.symbolData);
+      this.#tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, repair.ssStart);
+    }
+    return true;
+  }
+  /**
+   * An admitted repair placed a governed block (its SSB_length delimits it):
+   * open the block's record, which the symbols its live decoder takes join.
+   */
+  #openAssistBlock(ownerPacketId, catalogTrackName, blockStart, ssbLength) {
+    const key = assistKey(ownerPacketId, catalogTrackName, blockStart);
+    if (!this.#scratchDecoderFactory || this.#assistBlocks.has(key) || !this.#governs(ownerPacketId)) return;
+    this.#assistBlocks.set(key, { ssbLength, sources: /* @__PURE__ */ new Map(), repairs: /* @__PURE__ */ new Map(), pooled: /* @__PURE__ */ new Map() });
+    for (const oldest of this.#assistBlocks.keys()) {
+      if (this.#assistBlocks.size <= ASSIST_BLOCK_LIMIT) break;
+      this.#assistBlocks.delete(oldest);
+    }
+  }
+  /** A symbol fed to an open governed block's live decoder that did not recover it. */
+  #noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, symbol, data) {
+    const key = assistKey(ownerPacketId, catalogTrackName, blockStart);
+    const block = this.#assistBlocks.get(key);
+    if (block === void 0) return;
+    if ("rsId" in symbol) {
+      block.repairs.set(symbol.rsId, data);
+      block.pooled.delete(symbol.rsId);
+    } else {
+      block.sources.set(symbol.esi, data);
+    }
+    this.#tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, blockStart);
+  }
+  /**
+   * 7.2.7 step 2, phase two: a governed block its admitted symbols cannot
+   * decode (the live decoder already had them all) is decoded in a scratch
+   * decoder from its admitted symbols plus pooled unlisted repair, only as
+   * many as close the shortfall. What it recovers is released only through
+   * admission (#routeRecoveredBlock), so the live decoder is never touched and
+   * a refused recovery leaves the block to fail at its FEC deadline. At most
+   * two such decodes may fail per block; a third is refused.
+   */
+  #tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, blockStart) {
+    const fec = this.#fecManager;
+    const admitted = block.sources.size + block.repairs.size;
+    if (!fec || block.pooled.size === 0) return;
+    if (admitted >= block.ssbLength || admitted + block.pooled.size < block.ssbLength) return;
+    if (fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName)) {
+      this.#assistBlocks.delete(key);
+      return;
+    }
+    if ((this.#assistFailures.get(key) ?? 0) >= ASSIST_FAILED_DECODES_MAX) {
+      this.#unlistedAssistedRefusals++;
+      return;
+    }
+    const decoder = this.#scratchDecoderFactory?.(ownerPacketId, catalogTrackName);
+    if (!decoder) return;
+    let recovered = null;
+    const fed = [];
+    try {
+      for (const [esi, data] of block.sources) decoder.add_source(serial32Add(blockStart, esi), data, 0);
+      for (const [rsId, data] of block.repairs) {
+        recovered ??= decoder.add_repair(blockStart, block.ssbLength, rsId, data, 0);
+      }
+      for (const [rsId, data] of block.pooled) {
+        if (recovered || fed.length >= block.ssbLength - admitted) break;
+        fed.push(rsId);
+        recovered = decoder.add_repair(blockStart, block.ssbLength, rsId, data, 0);
+      }
+    } catch {
+      recovered = null;
+    } finally {
+      decoder.free?.();
+    }
+    if (recovered && this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
+      fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
+      fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
+      fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
+    })) {
+      this.#unlistedAssistedRecoveries++;
+      this.#assistBlocks.delete(key);
+      return;
+    }
+    for (const rsId of fed) block.pooled.delete(rsId);
+    const failed = (this.#assistFailures.get(key) ?? 0) + 1;
+    this.#assistFailures.delete(key);
+    this.#assistFailures.set(key, failed);
+    for (const oldest of this.#assistFailures.keys()) {
+      if (this.#assistFailures.size <= ASSIST_FAILURE_LEDGER_LIMIT) break;
+      this.#assistFailures.delete(oldest);
+    }
+  }
   /**
    * The admission that makes this router protected under `flow` (7.2.7):
    * its FEC instances discard what they hold of the flow's listed tracks so
@@ -20406,8 +20609,9 @@ var MmtpRouter = class {
       );
     }
     if (ownerPacketId != null && !admitted) {
-      const admit = this.#admitUnicast(ownerPacketId, packet, () => this.#feedRepairPacket(packet, ownerPacketIdHint, catalogTrackName, repairTrackName, true));
+      const admit = this.#admitUnicast(repairPacketId, packet, () => this.#feedRepairPacket(packet, ownerPacketIdHint, catalogTrackName, repairTrackName, true));
       if (admit === "held" || admit === "dropped") return;
+      if (admit === "unlisted" && this.#fecManager && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackName, parsed)) return;
     }
     if (ownerPacketId != null && this.#fecManager) {
       this.#moqRepairPidCounts[repairPacketId] = (this.#moqRepairPidCounts[repairPacketId] || 0) + 1;
@@ -20527,6 +20731,7 @@ var MmtpRouter = class {
     const placement = fec.placeIsoRepair(ownerPacketId, catalogTrackName, repair.ssStart, repair.ssbLength);
     if (placement.status !== "placed") return;
     const blockStart = placement.block.start;
+    this.#openAssistBlock(ownerPacketId, catalogTrackName, blockStart, repair.ssbLength);
     if (placement.span !== void 0) {
       this.#replayIsoSources(ownerPacketId, catalogTrackName, placement.span.block.start, placement.span.placed);
     }
@@ -20557,6 +20762,8 @@ var MmtpRouter = class {
         fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
         fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
       });
+    } else if (!recovered) {
+      this.#noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, { rsId: repair.rsId }, repair.symbolData);
     }
   }
   /**
@@ -20596,6 +20803,7 @@ var MmtpRouter = class {
       if (payload.oversized) continue;
       const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
       const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, catalogTrackName);
+      if (!recovered) this.#noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, { esi }, payload.symbolData);
       if (!recovered || alreadyCompleted) continue;
       this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
         fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
@@ -20666,6 +20874,9 @@ var MmtpRouter = class {
       }
     }
     this.#parser.resetTrack(packetId, catalogTrackName);
+    const assistPrefix = assistKey(packetId, catalogTrackName, 0).slice(0, -1);
+    for (const key of this.#assistBlocks.keys()) if (key.startsWith(assistPrefix)) this.#assistBlocks.delete(key);
+    for (const key of this.#assistFailures.keys()) if (key.startsWith(assistPrefix)) this.#assistFailures.delete(key);
     const streamKey = this.#mediaStreamKey(packetId, catalogTrackName);
     this.#trackSynced.delete(streamKey);
     this.#droppedPreSyncVideo.delete(streamKey);
@@ -21083,6 +21294,24 @@ var MmtpRouter = class {
   fecReleaseEarliestHeldAtMs(packetId, catalogTrackName) {
     return this.#parser.fecReleaseEarliestHeldAtMs(packetId, catalogTrackName);
   }
+  /**
+   * Whether a complete RAP above SS_ID `ssId` entered this stream's FEC
+   * release gate (see FecReleaseSequencer.rapAbove).
+   */
+  fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
+    return this.#parser.fecReleaseRapAbove(packetId, catalogTrackName, ssId);
+  }
+  /**
+   * Observe each complete RAP entering an FEC release gate, with the SS_ID
+   * its frame completed in. Called synchronously from the frame push: an
+   * observer that drives FEC state must defer that work.
+   */
+  addFecRapObserver(observer) {
+    this.#fecRapObservers.add(observer);
+    return () => {
+      this.#fecRapObservers.delete(observer);
+    };
+  }
   #requestFecPoke(packetId, catalogTrackName) {
     if (this.#disposed) return;
     if (this.#fecPokeDepth > 0) {
@@ -21128,6 +21357,10 @@ var MmtpRouter = class {
         this.#onFrameGap?.(decision);
         return decision;
       },
+      isRap: (data, meta) => this.#isRapForGap(data, meta),
+      onRap: (packetId, catalogTrackName, ssId) => {
+        for (const observer of this.#fecRapObservers) observer(packetId, catalogTrackName, ssId);
+      },
       onReleased: (data, meta) => {
         if (meta.trackType !== "video" || meta.mpuSequenceNumber === void 0) return;
         const timing = meta.authoredTiming;
@@ -21326,6 +21559,7 @@ var MmtpRouter = class {
       const ownerPacketId = this.#resolveRepairOwnerPacketId(info.packetId, ingress);
       if (ownerPacketId != null && this.#fecManager) {
         if (hasAmbiguousCatalogTrackName(ingress, ownerPacketId)) return;
+        if (source === "moq" && !manifestAdmitted && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
         this.#repairPidCounts[info.packetId] = (this.#repairPidCounts[info.packetId] || 0) + 1;
         const count = this.#repairPidCounts[info.packetId];
         if (count <= 2 || count % 500 === 0) {
@@ -21493,6 +21727,15 @@ var MmtpRouter = class {
           sourceFec.symbolData,
           catalogTrackName
         );
+        if (!recovered) {
+          this.#noteAssistAdmitted(
+            info.packetId,
+            catalogTrackName,
+            sourceFec.sbn,
+            { esi: serial32Distance(sourceFec.sbn, sourceFec.ssId) },
+            sourceFec.symbolData
+          );
+        }
         if (recovered && !alreadyCompleted) {
           const fec = this.#fecManager;
           const sbn = sourceFec.sbn;
@@ -26566,6 +26809,8 @@ function newBlockPolicyStats(packetId, catalogTrackName, epoch) {
     repairsSkippedPresentationDelayUnavailable: 0,
     repairsSkippedRangeNoAnchor: 0,
     repairsSkippedGroupCannotComplete: 0,
+    repairsSkippedMootRap: 0,
+    repairStops: { preempted: 0, reprioritized: 0, expired: 0, resolved: 0, reset: 0, disposed: 0, moot: 0 },
     lastRepairSkip: null,
     keyframeRepairFetchesSent: 0,
     rangeRepairFetchesSent: 0,
@@ -26652,7 +26897,17 @@ var REPAIR_SKIP_REASONS = /* @__PURE__ */ new Set([
   "rtt-exceeds-budget",
   "presentation-delay-unavailable",
   "range-no-anchor",
-  "group-cannot-complete"
+  "group-cannot-complete",
+  "moot-rap"
+]);
+var REPAIR_STOP_REASONS = /* @__PURE__ */ new Set([
+  "preempted",
+  "reprioritized",
+  "expired",
+  "resolved",
+  "reset",
+  "disposed",
+  "moot"
 ]);
 var REPAIR_DEADLINE_BOUNDS = /* @__PURE__ */ new Set(["wait", "presentation", "keyframe", "retention"]);
 var GAP_REASONS = {
@@ -26711,6 +26966,8 @@ function isRepairLifecycleEvent(value) {
       ]) && isRepairBlockIdentity(block) && (value["priority"] === 0 || value["priority"] === 1 || value["priority"] === 2) && isFiniteNumber(value["rttMs"]) && value["rttMs"] > 0 && isFiniteNumber(value["budgetMs"]) && value["budgetMs"] > value["rttMs"] && isNullableNonNegative(value["delayMs"]) && isNullableNonNegative(value["blockAgeMs"]) && value["delayMs"] === null === (value["blockAgeMs"] === null) && REPAIR_DEADLINE_BOUNDS.has(value["bound"]);
     case "repair-skipped":
       return hasExactKeys(value, ["version", "type", "block", "reason", "rttMs", "budgetMs"]) && isRepairBlockIdentity(block) && REPAIR_SKIP_REASONS.has(value["reason"]) && isNullableNonNegative(value["rttMs"]) && isFiniteNumber(value["budgetMs"]);
+    case "repair-stopped":
+      return hasExactKeys(value, ["version", "type", "block", "reason"]) && isRepairBlockIdentity(block) && REPAIR_STOP_REASONS.has(value["reason"]);
     case "repair-priority": {
       const blockClass = value["blockClass"];
       const action = value["action"];
@@ -28120,6 +28377,14 @@ var MulticastManager = class {
         }
       }
     }
+    const factory = typeof wasmDecoderSource === "function" ? wasmDecoderSource : null;
+    const fecTracks = fecTrackIndexes.map((i) => catalog.tracks[i]);
+    this.#router.setScratchFecDecoderFactory(factory && ((ownerPacketId, catalogTrackName) => {
+      const track = fecTracks.find((t) => t.packetId === ownerPacketId && t.name === catalogTrackName);
+      if (!track) return null;
+      const decoder = factory(track);
+      return [...fecDecoders.values()].includes(decoder) ? null : decoder;
+    }));
     this.#switchingSets.clear();
     this.#repairPacketIds.clear();
     this.#router.clearRepairPacketIdOwners();
@@ -28293,6 +28558,7 @@ var MulticastManager = class {
     else if (reason === "rtt-exceeds-budget") stats.repairsSkippedRttExceedsBudget++;
     else if (reason === "range-no-anchor") stats.repairsSkippedRangeNoAnchor++;
     else if (reason === "group-cannot-complete") stats.repairsSkippedGroupCannotComplete++;
+    else if (reason === "moot-rap") stats.repairsSkippedMootRap++;
     else stats.repairsSkippedPresentationDelayUnavailable++;
     stats.lastRepairSkip = {
       reason,
@@ -28353,6 +28619,27 @@ var MulticastManager = class {
       block: repairBlockIdentity(packetId, sbn, catalogTrackName)
     });
   }
+  /** Record a running repair FETCH the scheduler stopped, and why. */
+  noteRepairStopped(reason, sbn, packetId, catalogTrackName) {
+    this.#statsFor(packetId, catalogTrackName).repairStops[reason]++;
+    this.#emitRepairLifecycle({
+      version: 2,
+      type: "repair-stopped",
+      block: repairBlockIdentity(packetId, sbn, catalogTrackName),
+      reason
+    });
+  }
+  /**
+   * Whether a complete RAP above SS_ID `ssId` reached the stream's in-order
+   * release gate (draft-ramadan-moq-fec 11.4.2: repair below it is moot).
+   */
+  rapCompleteAbove(packetId, catalogTrackName, ssId) {
+    return this.#router.fecReleaseRapAbove(packetId, catalogTrackName, ssId);
+  }
+  /** Observe each complete RAP reaching a release gate (synchronous: defer FEC work). */
+  addRapCompleteObserver(observer) {
+    return this.#router.addFecRapObserver(observer);
+  }
   /** Catalog/reset epoch of a packet's streams; gap decisions carry it. */
   epochFor(packetId) {
     return this.#fec.epochFor(packetId);
@@ -28368,6 +28655,7 @@ var MulticastManager = class {
       if (stats.epoch !== this.#fec.epochFor(stats.packetId)) continue;
       out[key] = {
         ...stats,
+        repairStops: { ...stats.repairStops },
         lastRepairSkip: stats.lastRepairSkip === null ? null : { ...stats.lastRepairSkip }
       };
     }
@@ -30731,6 +31019,34 @@ function wireRepairFetch(mc, opts) {
     run.stopped = reason;
     run.controller.abort();
     if (reason === "preempted") releaseHold(entry);
+    mc.noteRepairStopped?.(reason, entry.sbn, entry.packetId, entry.catalogTrackName);
+  };
+  const lastSsId = (entry) => {
+    if (entry.range) return entry.sbn + entry.range.holeLength - 1;
+    const length = symbolCounts(entry.sbn, entry.packetId, entry.catalogTrackName)?.authoredLength;
+    return length === void 0 ? void 0 : entry.sbn + length - 1;
+  };
+  const moot = (entry) => {
+    if (entry.priority !== 0) return false;
+    const last = lastSsId(entry);
+    if (last === void 0) return false;
+    try {
+      return mc.rapCompleteAbove?.(entry.packetId, entry.catalogTrackName, last) === true;
+    } catch {
+      return false;
+    }
+  };
+  const skip = (entry, reason, rttMs, budgetMs) => {
+    retire(entry);
+    releaseHold(entry);
+    clearEntry(entry);
+    mc.noteRepairSkipped(
+      reason,
+      { rttMs, budgetMs, priority: entry.priority },
+      entry.sbn,
+      entry.packetId,
+      entry.catalogTrackName
+    );
   };
   const readKeyframeBudget = (packetId, catalogTrackName) => {
     const reader = opts.keyframeRepairBudgetMs;
@@ -30755,31 +31071,22 @@ function wireRepairFetch(mc, opts) {
     const rttMs = readRtt();
     const reason = !entry.range && !groupCanComplete(entry.sbn, entry.packetId, entry.catalogTrackName) ? "group-cannot-complete" : rttMs === null ? "rtt-unmeasured" : rttMs < budgetMs ? null : "rtt-exceeds-budget";
     if (reason === null) return rttMs;
-    retire(entry);
-    releaseHold(entry);
-    clearEntry(entry);
-    mc.noteRepairSkipped(
-      reason,
-      { rttMs, budgetMs, priority: entry.priority },
-      entry.sbn,
-      entry.packetId,
-      entry.catalogTrackName
-    );
+    skip(entry, reason, rttMs, budgetMs);
     return null;
   };
   const retire = (entry) => {
     if (entries.get(entry.key) === entry) entries.delete(entry.key);
     if (entry.expiry !== void 0) clearTimeout(entry.expiry);
   };
-  const urgentOutstanding = () => {
+  const outstandingBelow = (priority) => {
     for (const entry of entries.values()) {
-      if (entry.priority < 2) return true;
+      if (entry.priority < priority) return true;
     }
     return false;
   };
-  const preemptDeltas = () => {
+  const preemptBestEffort = () => {
     for (const entry of entries.values()) {
-      if (entry.priority !== 2 || !entry.running) continue;
+      if (entry.priority === 0 || !entry.running) continue;
       stop(entry, "preempted");
       note("repair-preempted", entry);
     }
@@ -30799,8 +31106,13 @@ function wireRepairFetch(mc, opts) {
   };
   const start = (entry, counted = true) => {
     const now = performance.now();
+    if (moot(entry)) {
+      skip(entry, "moot-rap", readRtt(), entry.deadlineAt - now);
+      return;
+    }
     const rttMs = admit(entry, now);
     if (rttMs === null) return;
+    if (entry.priority === 0) preemptBestEffort();
     if (counted) entry.attempts++;
     mc.noteRepairFetchSent?.(entry.priority, entry.sbn, entry.packetId, entry.catalogTrackName, {
       rttMs,
@@ -30844,9 +31156,13 @@ function wireRepairFetch(mc, opts) {
       queued.push(entry);
     }
     for (const entry of queued) {
-      if (entry.priority < 2) start(entry);
+      if (entry.priority === 0) start(entry);
+    }
+    if (outstandingBelow(1)) return;
+    for (const entry of queued) {
+      if (entry.priority === 1) start(entry);
     }
-    if (urgentOutstanding()) return;
+    if (outstandingBelow(2)) return;
     queued.filter((entry) => entry.priority === 2).sort((a, b) => a.deadlineAt - b.deadlineAt || a.order - b.order).forEach((entry) => start(entry));
   };
   const symbolCounts = (sbn, packetId, catalogTrackName) => {
@@ -30974,7 +31290,6 @@ function wireRepairFetch(mc, opts) {
         stop(entry2, "reprioritized");
         start(entry2, false);
       }
-      preemptDeltas();
       dispatch();
       return;
     }
@@ -31106,7 +31421,6 @@ function wireRepairFetch(mc, opts) {
     };
     entries.set(key, entry);
     noteBudget(entry, deadline.extensionMs);
-    if (entry.priority < 2) preemptDeltas();
     dispatch();
   });
   const rangeFor = (loss, repairTrack) => {
@@ -31182,15 +31496,28 @@ function wireRepairFetch(mc, opts) {
       }
       entries.set(entry.key, entry);
       entry.expiry = setTimeout(dispatch, Math.max(0, entry.deadlineAt - performance.now()) + 1);
-      preemptDeltas();
       dispatch();
     });
   }
+  const removeRapObserver = mc.addRapCompleteObserver?.((packetId) => {
+    queueMicrotask(() => {
+      if (disposed) return;
+      for (const entry of [...entries.values()]) {
+        if (entry.packetId !== packetId || !entry.running || !moot(entry)) continue;
+        stop(entry, "moot");
+        retire(entry);
+        releaseHold(entry);
+        clearEntry(entry);
+      }
+      dispatch();
+    });
+  });
   return () => {
     disposed = true;
     mc.setUnicastRepair?.(false);
     removeResetObserver();
     removeLifecycleObserver();
+    removeRapObserver?.();
     for (const entry of [...entries.values()]) {
       clearEntry(entry);
       if (entry.running) releaseHold(entry);