@blockcast/mmt-container 0.5.0-main.ed11aec88d91 → 0.5.0

package/dist/browser-runtime.js

@@ -17655,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;
@@ -17716,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");
@@ -17756,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) {
@@ -17846,7 +17871,8 @@ var FecReleaseSequencer = class {
         buf: [],
         last: null,
         lastSbn: void 0,
-        discontinuity: false
+        discontinuity: false,
+        rapSsId: void 0
       };
       this.#streams.set(streamKey, stream);
     }
@@ -18209,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;
@@ -19605,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.
@@ -21263,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) {
@@ -21308,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;
@@ -26756,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,
@@ -26842,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 = {
@@ -26901,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"];
@@ -28491,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,
@@ -28551,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);
@@ -28566,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 }
       };
     }
@@ -30929,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;
@@ -30953,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);
     }
@@ -30997,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,
@@ -31042,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) => {
@@ -31172,7 +31290,6 @@ function wireRepairFetch(mc, opts) {
         stop(entry2, "reprioritized");
         start(entry2, false);
       }
-      preemptDeltas();
       dispatch();
       return;
     }
@@ -31304,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) => {
@@ -31380,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);