@blockcast/mmt-container 2.0.0-main.609e08d7e29f → 2.0.1-main.0f2de6af487b

package/README.md

@@ -277,7 +277,7 @@ per-commit `0.1.0-main.<sha>` prerelease from `stamp-prerelease.mjs`), and a
 > Superseded by BLO-40665. Every package is now bumped in lockstep by a `v*`
 > tag and the sibling ranges move with it, so the objection above no longer
 > applies -- it was an argument against bumping *one* package. The set is at
-> `2.0.0`; see `RELEASES.md`.
+> `2.0.1`; see `RELEASES.md`.
 
 #### Track-role convention (Phase 14)
 

package/dist/browser-runtime.js

@@ -22647,6 +22647,14 @@ var MmtpRouter = class {
   #packetIdRoles = /* @__PURE__ */ new Map();
   /** Explicit catalog ownership for dedicated repair-track packet IDs. */
   #repairOwnersByPacketId = /* @__PURE__ */ new Map();
+  /** Keyframe-overlay repair PID → the source its FEC instance protects
+   *  (draft-ramadan-mmt-fec-02 7.4.1). Never an owner in
+   *  #repairOwnersByPacketId: the overlay is decoded as its own instance. */
+  #overlayLegs = /* @__PURE__ */ new Map();
+  /** Keyframe-overlay repair track names, which name a leg too: a catalog
+   *  may state no PID for it (learned at subscribe time). */
+  #overlayRepairNames = /* @__PURE__ */ new Map();
+  #overlayStats = { repairDropped: 0, ownerRefused: 0 };
   /** Callback fired when a delta-track FEC block completes or fails. */
   #onDeltaBlockCompleteCb = null;
   // Debug counters
@@ -23165,13 +23173,53 @@ var MmtpRouter = class {
   /** Replace catalog-derived repair ownership before a catalog reconfiguration. */
   clearRepairPacketIdOwners() {
     this.#repairOwnersByPacketId.clear();
+    this.#overlayLegs.clear();
+    this.#overlayRepairNames.clear();
   }
-  /** Bind one dedicated repair-track PID to its authoritative media PID. */
+  /** Bind one dedicated repair-track PID to its authoritative media PID. A
+   *  known keyframe-overlay PID is refused, and counted: its symbols belong to
+   *  the overlay instance, never to the source's base decoder (mmt-02 7.4.4). */
   setRepairPacketIdOwner(repairPacketId, ownerPacketId) {
+    if (this.#overlayLegs.has(repairPacketId)) {
+      this.#overlayStats.ownerRefused++;
+      return;
+    }
     const owners = this.#repairOwnersByPacketId.get(repairPacketId) ?? /* @__PURE__ */ new Set();
     owners.add(ownerPacketId);
     this.#repairOwnersByPacketId.set(repairPacketId, owners);
   }
+  /**
+   * Record a keyframe-overlay repair leg (draft-ramadan-mmt-fec-02 7.4): its
+   * PID, the source it protects, and its repair track name. Either one names
+   * the leg, so a catalog that states no PID (learned at subscribe time) is
+   * covered by the name. Overlay repair is then never resolved to a base
+   * owner, on multicast or MoQ. Cleared with the catalog owners
+   * (`clearRepairPacketIdOwners`).
+   */
+  setKeyframeOverlayLeg(repairPacketId, leg) {
+    if (leg.repairTrackName !== void 0) this.#overlayRepairNames.set(leg.repairTrackName, { ...leg });
+    if (repairPacketId === void 0) return;
+    this.#repairOwnersByPacketId.delete(repairPacketId);
+    this.#overlayLegs.set(repairPacketId, { ...leg });
+  }
+  /** The keyframe-overlay leg registered on `repairPacketId`, if any. */
+  keyframeOverlayLeg(repairPacketId) {
+    return this.#overlayLegs.get(repairPacketId);
+  }
+  /** Overlay repair dropped for want of an overlay instance, and base-owner
+   *  registrations refused on an overlay PID. */
+  get keyframeOverlayStats() {
+    return { ...this.#overlayStats };
+  }
+  #isOverlayRepair(repairPacketId, repairTrackName) {
+    return this.#overlayLegs.has(repairPacketId) || repairTrackName !== void 0 && this.#overlayRepairNames.has(repairTrackName);
+  }
+  /** Overlay repair has no decoder until the overlay instance lands
+   *  (BLO-52077 PR 2): drop it before any base owner, locator or decoder. */
+  #dropOverlayRepair(repairPacketId) {
+    this.#overlayStats.repairDropped++;
+    debugRouter(`[MmtpRouter] Dropping keyframe-overlay repair pid=${repairPacketId}: no overlay instance`);
+  }
   /**
    * Register callback fired when a delta-track FEC block completes or fails.
    *
@@ -23595,6 +23643,10 @@ var MmtpRouter = class {
       return;
     }
     const repairPacketId = header.packetId;
+    if (this.#isOverlayRepair(repairPacketId, repairTrackName)) {
+      this.#dropOverlayRepair(repairPacketId);
+      return;
+    }
     const hintedOwner = ownerPacketIdHint != null && this.#classifyPacketId(ownerPacketIdHint) !== null ? ownerPacketIdHint : null;
     const ownerPacketId = hintedOwner ?? (this.#classifyPacketId(repairPacketId) !== null ? repairPacketId : null);
     if (ownerPacketId === null) {
@@ -23970,6 +24022,13 @@ var MmtpRouter = class {
     this.#packetIdRoles.delete(packetId);
     this.#catalogTrackNamesByPacketId.delete(packetId);
     this.#repairOwnersByPacketId.delete(packetId);
+    this.#overlayLegs.delete(packetId);
+    for (const [repairPacketId, leg] of [...this.#overlayLegs]) {
+      if (leg.sourcePacketId === packetId) this.#overlayLegs.delete(repairPacketId);
+    }
+    for (const [name, leg] of [...this.#overlayRepairNames]) {
+      if (leg.sourcePacketId === packetId) this.#overlayRepairNames.delete(name);
+    }
     delete this.#pidCounts[packetId];
     delete this.#repairPidCounts[packetId];
     delete this.#moqRepairPidCounts[packetId];
@@ -24208,6 +24267,8 @@ var MmtpRouter = class {
     this.#parserDiagnostics.clear();
     this.#catalogTrackNamesByPacketId.clear();
     this.#repairOwnersByPacketId.clear();
+    this.#overlayLegs.clear();
+    this.#overlayRepairNames.clear();
     for (const { receiver } of this.#provenance.values()) receiver.release();
     this.#provenance.clear();
     this.#provenanceStreamFlow.clear();
@@ -24563,6 +24624,10 @@ var MmtpRouter = class {
       }
     }
     if (info.isRepair) {
+      if (this.#isOverlayRepair(info.packetId, catalogTrackNameForPacket(ingress, info.packetId))) {
+        this.#dropOverlayRepair(info.packetId);
+        return;
+      }
       const ownerPacketId = this.#resolveRepairOwnerPacketId(info.packetId, ingress);
       if (ownerPacketId != null && this.#fecManager && hasAmbiguousCatalogTrackName(ingress, ownerPacketId)) return;
       const repair = this.#readRepairObject(
@@ -27193,9 +27258,7 @@ function repairTrackNamesBySource(tracks) {
 }
 function boundRepairNames(binding) {
   if (binding?.status !== "ok") return [];
-  const names = binding.layers.map((layer) => layer.repairTrackName);
-  if (binding.overlay) names.push(binding.overlay.repairTrackName);
-  return names;
+  return binding.layers.map((layer) => layer.repairTrackName);
 }
 var MulticastManager = class {
   #fec;
@@ -27961,7 +28024,11 @@ var MulticastManager = class {
         console.warn("[MulticastManager] repair group release failed", error);
       }
     };
-    const repairOwners = endpoints.flatMap((endpoint) => endpoint.repairOwners);
+    const repairOwners = endpoints.flatMap((endpoint) => endpoint.repairOwners.map((owner) => owner.instance !== "keyframe" ? owner : {
+      ...owner,
+      ownerTrackName: endpoint.tracks.find((t) => t.packetId === owner.ownerPacketId)?.name,
+      repairTrackName: endpoint.tracks.find((t) => t.packetId === owner.packetId)?.name
+    }));
     this.#applyRepairOwners(repairOwners);
     for (const endpoint of endpoints) {
       const ingress = {
@@ -28009,9 +28076,17 @@ var MulticastManager = class {
     return release;
   }
   #applyRepairOwners(owners) {
-    for (const { packetId, ownerPacketId } of owners) {
+    for (const { packetId, ownerPacketId, instance, ownerTrackName, repairTrackName } of owners) {
       this.#router.setPacketIdRole(packetId, "repair");
-      this.#router.setRepairPacketIdOwner(packetId, ownerPacketId);
+      if (instance === "keyframe") {
+        this.#router.setKeyframeOverlayLeg(packetId, {
+          sourcePacketId: ownerPacketId,
+          ...ownerTrackName === void 0 ? {} : { sourceCatalogTrackName: ownerTrackName },
+          ...repairTrackName === void 0 ? {} : { repairTrackName }
+        });
+      } else {
+        this.#router.setRepairPacketIdOwner(packetId, ownerPacketId);
+      }
     }
   }
   // ---------------------------------------------------------------------------
@@ -28275,8 +28350,8 @@ var MulticastManager = class {
     this.#fec.setMulticastSymbolDelivery(delivery);
   }
   /** Process a repair packet from MoQ (reliable QUIC). */
-  processRepairFromMoQ(packet, ownerPacketId, catalogTrackName) {
-    this.#router.feedRepairPacket(packet, ownerPacketId, catalogTrackName);
+  processRepairFromMoQ(packet, ownerPacketId, catalogTrackName, repairTrackName) {
+    this.#router.feedRepairPacket(packet, ownerPacketId, catalogTrackName, repairTrackName);
   }
   /** Route a Worker-recovered FEC block through the MMTP parser + dedup pipeline. */
   routeRecoveredBlock(blockId, data, packetId, catalogTrackName) {
@@ -28328,7 +28403,10 @@ var MulticastManager = class {
     const ownedRepairNames = /* @__PURE__ */ new Set();
     const claimed = /* @__PURE__ */ new Map();
     for (const binding of bindings.values()) {
-      for (const name of boundRepairNames(binding)) claimed.set(name, (claimed.get(name) ?? 0) + 1);
+      const overlay = binding.status === "ok" ? binding.overlay?.repairTrackName : void 0;
+      for (const name of [...boundRepairNames(binding), ...overlay === void 0 ? [] : [overlay]]) {
+        claimed.set(name, (claimed.get(name) ?? 0) + 1);
+      }
     }
     for (const [name, count] of claimed) if (count === 1) ownedRepairNames.add(name);
     const repairOwnerGroup = /* @__PURE__ */ new Map();
@@ -28459,6 +28537,14 @@ var MulticastManager = class {
               this.#router.setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
             }
           }
+          const overlayName = binding.overlay?.repairTrackName;
+          if (overlayName !== void 0 && ownedRepairNames.has(overlayName)) {
+            this.#router.setKeyframeOverlayLeg(catalogTracksByName.get(overlayName)?.packetId, {
+              sourcePacketId: track.packetId,
+              sourceCatalogTrackName: track.name,
+              repairTrackName: overlayName
+            });
+          }
         }
         const wasmDecoder = fecDecoders.get(i);
         if (track.packetId !== void 0 && wasmDecoder !== void 0) {