@blockcast/mmt-container 0.1.0-main.f24ff7b49949 → 0.1.0-main.f8328f38cfb6

package/dist/browser-runtime.js

@@ -143,8 +143,8 @@ var init_fec_worker_client = __esm({
        * Caller must not access data after this call — it is detached.
        *
        * Carries the wire-level Repair FEC Payload ID fields (ISO 23008-1 §C.5.3):
-       * - ssStart:   SS_ID of first source symbol in the block (= SBN * SSB_length)
-       * - ssbLength: K for this block
+       * - ssStart:   SS_ID of first source symbol in the block (= SBN * configured K)
+       * - ssbLength: authored source-symbol count (1..configured K)
        * - rsId:      repair symbol index within the block
        */
       feedRepair(ssStart, ssbLength, rsId, data, ts) {
@@ -9322,6 +9322,24 @@ var TrackSession = class {
   get isFecArmed() {
     return __privateGet(this, _fecArmed);
   }
+  /**
+   * Start the deadline a `joining` entry deferred while the join was inactive
+   * (SessionManager.joinActive). The track gets the FULL deadline from here,
+   * because that is when media can first arrive. No-op outside `joining` and
+   * when a deadline is already running, so it never shortens or restarts one.
+   *
+   * The `joinActive` guard is what makes this safe to call from anywhere: a
+   * track parked in `joining` with a deferred (null) timer satisfies the other
+   * two, so without it a host calling this while the join is still inactive
+   * would arm the exact deadline the gate exists to defer -- silently
+   * reinstating BLO-34289. It is a no-op for the internal caller, which writes
+   * `#joinActive = true` before iterating the sessions.
+   */
+  armDeferredJoinDeadline() {
+    if (__privateGet(this, _state) !== "joining" || __privateGet(this, _joinDeadlineTimer) !== null) return;
+    if (!__privateGet(this, _manager).joinActive) return;
+    __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, __privateGet(this, _manager).takeoverDeadlineMs);
+  }
   dispose() {
     __privateMethod(this, _TrackSession_instances, clearHysteresis_fn).call(this);
     __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
@@ -9348,7 +9366,9 @@ transition_fn = function(to, opts) {
   const joinDeadlineMs = to === "joining" ? __privateGet(this, _manager).takeoverDeadlineMs : void 0;
   __privateSet(this, _state, to);
   if (from === "joining") __privateMethod(this, _TrackSession_instances, clearJoinDeadline_fn).call(this);
-  if (joinDeadlineMs !== void 0) __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, joinDeadlineMs);
+  if (joinDeadlineMs !== void 0 && __privateGet(this, _manager).joinActive) {
+    __privateMethod(this, _TrackSession_instances, armJoinDeadline_fn).call(this, joinDeadlineMs);
+  }
   const fecActive = (s) => s === "joining" || s === "multicast" || s === "amt" || s === "failing" || s === "unicast-fallback";
   if (!fecActive(to) && !opts?.retainFec) __privateMethod(this, _TrackSession_instances, disarmFec_fn).call(this);
   __privateGet(this, _manager).callbacks?.onStateChange?.(this.config.trackName, from, to);
@@ -9400,13 +9420,16 @@ unsuppress_fn = function() {
   __privateGet(this, _manager).callbacks?.onSuppress?.(this.config.trackName, false);
 };
 var MAX_TAKEOVER_DEADLINE_MS = 2147483647;
-var _takeoverDeadlineMs, _SessionManager_instances, requireTakeoverDeadlineMs_fn;
+var JOIN_DEFER_WARN_MS = 3e4;
+var _takeoverDeadlineMs, _joinActive, _joinDeferWarnTimer, _SessionManager_instances, armJoinDeferWarn_fn, clearJoinDeferWarn_fn, requireTakeoverDeadlineMs_fn;
 var SessionManager = class {
   constructor(poolOptions) {
     __privateAdd(this, _SessionManager_instances);
     this.sessions = /* @__PURE__ */ new Map();
     this.callbacks = null;
     __privateAdd(this, _takeoverDeadlineMs);
+    __privateAdd(this, _joinActive, true);
+    __privateAdd(this, _joinDeferWarnTimer, null);
     this.pool = new TransportPool(poolOptions);
     this.pool.onSubscriptionFailed((sub) => {
       for (const trackName of sub.consumers) {
@@ -9455,6 +9478,46 @@ var SessionManager = class {
   get hasTakeoverDeadline() {
     return __privateGet(this, _takeoverDeadlineMs) !== void 0;
   }
+  /**
+   * Whether the transport the joining tracks are waiting on is actually
+   * subscribed. The takeover deadline is a media-arrival budget and media
+   * cannot arrive before the join exists, so while this is false, entering
+   * `joining` arms no deadline; flipping it true starts the FULL deadline for
+   * every track already parked there.
+   *
+   * Default true, which is the arm-on-`joining` behaviour every host had
+   * before: a host that only calls joinStarted() after its own join resolves
+   * (moqtail-private's player, post-BLO-33339) is already at the right edge and
+   * needs no gate. A host that arms joinStarted() up front — to have FEC
+   * decoders ready before the first datagram — sets this false before addTrack()
+   * and true when its subscribe settles. Charging a slow subscribe (bridge
+   * reconnect, AMT relay handshake) against the media budget expired the
+   * deadline before the subscription existed and abandoned the join on the
+   * happy path. BLO-34289.
+   *
+   * The flag tracks the host's primary join, not per-track transport state. A
+   * track that fails over to the next transport in its own chain while this is
+   * false (transportFailed's failover branch also enters `joining`) has that
+   * deadline gated on the primary join activating, not on its own transport.
+   * Under the documented usage -- false once at setup, true once the subscribe
+   * settles -- the two coincide.
+   *
+   * Leaving this false is not free: see JOIN_DEFER_WARN_MS.
+   */
+  get joinActive() {
+    return __privateGet(this, _joinActive);
+  }
+  set joinActive(active) {
+    const wasActive = __privateGet(this, _joinActive);
+    __privateSet(this, _joinActive, active);
+    if (!active) {
+      if (wasActive) __privateMethod(this, _SessionManager_instances, armJoinDeferWarn_fn).call(this);
+      return;
+    }
+    __privateMethod(this, _SessionManager_instances, clearJoinDeferWarn_fn).call(this);
+    if (wasActive) return;
+    for (const [, session] of this.sessions) session.armDeferredJoinDeadline();
+  }
   /** Narrow to MMTP callbacks (onTrackEvent). Safe — optional chaining handles PIM-only consumers. */
   get mmtp() {
     return this.callbacks;
@@ -9608,6 +9671,7 @@ var SessionManager = class {
   // Cleanup
   // -----------------------------------------------------------------------
   dispose() {
+    __privateMethod(this, _SessionManager_instances, clearJoinDeferWarn_fn).call(this);
     for (const [, session] of this.sessions) {
       session.dispose();
     }
@@ -9617,7 +9681,23 @@ var SessionManager = class {
   }
 };
 _takeoverDeadlineMs = new WeakMap();
+_joinActive = new WeakMap();
+_joinDeferWarnTimer = new WeakMap();
 _SessionManager_instances = new WeakSet();
+armJoinDeferWarn_fn = function() {
+  __privateSet(this, _joinDeferWarnTimer, setTimeout(() => {
+    __privateSet(this, _joinDeferWarnTimer, null);
+    const deferred = [...this.sessions.values()].filter((s) => s.state === "joining").length;
+    console.warn(
+      `[SessionManager] joinActive has been false for ${JOIN_DEFER_WARN_MS} ms and ${deferred} track(s) sit in 'joining' with no takeover deadline. Set joinActive = true when the subscribe settles, on every exit path including failures, or these tracks never time out, never release their FEC decoders, and never advance to the next transport.`
+    );
+  }, JOIN_DEFER_WARN_MS));
+};
+clearJoinDeferWarn_fn = function() {
+  if (__privateGet(this, _joinDeferWarnTimer) === null) return;
+  clearTimeout(__privateGet(this, _joinDeferWarnTimer));
+  __privateSet(this, _joinDeferWarnTimer, null);
+};
 // -----------------------------------------------------------------------
 // Track management
 // -----------------------------------------------------------------------
@@ -9965,6 +10045,7 @@ var FECManager = class {
     const k = this.kForPacket(packetId);
     const isSourceSymbol = esi >= 0 && esi < k;
     const isStartupPartial = __privateGet(this, _startupPartialBlocks).has(blockKey);
+    const isReadyMulticastRepair = __privateGet(this, _startupRequireRepairReady) && source === "multicast" && !isSourceSymbol && __privateGet(this, _startupRepairReadyPackets).has(streamKey);
     const awaitingMulticastRepair = __privateGet(this, _startupRequireRepairReady) && source === "multicast" && !__privateGet(this, _startupRepairReadyPackets).has(streamKey) && !__privateGet(this, _startupRepairFailOpenPackets).has(streamKey);
     if (awaitingMulticastRepair) {
       if (!isSourceSymbol) {
@@ -9991,7 +10072,7 @@ var FECManager = class {
     if (isSourceSymbol && esi === 0) {
       __privateGet(this, _startupPartialBlocks).delete(blockKey);
       __privateGet(this, _startupAlignedPackets).add(streamKey);
-    } else if (isStartupPartial || !__privateGet(this, _startupAlignedPackets).has(streamKey)) {
+    } else if (isStartupPartial && !isReadyMulticastRepair || !__privateGet(this, _startupAlignedPackets).has(streamKey) && !isReadyMulticastRepair) {
       __privateMethod(this, _FECManager_instances, markStartupPartial_fn).call(this, blockKey);
       return false;
     }
@@ -10406,14 +10487,10 @@ var FECManager = class {
       return null;
     }
     const fecData = repairData;
-    if (ssbLength > 1) {
-      this.noteBlockActivity(
-        Math.floor(ssStart / ssbLength),
-        packetId,
-        catalogTrackName
-      );
-    }
-    const sbn = ssbLength > 0 ? Math.floor(ssStart / ssbLength) : 0;
+    const k = this.kForPacket(packetId);
+    if (ssbLength <= 0 || ssbLength > k || ssStart % k !== 0) return null;
+    const sbn = Math.floor(ssStart / k);
+    this.noteBlockActivity(sbn, packetId, catalogTrackName);
     const blockKey = __privateMethod(this, _FECManager_instances, blockKey_fn).call(this, sbn, packetId, catalogTrackName);
     if (__privateGet(this, _completedBlocks).has(blockKey)) return null;
     const syncBlockOwner = __privateGet(this, _syncDecoderBlockOwners).get(blockKey);
@@ -10449,15 +10526,6 @@ var FECManager = class {
     if (recovered) __privateGet(this, _syncDecoderBlockOwners).delete(blockKey);
     return recovered;
   }
-  /**
-   * Unified symbol feeder. Dispatches to feedSourceSymbol or feedRepairSymbol.
-   */
-  feedSymbol(packetId, symbolId, data, isRepair) {
-    if (isRepair) {
-      return this.feedRepairSymbol(packetId, symbolId, 1, symbolId, data);
-    }
-    return this.feedSourceSymbol(packetId, symbolId, data);
-  }
   // -----------------------------------------------------------------------
   // Block lifecycle
   // -----------------------------------------------------------------------
@@ -13564,6 +13632,7 @@ var MmtpRouter = class {
         );
       }
       const repairSbn = __privateMethod(this, _MmtpRouter_instances, deriveRepairSbn_fn).call(this, parsed.ssStart, parsed.ssbLength, ownerPacketId);
+      if (repairSbn === null) return;
       const repairEsi = __privateMethod(this, _MmtpRouter_instances, kForPacket_fn).call(this, ownerPacketId) + parsed.rsId;
       if (!__privateMethod(this, _MmtpRouter_instances, feedFecTransportSymbol_fn).call(this, ownerPacketId, repairSbn, repairEsi, parsed.repairData, "moq", catalogTrackName)) return;
       const recovered = catalogTrackName === void 0 ? __privateGet(this, _fecManager).feedRepairSymbol(
@@ -13594,7 +13663,7 @@ var MmtpRouter = class {
           } else {
             __privateGet(this, _fecManager).markBlockCompleted(repairSbn, ownerPacketId, catalogTrackName);
           }
-          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, repairSbn, recovered, ownerPacketId, parsed.ssbLength, catalogTrackName);
+          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, repairSbn, recovered, ownerPacketId, catalogTrackName);
         }
       }
     }
@@ -13602,7 +13671,7 @@ var MmtpRouter = class {
   /** Route a recovered FEC block through the parser + dedup pipeline.
    *  Sync WASM decoders return K fixed-width source symbols concatenated. */
   routeRecoveredBlock(blockId, data, packetId, catalogTrackName) {
-    __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, blockId, data, packetId, void 0, catalogTrackName);
+    __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, blockId, data, packetId, catalogTrackName);
   }
   /** Route a single recovered source symbol through the parser + dedup pipeline.
    *  Worker-backed decoders emit one padded source symbol per frame event. */
@@ -13761,8 +13830,9 @@ deriveSbnEsi_fn = function(ssId, packetId) {
   return { sbn: Math.floor(ssId / k), esi: ssId % k };
 };
 deriveRepairSbn_fn = function(ssStart, ssbLength, packetId) {
-  if (ssbLength > 0) return Math.floor(ssStart / ssbLength);
-  return __privateMethod(this, _MmtpRouter_instances, deriveSbnEsi_fn).call(this, ssStart, packetId).sbn;
+  const k = __privateMethod(this, _MmtpRouter_instances, kForPacket_fn).call(this, packetId);
+  if (ssbLength <= 0 || ssbLength > k || ssStart % k !== 0) return null;
+  return Math.floor(ssStart / k);
 };
 resolveRepairOwnerPacketId_fn = function(packetId, ingress) {
   if (__privateMethod(this, _MmtpRouter_instances, classifyPacketId_fn).call(this, packetId) !== null) return packetId;
@@ -13921,6 +13991,7 @@ processMMTP_fn = function(packet, source, manifestIdentity, manifestAdmitted = f
         );
       }
       const repairSbn = __privateMethod(this, _MmtpRouter_instances, deriveRepairSbn_fn).call(this, parsed.ssStart, parsed.ssbLength, ownerPacketId);
+      if (repairSbn === null) return;
       const repairEsi = __privateMethod(this, _MmtpRouter_instances, kForPacket_fn).call(this, ownerPacketId) + parsed.rsId;
       if (!__privateMethod(this, _MmtpRouter_instances, feedFecTransportSymbol_fn).call(this, ownerPacketId, repairSbn, repairEsi, parsed.repairData, source, catalogTrackNameForPacket(ingress, ownerPacketId))) return;
       const repairCatalogTrackName = catalogTrackNameForPacket(ingress, ownerPacketId);
@@ -13973,7 +14044,7 @@ processMMTP_fn = function(packet, source, manifestIdentity, manifestAdmitted = f
               repairCatalogTrackName
             );
           }
-          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, repairSbn, recovered, ownerPacketId, parsed.ssbLength, catalogTrackNameForPacket(ingress, ownerPacketId));
+          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, repairSbn, recovered, ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId));
         }
       }
     }
@@ -14089,7 +14160,7 @@ processMMTP_fn = function(packet, source, manifestIdentity, manifestAdmitted = f
               catalogTrackName
             );
           }
-          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, sourceFec.sbn, recovered, info.packetId, void 0, catalogTrackName);
+          __privateMethod(this, _MmtpRouter_instances, routeRecoveredBlock_fn).call(this, sourceFec.sbn, recovered, info.packetId, catalogTrackName);
         }
       }
     }
