@blockcast/mmt-container 0.1.0-main.149f78a4adae

package/dist/cmaf-group-batcher.js

@@ -0,0 +1,195 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+// src/mmtp-to-cmaf.ts
+function box(type, ...children) {
+  let size = 8;
+  for (const c of children) size += c.length;
+  const buf = new Uint8Array(size);
+  new DataView(buf.buffer).setUint32(0, size);
+  buf[4] = type.charCodeAt(0);
+  buf[5] = type.charCodeAt(1);
+  buf[6] = type.charCodeAt(2);
+  buf[7] = type.charCodeAt(3);
+  let pos = 8;
+  for (const c of children) {
+    buf.set(c, pos);
+    pos += c.length;
+  }
+  return buf;
+}
+function fullBox(type, version, flags, ...children) {
+  let size = 12;
+  for (const c of children) size += c.length;
+  const buf = new Uint8Array(size);
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(0, size);
+  buf[4] = type.charCodeAt(0);
+  buf[5] = type.charCodeAt(1);
+  buf[6] = type.charCodeAt(2);
+  buf[7] = type.charCodeAt(3);
+  dv.setUint32(8, version << 24 | flags & 16777215);
+  let pos = 12;
+  for (const c of children) {
+    buf.set(c, pos);
+    pos += c.length;
+  }
+  return buf;
+}
+function u32(v) {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, v);
+  return b;
+}
+var KEYFRAME_FLAGS = 33554432;
+var DELTA_FLAGS = 16842752;
+var UINT32_MAX = 4294967295;
+var MAX_TRACK_ID = UINT32_MAX - 1;
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+function assertTrackId(trackId, label) {
+  if (!Number.isInteger(trackId) || trackId <= 0 || trackId > MAX_TRACK_ID) {
+    throw new RangeError(`${label} must be an integer in 1..${MAX_TRACK_ID}, got ${trackId}`);
+  }
+}
+function assertCompositionTimeOffsets(samples) {
+  for (let i = 0; i < samples.length; i++) {
+    const offset = samples[i].compositionTimeOffset;
+    if (offset !== void 0 && (!Number.isInteger(offset) || offset < INT32_MIN || offset > INT32_MAX)) {
+      throw new RangeError(
+        `sample ${i} compositionTimeOffset must be an integer in ${INT32_MIN}..${INT32_MAX}, got ${offset}`
+      );
+    }
+  }
+}
+function encodeMultiSampleSegment(samples, baseDecodeTime, sequence, trackId = 1) {
+  if (samples.length === 0) return new Uint8Array(0);
+  assertTrackId(trackId, "trackId");
+  assertCompositionTimeOffsets(samples);
+  const mfhd = fullBox("mfhd", 0, 0, u32(sequence));
+  const tfhd = fullBox("tfhd", 0, 131072, u32(trackId));
+  const tfdtBody = new Uint8Array(8);
+  const tfdtView = new DataView(tfdtBody.buffer);
+  tfdtView.setUint32(0, Math.floor(baseDecodeTime / 4294967296));
+  tfdtView.setUint32(4, baseDecodeTime >>> 0);
+  const tfdt = fullBox("tfdt", 1, 0, tfdtBody);
+  const hasCompositionTimeOffset = samples.some((sample) => sample.compositionTimeOffset !== void 0);
+  const trunVersion = hasCompositionTimeOffset ? 1 : 0;
+  const trunFlags = 1793 | (hasCompositionTimeOffset ? 2048 : 0);
+  const sampleCount = samples.length;
+  const sampleEntrySize = hasCompositionTimeOffset ? 16 : 12;
+  const trunBody = new Uint8Array(8 + sampleCount * sampleEntrySize);
+  const trunView = new DataView(trunBody.buffer);
+  trunView.setUint32(0, sampleCount);
+  trunView.setUint32(4, 0);
+  for (let i = 0; i < sampleCount; i++) {
+    const s = samples[i];
+    const off = 8 + i * sampleEntrySize;
+    trunView.setUint32(off, s.duration >>> 0);
+    trunView.setUint32(off + 4, s.data.length);
+    trunView.setUint32(off + 8, s.keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS);
+    if (hasCompositionTimeOffset) {
+      trunView.setInt32(off + 12, s.compositionTimeOffset ?? 0);
+    }
+  }
+  const trun = fullBox("trun", trunVersion, trunFlags, trunBody);
+  const traf = box("traf", tfhd, tfdt, trun);
+  const moof = box("moof", mfhd, traf);
+  let mdatSize = 0;
+  for (const s of samples) mdatSize += s.data.length;
+  const mdatPayload = new Uint8Array(mdatSize);
+  let pos = 0;
+  for (const s of samples) {
+    mdatPayload.set(s.data, pos);
+    pos += s.data.length;
+  }
+  const mdat = box("mdat", mdatPayload);
+  const dataOffsetPos = 8 + mfhd.length + 8 + tfhd.length + tfdt.length + 12 + 4;
+  new DataView(moof.buffer).setUint32(dataOffsetPos, moof.length + 8);
+  const result = new Uint8Array(moof.length + mdat.length);
+  result.set(moof, 0);
+  result.set(mdat, moof.length);
+  return result;
+}
+
+// src/cmaf-group-batcher.ts
+var _trackId, _fallbackFrameDuration, _buffer, _sequence, _baseTs, _disposed;
+var CmafGroupBatcher = class {
+  constructor(config) {
+    __privateAdd(this, _trackId);
+    __privateAdd(this, _fallbackFrameDuration);
+    __privateAdd(this, _buffer, []);
+    __privateAdd(this, _sequence, 1);
+    __privateAdd(this, _baseTs, -1);
+    __privateAdd(this, _disposed, false);
+    this.onSegment = null;
+    if (!Number.isFinite(config.trackId) || config.trackId <= 0) {
+      throw new Error(`CmafGroupBatcher: trackId must be a positive finite number (got ${config.trackId})`);
+    }
+    if (!Number.isFinite(config.fallbackFrameDuration) || config.fallbackFrameDuration <= 0) {
+      throw new Error(
+        `CmafGroupBatcher: fallbackFrameDuration must be positive and finite \u2014 derive from catalog (video=1e6/fps, audio=1e6*1024/sampleRate). Got ${config.fallbackFrameDuration}`
+      );
+    }
+    this.trackType = config.trackType;
+    __privateSet(this, _trackId, config.trackId);
+    __privateSet(this, _fallbackFrameDuration, config.fallbackFrameDuration);
+  }
+  addFrame(data, timestamp, keyframe) {
+    if (__privateGet(this, _disposed)) return;
+    __privateGet(this, _buffer).push({ data, timestamp, keyframe });
+  }
+  flush() {
+    if (__privateGet(this, _disposed)) return;
+    const frames = __privateGet(this, _buffer);
+    if (frames.length === 0) return;
+    __privateSet(this, _buffer, []);
+    if (__privateGet(this, _baseTs) < 0) __privateSet(this, _baseTs, frames[0].timestamp);
+    const relTs = frames[0].timestamp - __privateGet(this, _baseTs);
+    const samples = frames.map((f, i) => {
+      let duration;
+      if (i < frames.length - 1) {
+        duration = frames[i + 1].timestamp - f.timestamp;
+      } else {
+        duration = i > 0 ? f.timestamp - frames[i - 1].timestamp : __privateGet(this, _fallbackFrameDuration);
+      }
+      if (duration <= 0) duration = __privateGet(this, _fallbackFrameDuration);
+      return { data: f.data, duration, keyframe: f.keyframe };
+    });
+    const segment = encodeMultiSampleSegment(samples, relTs, __privateWrapper(this, _sequence)._++, __privateGet(this, _trackId));
+    this.onSegment?.(segment);
+  }
+  reset() {
+    __privateSet(this, _buffer, []);
+    __privateSet(this, _sequence, 1);
+    __privateSet(this, _baseTs, -1);
+  }
+  dispose() {
+    __privateSet(this, _disposed, true);
+    __privateSet(this, _buffer, []);
+    this.onSegment = null;
+  }
+};
+_trackId = new WeakMap();
+_fallbackFrameDuration = new WeakMap();
+_buffer = new WeakMap();
+_sequence = new WeakMap();
+_baseTs = new WeakMap();
+_disposed = new WeakMap();
+export {
+  CmafGroupBatcher
+};
+//# sourceMappingURL=cmaf-group-batcher.js.map

