@blockcast/mmt-container 0.5.0-main.9c437a834da9 → 0.5.0-main.dd44e35d4e29

package/dist/browser-runtime.js

@@ -13502,6 +13502,9 @@ var FECManager = class _FECManager {
     // Receiver-local first-accepted-symbol time per block, bounded like
     // #blockPathCounts (see blockAnchorAtMs).
     this.#blockAnchorsMs = /* @__PURE__ */ new Map();
+    // The receipt time of the packet being fed, when it is not now: a datagram
+    // held on a miss and admitted later (withReceiptTime).
+    this.#receiptAtMs = void 0;
     // Exact catalog identity observed on accepted symbols for each FEC block.
     // Conflicting identities collapse to null so recovery fails closed.
     this.#blockCatalogTrackNames = /* @__PURE__ */ new Map();
@@ -13549,6 +13552,9 @@ var FECManager = class _FECManager {
     // Worker recovery emits all K source symbols. Track recovery once per block
     // while routing only ESI slots that were absent from the direct source path.
     this.#workerRecoveredBlocks = /* @__PURE__ */ new Set();
+    // 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();
     // How the multicast leg delivers symbols (see MulticastSymbolDelivery). The
     // provider declares it per transport join; absence keeps datagram semantics.
     this.#multicastSymbolDelivery = "datagram";
@@ -13687,6 +13693,11 @@ var FECManager = class _FECManager {
     /** A stream's SBN went backwards (or jumped implausibly): the source restarted. */
     this.onSourceDiscontinuity = null;
     // Worker-path callbacks — async recovery and stats from FecWorkerClient.
+    /**
+     * A recovered source symbol. Return false when admission refused the
+     * packet it carries (bc-provenance v2, draft-ramadan-moq-multicast-01
+     * 7.2.7): the block is then unrecovered and stays open to its FEC deadline.
+     */
     this.onBlockRecovered = null;
     this.onFecStatsUpdate = null;
   }
@@ -13739,6 +13750,7 @@ var FECManager = class _FECManager {
   #seenSymbols;
   #blockPathCounts;
   #blockAnchorsMs;
+  #receiptAtMs;
   #blockCatalogTrackNames;
   #startupAlignedPackets;
   #startupPartialBlocks;
@@ -13751,6 +13763,7 @@ var FECManager = class _FECManager {
   #repairDeadlines;
   #repairDeadlineAtMs;
   #workerRecoveredBlocks;
+  #refusedRecoveries;
   #multicastSymbolDelivery;
   #orderedFrontiers;
   #orderedPendingBlocks;
@@ -13890,6 +13903,7 @@ var FECManager = class _FECManager {
       this.#completedBlocks.delete(record.key);
       this.#cleanlyCompletedBlocks.delete(record.key);
       this.#workerRecoveredBlocks.delete(record.key);
+      this.#refusedRecoveries.delete(record.key);
       this.#failedBlocks.delete(record.key);
       this.#resolvedBlockClasses.delete(record.key);
       this.#repairedBlocks.delete(record.key);
@@ -14228,7 +14242,7 @@ var FECManager = class _FECManager {
    * remainder, so repeated source progress costs no timer operation.
    */
   #armRepairDeadline(key, sbn, packetId, catalogTrackName, delayMs) {
-    const deadlineMs = performance.now() + delayMs;
+    const deadlineMs = this.#notEarlierUnderReceipt(this.#receiptNow() + delayMs, this.#repairDeadlineAtMs.get(key));
     this.#repairDeadlineAtMs.set(key, deadlineMs);
     const armed = this.#repairDeadlines.get(key);
     if (armed?.handle != null) {
@@ -14248,7 +14262,7 @@ var FECManager = class _FECManager {
       timer.handle = null;
       this.#requestRepair(sbn, packetId, catalogTrackName);
     };
-    timer.handle = setTimeout(onFire, delayMs);
+    timer.handle = setTimeout(onFire, Math.max(0, deadlineMs - performance.now()));
     this.#repairDeadlines.set(key, timer);
   }
   #requestRepair(sbn, packetId, catalogTrackName, settledByOrder = false) {
@@ -14652,7 +14666,10 @@ var FECManager = class _FECManager {
   }
   #armBlockTimeout(sbn, packetId, catalogTrackName, delayMs) {
     const key = this.#blockKey(sbn, packetId, catalogTrackName);
-    const waitAtMs = performance.now() + Math.max(1, Math.ceil(delayMs));
+    const waitAtMs = this.#notEarlierUnderReceipt(
+      this.#receiptNow() + Math.max(1, Math.ceil(delayMs)),
+      this.#blockWaitDeadlinesMs.get(key)
+    );
     const holdAtMs = this.#repairHoldUntilMs.get(key);
     this.#blockWaitDeadlinesMs.set(key, holdAtMs === void 0 ? waitAtMs : Math.min(waitAtMs, holdAtMs));
     this.#applyBlockDeadline(key, sbn, packetId, catalogTrackName);
@@ -15041,6 +15058,7 @@ var FECManager = class _FECManager {
     resetSet(this.#cleanlyCompletedBlocks);
     resetSet(this.#repairRequestedBlocks);
     resetSet(this.#workerRecoveredBlocks);
+    resetSet(this.#refusedRecoveries);
     resetSet(this.#startupAlignedPackets);
     resetSet(this.#startupPartialBlocks);
     resetSet(this.#startupRepairReadyPackets);
@@ -15167,6 +15185,7 @@ var FECManager = class _FECManager {
     dropSet(this.#cleanlyCompletedBlocks);
     dropSet(this.#repairRequestedBlocks);
     dropSet(this.#workerRecoveredBlocks);
+    dropSet(this.#refusedRecoveries);
     dropSet(this.#startupAlignedPackets);
     dropSet(this.#startupPartialBlocks);
     dropSet(this.#startupRepairReadyPackets);
@@ -15280,7 +15299,9 @@ var FECManager = class _FECManager {
       moqSymbols: 0,
       complete: false
     };
-    if (!this.#blockAnchorsMs.has(blockKey)) this.#blockAnchorsMs.set(blockKey, performance.now());
+    const receivedAtMs = this.#receiptNow();
+    const anchorMs = this.#blockAnchorsMs.get(blockKey);
+    if (anchorMs === void 0 || receivedAtMs < anchorMs) this.#blockAnchorsMs.set(blockKey, receivedAtMs);
     if (source === "multicast") counts.multicastSymbols++;
     else counts.moqSymbols++;
     this.#blockPathCounts.set(blockKey, counts);
@@ -15953,7 +15974,25 @@ var FECManager = class _FECManager {
         const blockKey = this.#blockKey(meta.sbn, packetId, recoveredCatalogTrackName);
         const cleanlyCompleted = this.#cleanlyCompletedBlocks.has(blockKey);
         if (!cleanlyCompleted) {
-          if (!this.#workerRecoveredBlocks.has(blockKey)) {
+          const symbolKey = `${blockKey}:${esi}`;
+          if (!this.#seenSymbols.has(symbolKey)) {
+            this.#seenSymbols.add(symbolKey);
+            const admitted = this.onBlockRecovered?.(
+              meta.sbn,
+              packetId,
+              data,
+              meta,
+              recoveredCatalogTrackName
+            );
+            if (admitted === false) {
+              this.#refusedRecoveries.add(blockKey);
+              if (this.#refusedRecoveries.size > 1e3) dropOldest(this.#refusedRecoveries, 500);
+            }
+          }
+        }
+        const refused = esi >= meta.ssbLength - 1 && this.#refusedRecoveries.delete(blockKey);
+        if (esi >= meta.ssbLength - 1 && !refused && !this.#completedBlocks.has(blockKey)) {
+          if (!cleanlyCompleted && !this.#workerRecoveredBlocks.has(blockKey)) {
             this.#traceLifecycle(
               "recovered",
               meta.sbn,
@@ -15968,19 +16007,6 @@ var FECManager = class _FECManager {
             }
             this.#noteBlockRepaired(blockKey, meta.sbn, packetId, recoveredCatalogTrackName);
           }
-          const symbolKey = `${blockKey}:${esi}`;
-          if (!this.#seenSymbols.has(symbolKey)) {
-            this.#seenSymbols.add(symbolKey);
-            this.onBlockRecovered?.(
-              meta.sbn,
-              packetId,
-              data,
-              meta,
-              recoveredCatalogTrackName
-            );
-          }
-        }
-        if (esi >= meta.ssbLength - 1 && !this.#completedBlocks.has(blockKey)) {
           this.cancelBlockTimeout(meta.sbn, packetId, recoveredCatalogTrackName);
           if (recoveredCatalogTrackName === void 0) {
             this.onBlockComplete?.(meta.sbn, packetId);
@@ -16550,6 +16576,33 @@ var FECManager = class _FECManager {
     }
     queueMicrotask(() => this.#syncDecoderBlockOwners.delete(key));
   }
+  /**
+   * Run `fn` with `receivedAtMs` (performance.now() clock) as the receipt
+   * time of what it feeds. Within a consumer the bc-provenance profile
+   * governs, a datagram held on a miss and admitted later keeps its receipt
+   * time (fec-01 9): it anchors its block's ts and arms the block's
+   * deadlines from then, never later than they are already armed.
+   */
+  withReceiptTime(receivedAtMs, fn) {
+    const outer = this.#receiptAtMs;
+    this.#receiptAtMs = receivedAtMs;
+    try {
+      fn();
+    } finally {
+      this.#receiptAtMs = outer;
+    }
+  }
+  #receiptNow() {
+    return this.#receiptAtMs ?? performance.now();
+  }
+  /**
+   * A held packet admitted late arms from its (earlier) receipt time; that
+   * never pulls in a deadline later activity already armed. Outside a
+   * receipt scope a re-arm replaces the deadline, as a narrower bound may.
+   */
+  #notEarlierUnderReceipt(deadlineMs, armedMs) {
+    return this.#receiptAtMs === void 0 || armedMs === void 0 ? deadlineMs : Math.max(deadlineMs, armedMs);
+  }
   /** Refresh deadlines after accepted block activity. */
   noteBlockActivity(sbn, packetId, catalogTrackName, sourceProgress = false) {
     if (!this.#trackConfigs.has(packetId)) return;
@@ -16728,6 +16781,7 @@ var FECManager = class _FECManager {
     this.#cleanlyCompletedBlocks.clear();
     this.#repairRequestedBlocks.clear();
     this.#workerRecoveredBlocks.clear();
+    this.#refusedRecoveries.clear();
     this.#syncDecoderBlockOwners.clear();
     this.#startupAlignedPackets.clear();
     this.#startupPartialBlocks.clear();
@@ -19434,6 +19488,8 @@ var MmtpRouter = class {
   #unicastRepair = false;
   /** How to route a held unicast (MoQ) datagram once a record admits it. */
   #heldReplay = /* @__PURE__ */ new WeakMap();
+  /** When a held datagram was received: admitted later, it keeps that receipt time (fec-01 9). */
+  #heldAt = /* @__PURE__ */ new WeakMap();
   /** The flow whose receiver admitted a stream's source datagrams, by packetId then catalog track name: recovered packets answer to it. */
   #provenanceStreamFlow = /* @__PURE__ */ new Map();
   #unregisteredFlowDrops = 0;
@@ -20219,6 +20275,7 @@ var MmtpRouter = class {
     if (verdict === "admitted") return "admitted";
     if (verdict === "held") {
       this.#heldReplay.set(packet, replay);
+      this.#heldAt.set(packet, performance.now());
       return "held";
     }
     this.#unadmittedListedDrops++;
@@ -20237,9 +20294,14 @@ var MmtpRouter = class {
       this.#noteFlowAdmitted(flow);
       this.#withDeferredFecPokes(() => {
         for (const datagram of result.admitted) {
-          const replay = this.#heldReplay.get(datagram);
-          if (replay) replay();
-          else this.#processMMTP(datagram, "multicast", true, this.#heldIngress.get(datagram) ?? entry.ingress, false, true);
+          const route = () => {
+            const replay = this.#heldReplay.get(datagram);
+            if (replay) replay();
+            else this.#processMMTP(datagram, "multicast", true, this.#heldIngress.get(datagram) ?? entry.ingress, false, true);
+          };
+          const heldAt = this.#heldAt.get(datagram);
+          if (heldAt !== void 0 && this.#fecManager?.withReceiptTime) this.#fecManager.withReceiptTime(heldAt, route);
+          else route();
         }
       });
     }
@@ -20490,10 +20552,11 @@ var MmtpRouter = class {
       catalogTrackName
     );
     if (recovered && !alreadyCompleted) {
-      fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
-      fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
-      fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-      this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName);
+      this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
+        fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
+        fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
+        fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
+      });
     }
   }
   /**
@@ -20534,10 +20597,11 @@ var MmtpRouter = class {
       const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
       const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, catalogTrackName);
       if (!recovered || alreadyCompleted) continue;
-      fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
-      fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
-      fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
-      this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName);
+      this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
+        fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
+        fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
+        fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
+      });
     }
   }
   #resolveRepairOwnerPacketId(packetId, ingress) {
@@ -20560,14 +20624,18 @@ var MmtpRouter = class {
    *  Sync WASM decoders return the block's K' = SSB_length fixed-width
    *  ssbg_mode1 source symbols concatenated. */
   routeRecoveredBlock(blockId, data, packetId, catalogTrackName) {
-    this.#withDeferredFecPokes(() => this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName));
+    let recovered = false;
+    this.#withDeferredFecPokes(() => {
+      recovered = this.#routeRecoveredBlock(blockId, data, packetId, catalogTrackName);
+    });
+    return recovered;
   }
   /** Route a single recovered source symbol through the parser + dedup pipeline.
    *  Worker-backed decoders emit one padded source symbol per frame event. */
   routeRecoveredSymbol(blockId, data, packetId, esi = 0, catalogTrackName) {
     const blockProfile = this.#blockProfileFor(packetId);
     const result = processFecSymbol(data, { ownerPacketId: packetId, index: esi, blockProfile });
-    this.#routeVerifiedFecSymbols(blockId, result, packetId, catalogTrackName);
+    return this.#routeVerifiedFecSymbols(blockId, result, packetId, catalogTrackName);
   }
   // ── Keyframe timer cancellation ─────────────────────────────────
   /** Cancel the active keyframe loss timer.
@@ -21239,7 +21307,10 @@ var MmtpRouter = class {
       if (verdict === "admitted") {
         this.#noteFlowAdmitted(ingress.flow);
         this.#processMMTP(packet, source, true, ingress, overlapCopy);
-      } else if (verdict === "held") this.#heldIngress.set(packet, ingress);
+      } else if (verdict === "held") {
+        this.#heldIngress.set(packet, ingress);
+        this.#heldAt.set(packet, performance.now());
+      }
       return;
     }
     if (source === "moq" && !manifestAdmitted) {
@@ -21422,36 +21493,22 @@ var MmtpRouter = class {
           sourceFec.symbolData,
           catalogTrackName
         );
-        if (recovered) {
-          if (!alreadyCompleted && this.#classifyPacketId(info.packetId) !== null) {
+        if (recovered && !alreadyCompleted) {
+          const fec = this.#fecManager;
+          const sbn = sourceFec.sbn;
+          const packetId = info.packetId;
+          const tracked = this.#classifyPacketId(packetId) !== null;
+          this.#routeRecoveredBlock(sbn, recovered, packetId, catalogTrackName, () => {
             if (catalogTrackName === void 0) {
-              this.#fecManager.cancelBlockTimeout(sourceFec.sbn, info.packetId);
+              if (tracked) fec.cancelBlockTimeout(sbn, packetId);
+              fec.countRecovery(packetId, sbn, catalogTrackName);
+              fec.markBlockCompleted(sbn, packetId);
             } else {
-              this.#fecManager.cancelBlockTimeout(
-                sourceFec.sbn,
-                info.packetId,
-                catalogTrackName
-              );
+              if (tracked) fec.cancelBlockTimeout(sbn, packetId, catalogTrackName);
+              fec.countRecovery(packetId, sbn, catalogTrackName);
+              fec.markBlockCompleted(sbn, packetId, catalogTrackName);
             }
-          }
-          if (!alreadyCompleted) {
-            this.#fecManager.countRecovery(info.packetId, sourceFec.sbn, catalogTrackName);
-            if (catalogTrackName === void 0) {
-              this.#fecManager.markBlockCompleted(sourceFec.sbn, info.packetId);
-            } else {
-              this.#fecManager.markBlockCompleted(
-                sourceFec.sbn,
-                info.packetId,
-                catalogTrackName
-              );
-            }
-            this.#routeRecoveredBlock(
-              sourceFec.sbn,
-              recovered,
-              info.packetId,
-              catalogTrackName
-            );
-          }
+          });
         }
       }
     }
@@ -21827,7 +21884,7 @@ var MmtpRouter = class {
   }
   // ── Private: FEC recovery routing ───────────────────────────────
   /** Route WASM-recovered block through appropriate path based on container kind. */
-  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName) {
+  #routeRecoveredBlock(blockId, recovered, ownerPacketId, catalogTrackName, complete) {
     const packetSymbolSize = this.#symbolSizeForPacket(ownerPacketId);
     if (ownerPacketId === void 0) {
       throw new Error("[MmtpRouter] a recovered FEC block needs its owner packetId to read its fec.blockProfile");
@@ -21844,31 +21901,46 @@ var MmtpRouter = class {
       ownerPacketId,
       blockProfile
     });
-    this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName);
+    return this.#routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete);
   }
   /**
    * A recovered source packet of a protected flow is admitted on its own
    * digest: its bytes with the SS_ID it was sent with (SS_Start + ESI)
    * appended are the datagram the record listed (7.2.7). One that no record
    * lists is dropped; holding it would let it out later as a multicast arrival.
+   * Returns whether the decode recovered the block: every packet it yields
+   * that this router has not parsed already is admitted. A block one of whose
+   * recovered packets is refused is unrecovered (7.2.7): its caller leaves it
+   * open, so it reaches its FEC deadline and fails by class. Always true
+   * outside a protected flow.
    */
-  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName) {
+  #routeVerifiedFecSymbols(blockId, result, ownerPacketId, catalogTrackName, complete) {
     const receiver = ownerPacketId == null ? void 0 : this.#provenanceFor(ownerPacketId, catalogTrackName);
-    if (receiver === "ambiguous") {
-      this.#ambiguousRecoveredDrops += result.symbols.length;
-      result = { ...result, symbols: [] };
-    } else if (receiver) {
+    let recovered = true;
+    if (receiver) {
+      const parsed = this.#stream(ownerPacketId, catalogTrackName).duplicates.parsedSymbols;
       result = {
         ...result,
         symbols: result.symbols.filter((sym) => {
-          const wire = new Uint8Array(sym.rawSymbol.byteLength + 4);
-          wire.set(sym.rawSymbol);
-          new DataView(wire.buffer).setUint32(sym.rawSymbol.byteLength, this.#fecAnchorForRecovered(blockId, sym.index));
-          return receiver.admitRecovered(wire);
+          const ssId = this.#fecAnchorForRecovered(blockId, sym.index);
+          if (parsed.has(ssId)) return false;
+          let admitted = false;
+          if (receiver === "ambiguous") {
+            this.#ambiguousRecoveredDrops++;
+          } else {
+            const wire = new Uint8Array(sym.rawSymbol.byteLength + 4);
+            wire.set(sym.rawSymbol);
+            new DataView(wire.buffer).setUint32(sym.rawSymbol.byteLength, ssId);
+            admitted = receiver.admitRecovered(wire);
+          }
+          if (!admitted) recovered = false;
+          return admitted;
         })
       };
     }
+    if (recovered) complete?.();
     this.#routeProcessedFecSymbols(blockId, result, ownerPacketId, catalogTrackName);
+    return recovered;
   }
   /**
    * The receiver a recovered packet of `packetId` answers to: the flow that
@@ -26928,17 +27000,7 @@ var MulticastManager = class {
     this.#fec.onBlockRecovered = (sbn, packetId, data, meta, recoveredTrackName) => {
       const recovered = new Uint8Array(data);
       const catalogTrackName = recoveredTrackName ?? this.#fec.catalogTrackNameForBlock(sbn, packetId);
-      if (catalogTrackName === void 0) {
-        this.#router.routeRecoveredSymbol(sbn, recovered, packetId, meta.esi);
-      } else {
-        this.#router.routeRecoveredSymbol(
-          sbn,
-          recovered,
-          packetId,
-          meta.esi,
-          catalogTrackName
-        );
-      }
+      return catalogTrackName === void 0 ? this.#router.routeRecoveredSymbol(sbn, recovered, packetId, meta.esi) : this.#router.routeRecoveredSymbol(sbn, recovered, packetId, meta.esi, catalogTrackName);
     };
     this.#fec.onRepairResolved = (sbn, packetId, _outcome, catalogTrackName) => {
       this.clearRepairForBlock(sbn, packetId, catalogTrackName);
@@ -27916,11 +27978,11 @@ var MulticastManager = class {
   }
   /** Route a Worker-recovered FEC block through the MMTP parser + dedup pipeline. */
   routeRecoveredBlock(blockId, data, packetId, catalogTrackName) {
-    this.#router.routeRecoveredBlock(blockId, data, packetId, catalogTrackName);
+    return this.#router.routeRecoveredBlock(blockId, data, packetId, catalogTrackName);
   }
   /** Route one Worker-recovered source symbol through the MMTP parser + dedup pipeline. */
   routeRecoveredSymbol(blockId, data, packetId, esi = 0, catalogTrackName) {
-    this.#router.routeRecoveredSymbol(blockId, data, packetId, esi, catalogTrackName);
+    return this.#router.routeRecoveredSymbol(blockId, data, packetId, esi, catalogTrackName);
   }
   // ---------------------------------------------------------------------------
   // Phase 14: multi-track catalog ingest (D-04, D-06, D-07, D-17, D-26, D-28)