@blockcast/mmt-container 0.1.0-main.f2d8d03d6809 → 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) {
@@ -1936,6 +1936,62 @@ if (void 0) {
       expect(out?.data).toEqual(new Uint8Array([161, 162]));
       expect(out?.sampleOffset).toBe(4);
     });
+    test("a mid-data-unit packet sequence gap strands the data unit", () => {
+      const reassembler = new MFUReassembler({ timeoutMs: null, maxBuffered: 10 });
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 1,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 2,
+          movieFragmentSequenceNumber: 9,
+          sampleNumber: 17,
+          sampleOffset: 0,
+          packetSequenceNumber: 100,
+          data: new Uint8Array([161]),
+          timestamp: 1100n,
+          rapFlag: true
+        })
+      ).toBeNull();
+      const interleaved = reassembler.addFragment({
+        fragmentationIndicator: 0,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        movieFragmentSequenceNumber: 9,
+        sampleNumber: 18,
+        sampleOffset: 0,
+        packetSequenceNumber: 101,
+        data: new Uint8Array([255]),
+        timestamp: 1101n,
+        rapFlag: true
+      });
+      expect(interleaved?.data).toEqual(new Uint8Array([255]));
+      expect(
+        reassembler.addFragment({
+          fragmentationIndicator: 2,
+          mpuSequenceNumber: 7,
+          fragmentCounter: 1,
+          packetSequenceNumber: 102,
+          data: new Uint8Array([162]),
+          timestamp: 1102n,
+          rapFlag: false
+        })
+      ).toBeNull();
+      const output = reassembler.addFragment({
+        fragmentationIndicator: 3,
+        mpuSequenceNumber: 7,
+        fragmentCounter: 0,
+        packetSequenceNumber: 103,
+        data: new Uint8Array([163]),
+        timestamp: 1103n,
+        rapFlag: false
+      });
+      expect(output).toBeNull();
+      expect(reassembler.stats.reassembledMFUs).toBe(1);
+      expect(reassembler.stats.rejectedFragments).toBe(0);
+      expect(reassembler.stats.evictedMemoryLimit).toBe(0);
+      expect(reassembler.getStatus().bufferedMFUs).toBe(2);
+      expect(reassembler.getStatus().pendingFragments).toBe(3);
+    });
     test("sibling subsample DUs of one sample reassemble independently by offset", () => {
       const reassembler = new MFUReassembler({ timeoutMs: 1e3 });
       expect(
@@ -7719,16 +7775,26 @@ var MmtpToCmaf = class {
     return __privateGet(this, _audioInitSegment);
   }
   /** Convert a raw video sample to an fMP4 moof+mdat segment. */
-  wrapVideoSample(data, timestamp, keyframe, duration) {
-    return this.wrapVideoSampleWithTiming(data, timestamp, keyframe, duration).segment;
+  wrapVideoSample(data, timestamp, keyframe, duration, compositionTimeOffset) {
+    return this.wrapVideoSampleWithTiming(data, timestamp, keyframe, duration, compositionTimeOffset).segment;
   }
   /**
    * Convert a raw video sample and return the exact browser media interval
    * encoded into tfdt/trun. Consumers that correlate SourceBuffer appends with
    * requestVideoFrameCallback must use this rebased timestamp, not the wire or
    * caller-owned timestamp passed above.
+   *
+   * `compositionTimeOffset` is the signed authored PTS-DTS delta, in the same
+   * #videoTimescale units as `timestamp` and `duration` — unlike wrapAudioSample,
+   * which takes microseconds and rescales, because every other quantity on this
+   * path is already denominated in #videoTimescale (see setVideoTrackParams).
+   * Passing it therefore needs no conversion here; rescaling would double-convert.
+   * Absent leaves the trun at version 0 with no offset field; a declared 0 is an
+   * authored value and still promotes to version 1. Never reconstruct it from
+   * arrival time.
    */
-  wrapVideoSampleWithTiming(data, timestamp, keyframe, duration) {
+  wrapVideoSampleWithTiming(data, timestamp, keyframe, duration, compositionTimeOffset) {
+    assertCompositionTimeOffsets([{ compositionTimeOffset }]);
     if (duration !== void 0 && Number.isFinite(duration) && duration > 0) {
       __privateSet(this, _frameDuration, Math.round(duration));
     } else if (__privateGet(this, _lastVideoTimestamp) > 0 && timestamp > __privateGet(this, _lastVideoTimestamp)) {
@@ -7746,7 +7812,8 @@ var MmtpToCmaf = class {
         frameDuration,
         keyframe,
         __privateWrapper(this, _videoSeq)._++,
-        __privateGet(this, _videoTrackId)
+        __privateGet(this, _videoTrackId),
+        compositionTimeOffset
       ),
       mediaTimestamp: relTs,
       duration: frameDuration
@@ -9255,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);
@@ -9281,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);
@@ -9333,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) {
@@ -9388,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;
@@ -9541,6 +9671,7 @@ var SessionManager = class {
   // Cleanup
   // -----------------------------------------------------------------------
   dispose() {
+    __privateMethod(this, _SessionManager_instances, clearJoinDeferWarn_fn).call(this);
     for (const [, session] of this.sessions) {
       session.dispose();
     }
@@ -9550,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
 // -----------------------------------------------------------------------
@@ -9898,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) {
@@ -9924,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;
     }
@@ -10017,7 +10165,7 @@ var FECManager = class {
   symbolSizeForPacket(packetId) {
     return __privateMethod(this, _FECManager_instances, resolveTrackConfig_fn).call(this, packetId).symbolSize;
   }
-  /** FEC interleave window in milliseconds (0 = no interleaving). */
+  /** FEC block span in milliseconds (0 = no interleaving). */
   get interleaveDepthMs() {
     return __privateGet(this, _fecInterleaveDepthMs);
   }
@@ -10339,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);
@@ -10382,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
   // -----------------------------------------------------------------------
@@ -13497,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(
@@ -13527,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);
         }
       }
     }
@@ -13535,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. */
@@ -13694,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;
@@ -13854,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);
@@ -13906,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));
         }
       }
     }
