@blockcast/mmt-container 2.1.0 → 2.2.0-main.050b52fb9b00

package/dist/mmtp-container-parser.no-modules.js

@@ -73,6 +73,8 @@ var BlockcastMmt = (() => {
   var PACKET_TYPE_REPAIR = 3;
   var MMTP_SIGNALING_PACKET_ID = 0;
   var MMTP_PACKET_ID_MAX = 65535;
+  var FEC_CODE_REED_SOLOMON = 1;
+  var FEC_CODE_RAPTORQ = 3;
   function parseMMTPHeader(buffer) {
     if (buffer.length < MMTP_HEADER_SIZE) {
       throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
@@ -213,30 +215,26 @@ var BlockcastMmt = (() => {
     const authLength = view2.getUint16(2, false);
     return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
   }
-  function resolveDeclaredTrailers(payload, declaredEnd, fecType, options, rapFlag = false) {
+  function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
     if (declaredEnd > payload.length)
       return null;
     if (options?.skipFecId) {
-      return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false, hasOverlayFecId: false } : null;
+      return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
     }
-    const overlay = options?.overlayDeclared === true && rapFlag;
     if (fecType === 1) {
-      const fecStart = payload.length - sourceFecTrailerSize(overlay);
+      const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
       if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
         return null;
       }
-      return { hasFecId: true, hasOverlayFecId: overlay };
+      return { hasFecId: true };
     }
-    if (fecType !== 0 || overlay)
+    if (fecType !== 0)
       return null;
     if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
-      return { hasFecId: false, hasOverlayFecId: false };
+      return { hasFecId: false };
     }
     return null;
   }
-  function sourceFecTrailerSize(overlay) {
-    return overlay ? 2 * SOURCE_FEC_PAYLOAD_ID_SIZE : SOURCE_FEC_PAYLOAD_ID_SIZE;
-  }
   function planMfuExtraction(mmtpPacket, options, parsedHeader) {
     if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {
       return {
@@ -289,11 +287,11 @@ var BlockcastMmt = (() => {
     if ("rejection" in layoutResult)
       return layoutResult;
     const { layout } = layoutResult;
-    const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options, header.rapFlag);
+    const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
     if (!trailerLayout) {
       if (!options?.skipFecId && header.fecType === 1) {
         const observed = payload.length - layout.dataEnd;
-        const expected = sourceFecTrailerSize(options?.overlayDeclared === true && header.rapFlag);
+        const expected = SOURCE_FEC_PAYLOAD_ID_SIZE;
         if (observed !== expected) {
           return {
             rejection: {
@@ -325,13 +323,10 @@ var BlockcastMmt = (() => {
     const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE) : null;
     const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false) : null;
     const data = payload.subarray(mfuOffset, dataEnd);
-    const trailerStart = mmtpPacket.length - sourceFecTrailerSize(trailerLayout.hasOverlayFecId);
-    const ssIdAt = (offset) => ({
-      ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + offset, 4).getUint32(0, false)
-    });
-    const fecPayloadId = trailerLayout.hasFecId ? ssIdAt(trailerStart) : null;
-    const overlayFecPayloadId = trailerLayout.hasOverlayFecId ? ssIdAt(trailerStart + SOURCE_FEC_PAYLOAD_ID_SIZE) : null;
-    return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId, overlayFecPayloadId };
+    const fecPayloadId = trailerLayout.hasFecId ? {
+      ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, 4).getUint32(0, false)
+    } : null;
+    return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
   }
   function sourceFecPayloadIdOf(mmtpPacket, header) {
     if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
@@ -423,6 +418,50 @@ var BlockcastMmt = (() => {
   var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
   var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
 
+  // ../mmt-base/dist/signalling.js
+  var FEC_CODING_STRUCTURE_ONE_STAGE = 1;
+  var SSBG_MODE_1 = 1;
+  var RAPTORQ_MAX_SOURCE_SYMBOLS = 56403;
+  var REPAIR_SYMBOL_ID_MAX = 16777215;
+  var MIN_REPAIR_SYMBOL_SIZE = 14;
+  var REED_SOLOMON_MAX_BLOCK = 255;
+  function alFecRaptorQFlowConfig(flow) {
+    if (flow.fecCodingStructure !== FEC_CODING_STRUCTURE_ONE_STAGE || flow.repairFlows.length !== 1)
+      return null;
+    if (flow.ssbgMode !== SSBG_MODE_1 || flow.ffsrptsFlag !== 0 || flow.fecPayloadIdMode !== 0)
+      return null;
+    if (flow.packetIds.length !== 1)
+      return null;
+    const repair = flow.repairFlows[0];
+    const { fecCodeId, maximumK: k, maximumP: p } = repair;
+    const t = flow.repairSymbolSize;
+    if (t < MIN_REPAIR_SYMBOL_SIZE || k < 1 || p < 1 || k + p - 1 > REPAIR_SYMBOL_ID_MAX)
+      return null;
+    if (fecCodeId === FEC_CODE_RAPTORQ) {
+      if (t % 8 !== 0 || k > RAPTORQ_MAX_SOURCE_SYMBOLS)
+        return null;
+    } else if (fecCodeId === FEC_CODE_REED_SOLOMON) {
+      if (k + p > REED_SOLOMON_MAX_BLOCK)
+        return null;
+    } else {
+      return null;
+    }
+    if (repair.repairFlowId === MMTP_SIGNALING_PACKET_ID || repair.repairFlowId === flow.packetIds[0])
+      return null;
+    return {
+      sourcePacketIds: [...flow.packetIds],
+      repairFlowId: repair.repairFlowId,
+      fecCodeId,
+      ssbgMode: flow.ssbgMode,
+      fecPayloadIdMode: flow.fecPayloadIdMode,
+      repairSymbolSize: t,
+      maximumK: k,
+      maximumP: p,
+      protectionWindowTime: repair.protectionWindowTime,
+      protectionWindowSize: repair.protectionWindowSize
+    };
+  }
+
   // ../mmt-base/dist/serial-number.js
   var SERIAL32_SPAN = 4294967296;
   var SERIAL32_HALF = 2147483648;
@@ -5594,13 +5633,21 @@ var BlockcastMmt = (() => {
   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, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
+  var _track, _fragments, _firstSamples, _delivered, _pendingSamples, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
   var IsoBmffTimingResolver = class {
     constructor(maxPendingSamples) {
       this.maxPendingSamples = maxPendingSamples;
       __privateAdd(this, _IsoBmffTimingResolver_instances);
       __privateAdd(this, _track, null);
       __privateAdd(this, _fragments, /* @__PURE__ */ new Map());
+      /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+      __privateAdd(this, _firstSamples, /* @__PURE__ */ new Map());
+      /**
+       * First sample and sample count of the newest fragments whose every slot was
+       * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+       * matches the combiner, since it retires an abandoned sample as well.
+       */
+      __privateAdd(this, _delivered, /* @__PURE__ */ new Map());
       __privateAdd(this, _pendingSamples, 0);
       __privateAdd(this, _evictedSamples, 0);
       __privateAdd(this, _lastMovieFragmentRejection, null);
@@ -5608,6 +5655,10 @@ var BlockcastMmt = (() => {
         throw new Error("[IsoBmffTimingResolver] maxPendingSamples must be a positive integer");
       }
     }
+    /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+    get initialized() {
+      return __privateGet(this, _track) !== null;
+    }
     get pendingSampleCount() {
       return __privateGet(this, _pendingSamples);
     }
@@ -5631,7 +5682,14 @@ var BlockcastMmt = (() => {
       __privateSet(this, _track, timing);
       return true;
     }
-    addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
+    /**
+     * `recovered` marks an FEC-recovered copy. A recovered block hands back
+     * every FT=1 it holds, the received ones included, so a recovered copy of a
+     * fragment whose samples are all done is a duplicate: admitting it again
+     * would charge stale timing and could displace the live MPU's. A source
+     * copy is still admitted again (a rendition switch re-arms timing that way).
+     */
+    addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
       __privateSet(this, _lastMovieFragmentRejection, null);
       if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
         __privateSet(this, _lastMovieFragmentRejection, "invalid");
@@ -5657,6 +5715,8 @@ var BlockcastMmt = (() => {
           (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
         );
       }
+      const delivered = recovered ? __privateGet(this, _delivered).get(key) : void 0;
+      if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
       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);
@@ -5670,6 +5730,7 @@ var BlockcastMmt = (() => {
         return false;
       }
       __privateGet(this, _fragments).set(key, [...parsed.samples]);
+      __privateGet(this, _firstSamples).set(key, parsed.samples[0]);
       __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) + parsed.samples.length);
       return true;
     }
@@ -5716,11 +5777,15 @@ var BlockcastMmt = (() => {
     reset() {
       __privateSet(this, _track, null);
       __privateGet(this, _fragments).clear();
+      __privateGet(this, _firstSamples).clear();
+      __privateGet(this, _delivered).clear();
       __privateSet(this, _pendingSamples, 0);
     }
   };
   _track = new WeakMap();
   _fragments = new WeakMap();
+  _firstSamples = new WeakMap();
+  _delivered = new WeakMap();
   _pendingSamples = new WeakMap();
   _evictedSamples = new WeakMap();
   _lastMovieFragmentRejection = new WeakMap();
@@ -5739,6 +5804,7 @@ var BlockcastMmt = (() => {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     __privateGet(this, _fragments).delete(oldest);
+    __privateGet(this, _firstSamples).delete(oldest);
     __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) - live);
     __privateSet(this, _evictedSamples, __privateGet(this, _evictedSamples) + live);
     return live;
@@ -5754,7 +5820,16 @@ var BlockcastMmt = (() => {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     __privateWrapper(this, _pendingSamples)._--;
-    if (samples.every((value) => value === null)) __privateGet(this, _fragments).delete(key);
+    if (samples.every((value) => value === null)) {
+      __privateGet(this, _fragments).delete(key);
+      const first = __privateGet(this, _firstSamples).get(key);
+      __privateGet(this, _firstSamples).delete(key);
+      __privateGet(this, _delivered).delete(key);
+      __privateGet(this, _delivered).set(key, { first, sampleCount: samples.length });
+      if (__privateGet(this, _delivered).size > this.maxPendingSamples) {
+        __privateGet(this, _delivered).delete(__privateGet(this, _delivered).keys().next().value);
+      }
+    }
     return true;
   };
   function fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber) {
@@ -5930,7 +6005,10 @@ var BlockcastMmt = (() => {
   function ssIdAfter(a, b) {
     return (a - b | 0) > 0;
   }
-  var _streams2, _gate, _emit2, _recordStat2, _deferDepth, _deferredStreams, _FecReleaseSequencer_instances, drainUnlessDeferred_fn, streamFor_fn2, drain_fn, release_fn;
+  function holdsRebuilt(stream) {
+    return stream.buf.some(({ meta }) => meta.fecSbnFirst !== void 0);
+  }
+  var _streams2, _gate, _emit2, _recordStat2, _deferDepth, _deferredStreams, _FecReleaseSequencer_instances, drainUnlessDeferred_fn, streamFor_fn2, drain_fn, drainLoop_fn, cursorPassed_fn, release_fn;
   var FecReleaseSequencer = class {
     constructor(gate, emit, recordStat) {
       __privateAdd(this, _FecReleaseSequencer_instances);
@@ -5990,6 +6068,7 @@ var BlockcastMmt = (() => {
         stream.lastSbn = void 0;
         stream.discontinuity = false;
         stream.rapSsId = void 0;
+        stream.sourced = false;
       }
       if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
         __privateGet(this, _recordStat2).call(this, "droppedStale");
@@ -6016,6 +6095,7 @@ var BlockcastMmt = (() => {
         if (compareFrameOrder(stream.buf[mid], frame) < 0) lo = mid + 1;
         else hi = mid;
       }
+      if (stream.buf[lo]?.passed === true) frame.passed = true;
       stream.buf.splice(lo, 0, frame);
       __privateMethod(this, _FecReleaseSequencer_instances, drainUnlessDeferred_fn).call(this, stream);
     }
@@ -6051,6 +6131,41 @@ var BlockcastMmt = (() => {
       }
       return false;
     }
+    /**
+     * These streams' sink is being replaced by one that has seen no source
+     * frame yet. First, from a stream that holds a frame the overlay rebuilt,
+     * release to the sink being replaced the frames the unanchored path had
+     * already released to it (#cursorPassed): there they waited in its queue,
+     * which its replacement flushes. A stream that holds none is not drained:
+     * it holds nothing the anchor kept back, and a drain would still force out
+     * a frame held past the hold limit, which before the anchor waited for the
+     * next push. Then treat the streams as unsourced until a source frame is
+     * released.
+     */
+    unsource(packetId, catalogTrackName) {
+      for (const stream of __privateGet(this, _streams2).values()) {
+        if (stream.packetId === packetId && (catalogTrackName === void 0 || stream.catalogTrackName === catalogTrackName)) {
+          if (stream.draining === 0 && holdsRebuilt(stream)) {
+            if (__privateGet(this, _deferDepth) > 0) __privateGet(this, _deferredStreams).add(stream);
+            else __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream, true);
+          }
+          stream.sourced = false;
+        }
+      }
+    }
+    /**
+     * Whether a stream of `packetId` holds a frame the keyframe overlay rebuilt
+     * (FrameMeta.fecSbnFirst). Without `catalogTrackName`, every stream of the
+     * packetId.
+     */
+    holdsRebuilt(packetId, catalogTrackName) {
+      for (const stream of __privateGet(this, _streams2).values()) {
+        if (stream.packetId !== packetId) continue;
+        if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+        if (holdsRebuilt(stream)) return true;
+      }
+      return false;
+    }
     /** Re-evaluate held gaps after FEC state changed. */
     poke(streamKey) {
       if (streamKey !== void 0) {
@@ -6154,16 +6269,32 @@ var BlockcastMmt = (() => {
         last: null,
         lastSbn: void 0,
         discontinuity: false,
-        rapSsId: void 0
+        rapSsId: void 0,
+        sourced: false,
+        draining: 0
       };
       __privateGet(this, _streams2).set(streamKey, stream);
     }
     return stream;
   };
-  drain_fn = function(stream) {
+  /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
+  drain_fn = function(stream, asUnanchored = false) {
+    stream.draining++;
+    try {
+      __privateMethod(this, _FecReleaseSequencer_instances, drainLoop_fn).call(this, stream, asUnanchored);
+    } finally {
+      stream.draining--;
+    }
+  };
+  drainLoop_fn = function(stream, asUnanchored) {
     while (stream.buf.length > 0 && stream.last !== null) {
       const head = stream.buf[0];
       const last = stream.last;
+      if (compareFrameOrder(head, last) <= 0) {
+        stream.buf.shift();
+        __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, void 0);
+        continue;
+      }
       if (stream.discontinuity) {
         stream.discontinuity = false;
         stream.buf.shift();
@@ -6177,9 +6308,10 @@ var BlockcastMmt = (() => {
       }
       const headSbn = head.meta.fecSbn;
       const from = stream.lastSbn ?? headSbn;
-      const to = headSbn ?? stream.lastSbn;
+      const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn;
       let lost = [];
       const unanchored = from === void 0 && to === void 0;
+      let unresolved = false;
       if (from !== void 0 && to !== void 0) {
         const resolved = __privateGet(this, _gate).resolvedLoss(
           stream.packetId,
@@ -6188,7 +6320,8 @@ var BlockcastMmt = (() => {
           Math.max(from, to),
           from
         );
-        if (resolved === null) {
+        unresolved = resolved === null;
+        if (unresolved && !__privateMethod(this, _FecReleaseSequencer_instances, cursorPassed_fn).call(this, stream, asUnanchored)) {
           const heldMs = performance.now() - head.arrivedAtMs;
           if (heldMs <= __privateGet(this, _gate).holdLimitMs(stream.packetId, stream.catalogTrackName)) return;
           __privateGet(this, _recordStat2).call(this, "forcedWindowFlushes");
@@ -6196,18 +6329,52 @@ var BlockcastMmt = (() => {
           __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, __privateGet(this, _gate).decide(last, head, [], true));
           continue;
         }
-        lost = resolved;
+        lost = resolved ?? [];
       }
       stream.buf.shift();
-      __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, lost.length > 0 || unanchored || authoredGap(last.meta, head.meta) ? __privateGet(this, _gate).decide(last, head, lost, false) : void 0);
+      __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta) ? __privateGet(this, _gate).decide(last, head, lost, false) : void 0);
     }
   };
+  /**
+   * An overlay-rebuilt frame (fecSbnFirst) waits no longer than the BLO-53342
+   * source cursor holds it unanchored, and neither does a later frame behind
+   * it. Unanchored, a frame that waits on no block (fecSbnFirst set, or no
+   * fecSbn) left the gate once every frame ahead of it had: mark it `passed`,
+   * like each frame that arrived in front of it since (stale there). The head
+   * then goes, decided as it would be unanchored, once a frame the base path
+   * delivered (a source frame, or one base FEC recovered) is buffered after a
+   * marked one: the base path has passed that one, so a frame still missing
+   * before it can only come from a repair. It also goes while no source frame
+   * has been released, when the direct path shows a recovered frame at once.
+   * And it goes at once while a staged switch decides on when frames arrive
+   * (FecReleaseGate.releaseUnanchored), and when unsource releases into a
+   * sink being replaced: unanchored, it had already reached the sink.
+   * The scan also writes: the `passed` marks it sets stay on the frames,
+   * and push marks a frame it inserts in front of a marked one from them.
+   */
+  cursorPassed_fn = function(stream, asUnanchored) {
+    let at = -1;
+    for (let i = 0; i < stream.buf.length; i++) {
+      const frame = stream.buf[i];
+      if (frame.meta.fecSbnFirst !== void 0 || frame.meta.fecSbn === void 0) {
+        frame.passed = true;
+        if (at < 0) at = i;
+      } else if (frame.passed !== true) break;
+    }
+    if (at < 0) return false;
+    return asUnanchored || !stream.sourced || __privateGet(this, _gate).releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at && meta.fecSbnFirst === void 0 && (meta.recovered !== true || meta.fecSbn !== void 0));
+  };
   release_fn = function(stream, frame, decision) {
+    const stale = stream.last !== null && compareFrameOrder(frame, stream.last) <= 0;
+    if (stale) __privateGet(this, _recordStat2).call(this, "droppedStale");
     if (decision) frame.meta.gapBefore = decision;
     stream.last = frame;
-    if (frame.meta.fecSbn !== void 0) stream.lastSbn = frame.meta.fecSbn;
+    if (frame.meta.fecSbn !== void 0 && (frame.meta.fecSbnFirst === void 0 || stream.lastSbn !== void 0)) {
+      stream.lastSbn = frame.meta.fecSbn;
+    }
+    if (frame.meta.recovered !== true) stream.sourced = true;
     __privateGet(this, _gate).onReleased?.(frame.data, frame.meta);
-    __privateGet(this, _emit2).call(this, frame.data, frame.meta);
+    if (!stale) __privateGet(this, _emit2).call(this, frame.data, frame.meta);
   };
   var FMPU_BOX_TYPES = /* @__PURE__ */ new Set(["ftyp", "moov", "moof"]);
   function isFmp4Box(data) {
@@ -6216,7 +6383,7 @@ var BlockcastMmt = (() => {
     return FMPU_BOX_TYPES.has(type);
   }
   var MAX_AWAITING_TIMING_HEADS = 8;
-  var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _evictedTimingSamples, _rejectedMovieFragments, _sequencers, _fecGate, _fecSequencer, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed, _replayingAwaitingTiming, _fedObjects, _reassemblerFragmentsFed, _reassemblerDataUnitsReturned, _feedOutcomes, _deferredFeedOutcomes, _lastOutcome, _lastOutcomeCount, _MmtpContainerParser_instances, streamKey_fn, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, countOutcome_fn, countDeferredOutcome_fn, drop_fn, feedCounted_fn, feed_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, awaitTiming_fn, replayAwaitingTiming_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, _recoveredHeadsAwaitingTiming, _sequencers, _fecGate, _fecSequencer, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed, _replayingAwaitingTiming, _fedObjects, _reassemblerFragmentsFed, _reassemblerDataUnitsReturned, _feedOutcomes, _deferredFeedOutcomes, _lastOutcome, _lastOutcomeCount, _MmtpContainerParser_instances, streamKey_fn, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, countOutcome_fn, countDeferredOutcome_fn, drop_fn, feedCounted_fn, feed_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, awaitTiming_fn, leaveAwaitingTiming_fn, replayAwaitingTiming_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);
@@ -6252,6 +6419,12 @@ var BlockcastMmt = (() => {
       __privateAdd(this, _reclaimedTimingSamples, 0);
       __privateAdd(this, _evictedTimingSamples, 0);
       __privateAdd(this, _rejectedMovieFragments, 0);
+      __privateAdd(this, _recoveredHeadsAwaitingTiming, {
+        held: 0,
+        expired: 0,
+        discarded: 0,
+        superseded: 0
+      });
       __privateAdd(this, _sequencers, /* @__PURE__ */ new Map());
       __privateAdd(this, _fecGate, null);
       __privateAdd(this, _fecSequencer, null);
@@ -6379,11 +6552,12 @@ var BlockcastMmt = (() => {
     /**
      * Typed view of the ISO-BMFF timing-sample budget.
      *
-     * This is the acceptance signal for the budget ratchet: `pending` walking
-     * to `capacity` while `rejectedMovieFragments` climbs is the stream wedging,
-     * and it is observable here rather than only as media silently stopping.
-     * Per repo policy this is a producer-owned counter -- never infer budget
-     * state by parsing logs.
+     * Each stream admits timing against its own window of `capacity` slots
+     * (BLO-52085). A stream at capacity displaces its own oldest timing to
+     * admit the moof in hand, and `evicted` counts the slots so displaced:
+     * timing a stream declared and never delivered shows up there. `pending`
+     * sums every stream, so it can exceed `capacity`. Per repo policy this is
+     * a producer-owned counter -- never infer budget state by parsing logs.
      */
     get timingBudgetStats() {
       return {
@@ -6394,6 +6568,14 @@ var BlockcastMmt = (() => {
         rejectedMovieFragments: __privateGet(this, _rejectedMovieFragments)
       };
     }
+    /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+    get recoveredHeadsAwaitingTiming() {
+      let pending = 0;
+      for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
+        for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+      }
+      return { ...__privateGet(this, _recoveredHeadsAwaitingTiming), pending };
+    }
     get reorderStats() {
       let bufferedFrames = __privateGet(this, _fecSequencer)?.buffered ?? 0;
       for (const { sequencer } of __privateGet(this, _sequencers).values()) bufferedFrames += sequencer.buffered;
@@ -6435,6 +6617,14 @@ var BlockcastMmt = (() => {
     fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
       return __privateGet(this, _fecSequencer)?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
     }
+    /** See FecReleaseSequencer.unsource. */
+    unsourceFecRelease(packetId, catalogTrackName) {
+      __privateGet(this, _fecSequencer)?.unsource(packetId, catalogTrackName);
+    }
+    /** See FecReleaseSequencer.holdsRebuilt. */
+    fecReleaseHoldsRebuilt(packetId, catalogTrackName) {
+      return __privateGet(this, _fecSequencer)?.holdsRebuilt(packetId, catalogTrackName) ?? false;
+    }
     /** Re-evaluate held gaps after FEC block state changed. */
     pokeFecRelease(packetId, catalogTrackName) {
       if (!__privateGet(this, _fecSequencer)) return;
@@ -6545,7 +6735,7 @@ var BlockcastMmt = (() => {
       const now = Date.now();
       for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
         while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-          awaitingTiming.shift();
+          __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, awaitingTiming.shift(), "expired");
         }
       }
     }
@@ -6750,6 +6940,10 @@ var BlockcastMmt = (() => {
       }
       __privateMethod(this, _MmtpContainerParser_instances, emitFrame_fn2).call(this, data, meta);
     }
+    /** Whether FT=1 metadata already names this sample, without claiming it. */
+    hasAuthoredTimingFor(packetId, mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber, catalogTrackName) {
+      return __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, __privateMethod(this, _MmtpContainerParser_instances, streamKey_fn).call(this, packetId, catalogTrackName), packetId, false)?.sampleTiming(mpuSequenceNumber, movieFragmentSequenceNumber, sampleNumber) != null;
+    }
     /**
      * Claim and return the authored timing for a recovered sample. Recovery does
      * not pass through the ordinary `feed()` completion path, so it must retire
@@ -6794,6 +6988,9 @@ var BlockcastMmt = (() => {
       for (const { sequencer } of __privateGet(this, _sequencers).values()) sequencer.discard();
       __privateGet(this, _sequencers).clear();
       __privateGet(this, _fecSequencer)?.discard();
+      for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
+        for (const head of awaitingTiming) __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, head, "discarded");
+      }
       __privateGet(this, _timingStreams).clear();
       __privateSet(this, _pendingTimingSamples, 0);
       __privateGet(this, _reliableMoqStartupGate).clear();
@@ -6822,6 +7019,7 @@ var BlockcastMmt = (() => {
   _reclaimedTimingSamples = new WeakMap();
   _evictedTimingSamples = new WeakMap();
   _rejectedMovieFragments = new WeakMap();
+  _recoveredHeadsAwaitingTiming = new WeakMap();
   _sequencers = new WeakMap();
   _fecGate = new WeakMap();
   _fecSequencer = new WeakMap();
@@ -6980,11 +7178,16 @@ var BlockcastMmt = (() => {
       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");
+      if (!resolver2?.initialized) 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);
+      const remaining = __privateGet(this, _maxPendingTimingSamples) - resolver2.pendingSampleCount;
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) + (resolver2.pendingSampleCount - pendingBefore));
       __privateSet(this, _evictedTimingSamples, __privateGet(this, _evictedTimingSamples) + (resolver2.evictedSampleCount - evictedBefore));
       if (!admitted) {
@@ -7004,7 +7207,7 @@ var BlockcastMmt = (() => {
       };
     }
     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);
+    const resolver = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, true);
     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");
@@ -7025,6 +7228,7 @@ var BlockcastMmt = (() => {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-sample-timing-missing");
@@ -7045,7 +7249,7 @@ var BlockcastMmt = (() => {
         headTiming.size
       );
       if (readyOnRegister) {
-        const deferred = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true, options?.fecSbn);
+        const deferred = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true, options?.fecSbn, options?.fecSbnFirst);
         if (deferred.record === void 0) __privateMethod(this, _MmtpContainerParser_instances, countDeferredOutcome_fn).call(this, deferred.reason);
       }
     }
@@ -7132,7 +7336,7 @@ var BlockcastMmt = (() => {
         fragmentCounter: mpu.fragmentCounter
       };
     }
-    const outcome = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true, options?.fecSbn);
+    const outcome = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true, options?.fecSbn, options?.fecSbnFirst);
     if (outcome.record !== void 0) return outcome.record;
     return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, outcome.reason);
   };
@@ -7151,7 +7355,7 @@ var BlockcastMmt = (() => {
    * attribution exists to keep readable. Leaving the choice at the call site
    * is what keeps both true.
    */
-  emitCombinedSample_fn = function(combined, info, resolver, recovered, fecSbn) {
+  emitCombinedSample_fn = function(combined, info, resolver, recovered, fecSbn, fecSbnFirst) {
     const timing = resolver.sampleTiming(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -7162,6 +7366,7 @@ var BlockcastMmt = (() => {
     const meta = __privateMethod(this, _MmtpContainerParser_instances, buildFrameMeta_fn).call(this, combined, info.packetId, info.sequenceNumber, timing, recovered);
     if (!meta) return { reason: "combined-meta-build-failed" };
     if (fecSbn !== void 0) meta.fecSbn = fecSbn;
+    if (fecSbnFirst !== void 0) meta.fecSbnFirst = fecSbnFirst;
     if (!resolver.consumeSample(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -7206,10 +7411,23 @@ var BlockcastMmt = (() => {
     return resolver;
   };
   awaitTiming_fn = function(streamKey, head) {
-    const awaitingTiming = __privateGet(this, _timingStreams).get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = __privateGet(this, _timingStreams).get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      __privateGet(this, _recoveredHeadsAwaitingTiming).superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) __privateGet(this, _recoveredHeadsAwaitingTiming).held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, awaitingTiming.shift(), "expired");
+    }
+  };
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  leaveAwaitingTiming_fn = function(head, outcome) {
+    if (head.options?.recovered) __privateGet(this, _recoveredHeadsAwaitingTiming)[outcome]++;
   };
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -7237,6 +7455,7 @@ var BlockcastMmt = (() => {
     const state = __privateGet(this, _timingStreams).get(streamKey);
     if (!state) return;
     __privateGet(this, _timingStreams).delete(streamKey);
+    for (const head of state.awaitingTiming) __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, head, "discarded");
     __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) - state.resolver.pendingSampleCount);
     if (__privateGet(this, _pendingTimingSamples) < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");
@@ -8217,7 +8436,7 @@ var BlockcastMmt = (() => {
   // src/mmtp-fec-session.ts
   var PATH_BITS = { moq: 1, multicast: 2 };
   var MIXED_PATHS = PATH_BITS.moq | PATH_BITS.multicast;
-  var _decoder, _blocks, _settled, _have, _newest, _prunedAt, _repairPacketId, _newestSource, _heldLayers, _anchorHorizon, _stats3, _MmtpFecSession_instances, drop_fn2, noteNewest_fn, blockStartOf_fn, countHeld_fn, noteMixed_fn, behindHorizon_fn, settle_fn, settleClean_fn, settleDecoded_fn, retireBehindHorizon_fn;
+  var _decoder, _repairSymbols, _message, _blocks, _settled, _have, _newest, _prunedAt, _repairPacketId, _newestSource, _heldLayers, _anchorHorizon, _stats3, _MmtpFecSession_instances, trackFor_fn, drop_fn2, noteNewest_fn, blockStartOf_fn, countHeld_fn, noteMixed_fn, behindHorizon_fn, settle_fn, settleClean_fn, settleDecoded_fn, retireBehindHorizon_fn;
   var MmtpFecSession = class {
     /**
      * @throws when the instance lacks or misstates a field the session needs:
@@ -8227,6 +8446,9 @@ var BlockcastMmt = (() => {
     constructor(config) {
       __privateAdd(this, _MmtpFecSession_instances);
       __privateAdd(this, _decoder);
+      __privateAdd(this, _repairSymbols);
+      /** The message entry a catalog-less session was built from; undefined under a catalog. */
+      __privateAdd(this, _message);
       /** Blocks a repair has defined and that are not settled yet, by SS_Start. */
       __privateAdd(this, _blocks, /* @__PURE__ */ new Map());
       /** SS_Starts of settled blocks, so a later repair for one is refused. */
@@ -8258,6 +8480,24 @@ var BlockcastMmt = (() => {
         mixedPath: { clean: 0, recovered: 0, failed: 0, released: 0 },
         failClosed: null
       });
+      if (config && "alFecFlow" in config) {
+        const message = alFecRaptorQFlowConfig(config.alFecFlow);
+        if (!message) {
+          throw new Error("MmtpFecSession: the AL-FEC entry is outside draft-ramadan-moq-mmt-02 8.3 (iso-ssbg1-v1)");
+        }
+        __privateSet(this, _message, message);
+        this.blockProfile = parseFecBlockProfile("iso-ssbg1-v1", "alFecFlow");
+        this.algorithm = message.fecCodeId === FEC_CODE_RAPTORQ ? "raptorq" : "reed-solomon";
+        this.sourceSymbols = message.maximumK;
+        __privateSet(this, _repairSymbols, message.maximumP);
+        this.symbolSize = message.repairSymbolSize;
+        this.retentionBlocks = requirePositiveInteger(config.retentionBlocks, "retentionBlocks");
+        __privateSet(this, _repairPacketId, message.repairFlowId);
+        __privateSet(this, _heldLayers, layerZero(message.maximumP));
+        __privateSet(this, _anchorHorizon, heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols));
+        __privateSet(this, _decoder, buildDecoder(config.Decoder, this));
+        return;
+      }
       const fec = config?.fec;
       if (!fec || typeof fec !== "object") {
         throw new Error("MmtpFecSession: the catalog fec instance is required");
@@ -8268,7 +8508,7 @@ var BlockcastMmt = (() => {
       }
       this.algorithm = fec.scheme;
       this.sourceSymbols = requirePositiveInteger(fec.sourceSymbols, "fec.sourceSymbols");
-      this.repairSymbols = requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols");
+      __privateSet(this, _repairSymbols, requirePositiveInteger(fec.repairSymbols, "fec.repairSymbols"));
       this.symbolSize = requirePositiveInteger(fec.symbolSize, "fec.symbolSize");
       const interleaveDepthMs = requireNumber(fec.interleaveDepthMs, "fec.interleaveDepthMs");
       const reorderToleranceMs = requireNumber(fec.reorderToleranceMs, "fec.reorderToleranceMs");
@@ -8288,17 +8528,34 @@ var BlockcastMmt = (() => {
         config.heldLayers
       ));
       __privateSet(this, _anchorHorizon, heldLayerAnchorHorizon(this.retentionBlocks, this.sourceSymbols));
-      if (typeof config.Decoder !== "function") {
-        throw new Error("MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required");
-      }
-      const decoder = new config.Decoder(this.retentionBlocks, this.blockProfile, this.algorithm);
-      try {
-        decoder.configure_params(this.sourceSymbols, this.symbolSize);
-      } catch (error) {
-        decoder.free();
-        throw error;
-      }
-      __privateSet(this, _decoder, decoder);
+      __privateSet(this, _decoder, buildDecoder(config.Decoder, this));
+    }
+    /** P_0 = B_0, the held total every repair packet is checked against. */
+    get repairSymbols() {
+      return __privateGet(this, _repairSymbols);
+    }
+    /**
+     * A later version of the AL-FEC message, catalog-less sessions only. A
+     * maximum_p_for_repair_flow above the held total raises it (`raised`): the
+     * anchored check restarts at the new total, so a block generated under the
+     * previous one stays valid before the first block carrying the new total
+     * (fec-core-00 7.3.2, mmt-02 8.3). A field at or below it changes nothing
+     * (`unchanged`): no publisher lowers it, and the check catches a wire that
+     * does. An entry with another asset, repair flow, code point, K or T, or
+     * one outside 8.3, is `refused`: that is a new source encoding, which needs
+     * a new session. A latched fail-closed stays latched either way.
+     */
+    updateAlFecFlow(flow) {
+      const held = __privateGet(this, _message);
+      if (!held) throw new Error("MmtpFecSession: updateAlFecFlow() needs a session built from an AL-FEC entry");
+      const next = alFecRaptorQFlowConfig(flow);
+      if (!next || next.sourcePacketIds[0] !== held.sourcePacketIds[0] || next.repairFlowId !== held.repairFlowId || next.fecCodeId !== held.fecCodeId || next.maximumK !== held.maximumK || next.repairSymbolSize !== held.repairSymbolSize) {
+        return "refused";
+      }
+      if (next.maximumP <= __privateGet(this, _repairSymbols)) return "unchanged";
+      __privateSet(this, _repairSymbols, next.maximumP);
+      __privateSet(this, _heldLayers, layerZero(next.maximumP));
+      return "raised";
     }
     /** True once release() ran. */
     get released() {
@@ -8393,7 +8650,7 @@ var BlockcastMmt = (() => {
       }
       if (admission.reject) {
         const verdict2 = __privateGet(this, _heldLayers).failsClosed(
-          repairTrackName,
+          __privateMethod(this, _MmtpFecSession_instances, trackFor_fn).call(this, repairTrackName),
           frame.ssStart,
           frame.rsbLength,
           __privateGet(this, _anchorHorizon),
@@ -8408,7 +8665,7 @@ var BlockcastMmt = (() => {
       __privateGet(this, _repairPacketId) ?? __privateSet(this, _repairPacketId, frame.packetId);
       if (frame.ssbLength > this.sourceSymbols) return __privateMethod(this, _MmtpFecSession_instances, drop_fn2).call(this, "repair:ssb-length");
       const verdict = __privateGet(this, _heldLayers).admit(
-        repairTrackName,
+        __privateMethod(this, _MmtpFecSession_instances, trackFor_fn).call(this, repairTrackName),
         frame.ssStart,
         frame.rsbLength,
         __privateGet(this, _anchorHorizon),
@@ -8469,6 +8726,8 @@ var BlockcastMmt = (() => {
     }
   };
   _decoder = new WeakMap();
+  _repairSymbols = new WeakMap();
+  _message = new WeakMap();
   _blocks = new WeakMap();
   _settled = new WeakMap();
   _have = new WeakMap();
@@ -8480,6 +8739,10 @@ var BlockcastMmt = (() => {
   _anchorHorizon = new WeakMap();
   _stats3 = new WeakMap();
   _MmtpFecSession_instances = new WeakSet();
+  /** Catalog-less: layer 0 has no own-track clause (mmt-02 8.3), so no track name is judged. */
+  trackFor_fn = function(repairTrackName) {
+    return __privateGet(this, _message) ? void 0 : repairTrackName;
+  };
   drop_fn2 = function(reason) {
     __privateGet(this, _stats3).dropped[reason] = (__privateGet(this, _stats3).dropped[reason] ?? 0) + 1;
     return [];
@@ -8600,6 +8863,22 @@ var BlockcastMmt = (() => {
       if (__privateMethod(this, _MmtpFecSession_instances, behindHorizon_fn).call(this, start)) __privateGet(this, _settled).delete(start);
     }
   };
+  function layerZero(total) {
+    return new HeldLayerAdmission([{ layer: 0, repairTrackName: "", rsIdOffset: 0, repairSymbols: total }]);
+  }
+  function buildDecoder(Decoder, session) {
+    if (typeof Decoder !== "function") {
+      throw new Error("MmtpFecSession: a decoder constructor (wasm_bindgen.MmtFecDecoder) is required");
+    }
+    const decoder = new Decoder(session.retentionBlocks, session.blockProfile, session.algorithm);
+    try {
+      decoder.configure_params(session.sourceSymbols, session.symbolSize);
+    } catch (error) {
+      decoder.free();
+      throw error;
+    }
+    return decoder;
+  }
   function requirePositiveInteger(value, path) {
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
       throw new Error(`MmtpFecSession: ${path} must be a positive integer (got ${String(value)})`);