@blockcast/mmt-container 2.2.0-main.efb4fa4521af → 2.2.0-main.fb5c7dfbe2de

package/src/multicast-manager.ts

@@ -18,8 +18,10 @@ import {
   type FecFallbackDecoder,
   type MulticastSymbolDelivery,
   type RepairVia,
+  type ExpiredIsoHole,
   type UndelimitedIsoLoss,
   type FecFailClosedEvent,
+  type IsoSpanFailure,
 } from "./fec-manager.js";
 import {
   deriveBlockClassifierGeometry,
@@ -407,6 +409,14 @@ export type RepairLifecycleEvent =
       readonly block: RepairBlockIdentity;
       readonly blockClass: BlockClass;
       readonly symbols: RepairSymbolCounts;
+      /**
+       * Set when what failed is an iso-ssbg1-v1 repair-less span starting at
+       * `block.sbn`: `length` SS_IDs between two stated blocks, `sources` of
+       * them received. No repair stated the blocks inside it, so the receiver
+       * cannot tell which of them lost a source; it is not the failure of the
+       * block at `block.sbn` alone.
+       */
+      readonly span?: IsoSpanFailure;
     }
   | {
       readonly version: 2;
@@ -791,6 +801,19 @@ function isSymbolCounts(value: unknown): boolean {
   );
 }
 
+/** A failed repair-less span: `sources` of its `length` SS_IDs arrived, never all. */
+function isSpanFailure(value: unknown): boolean {
+  if (!isRecord(value) || !hasExactKeys(value, ["length", "sources"])) return false;
+  const length = value["length"];
+  const sources = value["sources"];
+  return (
+    Number.isSafeInteger(length) &&
+    (length as number) > 0 &&
+    isNonNegativeSafeInteger(sources) &&
+    (sources as number) < (length as number)
+  );
+}
+
 function isNullableNonNegative(value: unknown): boolean {
   return value === null || (typeof value === "number" && Number.isFinite(value) && value >= 0);
 }
@@ -833,10 +856,16 @@ export function isRepairLifecycleEvent(
       );
     case "failed":
       return (
-        hasExactKeys(value, ["version", "type", "block", "blockClass", "symbols"]) &&
+        hasExactKeys(
+          value,
+          "span" in value
+            ? ["version", "type", "block", "blockClass", "symbols", "span"]
+            : ["version", "type", "block", "blockClass", "symbols"],
+        ) &&
         isRepairBlockIdentity(block) &&
         BLOCK_CLASSES.has(value["blockClass"]) &&
-        isSymbolCounts(value["symbols"])
+        isSymbolCounts(value["symbols"]) &&
+        (!("span" in value) || isSpanFailure(value["span"]))
       );
     case "repair-preempted":
     case "repair-deferred":
@@ -1366,7 +1395,7 @@ export class MulticastManager {
       onPublisherRestart: (packetId, catalogTrackName) => {
         this.#resetStreamOutsideRouter(packetId, catalogTrackName);
       },
-      onBlockFailed: (sbn, packetId, catalogTrackName, blockClass) => {
+      onBlockFailed: (sbn, packetId, catalogTrackName, blockClass, span) => {
         const pathCount = this.#fec.blockPathCount(
           sbn,
           packetId,
@@ -1385,6 +1414,7 @@ export class MulticastManager {
             multicast: pathCount?.multicastSymbols ?? 0,
             moq: pathCount?.moqSymbols ?? 0,
           },
+          ...(span === undefined ? {} : { span }),
         });
       },
       onFrameGap: (decision) => {
@@ -3193,10 +3223,15 @@ export class MulticastManager {
    * Register the range repair scheduler (draft-ramadan-moq-fec §7.5): from now
    * on an iso-ssbg1-v1 gap missing a source and every repair is kept as a
    * pending hole and reported here, and `closeIsoHoles` must be called for it
-   * once its range FETCH ends (or none is sent).
+   * once its range FETCH ends (or none is sent). `onExpired` is told of a
+   * pending hole the stream runs past the locator's horizon: returning true,
+   * the caller closes it (`closeIsoHoles`); otherwise it is discarded.
    */
-  onUndelimitedLoss(cb: (loss: UndelimitedIsoLoss) => void): void {
-    this.#fec.setUndelimitedLossHandler(cb);
+  onUndelimitedLoss(
+    cb: (loss: UndelimitedIsoLoss) => void,
+    onExpired?: (hole: ExpiredIsoHole) => boolean,
+  ): void {
+    this.#fec.setUndelimitedLossHandler(cb, onExpired ?? null);
   }
 
   /**
@@ -3515,6 +3550,9 @@ export class MulticastManager {
                 ...("symbols" in event
                   ? { symbols: Object.freeze({ ...event.symbols }) }
                   : {}),
+                ...("span" in event && event.span !== undefined
+                  ? { span: Object.freeze({ ...event.span }) }
+                  : {}),
               },
         ) as RepairLifecycleEvent);
     // Serialize before invoking observers so a re-entrant observer cannot log