package/dist/cmaf-group-batcher.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/mmtp-to-cmaf.ts", "../src/cmaf-group-batcher.ts"],
+  "sourcesContent": ["/**\n * MMTP \u2192 CMAF converter per draft-ramadan-moq-mmt \u00A75.3.\n *\n * Converts reassembled MFU frames (raw codec samples from MMTP) into\n * fMP4 segments (moof+mdat) suitable for MSE SourceBuffer.appendBuffer().\n *\n * MPU metadata (fragment_type=0) packets from FFmpeg are complete\n * ftyp+moov init segments and can be used directly as MSE init data.\n *\n * MFU data (fragment_type=2) contains raw AVCC samples that must be\n * wrapped in moof+mdat boxes for MSE consumption.\n *\n * ISO 14496-12 (ISOBMFF) box construction is inline \u2014 no dependencies.\n */\n\n// \u2500\u2500 ISOBMFF box helpers \u2500\u2500\n\nfunction box(type: string, ...children: Uint8Array[]): Uint8Array {\n  let size = 8\n  for (const c of children) size += c.length\n  const buf = new Uint8Array(size)\n  new DataView(buf.buffer).setUint32(0, size)\n  buf[4] = type.charCodeAt(0)\n  buf[5] = type.charCodeAt(1)\n  buf[6] = type.charCodeAt(2)\n  buf[7] = type.charCodeAt(3)\n  let pos = 8\n  for (const c of children) {\n    buf.set(c, pos)\n    pos += c.length\n  }\n  return buf\n}\n\nfunction fullBox(type: string, version: number, flags: number, ...children: Uint8Array[]): Uint8Array {\n  let size = 12\n  for (const c of children) size += c.length\n  const buf = new Uint8Array(size)\n  const dv = new DataView(buf.buffer)\n  dv.setUint32(0, size)\n  buf[4] = type.charCodeAt(0)\n  buf[5] = type.charCodeAt(1)\n  buf[6] = type.charCodeAt(2)\n  buf[7] = type.charCodeAt(3)\n  dv.setUint32(8, (version << 24) | (flags & 0xffffff))\n  let pos = 12\n  for (const c of children) {\n    buf.set(c, pos)\n    pos += c.length\n  }\n  return buf\n}\n\nfunction u32(v: number): Uint8Array {\n  const b = new Uint8Array(4)\n  new DataView(b.buffer).setUint32(0, v)\n  return b\n}\n\n// \u2500\u2500 Sample flags per ISO 14496-12 \u00A78.8.3.1 \u2500\u2500\nconst KEYFRAME_FLAGS = 0x02000000\nconst DELTA_FLAGS = 0x01010000\n\n// \u2500\u2500 Track geometry field ranges per ISO 14496-12 \u2500\u2500\n// tkhd/trex/tfhd track_ID and the mdhd/mvhd timescales are all unsigned 32-bit\n// fields, written below with DataView.setUint32. That call takes the value\n// modulo 2^32 without complaint, so an out-of-range configuration does not\n// fail \u2014 it silently emits different geometry than the caller asked for\n// (trackId 2^32 becomes track 0, which no fragment can ever reference).\nconst UINT32_MAX = 0xffffffff\n// mvhd next_track_ID is emitted as track_ID + 1 by both buildVideoInitSegment\n// and buildAudioInitSegment (ISO 14496-12 \u00A78.2.2.3, \"a non-zero integer\"). At\n// track_ID = UINT32_MAX that sum wraps to 0, which is both invalid and\n// indistinguishable from an unset field, so the largest usable track_ID is one\n// below the field maximum. (Cited by symbol, not line: this repo's docs gate\n// exists because line anchors rot silently \u2014 see rustfmt.yml's citation check.)\nconst MAX_TRACK_ID = UINT32_MAX - 1\nconst INT32_MIN = -0x80000000\nconst INT32_MAX = 0x7fffffff\n\n/**\n * Fail closed on a track_ID the fMP4 writers below cannot serialize faithfully.\n *\n * Called from both low-level encoders (encodeDataSegment,\n * encodeMultiSampleSegment) so every fragment path is covered by construction\n * rather than by enumerating callers. The class wrappers and init builders call\n * it earlier as well \u2014 partly for a clearer label, partly because the encoders\n * receive an already-incremented sequence number, so their throw would gap the\n * sequence on a call that emitted nothing.\n */\nfunction assertTrackId(trackId: number, label: string): void {\n  if (!Number.isInteger(trackId) || trackId <= 0 || trackId > MAX_TRACK_ID) {\n    throw new RangeError(`${label} must be an integer in 1..${MAX_TRACK_ID}, got ${trackId}`)\n  }\n}\n\n/** Fail closed on a timescale the mdhd/mvhd uint32 fields cannot hold. */\nfunction assertTimescale(timescale: number, label: string): void {\n  if (!Number.isInteger(timescale) || timescale <= 0 || timescale > UINT32_MAX) {\n    throw new RangeError(`${label} must be an integer in 1..${UINT32_MAX}, got ${timescale}`)\n  }\n}\n\n/** Fail closed on a signed trun sample_composition_time_offset. */\nfunction assertCompositionTimeOffsets(\n  samples: Array<{ compositionTimeOffset?: number }>,\n): void {\n  for (let i = 0; i < samples.length; i++) {\n    const offset = samples[i]!.compositionTimeOffset\n    if (offset !== undefined &&\n        (!Number.isInteger(offset) || offset < INT32_MIN || offset > INT32_MAX)) {\n      throw new RangeError(\n        `sample ${i} compositionTimeOffset must be an integer in ${INT32_MIN}..${INT32_MAX}, got ${offset}`,\n      )\n    }\n  }\n}\n\n/**\n * Wrap multiple samples in a single moof+mdat fMP4 segment.\n *\n * Builds a trun with N sample entries (duration + size + flags each).\n * Used by CmafBlockAssembler to emit one segment per FEC source block.\n *\n * @param samples - Array of samples with data, duration (timescale units), keyframe flag,\n *   and an optional signed composition-time offset (same timescale units)\n * @param baseDecodeTime - Decode time of the first sample in timescale units\n * @param sequence - moof sequence number\n * @param trackId - ISO track ID (default 1)\n * @returns moof+mdat bytes ready for SourceBuffer.appendBuffer()\n */\nexport function encodeMultiSampleSegment(\n  samples: Array<{\n    data: Uint8Array\n    duration: number\n    keyframe: boolean\n    compositionTimeOffset?: number\n  }>,\n  baseDecodeTime: number,\n  sequence: number,\n  trackId = 1,\n): Uint8Array {\n  if (samples.length === 0) return new Uint8Array(0)\n  assertTrackId(trackId, 'trackId')\n  assertCompositionTimeOffsets(samples)\n\n  const mfhd = fullBox('mfhd', 0, 0, u32(sequence))\n  const tfhd = fullBox('tfhd', 0, 0x020000, u32(trackId))\n\n  // tfdt version=1 for 64-bit baseMediaDecodeTime\n  const tfdtBody = new Uint8Array(8)\n  const tfdtView = new DataView(tfdtBody.buffer)\n  tfdtView.setUint32(0, Math.floor(baseDecodeTime / 0x100000000))\n  tfdtView.setUint32(4, baseDecodeTime >>> 0)\n  const tfdt = fullBox('tfdt', 1, 0, tfdtBody)\n\n  // A composition-time offset is signed only in trun version 1. When one is\n  // present, every sample gets the field; omitted offsets are encoded as zero.\n  const hasCompositionTimeOffset = samples.some(sample => sample.compositionTimeOffset !== undefined)\n  const trunVersion = hasCompositionTimeOffset ? 1 : 0\n  const trunFlags = 0x000701 | (hasCompositionTimeOffset ? 0x000800 : 0)\n  // 4 bytes sample_count + 4 bytes data_offset + N * (4+4+4 [+4]) per sample\n  const sampleCount = samples.length\n  const sampleEntrySize = hasCompositionTimeOffset ? 16 : 12\n  const trunBody = new Uint8Array(8 + sampleCount * sampleEntrySize)\n  const trunView = new DataView(trunBody.buffer)\n  trunView.setUint32(0, sampleCount)\n  trunView.setUint32(4, 0) // dataOffset placeholder\n  for (let i = 0; i < sampleCount; i++) {\n    const s = samples[i]!\n    const off = 8 + i * sampleEntrySize\n    trunView.setUint32(off, s.duration >>> 0)\n    trunView.setUint32(off + 4, s.data.length)\n    trunView.setUint32(off + 8, s.keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS)\n    if (hasCompositionTimeOffset) {\n      trunView.setInt32(off + 12, s.compositionTimeOffset ?? 0)\n    }\n  }\n  const trun = fullBox('trun', trunVersion, trunFlags, trunBody)\n\n  const traf = box('traf', tfhd, tfdt, trun)\n  const moof = box('moof', mfhd, traf)\n\n  // Concatenate all sample data into mdat\n  let mdatSize = 0\n  for (const s of samples) mdatSize += s.data.length\n  const mdatPayload = new Uint8Array(mdatSize)\n  let pos = 0\n  for (const s of samples) {\n    mdatPayload.set(s.data, pos)\n    pos += s.data.length\n  }\n  const mdat = box('mdat', mdatPayload)\n\n  // Fix trun.dataOffset: moof size + 8 (mdat box header)\n  const dataOffsetPos = 8 + mfhd.length + 8 + tfhd.length + tfdt.length + 12 + 4\n  new DataView(moof.buffer).setUint32(dataOffsetPos, moof.length + 8)\n\n  const result = new Uint8Array(moof.length + mdat.length)\n  result.set(moof, 0)\n  result.set(mdat, moof.length)\n  return result\n}\n\n// \u2500\u2500 Green fill / silence generators \u2500\u2500\n\n/**\n * Generate a minimal H.264 IDR slice NAL for green fill (YUV 0,128,128).\n *\n * Reuses SPS/PPS from the stream's avcC so the fill frame is compatible\n * with the existing decoder configuration. Returns AVCC-framed data\n * (4-byte length prefix per NAL) ready for moof+mdat wrapping.\n *\n * @param avcC - Raw avcC payload from catalog description\n * @param width - Video width in pixels\n * @param height - Video height in pixels\n */\nexport function generateGreenFillNAL(avcC: Uint8Array, width: number, height: number): Uint8Array {\n  // Parse SPS and PPS from avcC box payload\n  // avcC layout: version(1) + profile(1) + compat(1) + level(1) + lengthSizeMinusOne(1)\n  //              + numSPS(1) + [spsLen(2) + spsData]... + numPPS(1) + [ppsLen(2) + ppsData]...\n  if (avcC.length < 8) return new Uint8Array(0)\n\n  const lengthSize = (avcC[4]! & 0x03) + 1 // NAL length field size (usually 4)\n  let offset = 5\n  const numSPS = avcC[offset++]! & 0x1f\n  const nals: Uint8Array[] = []\n\n  // Extract SPS NAL(s)\n  for (let i = 0; i < numSPS; i++) {\n    if (offset + 2 > avcC.length) break\n    const spsLen = (avcC[offset]! << 8) | avcC[offset + 1]!\n    offset += 2\n    if (offset + spsLen > avcC.length) break\n    const sps = avcC.subarray(offset, offset + spsLen)\n    // AVCC frame: 4-byte length + NAL\n    const framed = new Uint8Array(4 + sps.length)\n    new DataView(framed.buffer).setUint32(0, sps.length)\n    framed.set(sps, 4)\n    nals.push(framed)\n    offset += spsLen\n  }\n\n  // Extract PPS NAL(s)\n  if (offset < avcC.length) {\n    const numPPS = avcC[offset++]!\n    for (let i = 0; i < numPPS; i++) {\n      if (offset + 2 > avcC.length) break\n      const ppsLen = (avcC[offset]! << 8) | avcC[offset + 1]!\n      offset += 2\n      if (offset + ppsLen > avcC.length) break\n      const pps = avcC.subarray(offset, offset + ppsLen)\n      const framed = new Uint8Array(4 + pps.length)\n      new DataView(framed.buffer).setUint32(0, pps.length)\n      framed.set(pps, 4)\n      nals.push(framed)\n      offset += ppsLen\n    }\n  }\n\n  // Build minimal IDR slice NAL (NAL type 5)\n  // Slice header: first_mb_in_slice=0, slice_type=7 (I), pic_parameter_set_id=0\n  // Exp-Golomb coded: 0(1 bit) + 0001000(slice_type=7=I-all, ue(v)) + 1(pps_id=0, ue(v))\n  // Then fill with green macroblocks.\n  //\n  // For a minimal valid IDR that decodes to green, we use:\n  //   nal_type=5 (IDR), slice_type=I, then CABAC/CAVLC all-intra-16x16\n  //   with luma DC=0, chroma DC=128. Exact encoding depends on SPS entropy mode.\n  //\n  // Simplified approach: generate a very small IDR slice that MSE will accept.\n  // The slice header + minimal macroblock data. The decoder fills with the\n  // predicted values which default to mid-gray/green.\n  const mbWidth = Math.ceil(width / 16)\n  const mbHeight = Math.ceil(height / 16)\n  const totalMBs = mbWidth * mbHeight\n\n  // Minimal IDR slice: nal_ref_idc=3, nal_type=5\n  // Slice header bits: first_mb=0 (1 bit ue), slice_type=7 (I-all, 0001000 ue),\n  //                    pps_id=0 (1 bit ue), frame_num=0 (depends on SPS log2_max)\n  // We construct a minimal bitstream that encodes an all-skip I-slice.\n  // For simplicity, build a fixed small IDR payload \u2014 the decoder will\n  // pad/error-conceal remaining MBs producing a solid fill frame.\n  const idrSlice = new Uint8Array([\n    0x65, // nal_ref_idc=3, nal_type=5 (IDR)\n    0x88, // slice header: first_mb_in_slice=0, slice_type=7 (I)\n    0x80, // pps_id=0, frame_num=0, idr_pic_id=0\n    0x40, // slice data: mb_skip_run covering remaining MBs\n    // Truncated \u2014 decoder will error-conceal remaining MBs as green/gray\n  ])\n  const idrFramed = new Uint8Array(4 + idrSlice.length)\n  new DataView(idrFramed.buffer).setUint32(0, idrSlice.length)\n  idrFramed.set(idrSlice, 4)\n  nals.push(idrFramed)\n\n  // Concatenate all NALs: SPS + PPS + IDR\n  let totalLen = 0\n  for (const n of nals) totalLen += n.length\n  const result = new Uint8Array(totalLen)\n  let p = 0\n  for (const n of nals) {\n    result.set(n, p)\n    p += n.length\n  }\n  return result\n}\n\n/**\n * Generate a minimal silent audio frame for FEC fill.\n *\n * Supports AAC (mp4a) and Opus codecs. Returns raw frame data (no ADTS/OBU\n * header) suitable for fMP4/CMAF wrapping.\n *\n * @param codec - Audio codec string (e.g. 'mp4a.40.2', 'opus')\n * @param sampleRate - Audio sample rate (e.g. 48000)\n * @param channels - Channel count (e.g. 1 or 2)\n */\nexport function generateSilenceFrame(codec: string, sampleRate: number, channels: number): Uint8Array {\n  if (codec.startsWith('opus') || codec.startsWith('Opus')) {\n    return generateSilenceOpus(channels)\n  }\n  return generateSilenceAAC(sampleRate, channels)\n}\n\n/** Minimal silent AAC-LC access unit (raw, no ADTS). */\nfunction generateSilenceAAC(sampleRate: number, channels: number): Uint8Array {\n  if (channels >= 2) {\n    // CPE (channel pair element) + END\n    return new Uint8Array([\n      0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80,\n    ])\n  }\n  // SCE (single channel element) + END\n  return new Uint8Array([\n    0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,\n  ])\n}\n\n/** Minimal silent Opus frame.\n *  RFC 6716 \u00A73.1: a 1-byte frame with code 0 encodes silence for SILK/CELT. */\nfunction generateSilenceOpus(channels: number): Uint8Array {\n  // Opus TOC byte: config=0 (SILK NB 10ms), s=0 (mono/stereo from channel mapping), c=0 (1 frame)\n  // Frame data: single zero byte \u2192 silence\n  // For stereo, channel mapping in fMP4 init handles routing; the Opus frame itself is the same.\n  return new Uint8Array([0xF8, 0xFF, 0xFE])\n}\n\nexport function normalizeAacSampleForCmaf(data: Uint8Array): Uint8Array {\n  if (data.length < 7 || data[0] !== 0xff || (data[1]! & 0xf6) !== 0xf0) {\n    return data\n  }\n  const headerLength = (data[1]! & 0x01) ? 7 : 9\n  if (data.length <= headerLength) return data\n  const frameLength = ((data[3]! & 0x03) << 11) | (data[4]! << 3) | ((data[5]! & 0xe0) >>> 5)\n  if (frameLength !== data.length || frameLength <= headerLength) return data\n  return data.subarray(headerLength)\n}\n\n/**\n * Wrap a single raw codec sample in a moof+mdat fMP4 segment.\n *\n * @param data - Raw sample bytes (AVCC H.264 or raw AAC)\n * @param timestamp - Decode time in timescale units\n * @param duration - Sample duration in timescale units\n * @param keyframe - true for IDR/sync sample\n * @param sequence - moof sequence number (monotonically incrementing)\n * @param trackId - ISO track ID (default 1)\n * @returns moof+mdat bytes ready for SourceBuffer.appendBuffer()\n */\nexport function encodeDataSegment(\n  data: Uint8Array,\n  timestamp: number,\n  duration: number,\n  keyframe: boolean,\n  sequence: number,\n  trackId = 1,\n  compositionTimeOffset?: number,\n): Uint8Array {\n  assertTrackId(trackId, 'trackId')\n  assertCompositionTimeOffsets([{ compositionTimeOffset }])\n  if (compositionTimeOffset !== undefined) {\n    return encodeMultiSampleSegment(\n      [{ data, duration, keyframe, compositionTimeOffset }],\n      timestamp,\n      sequence,\n      trackId,\n    )\n  }\n  const sampleFlags = keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS\n\n  const mfhd = fullBox('mfhd', 0, 0, u32(sequence))\n  const tfhd = fullBox('tfhd', 0, 0x020000, u32(trackId))\n\n  // tfdt version=1 for 64-bit baseMediaDecodeTime\n  const tfdtBody = new Uint8Array(8)\n  const tfdtView = new DataView(tfdtBody.buffer)\n  tfdtView.setUint32(0, Math.floor(timestamp / 0x100000000))\n  tfdtView.setUint32(4, timestamp >>> 0)\n  const tfdt = fullBox('tfdt', 1, 0, tfdtBody)\n\n  // trun: flags=0x000701 (data-offset + duration + size + flags)\n  const trunBody = new Uint8Array(20)\n  const trunView = new DataView(trunBody.buffer)\n  trunView.setUint32(0, 1) // sample_count\n  trunView.setUint32(4, 0) // dataOffset placeholder\n  trunView.setUint32(8, duration >>> 0)\n  trunView.setUint32(12, data.length)\n  trunView.setUint32(16, sampleFlags)\n  const trun = fullBox('trun', 0, 0x000701, trunBody)\n\n  const traf = box('traf', tfhd, tfdt, trun)\n  const moof = box('moof', mfhd, traf)\n  const mdat = box('mdat', data)\n\n  // Fix trun.dataOffset: moof size + 8 (mdat box header)\n  const dataOffsetPos = 8 + mfhd.length + 8 + tfhd.length + tfdt.length + 12 + 4\n  new DataView(moof.buffer).setUint32(dataOffsetPos, moof.length + 8)\n\n  const result = new Uint8Array(moof.length + mdat.length)\n  result.set(moof, 0)\n  result.set(mdat, moof.length)\n  return result\n}\n\n/**\n * Build an ftyp+moov init segment for H.264 video MSE from an avcC box.\n *\n * @param avcC - Raw avcC box payload (SPS/PPS configuration)\n * @param width - Video width in pixels\n * @param height - Video height in pixels\n * @param timescale - Timescale (default 1_000_000 = microseconds)\n * @param trackId - Track ID (default 1)\n */\nexport function buildVideoInitSegment(\n  avcC: Uint8Array,\n  width: number,\n  height: number,\n  timescale = 1_000_000,\n  trackId = 1,\n): Uint8Array {\n  // Validated here as well as in setVideoTrackParams: this builder is exported\n  // from the package index, so a direct caller reaches the same uint32 tkhd /\n  // trex / mdhd / mvhd fields without passing through the class.\n  assertTrackId(trackId, 'video trackId')\n  assertTimescale(timescale, 'video timescale')\n  const ftyp = box('ftyp', new Uint8Array([\n    0x69, 0x73, 0x6f, 0x6d, 0, 0, 2, 0,\n    0x69, 0x73, 0x6f, 0x6d,\n    0x69, 0x73, 0x6f, 0x36,\n    0x6d, 0x70, 0x34, 0x31,\n  ]))\n\n  const avcCBox = box('avcC', avcC)\n  const avc1Body = new Uint8Array(78 + avcCBox.length)\n  const avc1View = new DataView(avc1Body.buffer)\n  avc1View.setUint16(6, 1)\n  avc1View.setUint16(24, width)\n  avc1View.setUint16(26, height)\n  avc1View.setUint32(28, 0x00480000)\n  avc1View.setUint32(32, 0x00480000)\n  avc1View.setUint16(40, 1)\n  avc1View.setUint16(74, 0x0018)\n  avc1View.setInt16(76, -1)\n  avc1Body.set(avcCBox, 78)\n  const avc1 = box('avc1', avc1Body)\n\n  const stsd = fullBox('stsd', 0, 0, u32(1), avc1)\n  const stbl = box('stbl', stsd,\n    fullBox('stts', 0, 0, u32(0)),\n    fullBox('stsc', 0, 0, u32(0)),\n    fullBox('stsz', 0, 0, u32(0), u32(0)),\n    fullBox('stco', 0, 0, u32(0)),\n  )\n  const dinf = box('dinf', fullBox('dref', 0, 0, u32(1), fullBox('url ', 0, 1)))\n  const minf = box('minf', fullBox('vmhd', 0, 1), dinf, stbl)\n  const hdlr = fullBox('hdlr', 0, 0, new Uint8Array([\n    0, 0, 0, 0, 0x76, 0x69, 0x64, 0x65,\n    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n    0x56, 0x69, 0x64, 0x65, 0x6f, 0,\n  ]))\n  const mdhdBody = new Uint8Array(20)\n  new DataView(mdhdBody.buffer).setUint32(8, timescale)\n  const mdhd = fullBox('mdhd', 0, 0, mdhdBody)\n  const mdia = box('mdia', mdhd, hdlr, minf)\n\n  const tkhdBody = new Uint8Array(80)\n  const tkhdView = new DataView(tkhdBody.buffer)\n  tkhdView.setUint32(8, trackId)\n  tkhdView.setUint32(36, 0x00010000)\n  tkhdView.setUint32(52, 0x00010000)\n  tkhdView.setUint32(64, 0x40000000)\n  tkhdView.setUint32(72, width << 16)\n  tkhdView.setUint32(76, height << 16)\n  const tkhd = fullBox('tkhd', 0, 3, tkhdBody)\n  const trak = box('trak', tkhd, mdia)\n\n  const mvhdBody = new Uint8Array(96)\n  const mvhdView = new DataView(mvhdBody.buffer)\n  mvhdView.setUint32(8, timescale)\n  mvhdView.setUint32(16, 0x00010000)\n  mvhdView.setUint16(20, 0x0100)\n  mvhdView.setUint32(32, 0x00010000)\n  mvhdView.setUint32(48, 0x00010000)\n  mvhdView.setUint32(60, 0x40000000)\n  mvhdView.setUint32(92, trackId + 1)\n  const mvhd = fullBox('mvhd', 0, 0, mvhdBody)\n\n  const trexBody = new Uint8Array(20)\n  new DataView(trexBody.buffer).setUint32(0, trackId)\n  new DataView(trexBody.buffer).setUint32(4, 1)\n  const mvex = box('mvex', fullBox('trex', 0, 0, trexBody))\n\n  const moov = box('moov', mvhd, trak, mvex)\n  const result = new Uint8Array(ftyp.length + moov.length)\n  result.set(ftyp, 0)\n  result.set(moov, ftyp.length)\n  return result\n}\n\n/**\n * Build ftyp+moov init segment for AAC audio MSE.\n */\nexport function buildAudioInitSegment(\n  sampleRate: number,\n  channels: number,\n  asc?: Uint8Array,\n  timescale?: number,\n  trackId = 1,\n): Uint8Array {\n  // trackId only: this reaches the same uint32 tkhd/trex/mvhd fields as the\n  // video builder. The audio *timescale* is deliberately left unchecked here \u2014\n  // wrapAudioSample branches on its exact value, so constraining it belongs\n  // with that path rather than in this range fix.\n  assertTrackId(trackId, 'audio trackId')\n  const ts = timescale ?? sampleRate\n\n  if (!asc) {\n    const freqTable = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350]\n    const fi = freqTable.indexOf(sampleRate)\n    const freqIdx = fi >= 0 ? fi : 0x0f\n    if (freqIdx <= 0x0e) {\n      const v = (2 << 11) | (freqIdx << 7) | (channels << 3)\n      asc = new Uint8Array([(v >> 8) & 0xff, v & 0xff])\n    } else {\n      asc = new Uint8Array([\n        (2 << 3) | 0x07,\n        (0x08 | ((sampleRate >> 20) & 0x07)) & 0xff,\n        (sampleRate >> 12) & 0xff,\n        (sampleRate >> 4) & 0xff,\n        (((sampleRate & 0x0f) << 4) | (channels << 0)) & 0xff,\n      ])\n    }\n  }\n\n  // esds: ES_Descriptor \u2192 DecoderConfigDescriptor \u2192 AudioSpecificConfig\n  const dsi = new Uint8Array(2 + asc.length)\n  dsi[0] = 0x05; dsi[1] = asc.length; dsi.set(asc, 2)\n  const dcdBody = new Uint8Array(13 + dsi.length)\n  dcdBody[0] = 0x40; dcdBody[1] = 0x15; dcdBody.set(dsi, 13)\n  const dcd = new Uint8Array(2 + dcdBody.length)\n  dcd[0] = 0x04; dcd[1] = dcdBody.length; dcd.set(dcdBody, 2)\n  const esBody = new Uint8Array(3 + dcd.length)\n  esBody[0] = 0; esBody[1] = 0x01; esBody[2] = 0; esBody.set(dcd, 3)\n  const es = new Uint8Array(2 + esBody.length)\n  es[0] = 0x03; es[1] = esBody.length; es.set(esBody, 2)\n  const esdsBox = fullBox('esds', 0, 0, es)\n\n  const mp4aBody = new Uint8Array(28 + esdsBox.length)\n  const mp4aView = new DataView(mp4aBody.buffer)\n  mp4aView.setUint16(6, 1)\n  mp4aView.setUint16(16, channels)\n  mp4aView.setUint16(18, 16)\n  mp4aView.setUint32(24, sampleRate << 16)\n  mp4aBody.set(esdsBox, 28)\n  const mp4a = box('mp4a', mp4aBody)\n\n  const stsd = fullBox('stsd', 0, 0, u32(1), mp4a)\n  const stbl = box('stbl', stsd,\n    fullBox('stts', 0, 0, u32(0)),\n    fullBox('stsc', 0, 0, u32(0)),\n    fullBox('stsz', 0, 0, u32(0), u32(0)),\n    fullBox('stco', 0, 0, u32(0)),\n  )\n  const dinf = box('dinf', fullBox('dref', 0, 0, u32(1), fullBox('url ', 0, 1)))\n  const minf = box('minf', fullBox('smhd', 0, 0, new Uint8Array(4)), dinf, stbl)\n  const hdlr = fullBox('hdlr', 0, 0, new Uint8Array([\n    0, 0, 0, 0, 0x73, 0x6f, 0x75, 0x6e,\n    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n    0x53, 0x6f, 0x75, 0x6e, 0x64, 0,\n  ]))\n  const mdhdBody = new Uint8Array(20)\n  new DataView(mdhdBody.buffer).setUint32(8, ts)\n  const mdhd = fullBox('mdhd', 0, 0, mdhdBody)\n  const mdia = box('mdia', mdhd, hdlr, minf)\n\n  const tkhdBody = new Uint8Array(80)\n  const tkhdView = new DataView(tkhdBody.buffer)\n  tkhdView.setUint32(8, trackId)\n  tkhdView.setUint32(36, 0x00010000)\n  tkhdView.setUint32(52, 0x00010000)\n  tkhdView.setUint32(64, 0x40000000)\n  const tkhd = fullBox('tkhd', 0, 3, tkhdBody)\n  const trak = box('trak', tkhd, mdia)\n\n  const mvhdBody = new Uint8Array(96)\n  const mvhdView = new DataView(mvhdBody.buffer)\n  mvhdView.setUint32(8, ts)\n  mvhdView.setUint32(16, 0x00010000)\n  mvhdView.setUint16(20, 0x0100)\n  mvhdView.setUint32(32, 0x00010000)\n  mvhdView.setUint32(48, 0x00010000)\n  mvhdView.setUint32(60, 0x40000000)\n  mvhdView.setUint32(92, trackId + 1)\n  const mvhd = fullBox('mvhd', 0, 0, mvhdBody)\n\n  const trexBody = new Uint8Array(20)\n  new DataView(trexBody.buffer).setUint32(0, trackId)\n  new DataView(trexBody.buffer).setUint32(4, 1)\n  const mvex = box('mvex', fullBox('trex', 0, 0, trexBody))\n\n  const moov = box('moov', mvhd, trak, mvex)\n  const ftyp = box('ftyp', new Uint8Array([\n    0x69, 0x73, 0x6f, 0x6d, 0, 0, 2, 0,\n    0x69, 0x73, 0x6f, 0x6d,\n    0x69, 0x73, 0x6f, 0x36,\n    0x6d, 0x70, 0x34, 0x31,\n  ]))\n  const result = new Uint8Array(ftyp.length + moov.length)\n  result.set(ftyp, 0)\n  result.set(moov, ftyp.length)\n  return result\n}\n\n/**\n * MMTP \u2192 CMAF converter.\n *\n * Accepts reassembled MFU frames (raw codec samples) from MmtpDecoder\n * and produces fMP4 segments for MSE SourceBuffer.\n *\n * Per draft-ramadan-moq-mmt \u00A75.3:\n *   MPU metadata (ftyp+moov) \u2192 init segment\n *   MFU sample bytes \u2192 moof+mdat data segment\n *\n * Timescale is microseconds (1_000_000) matching MMTP NTP short timestamps\n * converted via mmtpTimestampToMicros().\n */\nexport class MmtpToCmaf {\n  #videoSeq = 1\n  #audioSeq = 1\n  #videoInitSegment: Uint8Array | null = null\n  // Known only for locally-built init segments. Wire-supplied MPU metadata is\n  // intentionally opaque here, so setVideoTrackParams remains the API that\n  // lets a caller declare its track geometry before wrapping samples.\n  #videoInitTrackId: number | null = null\n  #audioInitSegment: Uint8Array | null = null\n  #lastVideoTimestamp = 0\n  // Sticky sample duration in video timescale units, updated from caller-\n  // supplied durations or adjacent-timestamp deltas. null means \"nothing\n  // observed yet\", in which case #videoFrameDuration derives ~30fps from the\n  // configured timescale (33333 at the 1_000_000 default, i.e. unchanged).\n  #frameDuration: number | null = null\n  // Per-track rebase: each track anchors on its OWN first sample so\n  // baseMediaDecodeTime is never negative. A shared base was wrong \u2014 if the\n  // first sample of one track arrives later than the other's first sample,\n  // the earlier track computes `timestamp - sharedBase` as a negative number,\n  // which serializes into tfdt as a huge unsigned uint64 (~2^64 - 46) and\n  // Chromium rejects the segment with CHUNK_DEMUXER_ERROR_APPEND_FAILED,\n  // closing the MediaSource and detaching all SourceBuffers.\n  // For A/V alignment, choose a COMMON anchor: set when the first sample of\n  // EITHER track arrives, but only if that sample's timestamp is <= any\n  // subsequent track's first sample. Implementation: each track rebases to\n  // the minimum timestamp seen across tracks on their respective first sample.\n  #videoBaseTs = -1\n  #audioBaseTs = -1\n\n  // Video track geometry. These pair with the video init segment's tkhd\n  // track_ID and mdhd/mvhd timescale: every moof this converter emits must\n  // reference the same track at the same rate or the browser either drops the\n  // fragment (unknown track) or plays it at the wrong rate. They are\n  // configuration rather than stream state, so \u2014 unlike the sequence numbers\n  // and time bases above \u2014 reset() deliberately preserves them, matching the\n  // fact that reset() also preserves #videoInitSegment.\n  #videoTrackId = 1\n  #videoTimescale = 1_000_000\n\n  /**\n   * Point the single-sample video wrappers at a specific track and rate.\n   *\n   * Call this when the init segment came off the wire (setInitSegmentFromMpu)\n   * rather than from buildVideoInit, so the wrappers match the publisher's\n   * tkhd/mdhd instead of assuming trackId=1 at microsecond rate. Consumers\n   * that build their init through buildVideoInit can pass the same values\n   * there instead and skip this call.\n   *\n   * The rate is settable only until the first single-sample wrap \u2014 see the\n   * throw below for why.\n   */\n  setVideoTrackParams(trackId: number, timescale: number) {\n    assertTrackId(trackId, 'video trackId')\n    assertTimescale(timescale, 'video timescale')\n    // #frameDuration, #lastVideoTimestamp and #videoBaseTs are all denominated\n    // in #videoTimescale, so moving the rate out from under them reinterprets\n    // every one at the new rate. Both consequences are silent:\n    //   - a duration latched as 33333 (1 MHz ~30fps) re-emits as 33333 ticks of\n    //     90 kHz, a 370 ms frame;\n    //   - a base captured on the old scale rebases new-scale timestamps to a\n    //     negative relTs, which tfdt serializes as a ~2^64 uint64 and Chromium\n    //     rejects with CHUNK_DEMUXER_ERROR_APPEND_FAILED, closing the\n    //     MediaSource (same failure the #videoBaseTs comment above describes).\n    // Rescaling instead of refusing would be a guess: the class cannot tell\n    // whether the caller's next timestamps continue this timeline in new units\n    // or open a fresh epoch. reset() is the exact mechanism for that\n    // discontinuity \u2014 it clears all three fields while preserving geometry \u2014\n    // so require it rather than infer. Re-asserting the same rate is a no-op.\n    // A cached init also fixes the track ID in tkhd/trex; changing only the\n    // wrapper setting would make later tfhd IDs disagree with that init.\n    if (trackId !== this.#videoTrackId && this.#videoInitTrackId !== null) {\n      throw new Error(\n        `video track ID cannot change from ${this.#videoTrackId} to ${trackId} ` +\n          'after a video init has been cached; replace the init atomically',\n      )\n    }\n    if (timescale !== this.#videoTimescale && this.#videoBaseTs >= 0) {\n      throw new Error(\n        `video timescale cannot change from ${this.#videoTimescale} to ${timescale} ` +\n          `after video samples have been wrapped; call reset() first`,\n      )\n    }\n    this.#videoTrackId = trackId\n    this.#videoTimescale = timescale\n  }\n\n  /** Set init segment from MPU metadata packet (fragment_type=0).\n   *  These are complete ftyp+moov bytes from FFmpeg \u2014 use directly. */\n  setInitSegmentFromMpu(data: Uint8Array, isAudio: boolean) {\n    if (isAudio) {\n      this.#audioInitSegment = data\n    } else {\n      this.#videoInitSegment = data\n      this.#videoInitTrackId = null\n    }\n  }\n\n  /** Build init segment from codec config (catalog path \u2014 no MPU metadata available).\n   *  Passing timescale/trackId also configures the wrappers via\n   *  setVideoTrackParams, so init and media segments cannot disagree. */\n  buildVideoInit(avcC: Uint8Array, width: number, height: number, timescale?: number, trackId?: number) {\n    const nextTimescale = timescale ?? this.#videoTimescale\n    const nextTrackId = trackId ?? this.#videoTrackId\n    assertTrackId(nextTrackId, 'video trackId')\n    assertTimescale(nextTimescale, 'video timescale')\n    if (nextTimescale !== this.#videoTimescale && this.#videoBaseTs >= 0) {\n      throw new Error(\n        `video timescale cannot change from ${this.#videoTimescale} to ${nextTimescale} ` +\n          'after video samples have been wrapped; call reset() first',\n      )\n    }\n    // Build first, then publish both geometry and init together. This is the\n    // sanctioned path for replacing a cached init with a new track ID.\n    const init = buildVideoInitSegment(\n      avcC,\n      width,\n      height,\n      nextTimescale,\n      nextTrackId,\n    )\n    this.#videoTimescale = nextTimescale\n    this.#videoTrackId = nextTrackId\n    this.#videoInitSegment = init\n    this.#videoInitTrackId = nextTrackId\n  }\n\n  buildAudioInit(sampleRate: number, channels: number, asc?: Uint8Array, timescale?: number) {\n    const ts = timescale ?? sampleRate\n    this.#audioTimescale = ts\n    this.#audioInitSegment = buildAudioInitSegment(sampleRate, channels, asc, ts)\n  }\n\n  get videoInitSegment(): Uint8Array | null { return this.#videoInitSegment }\n  get audioInitSegment(): Uint8Array | null { return this.#audioInitSegment }\n\n  /** Convert a raw video sample to an fMP4 moof+mdat segment. */\n  wrapVideoSample(data: Uint8Array, timestamp: number, keyframe: boolean, duration?: number): Uint8Array {\n    return this.wrapVideoSampleWithTiming(data, timestamp, keyframe, duration).segment\n  }\n\n  /**\n   * Convert a raw video sample and return the exact browser media interval\n   * encoded into tfdt/trun. Consumers that correlate SourceBuffer appends with\n   * requestVideoFrameCallback must use this rebased timestamp, not the wire or\n   * caller-owned timestamp passed above.\n   */\n  wrapVideoSampleWithTiming(\n    data: Uint8Array,\n    timestamp: number,\n    keyframe: boolean,\n    duration?: number,\n  ): Readonly<{ segment: Uint8Array; mediaTimestamp: number; duration: number }> {\n    // Prefer a caller-provided media duration when the browser append timeline\n    // is intentionally decoupled from sparse MMTP wire timestamps. Fall back to\n    // estimating from adjacent timestamps for legacy/direct callers. A delta of\n    // a full second or more is not a frame interval, so it is rejected as a\n    // discontinuity rather than latched.\n    if (duration !== undefined && Number.isFinite(duration) && duration > 0) {\n      this.#frameDuration = Math.round(duration)\n    } else if (this.#lastVideoTimestamp > 0 && timestamp > this.#lastVideoTimestamp) {\n      const delta = timestamp - this.#lastVideoTimestamp\n      if (delta > 0 && delta < this.#videoTimescale) this.#frameDuration = delta\n    }\n    this.#lastVideoTimestamp = timestamp\n    if (this.#videoBaseTs < 0) this.#videoBaseTs = timestamp\n    const relTs = timestamp - this.#videoBaseTs\n    const frameDuration = this.#videoFrameDuration\n    return Object.freeze({\n      segment: encodeDataSegment(\n        data,\n        relTs,\n        frameDuration,\n        keyframe,\n        this.#videoSeq++,\n        this.#videoTrackId,\n      ),\n      mediaTimestamp: relTs,\n      duration: frameDuration,\n    })\n  }\n\n  /** Sticky duration if one has been observed, else ~30fps at the current rate. */\n  get #videoFrameDuration(): number {\n    return this.#frameDuration ?? Math.max(1, Math.round(this.#videoTimescale / 30))\n  }\n\n  /** Convert an append-safe video batch using the caller-owned timeline.\n   *  Durations, baseDecodeTime, and compositionTimeOffset are in the\n   *  configured video timescale. compositionTimeOffset is the signed PTS-DTS\n   *  delta; its presence selects a version-1 trun for the whole batch.\n   *  An explicit trackId is range-checked before #videoSeq++ for the same\n   *  reason as wrapAudioSamples: the encoder's own check fires too late to\n   *  keep the sequence ungapped. */\n  wrapVideoSamples(\n    samples: Array<{\n      data: Uint8Array\n      duration: number\n      keyframe: boolean\n      compositionTimeOffset?: number\n    }>,\n    baseDecodeTime: number,\n    trackId = this.#videoTrackId,\n  ): Uint8Array {\n    assertTrackId(trackId, 'video trackId')\n    assertCompositionTimeOffsets(samples)\n    return encodeMultiSampleSegment(samples, baseDecodeTime, this.#videoSeq++, trackId)\n  }\n\n  // Audio timescale from init segment (default 1M \u00B5s; real FFmpeg init uses sampleRate).\n  // Set by buildAudioInit or setAudioTimescale.\n  #audioTimescale = 1_000_000\n\n  /** Set audio timescale to match the init segment's mdhd timescale.\n   *  Call after appending the real encoder init (FT=0 ftyp+moov). */\n  setAudioTimescale(timescale: number) { this.#audioTimescale = timescale }\n\n  // Audio sample counter for drift-free baseMediaDecodeTime.\n  // AAC frames are exactly 1024 samples at sampleRate. Using sequential\n  // counter \u00D7 1024 avoids floating-point rounding drift from timestamp conversion.\n  #audioSampleCount = 0\n\n  /** AAC access-unit length in samples. ISO/IEC 14496-3: an AAC-LC frame is\n   *  exactly 1024 samples at every sample rate \u2014 it is not rate-dependent. */\n  readonly #aacFrameSamples = 1024\n\n  /** Convert a raw audio sample to an fMP4 moof+mdat segment. */\n  wrapAudioSample(\n    data: Uint8Array,\n    timestamp: number,\n    sampleDuration = 21333,\n    compositionTimeOffset?: number,\n  ): Uint8Array {\n    assertCompositionTimeOffsets([{ compositionTimeOffset }])\n    const sampleData = normalizeAacSampleForCmaf(data)\n    if (this.#audioBaseTs < 0) this.#audioBaseTs = timestamp\n\n    // When timescale matches sampleRate (e.g. 48000), use integer sample counting\n    // for exact baseMediaDecodeTime alignment. This eliminates cumulative rounding\n    // drift from Math.round(\u00B5s * sampleRate / 1_000_000) that causes frequency\n    // wandering in FFT analysis (42% consistency \u2192 99%+ with exact counting).\n    //\n    // samplesPerFrame is the AAC access-unit length, NOT a rescaled duration.\n    // Deriving it as Math.round(sampleDuration * timescale / 1e6) only lands on\n    // 1024 when the rate happens to be 48 kHz (21333 * 48000 / 1e6 = 1023.98),\n    // which made the default silently correct at 48 kHz and wrong everywhere\n    // else: at 44.1 kHz it yields 941, so every moof declared ~8% short frames\n    // and Chrome rejected the first packet with PIPELINE_ERROR_DECODE\n    // (\"Failed to send audio packet for decoding\", duration=21337\u00B5s = 941/44100).\n    const samplesPerFrame = this.#audioTimescale !== 1_000_000\n      ? this.#aacFrameSamples\n      : sampleDuration\n    const scaledTs = this.#audioTimescale !== 1_000_000\n      ? this.#audioSampleCount * samplesPerFrame\n      : (timestamp - this.#audioBaseTs)\n    this.#audioSampleCount++\n\n    return encodeDataSegment(\n      sampleData,\n      scaledTs,\n      samplesPerFrame,\n      true,\n      this.#audioSeq++,\n      1,\n      compositionTimeOffset,\n    )\n  }\n\n  /** Convert an ordered audio batch using the caller-owned timeline. */\n  wrapAudioSamples(\n    samples: Array<{\n      data: Uint8Array\n      duration: number\n      compositionTimeOffset?: number\n    }>,\n    baseDecodeTime: number,\n    trackId = 1,\n  ): Uint8Array {\n    // Checked before #audioSeq++ below: the encoder validates too, but its\n    // throw would land after the counter had already advanced, leaving the\n    // sequence gapped by a call that produced no segment.\n    assertTrackId(trackId, 'audio trackId')\n    assertCompositionTimeOffsets(samples)\n    return encodeMultiSampleSegment(\n      samples.map(sample => ({\n        data: normalizeAacSampleForCmaf(sample.data),\n        duration: sample.duration,\n        keyframe: true,\n        compositionTimeOffset: sample.compositionTimeOffset,\n      })),\n      baseDecodeTime,\n      this.#audioSeq++,\n      trackId,\n    )\n  }\n\n  /** Clear per-stream sequencing and time bases.\n   *  Cached init segments and the video track geometry survive, so a converter\n   *  reset mid-subscription keeps emitting moofs the existing init can resolve.\n   *  Clearing the timescale-denominated timing state also re-opens the video\n   *  rate for change \u2014 this is the sanctioned way to retarget mid-subscription. */\n  reset() {\n    this.#videoSeq = 1\n    this.#audioSeq = 1\n    this.#audioSampleCount = 0\n    this.#lastVideoTimestamp = 0\n    this.#frameDuration = null\n    this.#videoBaseTs = -1\n    this.#audioBaseTs = -1\n    this.#audioTimescale = 1_000_000\n  }\n}\n", "/**\n * CMAF batcher for MoQ group boundaries.\n *\n * Collects frames via addFrame() and emits a single multi-sample moof+mdat\n * segment on flush(). Designed to be called once per MoQ group so one\n * appendBuffer() call per group lands in MSE.\n *\n * Unlike CmafBlockAssembler (FEC-SBN keyed, for multicast), this class is\n * caller-driven \u2014 no SBN/ESI, no block timeouts. Call flush() when the\n * group's readFrame() loop returns done.\n *\n * Timestamps passed to addFrame() MUST be in the same timescale the caller\n * used to build the init segment (typically microseconds). The batcher does\n * not scale \u2014 it rebases per-instance (first sample \u2192 0) and passes\n * inter-frame deltas as sample durations.\n */\n\nimport { encodeMultiSampleSegment } from './mmtp-to-cmaf.js'\n\nexport interface CmafGroupBatcherConfig {\n  trackType: 'video' | 'audio'\n  /** ISO track ID. Must match the trackId used when building the init segment. */\n  trackId: number\n  /**\n   * Duration (in the same units as timestamp) for the last sample of a group\n   * with exactly one frame (no inter-frame delta to measure). Derive from\n   * catalog: video = 1_000_000 / fps; audio = 1_000_000 * 1024 / sampleRate.\n   */\n  fallbackFrameDuration: number\n}\n\ninterface BufferedFrame {\n  data: Uint8Array\n  timestamp: number\n  keyframe: boolean\n}\n\nexport class CmafGroupBatcher {\n  readonly trackType: 'video' | 'audio'\n  readonly #trackId: number\n  readonly #fallbackFrameDuration: number\n\n  #buffer: BufferedFrame[] = []\n  #sequence = 1\n  #baseTs = -1\n  #disposed = false\n\n  onSegment: ((segment: Uint8Array) => void) | null = null\n\n  constructor(config: CmafGroupBatcherConfig) {\n    if (!Number.isFinite(config.trackId) || config.trackId <= 0) {\n      throw new Error(`CmafGroupBatcher: trackId must be a positive finite number (got ${config.trackId})`)\n    }\n    if (!Number.isFinite(config.fallbackFrameDuration) || config.fallbackFrameDuration <= 0) {\n      throw new Error(\n        `CmafGroupBatcher: fallbackFrameDuration must be positive and finite \u2014 derive from catalog (video=1e6/fps, audio=1e6*1024/sampleRate). Got ${config.fallbackFrameDuration}`,\n      )\n    }\n    this.trackType = config.trackType\n    this.#trackId = config.trackId\n    this.#fallbackFrameDuration = config.fallbackFrameDuration\n  }\n\n  addFrame(data: Uint8Array, timestamp: number, keyframe: boolean): void {\n    if (this.#disposed) return\n    this.#buffer.push({ data, timestamp, keyframe })\n  }\n\n  flush(): void {\n    if (this.#disposed) return\n    const frames = this.#buffer\n    if (frames.length === 0) return\n    this.#buffer = []\n\n    if (this.#baseTs < 0) this.#baseTs = frames[0].timestamp\n    const relTs = frames[0].timestamp - this.#baseTs\n\n    const samples = frames.map((f, i) => {\n      let duration: number\n      if (i < frames.length - 1) {\n        duration = frames[i + 1].timestamp - f.timestamp\n      } else {\n        duration = i > 0 ? (f.timestamp - frames[i - 1].timestamp) : this.#fallbackFrameDuration\n      }\n      if (duration <= 0) duration = this.#fallbackFrameDuration\n      return { data: f.data, duration, keyframe: f.keyframe }\n    })\n\n    const segment = encodeMultiSampleSegment(samples, relTs, this.#sequence++, this.#trackId)\n    this.onSegment?.(segment)\n  }\n\n  reset(): void {\n    this.#buffer = []\n    this.#sequence = 1\n    this.#baseTs = -1\n  }\n\n  dispose(): void {\n    this.#disposed = true\n    this.#buffer = []\n    this.onSegment = null\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cmcd-producer.d.ts

@@ -0,0 +1,104 @@
+/**
+ * CmcdProducer — transport-agnostic CMCD telemetry producer.
+ *
+ * Maps FecTrackStats snapshots and TransportSnapshot state to x-bc-*
+ * CMCD vendor keys (proto tags 70-99). Fires callbacks for two delivery
+ * channels: MoQ SUBSCRIBE params and multicast HTTP POST.
+ *
+ * Does NOT call fetch() or write to QUIC directly — the player wiring
+ * layer is responsible for attaching params to SUBSCRIBE or POSTing
+ * the payload to the CDN CMCD endpoint.
+ *
+ * @see docs/superpowers/specs/2026-04-15-iwa-multicast-stack-design.md §3.3
+ * @see CDN+ Track D BLO-1044
+ */
+import type { FecTrackStats } from '@blockcast/fec-worker';
+import type { ManifestVerificationStats } from '@blockcast/mmt-manifest-verify';
+/** Transport state snapshot, built by the player wiring layer from SocketPool. */
+export interface TransportSnapshot {
+    transport: 'native' | 'amt' | 'moq';
+    /** IPv4/IPv6 multicast group address */
+    multicastGroup?: string;
+    /** SSM source address */
+    multicastSource?: string;
+    /** AMT relay address (omit when undefined) */
+    amtRelay?: string;
+}
+/** Transport transition event identifiers for x-bc-ct. */
+export type TransportTransitionEvent = 'mc-start' | 'mc-to-uc' | 'amt-start';
+/**
+ * Phase 14 play-mode state (D-12, x-bc-play-mode):
+ * - `full`         — base + delta both active
+ * - `base-only`    — delta fell back; base carries playback
+ * - `single-track` — stream is not a multi-track switching set (legacy)
+ */
+export type PlayMode = 'full' | 'base-only' | 'single-track';
+/** CMCD vendor key map. Values are string, number, or boolean. */
+export type CmcdParams = Record<string, string | number | boolean>;
+/** Options for CmcdProducer construction. */
+export interface CmcdProducerOptions {
+    /** Fired on each snapshot and on transport transitions. Params for MoQ SUBSCRIBE. */
+    onCmcdParams?: (params: CmcdParams) => void;
+    /** Fired on each snapshot and on transport transitions. RFC 9559 query-string for HTTP POST body. */
+    onCmcdPost?: (payload: string) => void;
+}
+/** Snapshot data passed to onSnapshot(). */
+export interface SnapshotData {
+    tracks: FecTrackStats[];
+    timestampMs: number;
+}
+/** Transport-only telemetry for receivers that do not own FEC track stats. */
+export interface TransportOnlySnapshotData {
+    transport: TransportSnapshot;
+    timestampMs: number;
+    playMode?: PlayMode;
+    switchMiscount?: number;
+}
+export declare class CmcdProducer {
+    #private;
+    constructor(options: CmcdProducerOptions);
+    /** Update the stored transport state. Called by player wiring layer. */
+    updateTransport(snapshot: TransportSnapshot): void;
+    /**
+     * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
+     * snapshots. Throws on any value outside {'full','base-only','single-track'}
+     * (CLAUDE.md: error on bad init).
+     */
+    updatePlayMode(mode: PlayMode): void;
+    /**
+     * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
+     * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
+     * Omitted on single-track streams.
+     */
+    updateDeltaFailRate(rate: number): void;
+    /**
+     * Bump the cumulative switching-set misalignment counter. Emitted as
+     * `x-bc-switch-miscount` on snapshots when the counter is > 0.
+     */
+    incrementSwitchMiscount(): void;
+    updateManifestVerification(stats: ManifestVerificationStats): void;
+    /**
+     * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
+     * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
+     * include the drift key until the next emitSwitchDrift(). Mirrors the
+     * existing onTransition() pattern.
+     */
+    emitSwitchDrift(driftUs: number): void;
+    /**
+     * Process a FecTrackStats snapshot. Finds the video track, builds
+     * x-bc-* vendor keys, and fires both delivery callbacks.
+     */
+    onSnapshot(data: SnapshotData): void;
+    /**
+     * Emit transport state without inventing FEC metrics. Cadence is owned by
+     * the caller because only the transport integration knows when state changed.
+     */
+    onTransportSnapshot(data: TransportOnlySnapshotData): void;
+    /**
+     * Signal a transport transition event. Fires an immediate out-of-band
+     * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
+     * x-bc-ct (one-shot).
+     */
+    onTransition(event: TransportTransitionEvent): void;
+}
+//# sourceMappingURL=cmcd-producer.d.ts.map

package/dist/cmcd-producer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmcd-producer.d.ts","sourceRoot":"","sources":["../src/cmcd-producer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAM/E,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAA;IACnC,wCAAwC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,yBAAyB;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,0DAA0D;AAC1D,MAAM,MAAM,wBAAwB,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAA;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,cAAc,CAAA;AAI5D,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;AAElE,6CAA6C;AAC7C,MAAM,WAAW,mBAAmB;IAClC,qFAAqF;IACrF,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAA;IAC3C,qGAAqG;IACrG,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACvC;AAED,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,8EAA8E;AAC9E,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAkFD,qBAAa,YAAY;;gBAWX,OAAO,EAAE,mBAAmB;IAKxC,wEAAwE;IACxE,eAAe,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAIlD;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IASpC;;;;OAIG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASvC;;;OAGG;IACH,uBAAuB,IAAI,IAAI;IAI/B,0BAA0B,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI;IAIlE;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAkBtC;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAqCpC;;;OAGG;IACH,mBAAmB,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI;IAoB1D;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE,wBAAwB,GAAG,IAAI;CAsBpD"}

package/dist/cmcd-producer.js

@@ -0,0 +1,207 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/cmcd-producer.ts
+var PLAY_MODES = ["full", "base-only", "single-track"];
+function sanitize(value) {
+  return value.replace(/[,\r\n]/g, "");
+}
+function buildFecParams(stats) {
+  const params = {};
+  const cfg = stats.config;
+  params["x-bc-fec-algo"] = cfg.algorithm;
+  params["x-bc-fec-k"] = cfg.k;
+  params["x-bc-fec-p"] = cfg.repairCount;
+  params["x-bc-fec-recovery"] = parseFloat((stats.recoveryRate / 100).toFixed(4));
+  if (stats.greenFillFrames > 0) {
+    params["x-bc-scu"] = stats.greenFillFrames;
+  }
+  if (cfg.altaEnabled) {
+    params["x-bc-alta-verified"] = stats.altaVerified > 0;
+    params["x-bc-alta-failures"] = stats.altaFailed;
+  }
+  return params;
+}
+function buildTransportParams(snap) {
+  if (!snap) return {};
+  const params = {};
+  params["x-bc-transport"] = snap.transport;
+  if (snap.multicastGroup != null) {
+    params["x-bc-multicast-group"] = snap.multicastGroup;
+  }
+  if (snap.multicastSource != null) {
+    params["x-bc-multicast-source"] = snap.multicastSource;
+  }
+  if (snap.amtRelay != null) {
+    params["x-bc-amt-relay"] = snap.amtRelay;
+  }
+  return params;
+}
+function formatQueryString(params) {
+  return Object.keys(params).sort().map((key) => {
+    const v = params[key];
+    if (typeof v === "string") return `${key}=${sanitize(v)}`;
+    return `${key}=${v}`;
+  }).join(",");
+}
+var _onCmcdParams, _onCmcdPost, _transport, _lastStats, _playMode, _deltaFailRate, _switchMiscount, _manifestStats, _CmcdProducer_instances, emit_fn;
+var CmcdProducer = class {
+  constructor(options) {
+    __privateAdd(this, _CmcdProducer_instances);
+    __privateAdd(this, _onCmcdParams);
+    __privateAdd(this, _onCmcdPost);
+    __privateAdd(this, _transport);
+    __privateAdd(this, _lastStats);
+    // Phase 14 state — Plan 03 Task 2 (D-12, D-15).
+    __privateAdd(this, _playMode, null);
+    __privateAdd(this, _deltaFailRate, null);
+    __privateAdd(this, _switchMiscount, 0);
+    __privateAdd(this, _manifestStats, null);
+    __privateSet(this, _onCmcdParams, options.onCmcdParams);
+    __privateSet(this, _onCmcdPost, options.onCmcdPost);
+  }
+  /** Update the stored transport state. Called by player wiring layer. */
+  updateTransport(snapshot) {
+    __privateSet(this, _transport, snapshot);
+  }
+  /**
+   * Set the current play-mode. Emitted as `x-bc-play-mode` on subsequent
+   * snapshots. Throws on any value outside {'full','base-only','single-track'}
+   * (CLAUDE.md: error on bad init).
+   */
+  updatePlayMode(mode) {
+    if (typeof mode !== "string" || !PLAY_MODES.includes(mode)) {
+      throw new Error(
+        `[CmcdProducer] invalid play-mode "${String(mode)}"; expected one of: ${PLAY_MODES.join(", ")}`
+      );
+    }
+    __privateSet(this, _playMode, mode);
+  }
+  /**
+   * Set the delta-track FEC block-failure rate (0..1 inclusive). Emitted as
+   * `x-bc-delta-fail-rate` on snapshots when play-mode is 'full' or 'base-only'.
+   * Omitted on single-track streams.
+   */
+  updateDeltaFailRate(rate) {
+    if (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0 || rate > 1) {
+      throw new Error(
+        `[CmcdProducer] invalid delta-fail-rate "${String(rate)}"; expected a finite number in [0, 1]`
+      );
+    }
+    __privateSet(this, _deltaFailRate, rate);
+  }
+  /**
+   * Bump the cumulative switching-set misalignment counter. Emitted as
+   * `x-bc-switch-miscount` on snapshots when the counter is > 0.
+   */
+  incrementSwitchMiscount() {
+    __privateSet(this, _switchMiscount, __privateGet(this, _switchMiscount) + 1);
+  }
+  updateManifestVerification(stats) {
+    __privateSet(this, _manifestStats, stats);
+  }
+  /**
+   * One-shot emit of `x-bc-switch-drift-us` for a single misalignment event.
+   * Does NOT mutate snapshot state — subsequent onSnapshot() calls will not
+   * include the drift key until the next emitSwitchDrift(). Mirrors the
+   * existing onTransition() pattern.
+   */
+  emitSwitchDrift(driftUs) {
+    if (typeof driftUs !== "number" || !Number.isFinite(driftUs) || driftUs < 0) {
+      throw new Error(
+        `[CmcdProducer] invalid drift-us "${String(driftUs)}"; expected a non-negative finite number`
+      );
+    }
+    const params = {};
+    if (__privateGet(this, _lastStats)) Object.assign(params, buildFecParams(__privateGet(this, _lastStats)));
+    Object.assign(params, buildTransportParams(__privateGet(this, _transport)));
+    if (__privateGet(this, _switchMiscount) > 0) params["x-bc-switch-miscount"] = __privateGet(this, _switchMiscount);
+    params["x-bc-switch-drift-us"] = driftUs;
+    __privateMethod(this, _CmcdProducer_instances, emit_fn).call(this, params);
+  }
+  /**
+   * Process a FecTrackStats snapshot. Finds the video track, builds
+   * x-bc-* vendor keys, and fires both delivery callbacks.
+   */
+  onSnapshot(data) {
+    const videoTrack = data.tracks.find((t) => t.config.trackType === "video");
+    if (!videoTrack) return;
+    __privateSet(this, _lastStats, videoTrack);
+    const params = {
+      ...buildFecParams(videoTrack),
+      ...buildTransportParams(__privateGet(this, _transport))
+    };
+    if (__privateGet(this, _playMode) !== null) {
+      params["x-bc-play-mode"] = __privateGet(this, _playMode);
+    }
+    if (__privateGet(this, _playMode) !== null && __privateGet(this, _playMode) !== "single-track" && __privateGet(this, _deltaFailRate) !== null) {
+      params["x-bc-delta-fail-rate"] = parseFloat(__privateGet(this, _deltaFailRate).toFixed(4));
+    }
+    if (__privateGet(this, _switchMiscount) > 0) {
+      params["x-bc-switch-miscount"] = __privateGet(this, _switchMiscount);
+    }
+    if (__privateGet(this, _manifestStats)) {
+      params["x-bc-manifest-verified"] = __privateGet(this, _manifestStats).verified > 0;
+      params["x-bc-manifest-failures"] = Object.values(__privateGet(this, _manifestStats).failures).reduce((total, count) => total + count, 0);
+    }
+    __privateMethod(this, _CmcdProducer_instances, emit_fn).call(this, params);
+  }
+  /**
+   * Emit transport state without inventing FEC metrics. Cadence is owned by
+   * the caller because only the transport integration knows when state changed.
+   */
+  onTransportSnapshot(data) {
+    if (!Number.isFinite(data.timestampMs) || data.timestampMs < 0) {
+      throw new Error("[CmcdProducer] transport snapshot timestamp must be a non-negative finite number");
+    }
+    if (data.playMode !== void 0) this.updatePlayMode(data.playMode);
+    if (data.switchMiscount !== void 0 && (!Number.isSafeInteger(data.switchMiscount) || data.switchMiscount < 0)) {
+      throw new Error("[CmcdProducer] transport snapshot switch-miscount must be a non-negative safe integer");
+    }
+    __privateSet(this, _transport, data.transport);
+    const params = buildTransportParams(data.transport);
+    if (__privateGet(this, _playMode) !== null) params["x-bc-play-mode"] = __privateGet(this, _playMode);
+    const switchMiscount = data.switchMiscount ?? __privateGet(this, _switchMiscount);
+    if (switchMiscount > 0) params["x-bc-switch-miscount"] = switchMiscount;
+    __privateMethod(this, _CmcdProducer_instances, emit_fn).call(this, params);
+  }
+  /**
+   * Signal a transport transition event. Fires an immediate out-of-band
+   * emit with x-bc-ct set. The subsequent onSnapshot() will NOT include
+   * x-bc-ct (one-shot).
+   */
+  onTransition(event) {
+    const params = {};
+    if (__privateGet(this, _lastStats)) {
+      Object.assign(params, buildFecParams(__privateGet(this, _lastStats)));
+    }
+    Object.assign(params, buildTransportParams(__privateGet(this, _transport)));
+    params["x-bc-ct"] = event;
+    __privateMethod(this, _CmcdProducer_instances, emit_fn).call(this, params);
+  }
+};
+_onCmcdParams = new WeakMap();
+_onCmcdPost = new WeakMap();
+_transport = new WeakMap();
+_lastStats = new WeakMap();
+_playMode = new WeakMap();
+_deltaFailRate = new WeakMap();
+_switchMiscount = new WeakMap();
+_manifestStats = new WeakMap();
+_CmcdProducer_instances = new WeakSet();
+/** Fire both delivery callbacks with the given params. */
+emit_fn = function(params) {
+  var _a, _b;
+  (_a = __privateGet(this, _onCmcdParams)) == null ? void 0 : _a.call(this, params);
+  (_b = __privateGet(this, _onCmcdPost)) == null ? void 0 : _b.call(this, formatQueryString(params));
+};
+export {
+  CmcdProducer
+};
+//# sourceMappingURL=cmcd-producer.js.map