@@ -14437,8 +14508,8 @@ routeDirectRecoveredAudio_fn = function(packetId, data, meta, cb) {
 };
 // ── Private: FEC recovery routing ───────────────────────────────
 /** Route WASM-recovered block through appropriate path based on container kind. */
-routeRecoveredBlock_fn = function(blockId, recovered, ownerPacketId, blockK, catalogTrackName) {
-  const k = blockK ?? __privateMethod(this, _MmtpRouter_instances, kForPacket_fn).call(this, ownerPacketId);
+routeRecoveredBlock_fn = function(blockId, recovered, ownerPacketId, catalogTrackName) {
+  const k = __privateMethod(this, _MmtpRouter_instances, kForPacket_fn).call(this, ownerPacketId);
   const packetSymbolSize = __privateMethod(this, _MmtpRouter_instances, symbolSizeForPacket_fn).call(this, ownerPacketId);
   const symbolSize = packetSymbolSize > 0 ? packetSymbolSize : void 0;
   const result = processFecBlock(recovered, {
@@ -19946,6 +20017,7 @@ export {
   FEC_SBN_MAX,
   FecSourceInfo,
   FecStarvationDetector,
+  JOIN_DEFER_WARN_MS,
   KEYFRAME_LOST_TIMEOUT_SLACK,
   LOCHeaderExtensionId,
   MAX_ENCODING_SYMBOL_ID,