@blockcast/mmt-container 0.3.0 → 0.4.0-main.1cd3cdea89da

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

@@ -57,81 +57,20 @@ var BlockcastMmt = (() => {
     validateCmsfMmtpCatalog: () => validateCmsfMmtpCatalog
   });
 
-  // ../mmt-alta-parse/dist/index.js
+  // ../mmt-base/dist/mmtp.js
   var MMTP_HEADER_SIZE = 12;
   var MPU_HEADER_SIZE = 8;
-  var MPU_LENGTH_FIELD_SIZE = 2;
-  var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
-  var TIMED_MFU_DU_HEADER_SIZE = 14;
-  var NONTIMED_MFU_DU_HEADER_SIZE = 4;
-  var PACKET_TYPE_MPU = 0;
-  var MMTP_EXT_TYPE_ALTA_AUTH = 61601;
-  var MMTP_EXT_TRAILER_HEADER_SIZE = 4;
-  function extractAltaTrailer(mmtpPacket, options) {
-    if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
-      return null;
-    const packetType = mmtpPacket[1] & 63;
-    if (packetType !== PACKET_TYPE_MPU)
-      return null;
-    const fecType = mmtpPacket[0] >> 3 & 3;
-    let headerLength = MMTP_HEADER_SIZE;
-    if (fecType < 2 && (mmtpPacket[0] & 32) !== 0)
-      headerLength += 4;
-    if (fecType < 2 && (mmtpPacket[0] & 2) !== 0) {
-      if (headerLength + 4 > mmtpPacket.length)
-        return null;
-      const extensionLength = new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + headerLength + 2, 2).getUint16(0, false);
-      headerLength += 4 + extensionLength;
-    }
-    if (headerLength + MPU_HEADER_SIZE > mmtpPacket.length)
-      return null;
-    const payload = mmtpPacket.subarray(headerLength);
-    const payloadLength = payload[0] << 8 | payload[1];
-    const flagsByte = payload[2];
-    const fragmentType = flagsByte >> 4 & 15;
-    const timed = (flagsByte >> 3 & 1) === 1;
-    const fragmentationIndicator = flagsByte >> 1 & 3;
-    if (fragmentType !== 2)
-      return null;
-    const dataUnitHeaderSize = fragmentationIndicator <= 1 ? timed ? TIMED_MFU_DU_HEADER_SIZE : NONTIMED_MFU_DU_HEADER_SIZE : 0;
-    if (payloadLength <= MPU_HEADER_REMAINDER_SIZE + dataUnitHeaderSize)
-      return null;
-    if (fecType > 1)
-      return null;
-    const hasFecId = !options?.skipFecId && fecType === 1;
-    const payloadEnd = hasFecId ? payload.length - 4 : payload.length;
-    const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength;
-    if (declaredEnd > payloadEnd)
-      return null;
-    if (declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE > payloadEnd)
-      return null;
-    const extType = payload[declaredEnd] << 8 | payload[declaredEnd + 1];
-    if (extType !== MMTP_EXT_TYPE_ALTA_AUTH)
-      return null;
-    const extLen = payload[declaredEnd + 2] << 8 | payload[declaredEnd + 3];
-    const authStart = declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE;
-    if (authStart + extLen !== payloadEnd)
-      return null;
-    return {
-      auth: payload.subarray(authStart, payloadEnd),
-      signedEnd: headerLength + declaredEnd
-    };
-  }
-
-  // ../mmt-base/dist/mmtp.js
-  var MMTP_HEADER_SIZE2 = 12;
-  var MPU_HEADER_SIZE2 = 8;
   var MFU_DU_HEADER_SIZE_TIMED = 14;
   var MFU_DU_HEADER_SIZE_NONTIMED = 4;
-  var MPU_LENGTH_FIELD_SIZE2 = 2;
-  var MPU_HEADER_REMAINDER_SIZE2 = MPU_HEADER_SIZE2 - MPU_LENGTH_FIELD_SIZE2;
+  var MPU_LENGTH_FIELD_SIZE = 2;
+  var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
   var SOURCE_FEC_PAYLOAD_ID_SIZE = 4;
