@blockcast/mmt-container 0.5.0-main.6f3380bce0c1 → 0.5.0-main.8fbc25eb9deb

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();
@@ -13747,6 +13750,7 @@ var FECManager = class _FECManager {
   #seenSymbols;
   #blockPathCounts;
   #blockAnchorsMs;
+  #receiptAtMs;
   #blockCatalogTrackNames;
   #startupAlignedPackets;
   #startupPartialBlocks;
@@ -14238,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) {
@@ -14258,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) {
@@ -14662,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);
@@ -15292,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);
@@ -16567,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;
@@ -19452,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;
@@ -20237,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++;
@@ -20255,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();
         }
       });
     }
@@ -21263,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) {