@@ -14022,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);
         }
       }
     }
@@ -14370,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, {
@@ -14452,7 +14590,11 @@ admitRecoveredResult_fn = function(blockId, result, ownerPacketId, catalogTrackN
           __privateMethod(this, _MmtpRouter_instances, routeProcessedFecSymbols_fn).call(this, blockId, { ...result, symbols: [symbol] }, ownerPacketId, catalogTrackName);
         }
         admitNext(index + 1);
-      }
+      },
+      // A stalled symbol that is later discarded instead of played must still
+      // advance this loop; enforce mode never calls the release callback for
+      // it (BLO-30095).
+      () => admitNext(index + 1)
     );
     if (admission.action === "drop") admitNext(index + 1);
   };
@@ -15225,12 +15367,16 @@ var driadDiscovery = new DRIADDiscovery();
 function endpointKey(endpoint) {
   return `${endpoint.sourceAddress ?? ""}|${endpoint.groupAddress}|${endpoint.port}`;
 }
+function carriesMedia(endpoint) {
+  return endpoint.carriesMedia !== false;
+}
 function selectMulticastTier(endpoints, estimate) {
-  if (endpoints.length <= 1)
-    return endpoints[0];
-  const ranked = endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
+  const media = endpoints.filter(carriesMedia);
+  if (media.length <= 1)
+    return media[0];
+  const ranked = media.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > 0).sort((a, b) => a.bandwidth - b.bandwidth);
   if (ranked.length < 2)
-    return endpoints[0];
+    return media[0];
   if (estimate === void 0)
     return ranked[0];
   const budget = estimate * 0.8;
