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

package/dist/browser-runtime.js

@@ -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
@@ -10017,7 +10084,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);
   }
@@ -11577,7 +11644,7 @@ function sameTrack(a, b) {
 function sameSample(a, b) {
   return a.decodeTime === b.decodeTime && a.presentationTime === b.presentationTime && a.duration === b.duration && a.timescale === b.timescale && a.size === b.size && a.bytePosition === b.bytePosition;
 }
-var _track, _fragments, _pendingSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, clearSlot_fn;
+var _track, _fragments, _pendingSamples, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
 var IsoBmffTimingResolver = class {
   constructor(maxPendingSamples) {
     this.maxPendingSamples = maxPendingSamples;
@@ -11585,6 +11652,7 @@ var IsoBmffTimingResolver = class {
     __privateAdd(this, _track, null);
     __privateAdd(this, _fragments, /* @__PURE__ */ new Map());
     __privateAdd(this, _pendingSamples, 0);
+    __privateAdd(this, _evictedSamples, 0);
     __privateAdd(this, _lastMovieFragmentRejection, null);
     if (!Number.isInteger(maxPendingSamples) || maxPendingSamples <= 0) {
       throw new Error("[IsoBmffTimingResolver] maxPendingSamples must be a positive integer");
@@ -11593,6 +11661,15 @@ var IsoBmffTimingResolver = class {
   get pendingSampleCount() {
     return __privateGet(this, _pendingSamples);
   }
+  /**
+   * Slots reclaimed by window displacement rather than by delivery or
+   * abandonment. Deliberately separate from the combiner's own release count:
+   * "nobody ever saw this sample" and "the combiner gave up on it" are
+   * different failures with different owners, and one number cannot say which.
+   */
+  get evictedSampleCount() {
+    return __privateGet(this, _evictedSamples);
+  }
   /** Typed reason for the most recent rejected movie fragment. */
   get lastMovieFragmentRejection() {
     return __privateGet(this, _lastMovieFragmentRejection);
@@ -11630,7 +11707,11 @@ var IsoBmffTimingResolver = class {
         (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
       );
     }
-    if (parsed.samples.length > additionalSampleLimit) {
+    let freed = 0;
+    while (__privateGet(this, _fragments).size > 0 && (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
+      freed += __privateMethod(this, _IsoBmffTimingResolver_instances, evictOldestFragment_fn).call(this);
+    }
+    if (parsed.samples.length - freed > additionalSampleLimit) {
       __privateSet(this, _lastMovieFragmentRejection, "budget");
       return false;
     }
@@ -11663,12 +11744,11 @@ var IsoBmffTimingResolver = class {
    * Free the budget slot of a sample that will never be delivered.
    *
    * `consumeSample` is the delivery path and is the only decrement on a
-   * healthy stream. But a sample whose data units never complete is never
-   * delivered, and without this path its slot is held until `reset()` --
-   * making `maxPendingSamples` a one-way ratchet. Once it saturates,
-   * `addMovieFragment` rejects every subsequent moof and the stream is
-   * wedged permanently: the consumer sees media stop with no error, and only
-   * a full track reset clears it.
+   * healthy stream. A sample whose data units never complete is never
+   * delivered; window displacement in `addMovieFragment` eventually reclaims
+   * it, but only after it has aged out of the whole window. This path frees
+   * the slot as soon as the combiner knows the sample is gone, so the budget
+   * tracks what is actually in flight rather than what has merely aged.
    *
    * The caller is whoever abandoned the sample, so the release is driven by
    * the abandonment itself rather than by a timer, an LRU, or an age bound --
@@ -11692,8 +11772,27 @@ var IsoBmffTimingResolver = class {
 _track = new WeakMap();
 _fragments = new WeakMap();
 _pendingSamples = new WeakMap();
+_evictedSamples = new WeakMap();
 _lastMovieFragmentRejection = new WeakMap();
 _IsoBmffTimingResolver_instances = new WeakSet();
+/**
+ * Drop the oldest pending fragment whole and return the slots it held.
+ *
+ * Oldest is insertion order, which for a moof stream is arrival order, so
+ * this is the least-recently-declared timing -- the entries least likely to
+ * still have data units in flight.
+ */
+evictOldestFragment_fn = function() {
+  const oldest = __privateGet(this, _fragments).keys().next().value;
+  if (oldest === void 0) return 0;
+  const samples = __privateGet(this, _fragments).get(oldest);
+  let live = 0;
+  for (const sample of samples) if (sample !== null) live++;
+  __privateGet(this, _fragments).delete(oldest);
+  __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) - live);
+  __privateSet(this, _evictedSamples, __privateGet(this, _evictedSamples) + live);
+  return live;
+};
 /** Null one slot, decrement the budget, and drop the fragment when empty. */
 clearSlot_fn = function(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) {
   if (!isU322(mpuSequenceNumber) || !isU322(movieFragmentSequenceNumber) || movieFragmentSequenceNumber === 0 || !isU322(sampleNumber) || sampleNumber === 0) {
@@ -11872,7 +11971,7 @@ function isFmp4Box(data) {
   const type = String.fromCharCode(data[4], data[5], data[6], data[7]);
   return FMPU_BOX_TYPES.has(type);
 }
-var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _rejectedMovieFragments, _sequencers, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed2, _MmtpContainerParser_instances, streamKey_fn2, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
+var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _evictedTimingSamples, _rejectedMovieFragments, _sequencers, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed2, _fedObjects, _feedOutcomes, _deferredFeedOutcomes, _lastOutcome, _lastOutcomeCount, _MmtpContainerParser_instances, streamKey_fn2, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, countOutcome_fn, countDeferredOutcome_fn, drop_fn, feed_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
 var _MmtpContainerParser = class _MmtpContainerParser {
   constructor(config) {
     __privateAdd(this, _MmtpContainerParser_instances);
@@ -11906,6 +12005,7 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     __privateAdd(this, _maxPendingTimingSamples);
     __privateAdd(this, _pendingTimingSamples, 0);
     __privateAdd(this, _reclaimedTimingSamples, 0);
+    __privateAdd(this, _evictedTimingSamples, 0);
     __privateAdd(this, _rejectedMovieFragments, 0);
     __privateAdd(this, _sequencers, /* @__PURE__ */ new Map());
     __privateAdd(this, _reorderWindow, 0);
@@ -11932,6 +12032,11 @@ var _MmtpContainerParser = class _MmtpContainerParser {
      *  reordering into the parser. */
     __privateAdd(this, _reliableMoqStartupGate, /* @__PURE__ */ new Map());
     __privateAdd(this, _disposed2, false);
+    __privateAdd(this, _fedObjects, 0);
+    __privateAdd(this, _feedOutcomes, /* @__PURE__ */ new Map());
+    __privateAdd(this, _deferredFeedOutcomes, /* @__PURE__ */ new Map());
+    __privateAdd(this, _lastOutcome, null);
+    __privateAdd(this, _lastOutcomeCount, 0);
     /** Authored presentation timestamp of the last emitted frame, in microseconds. */
     this.lastFrameTimestamp = void 0;
     if (config?.reassemblyPolicy && config.mfuTimeoutMs !== void 0) {
@@ -12034,6 +12139,7 @@ var _MmtpContainerParser = class _MmtpContainerParser {
       pending: __privateGet(this, _pendingTimingSamples),
       capacity: __privateGet(this, _maxPendingTimingSamples),
       reclaimed: __privateGet(this, _reclaimedTimingSamples),
+      evicted: __privateGet(this, _evictedTimingSamples),
       rejectedMovieFragments: __privateGet(this, _rejectedMovieFragments)
     };
   }
@@ -12042,6 +12148,36 @@ var _MmtpContainerParser = class _MmtpContainerParser {
     for (const { sequencer } of __privateGet(this, _sequencers).values()) bufferedFrames += sequencer.buffered;
     return { ...__privateGet(this, _reorderStats), bufferedFrames };
   }
+  /**
+   * Feed tallies for this parser. A fresh snapshot per call, not a live view,
+   * so a caller can hold one and compare it against a later read.
+   *
+   * Survives dispose() — the counters are the parser's own state and are not
+   * cleared by teardown, because a wedged receive path is usually read after
+   * the fact.
+   */
+  get feedStats() {
+    return {
+      fedObjects: __privateGet(this, _fedObjects),
+      outcomes: Object.fromEntries(__privateGet(this, _feedOutcomes)),
+      deferredOutcomes: Object.fromEntries(__privateGet(this, _deferredFeedOutcomes))
+    };
+  }
+  /**
+   * Outcome token of the most recent feed(), or null before the first call.
+   *
+   * Exposed alongside `lastFeedOutcomeCount` as two scalars rather than one
+   * object because a wrapper reads them on every packet, and feedStats()
+   * allocates a fresh snapshot per call.
+   */
+  get lastFeedOutcome() {
+    return __privateGet(this, _lastOutcome);
+  }
+  /** How many times `lastFeedOutcome` has now been seen. 1 on its first
+   *  occurrence, which is what a caller logging once per novel outcome needs. */
+  get lastFeedOutcomeCount() {
+    return __privateGet(this, _lastOutcomeCount);
+  }
   get reorderDiagnostics() {
     const streams = [];
     for (const { packetId, sequencer } of __privateGet(this, _sequencers).values()) {
@@ -12091,181 +12227,16 @@ var _MmtpContainerParser = class _MmtpContainerParser {
   }
   /** Feed a complete MMTP packet. For two-phase use, call parseHeader() first. */
   feed(packet, options) {
-    var _a;
-    if (__privateGet(this, _disposed2)) return null;
-    this.cleanupTimeouts();
-    const info = this.parseHeader(packet, options);
-    if (!info) return null;
-    if (info.packetType !== PACKET_TYPE_MPU2) {
-      return {
-        kind: info.isRepair ? "repair" : "non-media",
-        packet: info,
-        byteLength: packet.byteLength
-      };
-    }
-    if (info.fecPayloadId !== null && __privateGet(this, _sourceSymbolCb)) {
-      const rawSymbol = packet.subarray(0, packet.length - 4);
-      const altaTrailer = extractAltaTrailer2(packet);
-      const alta = altaTrailer ? { auth: altaTrailer.auth, payloadEnd: altaTrailer.signedEnd } : void 0;
-      try {
-        __privateGet(this, _sourceSymbolCb).call(this, info.packetId, info.fecPayloadId.ssId, rawSymbol, alta);
-      } catch {
-      }
-    }
-    const extraction = extractMFUPayload(packet, {
-      skipFecId: options?.skipFecPayloadId
-    });
-    if (!extraction) return null;
-    const { mpu, fragmentType, data, mfuDuHeader } = extraction;
-    if (mpu.timedFlag !== 1) return null;
-    const streamKey = __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn2).call(this, info.packetId, options?.catalogTrackName);
-    if (fragmentType === 0) {
-      if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0) return null;
-      const normalizedInit = normalizeMmtpInitSegment(data);
-      if (!normalizedInit) return null;
-      const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, true);
-      if (!resolver2?.addInitialization(normalizedInit)) return null;
-      (_a = __privateGet(this, _initCb)) == null ? void 0 : _a.call(this, normalizedInit, info.packetId, options?.catalogTrackName);
-      return {
-        kind: "init",
-        packet: info,
-        data: normalizedInit,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter
-      };
-    }
-    if (fragmentType === 1) {
-      if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0) return null;
-      const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
-      if (!resolver2) return null;
-      const pendingBefore = resolver2.pendingSampleCount;
-      const remaining = __privateGet(this, _maxPendingTimingSamples) - __privateGet(this, _pendingTimingSamples);
-      if (!resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining)) {
-        if (resolver2.lastMovieFragmentRejection === "budget") {
-          __privateWrapper(this, _rejectedMovieFragments)._++;
-        }
-        return null;
-      }
-      __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) + (resolver2.pendingSampleCount - pendingBefore));
-      return {
-        kind: "fragment",
-        packet: info,
-        data,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter
-      };
-    }
-    if (fragmentType !== 2) return null;
-    const resolver = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
-    if (!resolver) return null;
-    if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0) return null;
-    if (mpu.fragmentationIndicator === 0 || mpu.fragmentationIndicator === 1) {
-      if (!mfuDuHeader || mfuDuHeader.movieFragmentSequenceNumber === 0 || mfuDuHeader.sampleNumber === 0) {
-        return null;
-      }
-      const headTiming = resolver.sampleTiming(
-        mpu.mpuSequenceNumber,
-        mfuDuHeader.movieFragmentSequenceNumber,
-        mfuDuHeader.sampleNumber
-      );
-      if (!headTiming) return null;
-      const offset = mfuDuHeader.offset;
-      if (!Number.isSafeInteger(offset) || offset < 0 || offset >= headTiming.size) return null;
-      const remaining = headTiming.size - offset;
-      if (mpu.fragmentationIndicator === 0 && data.byteLength !== remaining) return null;
-      if (mpu.fragmentationIndicator === 1 && data.byteLength >= remaining) return null;
-      const readyOnRegister = __privateMethod(this, _MmtpContainerParser_instances, sampleCombinerFor_fn).call(this, streamKey).registerAuthoredSize(
-        options?.catalogTrackName,
-        mpu.mpuSequenceNumber,
-        mfuDuHeader.movieFragmentSequenceNumber,
-        mfuDuHeader.sampleNumber,
-        headTiming.size
-      );
-      if (readyOnRegister) {
-        __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true);
-      }
-    }
-    let assembled;
-    try {
-      assembled = __privateGet(this, _reassembler).addFragment({
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentCounter: mpu.fragmentCounter,
-        data,
-        timestamp: info.timestamp,
-        rapFlag: info.rapFlag,
-        priority: mfuDuHeader?.priority,
-        sampleNumber: mfuDuHeader?.sampleNumber,
-        movieFragmentSequenceNumber: mfuDuHeader?.movieFragmentSequenceNumber,
-        sampleOffset: mfuDuHeader?.offset,
-        packetSequenceNumber: info.sequenceNumber,
-        recovered: options?.recovered === true,
-        source: options?.source,
-        deliveryProvenance: options?.deliveryProvenance,
-        catalogTrackName: options?.catalogTrackName,
-        packetId: info.packetId
-      });
-    } catch (error) {
-      if (!isMfuReassemblyError(error)) throw error;
-      console.warn(
-        `[MmtpContainerParser] rejected MFU fragment: code=${error.code} mpu=${mpu.mpuSequenceNumber} fi=${mpu.fragmentationIndicator} counter=${mpu.fragmentCounter}`
-      );
-      return {
-        kind: "rejected",
-        packet: info,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter,
-        error: { code: error.code, message: error.message }
-      };
-    }
-    if (!assembled) {
-      return {
-        kind: "pending",
-        packet: info,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter
-      };
-    }
-    const movieFragmentSequenceNumber = assembled.movieFragmentSequenceNumber;
-    const sampleNumber = assembled.sampleNumber;
-    if (movieFragmentSequenceNumber === void 0 || sampleNumber === void 0) return null;
-    if (!resolver.sampleTiming(
-      assembled.mpuSequenceNumber,
-      movieFragmentSequenceNumber,
-      sampleNumber
-    )) return null;
-    if (assembled.mpuSequenceNumber !== mpu.mpuSequenceNumber) return null;
-    let combined;
+    __privateSet(this, _fedObjects, __privateGet(this, _fedObjects) + 1);
+    let record;
     try {
-      combined = __privateMethod(this, _MmtpContainerParser_instances, sampleCombinerFor_fn).call(this, streamKey).addMfu(assembled);
+      record = __privateMethod(this, _MmtpContainerParser_instances, feed_fn).call(this, packet, options);
     } catch (error) {
-      if (!(error instanceof SampleCombineError)) throw error;
-      console.warn(
-        `[MmtpContainerParser] rejected subsample data unit: code=${error.code} mpu=${assembled.mpuSequenceNumber} sample=${sampleNumber} offset=${assembled.sampleOffset ?? 0}`
-      );
-      return {
-        kind: "rejected",
-        packet: info,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter,
-        error: { code: error.code, message: error.message }
-      };
-    }
-    if (!combined) {
-      return {
-        kind: "pending",
-        packet: info,
-        mpuSequenceNumber: mpu.mpuSequenceNumber,
-        fragmentationIndicator: mpu.fragmentationIndicator,
-        fragmentCounter: mpu.fragmentCounter
-      };
+      __privateMethod(this, _MmtpContainerParser_instances, countOutcome_fn).call(this, "drop:threw");
+      throw error;
     }
-    return __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true);
+    if (record) __privateMethod(this, _MmtpContainerParser_instances, countOutcome_fn).call(this, record.kind);
+    return record;
   }
   onInit(cb) {
     __privateSet(this, _initCb, cb);
@@ -12433,6 +12404,7 @@ _timingStreams = new WeakMap();
 _maxPendingTimingSamples = new WeakMap();
 _pendingTimingSamples = new WeakMap();
 _reclaimedTimingSamples = new WeakMap();
+_evictedTimingSamples = new WeakMap();
 _rejectedMovieFragments = new WeakMap();
 _sequencers = new WeakMap();
 _reorderWindow = new WeakMap();
@@ -12444,6 +12416,11 @@ _trackFrameCbs = new WeakMap();
 _reorderStats = new WeakMap();
 _reliableMoqStartupGate = new WeakMap();
 _disposed2 = new WeakMap();
+_fedObjects = new WeakMap();
+_feedOutcomes = new WeakMap();
+_deferredFeedOutcomes = new WeakMap();
+_lastOutcome = new WeakMap();
+_lastOutcomeCount = new WeakMap();
 _MmtpContainerParser_instances = new WeakSet();
 streamKey_fn2 = function(packetId, catalogTrackName) {
   return JSON.stringify([packetId, catalogTrackName ?? null]);
@@ -12462,12 +12439,12 @@ sampleCombinerFor_fn = function(streamKey) {
 /**
  * Return the timing budget slot of a sample the combiner abandoned.
  *
- * Without this, `#pendingTimingSamples` is a one-way ratchet: it is charged
- * for every sample a moof declares but credited only when that sample is
- * delivered, so each sample lost to eviction or timeout permanently burns a
- * slot. At saturation `addMovieFragment` rejects every subsequent moof and
- * every FT=2 data unit is dropped -- media stops with no error surfaced and
- * nothing short of a track reset recovers.
+ * Without this, `#pendingTimingSamples` is charged for every sample a moof
+ * declares but credited only when that sample is delivered, so each sample
+ * lost to eviction or timeout burns a slot until the window displaces it.
+ * Window displacement bounds that leak but only reclaims the OLDEST entries;
+ * this path returns a slot the moment the combiner knows the sample is gone,
+ * which keeps the live window as wide as the stream actually needs.
  *
  * The parser total is decremented only when the resolver reports it
  * actually freed a slot, so a resolver already dropped by a track reset, or
@@ -12499,11 +12476,232 @@ dropSampleCombiner_fn = function(streamKey) {
   __privateGet(this, _retiredSampleCombinerStats).evictedSamples += stats.evictedSamples;
   __privateGet(this, _sampleCombiners).delete(streamKey);
 };
+countOutcome_fn = function(token) {
+  const count = (__privateGet(this, _feedOutcomes).get(token) ?? 0) + 1;
+  __privateGet(this, _feedOutcomes).set(token, count);
+  __privateSet(this, _lastOutcome, token);
+  __privateSet(this, _lastOutcomeCount, count);
+};
+countDeferredOutcome_fn = function(reason) {
+  __privateGet(this, _deferredFeedOutcomes).set(
+    reason,
+    (__privateGet(this, _deferredFeedOutcomes).get(reason) ?? 0) + 1
+  );
+};
+/**
+ * Count a feed() drop and return null in one expression, so every early
+ * return inside feed() states the reason it took instead of collapsing into
+ * a single failure bucket. Returns null so call sites stay `return this.#drop(...)`.
+ */
+drop_fn = function(reason) {
+  __privateMethod(this, _MmtpContainerParser_instances, countOutcome_fn).call(this, `drop:${reason}`);
+  return null;
+};
+feed_fn = function(packet, options) {
+  var _a;
+  if (__privateGet(this, _disposed2)) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "disposed");
+  this.cleanupTimeouts();
+  const info = this.parseHeader(packet, options);
+  if (!info) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "header-parse-failed");
+  if (info.packetType !== PACKET_TYPE_MPU2) {
+    return {
+      kind: info.isRepair ? "repair" : "non-media",
+      packet: info,
+      byteLength: packet.byteLength
+    };
+  }
+  if (info.fecPayloadId !== null && __privateGet(this, _sourceSymbolCb)) {
+    const rawSymbol = packet.subarray(0, packet.length - 4);
+    const altaTrailer = extractAltaTrailer2(packet);
+    const alta = altaTrailer ? { auth: altaTrailer.auth, payloadEnd: altaTrailer.signedEnd } : void 0;
+    try {
+      __privateGet(this, _sourceSymbolCb).call(this, info.packetId, info.fecPayloadId.ssId, rawSymbol, alta);
+    } catch {
+    }
+  }
+  const extraction = extractMFUPayload(packet, {
+    skipFecId: options?.skipFecPayloadId
+  });
+  if (!extraction) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-extract-failed");
+  const { mpu, fragmentType, data, mfuDuHeader } = extraction;
+  if (mpu.timedFlag !== 1) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "untimed-mpu");
+  const streamKey = __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn2).call(this, info.packetId, options?.catalogTrackName);
+  if (fragmentType === 0) {
+    if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "init-unexpected-fragmentation");
+    const normalizedInit = normalizeMmtpInitSegment(data);
+    if (!normalizedInit) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "init-normalize-failed");
+    const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, true);
+    if (!resolver2?.addInitialization(normalizedInit)) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "init-timing-refused");
+    (_a = __privateGet(this, _initCb)) == null ? void 0 : _a.call(this, normalizedInit, info.packetId, options?.catalogTrackName);
+    return {
+      kind: "init",
+      packet: info,
+      data: normalizedInit,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter
+    };
+  }
+  if (fragmentType === 1) {
+    if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-unexpected-fragmentation");
+    const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
+    if (!resolver2) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-no-resolver");
+    const pendingBefore = resolver2.pendingSampleCount;
+    const evictedBefore = resolver2.evictedSampleCount;
+    const remaining = __privateGet(this, _maxPendingTimingSamples) - __privateGet(this, _pendingTimingSamples);
+    const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+    __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) + (resolver2.pendingSampleCount - pendingBefore));
+    __privateSet(this, _evictedTimingSamples, __privateGet(this, _evictedTimingSamples) + (resolver2.evictedSampleCount - evictedBefore));
+    if (!admitted) {
+      if (resolver2.lastMovieFragmentRejection === "budget") {
+        __privateWrapper(this, _rejectedMovieFragments)._++;
+      }
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-timing-refused");
+    }
+    return {
+      kind: "fragment",
+      packet: info,
+      data,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter
+    };
+  }
+  if (fragmentType !== 2) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "unknown-fragment-type");
+  const resolver = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
+  if (!resolver) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-no-resolver");
+  if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
+    return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-empty-payload");
+  if (mpu.fragmentationIndicator === 0 || mpu.fragmentationIndicator === 1) {
+    if (!mfuDuHeader || mfuDuHeader.movieFragmentSequenceNumber === 0 || mfuDuHeader.sampleNumber === 0) {
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-du-header-missing");
+    }
+    const headTiming = resolver.sampleTiming(
+      mpu.mpuSequenceNumber,
+      mfuDuHeader.movieFragmentSequenceNumber,
+      mfuDuHeader.sampleNumber
+    );
+    if (!headTiming) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-sample-timing-missing");
+    const offset = mfuDuHeader.offset;
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset >= headTiming.size)
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-offset-out-of-range");
+    const remaining = headTiming.size - offset;
+    if (mpu.fragmentationIndicator === 0 && data.byteLength !== remaining)
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-size-mismatch");
+    if (mpu.fragmentationIndicator === 1 && data.byteLength >= remaining)
+      return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-size-mismatch");
+    const readyOnRegister = __privateMethod(this, _MmtpContainerParser_instances, sampleCombinerFor_fn).call(this, streamKey).registerAuthoredSize(
+      options?.catalogTrackName,
+      mpu.mpuSequenceNumber,
+      mfuDuHeader.movieFragmentSequenceNumber,
+      mfuDuHeader.sampleNumber,
+      headTiming.size
+    );
+    if (readyOnRegister) {
+      const deferred = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true);
+      if (deferred.record === void 0) __privateMethod(this, _MmtpContainerParser_instances, countDeferredOutcome_fn).call(this, deferred.reason);
+    }
+  }
+  let assembled;
+  try {
+    assembled = __privateGet(this, _reassembler).addFragment({
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentCounter: mpu.fragmentCounter,
+      data,
+      timestamp: info.timestamp,
+      rapFlag: info.rapFlag,
+      priority: mfuDuHeader?.priority,
+      sampleNumber: mfuDuHeader?.sampleNumber,
+      movieFragmentSequenceNumber: mfuDuHeader?.movieFragmentSequenceNumber,
+      sampleOffset: mfuDuHeader?.offset,
+      packetSequenceNumber: info.sequenceNumber,
+      recovered: options?.recovered === true,
+      source: options?.source,
+      deliveryProvenance: options?.deliveryProvenance,
+      catalogTrackName: options?.catalogTrackName,
+      packetId: info.packetId
+    });
+  } catch (error) {
+    if (!isMfuReassemblyError(error)) throw error;
+    console.warn(
+      `[MmtpContainerParser] rejected MFU fragment: code=${error.code} mpu=${mpu.mpuSequenceNumber} fi=${mpu.fragmentationIndicator} counter=${mpu.fragmentCounter}`
+    );
+    return {
+      kind: "rejected",
+      packet: info,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter,
+      error: { code: error.code, message: error.message }
+    };
+  }
+  if (!assembled) {
+    return {
+      kind: "pending",
+      packet: info,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter
+    };
+  }
+  const movieFragmentSequenceNumber = assembled.movieFragmentSequenceNumber;
+  const sampleNumber = assembled.sampleNumber;
+  if (movieFragmentSequenceNumber === void 0 || sampleNumber === void 0)
+    return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "assembled-identity-missing");
+  if (!resolver.sampleTiming(
+    assembled.mpuSequenceNumber,
+    movieFragmentSequenceNumber,
+    sampleNumber
+  )) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "assembled-timing-missing");
+  if (assembled.mpuSequenceNumber !== mpu.mpuSequenceNumber)
+    return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "assembled-mpu-mismatch");
+  let combined;
+  try {
+    combined = __privateMethod(this, _MmtpContainerParser_instances, sampleCombinerFor_fn).call(this, streamKey).addMfu(assembled);
+  } catch (error) {
+    if (!(error instanceof SampleCombineError)) throw error;
+    console.warn(
+      `[MmtpContainerParser] rejected subsample data unit: code=${error.code} mpu=${assembled.mpuSequenceNumber} sample=${sampleNumber} offset=${assembled.sampleOffset ?? 0}`
+    );
+    return {
+      kind: "rejected",
+      packet: info,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter,
+      error: { code: error.code, message: error.message }
+    };
+  }
+  if (!combined) {
+    return {
+      kind: "pending",
+      packet: info,
+      mpuSequenceNumber: mpu.mpuSequenceNumber,
+      fragmentationIndicator: mpu.fragmentationIndicator,
+      fragmentCounter: mpu.fragmentCounter
+    };
+  }
+  const outcome = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true);
+  if (outcome.record !== void 0) return outcome.record;
+  return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, outcome.reason);
+};
 /**
  * Deliver one combined sample: resolve its authored timing, build frame
  * metadata, retire the timing entry, and route it. Shared by the ordinary
  * completion path and by the rarer completion that falls out of registering
  * an authored size for data units that arrived before it.
+ *
+ * Reports a refusal as a reason rather than counting it, because the two
+ * call sites owe different accounting. On `#feed()`'s tail return the
+ * refusal *is* that feed()'s outcome and must be attributed; on the
+ * register-completion path it belongs to an earlier sample while this
+ * packet's own fragment continues to its own outcome, so counting it there
+ * would push `outcomes` past `fedObjects` — the very invariant the
+ * attribution exists to keep readable. Leaving the choice at the call site
+ * is what keeps both true.
  */
 emitCombinedSample_fn = function(combined, info, resolver, recovered) {
   const timing = resolver.sampleTiming(
@@ -12511,27 +12709,29 @@ emitCombinedSample_fn = function(combined, info, resolver, recovered) {
     combined.movieFragmentSequenceNumber,
     combined.sampleNumber
   );
-  if (!timing) return null;
-  if (combined.data.byteLength !== timing.size) return null;
+  if (!timing) return { reason: "combined-timing-missing" };
+  if (combined.data.byteLength !== timing.size) return { reason: "combined-size-mismatch" };
   const meta = __privateMethod(this, _MmtpContainerParser_instances, buildFrameMeta_fn).call(this, combined, info.packetId, info.sequenceNumber, timing, recovered);
-  if (!meta) return null;
+  if (!meta) return { reason: "combined-meta-build-failed" };
   if (!resolver.consumeSample(
     combined.mpuSequenceNumber,
     combined.movieFragmentSequenceNumber,
     combined.sampleNumber,
     timing
-  )) return null;
+  )) return { reason: "combined-timing-consume-refused" };
   __privateWrapper(this, _pendingTimingSamples)._--;
   this.routeFrame(combined.data, meta);
   return {
-    kind: "frame",
-    packet: info,
-    data: combined.data,
-    meta,
-    mpuSequenceNumber: combined.mpuSequenceNumber,
-    fragmentCount: combined.fragmentCount,
-    rapFlag: combined.rapFlag,
-    ...combined.priority === void 0 ? {} : { priority: combined.priority }
+    record: {
+      kind: "frame",
+      packet: info,
+      data: combined.data,
+      meta,
+      mpuSequenceNumber: combined.mpuSequenceNumber,
+      fragmentCount: combined.fragmentCount,
+      rapFlag: combined.rapFlag,
+      ...combined.priority === void 0 ? {} : { priority: combined.priority }
+    }
   };
 };
 /** Order-independent reliable-moq startup gate: discard delta frames for a
@@ -14319,7 +14519,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);
   };
@@ -15092,12 +15296,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;
@@ -15346,7 +15554,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;
@@ -16277,6 +16485,14 @@ function getMulticastGlobals() {
 function hasMulticastGateway() {
   return typeof getMulticastGlobals().multicast?.subscribe === "function";
 }
+function normalizeBytesEventDetail(detail) {
+  const value = detail && typeof detail === "object" && "data" in detail ? detail.data : detail;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return null;
+}
 var _onPacket, _subscription2, _bytesListener, _resolvedTransport, _videoConfirmed, _audioConfirmed, _watchdog, _failbackWindowMs, _onTakeover, _onFailback, _disposed4, _stats3, _droppedPidCounts, _packetIds, _joinGeneration, _MulticastTransport_instances, releaseSubscription_fn, acceptPacket_fn, recordUnregisteredPidDrop_fn, checkTakeover_fn, resetWatchdog_fn;
 var _MulticastTransport = class _MulticastTransport {
   constructor(onPacket) {
@@ -16343,8 +16559,11 @@ var _MulticastTransport = class _MulticastTransport {
       }
       const onBytes = (event) => {
         if (__privateGet(this, _disposed4) || generation !== __privateGet(this, _joinGeneration)) return;
-        const detail = event.detail;
-        const packet = detail instanceof Uint8Array ? detail : new Uint8Array(detail);
+        const packet = normalizeBytesEventDetail(event.detail);
+        if (!packet) {
+          __privateGet(this, _stats3).packetsDroppedUnparseable++;
+          return;
+        }
         if (!__privateMethod(this, _MulticastTransport_instances, acceptPacket_fn).call(this, packet)) return;
         __privateGet(this, _stats3).packetsReceived++;
         __privateGet(this, _stats3).bytesReceived += packet.byteLength;
@@ -16641,6 +16860,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) {
@@ -17101,34 +17338,36 @@ var MulticastManager = class {
    *                            a factory returning a distinct decoder per stream.
    */
   configureMultiTrack(catalog, wasmDecoderSource) {
-    const explicitRepairNamesByGroup = /* @__PURE__ */ new Map();
+    const repairNamesBySource = repairTrackNamesBySource(catalog.tracks);
+    const repairOwnerGroup = /* @__PURE__ */ new Map();
+    const repairOwnerAltGroup = /* @__PURE__ */ new Map();
+    for (const track of catalog.tracks) {
+      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);
     const trackNamesByGroup = /* @__PURE__ */ new Map();
     for (const track of catalog.tracks) {
-      const groupKey = altGroupKey(track);
+      const groupKey = groupKeyFor(track);
       const groupNames = trackNamesByGroup.get(groupKey) ?? [];
       groupNames.push(track.name);
       trackNamesByGroup.set(groupKey, groupNames);
-      if (track.fec !== void 0 && isFecCatalogConfig(track.fec) && track.fec.repairTrack) {
-        const explicitRepairNames = explicitRepairNamesByGroup.get(groupKey) ?? /* @__PURE__ */ new Set();
-        explicitRepairNames.add(track.fec.repairTrack);
-        explicitRepairNamesByGroup.set(groupKey, explicitRepairNames);
-      }
     }
     const hasSwitchingSetByGroup = /* @__PURE__ */ new Map();
     for (const [groupKey, trackNames] of trackNamesByGroup) {
       hasSwitchingSetByGroup.set(groupKey, hasSwitchingSetRole(trackNames));
     }
     const resolvedRoles = catalog.tracks.map((track) => {
-      const groupKey = altGroupKey(track);
-      const hasSwitchingSet = hasSwitchingSetByGroup.get(groupKey) ?? false;
-      const explicitRepairNames = explicitRepairNamesByGroup.get(groupKey);
-      if (explicitRepairNames?.has(track.name)) return "repair";
+      if (repairOwnerGroup.has(track.name)) return "repair";
+      const hasSwitchingSet = hasSwitchingSetByGroup.get(altGroupKey(track)) ?? false;
       if (!hasSwitchingSet) return "single";
       return parseTrackRole(track.name);
     });
     const resolvedRolesByGroup = /* @__PURE__ */ new Map();
     for (let i = 0; i < catalog.tracks.length; i++) {
-      const groupKey = altGroupKey(catalog.tracks[i]);
+      const groupKey = groupKeyFor(catalog.tracks[i]);
       const roles = resolvedRolesByGroup.get(groupKey) ?? [];
       roles.push(resolvedRoles[i]);
       resolvedRolesByGroup.set(groupKey, roles);
@@ -17191,10 +17430,11 @@ var MulticastManager = class {
     for (let i = 0; i < catalog.tracks.length; i++) {
       const track = catalog.tracks[i];
       const role = resolvedRoles[i];
-      if (track.altGroup !== void 0) {
-        const existing = __privateGet(this, _switchingSets).get(track.altGroup) ?? [];
+      const altGroup = repairOwnerAltGroup.has(track.name) ? repairOwnerAltGroup.get(track.name) : track.altGroup;
+      if (altGroup !== void 0) {
+        const existing = __privateGet(this, _switchingSets).get(altGroup) ?? [];
         existing.push(track.name);
-        __privateGet(this, _switchingSets).set(track.altGroup, existing);
+        __privateGet(this, _switchingSets).set(altGroup, existing);
       }
       if (track.packetId !== void 0) {
         __privateGet(this, _router).setPacketIdRole(track.packetId, role);
@@ -17207,9 +17447,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) {
@@ -17499,7 +17743,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,
@@ -18422,7 +18668,7 @@ _readIndex = new WeakMap();
 _stalled = new WeakMap();
 
 // src/mmtp-decode-pipeline.ts
-var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _trackType, _gateDropped, _gateEmitted, _fedObjects, _warnedNoParser, _feedOutcomes, _MmtpDecodePipeline_instances, tag_fn, gatedEmit_fn;
+var _parser2, _fecClient, _frameCb2, _initCb2, _needsKeyframe, _codec, _trackType, _gateDropped, _gateEmitted, _fedObjects2, _warnedNoParser, _feedOutcomes2, _MmtpDecodePipeline_instances, tag_fn, gatedEmit_fn;
 var MmtpDecodePipeline = class {
   constructor() {
     __privateAdd(this, _MmtpDecodePipeline_instances);
@@ -18442,7 +18688,7 @@ var MmtpDecodePipeline = class {
      *  emitted. Bounded logging only — these gate nothing. */
     __privateAdd(this, _gateDropped, 0);
     __privateAdd(this, _gateEmitted, 0);
-    __privateAdd(this, _fedObjects, 0);
+    __privateAdd(this, _fedObjects2, 0);
     /** Warned-once latch for feeds arriving with no parser. Kept separate from
      *  #fedObjects so that counter stays a pure monotonic count. */
     __privateAdd(this, _warnedNoParser, false);
@@ -18451,16 +18697,16 @@ var MmtpDecodePipeline = class {
      *  so a packet that fails header parse, fails MFU extraction, or accumulates
      *  forever as an unreassembled fragment is indistinguishable from one that
      *  produced a frame. Tally the kinds instead of guessing. */
-    __privateAdd(this, _feedOutcomes, /* @__PURE__ */ new Map());
+    __privateAdd(this, _feedOutcomes2, /* @__PURE__ */ new Map());
   }
   /** Configure the inner parser. Call before feedMoqObject(). */
   configure(config) {
     __privateGet(this, _parser2)?.flush();
     __privateGet(this, _parser2)?.dispose();
-    __privateSet(this, _fedObjects, 0);
+    __privateSet(this, _fedObjects2, 0);
     __privateSet(this, _gateDropped, 0);
     __privateSet(this, _gateEmitted, 0);
-    __privateGet(this, _feedOutcomes).clear();
+    __privateGet(this, _feedOutcomes2).clear();
     __privateSet(this, _warnedNoParser, false);
     __privateSet(this, _codec, config.codec);
     const trackType = isVideoCodec(config.codec) ? "video" : "audio";
@@ -18520,10 +18766,10 @@ var MmtpDecodePipeline = class {
     return {
       trackType: __privateGet(this, _trackType),
       codec: __privateGet(this, _codec),
-      fedObjects: __privateGet(this, _fedObjects),
+      fedObjects: __privateGet(this, _fedObjects2),
       emitted: __privateGet(this, _gateEmitted),
       gateDropped: __privateGet(this, _gateDropped),
-      outcomes: Object.fromEntries(__privateGet(this, _feedOutcomes))
+      outcomes: Object.fromEntries(__privateGet(this, _feedOutcomes2))
     };
   }
   /**
@@ -18538,8 +18784,8 @@ var MmtpDecodePipeline = class {
       }
       return;
     }
-    __privateSet(this, _fedObjects, __privateGet(this, _fedObjects) + 1);
-    if (__privateGet(this, _fedObjects) === 1) {
+    __privateSet(this, _fedObjects2, __privateGet(this, _fedObjects2) + 1);
+    if (__privateGet(this, _fedObjects2) === 1) {
       console.log(`[mmtp-pipeline] first object fed ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${packet.length}`);
     }
     let outcomeKind = "threw";
@@ -18553,18 +18799,18 @@ var MmtpDecodePipeline = class {
       const record = __privateGet(this, _parser2).feed(packet);
       outcomeKind = record?.kind ?? "null(parse-or-extract-failed)";
     } finally {
-      const seen = (__privateGet(this, _feedOutcomes).get(outcomeKind) ?? 0) + 1;
-      __privateGet(this, _feedOutcomes).set(outcomeKind, seen);
+      const seen = (__privateGet(this, _feedOutcomes2).get(outcomeKind) ?? 0) + 1;
+      __privateGet(this, _feedOutcomes2).set(outcomeKind, seen);
       if (seen === 1) {
         console.log(
-          `[mmtp-pipeline] feed outcome FIRST '${outcomeKind}' ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} at object #${__privateGet(this, _fedObjects)} bytes=${packet.length}`
+          `[mmtp-pipeline] feed outcome FIRST '${outcomeKind}' ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} at object #${__privateGet(this, _fedObjects2)} bytes=${packet.length}`
         );
       }
     }
-    if (__privateGet(this, _fedObjects) % 200 === 0) {
-      const hist = [...__privateGet(this, _feedOutcomes)].map(([k, v]) => `${k}=${v}`).join(" ");
+    if (__privateGet(this, _fedObjects2) % 200 === 0) {
+      const hist = [...__privateGet(this, _feedOutcomes2)].map(([k, v]) => `${k}=${v}`).join(" ");
       console.log(
-        `[mmtp-pipeline] feed histogram ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} @${__privateGet(this, _fedObjects)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
+        `[mmtp-pipeline] feed histogram ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} @${__privateGet(this, _fedObjects2)}: ${hist} | emitted=${__privateGet(this, _gateEmitted)} gateDropped=${__privateGet(this, _gateDropped)}`
       );
     }
   }
@@ -18631,9 +18877,9 @@ _codec = new WeakMap();
 _trackType = new WeakMap();
 _gateDropped = new WeakMap();
 _gateEmitted = new WeakMap();
-_fedObjects = new WeakMap();
+_fedObjects2 = new WeakMap();
 _warnedNoParser = new WeakMap();
-_feedOutcomes = new WeakMap();
+_feedOutcomes2 = new WeakMap();
 _MmtpDecodePipeline_instances = new WeakSet();
 /** Identity prefix for diagnostics: one pipeline per track means two
  *  instances write to the same console, and unlabelled lines interleave into
@@ -18649,7 +18895,7 @@ gatedEmit_fn = function(data, meta) {
       __privateSet(this, _gateDropped, __privateGet(this, _gateDropped) + 1);
       if (__privateGet(this, _gateDropped) <= 3 || __privateGet(this, _gateDropped) % 200 === 0) {
         console.warn(
-          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length} fed=${__privateGet(this, _fedObjects)} emitted=${__privateGet(this, _gateEmitted)}`
+          `[mmtp-pipeline] keyframe gate DROP #${__privateGet(this, _gateDropped)} ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} bytes=${data.length} fed=${__privateGet(this, _fedObjects2)} emitted=${__privateGet(this, _gateEmitted)}`
         );
       }
       return;
@@ -18657,7 +18903,7 @@ gatedEmit_fn = function(data, meta) {
     __privateSet(this, _needsKeyframe, false);
     sourceDiscontinuity = true;
     console.log(
-      `[mmtp-pipeline] keyframe gate OPENED ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects)}`
+      `[mmtp-pipeline] keyframe gate OPENED ${__privateMethod(this, _MmtpDecodePipeline_instances, tag_fn).call(this)} after ${__privateGet(this, _gateDropped)} drops, fed=${__privateGet(this, _fedObjects2)}`
     );
   }
   __privateSet(this, _gateEmitted, __privateGet(this, _gateEmitted) + 1);
@@ -19361,6 +19607,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;
 }
@@ -19790,6 +20046,7 @@ export {
   isSignalingPacket,
   isSourcePacket,
   isTrackTimingConfig,
+  joinedRepairSymbolCount,
   mergeOverrideIntoCmsfTracks,
   mergeOverrideIntoHangRenditions,
   mfuReassemblyTimeoutMs,