@blockcast/mmt-container 0.1.0 → 0.3.0-main.0bde85f7082f

package/dist/signaling.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/signalling.ts", "../../mmt-base/src/fec-block-profile.ts", "../src/signaling.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 * Receiver-side parsers for MMTP signalling message mode.\n *\n * - The MMTP payload header for signalling message mode\n *   (ISO/IEC 23008-1:2023 9.3.4.2, Figure 15).\n * - The general signalling message format (10.2, Table 20).\n * - The AL-FEC message (Annex C Table C.3 as replaced by\n *   ISO/IEC 23008-1:2023/Amd 1:2025; semantics C.6.3).\n * - The PA message (10.3.2, Table 21) and MPT message (10.3.4, Table 23)\n *   with the MP table (10.3.9, Table 29), Identifier_mapping (10.6.3,\n *   Table 98), asset_id (10.6.2, Table 97) and MMT_general_location_info\n *   (10.6.1, Table 95).\n *\n * Every parser here is total: malformed, truncated, ambiguous or unsupported\n * input yields null, never an exception. Nothing is inferred: a field the\n * receiver cannot place exactly makes the whole message unparseable, because\n * every later field of a sequential syntax would be misread after it.\n *\n * Reserved bits are ignored on receipt. The senders write them, and a\n * receiver that refuses a reserved value cannot accept a conformant revision\n * of the syntax that assigns it.\n */\nimport {\n  ALFEC_MESSAGE_ID,\n  FEC_CODE_RAPTORQ,\n  PACKET_TYPE_SIGNALING,\n  parseMMTPHeader,\n  type MMTPHeader,\n} from './mmtp.js'\n\n// ---------------------------------------------------------------------------\n// Wire reader\n// ---------------------------------------------------------------------------\n\n/** Internal: raised by WireReader, caught at every exported parser. */\nclass MalformedSignalling extends Error {}\n\nclass WireReader {\n  readonly #bytes: Uint8Array\n  readonly #end: number\n  #offset: number\n\n  constructor(bytes: Uint8Array, start = 0, end = bytes.length) {\n    this.#bytes = bytes\n    this.#offset = start\n    this.#end = end\n  }\n\n  get offset(): number {\n    return this.#offset\n  }\n\n  get remaining(): number {\n    return this.#end - this.#offset\n  }\n\n  #take(length: number): number {\n    if (length < 0 || length > this.remaining) throw new MalformedSignalling('truncated')\n    const at = this.#offset\n    this.#offset += length\n    return at\n  }\n\n  u8(): number {\n    return this.#bytes[this.#take(1)]!\n  }\n\n  u16(): number {\n    const at = this.#take(2)\n    return (this.#bytes[at]! << 8) | this.#bytes[at + 1]!\n  }\n\n  u24(): number {\n    const at = this.#take(3)\n    return (this.#bytes[at]! << 16) | (this.#bytes[at + 1]! << 8) | this.#bytes[at + 2]!\n  }\n\n  u32(): number {\n    const at = this.#take(4)\n    return ((this.#bytes[at]! << 24) | (this.#bytes[at + 1]! << 16) |\n      (this.#bytes[at + 2]! << 8) | this.#bytes[at + 3]!) >>> 0\n  }\n\n  /** A copy, so a parsed message never aliases a reused packet buffer. */\n  bytes(length: number): Uint8Array {\n    const at = this.#take(length)\n    return this.#bytes.slice(at, at + length)\n  }\n\n  /** Throw unless every byte up to the end bound was consumed. */\n  expectEnd(): void {\n    if (this.remaining !== 0) throw new MalformedSignalling('trailing bytes')\n  }\n}\n\nfunction fail(reason: string): never {\n  throw new MalformedSignalling(reason)\n}\n\n/** Run a parser, turning only our own malformed-input signal into null. */\nfunction total<T>(parse: () => T | null): T | null {\n  try {\n    return parse()\n  } catch (error) {\n    if (error instanceof MalformedSignalling) return null\n    throw error\n  }\n}\n\n// ---------------------------------------------------------------------------\n// 9.3.4.2 \u2014 MMTP payload header for signalling message mode\n// ---------------------------------------------------------------------------\n\n/**\n * How the signalling payload of an MMTP packet was framed.\n *\n * - `iso-9.3.4.2`: the 2-byte `f_i(2) RES(4) H(1) A(1) | frag_counter(8)`\n *   header of ISO/IEC 23008-1:2023 9.3.4.2 precedes the message(s).\n * - `legacy-bare-alfec`: the pre-remediation Blockcast form, where the\n *   AL-FEC message starts directly after the MMTP header. It is recognised\n *   only by its first two bytes being `0x02 0x03` (message_id 0x0203). That\n *   pair is never a valid 9.3.4.2 header for a complete message: f_i=00 with\n *   frag_counter=3 claims three further fragments of a message the same\n *   header declares complete. The peek is therefore exact, not a heuristic.\n *   The legacy branch is deleted once no legacy sender remains (BLO-35597\n *   plan, Phase L).\n */\nexport type SignallingPayloadForm = 'iso-9.3.4.2' | 'legacy-bare-alfec'\n\nexport interface SignallingPayload {\n  form: SignallingPayloadForm\n  /** Each complete signalling message, starting at its message_id. */\n  messages: Uint8Array[]\n}\n\n/** f_i (Table 19): payload contains one or more complete signalling messages. */\nexport const SIGNALLING_FRAGMENTATION_COMPLETE = 0b00\n\n/**\n * Split the payload of an MMTP signalling packet into its complete\n * signalling messages.\n *\n * Returns null when the packet is not a well-formed, unprotected (FEC_type 0)\n * signalling packet, or when it carries a fragment (f_i != 00): reassembly\n * across packets is not implemented, and a fragment is not a message.\n */\nexport function parseSignallingPayload(mmtpPacket: Uint8Array): SignallingPayload | null {\n  let header: MMTPHeader\n  try {\n    header = parseMMTPHeader(mmtpPacket)\n  } catch {\n    return null\n  }\n  if (header.packetType !== PACKET_TYPE_SIGNALING || header.fecType !== 0) return null\n  const payload = mmtpPacket.subarray(header.headerLength)\n  return total(() => splitSignallingPayload(payload))\n}\n\nfunction splitSignallingPayload(payload: Uint8Array): SignallingPayload {\n  if (payload.length < 2) fail('short signalling payload')\n  if (payload[0] === (ALFEC_MESSAGE_ID >> 8) && payload[1] === (ALFEC_MESSAGE_ID & 0xff)) {\n    return { form: 'legacy-bare-alfec', messages: [payload] }\n  }\n\n  const reader = new WireReader(payload)\n  const flags = reader.u8()\n  const fragmentation = flags >> 6\n  const lengthIs32Bits = ((flags >> 1) & 1) === 1 // H\n  const aggregated = (flags & 1) === 1 // A\n  const fragmentCounter = reader.u8()\n  if (fragmentation !== SIGNALLING_FRAGMENTATION_COMPLETE) fail('fragmented signalling message')\n  // frag_counter counts the fragments that follow this one; a complete\n  // message has none, and an aggregated payload \"shall\" carry 0.\n  if (fragmentCounter !== 0) fail('frag_counter on a complete message')\n\n  if (!aggregated) {\n    // A=0: exactly one message and no MSG_length field (H is meaningless).\n    if (reader.remaining === 0) fail('empty signalling payload')\n    return { form: 'iso-9.3.4.2', messages: [payload.subarray(reader.offset)] }\n  }\n\n  const messages: Uint8Array[] = []\n  while (reader.remaining > 0) {\n    const length = lengthIs32Bits ? reader.u32() : reader.u16()\n    if (length === 0) fail('zero MSG_length')\n    const start = reader.offset\n    reader.bytes(length) // bounds check\n    messages.push(payload.subarray(start, start + length))\n  }\n  if (messages.length === 0) fail('aggregated payload with no message')\n  return { form: 'iso-9.3.4.2', messages }\n}\n\n// ---------------------------------------------------------------------------\n// 10.2 \u2014 general signalling message format\n// ---------------------------------------------------------------------------\n\nexport const PA_MESSAGE_ID = 0x0000\nexport const MPI_MESSAGE_ID_FIRST = 0x0001\nexport const MPI_MESSAGE_ID_LAST = 0x0010\nexport const MPT_MESSAGE_ID_FIRST = 0x0011\n/** MPT message carrying the complete MP table (Table 101). */\nexport const MPT_MESSAGE_ID_COMPLETE = 0x0020\n\n/**\n * Whether a message's `length` field is 32 bits (Table 20: PA and MPI\n * messages; Table 101: the 0x7000-0x7FFF range \"32-bit length message\").\n */\nexport function signallingMessageHas32BitLength(messageId: number): boolean {\n  return messageId === PA_MESSAGE_ID ||\n    (messageId >= MPI_MESSAGE_ID_FIRST && messageId <= MPI_MESSAGE_ID_LAST) ||\n    (messageId >= 0x7000 && messageId <= 0x7fff)\n}\n\n/**\n * Read the general header (Table 20) of a complete message and check that\n * `length` covers exactly the rest of the message.\n */\nfunction readMessageHeader(message: Uint8Array): { reader: WireReader; messageId: number; version: number } {\n  const reader = new WireReader(message)\n  const messageId = reader.u16()\n  const version = reader.u8()\n  const length = signallingMessageHas32BitLength(messageId) ? reader.u32() : reader.u16()\n  // \"The value 0 is not valid for this field\" (C.6.3, 10.3.2.3, 10.3.4.3).\n  if (length === 0 || length !== reader.remaining) fail('message length mismatch')\n  return { reader, messageId, version }\n}\n\n// ---------------------------------------------------------------------------\n// Annex C Table C.3 (Amd 1:2025) \u2014 AL-FEC message\n// ---------------------------------------------------------------------------\n\n/** fec_coding_structure values (Table C.8 as replaced by Amd 1:2025). */\nexport const FEC_CODING_STRUCTURE_NONE = 0b0000\nexport const FEC_CODING_STRUCTURE_ONE_STAGE = 0b0001\nexport const FEC_CODING_STRUCTURE_TWO_STAGE = 0b0010\nexport const FEC_CODING_STRUCTURE_LAYER_AWARE = 0b0011\nexport const FEC_CODING_STRUCTURE_ADAPTIVE = 0b0100\n\n/** ssbg_mode values (Table C.5). b11 is reserved. */\nexport const SSBG_MODE_0 = 0b00\nexport const SSBG_MODE_1 = 0b01\nexport const SSBG_MODE_2 = 0b10\n\nexport interface AlFecPrivateField {\n  privateFlag: 0 | 1\n  data: Uint8Array\n}\n\nexport interface AlFecRepairFlow {\n  /**\n   * repair_flow_id (16 bits under Amd 1:2025 for one-stage, two-stage and\n   * LA-FEC). Blockcast senders set it to the repair flow's MMTP packet_id.\n   */\n  repairFlowId: number\n  /**\n   * fec_code_id_for_repair_flow. Under LA-FEC (0011) one value is signalled\n   * per FEC flow and is repeated here on every layer.\n   */\n  fecCodeId: number\n  /**\n   * The private_flag/private_field_length/private_field triple, present\n   * exactly when the message's private_fec_flag is 1. Shared by every layer\n   * under LA-FEC, like fecCodeId.\n   */\n  privateField?: AlFecPrivateField\n  maximumK: number\n  maximumP: number\n  protectionWindowTime: number\n  protectionWindowSize: number\n}\n\nexport interface AlFecFlow {\n  fecFlowId: number\n  sourceFlowId: number\n  /** Every asset packet_id of the FEC source flow, in signalled order. */\n  packetIds: number[]\n  fecCodingStructure: number\n  ssbgMode: number\n  ffsrptsFlag: 0 | 1\n  /**\n   * The low bit of the coding byte. Amd 1:2025 Table C.3 names it\n   * fec_payload_id_mode (Table C.7: 0 = mode 0, Source FEC Payload ID added\n   * to each packet; 1 = mode 1, C.7, packets unmodified). The unamended 2023\n   * Table C.3 lists the same bit as reserved \"1\". The parse never depends on\n   * it \u2014 no later field is conditional on it \u2014 so both readings are\n   * accepted and the value is reported, not interpreted (BLO-35597 N1).\n   */\n  fecPayloadIdMode: 0 | 1\n  /** length_of_repair_symbol, in bytes. */\n  repairSymbolSize: number\n  /** Present exactly when ssbg_mode is b10. */\n  ssbgMode2?: {\n    numRepairSymbolPerPacket: number\n    numSymbolElementPerSourceSymbol: number\n  }\n  /** num_of_sub_block_per_source_block, two-stage (0010) only. */\n  numSubBlockPerSourceBlock?: number\n  /** One entry for one-stage; N3 parity flows; N4 LA-FEC layers; none for 0000. */\n  repairFlows: AlFecRepairFlow[]\n}\n\nexport interface AlFecMessageBody {\n  /** The message's version counter (C.6.3). Any value is accepted. */\n  version: number\n  fecFlag: 0 | 1\n  privateFecFlag: 0 | 1\n  /** Empty exactly when fec_flag is 0 (no FEC source flow). */\n  flows: AlFecFlow[]\n}\n\nexport interface AlFecMessage extends AlFecMessageBody {\n  payloadForm: SignallingPayloadForm\n}\n\nfunction readPrivateField(reader: WireReader): AlFecPrivateField {\n  const head = reader.u8()\n  return { privateFlag: (head >> 7) as 0 | 1, data: reader.bytes(head & 0x7f) }\n}\n\nfunction readRepairFlowTail(\n  reader: WireReader,\n  repairFlowId: number,\n  fecCodeId: number,\n  privateField: AlFecPrivateField | undefined,\n): AlFecRepairFlow {\n  const maximumK = reader.u24()\n  const maximumP = reader.u24()\n  const protectionWindowTime = reader.u32()\n  const protectionWindowSize = reader.u32()\n  return {\n    repairFlowId,\n    fecCodeId,\n    ...(privateField ? { privateField } : {}),\n    maximumK,\n    maximumP,\n    protectionWindowTime,\n    protectionWindowSize,\n  }\n}\n\nfunction readRepairFlow(reader: WireReader, privateFecFlag: boolean): AlFecRepairFlow {\n  const repairFlowId = reader.u16()\n  const fecCodeId = reader.u8()\n  const privateField = privateFecFlag ? readPrivateField(reader) : undefined\n  return readRepairFlowTail(reader, repairFlowId, fecCodeId, privateField)\n}\n\nfunction readFecFlow(reader: WireReader, privateFecFlag: boolean): AlFecFlow {\n  const fecFlowId = reader.u8()\n  const sourceFlowId = reader.u8()\n  const numberOfAssets = reader.u8()\n  if (numberOfAssets === 0) fail('FEC flow with no asset')\n  const packetIds: number[] = []\n  for (let i = 0; i < numberOfAssets; i++) packetIds.push(reader.u16())\n\n  const coding = reader.u8()\n  const fecCodingStructure = coding >> 4\n  const ssbgMode = (coding >> 2) & 0b11\n  const ffsrptsFlag = ((coding >> 1) & 1) as 0 | 1\n  const fecPayloadIdMode = (coding & 1) as 0 | 1\n  if (ssbgMode === 0b11) fail('reserved ssbg_mode')\n  const repairSymbolSize = reader.u16()\n\n  const flow: AlFecFlow = {\n    fecFlowId,\n    sourceFlowId,\n    packetIds,\n    fecCodingStructure,\n    ssbgMode,\n    ffsrptsFlag,\n    fecPayloadIdMode,\n    repairSymbolSize,\n    repairFlows: [],\n  }\n  if (ssbgMode === SSBG_MODE_2) {\n    flow.ssbgMode2 = {\n      numRepairSymbolPerPacket: reader.u16(),\n      numSymbolElementPerSourceSymbol: reader.u16(),\n    }\n  }\n\n  switch (fecCodingStructure) {\n    case FEC_CODING_STRUCTURE_NONE:\n      break\n    case FEC_CODING_STRUCTURE_ONE_STAGE:\n      flow.repairFlows.push(readRepairFlow(reader, privateFecFlag))\n      break\n    case FEC_CODING_STRUCTURE_TWO_STAGE: {\n      flow.numSubBlockPerSourceBlock = reader.u8()\n      const numberOfParityFlows = reader.u8()\n      for (let k = 0; k < numberOfParityFlows; k++) {\n        flow.repairFlows.push(readRepairFlow(reader, privateFecFlag))\n      }\n      break\n    }\n    case FEC_CODING_STRUCTURE_LAYER_AWARE: {\n      const numberOfLayers = reader.u8()\n      const fecCodeId = reader.u8()\n      const privateField = privateFecFlag ? readPrivateField(reader) : undefined\n      for (let l = 0; l < numberOfLayers; l++) {\n        flow.repairFlows.push(readRepairFlowTail(reader, reader.u16(), fecCodeId, privateField))\n      }\n      break\n    }\n    default:\n      // 0100 (adaptive FEC, Amd 1:2025): the published table leaves the\n      // width of number_of__class unstated, so its flows cannot be placed\n      // exactly. 0101-1111 are reserved. Either way every later flow would\n      // be misread, so the whole message is refused.\n      fail(`unsupported fec_coding_structure ${fecCodingStructure}`)\n  }\n  return flow\n}\n\n/**\n * Parse a complete AL-FEC message (Table C.3, Amd 1:2025), starting at its\n * message_id. Every FEC flow, every asset packet_id and every\n * coding-structure-conditional field is returned.\n */\nexport function parseAlFecMessageBody(message: Uint8Array): AlFecMessageBody | null {\n  return total(() => {\n    const { reader, messageId, version } = readMessageHeader(message)\n    if (messageId !== ALFEC_MESSAGE_ID) return null\n    const flags = reader.u8()\n    const fecFlag = (flags >> 7) as 0 | 1\n    const privateFecFlag = ((flags >> 6) & 1) as 0 | 1\n    if (fecFlag === 0) {\n      // \"If every source flows are delivered without AL-FEC protection, all\n      // the remaining message is not to be delivered\" (C.6.3).\n      reader.expectEnd()\n      return { version, fecFlag, privateFecFlag, flows: [] }\n    }\n    const descriptorLength = reader.u16()\n    if (descriptorLength === 0 || descriptorLength !== reader.remaining) {\n      fail('length_of_fec_flow_descriptor mismatch')\n    }\n    const numberOfFecFlows = reader.u8()\n    if (numberOfFecFlows === 0) fail('fec_flag=1 with no FEC flow')\n    const flows: AlFecFlow[] = []\n    for (let i = 0; i < numberOfFecFlows; i++) flows.push(readFecFlow(reader, privateFecFlag === 1))\n    reader.expectEnd()\n    return { version, fecFlag, privateFecFlag, flows }\n  })\n}\n\n/**\n * Parse the AL-FEC message carried by a full MMTP signalling packet, in\n * either payload form (see SignallingPayloadForm). Returns null when the\n * packet carries no AL-FEC message, more than one, or a malformed one.\n */\nexport function parseAlFecMessage(mmtpPacket: Uint8Array): AlFecMessage | null {\n  const packet = parseSignallingPacket(mmtpPacket)\n  if (!packet) return null\n  const alFec = packet.messages.filter(\n    (message): message is Extract<MmtSignallingMessage, { kind: 'al-fec' }> => message.kind === 'al-fec',\n  )\n  if (alFec.length !== 1) return null\n  return { ...alFec[0]!.message, payloadForm: packet.payloadForm }\n}\n\n/**\n * Decoder geometry of one FEC flow under the Blockcast one-stage RaptorQ\n * profile: private_field = RaptorQ FEC OTI (RFC 6330 3.3.2-3.3.3, 12 bytes)\n * followed by the interleave depth (1 byte).\n */\nexport interface AlFecRaptorQFlowConfig {\n  sourcePacketIds: number[]\n  repairFlowId: number\n  ssbgMode: number\n  fecPayloadIdMode: 0 | 1\n  repairSymbolSize: number\n  maximumK: number\n  maximumP: number\n  interleaveDepth: number\n  oti: Uint8Array\n  protectionWindowTime: number\n  protectionWindowSize: number\n}\n\nconst RAPTORQ_PRIVATE_FIELD_LENGTH = 13\nconst RAPTORQ_MAX_SOURCE_SYMBOLS = 56_403\nconst REPAIR_SYMBOL_ID_MAX = 0x00ff_ffff\n\nfunction canonicalRaptorQOtiK(oti: Uint8Array, repairSymbolSize: number): number | null {\n  if (oti.length !== 12 || oti[5] !== 0) return null\n  const transferLength = (oti[0]! * 0x1_0000_0000) +\n    (((oti[1]! << 24) | (oti[2]! << 16) | (oti[3]! << 8) | oti[4]!) >>> 0)\n  const symbolSize = (oti[6]! << 8) | oti[7]!\n  const sourceBlocks = oti[8]!\n  const subBlocks = (oti[9]! << 8) | oti[10]!\n  const alignment = oti[11]!\n  if (!Number.isSafeInteger(transferLength) || transferLength <= 0 ||\n      symbolSize !== repairSymbolSize || symbolSize === 0 || symbolSize % 8 !== 0 ||\n      sourceBlocks !== 1 || subBlocks !== 1 || alignment !== 8 ||\n      transferLength % symbolSize !== 0) {\n    return null\n  }\n  const k = transferLength / symbolSize\n  return Number.isInteger(k) && k >= 1 && k <= RAPTORQ_MAX_SOURCE_SYMBOLS ? k : null\n}\n\n/**\n * Validate one parsed FEC flow against the Blockcast one-stage RaptorQ\n * profile and return its decoder geometry, or null when the flow is outside\n * the profile. Nothing is inferred: K comes from the OTI and must equal\n * maximum_k_for_repair_flow.\n *\n * ssbg_mode 0 and 1 are both returned as signalled: which source-symbol\n * construction a decoder applies is the stream's FEC block profile, decided\n * by its consumer, not here. ffsrpts_flag=1 is refused because the FFSRP_TS\n * word changes the source/repair packet trailer layout that every Blockcast\n * receiver assumes.\n */\nexport function alFecRaptorQFlowConfig(flow: AlFecFlow): AlFecRaptorQFlowConfig | null {\n  if (flow.fecCodingStructure !== FEC_CODING_STRUCTURE_ONE_STAGE || flow.repairFlows.length !== 1) return null\n  if (flow.ssbgMode !== SSBG_MODE_0 && flow.ssbgMode !== SSBG_MODE_1) return null\n  if (flow.ffsrptsFlag !== 0) return null\n  const repair = flow.repairFlows[0]!\n  if (repair.fecCodeId !== FEC_CODE_RAPTORQ) return null\n  const privateField = repair.privateField\n  if (!privateField || privateField.privateFlag !== 1 ||\n      privateField.data.length !== RAPTORQ_PRIVATE_FIELD_LENGTH) {\n    return null\n  }\n  const oti = privateField.data.slice(0, 12)\n  const interleaveDepth = privateField.data[12]!\n  const otiK = canonicalRaptorQOtiK(oti, flow.repairSymbolSize)\n  if (otiK === null || interleaveDepth === 0) return null\n  if (repair.maximumK !== otiK || repair.maximumP === 0 ||\n      repair.maximumK + repair.maximumP - 1 > REPAIR_SYMBOL_ID_MAX) {\n    return null\n  }\n  return {\n    sourcePacketIds: [...flow.packetIds],\n    repairFlowId: repair.repairFlowId,\n    ssbgMode: flow.ssbgMode,\n    fecPayloadIdMode: flow.fecPayloadIdMode,\n    repairSymbolSize: flow.repairSymbolSize,\n    maximumK: repair.maximumK,\n    maximumP: repair.maximumP,\n    interleaveDepth,\n    oti,\n    protectionWindowTime: repair.protectionWindowTime,\n    protectionWindowSize: repair.protectionWindowSize,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// 10.6 \u2014 location, asset_id and identifier mapping\n// ---------------------------------------------------------------------------\n\n/** location_type values (Table 96) a receiver may meet in an asset location. */\nexport type MmtGeneralLocation =\n  | { locationType: 0x00; packetId: number }\n  | { locationType: 0x01; srcAddress: Uint8Array; dstAddress: Uint8Array; dstPort: number; packetId: number }\n  | { locationType: 0x02; srcAddress: Uint8Array; dstAddress: Uint8Array; dstPort: number; packetId: number }\n  | { locationType: 0x03; networkId: number; transportStreamId: number; mpeg2Pid: number }\n  | { locationType: 0x04; srcAddress: Uint8Array; dstAddress: Uint8Array; dstPort: number; mpeg2Pid: number }\n  | { locationType: 0x05; url: Uint8Array }\n  | { locationType: 0x06; data: Uint8Array }\n\n/**\n * MMT_general_location_info() for an Asset location. \"Only the value of\n * location_type between 0x00 and 0x06 shall be used for an Asset location\"\n * (10.3.9.3), so any other value is refused rather than skipped: the\n * remaining types have their own lengths, and a reserved one has none.\n */\nfunction readAssetLocation(reader: WireReader): MmtGeneralLocation {\n  const locationType = reader.u8()\n  switch (locationType) {\n    case 0x00:\n      return { locationType, packetId: reader.u16() }\n    case 0x01:\n    case 0x02: {\n      const addressLength = locationType === 0x01 ? 4 : 16\n      const srcAddress = reader.bytes(addressLength)\n      const dstAddress = reader.bytes(addressLength)\n      const dstPort = reader.u16()\n      return { locationType, srcAddress, dstAddress, dstPort, packetId: reader.u16() }\n    }\n    case 0x03: {\n      const networkId = reader.u16()\n      const transportStreamId = reader.u16()\n      return { locationType, networkId, transportStreamId, mpeg2Pid: reader.u16() & 0x1fff }\n    }\n    case 0x04: {\n      const srcAddress = reader.bytes(16)\n      const dstAddress = reader.bytes(16)\n      const dstPort = reader.u16()\n      return { locationType, srcAddress, dstAddress, dstPort, mpeg2Pid: reader.u16() & 0x1fff }\n    }\n    case 0x05:\n      return { locationType, url: reader.bytes(reader.u8()) }\n    case 0x06:\n      return { locationType, data: reader.bytes(reader.u16()) }\n    default:\n      fail(`location_type ${locationType} is not an Asset location`)\n  }\n}\n\n/** Identifier_mapping() (Table 98). */\nexport type MmtIdentifierMapping =\n  | { identifierType: 0x00; assetIdScheme: number; assetId: Uint8Array }\n  | { identifierType: 0x01; urls: Uint8Array[] }\n  | { identifierType: 0x02; regex: Uint8Array }\n  | { identifierType: 0x03; representationId: Uint8Array }\n  | { identifierType: number; privateIdentifier: Uint8Array }\n\nfunction readIdentifierMapping(reader: WireReader): MmtIdentifierMapping {\n  const identifierType = reader.u8()\n  switch (identifierType) {\n    case 0x00: {\n      const assetIdScheme = reader.u32()\n      return { identifierType, assetIdScheme, assetId: reader.bytes(reader.u32()) }\n    }\n    case 0x01: {\n      const urls: Uint8Array[] = []\n      const urlCount = reader.u16()\n      for (let i = 0; i < urlCount; i++) urls.push(reader.bytes(reader.u16()))\n      return { identifierType, urls }\n    }\n    case 0x02:\n      return { identifierType, regex: reader.bytes(reader.u16()) }\n    case 0x03:\n      return { identifierType, representationId: reader.bytes(reader.u16()) }\n    default:\n      return { identifierType, privateIdentifier: reader.bytes(reader.u16()) }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// 10.3.9 \u2014 MP table; 10.3.2 PA message; 10.3.4 MPT message\n// ---------------------------------------------------------------------------\n\n/** table_id range of the MP table (Table 102): subset 0..14, then complete. */\nexport const MP_TABLE_ID_SUBSET_0 = 0x11\nexport const MP_TABLE_ID_COMPLETE = 0x20\nexport const MPI_TABLE_ID_FIRST = 0x01\nexport const MPI_TABLE_ID_LAST = 0x10\n\nexport interface MpAsset {\n  identifier: MmtIdentifierMapping\n  /** asset_type, a 4CC (for example 'hvc1', 'mp4a'). */\n  assetType: string\n  assetModificationFlag: boolean\n  defaultAssetFlag: boolean\n  /** Present exactly when asset_clock_relation_flag is 1. */\n  assetClockRelationId?: number\n  /** Present exactly when asset_timescale_flag is 1. */\n  assetTimescale?: number\n  locations: MmtGeneralLocation[]\n  descriptors: Uint8Array\n}\n\nexport interface MpTable {\n  tableId: number\n  version: number\n  /** MP_table_mode (Table 30); b11 is reserved and reported as read. */\n  mpTableMode: number\n  /** Present exactly for the complete table (0x20) and subset 0 (0x11). */\n  packageId?: Uint8Array\n  /** Present exactly for the complete table (0x20) and subset 0 (0x11). */\n  descriptors?: Uint8Array\n  assets: MpAsset[]\n}\n\nfunction readMpTable(reader: WireReader): MpTable {\n  const tableId = reader.u8()\n  if (tableId < MP_TABLE_ID_SUBSET_0 || tableId > MP_TABLE_ID_COMPLETE) fail('not an MP table')\n  const version = reader.u8()\n  const length = reader.u16()\n  if (length === 0) fail('zero MP table length')\n  const table = new WireReader(reader.bytes(length))\n\n  const mpTableMode = table.u8() & 0b11\n  const result: MpTable = { tableId, version, mpTableMode, assets: [] }\n  if (tableId === MP_TABLE_ID_COMPLETE || tableId === MP_TABLE_ID_SUBSET_0) {\n    result.packageId = table.bytes(table.u8())\n    result.descriptors = table.bytes(table.u16())\n  }\n  const numberOfAssets = table.u8()\n  for (let i = 0; i < numberOfAssets; i++) {\n    const identifier = readIdentifierMapping(table)\n    const assetType = String.fromCharCode(...table.bytes(4))\n    const flags = table.u8()\n    const asset: MpAsset = {\n      identifier,\n      assetType,\n      assetModificationFlag: ((flags >> 2) & 1) === 1,\n      defaultAssetFlag: ((flags >> 1) & 1) === 1,\n      locations: [],\n      descriptors: new Uint8Array(0),\n    }\n    if ((flags & 1) === 1) { // asset_clock_relation_flag\n      asset.assetClockRelationId = table.u8()\n      if ((table.u8() & 1) === 1) asset.assetTimescale = table.u32() // asset_timescale_flag\n    }\n    const locationCount = table.u8()\n    for (let j = 0; j < locationCount; j++) asset.locations.push(readAssetLocation(table))\n    asset.descriptors = table.bytes(table.u16())\n    result.assets.push(asset)\n  }\n  table.expectEnd()\n  return result\n}\n\n/** Parse a complete MP table (Table 29), starting at its table_id. */\nexport function parseMpTable(bytes: Uint8Array): MpTable | null {\n  return total(() => {\n    const reader = new WireReader(bytes)\n    const table = readMpTable(reader)\n    reader.expectEnd()\n    return table\n  })\n}\n\n/**\n * The packet_ids an Asset is delivered on: every location of type 0x00\n * (same MMTP packet flow), 0x01 (UDP/IPv4) or 0x02 (UDP/IPv6), in\n * signalled order.\n */\nexport function mpAssetPacketIds(asset: MpAsset): number[] {\n  const packetIds: number[] = []\n  for (const location of asset.locations) {\n    if (location.locationType === 0x00 || location.locationType === 0x01 || location.locationType === 0x02) {\n      packetIds.push(location.packetId)\n    }\n  }\n  return packetIds\n}\n\nexport interface MmtSignallingTable {\n  tableId: number\n  version: number\n  /** The complete table, starting at its table_id. */\n  bytes: Uint8Array\n}\n\nexport interface PaMessage {\n  version: number\n  /** Every table of the message payload, in order. */\n  tables: MmtSignallingTable[]\n  /** The MP tables among `tables`, decoded. */\n  mpTables: MpTable[]\n}\n\nexport interface MptMessage {\n  /** 0x0011-0x001F carry subset 0-14, 0x0020 the complete MP table. */\n  messageId: number\n  version: number\n  table: MpTable\n}\n\n/**\n * Parse a complete PA message (Table 21), starting at its message_id.\n *\n * Every table in the payload is delimited by its own 16-bit `length` and\n * must match the extension's table_id and table_version. For non-MPI tables\n * table_length is \"a copy of the length field\" (10.3.2.3) and must match it\n * too; for an MPI table it is derived differently, so it is not compared.\n */\nexport function parsePaMessageBody(message: Uint8Array): PaMessage | null {\n  return total(() => {\n    const { reader, messageId, version } = readMessageHeader(message)\n    if (messageId !== PA_MESSAGE_ID) return null\n    const numberOfTables = reader.u8()\n    const entries: { tableId: number; tableVersion: number; tableLength: number }[] = []\n    for (let i = 0; i < numberOfTables; i++) {\n      entries.push({ tableId: reader.u8(), tableVersion: reader.u8(), tableLength: reader.u16() })\n    }\n    const tables: MmtSignallingTable[] = []\n    const mpTables: MpTable[] = []\n    for (const entry of entries) {\n      const start = reader.offset\n      const tableId = reader.u8()\n      const tableVersion = reader.u8()\n      const length = reader.u16()\n      if (length === 0) fail('zero table length')\n      reader.bytes(length) // bounds check\n      const isMpi = tableId >= MPI_TABLE_ID_FIRST && tableId <= MPI_TABLE_ID_LAST\n      if (tableId !== entry.tableId || tableVersion !== entry.tableVersion ||\n          (!isMpi && length !== entry.tableLength)) {\n        fail('PA extension does not describe its table')\n      }\n      const bytes = message.subarray(start, reader.offset)\n      tables.push({ tableId, version: tableVersion, bytes })\n      if (tableId >= MP_TABLE_ID_SUBSET_0 && tableId <= MP_TABLE_ID_COMPLETE) {\n        const table = parseMpTable(bytes)\n        if (!table) fail('malformed MP table in PA message')\n        mpTables.push(table)\n      }\n    }\n    reader.expectEnd()\n    return { version, tables, mpTables }\n  })\n}\n\n/** Parse a complete MPT message (Table 23), starting at its message_id. */\nexport function parseMptMessageBody(message: Uint8Array): MptMessage | null {\n  return total(() => {\n    const { reader, messageId, version } = readMessageHeader(message)\n    if (messageId < MPT_MESSAGE_ID_FIRST || messageId > MPT_MESSAGE_ID_COMPLETE) return null\n    const table = readMpTable(reader)\n    reader.expectEnd()\n    return { messageId, version, table }\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Packet-level dispatch (the packet_id 0 signalling handler)\n// ---------------------------------------------------------------------------\n\nexport type MmtSignallingMessage =\n  | { kind: 'al-fec'; message: AlFecMessageBody }\n  | { kind: 'pa'; message: PaMessage }\n  | { kind: 'mpt'; message: MptMessage }\n  /** A message this module does not decode, delimited and length-checked. */\n  | { kind: 'other'; messageId: number; version: number; bytes: Uint8Array }\n\nexport interface MmtSignallingPacket {\n  payloadForm: SignallingPayloadForm\n  messages: MmtSignallingMessage[]\n}\n\nfunction decodeSignallingMessage(bytes: Uint8Array): MmtSignallingMessage {\n  const { messageId, version } = readMessageHeader(bytes)\n  if (messageId === ALFEC_MESSAGE_ID) {\n    const message = parseAlFecMessageBody(bytes)\n    if (!message) fail('malformed AL-FEC message')\n    return { kind: 'al-fec', message }\n  }\n  if (messageId === PA_MESSAGE_ID) {\n    const message = parsePaMessageBody(bytes)\n    if (!message) fail('malformed PA message')\n    return { kind: 'pa', message }\n  }\n  if (messageId >= MPT_MESSAGE_ID_FIRST && messageId <= MPT_MESSAGE_ID_COMPLETE) {\n    const message = parseMptMessageBody(bytes)\n    if (!message) fail('malformed MPT message')\n    return { kind: 'mpt', message }\n  }\n  return { kind: 'other', messageId, version, bytes }\n}\n\n/**\n * Parse every signalling message of a full MMTP signalling packet (the\n * packet_id 0 flow). Returns null when the packet or any message in it is\n * malformed: one unparseable message leaves the receiver unable to say what\n * the packet signalled.\n *\n * The legacy bare form carries exactly one AL-FEC message; any other message\n * is only accepted inside a 9.3.4.2 payload.\n */\nexport function parseSignallingPacket(mmtpPacket: Uint8Array): MmtSignallingPacket | null {\n  const payload = parseSignallingPayload(mmtpPacket)\n  if (!payload) return null\n  return total(() => ({\n    payloadForm: payload.form,\n    messages: payload.messages.map(decodeSignallingMessage),\n  }))\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 * MMTP Signaling Parser for Multicast\n *\n * Provides packet type detection and AL-FEC signaling message parsing.\n * Used by the multicast pipeline to classify and route MMTP packets.\n *\n * Packet types (ISO/IEC 23008-1:2023 Section 9.2.2):\n * - 0x00: MPU (Media Processing Unit) - video/audio data\n * - 0x02: Signaling - control messages including AL-FEC config\n * - 0x03: Repair - FEC repair symbols\n */\nimport {\n\tALFEC_MESSAGE_ID,\n\tFEC_CODE_RAPTORQ,\n\tFEC_CODE_XOR,\n\tPACKET_TYPE_MPU,\n\tPACKET_TYPE_REPAIR,\n\tPACKET_TYPE_SIGNALING,\n\tparseAlFecMessage,\n} from \"@blockcast/mmt-base\";\n\nexport {\n\tALFEC_MESSAGE_ID,\n\tFEC_CODE_RAPTORQ,\n\tFEC_CODE_XOR,\n\tPACKET_TYPE_MPU,\n\tPACKET_TYPE_REPAIR,\n\tPACKET_TYPE_SIGNALING,\n\tparseAlFecMessage,\n};\n\nexport type PacketClass = \"source\" | \"signaling\" | \"repair\" | \"unknown\";\n\n/** Get the MMTP packet type from raw multicast packet bytes.\n *\n * ISO/IEC 23008-1:2023 Figure 8 (V=0): byte 1 is\n * reserved(2)|packet_type(6), so signaling is 0x02 and repair is 0x03.\n * Pre-migration FFmpeg high-bits bytes (0x08/0x0c) are NOT accepted:\n * writers and readers move together in the pinned smoke train.\n */\nexport function getPacketType(mmtpPacket: Uint8Array): number {\n\tif (mmtpPacket.length < 2) return -1;\n\treturn mmtpPacket[1] & 0x3f;\n}\n\n/** Check if packet is a signaling packet (type 0x02). */\nexport function isSignalingPacket(mmtpPacket: Uint8Array): boolean {\n\treturn getPacketType(mmtpPacket) === PACKET_TYPE_SIGNALING;\n}\n\n/** Determine if packet is a source (video/audio) packet. */\nexport function isSourcePacket(mmtpPacket: Uint8Array): boolean {\n\tif (mmtpPacket.length < 2) return false;\n\tconst packetType = mmtpPacket[1] & 0x3f;\n\tconst fecType = (mmtpPacket[0] >> 3) & 0x03;\n\treturn packetType === 0x00 && fecType <= 1;\n}\n\n/** Classify MMTP packet for multicast pipeline routing. */\nexport function classifyPacket(mmtpPacket: Uint8Array): PacketClass {\n\tif (mmtpPacket.length < 2) return \"unknown\";\n\tconst packetType = mmtpPacket[1] & 0x3f;\n\tconst fecType = (mmtpPacket[0] >> 3) & 0x03;\n\tif ((mmtpPacket[0] >> 6) !== 0) return \"unknown\";\n\tswitch (packetType) {\n\t\tcase 0x00:\n\t\t\tif (mmtpPacket.length < 20) return \"unknown\";\n\t\t\tif (fecType >= 2) return \"repair\";\n\t\t\treturn \"source\";\n\t\tcase 0x02:\n\t\t\treturn \"signaling\";\n\t\tcase 0x03:\n\t\t\tif (mmtpPacket.length < 20) return \"unknown\";\n\t\t\treturn \"repair\";\n\t\tdefault:\n\t\t\treturn \"unknown\";\n\t}\n}\n"],
+  "mappings": "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",
+  "names": ["MPU_HEADER_SIZE", "MPU_LENGTH_FIELD_SIZE", "MPU_HEADER_REMAINDER_SIZE", "MPU_HEADER_SIZE"]
+}

package/dist/source-auth.d.ts

@@ -0,0 +1,2 @@
+export * from '@blockcast/mmt-manifest-verify';
+//# sourceMappingURL=source-auth.d.ts.map

package/dist/source-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-auth.d.ts","sourceRoot":"","sources":["../src/source-auth.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA"}