@@ -15479,7 +15625,7 @@ var MulticastOrchestrator = class {
     const currentBandwidth = __privateGet(this, _current).bandwidth;
     if (typeof currentBandwidth !== "number")
       return void 0;
-    const desired = this.options.endpoints.filter((endpoint) => typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
+    const desired = this.options.endpoints.filter((endpoint) => carriesMedia(endpoint) && typeof endpoint.bandwidth === "number" && endpoint.bandwidth > currentBandwidth).sort((a, b) => a.bandwidth - b.bandwidth)[0];
     if (!desired) {
       __privateSet(this, _favored, void 0);
       return void 0;
@@ -16785,6 +16931,24 @@ function publishFecDiagnostics(packetId, stats) {
 function altGroupKey(track) {
   return track.altGroup === void 0 ? DEFAULT_ALT_GROUP : String(track.altGroup);
 }
+function repairTrackNamesBySource(tracks) {
+  const bySource = /* @__PURE__ */ new Map();
+  const add = (source, repair) => {
+    if (!source || !repair) return;
+    const names = bySource.get(source) ?? /* @__PURE__ */ new Set();
+    names.add(repair);
+    bySource.set(source, names);
+  };
+  for (const track of tracks) {
+    if (track.fec !== void 0 && isFecCatalogConfig(track.fec) && track.fec.repairTrack) {
+      add(track.name, track.fec.repairTrack);
+    }
+    if (track.packaging === "fec-repair" && Array.isArray(track.depends) && track.depends.length === 1) {
+      add(track.depends[0], track.name);
+    }
+  }
+  return bySource;
+}
 var _fec, _router, _transport, _reportedFecDiagnosticsFailure, _streamFecBaseline, _trackFecTiming, _switchingSets, _repairPacketIds, _repairInFlight, _repairLifecycleObservers, _trackResetObservers, _onRepairSubscribeCb, _MulticastManager_instances, configureTrackMapper_fn, applyStreamGlobalFecTiming_fn, _onTrackTypeDiscovered, emitRepairLifecycle_fn;
 var MulticastManager = class {
   constructor(options) {
@@ -17245,12 +17409,13 @@ var MulticastManager = class {
    *                            a factory returning a distinct decoder per stream.
    */
   configureMultiTrack(catalog, wasmDecoderSource) {
+    const repairNamesBySource = repairTrackNamesBySource(catalog.tracks);
     const repairOwnerGroup = /* @__PURE__ */ new Map();
     const repairOwnerAltGroup = /* @__PURE__ */ new Map();
     for (const track of catalog.tracks) {
-      if (track.fec !== void 0 && isFecCatalogConfig(track.fec) && track.fec.repairTrack) {
-        repairOwnerGroup.set(track.fec.repairTrack, altGroupKey(track));
-        repairOwnerAltGroup.set(track.fec.repairTrack, track.altGroup);
+      for (const repairName of repairNamesBySource.get(track.name) ?? []) {
+        repairOwnerGroup.set(repairName, altGroupKey(track));
+        repairOwnerAltGroup.set(repairName, track.altGroup);
       }
     }
     const groupKeyFor = (track) => repairOwnerGroup.get(track.name) ?? altGroupKey(track);
@@ -17353,9 +17518,13 @@ var MulticastManager = class {
       }
       if (track.fec !== void 0) {
         const fecCfg = track.fec;
-        const repairTrack = catalogTracksByName.get(fecCfg.repairTrack);
-        if (track.packetId !== void 0 && repairTrack?.packetId !== void 0) {
-          __privateGet(this, _router).setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
+        if (track.packetId !== void 0) {
+          for (const repairName of repairNamesBySource.get(track.name) ?? []) {
+            const repairTrack = catalogTracksByName.get(repairName);
+            if (repairTrack?.packetId !== void 0) {
+              __privateGet(this, _router).setRepairPacketIdOwner(repairTrack.packetId, track.packetId);
+            }
+          }
         }
         const wasmDecoder = fecDecoders.get(i);
         if (track.packetId !== void 0 && wasmDecoder !== void 0) {
@@ -17645,7 +17814,9 @@ async function setupFecWorkerForTrack(opts) {
     sampleRate: opts.sampleRate,
     algorithm: "raptor",
     k: opts.fecK,
-    repairCount: opts.fecRepairCount,
+    // P as this receiver joined it, not the catalog total: the worker snapshot
+    // and CMCD `x-bc-fec-p` are read from this. Identity on a single layer.
+    repairCount: opts.joinedRepairCount ?? opts.fecRepairCount,
     symbolSize: opts.fecSymbolSize,
     interleaveDepth: interleaveDepthBlocks,
     interleaveMs: opts.fecInterleaveMs,
@@ -19507,6 +19678,16 @@ var NO_FEC = {
   fecSymbolSize: 0,
   fecInterleaveMs: 0
 };
+function joinedRepairSymbolCount(params, joinedRepairTrackNames) {
+  const layers = params.repairLayers;
+  if (layers === void 0 || layers.length === 0) return params.fecRepairCount;
+  const joined = new Set(joinedRepairTrackNames);
+  let total = 0;
+  for (const layer of layers) {
+    if (joined.has(layer.repairTrackName)) total += layer.repairSymbols;
+  }
+  return total;
+}
 function recordOf(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -19836,6 +20017,7 @@ export {
   FEC_SBN_MAX,
   FecSourceInfo,
   FecStarvationDetector,
+  JOIN_DEFER_WARN_MS,
   KEYFRAME_LOST_TIMEOUT_SLACK,
   LOCHeaderExtensionId,
   MAX_ENCODING_SYMBOL_ID,
@@ -19936,6 +20118,7 @@ export {
   isSignalingPacket,
   isSourcePacket,
   isTrackTimingConfig,
+  joinedRepairSymbolCount,
   mergeOverrideIntoCmsfTracks,
   mergeOverrideIntoHangRenditions,
   mfuReassemblyTimeoutMs,