@blockcast/mmt-container 0.1.0 → 0.3.0

package/dist/timestamp-codec.js

@@ -0,0 +1,473 @@
+// ../mmt-alta-parse/dist/index.js
+var MPU_HEADER_SIZE = 8;
+var MPU_LENGTH_FIELD_SIZE = 2;
+var MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE;
+var MMTP_EXT_TYPE_ALTA_AUTH = 61601;
+var MMTP_EXT_TRAILER_HEADER_SIZE = 4;
+
+// ../mmt-base/dist/mmtp.js
+var MMTP_HEADER_SIZE = 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 SOURCE_FEC_PAYLOAD_ID_SIZE = 4;
+var PACKET_TYPE_MPU = 0;
+function parseMMTPHeader(buffer) {
+  if (buffer.length < MMTP_HEADER_SIZE) {
+    throw new Error(`MMTP packet too small: ${buffer.length} bytes`);
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const version = buffer[0] >> 6 & 3;
+  if (version !== 0) {
+    throw new Error(`Unsupported MMTP version: ${version}`);
+  }
+  const fecType = buffer[0] >> 3 & 3;
+  const packetCounterFlag = (buffer[0] & 32) !== 0;
+  const extensionFlag = (buffer[0] & 2) !== 0;
+  const rapFlag = (buffer[0] & 1) === 1;
+  const packetType = buffer[1] & 63;
+  let offset = 2;
+  const packetId = view.getUint16(offset, false);
+  offset += 2;
+  const timestamp = BigInt(view.getUint32(offset, false));
+  offset += 4;
+  const sequenceNumber = view.getUint32(offset, false);
+  offset += 4;
+  let packetCounter;
+  if (packetCounterFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in packet_counter");
+    packetCounter = view.getUint32(offset, false);
+    offset += 4;
+  }
+  let extension;
+  if (extensionFlag) {
+    if (offset + 4 > buffer.length)
+      throw new Error("MMTP packet truncated in header extension");
+    const type = view.getUint16(offset, false);
+    const length = view.getUint16(offset + 2, false);
+    offset += 4;
+    if (offset + length > buffer.length)
+      throw new Error("MMTP packet truncated in header extension value");
+    extension = { type, data: buffer.subarray(offset, offset + length) };
+    offset += length;
+  }
+  return {
+    version,
+    packetType,
+    packetId,
+    timestamp,
+    sequenceNumber,
+    payloadLength: buffer.length - offset,
+    fecType,
+    packetCounterFlag,
+    packetCounter,
+    extensionFlag,
+    extension,
+    headerLength: offset,
+    rapFlag
+  };
+}
+function unwrapMMTP(buffer) {
+  const header = parseMMTPHeader(buffer);
+  const payload = buffer.subarray(header.headerLength);
+  return { header, payload };
+}
+function parseMPUHeader(payload) {
+  if (payload.length < MPU_HEADER_SIZE2) {
+    throw new Error(`Payload too small for MPU header: ${payload.length} bytes`);
+  }
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  const payloadLength = view.getUint16(0, false);
+  const flagsByte = payload[2];
+  const timedFlag = flagsByte >> 3 & 1;
+  const fragmentationIndicator = flagsByte >> 1 & 3;
+  const aggregationFlag = (flagsByte & 1) !== 0;
+  const fragmentCounter = payload[3];
+  const mpuSequenceNumber = view.getUint32(4, false);
+  return {
+    mpuSequenceNumber,
+    fragmentationIndicator,
+    fragmentCounter,
+    timedFlag,
+    aggregationFlag,
+    payloadLength
+  };
+}
+function parseTimedMfuDuHeader(payload, offset) {
+  if (offset < 0 || offset + MFU_DU_HEADER_SIZE_TIMED > payload.length)
+    return null;
+  const view = new DataView(payload.buffer, payload.byteOffset + offset, MFU_DU_HEADER_SIZE_TIMED);
+  return {
+    movieFragmentSequenceNumber: view.getUint32(0, false),
+    sampleNumber: view.getUint32(4, false),
+    offset: view.getUint32(8, false),
+    priority: payload[offset + 12],
+    dependencyCounter: payload[offset + 13]
+  };
+}
+function resolveMfuPayloadLayout(mpu, fragmentType, payload) {
+  if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE2) {
+    return {
+      rejection: {
+        gate: "mpu-payload-length-below-header-remainder",
+        detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE2}`
+      }
+    };
+  }
+  const declaredEnd = MPU_LENGTH_FIELD_SIZE2 + mpu.payloadLength;
+  if (declaredEnd > payload.length) {
+    return {
+      rejection: {
+        gate: "mpu-declared-end-exceeds-payload",
+        detail: `payload_length=${mpu.payloadLength} implies end=${declaredEnd}, payload is ${payload.length} bytes`
+      }
+    };
+  }
+  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);
+  if (mfuOffset >= declaredEnd) {
+    return {
+      rejection: {
+        gate: "mfu-offset-at-or-past-declared-end",
+        detail: `mfuOffset=${mfuOffset} >= declaredEnd=${declaredEnd}`
+      }
+    };
+  }
+  return {
+    layout: {
+      hasMfuDuHeader: hasHeader,
+      mfuOffset,
+      dataEnd: declaredEnd
+    }
+  };
+}
+function isEmptyOrExactAltaTrailer(payload, start, end) {
+  if (start === end)
+    return true;
+  if (start < 0 || end > payload.length || start + MMTP_EXT_TRAILER_HEADER_SIZE > end) {
+    return false;
+  }
+  const view = new DataView(payload.buffer, payload.byteOffset + start, end - start);
+  if (view.getUint16(0, false) !== MMTP_EXT_TYPE_ALTA_AUTH)
+    return false;
+  const authLength = view.getUint16(2, false);
+  return start + MMTP_EXT_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;
+  }
+  if (fecType === 1) {
+    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE;
+    if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {
+      return null;
+    }
+    return { hasFecId: true };
+  }
+  if (fecType !== 0)
+    return null;
+  if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {
+    return { hasFecId: false };
+  }
+  return null;
+}
+function extractNALUnit(mmtpPacket) {
+  const extraction = extractMFUPayload(mmtpPacket);
+  if (!extraction)
+    throw new Error("Malformed MMTP MPU payload");
+  return extraction.data;
+}
+function planMfuExtraction(mmtpPacket, options, parsedHeader) {
+  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE2) {
+    return {
+      rejection: {
+        gate: "packet-shorter-than-mmtp-plus-mpu-header",
+        detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE + MPU_HEADER_SIZE2}`
+      }
+    };
+  }
+  let header;
+  if (parsedHeader) {
+    header = parsedHeader;
+  } else {
+    try {
+      header = parseMMTPHeader(mmtpPacket);
+    } catch (error) {
+      return {
+        rejection: {
+          gate: "mmtp-header-unparseable",
+          detail: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  if (header.packetType !== PACKET_TYPE_MPU) {
+    return {
+      rejection: {
+        gate: "not-an-mpu-packet",
+        detail: `packetType=0x${header.packetType.toString(16).padStart(2, "0")}`
+      }
+    };
+  }
+  const payload = mmtpPacket.subarray(header.headerLength);
+  if (payload.length < MPU_HEADER_SIZE2) {
+    return {
+      rejection: {
+        gate: "payload-shorter-than-mpu-header",
+        detail: `${payload.length} bytes < ${MPU_HEADER_SIZE2}`
+      }
+    };
+  }
+  const mpu = parseMPUHeader(payload);
+  if (mpu.aggregationFlag) {
+    return {
+      rejection: { gate: "aggregation-flag-set", detail: "strict profile requires A=0" }
+    };
+  }
+  const fragmentType = payload[2] >> 4 & 15;
+  const layoutResult = resolveMfuPayloadLayout(mpu, fragmentType, payload);
+  if ("rejection" in layoutResult)
+    return layoutResult;
+  const { layout } = layoutResult;
+  const trailerLayout = resolveDeclaredTrailers(payload, layout.dataEnd, header.fecType, options);
+  if (!trailerLayout) {
+    if (!options?.skipFecId && header.fecType === 1) {
+      const observed = payload.length - layout.dataEnd;
+      if (observed !== SOURCE_FEC_PAYLOAD_ID_SIZE) {
+        return {
+          rejection: {
+            gate: "source-fec-payload-id-width-mismatch",
+            detail: `producer wrote a ${observed}-byte Source FEC Payload ID, ISO/IEC 23008-1 \xA7C.5.2 requires ${SOURCE_FEC_PAYLOAD_ID_SIZE} (payload=${payload.length}, declaredEnd=${layout.dataEnd})`
+          }
+        };
+      }
+    }
+    return {
+      rejection: {
+        gate: "declared-trailers-unresolved",
+        detail: `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty nor an exact ALTA trailer (fecType=${header.fecType})`
+      }
+    };
+  }
+  return { plan: { header, payload, mpu, fragmentType, layout, trailerLayout } };
+}
+function extractMFUPayload(mmtpPacket, options) {
+  return extractPlannedMfu(mmtpPacket, planMfuExtraction(mmtpPacket, options));
+}
+function extractPlannedMfu(mmtpPacket, result) {
+  if ("rejection" in result)
+    return null;
+  const { header, payload, mpu, fragmentType, layout, trailerLayout } = result.plan;
+  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 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)
+  } : null;
+  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId };
+}
+function extractTimestamp(mmtpPacket) {
+  const { header } = unwrapMMTP(mmtpPacket);
+  return header.timestamp;
+}
+
+// ../mmt-base/dist/ntp-short.js
+var NTP_SHORT_BITS = 32;
+var NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS;
+var NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1);
+
+// ../mmt-base/dist/fec-block-profile.js
+var FEC_BLOCK_PROFILES = Object.freeze([
+  "k-padded-v1",
+  "iso-ssbg1-v1"
+]);
+
+// src/timestamp-codec.ts
+var DEFAULT_CONTAINER = "legacy";
+function encodeTimestamp(timestamp, container = DEFAULT_CONTAINER) {
+  switch (container) {
+    case "legacy":
+      return encodeVarInt(timestamp);
+    case "raw":
+      return encodeU64(timestamp);
+    case "mmtp":
+    case "mmtp-fec":
+      return encodeU64(timestamp);
+    case "loc":
+      return encodeLocTimestamp(timestamp);
+    case "fmp4":
+      throw new Error("fmp4 container not yet implemented");
+  }
+}
+function decodeTimestamp(buffer, container = DEFAULT_CONTAINER) {
+  switch (container) {
+    case "legacy": {
+      const [value, remaining] = decodeVarInt(buffer);
+      return [value, remaining];
+    }
+    case "raw": {
+      const [value, remaining] = decodeU64(buffer);
+      return [value, remaining];
+    }
+    case "mmtp":
+    case "mmtp-fec": {
+      const timestamp = extractTimestamp(buffer);
+      const payload = extractNALUnit(buffer);
+      return [Number(timestamp), payload];
+    }
+    case "loc": {
+      const [ts, payload] = decodeLocTimestamp(buffer);
+      return [ts, payload];
+    }
+    case "fmp4":
+      throw new Error("fmp4 container not yet implemented");
+  }
+}
+function getTimestampSize(container = DEFAULT_CONTAINER) {
+  switch (container) {
+    case "legacy":
+      return 8;
+    case "raw":
+      return 8;
+    case "mmtp":
+    case "mmtp-fec":
+      return 12;
+    case "loc":
+      return 11;
+    case "fmp4":
+      throw new Error("fmp4 container not yet implemented");
+  }
+}
+var MAX_U6 = 2 ** 6 - 1;
+var MAX_U14 = 2 ** 14 - 1;
+var MAX_U30 = 2 ** 30 - 1;
+var MAX_U53 = Number.MAX_SAFE_INTEGER;
+function decodeVarInt(buf) {
+  const size = 1 << ((buf[0] & 192) >> 6);
+  const view = new DataView(buf.buffer, buf.byteOffset, size);
+  const remain = new Uint8Array(buf.buffer, buf.byteOffset + size, buf.byteLength - size);
+  let v;
+  if (size === 1) {
+    v = buf[0] & 63;
+  } else if (size === 2) {
+    v = view.getUint16(0) & 16383;
+  } else if (size === 4) {
+    v = view.getUint32(0) & 1073741823;
+  } else if (size === 8) {
+    v = Number(view.getBigUint64(0) & 0x3fffffffffffffffn);
+  } else {
+    throw new Error("impossible");
+  }
+  return [v, remain];
+}
+function encodeVarInt(v) {
+  if (v > MAX_U53) throw new RangeError("value too large for varint");
+  let size;
+  if (v <= MAX_U6) {
+    size = 1;
+  } else if (v <= MAX_U14) {
+    size = 2;
+  } else if (v <= MAX_U30) {
+    size = 4;
+  } else {
+    size = 8;
+  }
+  const arr = new Uint8Array(size);
+  const view = new DataView(arr.buffer, arr.byteOffset, size);
+  const prefixMap = { 1: 0, 2: 1, 4: 2, 8: 3 };
+  const prefix = prefixMap[size];
+  if (size === 1) {
+    view.setUint8(0, prefix << 6 | v);
+  } else if (size === 2) {
+    view.setUint16(0, prefix << 14 | v);
+  } else if (size === 4) {
+    view.setUint32(0, prefix << 30 | v);
+  } else if (size === 8) {
+    view.setBigUint64(0, BigInt(prefix) << 62n | BigInt(v));
+  }
+  return arr;
+}
+function decodeU64(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, 8);
+  const remain = new Uint8Array(buf.buffer, buf.byteOffset + 8, buf.byteLength - 8);
+  const v = Number(view.getBigUint64(0));
+  return [v, remain];
+}
+function encodeU64(v) {
+  const arr = new Uint8Array(8);
+  const view = new DataView(arr.buffer, arr.byteOffset, 8);
+  view.setBigUint64(0, BigInt(v));
+  return arr;
+}
+var LOC_HEADER_VARINTS = 4;
+var LOC_EXT_CAPTURE_TIMESTAMP = 2;
+var LOC_EXT_VIDEO_FRAME_MARKING = 4;
+function decodeLocTimestamp(buffer) {
+  const { timestamp, payload } = decodeLocHeader(buffer);
+  return [timestamp, payload];
+}
+function decodeLocHeader(buffer) {
+  const readVarInt = (buf, field) => {
+    if (buf.length === 0) {
+      throw new Error(
+        `LOC header truncated at ${field}: buffer is ${buffer.byteLength} bytes, expected ${LOC_HEADER_VARINTS} varints`
+      );
+    }
+    try {
+      return decodeVarInt(buf);
+    } catch {
+      throw new Error(
+        `LOC header truncated at ${field}: ${buf.length} byte(s) remain, too few for the declared varint width`
+      );
+    }
+  };
+  const [tsId, afterTsId] = readVarInt(buffer, "CaptureTimestamp ID");
+  if (tsId !== LOC_EXT_CAPTURE_TIMESTAMP) {
+    throw new Error(
+      `LOC header extension IDs: expected ${LOC_EXT_CAPTURE_TIMESTAMP} (CaptureTimestamp) first, got ${tsId}. The producer is advertising packaging="loc" but not emitting LOC framing \u2014 see hang Avc1::set_explicit_container / Aac::set_container.`
+    );
+  }
+  const [timestamp, afterTs] = readVarInt(afterTsId, "CaptureTimestamp value");
+  const [kfId, afterKfId] = readVarInt(afterTs, "VideoFrameMarking ID");
+  if (kfId !== LOC_EXT_VIDEO_FRAME_MARKING) {
+    throw new Error(
+      `LOC header extension IDs: expected ${LOC_EXT_VIDEO_FRAME_MARKING} (VideoFrameMarking) second, got ${kfId}.`
+    );
+  }
+  const [kfValue, payload] = readVarInt(afterKfId, "VideoFrameMarking value");
+  return { timestamp, keyframe: (kfValue & 1) === 1, payload };
+}
+function encodeLocTimestamp(timestamp, keyframe = false) {
+  const parts = [
+    encodeVarInt(LOC_EXT_CAPTURE_TIMESTAMP),
+    encodeVarInt(timestamp),
+    encodeVarInt(LOC_EXT_VIDEO_FRAME_MARKING),
+    encodeVarInt(keyframe ? 1 : 0)
+  ];
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+export {
+  decodeLocHeader,
+  decodeLocTimestamp,
+  decodeTimestamp,
+  encodeLocTimestamp,
+  encodeTimestamp,
+  getTimestampSize
+};
+//# sourceMappingURL=timestamp-codec.js.map

package/dist/timestamp-codec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../mmt-alta-parse/src/index.ts", "../../mmt-base/src/mmtp.ts", "../../mmt-base/src/ntp-short.ts", "../../mmt-base/src/fec-block-profile.ts", "../src/timestamp-codec.ts"],
+  "sourcesContent": ["/**\n * Zero-dependency helper for extracting the detached ALTA authenticator trailer\n * from an MMTP source packet.\n *\n * Lives in its own leaf package so both `@blockcast/mmt-container` (wire-path\n * parsing) and `@blockcast/fec-worker` (FEC-recovered-source parsing) can share\n * one implementation without creating a package cycle between them.\n *\n * Spec: ISO/IEC 23008-1:2023 + draft-ramadan-moq-mmt \u00A712 (detached trailer, Path 2).\n */\n\n// --- Private MMTP/MPU/MFU constants (ISO/IEC 23008-1 \u00A79.2.2\u20139.2.3) ---\n// Duplicated here as immutable spec values so this package stays a leaf with\n// zero `@blockcast/*` dependencies. Re-deriving from `mmt-container` would\n// reintroduce the package cycle this split exists to avoid.\n\nconst MMTP_HEADER_SIZE = 12\nconst MPU_HEADER_SIZE = 8\nconst MPU_LENGTH_FIELD_SIZE = 2\nconst MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE\nconst TIMED_MFU_DU_HEADER_SIZE = 14\nconst NONTIMED_MFU_DU_HEADER_SIZE = 4\nconst PACKET_TYPE_MPU = 0x00\n\n// --- Public ALTA trailer constants ---\n\n/**\n * MMTP header-extension ext_type assigned to the detached ALTA authenticator\n * trailer (Path 2 / 08-07). Carried in an `[ext_type][ext_length][auth]`\n * block appended after the MPU's declared payload bytes, before the 4-byte\n * Source FEC Payload ID. MMTP X-bit stays 0 \u2014 non-ALTA MMTP receivers treat\n * the trailer as bytes past `payload_length` and skip it (per ISO 23008-1\n * \u00A79.2.2 \"may be discarded without impacting correct processing\").\n */\nexport const MMTP_EXT_TYPE_ALTA_AUTH = 0xf0a1\n\n/** Fixed size of the trailer's `[ext_type][ext_length]` prefix (2 + 2 BE). */\nexport const MMTP_EXT_TRAILER_HEADER_SIZE = 4\n\n/** Result of extracting the detached ALTA authenticator from an MMTP packet. */\nexport interface AltaTrailer {\n  /** Authenticator bytes (no ext_type/ext_length prefix, no trailing padding). */\n  auth: Uint8Array\n  /**\n   * Wire-packet byte offset where the signed payload ends, i.e. where the\n   * trailer begins. Caller uses this to produce\n   * `payload = wirePacket.subarray(0, signedEnd)` for verify_detached.\n   */\n  signedEnd: number\n}\n\n/**\n * Extract the detached ALTA authenticator trailer from an MMTP source packet.\n *\n * Wire layout:\n *   `[MMTP hdr][length(2)][remaining MPU hdr(6)][DU?][media][TRAILER][SS_ID?]`\n *   `payload_length = 6 + DU bytes + media bytes`\n *\n * Returns `null` when:\n * - the packet is too small / malformed,\n * - `payload_length` cannot contain the remaining six MPU-header bytes,\n * - the declared payload overruns the packet,\n * - no bytes remain between `payload_length` and the SS_ID,\n * - the trailer's `ext_type` isn't {@link MMTP_EXT_TYPE_ALTA_AUTH},\n * - the declared `ext_length` would extend past the SS_ID boundary.\n *\n * Non-MPU packets (repair, signaling) always return `null`.\n *\n * @param options.skipFecId When true, do NOT reserve 4 trailing bytes for the\n *   Source FEC Payload ID. Use on FEC-recovered symbols where the PID has\n *   already been stripped upstream.\n */\nexport function extractAltaTrailer(\n  mmtpPacket: Uint8Array,\n  options?: { skipFecId?: boolean },\n): AltaTrailer | null {\n  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) return null\n  // ISO/IEC 23008-1:2023 Figure 8 places V=0 packet_type in the low six bits.\n  const packetType = mmtpPacket[1]! & 0x3f\n  if (packetType !== PACKET_TYPE_MPU) return null\n\n  const fecType = (mmtpPacket[0]! >> 3) & 0x03\n  let headerLength = MMTP_HEADER_SIZE\n  if (fecType < 2 && (mmtpPacket[0]! & 0x20) !== 0) headerLength += 4\n  if (fecType < 2 && (mmtpPacket[0]! & 0x02) !== 0) {\n    if (headerLength + 4 > mmtpPacket.length) return null\n    const extensionLength = new DataView(\n      mmtpPacket.buffer,\n      mmtpPacket.byteOffset + headerLength + 2,\n      2,\n    ).getUint16(0, false)\n    headerLength += 4 + extensionLength\n  }\n  if (headerLength + MPU_HEADER_SIZE > mmtpPacket.length) return null\n\n  const payload = mmtpPacket.subarray(headerLength)\n\n  // Inline a minimal MPU-header read \u2014 only the fields extractAltaTrailer needs.\n  // payloadLength: 16 BE at bytes 0-1.\n  // Byte 2 packs FT(4) | T(1) | FI(2) | A(1).\n  const payloadLength = (payload[0]! << 8) | payload[1]!\n  const flagsByte = payload[2]!\n  const fragmentType = (flagsByte >> 4) & 0x0f\n  const timed = ((flagsByte >> 3) & 0x01) === 1\n  const fragmentationIndicator = (flagsByte >> 1) & 0x03\n\n  // Only MFU packets (FT=2) carry the detached trailer.\n  if (fragmentType !== 2) return null\n\n  // FI=0/1 structurally carries a DU header; FI=2/3 does not. Require at\n  // least one media byte after that deterministic layout so the bytes at the\n  // declared boundary cannot impersonate ALTA for a header-only fragment.\n  const dataUnitHeaderSize = fragmentationIndicator <= 1\n    ? (timed ? TIMED_MFU_DU_HEADER_SIZE : NONTIMED_MFU_DU_HEADER_SIZE)\n    : 0\n  if (payloadLength <= MPU_HEADER_REMAINDER_SIZE + dataUnitHeaderSize) return null\n\n  if (fecType > 1) return null\n  const hasFecId = !options?.skipFecId && fecType === 1\n  const payloadEnd = hasFecId ? payload.length - 4 : payload.length\n  const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength\n  if (declaredEnd > payloadEnd) return null\n\n  if (declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE > payloadEnd) return null\n  const extType = (payload[declaredEnd]! << 8) | payload[declaredEnd + 1]!\n  if (extType !== MMTP_EXT_TYPE_ALTA_AUTH) return null\n  const extLen = (payload[declaredEnd + 2]! << 8) | payload[declaredEnd + 3]!\n\n  const authStart = declaredEnd + MMTP_EXT_TRAILER_HEADER_SIZE\n  if (authStart + extLen !== payloadEnd) return null\n\n  return {\n    auth: payload.subarray(authStart, payloadEnd),\n    signedEnd: headerLength + declaredEnd,\n  }\n}\n", "import {\n  MMTP_EXT_TYPE_ALTA_AUTH as _LEAF_MMTP_EXT_TYPE_ALTA_AUTH,\n  MMTP_EXT_TRAILER_HEADER_SIZE as _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE,\n  extractAltaTrailer as _leafExtractAltaTrailer,\n  type AltaTrailer as _LeafAltaTrailer,\n} from '@blockcast/mmt-alta-parse'\n\n/**\n * @mmt/container - MMTP Parser\n *\n * MMTP (MMT Protocol) packet parser based on ISO/IEC 23008-1:2023 Section 9.2\n *\n * MMTP header format (12 bytes):\n * - Byte 0: V(2) | C(1) | FEC_type(2) | r(1) | X(1) | R(1)\n * - Byte 1: reserved(2) | packet_type(6)\n * - Bytes 2-3: packet_id (big-endian)\n * - Bytes 4-7: timestamp (big-endian, 32-bit)\n * - Bytes 8-11: sequence_number (big-endian)\n *\n * FEC_type values:\n * - 0: No FEC / source packet\n * - 1: FEC mode 0 (source with FEC payload ID)\n * - 2: FEC repair packet mode 0\n * - 3: FEC repair packet mode 1\n *\n * @packageDocumentation\n */\n\nexport interface MMTPHeader {\n  version: number\n  /** Packet type: 0x00=MPU, 0x02=Signaling, 0x03=Repair */\n  packetType: number\n  packetId: number\n  timestamp: bigint\n  sequenceNumber: number\n  payloadLength: number\n  fecType: number\n  /** C flag: header carries a 32-bit packet_counter. */\n  packetCounterFlag: boolean\n  packetCounter?: number\n  /** X flag: header carries an extension header and value. */\n  extensionFlag: boolean\n  extension?: { type: number; data: Uint8Array }\n  /** Byte offset at which the MMTP payload begins. */\n  headerLength: number\n  /** Random Access Point flag - indicates keyframe (ISO 23008-1, byte 0 bit 0) */\n  rapFlag: boolean\n}\n\nexport interface MPUHeader {\n  mpuSequenceNumber: number\n  fragmentationIndicator: number // FI: 0=complete, 1=first, 2=middle, 3=last\n  /** 8-bit MPU fragment_counter from byte 3. */\n  fragmentCounter: number\n  /** T flag: 1=timed media (14-byte MFU DU header), 0=non-timed (4-byte header) */\n  timedFlag: number\n  /** A flag: aggregated MPU payload. This strict profile requires A=0. */\n  aggregationFlag: boolean\n  /** MPU payload_length (bytes 0-1): bytes after the length field, including\n   *  the remaining six MPU-header bytes and all data-unit bytes. */\n  payloadLength: number\n}\n\nexport interface MFUDuHeader {\n  movieFragmentSequenceNumber: number\n  sampleNumber: number\n  offset: number\n  priority: number\n  dependencyCounter: number\n}\n\nexport interface MMTPPacket {\n  header: MMTPHeader\n  payload: Uint8Array\n}\n\nexport const MMTP_HEADER_SIZE = 12\nexport const MPU_HEADER_SIZE = 8\nexport const MFU_DU_HEADER_SIZE_TIMED = 14    // T=1: timed media (video/audio samples)\nexport const MFU_DU_HEADER_SIZE_NONTIMED = 4  // T=0: non-timed media (item_id only)\n\nconst MPU_LENGTH_FIELD_SIZE = 2\nconst MPU_HEADER_REMAINDER_SIZE = MPU_HEADER_SIZE - MPU_LENGTH_FIELD_SIZE\nconst SOURCE_FEC_PAYLOAD_ID_SIZE = 4\n\n// MMTP Packet Types (ISO/IEC 23008-1:2023 Section 9.2.2)\nexport const PACKET_TYPE_MPU = 0x00\nexport const PACKET_TYPE_SIGNALING = 0x02\nexport const PACKET_TYPE_REPAIR = 0x03\n\n// AL-FEC Signaling Message ID (ISO/IEC 23008-1:2023 Amendment 1:2025)\nexport const ALFEC_MESSAGE_ID = 0x0203\n\n/**\n * MMTP `packet_id` of the signaling flow, which carries PACKET_TYPE_SIGNALING\n * packets such as the AL-FEC message (ALFEC_MESSAGE_ID). The FFmpeg `moq_mmt`\n * muxer sends that message on this packet_id into the same multicast group as\n * the media, and moqcast-draft (PR #44) makes advertising it for a track a\n * MUST NOT. A track's packet_id is therefore 1..MMTP_PACKET_ID_MAX.\n */\nexport const MMTP_SIGNALING_PACKET_ID = 0\n\n/** Largest value of the 16-bit MMTP `packet_id` header field. */\nexport const MMTP_PACKET_ID_MAX = 0xffff\n\n// FEC Code IDs\nexport const FEC_CODE_XOR = 1\nexport const FEC_CODE_RAPTORQ = 2\n\n/**\n * Parse MMTP header from buffer\n */\nexport function parseMMTPHeader(buffer: Uint8Array): MMTPHeader {\n  if (buffer.length < MMTP_HEADER_SIZE) {\n    throw new Error(`MMTP packet too small: ${buffer.length} bytes`)\n  }\n\n  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)\n\n  const version = (buffer[0]! >> 6) & 0x03\n  if (version !== 0) {\n    throw new Error(`Unsupported MMTP version: ${version}`)\n  }\n\n  // Extract FEC type from byte 0, bits 3-4\n  const fecType = (buffer[0]! >> 3) & 0x03\n  const packetCounterFlag = (buffer[0]! & 0x20) !== 0\n  const extensionFlag = (buffer[0]! & 0x02) !== 0\n\n  // Extract RAP flag from byte 0, bit 0 (R bit - Random Access Point)\n  const rapFlag = (buffer[0]! & 0x01) === 1\n\n  // ISO/IEC 23008-1:2023 Figure 8 (V=0) places reserved(2) before\n  // packet_type(6), so packet_type occupies the low six bits of byte 1.\n  const packetType = buffer[1]! & 0x3F\n\n  let offset = 2\n\n  // Packet ID (2 bytes, big-endian)\n  const packetId = view.getUint16(offset, false)\n  offset += 2\n\n  // Timestamp (4 bytes, big-endian)\n  const timestamp = BigInt(view.getUint32(offset, false))\n  offset += 4\n\n  // Sequence number (4 bytes, big-endian)\n  const sequenceNumber = view.getUint32(offset, false)\n  offset += 4\n\n  let packetCounter: number | undefined\n  if (packetCounterFlag) {\n    if (offset + 4 > buffer.length) throw new Error('MMTP packet truncated in packet_counter')\n    packetCounter = view.getUint32(offset, false)\n    offset += 4\n  }\n\n  let extension: { type: number; data: Uint8Array } | undefined\n  if (extensionFlag) {\n    if (offset + 4 > buffer.length) throw new Error('MMTP packet truncated in header extension')\n    const type = view.getUint16(offset, false)\n    const length = view.getUint16(offset + 2, false)\n    offset += 4\n    if (offset + length > buffer.length) throw new Error('MMTP packet truncated in header extension value')\n    extension = { type, data: buffer.subarray(offset, offset + length) }\n    offset += length\n  }\n\n  return {\n    version,\n    packetType,\n    packetId,\n    timestamp,\n    sequenceNumber,\n    payloadLength: buffer.length - offset,\n    fecType,\n    packetCounterFlag,\n    packetCounter,\n    extensionFlag,\n    extension,\n    headerLength: offset,\n    rapFlag,\n  }\n}\n\n/**\n * The MMTP `packet_id` of `buffer`, or null exactly when parseMMTPHeader would\n * throw for it (short buffer, V != 0, truncated packet_counter or header\n * extension).\n *\n * This is the per-packet filter a receiver runs before any other work, so it\n * builds no header object, DataView or BigInt timestamp (BLO-36599). Use\n * parseMMTPHeader when any other header field is needed.\n */\nexport function readMMTPPacketId(buffer: Uint8Array): number | null {\n  if (buffer.length < MMTP_HEADER_SIZE) return null\n  const flags = buffer[0]!\n  if (((flags >> 6) & 0x03) !== 0) return null\n  let offset = MMTP_HEADER_SIZE\n  if ((flags & 0x20) !== 0) {\n    if (offset + 4 > buffer.length) return null\n    offset += 4\n  }\n  if ((flags & 0x02) !== 0) {\n    if (offset + 4 > buffer.length) return null\n    const length = (buffer[offset + 2]! << 8) | buffer[offset + 3]!\n    if (offset + 4 + length > buffer.length) return null\n  }\n  return (buffer[2]! << 8) | buffer[3]!\n}\n\n/**\n * Unwrap MMTP packet to extract payload\n */\nexport function unwrapMMTP(buffer: Uint8Array): MMTPPacket {\n  const header = parseMMTPHeader(buffer)\n  const payload = buffer.subarray(header.headerLength)\n\n  return { header, payload }\n}\n\n/**\n * Parse MPU header from payload\n * ISO/IEC 23008-1:2023 Section 9.2.3.3\n *\n * MPU Header format (8 bytes) as written by FFmpeg/libmmt:\n * - Bytes 0-1: payload_length (16 bits, big-endian)\n * - Byte 2: FT(4) | T(1) | FI(2) | A(1)\n * - Byte 3: fragment_counter (8 bits)\n * - Bytes 4-7: MPU_sequence_number (32 bits, big-endian)\n */\nexport function parseMPUHeader(payload: Uint8Array): MPUHeader {\n  if (payload.length < MPU_HEADER_SIZE) {\n    throw new Error(`Payload too small for MPU header: ${payload.length} bytes`)\n  }\n\n  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength)\n\n  // Bytes 0-1: payload_length (16 bits, big-endian)\n  const payloadLength = view.getUint16(0, false)\n\n  // Byte 2: FT(4) | T(1) | FI(2) | A(1)\n  const flagsByte = payload[2]!\n  const timedFlag = (flagsByte >> 3) & 0x01\n  const fragmentationIndicator = (flagsByte >> 1) & 0x03\n  const aggregationFlag = (flagsByte & 0x01) !== 0\n\n  // Byte 3: fragment_counter (8 bits). The high bit is part of the counter in\n  // the current libmmt/FFmpeg writer ABI.\n  const fragmentCounter = payload[3]!\n\n  // Bytes 4-7: MPU_sequence_number (32 bits, big-endian)\n  const mpuSequenceNumber = view.getUint32(4, false)\n\n  return {\n    mpuSequenceNumber,\n    fragmentationIndicator,\n    fragmentCounter,\n    timedFlag,\n    aggregationFlag,\n    payloadLength,\n  }\n}\n\nexport function parseTimedMfuDuHeader(payload: Uint8Array, offset: number): MFUDuHeader | null {\n  if (offset < 0 || offset + MFU_DU_HEADER_SIZE_TIMED > payload.length) return null\n  const view = new DataView(payload.buffer, payload.byteOffset + offset, MFU_DU_HEADER_SIZE_TIMED)\n  return {\n    movieFragmentSequenceNumber: view.getUint32(0, false),\n    sampleNumber: view.getUint32(4, false),\n    offset: view.getUint32(8, false),\n    priority: payload[offset + 12]!,\n    dependencyCounter: payload[offset + 13]!,\n  }\n}\n\n/**\n * Why `extractMFUPayload` refused a packet.\n *\n * These identifiers are part of the public contract: callers surface them in\n * diagnostics, so renaming one is a breaking change.\n */\nexport type MFURejectionGate =\n  | 'packet-shorter-than-mmtp-plus-mpu-header'\n  | 'mmtp-header-unparseable'\n  | 'not-an-mpu-packet'\n  | 'payload-shorter-than-mpu-header'\n  | 'aggregation-flag-set'\n  | 'mpu-payload-length-below-header-remainder'\n  | 'mpu-declared-end-exceeds-payload'\n  | 'mfu-offset-at-or-past-declared-end'\n  | 'source-fec-payload-id-width-mismatch'\n  | 'declared-trailers-unresolved'\n\nexport interface MFURejection {\n  gate: MFURejectionGate\n  /** Human-readable detail, including the byte arithmetic that decided it. */\n  detail: string\n}\n\ninterface MfuPayloadLayout {\n  hasMfuDuHeader: boolean\n  mfuOffset: number\n  dataEnd: number\n}\n\nfunction resolveMfuPayloadLayout(\n  mpu: MPUHeader,\n  fragmentType: number,\n  payload: Uint8Array,\n): { layout: MfuPayloadLayout } | { rejection: MFURejection } {\n  if (mpu.payloadLength < MPU_HEADER_REMAINDER_SIZE) {\n    return {\n      rejection: {\n        gate: 'mpu-payload-length-below-header-remainder',\n        detail: `payload_length=${mpu.payloadLength} < ${MPU_HEADER_REMAINDER_SIZE}`,\n      },\n    }\n  }\n\n  // ISO/IEC 23008-1 defines payload_length from immediately after its own\n  // two-byte field. It therefore includes the remaining six MPU-header bytes.\n  const declaredEnd = MPU_LENGTH_FIELD_SIZE + mpu.payloadLength\n  if (declaredEnd > payload.length) {\n    return {\n      rejection: {\n        gate: 'mpu-declared-end-exceeds-payload',\n        detail:\n          `payload_length=${mpu.payloadLength} implies end=${declaredEnd}, ` +\n          `payload is ${payload.length} bytes`,\n      },\n    }\n  }\n\n  const hasHeader = fragmentType === 2 && mpu.fragmentationIndicator <= 1\n  const mfuHeaderSize = mpu.timedFlag ? MFU_DU_HEADER_SIZE_TIMED : MFU_DU_HEADER_SIZE_NONTIMED\n  const mfuOffset = MPU_HEADER_SIZE + (hasHeader ? mfuHeaderSize : 0)\n  if (mfuOffset >= declaredEnd) {\n    return {\n      rejection: {\n        gate: 'mfu-offset-at-or-past-declared-end',\n        detail: `mfuOffset=${mfuOffset} >= declaredEnd=${declaredEnd}`,\n      },\n    }\n  }\n\n  return {\n    layout: {\n      hasMfuDuHeader: hasHeader,\n      mfuOffset,\n      dataEnd: declaredEnd,\n    },\n  }\n}\n\nfunction isEmptyOrExactAltaTrailer(payload: Uint8Array, start: number, end: number): boolean {\n  if (start === end) return true\n  if (start < 0 || end > payload.length || start + _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE > end) {\n    return false\n  }\n\n  const view = new DataView(\n    payload.buffer,\n    payload.byteOffset + start,\n    end - start,\n  )\n  if (view.getUint16(0, false) !== _LEAF_MMTP_EXT_TYPE_ALTA_AUTH) return false\n\n  const authLength = view.getUint16(2, false)\n  return start + _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE + authLength === end\n}\n\ninterface DeclaredTrailerLayout {\n  hasFecId: boolean\n}\n\nfunction resolveDeclaredTrailers(\n  payload: Uint8Array,\n  declaredEnd: number,\n  fecType: number,\n  options?: { skipFecId?: boolean },\n): DeclaredTrailerLayout | null {\n  if (declaredEnd > payload.length) return null\n\n  if (options?.skipFecId) {\n    return isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)\n      ? { hasFecId: false }\n      : null\n  }\n\n  if (fecType === 1) {\n    const fecStart = payload.length - SOURCE_FEC_PAYLOAD_ID_SIZE\n    if (fecStart < declaredEnd || !isEmptyOrExactAltaTrailer(payload, declaredEnd, fecStart)) {\n      return null\n    }\n    return { hasFecId: true }\n  }\n  if (fecType !== 0) return null\n\n  if (isEmptyOrExactAltaTrailer(payload, declaredEnd, payload.length)) {\n    return { hasFecId: false }\n  }\n\n  return null\n}\n\n/**\n * Extract NAL unit payload from MMTP packet\n */\nexport function extractNALUnit(mmtpPacket: Uint8Array): Uint8Array {\n  const extraction = extractMFUPayload(mmtpPacket)\n  if (!extraction) throw new Error('Malformed MMTP MPU payload')\n  return extraction.data\n}\n\n/** Result of extracting MFU payload from an MMTP packet */\nexport interface MFUExtraction {\n  /** MMTP header fields */\n  header: MMTPHeader\n  /** MPU header fields */\n  mpu: MPUHeader\n  /** Fragment type (FT field, 4 bits): 0=metadata, 2=MFU data */\n  fragmentType: number\n  /** MFU payload data (video/audio bytes, headers stripped, FEC ID excluded) */\n  data: Uint8Array\n  /** Parsed timed MFU DU header when present, otherwise null */\n  mfuDuHeader: MFUDuHeader | null\n  /** Non-timed MFU Item_ID when the 4-byte DU header is present. */\n  itemId: number | null\n  /** Source FEC Payload ID if present (`FEC_type == 1`), or null */\n  fecPayloadId: { ssId: number } | null\n}\n\n/**\n * Extract MFU payload from a raw MMTP packet.\n *\n * Handles all the byte arithmetic for:\n * - MMTP header (12 bytes)\n * - MPU sub-header (8 bytes, payloadLength field)\n * - MFU DU header (14 bytes timed / 4 bytes non-timed, only for FI \u2264 1)\n * - Source FEC Payload ID (4 bytes at end, only when `FEC_type == 1`)\n *\n * `payloadLength` is the ISO length-after-field value: six remaining MPU-header\n * bytes, then the MFU DU header when present, then media. ALTA and Source FEC\n * trailers are outside that declared span and must consume the exact suffix.\n *\n * @param mmtpPacket Raw MMTP packet (from multicast or MoQ)\n * @param options.skipFecId When true, do NOT subtract the 4-byte Source FEC Payload ID\n *   from the payload boundary, even if fecType >= 1 in the MMTP header.  Use this for\n *   FEC-recovered symbols where the FEC PID was already stripped before WASM decoding\n *   but the fecType bits in byte 0 still reflect the original packet (FEC Type=1 per\n *   draft-ramadan-moq-mmt-00 \u00A73.1).\n * @returns Extracted MFU data + metadata, or null if packet is too small\n */\ninterface MfuPlan {\n  header: MMTPHeader\n  payload: Uint8Array\n  mpu: MPUHeader\n  fragmentType: number\n  layout: MfuPayloadLayout\n  trailerLayout: DeclaredTrailerLayout\n}\n\n/**\n * Single source of truth for whether a packet yields an MFU payload.\n *\n * `extractMFUPayload` and `explainMFURejection` both delegate here, so the\n * reason reported to operators can never drift from the decision the parser\n * actually made.\n */\nfunction planMfuExtraction(\n  mmtpPacket: Uint8Array,\n  options?: { skipFecId?: boolean },\n  parsedHeader?: MMTPHeader,\n): { plan: MfuPlan } | { rejection: MFURejection } {\n  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) {\n    return {\n      rejection: {\n        gate: 'packet-shorter-than-mmtp-plus-mpu-header',\n        detail: `${mmtpPacket.length} bytes < ${MMTP_HEADER_SIZE + MPU_HEADER_SIZE}`,\n      },\n    }\n  }\n\n  let header: MMTPHeader\n  if (parsedHeader) {\n    header = parsedHeader\n  } else {\n    try {\n      header = parseMMTPHeader(mmtpPacket)\n    } catch (error) {\n      return {\n        rejection: {\n          gate: 'mmtp-header-unparseable',\n          detail: error instanceof Error ? error.message : String(error),\n        },\n      }\n    }\n  }\n  if (header.packetType !== PACKET_TYPE_MPU) {\n    return {\n      rejection: {\n        gate: 'not-an-mpu-packet',\n        detail: `packetType=0x${header.packetType.toString(16).padStart(2, '0')}`,\n      },\n    }\n  }\n\n  const payload = mmtpPacket.subarray(header.headerLength)\n  if (payload.length < MPU_HEADER_SIZE) {\n    return {\n      rejection: {\n        gate: 'payload-shorter-than-mpu-header',\n        detail: `${payload.length} bytes < ${MPU_HEADER_SIZE}`,\n      },\n    }\n  }\n\n  const mpu = parseMPUHeader(payload)\n  if (mpu.aggregationFlag) {\n    return {\n      rejection: { gate: 'aggregation-flag-set', detail: 'strict profile requires A=0' },\n    }\n  }\n\n  // Fragment type from byte 2 upper nibble (not returned by parseMPUHeader)\n  const fragmentType = (payload[2]! >> 4) & 0x0f\n\n  const layoutResult = resolveMfuPayloadLayout(mpu, fragmentType, payload)\n  if ('rejection' in layoutResult) return layoutResult\n  const { layout } = layoutResult\n\n  const trailerLayout = resolveDeclaredTrailers(\n    payload,\n    layout.dataEnd,\n    header.fecType,\n    options,\n  )\n  if (!trailerLayout) {\n    // The most common cause is a producer whose Source FEC Payload ID width\n    // disagrees with ISO/IEC 23008-1 \u00A7C.5.2. Name that explicitly rather than\n    // leaving operators to infer it from a generic trailer error.\n    if (!options?.skipFecId && header.fecType === 1) {\n      const observed = payload.length - layout.dataEnd\n      if (observed !== SOURCE_FEC_PAYLOAD_ID_SIZE) {\n        return {\n          rejection: {\n            gate: 'source-fec-payload-id-width-mismatch',\n            detail:\n              `producer wrote a ${observed}-byte Source FEC Payload ID, ` +\n              `ISO/IEC 23008-1 \u00A7C.5.2 requires ${SOURCE_FEC_PAYLOAD_ID_SIZE} ` +\n              `(payload=${payload.length}, declaredEnd=${layout.dataEnd})`,\n          },\n        }\n      }\n    }\n    return {\n      rejection: {\n        gate: 'declared-trailers-unresolved',\n        detail:\n          `trailer bytes [${layout.dataEnd}, ${payload.length}) are neither empty ` +\n          `nor an exact ALTA trailer (fecType=${header.fecType})`,\n      },\n    }\n  }\n\n  return { plan: { header, payload, mpu, fragmentType, layout, trailerLayout } }\n}\n\n/**\n * Report why `extractMFUPayload` would refuse this packet, or null if it would\n * accept it.\n *\n * `extractMFUPayload` returns bare `null` on ten distinct conditions, which\n * makes a producer/consumer framing disagreement indistinguishable from a\n * publisher that never started \u2014 both render as silence. Use this wherever\n * that distinction matters: diagnostics, contract tests, and operator-facing\n * logs.\n */\nexport function explainMFURejection(\n  mmtpPacket: Uint8Array,\n  options?: { skipFecId?: boolean },\n): MFURejection | null {\n  const result = planMfuExtraction(mmtpPacket, options)\n  return 'rejection' in result ? result.rejection : null\n}\n\nexport function extractMFUPayload(\n  mmtpPacket: Uint8Array,\n  options?: { skipFecId?: boolean },\n): MFUExtraction | null {\n  return extractPlannedMfu(mmtpPacket, planMfuExtraction(mmtpPacket, options))\n}\n\n/**\n * extractMFUPayload for a caller that already holds this packet's parsed MMTP\n * header, so the header is not parsed a second time (BLO-36599).\n *\n * `header` must be `parseMMTPHeader(mmtpPacket)` of this same packet; the\n * result is then identical to `extractMFUPayload(mmtpPacket, options)`.\n */\nexport function extractMFUPayloadWithHeader(\n  mmtpPacket: Uint8Array,\n  header: MMTPHeader,\n  options?: { skipFecId?: boolean },\n): MFUExtraction | null {\n  return extractPlannedMfu(mmtpPacket, planMfuExtraction(mmtpPacket, options, header))\n}\n\nfunction extractPlannedMfu(\n  mmtpPacket: Uint8Array,\n  result: { plan: MfuPlan } | { rejection: MFURejection },\n): MFUExtraction | null {\n  if ('rejection' in result) return null\n  const { header, payload, mpu, fragmentType, layout, trailerLayout } = result.plan\n\n  const mfuDuHeaderPresent = layout.hasMfuDuHeader\n  const mfuOffset = layout.mfuOffset\n  const dataEnd = layout.dataEnd\n\n  const mfuDuHeader =\n    mfuDuHeaderPresent && mpu.timedFlag === 1\n      ? parseTimedMfuDuHeader(payload, MPU_HEADER_SIZE)\n      : null\n  const itemId =\n    mfuDuHeaderPresent && mpu.timedFlag === 0\n      ? new DataView(payload.buffer, payload.byteOffset + MPU_HEADER_SIZE, 4).getUint32(0, false)\n      : null\n\n  const data = payload.subarray(mfuOffset, dataEnd)\n\n  const fecPayloadId = trailerLayout.hasFecId\n    ? {\n        ssId: new DataView(\n          mmtpPacket.buffer,\n          mmtpPacket.byteOffset + mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE,\n          SOURCE_FEC_PAYLOAD_ID_SIZE,\n        ).getUint32(0, false),\n      }\n    : null\n\n  return { header, mpu, fragmentType, data, mfuDuHeader, itemId, fecPayloadId }\n}\n\n/**\n * Extract timestamp from MMTP packet\n */\nexport function extractTimestamp(mmtpPacket: Uint8Array): bigint {\n  const { header } = unwrapMMTP(mmtpPacket)\n  return header.timestamp\n}\n\n/**\n * Check if MMTP packet is an FEC repair packet\n * FEC_type 2 and 3 are repair packets\n */\nexport function isFecRepairPacket(mmtpPacket: Uint8Array): boolean {\n  if (mmtpPacket.length < 1) return false\n  const fecType = (mmtpPacket[0]! >> 3) & 0x03\n  return fecType >= 2\n}\n\n/**\n * Extract Source FEC Payload ID (SS_ID) from the last 4 bytes of an MMTP\n * source packet per ISO/IEC 23008-1:2023 Section C.5.2 Figure C.10.\n *\n * SS_ID is a flat 32-bit monotonic counter (incremented by 1 per packet\n * for ssbg_mode0 and ssbg_mode1). Block membership and ESI use the\n * configured K; repair SS_Start identifies the first SS_ID of the block and\n * SSB_length records the authored source-symbol count:\n *   SBN = floor(SS_ID / K), ESI = SS_ID % K\n *   SS_Start = SBN * K  (first SS_ID of the block)\n *\n * This matches FFmpeg moqenc_mmt.c, the drafts (draft-ramadan-moq-fec \u00A76.2),\n * and ATSC A/331 \u00A78.1.2.5 which defers to ISO 23008-1 Annex C.\n */\nexport function extractFecPayloadId(mmtpPacket: Uint8Array): { ssId: number } | null {\n  const header = parseHeaderForSourceFecId(mmtpPacket)\n  return header ? sourceFecPayloadIdOf(mmtpPacket, header) : null\n}\n\n/**\n * Return true when FEC_type=1 and the exact suffix after the ISO-declared MPU\n * payload contains a four-byte Source FEC Payload ID.\n */\nexport function hasSourceFecPayloadId(mmtpPacket: Uint8Array): boolean {\n  const header = parseHeaderForSourceFecId(mmtpPacket)\n  return header !== null && sourceFecPayloadIdOf(mmtpPacket, header) !== null\n}\n\nfunction parseHeaderForSourceFecId(mmtpPacket: Uint8Array): MMTPHeader | null {\n  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) return null\n  try {\n    return parseMMTPHeader(mmtpPacket)\n  } catch {\n    return null\n  }\n}\n\n/**\n * The Source FEC Payload ID of a packet whose MMTP header the caller already\n * parsed, or null when the packet carries none: present only when FEC_type=1\n * and the exact suffix after the ISO-declared MPU payload holds the four-byte\n * ID (ISO/IEC 23008-1 \u00A7C.5.2). Same answer as extractFecPayloadId, without a\n * second header parse (BLO-36599).\n *\n * `header` must be `parseMMTPHeader(mmtpPacket)` of this same packet.\n */\nexport function sourceFecPayloadIdOf(\n  mmtpPacket: Uint8Array,\n  header: MMTPHeader,\n): { ssId: number } | null {\n  if (mmtpPacket.length < MMTP_HEADER_SIZE + MPU_HEADER_SIZE) return null\n  if (header.packetType !== PACKET_TYPE_MPU) return null\n\n  const payload = mmtpPacket.subarray(header.headerLength)\n  if (payload.length < MPU_HEADER_SIZE) return null\n  const payloadLength = (payload[0]! << 8) | payload[1]!\n  if (payloadLength < MPU_HEADER_REMAINDER_SIZE) return null\n  const declaredEnd = MPU_LENGTH_FIELD_SIZE + payloadLength\n  if (!resolveDeclaredTrailers(payload, declaredEnd, header.fecType)?.hasFecId) return null\n\n  // Flat 4-byte SS_ID: encoder writes block_id * K + symbol_id\n  const off = mmtpPacket.length - SOURCE_FEC_PAYLOAD_ID_SIZE\n  return {\n    ssId:\n      ((mmtpPacket[off]! << 24) |\n        (mmtpPacket[off + 1]! << 16) |\n        (mmtpPacket[off + 2]! << 8) |\n        mmtpPacket[off + 3]!) >>>\n      0,\n  }\n}\n\n/**\n * MMTP header-extension ext_type assigned to the detached ALTA authenticator\n * trailer (Path 2 / 08-07). Carried in an `[ext_type][ext_length][auth]`\n * block appended after the MPU's declared payload bytes, before the 4-byte\n * Source FEC Payload ID. MMTP X-bit stays 0 \u2014 non-ALTA MMTP receivers treat\n * the trailer as bytes past `payload_length` and skip it (per ISO 23008-1\n * \u00A79.2.2 \"may be discarded without impacting correct processing\").\n */\n// Re-export the ALTA trailer helper from the zero-dep leaf package. The leaf\n// owns the implementation so container and FEC consumers share one parser\n// without creating a package cycle.\nexport const MMTP_EXT_TYPE_ALTA_AUTH = _LEAF_MMTP_EXT_TYPE_ALTA_AUTH\nexport const MMTP_EXT_TRAILER_HEADER_SIZE = _LEAF_MMTP_EXT_TRAILER_HEADER_SIZE\nexport type AltaTrailer = _LeafAltaTrailer\nexport const extractAltaTrailer = _leafExtractAltaTrailer\n\n/** Size of Repair FEC Payload ID per ISO/IEC 23008-1 Section C.5.3 */\nexport const REPAIR_FEC_PID_SIZE = 13\n\n/**\n * Parse the 13-byte Repair FEC Payload ID after the complete dynamic MMTP header.\n * `parsedHeader`, when given, must be `parseMMTPHeader(mmtpPacket)` of this\n * same packet; it spares the second header parse (BLO-36599).\n */\nfunction readRepairFecPayloadIdFields(mmtpPacket: Uint8Array, parsedHeader?: MMTPHeader): {\n  packetId: number; ssStart: number; rsbLength: number; rsId: number; ssbLength: number; dataOffset: number\n} | null {\n  let header: MMTPHeader\n  if (parsedHeader) {\n    header = parsedHeader\n  } else {\n    try {\n      header = parseMMTPHeader(mmtpPacket)\n    } catch {\n      return null\n    }\n  }\n  if (header.packetType !== PACKET_TYPE_REPAIR || header.fecType !== 2) return null\n\n  const off = header.headerLength\n  if (mmtpPacket.length < off + REPAIR_FEC_PID_SIZE) return null\n  const ssStart =\n    ((mmtpPacket[off]! << 24) |\n      (mmtpPacket[off + 1]! << 16) |\n      (mmtpPacket[off + 2]! << 8) |\n      mmtpPacket[off + 3]!) >>>\n    0  // 32 bits\n  const rsbLength = (mmtpPacket[off + 4]! << 16) | (mmtpPacket[off + 5]! << 8) | mmtpPacket[off + 6]!  // 24 bits\n  const rsId = (mmtpPacket[off + 7]! << 16) | (mmtpPacket[off + 8]! << 8) | mmtpPacket[off + 9]!  // 24 bits\n  const ssbLength = (mmtpPacket[off + 10]! << 16) | (mmtpPacket[off + 11]! << 8) | mmtpPacket[off + 12]!  // 24 bits\n  return {\n    packetId: header.packetId,\n    ssStart,\n    rsbLength,\n    rsId,\n    ssbLength,\n    dataOffset: off + REPAIR_FEC_PID_SIZE,\n  }\n}\n\n/**\n * Extract Repair FEC Payload ID from a raw-multicast MMTP repair packet.\n * Per ISO/IEC 23008-1:2023 Section C.5.3 (ssbg_mode0, one-stage, no FFSRP_TS):\n *   [MMTP header][SS_Start:4][RSB_length:3][RS_ID:3][SSB_length:3][repair data]\n * OTI is delivered via AL-FEC signaling message (Table C.3), not per-packet.\n *\n * Byte 1 is reserved(2)|packet_type(6) for V=0, so repair type 0x03 is 0x03.\n * Pre-migration high-bits bytes (0x0c) are rejected \u2014 no compatibility decode.\n */\nexport function extractRepairFecPayloadId(mmtpPacket: Uint8Array): {\n  ssStart: number; rsbLength: number; rsId: number; ssbLength: number\n} | null {\n  const fields = readRepairFecPayloadIdFields(mmtpPacket)\n  if (!fields) return null\n  return {\n    ssStart: fields.ssStart,\n    rsbLength: fields.rsbLength,\n    rsId: fields.rsId,\n    ssbLength: fields.ssbLength,\n  }\n}\n\n/** Parsed MoQ repair frame per ISO/IEC 23008-1 Section C.4.3 + C.5.3 */\nexport interface MoqRepairFrame {\n  /** MMTP packetId (1=video, 2=audio) \u2014 for routing to correct FEC decoder */\n  packetId: number\n  /** SS_Start (32 bits): SS_ID of first source symbol in block */\n  ssStart: number\n  /** RSB_length (24 bits): number of repair symbols (P) */\n  rsbLength: number\n  /** RS_ID (24 bits): repair symbol index (0-based) */\n  rsId: number\n  /** SSB_length (24 bits): authored source-symbol count (1..=configured K) */\n  ssbLength: number\n  /** Repair symbol data after the dynamic MMTP header and 13-byte FEC payload ID. */\n  symbolData: Uint8Array\n}\n\n/**\n * Parse a MoQ repair frame (ISO/IEC 23008-1 Annex C format).\n *\n * Wire format per ISO 23008-1 \u00A7C.4.3 + \u00A7C.5.3:\n *   MMTP Header: fixed 12 bytes plus C/X optional fields\n *   then SS_Start (4 bytes) \u2192 block identifier\n *   then RSB_length (3 bytes) \u2192 P\n *   then RS_ID (3 bytes) \u2192 ESI = K + RS_ID\n *   then SSB_length (3 bytes) \u2192 authored source-symbol count (1..=K)\n *   then Repair Symbol Data (T bytes)\n *\n * @param frame - Raw MoQ repair frame bytes\n * @returns Parsed frame or null if invalid\n */\nexport function parseMoqRepairFrame(frame: Uint8Array): MoqRepairFrame | null {\n  return moqRepairFrameFrom(frame, readRepairFecPayloadIdFields(frame))\n}\n\n/**\n * parseMoqRepairFrame for a caller that already holds this frame's parsed MMTP\n * header, so the header is not parsed a second time (BLO-36599). The router's\n * multicast repair branch uses it: one repair packet in every K + P otherwise\n * paid two header parses.\n *\n * `header` must be `parseMMTPHeader(frame)` of this same frame; the result is\n * then identical to `parseMoqRepairFrame(frame)`.\n */\nexport function parseMoqRepairFrameWithHeader(\n  frame: Uint8Array,\n  header: MMTPHeader,\n): MoqRepairFrame | null {\n  return moqRepairFrameFrom(frame, readRepairFecPayloadIdFields(frame, header))\n}\n\nfunction moqRepairFrameFrom(\n  frame: Uint8Array,\n  repairId: ReturnType<typeof readRepairFecPayloadIdFields>,\n): MoqRepairFrame | null {\n  if (!repairId) return null\n\n  const symbolData = frame.subarray(repairId.dataOffset)\n  if (\n    repairId.rsbLength === 0 ||\n    repairId.ssbLength === 0 ||\n    repairId.rsId >= repairId.rsbLength ||\n    symbolData.length === 0\n  ) return null\n\n  return {\n    packetId: repairId.packetId,\n    ssStart: repairId.ssStart,\n    rsbLength: repairId.rsbLength,\n    rsId: repairId.rsId,\n    ssbLength: repairId.ssbLength,\n    symbolData,\n  }\n}\n\n// The signalling-message parsers (9.3.4.2 payload header, AL-FEC message,\n// PA/MPT) live in ./signalling.ts.\n", "/**\n * NTP short format (RFC 5905 \u00A76): an unsigned 32-bit, 16.16 fixed-point count\n * of seconds. The MMTP header `timestamp` field (ISO/IEC 23008-1 \u00A79.2.2)\n * carries each packet's UTC sending instant in this format, so the value wraps\n * to 0 every 2^16 s (~18.2 h).\n *\n * Plain numeric order on these values breaks at every wrap: a retained\n * `Math.max` stays at the pre-wrap value and every later instant compares as\n * older. Order send times only with {@link compareNtpShort}, which applies\n * RFC 1982 serial-number arithmetic over the field's width.\n */\n\n/** Width in bits of the MMTP `timestamp` field (NTP short). */\nexport const NTP_SHORT_BITS = 32\n\n/** Number of distinct NTP-short values; the field wraps to 0 here. */\nexport const NTP_SHORT_MODULUS = 2 ** NTP_SHORT_BITS\n\n/**\n * RFC 1982 \u00A73.2's `2^(SERIAL_BITS - 1)`. Two values whose forward distance is\n * below this are ordered; exactly this far apart they are not ordered at all.\n * Two instants must be less than this far apart (2^15 s, ~9.1 h of send time)\n * for the comparison to give their true order.\n */\nexport const NTP_SHORT_HALF_RANGE = 2 ** (NTP_SHORT_BITS - 1)\n\n/**\n * Serial order of one NTP-short value relative to another.\n *\n * `'unordered'` is RFC 1982's undefined case: the values are exactly\n * {@link NTP_SHORT_HALF_RANGE} apart, so neither precedes the other. It is\n * never folded into `'before'` or `'after'`; each caller decides what an\n * unorderable pair means for it.\n */\nexport type NtpShortOrder = 'before' | 'equal' | 'after' | 'unordered'\n\n/** True when `value` is an NTP-short value: an integer in [0, NTP_SHORT_MODULUS). */\nexport function isNtpShort(value: number): boolean {\n  return Number.isInteger(value) && value >= 0 && value < NTP_SHORT_MODULUS\n}\n\n/**\n * RFC 1982 serial comparison of NTP-short `a` against `b`: `'after'` when `a`\n * is the later instant, `'before'` when it is the earlier one.\n *\n * The answer is the true order only while the two instants are less than\n * {@link NTP_SHORT_HALF_RANGE} apart. Past that a 32-bit field cannot tell\n * later from earlier, and the result names whichever direction is nearer.\n * This is not a total order (it is not transitive across the whole space), so\n * it must never be used to sort.\n *\n * @throws {RangeError} if either operand is not an NTP-short value\n */\nexport function compareNtpShort(a: number, b: number): NtpShortOrder {\n  if (!isNtpShort(a) || !isNtpShort(b)) {\n    throw new RangeError(\n      `NTP-short values must be integers in [0, 2^${NTP_SHORT_BITS}), got ${String(a)} and ${String(b)}`,\n    )\n  }\n  if (a === b) return 'equal'\n  // Forward distance from b to a, reduced into [1, NTP_SHORT_MODULUS). Both\n  // operands are below 2^32, so every step is exact in a double.\n  const forward = (a - b + NTP_SHORT_MODULUS) % NTP_SHORT_MODULUS\n  if (forward < NTP_SHORT_HALF_RANGE) return 'after'\n  if (forward > NTP_SHORT_HALF_RANGE) return 'before'\n  return 'unordered'\n}\n", "/**\n * FEC block profile (BLO-35597, ISO/IEC 23008-1 Annex C).\n *\n * Every catalog `fec` object that declares an FEC instance names exactly one\n * block profile in `fec.blockProfile`. A receiver applies all of a profile's\n * rules or none of them, so the token is the one explicit per-stream\n * discriminator: it is never defaulted and never inferred from the wire.\n *\n * - `k-padded-v1` (legacy, Blockcast-private): a source symbol is the\n *   protected MMTP packet zero-padded to T with no length field; every block\n *   is a K-symbol RaptorQ block whose ESIs `SSB_length..K-1` are implicit\n *   zero padding; `SS_ID = SBN*K + ESI`, so `SS_Start = SBN*K`; repair\n *   ESI = K + RS_ID; the MoQ repair group id is the SBN.\n * - `iso-ssbg1-v1`: ssbg_mode1 (C.3.3): a source symbol is\n *   `u16 length || protected packet || zero padding` to T; a block is a\n *   K' = SSB_length RaptorQ block (C.5.3) and repair ESI = SSB_length + RS_ID;\n *   SS_ID increments by one per FEC source packet and wraps at 2^32 (C.5.2),\n *   so a block is located by membership in `[SS_Start, SS_Start + SSB_length)`\n *   under RFC 1982 serial arithmetic; the MoQ repair group id is the 62-bit\n *   wrap-epoch-extended SS_Start. The AL-FEC coding byte for this profile is\n *   0x14 (one-stage, ssbg_mode1, fec_payload_id_mode 0, Amd 1:2025 Table C.3).\n */\nimport { serial32Add, serial32Distance, serial32Precedes } from './serial-number.js'\n\n/** The two block profiles a catalog `fec.blockProfile` may name. */\nexport type FecBlockProfile = 'k-padded-v1' | 'iso-ssbg1-v1'\n\n/** Every accepted `fec.blockProfile` token, legacy first. */\nexport const FEC_BLOCK_PROFILES: readonly FecBlockProfile[] = Object.freeze([\n  'k-padded-v1',\n  'iso-ssbg1-v1',\n])\n\n/** True for a known block-profile token. */\nexport function isFecBlockProfile(value: unknown): value is FecBlockProfile {\n  return value === 'k-padded-v1' || value === 'iso-ssbg1-v1'\n}\n\n/**\n * Read a required `fec.blockProfile`. Throws on an absent or unknown token:\n * there is no default and nothing is inferred, because the two profiles carry\n * identical wire tuples whose repair math differs.\n *\n * @param where the catalog path of the field, for the error message.\n */\nexport function parseFecBlockProfile(value: unknown, where: string): FecBlockProfile {\n  if (isFecBlockProfile(value)) return value\n  if (value === undefined) {\n    throw new Error(\n      `${where} is required: name the FEC block profile (\"k-padded-v1\" or \"iso-ssbg1-v1\")`,\n    )\n  }\n  throw new Error(\n    `${where} must be \"k-padded-v1\" or \"iso-ssbg1-v1\" (got ${JSON.stringify(value)})`,\n  )\n}\n\n/** ISO/IEC 23008-1 C.3.3 ssbg_mode1: the two-octet packet length field. */\nexport const SSBG1_LENGTH_FIELD_BYTES = 2\n\n/** The largest protected packet an ssbg_mode1 symbol of size T can carry. */\nexport function ssbg1MaxPacketLength(symbolSize: number): number {\n  return symbolSize - SSBG1_LENGTH_FIELD_BYTES\n}\n\n/** Whether a protected packet of `packetLength` bytes fits one T-byte ssbg_mode1 symbol. */\nexport function ssbg1FitsSymbol(packetLength: number, symbolSize: number): boolean {\n  return (\n    Number.isSafeInteger(packetLength) &&\n    packetLength >= 0 &&\n    packetLength <= ssbg1MaxPacketLength(symbolSize) &&\n    packetLength <= 0xffff\n  )\n}\n\n/**\n * Build one ssbg_mode1 source symbol (C.3.3): the protected packet's length\n * in two octets, network byte order, then the packet, then zero octets up to\n * T. The protected packet is the MMTP packet before its Source FEC Payload ID\n * is appended (C.4.2).\n *\n * @throws when `length + 2 > T`: the packet cannot be protected under this\n * profile, and silently truncating it would corrupt every repair symbol.\n */\nexport function buildSsbg1SourceSymbol(packet: Uint8Array, symbolSize: number): Uint8Array {\n  if (!Number.isSafeInteger(symbolSize) || symbolSize <= SSBG1_LENGTH_FIELD_BYTES) {\n    throw new Error(`ssbg_mode1 symbol size must exceed ${SSBG1_LENGTH_FIELD_BYTES} (got ${symbolSize})`)\n  }\n  if (!ssbg1FitsSymbol(packet.byteLength, symbolSize)) {\n    throw new Error(\n      `ssbg_mode1 source symbol needs ${packet.byteLength} + ${SSBG1_LENGTH_FIELD_BYTES} bytes but T is ${symbolSize}`,\n    )\n  }\n  const symbol = new Uint8Array(symbolSize)\n  symbol[0] = (packet.byteLength >>> 8) & 0xff\n  symbol[1] = packet.byteLength & 0xff\n  symbol.set(packet, SSBG1_LENGTH_FIELD_BYTES)\n  return symbol\n}\n\n/**\n * Recover the protected packet from one ssbg_mode1 source symbol: the bytes\n * the length field names. Returns null, never a guess, when the length field\n * points past the symbol or any padding octet is non-zero (C.3.3 padding is\n * all 00h), since either means the recovered symbol is not what was sent.\n */\nexport function trimSsbg1SourceSymbol(symbol: Uint8Array): Uint8Array | null {\n  if (symbol.byteLength < SSBG1_LENGTH_FIELD_BYTES) return null\n  const length = (symbol[0]! << 8) | symbol[1]!\n  const end = SSBG1_LENGTH_FIELD_BYTES + length\n  if (end > symbol.byteLength) return null\n  for (let i = end; i < symbol.byteLength; i++) {\n    if (symbol[i] !== 0) return null\n  }\n  return symbol.subarray(SSBG1_LENGTH_FIELD_BYTES, end)\n}\n\n/** The SS_ID after the last source symbol of `[ssStart, ssStart + ssbLength)`. */\nexport function isoBlockEnd(ssStart: number, ssbLength: number): number {\n  return serial32Add(ssStart, ssbLength)\n}\n\n/**\n * Range membership (C.5.2, C.5.3): whether `ssId` is one of the\n * `ssbLength` consecutive SS_IDs starting at `ssStart`, modulo 2^32.\n */\nexport function isoBlockContains(ssStart: number, ssbLength: number, ssId: number): boolean {\n  return serial32Distance(ssStart, ssId) < ssbLength\n}\n\n/**\n * A lower bound on how many blocks the block starting at `a` lies behind the\n * one starting at `b` (0 when `a` does not precede `b`). An iso-ssbg1-v1\n * block holds at most `kMax` source symbols (the catalog `sourceSymbols`, the\n * AL-FEC maximum_k_for_repair_flow), so `n * kMax` SS_IDs always span at least\n * `n` blocks. Every interleave horizon in the receiver (decoder retention,\n * worker retirement, ordered-relay settlement) uses this one bound, so the\n * manager's horizon can never fall inside the decoder's.\n */\nexport function isoBlocksBehindLowerBound(a: number, b: number, kMax: number): number {\n  if (!Number.isSafeInteger(kMax) || kMax <= 0) {\n    throw new Error(`iso-ssbg1-v1 block horizon needs a positive maximum K (got ${kMax})`)\n  }\n  return serial32Precedes(a, b) ? Math.floor(serial32Distance(a, b) / kMax) : 0\n}\n", "/**\n * Container Timestamp Codec\n *\n * Encodes and decodes timestamps across container formats:\n * - \"legacy\": QUIC VarInt encoded (variable length 1-8 bytes)\n * - \"raw\": Fixed 8-byte BigUint64\n * - \"mmtp\" / \"mmtp-fec\": 12-byte MMTP header with embedded timestamp\n * - \"loc\": LOC extension header encoding\n * - \"fmp4\": Not yet implemented\n */\nimport { extractNALUnit, extractTimestamp } from \"@blockcast/mmt-base\";\n\nexport type ContainerFormat = \"legacy\" | \"raw\" | \"mmtp\" | \"mmtp-fec\" | \"loc\" | \"fmp4\";\n\nconst DEFAULT_CONTAINER: ContainerFormat = \"legacy\";\n\n/** Encodes a timestamp in microseconds according to the specified container format. */\nexport function encodeTimestamp(timestamp: number, container: ContainerFormat = DEFAULT_CONTAINER): Uint8Array {\n\tswitch (container) {\n\t\tcase \"legacy\":\n\t\t\treturn encodeVarInt(timestamp);\n\t\tcase \"raw\":\n\t\t\treturn encodeU64(timestamp);\n\t\tcase \"mmtp\":\n\t\tcase \"mmtp-fec\":\n\t\t\treturn encodeU64(timestamp);\n\t\tcase \"loc\":\n\t\t\treturn encodeLocTimestamp(timestamp);\n\t\tcase \"fmp4\":\n\t\t\tthrow new Error(\"fmp4 container not yet implemented\");\n\t}\n}\n\n/**\n * Decodes a timestamp from a buffer according to the specified container format.\n * @returns [timestamp in microseconds, remaining buffer after timestamp]\n */\nexport function decodeTimestamp(buffer: Uint8Array, container: ContainerFormat = DEFAULT_CONTAINER): [number, Uint8Array] {\n\tswitch (container) {\n\t\tcase \"legacy\": {\n\t\t\tconst [value, remaining] = decodeVarInt(buffer);\n\t\t\treturn [value, remaining];\n\t\t}\n\t\tcase \"raw\": {\n\t\t\tconst [value, remaining] = decodeU64(buffer);\n\t\t\treturn [value, remaining];\n\t\t}\n\t\tcase \"mmtp\":\n\t\tcase \"mmtp-fec\": {\n\t\t\tconst timestamp = extractTimestamp(buffer);\n\t\t\tconst payload = extractNALUnit(buffer);\n\t\t\treturn [Number(timestamp), payload];\n\t\t}\n\t\tcase \"loc\": {\n\t\t\tconst [ts, payload] = decodeLocTimestamp(buffer);\n\t\t\treturn [ts, payload];\n\t\t}\n\t\tcase \"fmp4\":\n\t\t\tthrow new Error(\"fmp4 container not yet implemented\");\n\t}\n}\n\n/** Gets the size in bytes of an encoded timestamp for the given container format. */\nexport function getTimestampSize(container: ContainerFormat = DEFAULT_CONTAINER): number {\n\tswitch (container) {\n\t\tcase \"legacy\":\n\t\t\treturn 8;\n\t\tcase \"raw\":\n\t\t\treturn 8;\n\t\tcase \"mmtp\":\n\t\tcase \"mmtp-fec\":\n\t\t\treturn 12;\n\t\tcase \"loc\":\n\t\t\t// [ExtID=2][ts][ExtID=4][kf]: two 1-byte IDs + a varint timestamp\n\t\t\t// (<=8 bytes) + a 1-byte keyframe flag.\n\t\t\treturn 11;\n\t\tcase \"fmp4\":\n\t\t\tthrow new Error(\"fmp4 container not yet implemented\");\n\t}\n}\n\n// LEGACY VARINT IMPLEMENTATION\nconst MAX_U6 = 2 ** 6 - 1;\nconst MAX_U14 = 2 ** 14 - 1;\nconst MAX_U30 = 2 ** 30 - 1;\nconst MAX_U53 = Number.MAX_SAFE_INTEGER;\n\nfunction decodeVarInt(buf: Uint8Array): [number, Uint8Array] {\n\tconst size = 1 << ((buf[0] & 0xc0) >> 6);\n\tconst view = new DataView(buf.buffer, buf.byteOffset, size);\n\tconst remain = new Uint8Array(buf.buffer, buf.byteOffset + size, buf.byteLength - size);\n\tlet v: number;\n\tif (size === 1) {\n\t\tv = buf[0] & 0x3f;\n\t} else if (size === 2) {\n\t\tv = view.getUint16(0) & 0x3fff;\n\t} else if (size === 4) {\n\t\tv = view.getUint32(0) & 0x3fffffff;\n\t} else if (size === 8) {\n\t\tv = Number(view.getBigUint64(0) & 0x3fffffffffffffffn);\n\t} else {\n\t\tthrow new Error(\"impossible\");\n\t}\n\treturn [v, remain];\n}\n\nfunction encodeVarInt(v: number): Uint8Array {\n\tif (v > MAX_U53) throw new RangeError(\"value too large for varint\");\n\tlet size: 1 | 2 | 4 | 8;\n\tif (v <= MAX_U6) {\n\t\tsize = 1;\n\t} else if (v <= MAX_U14) {\n\t\tsize = 2;\n\t} else if (v <= MAX_U30) {\n\t\tsize = 4;\n\t} else {\n\t\tsize = 8;\n\t}\n\tconst arr = new Uint8Array(size);\n\tconst view = new DataView(arr.buffer, arr.byteOffset, size);\n\tconst prefixMap: Record<1 | 2 | 4 | 8, number> = { 1: 0b00, 2: 0b01, 4: 0b10, 8: 0b11 };\n\tconst prefix = prefixMap[size];\n\tif (size === 1) {\n\t\tview.setUint8(0, (prefix << 6) | v);\n\t} else if (size === 2) {\n\t\tview.setUint16(0, (prefix << 14) | v);\n\t} else if (size === 4) {\n\t\tview.setUint32(0, (prefix << 30) | v);\n\t} else if (size === 8) {\n\t\tview.setBigUint64(0, (BigInt(prefix) << 62n) | BigInt(v));\n\t}\n\treturn arr;\n}\n\n// U64 IMPLEMENTATION\nfunction decodeU64(buf: Uint8Array): [number, Uint8Array] {\n\tconst view = new DataView(buf.buffer, buf.byteOffset, 8);\n\tconst remain = new Uint8Array(buf.buffer, buf.byteOffset + 8, buf.byteLength - 8);\n\tconst v = Number(view.getBigUint64(0));\n\treturn [v, remain];\n}\n\nfunction encodeU64(v: number): Uint8Array {\n\tconst arr = new Uint8Array(8);\n\tconst view = new DataView(arr.buffer, arr.byteOffset, 8);\n\tview.setBigUint64(0, BigInt(v));\n\treturn arr;\n}\n\n// LOC TIMESTAMP IMPLEMENTATION\n//\n// The LOC wire format is defined by hang's `ContainerMode::Loc` encoder\n// (hang-mmt-fec/rs/hang/src/container/producer.rs, the `ContainerMode::Loc`\n// arm), which writes a FIXED two-pair extension header and then the payload:\n//\n//     [ExtID=2][CaptureTimestamp_us][ExtID=4][keyframe][payload]\n//\n// all four fields QUIC varints. It is exactly two pairs \u2014 no count, no length,\n// no terminator \u2014 so the reader is deterministic: consume four varints, and the\n// payload starts at the fifth. Do NOT reintroduce a payload sniff (the removed\n// `firstByte === 0x00` heuristic guessed at the boundary, which held for AVCC\n// video and destroyed AAC audio, whose first byte is ID_SCE = 0x00-0x1f).\n//\n// A LOC track advertising `packaging: \"loc\"` MUST be emitted through\n// `ContainerMode::Loc`. A producer that stamps the catalog but leaves the track\n// in Legacy `[VarInt ts][payload]` mode is broken on the producer side \u2014 fix it\n// there rather than making this reader guess which framing it was handed.\n\n/** Number of varints in the fixed LOC extension header (2 ID/value pairs). */\nconst LOC_HEADER_VARINTS = 4;\n\n/** LOC extension IDs (draft-ietf-moq-loc). */\nconst LOC_EXT_CAPTURE_TIMESTAMP = 2;\nconst LOC_EXT_VIDEO_FRAME_MARKING = 4;\n\n/** Decode a LOC frame header.\n *  Returns [timestamp in microseconds, remaining payload]. */\nexport function decodeLocTimestamp(buffer: Uint8Array): [number, Uint8Array] {\n\tconst { timestamp, payload } = decodeLocHeader(buffer);\n\treturn [timestamp, payload];\n}\n\n// \u2500\u2500 LOC Header Parsing \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/** Parsed LOC extension header (CaptureTimestamp + VideoFrameMarking). */\nexport interface LocHeader {\n\t/** Capture timestamp in microseconds (extension ID 2). */\n\ttimestamp: number;\n\t/** Keyframe flag (extension ID 4, bit 0). */\n\tkeyframe?: boolean;\n\t/** Payload after the extension header (raw codec bitstream). */\n\tpayload: Uint8Array;\n}\n\n/**\n * Decode the fixed LOC extension header:\n * `[ExtID=2][timestamp_us][ExtID=4][keyframe][payload]`.\n *\n * Throws if the header is not the two pairs the producer emits \u2014 a truncated or\n * mis-framed buffer is a contract break, and returning a plausible-looking\n * payload from it just relocates the failure into the decoder.\n */\nexport function decodeLocHeader(buffer: Uint8Array): LocHeader {\n\t/** Read one varint, converting an over-run into a contract-break message. */\n\tconst readVarInt = (buf: Uint8Array, field: string): [number, Uint8Array] => {\n\t\tif (buf.length === 0) {\n\t\t\tthrow new Error(\n\t\t\t\t`LOC header truncated at ${field}: buffer is ${buffer.byteLength} bytes, ` +\n\t\t\t\t\t`expected ${LOC_HEADER_VARINTS} varints`,\n\t\t\t);\n\t\t}\n\t\ttry {\n\t\t\treturn decodeVarInt(buf);\n\t\t} catch {\n\t\t\t// decodeVarInt builds a DataView sized by the 2-bit prefix; a short\n\t\t\t// tail throws \"Invalid DataView length\" and hides what actually broke.\n\t\t\tthrow new Error(\n\t\t\t\t`LOC header truncated at ${field}: ${buf.length} byte(s) remain, ` +\n\t\t\t\t\t`too few for the declared varint width`,\n\t\t\t);\n\t\t}\n\t};\n\n\tconst [tsId, afterTsId] = readVarInt(buffer, \"CaptureTimestamp ID\");\n\t// Validate each ID as soon as it is read, so a Legacy-framed buffer reports\n\t// the contract break rather than an over-run further along the walk.\n\tif (tsId !== LOC_EXT_CAPTURE_TIMESTAMP) {\n\t\tthrow new Error(\n\t\t\t`LOC header extension IDs: expected ${LOC_EXT_CAPTURE_TIMESTAMP} ` +\n\t\t\t\t`(CaptureTimestamp) first, got ${tsId}. The producer is advertising ` +\n\t\t\t\t`packaging=\"loc\" but not emitting LOC framing \u2014 see ` +\n\t\t\t\t`hang Avc1::set_explicit_container / Aac::set_container.`,\n\t\t);\n\t}\n\n\tconst [timestamp, afterTs] = readVarInt(afterTsId, \"CaptureTimestamp value\");\n\tconst [kfId, afterKfId] = readVarInt(afterTs, \"VideoFrameMarking ID\");\n\tif (kfId !== LOC_EXT_VIDEO_FRAME_MARKING) {\n\t\tthrow new Error(\n\t\t\t`LOC header extension IDs: expected ${LOC_EXT_VIDEO_FRAME_MARKING} ` +\n\t\t\t\t`(VideoFrameMarking) second, got ${kfId}.`,\n\t\t);\n\t}\n\tconst [kfValue, payload] = readVarInt(afterKfId, \"VideoFrameMarking value\");\n\n\treturn { timestamp, keyframe: (kfValue & 1) === 1, payload };\n}\n\n/** Encode a LOC frame header: `[ExtID=2][timestamp_us][ExtID=4][keyframe]`. */\nexport function encodeLocTimestamp(timestamp: number, keyframe = false): Uint8Array {\n\tconst parts = [\n\t\tencodeVarInt(LOC_EXT_CAPTURE_TIMESTAMP),\n\t\tencodeVarInt(timestamp),\n\t\tencodeVarInt(LOC_EXT_VIDEO_FRAME_MARKING),\n\t\tencodeVarInt(keyframe ? 1 : 0),\n\t];\n\tconst total = parts.reduce((n, p) => n + p.length, 0);\n\tconst out = new Uint8Array(total);\n\tlet off = 0;\n\tfor (const p of parts) {\n\t\tout.set(p, off);\n\t\toff += p.length;\n\t}\n\treturn out;\n}\n"],
+  "mappings": "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",
+  "names": ["MPU_HEADER_SIZE", "MPU_LENGTH_FIELD_SIZE", "MPU_HEADER_REMAINDER_SIZE", "MPU_HEADER_SIZE", "MPU_HEADER_REMAINDER_SIZE", "MPU_LENGTH_FIELD_SIZE", "MPU_HEADER_SIZE"]
+}