-  var PACKET_TYPE_MPU2 = 0;
+  var PACKET_TYPE_MPU = 0;
   var PACKET_TYPE_REPAIR = 3;
   var MMTP_SIGNALING_PACKET_ID = 0;
   var MMTP_PACKET_ID_MAX = 65535;
   function parseMMTPHeader(buffer) {
-    if (buffer.length < MMTP_HEADER_SIZE2) {
+    if (buffer.length < MMTP_HEADER_SIZE) {
       throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
     }
     const view2 = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
@@ -187,7 +126,7 @@ var BlockcastMmt = (() => {
     };
   }
   function parseMPUHeader(payload) {
-    if (payload.length < MPU_HEADER_SIZE2) {
+    if (payload.length < MPU_HEADER_SIZE) {
       throw new Error(`Payload too small for MPU header: ${payload.length} bytes`);
     }
     const view2 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
@@ -220,15 +159,15 @@ var BlockcastMmt = (() => {
     };
   }
   function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
-    if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE2) {
+    if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE) {
       return {
         rejection: {
           gate: "mpu-payload-length-below-header-remainder",
-          detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE2}`
+          detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE}`
         }
       };
     }
-    const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + mpu.payloadLength;
+    const declaredEnd = MPU_LENGTH_FIELD_SIZE + mpu.payloadLength;
     if (declaredEnd > payload.length) {
       return {
         rejection: {
@@ -239,7 +178,7 @@ var BlockcastMmt = (() => {
     }
     const hasHeader = fragmentType === 2 && mpu.fragmentationIndicator <= 1;
     const mfuHeaderSize = mpu.timedFlag ? MFU_DU_HEADER_SIZE_TIMED : MFU_DU_HEADER_SIZE_NONTIMED;
-    const mfuOffset = MPU_HEADER_SIZE2 + (hasHeader ? mfuHeaderSize : 0);
+    const mfuOffset = MPU_HEADER_SIZE + (hasHeader ? mfuHeaderSize : 0);
     if (mfuOffset >= declaredEnd) {
       return {
         rejection: {
@@ -256,44 +195,46 @@ var BlockcastMmt = (() => {
       }
     };
   }
-  function isEmptyOrExactAltaTrailer(payload, start, end) {
+  var LEGACY_TRAILER_EXT_TYPE = 61601;
+  var LEGACY_TRAILER_HEADER_SIZE = 4;
+  function isEmptyOrExactLegacyTrailer(payload, start, end) {
     if (start === end)
       return true;
-    if (start < 0 || end > payload.length || start + MMTP_EXT_TRAILER_HEADER_SIZE > end) {
+    if (start < 0 || end > payload.length || start + LEGACY_TRAILER_HEADER_SIZE > end) {
       return false;
     }
     const view2 = new DataView(payload.buffer, payload.byteOffset + start, end - start);
-    if (view2.getUint16(0, false) !== MMTP_EXT_TYPE_ALTA_AUTH)
+    if (view2.getUint16(0, false) !== LEGACY_TRAILER_EXT_TYPE)
       return false;
     const authLength = view2.getUint16(2, false);
-    return start + MMTP_EXT_TRAILER_HEADER_SIZE + authLength === end;
+    return start + LEGACY_TRAILER_HEADER_SIZE + authLength === end;
   }
   function resolveDeclaredTrailers(payload, declaredEnd, fecType, options) {
     if (declaredEnd > payload.length)
       return null;
     if (options?.skipFecId) {
-      return isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
+      return isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length) ? { hasFecId: false } : null;
     }
     if (fecType === 1) {
       const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
-      if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {
+      if (fecStart < declaredEnd || !isEmptyOrExactLegacyTrailer(payload, declaredEnd, fecStart)) {
         return null;
       }
       return { hasFecId: true };
     }
     if (fecType !== 0)
       return null;
-    if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {
+    if (isEmptyOrExactLegacyTrailer(payload, declaredEnd, payload.length)) {
       return { hasFecId: false };
     }
     return null;
   }
   function planMfuExtraction(mmtpPacket, options, parsedHeader) {
-    if (mmtpPacket.length < MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2) {
+    if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {
       return {
         rejection: {
           gate: "packet-shorter-than-mmtp-plus-mpu-header",
-          detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2}`
+          detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE + MPU_HEADER_SIZE}`
         }
       };
     }
@@ -312,7 +253,7 @@ var BlockcastMmt = (() => {
         };
       }
     }
-    if (header.packetType !== PACKET_TYPE_MPU2) {
+    if (header.packetType !== PACKET_TYPE_MPU) {
       return {
         rejection: {
           gate: "not-an-mpu-packet",
@@ -321,11 +262,11 @@ var BlockcastMmt = (() => {
       };
     }
     const payload = mmtpPacket.subarray(header.headerLength);
-    if (payload.length < MPU_HEADER_SIZE2) {
+    if (payload.length < MPU_HEADER_SIZE) {
       return {
         rejection: {
           gate: "payload-shorter-than-mpu-header",
-          detail: `${payload.length} bytes < ${MPU_HEADER_SIZE2}`
+          detail: `${payload.length} bytes < ${MPU_HEADER_SIZE}`
         }
       };
     }
@@ -356,7 +297,7 @@ var BlockcastMmt = (() => {
       return {
         rejection: {
           gate: "declared-trailers-unresolved",
-          detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact ALTA trailer (fecType=${header.fecType})`
+          detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact legacy authenticator trailer (fecType=${header.fecType})`
         }
       };
     }
@@ -372,8 +313,8 @@ var BlockcastMmt = (() => {
     const mfuDuHeaderPresent = layout.hasMfuDuHeader;
     const mfuOffset = layout.mfuOffset;
     const dataEnd = layout.dataEnd;
-    const mfuDuHeader = mfuDuHeaderPresent && mpu.timedFlag === 1 ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE2) : null;
-    const itemId = mfuDuHeaderPresent && mpu.timedFlag === 0 ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE2, 4).getUint32(0, false) : null;
+    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 fecPayloadId = trailerLayout.hasFecId ? {
       ssId: new DataView(mmtpPacket.buffer, mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE, SOURCE_FEC_PAYLOAD_ID_SIZE).getUint32(0, false)
@@ -381,17 +322,17 @@ var BlockcastMmt = (() => {
     return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
   }
   function sourceFecPayloadIdOf(mmtpPacket, header) {
-    if (mmtpPacket.length < MMTP_HEADER_SIZE2 + MPU_HEADER_SIZE2)
+    if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE)
       return null;
-    if (header.packetType !== PACKET_TYPE_MPU2)
+    if (header.packetType !== PACKET_TYPE_MPU)
       return null;
     const payload = mmtpPacket.subarray(header.headerLength);
-    if (payload.length < MPU_HEADER_SIZE2)
+    if (payload.length < MPU_HEADER_SIZE)
       return null;
     const payloadLength = payload[0] << 8 | payload[1];
-    if (payloadLength < MPU_HEADER_REMAINDER_SIZE2)
+    if (payloadLength < MPU_HEADER_REMAINDER_SIZE)
       return null;
-    const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + payloadLength;
+    const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength;
     if (!resolveDeclaredTrailers(payload, declaredEnd, header.fecType)?.hasFecId)
       return null;
     const off = mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
@@ -399,7 +340,6 @@ var BlockcastMmt = (() => {
       ssId: (mmtpPacket[off] << 24 | mmtpPacket[off + 1] << 16 | mmtpPacket[off + 2] << 8 | mmtpPacket[off + 3]) >>> 0
     };
   }
-  var extractAltaTrailer2 = extractAltaTrailer;
 
   // ../mmt-base/dist/ntp-short.js
   var NTP_SHORT_BITS = 32;
@@ -411,19 +351,18 @@ var BlockcastMmt = (() => {
 
   // ../mmt-base/dist/fec-block-profile.js
   var FEC_BLOCK_PROFILES = Object.freeze([
-    "k-padded-v1",
     "iso-ssbg1-v1"
   ]);
   function isFecBlockProfile(value) {
-    return value === "k-padded-v1" || value === "iso-ssbg1-v1";
+    return value === "iso-ssbg1-v1";
   }
   function parseFecBlockProfile(value, where) {
     if (isFecBlockProfile(value))
       return value;
     if (value === void 0) {
-      throw new Error(`${where} is required: name the FEC block profile ("k-padded-v1" or "iso-ssbg1-v1")`);
+      throw new Error(`${where} is required: name the FEC block profile ("iso-ssbg1-v1")`);
     }
-    throw new Error(`${where} must be "k-padded-v1" or "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
+    throw new Error(`${where} must be "iso-ssbg1-v1" (got ${JSON.stringify(value)})`);
   }
 
   // src/mfu-reassembler.ts
@@ -5318,7 +5257,7 @@ var BlockcastMmt = (() => {
     if (!a || !b || a.mediaTimescale !== b.mediaTimescale) return false;
     return b.decodeTime > a.decodeTime + BigInt(a.durationTicks);
   }
-  var _streams2, _gate, _emit2, _recordStat2, _FecReleaseSequencer_instances, streamFor_fn2, drain_fn, release_fn;
+  var _streams2, _gate, _emit2, _recordStat2, _deferDepth, _deferredStreams, _FecReleaseSequencer_instances, drainUnlessDeferred_fn, streamFor_fn2, drain_fn, release_fn;
   var FecReleaseSequencer = class {
     constructor(gate, emit, recordStat) {
       __privateAdd(this, _FecReleaseSequencer_instances);
@@ -5326,6 +5265,8 @@ var BlockcastMmt = (() => {
       __privateAdd(this, _gate);
       __privateAdd(this, _emit2);
       __privateAdd(this, _recordStat2);
+      __privateAdd(this, _deferDepth, 0);
+      __privateAdd(this, _deferredStreams, /* @__PURE__ */ new Set());
       __privateSet(this, _gate, gate);
       __privateSet(this, _emit2, emit);
       __privateSet(this, _recordStat2, recordStat);
@@ -5335,6 +5276,36 @@ var BlockcastMmt = (() => {
       for (const stream of __privateGet(this, _streams2).values()) total += stream.buf.length;
       return total;
     }
+    /**
+     * Run `work` with the drains its pushes would run deferred to its end. A
+     * recovered FEC block is routed one frame at a time, and its block is
+     * already resolved when the first frame is pushed: draining on that push
+     * would release past the gap before the block's other recovered frames
+     * arrive (deciding a conceal or stall for media that is about to land),
+     * and those frames would then be dropped as stale. Nests.
+     */
+    defer(work) {
+      __privateWrapper(this, _deferDepth)._++;
+      let threw = true;
+      try {
+        work();
+        threw = false;
+      } finally {
+        __privateWrapper(this, _deferDepth)._--;
+        if (__privateGet(this, _deferDepth) === 0 && __privateGet(this, _deferredStreams).size > 0) {
+          const streams = [...__privateGet(this, _deferredStreams)];
+          __privateGet(this, _deferredStreams).clear();
+          if (!threw) {
+            for (const stream of streams) __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+          } else {
+            try {
+              for (const stream of streams) __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+            } catch {
+            }
+          }
+        }
+      }
+    }
     push(streamKey, data, meta, seq) {
       const frame = { data, meta: { ...meta }, seq, arrivedAtMs: performance.now() };
       const stream = __privateMethod(this, _FecReleaseSequencer_instances, streamFor_fn2).call(this, streamKey, meta);
@@ -5356,7 +5327,7 @@ var BlockcastMmt = (() => {
           return;
         }
         __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, frame, void 0);
-        __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+        __privateMethod(this, _FecReleaseSequencer_instances, drainUnlessDeferred_fn).call(this, stream);
         return;
       }
       let lo = 0;
@@ -5367,7 +5338,23 @@ var BlockcastMmt = (() => {
         else hi = mid;
       }
       stream.buf.splice(lo, 0, frame);
-      __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+      __privateMethod(this, _FecReleaseSequencer_instances, drainUnlessDeferred_fn).call(this, stream);
+    }
+    /**
+     * Arrival time of the earliest frame a stream of `packetId` holds behind a
+     * gap (the gate forces it out `holdLimitMs` after that), or undefined when
+     * none is held. Without `catalogTrackName`, every stream of the packetId.
+     */
+    earliestHeldArrivalMs(packetId, catalogTrackName) {
+      let earliest;
+      for (const stream of __privateGet(this, _streams2).values()) {
+        if (stream.packetId !== packetId) continue;
+        if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+        for (const frame of stream.buf) {
+          if (earliest === void 0 || frame.arrivedAtMs < earliest) earliest = frame.arrivedAtMs;
+        }
+      }
+      return earliest;
     }
     /** Re-evaluate held gaps after FEC state changed. */
     poke(streamKey) {
@@ -5420,6 +5407,21 @@ var BlockcastMmt = (() => {
         __privateGet(this, _streams2).delete(key);
       }
     }
+    /**
+     * The packet's FEC ended, so no block will resolve a held gap: release its
+     * frames in order, each gap stalled as a discontinuity, and forget its
+     * streams, so FEC configured on it again starts from a fresh one.
+     */
+    endPacket(packetId) {
+      for (const [key, stream] of __privateGet(this, _streams2)) {
+        if (stream.packetId !== packetId) continue;
+        while (stream.buf.length > 0 && stream.last !== null) {
+          stream.discontinuity = true;
+          __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+        }
+        __privateGet(this, _streams2).delete(key);
+      }
+    }
     discardPacket(packetId) {
       for (const [key, stream] of __privateGet(this, _streams2)) {
         if (stream.packetId !== packetId) continue;
@@ -5440,7 +5442,13 @@ var BlockcastMmt = (() => {
   _gate = new WeakMap();
   _emit2 = new WeakMap();
   _recordStat2 = new WeakMap();
+  _deferDepth = new WeakMap();
+  _deferredStreams = new WeakMap();
   _FecReleaseSequencer_instances = new WeakSet();
+  drainUnlessDeferred_fn = function(stream) {
+    if (__privateGet(this, _deferDepth) > 0) __privateGet(this, _deferredStreams).add(stream);
+    else __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream);
+  };
   streamFor_fn2 = function(streamKey, meta) {
     let stream = __privateGet(this, _streams2).get(streamKey);
     if (!stream) {
@@ -5709,6 +5717,22 @@ var BlockcastMmt = (() => {
         }
       ) : null);
     }
+    /**
+     * Run `work` with the FEC release gate's drains deferred to its end, so
+     * every frame it pushes is in place before any held gap is decided (see
+     * FecReleaseSequencer.defer).
+     */
+    deferFecRelease(work) {
+      if (!__privateGet(this, _fecSequencer)) {
+        work();
+        return;
+      }
+      __privateGet(this, _fecSequencer).defer(work);
+    }
+    /** See FecReleaseSequencer.earliestHeldArrivalMs. */
+    fecReleaseEarliestHeldAtMs(packetId, catalogTrackName) {
+      return __privateGet(this, _fecSequencer)?.earliestHeldArrivalMs(packetId, catalogTrackName);
+    }
     /** Re-evaluate held gaps after FEC block state changed. */
     pokeFecRelease(packetId, catalogTrackName) {
       if (!__privateGet(this, _fecSequencer)) return;
@@ -5723,6 +5747,13 @@ var BlockcastMmt = (() => {
     markFecDiscontinuity(packetId, catalogTrackName) {
       __privateGet(this, _fecSequencer)?.markDiscontinuity(__privateMethod(this, _MmtpContainerParser_instances, streamKey_fn).call(this, packetId, catalogTrackName));
     }
+    /**
+     * The FEC of a packet ID ended: release the frames the FEC release gate
+     * holds for it in order, each gap stalled, and forget its gated streams.
+     */
+    endFecRelease(packetId) {
+      __privateGet(this, _fecSequencer)?.endPacket(packetId);
+    }
     /**
      * MPU and data-unit identity of one MMTP packet, parsed in place (no copy,
      * no reassembly). Null for non-MPU packets and packets that do not parse.
@@ -6197,7 +6228,7 @@ var BlockcastMmt = (() => {
     const parsed = preParsed !== void 0 && preParsed.skipFecPayloadId === (options?.skipFecPayloadId === true) ? preParsed : this.parsePacket(packet, options);
     if (!parsed) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "header-parse-failed");
     const info = parsed.info;
-    if (info.packetType !== PACKET_TYPE_MPU2) {
+    if (info.packetType !== PACKET_TYPE_MPU) {
       return {
         kind: info.isRepair ? "repair" : "non-media",
         packet: info,
@@ -6206,10 +6237,8 @@ var BlockcastMmt = (() => {
     }
     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);
+        __privateGet(this, _sourceSymbolCb).call(this, info.packetId, info.fecPayloadId.ssId, rawSymbol);
       } catch {
       }
     }
@@ -7165,6 +7194,14 @@ var BlockcastMmt = (() => {
   };
   function readFecBlockProfile(value, path, declaresFecInstance, fail) {
     if (value === void 0 && !declaresFecInstance) return void 0;
+    if (isFecBlockProfile(value)) return value;
+    if (typeof value === "string" && value.length > 0) {
+      return fail(
+        "track_fec_block_profile_unimplemented",
+        path,
+        `${JSON.stringify(value)} is not an implemented FEC block profile; only "iso-ssbg1-v1" is implemented`
+      );
+    }
     try {
       return parseFecBlockProfile(value, "blockProfile");
     } catch (error) {
@@ -7637,8 +7674,8 @@ var BlockcastMmt = (() => {
             "repair layers are self-describing fec-repair tracks (depends, repairLayer); fec.enhancementRepair is not supported"
           );
         }
-        if (config["interleaveDepthMs"] !== void 0 && !positiveInteger2(config["interleaveDepthMs"])) {
-          catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a positive integer");
+        if (config["interleaveDepthMs"] !== void 0 && (!Number.isSafeInteger(config["interleaveDepthMs"]) || config["interleaveDepthMs"] < 0)) {
+          catalogError("track_fec", `${path}.fec.interleaveDepthMs`, "must be a non-negative safe integer");
         }
         if (algorithm !== "none") {
           for (const field of ["sourceSymbols", "repairSymbols", "symbolSize"]) {
@@ -7713,6 +7750,13 @@ var BlockcastMmt = (() => {
         for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex++) {
           const endpoint = endpoints[endpointIndex];
           if (typeof endpoint !== "object" || endpoint === null || Array.isArray(endpoint)) continue;
+          if ("relayAddress" in endpoint) {
+            catalogError(
+              "multicast_relay_address",
+              `$.multicast.endpoints[${endpointIndex}].relayAddress`,
+              'relayAddress is retired; publish the relay as multicast.networkSource[{type:"amt",relay}]'
+            );
+          }
           const refs = endpoint["tracks"];
           if (!Array.isArray(refs)) continue;
           const packetIds = /* @__PURE__ */ new Map();
@@ -7761,7 +7805,7 @@ var BlockcastMmt = (() => {
   // ../fec/dist/oti.js
   function catalogFecInterleaveMs(fec) {
     const ms = fec?.interleaveDepthMs;
-    return typeof ms === "number" && ms > 0 && Number.isFinite(ms) ? ms : void 0;
+    return typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0 ? ms : void 0;
   }
   function computeFecTimeout(interleaveDepthMs, safetyFactor = 3) {
     if (!Number.isFinite(interleaveDepthMs) || interleaveDepthMs <= 0) {
@@ -7780,7 +7824,6 @@ var BlockcastMmt = (() => {
   var MOQ_GROUP_ID_SPAN = WRAP_EPOCH_SPAN * SS_ID_SPAN;
 
   // src/fec-state.ts
-  var MIN_INTERLEAVE_DEPTH_MS = 33;
   var FEC_INACTIVE_REASONS = Object.freeze([
     "no-catalog-fec",
     "reliable-moq",
@@ -7807,7 +7850,7 @@ var BlockcastMmt = (() => {
     const block = recordOf(fec);
     if (block === void 0 || block["blockProfile"] !== "iso-ssbg1-v1") return true;
     const ms = block["interleaveDepthMs"];
-    return typeof ms === "number" && Number.isFinite(ms) && ms >= MIN_INTERLEAVE_DEPTH_MS;
+    return ms === void 0 || typeof ms === "number" && Number.isSafeInteger(ms) && ms >= 0;
   }
   function requireBoolean(value, field) {
     if (typeof value !== "boolean") {