@blockcast/mmt-container 0.1.0 → 0.3.0

package/dist/cmaf-block-assembler.js

@@ -0,0 +1,1966 @@
+// 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 assertTimescale(timescale, label) {
+  if (!Number.isInteger(timescale) || timescale <= 0 || timescale > UINT32_MAX) {
+    throw new RangeError(`${label} must be an integer in 1..${UINT32_MAX}, got ${timescale}`);
+  }
+}
+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;
+}
+function normalizeAacSampleForCmaf(data) {
+  if (data.length < 7 || data[0] !== 255 || (data[1] & 246) !== 240) {
+    return data;
+  }
+  const headerLength = data[1] & 1 ? 7 : 9;
+  if (data.length <= headerLength) return data;
+  const frameLength = (data[3] & 3) << 11 | data[4] << 3 | (data[5] & 224) >>> 5;
+  if (frameLength !== data.length || frameLength <= headerLength) return data;
+  return data.subarray(headerLength);
+}
+function encodeDataSegment(data, timestamp, duration, keyframe, sequence, trackId = 1, compositionTimeOffset) {
+  assertTrackId(trackId, "trackId");
+  assertCompositionTimeOffsets([{ compositionTimeOffset }]);
+  if (compositionTimeOffset !== void 0) {
+    return encodeMultiSampleSegment(
+      [{ data, duration, keyframe, compositionTimeOffset }],
+      timestamp,
+      sequence,
+      trackId
+    );
+  }
+  const sampleFlags = keyframe ? KEYFRAME_FLAGS : DELTA_FLAGS;
+  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(timestamp / 4294967296));
+  tfdtView.setUint32(4, timestamp >>> 0);
+  const tfdt = fullBox("tfdt", 1, 0, tfdtBody);
+  const trunBody = new Uint8Array(20);
+  const trunView = new DataView(trunBody.buffer);
+  trunView.setUint32(0, 1);
+  trunView.setUint32(4, 0);
+  trunView.setUint32(8, duration >>> 0);
+  trunView.setUint32(12, data.length);
+  trunView.setUint32(16, sampleFlags);
+  const trun = fullBox("trun", 0, 1793, trunBody);
+  const traf = box("traf", tfhd, tfdt, trun);
+  const moof = box("moof", mfhd, traf);
+  const mdat = box("mdat", data);
+  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;
+}
+function buildVideoInitSegment(avcC, width, height, timescale = 1e6, trackId = 1) {
+  return buildVisualInitSegment("avc1", "avcC", avcC, width, height, timescale, trackId);
+}
+function buildHevcVideoInitSegment(sampleEntry, hvcC, width, height, timescale, trackId) {
+  if (sampleEntry !== "hev1" && sampleEntry !== "hvc1") {
+    throw new Error(`HEVC init segment requires an hev1 or hvc1 sample entry, got ${String(sampleEntry)}`);
+  }
+  return buildVisualInitSegment(sampleEntry, "hvcC", hvcC, width, height, timescale, trackId);
+}
+function buildVisualInitSegment(sampleEntryType, configBoxType, configRecord, width, height, timescale, trackId) {
+  assertTrackId(trackId, "video trackId");
+  assertTimescale(timescale, "video timescale");
+  const ftyp = box("ftyp", new Uint8Array([
+    105,
+    115,
+    111,
+    109,
+    0,
+    0,
+    2,
+    0,
+    105,
+    115,
+    111,
+    109,
+    105,
+    115,
+    111,
+    54,
+    109,
+    112,
+    52,
+    49
+  ]));
+  const configBox = box(configBoxType, configRecord);
+  const sampleEntryBody = new Uint8Array(78 + configBox.length);
+  const sampleEntryView = new DataView(sampleEntryBody.buffer);
+  sampleEntryView.setUint16(6, 1);
+  sampleEntryView.setUint16(24, width);
+  sampleEntryView.setUint16(26, height);
+  sampleEntryView.setUint32(28, 4718592);
+  sampleEntryView.setUint32(32, 4718592);
+  sampleEntryView.setUint16(40, 1);
+  sampleEntryView.setUint16(74, 24);
+  sampleEntryView.setInt16(76, -1);
+  sampleEntryBody.set(configBox, 78);
+  const visualSampleEntry = box(sampleEntryType, sampleEntryBody);
+  const stsd = fullBox("stsd", 0, 0, u32(1), visualSampleEntry);
+  const stbl = box(
+    "stbl",
+    stsd,
+    fullBox("stts", 0, 0, u32(0)),
+    fullBox("stsc", 0, 0, u32(0)),
+    fullBox("stsz", 0, 0, u32(0), u32(0)),
+    fullBox("stco", 0, 0, u32(0))
+  );
+  const dinf = box("dinf", fullBox("dref", 0, 0, u32(1), fullBox("url ", 0, 1)));
+  const minf = box("minf", fullBox("vmhd", 0, 1, new Uint8Array(8)), dinf, stbl);
+  const hdlr = fullBox("hdlr", 0, 0, new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    118,
+    105,
+    100,
+    101,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    86,
+    105,
+    100,
+    101,
+    111,
+    0
+  ]));
+  const mdhdBody = new Uint8Array(20);
+  new DataView(mdhdBody.buffer).setUint32(8, timescale);
+  const mdhd = fullBox("mdhd", 0, 0, mdhdBody);
+  const mdia = box("mdia", mdhd, hdlr, minf);
+  const tkhdBody = new Uint8Array(80);
+  const tkhdView = new DataView(tkhdBody.buffer);
+  tkhdView.setUint32(8, trackId);
+  tkhdView.setUint32(36, 65536);
+  tkhdView.setUint32(52, 65536);
+  tkhdView.setUint32(64, 1073741824);
+  tkhdView.setUint32(72, width << 16);
+  tkhdView.setUint32(76, height << 16);
+  const tkhd = fullBox("tkhd", 0, 3, tkhdBody);
+  const trak = box("trak", tkhd, mdia);
+  const mvhdBody = new Uint8Array(96);
+  const mvhdView = new DataView(mvhdBody.buffer);
+  mvhdView.setUint32(8, timescale);
+  mvhdView.setUint32(16, 65536);
+  mvhdView.setUint16(20, 256);
+  mvhdView.setUint32(32, 65536);
+  mvhdView.setUint32(48, 65536);
+  mvhdView.setUint32(60, 1073741824);
+  mvhdView.setUint32(92, trackId + 1);
+  const mvhd = fullBox("mvhd", 0, 0, mvhdBody);
+  const trexBody = new Uint8Array(20);
+  new DataView(trexBody.buffer).setUint32(0, trackId);
+  new DataView(trexBody.buffer).setUint32(4, 1);
+  const mvex = box("mvex", fullBox("trex", 0, 0, trexBody));
+  const moov = box("moov", mvhd, trak, mvex);
+  const result = new Uint8Array(ftyp.length + moov.length);
+  result.set(ftyp, 0);
+  result.set(moov, ftyp.length);
+  return result;
+}
+function buildAudioInitSegment(sampleRate, channels, asc, timescale, trackId = 1) {
+  assertTrackId(trackId, "audio trackId");
+  const ts = timescale ?? sampleRate;
+  assertTimescale(ts, "audio timescale");
+  if (!asc) {
+    const freqTable = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+    const fi = freqTable.indexOf(sampleRate);
+    const freqIdx = fi >= 0 ? fi : 15;
+    if (freqIdx <= 14) {
+      const v = 2 << 11 | freqIdx << 7 | channels << 3;
+      asc = new Uint8Array([v >> 8 & 255, v & 255]);
+    } else {
+      asc = new Uint8Array([
+        2 << 3 | 7,
+        (8 | sampleRate >> 20 & 7) & 255,
+        sampleRate >> 12 & 255,
+        sampleRate >> 4 & 255,
+        ((sampleRate & 15) << 4 | channels << 0) & 255
+      ]);
+    }
+  }
+  const dsi = new Uint8Array(2 + asc.length);
+  dsi[0] = 5;
+  dsi[1] = asc.length;
+  dsi.set(asc, 2);
+  const dcdBody = new Uint8Array(13 + dsi.length);
+  dcdBody[0] = 64;
+  dcdBody[1] = 21;
+  dcdBody.set(dsi, 13);
+  const dcd = new Uint8Array(2 + dcdBody.length);
+  dcd[0] = 4;
+  dcd[1] = dcdBody.length;
+  dcd.set(dcdBody, 2);
+  const esBody = new Uint8Array(3 + dcd.length);
+  esBody[0] = 0;
+  esBody[1] = 1;
+  esBody[2] = 0;
+  esBody.set(dcd, 3);
+  const es = new Uint8Array(2 + esBody.length);
+  es[0] = 3;
+  es[1] = esBody.length;
+  es.set(esBody, 2);
+  const esdsBox = fullBox("esds", 0, 0, es);
+  const mp4aBody = new Uint8Array(28 + esdsBox.length);
+  const mp4aView = new DataView(mp4aBody.buffer);
+  mp4aView.setUint16(6, 1);
+  mp4aView.setUint16(16, channels);
+  mp4aView.setUint16(18, 16);
+  mp4aView.setUint32(24, sampleRate << 16);
+  mp4aBody.set(esdsBox, 28);
+  const mp4a = box("mp4a", mp4aBody);
+  const stsd = fullBox("stsd", 0, 0, u32(1), mp4a);
+  const stbl = box(
+    "stbl",
+    stsd,
+    fullBox("stts", 0, 0, u32(0)),
+    fullBox("stsc", 0, 0, u32(0)),
+    fullBox("stsz", 0, 0, u32(0), u32(0)),
+    fullBox("stco", 0, 0, u32(0))
+  );
+  const dinf = box("dinf", fullBox("dref", 0, 0, u32(1), fullBox("url ", 0, 1)));
+  const minf = box("minf", fullBox("smhd", 0, 0, new Uint8Array(4)), dinf, stbl);
+  const hdlr = fullBox("hdlr", 0, 0, new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    115,
+    111,
+    117,
+    110,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    83,
+    111,
+    117,
+    110,
+    100,
+    0
+  ]));
+  const mdhdBody = new Uint8Array(20);
+  new DataView(mdhdBody.buffer).setUint32(8, ts);
+  const mdhd = fullBox("mdhd", 0, 0, mdhdBody);
+  const mdia = box("mdia", mdhd, hdlr, minf);
+  const tkhdBody = new Uint8Array(80);
+  const tkhdView = new DataView(tkhdBody.buffer);
+  tkhdView.setUint32(8, trackId);
+  tkhdView.setUint32(36, 65536);
+  tkhdView.setUint32(52, 65536);
+  tkhdView.setUint32(64, 1073741824);
+  const tkhd = fullBox("tkhd", 0, 3, tkhdBody);
+  const trak = box("trak", tkhd, mdia);
+  const mvhdBody = new Uint8Array(96);
+  const mvhdView = new DataView(mvhdBody.buffer);
+  mvhdView.setUint32(8, ts);
+  mvhdView.setUint32(16, 65536);
+  mvhdView.setUint16(20, 256);
+  mvhdView.setUint32(32, 65536);
+  mvhdView.setUint32(48, 65536);
+  mvhdView.setUint32(60, 1073741824);
+  mvhdView.setUint32(92, trackId + 1);
+  const mvhd = fullBox("mvhd", 0, 0, mvhdBody);
+  const trexBody = new Uint8Array(20);
+  new DataView(trexBody.buffer).setUint32(0, trackId);
+  new DataView(trexBody.buffer).setUint32(4, 1);
+  const mvex = box("mvex", fullBox("trex", 0, 0, trexBody));
+  const moov = box("moov", mvhd, trak, mvex);
+  const ftyp = box("ftyp", new Uint8Array([
+    105,
+    115,
+    111,
+    109,
+    0,
+    0,
+    2,
+    0,
+    105,
+    115,
+    111,
+    109,
+    105,
+    115,
+    111,
+    54,
+    109,
+    112,
+    52,
+    49
+  ]));
+  const result = new Uint8Array(ftyp.length + moov.length);
+  result.set(ftyp, 0);
+  result.set(moov, ftyp.length);
+  return result;
+}
+
+// src/conceal-timeline.ts
+var AudioGapConcealer = class {
+  #last = null;
+  #stats = { rejectedUnits: 0 };
+  get stats() {
+    return { ...this.#stats };
+  }
+  /**
+   * Record a good access unit as it is emitted. An AU whose duration is not
+   * whole media ticks is refused and counted (`stats.rejectedUnits`), and the
+   * concealer forgets its previous AU: that one no longer precedes the gap, so
+   * sizing from it would misplace every slot. Refusing here keeps `plan()`
+   * total, so a bad AU never throws out of the packet path.
+   */
+  note(au) {
+    if (!Number.isSafeInteger(au.duration) || au.duration <= 0) {
+      this.#stats.rejectedUnits++;
+      this.#last = null;
+      return;
+    }
+    this.#last = au;
+  }
+  plan(decision, next) {
+    if (!decision || decision.trackKind !== "audio") return { kind: "none" };
+    const missing = decision.missingFrames;
+    if (decision.reason !== "audio-gap" || missing === null || !Number.isSafeInteger(missing) || missing <= 0) {
+      return { kind: "re-anchor", pts: next.pts };
+    }
+    const last = this.#last;
+    if (last === null) return { kind: "re-anchor", pts: next.pts };
+    const duration = BigInt(last.duration);
+    const repeat = [];
+    for (let slot = 1; slot <= missing; slot++) {
+      repeat.push({
+        payload: last.payload,
+        pts: last.pts + BigInt(slot) * duration,
+        duration: last.duration
+      });
+    }
+    return { kind: "conceal", repeat, silenceTicks: BigInt(missing) * duration };
+  }
+  reset() {
+    this.#last = null;
+  }
+};
+
+// src/codec-utils.ts
+function videoSampleEntryFromCodecString(codec) {
+  const fourCc = codec.split(".")[0];
+  if (fourCc === "avc1" || fourCc === "avc3" || fourCc === "hev1" || fourCc === "hvc1") return fourCc;
+  throw new Error(`Unsupported video codec family in codec string ${JSON.stringify(codec)}`);
+}
+function videoCodecFamily(sampleEntry) {
+  return sampleEntry === "avc1" || sampleEntry === "avc3" ? "avc" : "hevc";
+}
+var HEVC_NAL_UNIT_TYPE = {
+  TRAIL_R: 1,
+  /** First IRAP type. */
+  BLA_W_LP: 16,
+  IDR_W_RADL: 19,
+  IDR_N_LP: 20,
+  CRA_NUT: 21,
+  /** Last IRAP type (reserved IRAP VCL). */
+  RSV_IRAP_VCL23: 23,
+  /** Last VCL type; 32..=63 are non-VCL. */
+  LAST_VCL: 31,
+  VPS_NUT: 32,
+  SPS_NUT: 33,
+  PPS_NUT: 34,
+  AUD_NUT: 35,
+  PREFIX_SEI_NUT: 39,
+  SUFFIX_SEI_NUT: 40
+};
+var HEVC_NAL_HEADER_LENGTH = 2;
+function hevcNalUnitType(nal) {
+  return nal[0] >> 1 & 63;
+}
+function isHevcIrapNalUnitType(nalUnitType) {
+  return nalUnitType >= HEVC_NAL_UNIT_TYPE.BLA_W_LP && nalUnitType <= HEVC_NAL_UNIT_TYPE.RSV_IRAP_VCL23;
+}
+function removeEmulationPrevention(rbsp) {
+  const out = [];
+  let zeros = 0;
+  for (let i = 0; i < rbsp.length; i++) {
+    const b = rbsp[i];
+    if (zeros >= 2 && b === 3) {
+      zeros = 0;
+      continue;
+    }
+    out.push(b);
+    zeros = b === 0 ? zeros + 1 : 0;
+  }
+  return Uint8Array.from(out);
+}
+function splitHevcSample(data) {
+  if (isCompleteAvccSample(data)) return { nals: splitAvccNalUnits(data), lengthPrefixed: true };
+  if (isAnnexB(data)) return { nals: splitAnnexBNalUnits(data), lengthPrefixed: false };
+  return null;
+}
+function hevcNalUnitsContainIrap(nals) {
+  let sawNal = false;
+  for (const nal of nals) {
+    if (nal.length < HEVC_NAL_HEADER_LENGTH) continue;
+    sawNal = true;
+    if (isHevcIrapNalUnitType(hevcNalUnitType(nal))) return true;
+  }
+  return sawNal ? false : void 0;
+}
+function prepareHevcCmafSample(data, sampleEntry) {
+  const split = splitHevcSample(data);
+  if (split === null) return null;
+  const keyframe = hevcNalUnitsContainIrap(split.nals);
+  if (keyframe === void 0) return null;
+  const normalized = hevcNalUnitsToLengthPrefixed(data, split.nals, split.lengthPrefixed, sampleEntry);
+  return normalized === null ? null : { keyframe, data: normalized };
+}
+function hevcNalUnitsToLengthPrefixed(data, nals, lengthPrefixed, sampleEntry) {
+  const kept = sampleEntry === "hvc1" ? nals.filter((nal) => {
+    const t = hevcNalUnitType(nal);
+    return t !== HEVC_NAL_UNIT_TYPE.VPS_NUT && t !== HEVC_NAL_UNIT_TYPE.SPS_NUT && t !== HEVC_NAL_UNIT_TYPE.PPS_NUT;
+  }) : nals;
+  if (kept.length === 0) return null;
+  if (lengthPrefixed && kept.length === nals.length) return data;
+  const out = new Uint8Array(kept.reduce((sum, nal) => sum + 4 + nal.length, 0));
+  let w = 0;
+  for (const nal of kept) {
+    w = writeNalLength(out, w, nal.length);
+    out.set(nal, w);
+    w += nal.length;
+  }
+  return out;
+}
+function splitAvccNalUnits(data, lengthSize = 4) {
+  const nals = [];
+  let i = 0;
+  while (i + lengthSize <= data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i + len > data.length) break;
+    nals.push(data.subarray(i, i + len));
+    i += len;
+  }
+  return nals;
+}
+function isCompleteAvccSample(data, lengthSize = 4) {
+  let i = 0;
+  let count = 0;
+  while (i + lengthSize <= data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i + len > data.length) return false;
+    i += len;
+    count++;
+  }
+  return count > 0 && i === data.length;
+}
+function splitH264SampleNalUnits(data, options = {}) {
+  if (isCompleteAvccSample(data)) return { nals: splitAvccNalUnits(data), format: "avcc" };
+  if (isAnnexB(data)) return { nals: splitAnnexBNalUnits(data), format: "annexb" };
+  if (options.allowPartialAvcc === true) {
+    const partial = splitPartialAvccNalUnits(data);
+    if (partial.length > 0) return { nals: partial, format: "partial-avcc" };
+  }
+  if (isLikelyRawH264NalUnit(data)) return { nals: [data], format: "raw-nal" };
+  const nals = splitAvccNalUnits(data);
+  return { nals, format: nals.length > 0 ? "avcc" : "unknown" };
+}
+function isAnnexB(data) {
+  if (data.length >= 4 && data[0] === 0 && data[1] === 0 && (data[2] === 1 || data[2] === 0 && data[3] === 1)) {
+    return true;
+  }
+  return false;
+}
+function splitAnnexBNalUnits(data) {
+  const nalUnits = [];
+  let i = 0;
+  while (i < data.length - 3) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      let scLen = 0;
+      if (data[i + 2] === 1) scLen = 3;
+      else if (data[i + 2] === 0 && i + 3 < data.length && data[i + 3] === 1) scLen = 4;
+      if (scLen > 0) {
+        const nalStart = i + scLen;
+        let nalEnd = data.length;
+        for (let j = nalStart + 1; j < data.length - 2; j++) {
+          if (data[j] === 0 && data[j + 1] === 0 && (data[j + 2] === 1 || data[j + 2] === 0 && j + 3 < data.length && data[j + 3] === 1)) {
+            nalEnd = j;
+            break;
+          }
+        }
+        if (nalEnd > nalStart) nalUnits.push(data.subarray(nalStart, nalEnd));
+        i = nalEnd;
+        continue;
+      }
+    }
+    i++;
+  }
+  return nalUnits;
+}
+function classifyH264Keyframe(data, options = {}) {
+  const nals = h264NalUnitsForKeyframeDetection(data, options);
+  if (nals.length === 0) return void 0;
+  let sawIntraSlice = false;
+  let sawNonIntraVcl = false;
+  let sawNal = false;
+  for (const nal of nals) {
+    sawNal = true;
+    const nalType = nal[0] !== void 0 ? nal[0] & 31 : -1;
+    if (nalType === 5 || nalType === 7) return true;
+    if (nalType === 1) {
+      if (isH264IntraSlice(nal)) sawIntraSlice = true;
+      else sawNonIntraVcl = true;
+    }
+  }
+  if (sawIntraSlice && !sawNonIntraVcl) return true;
+  return sawNal ? false : void 0;
+}
+function detectH264Keyframe(data, options = {}) {
+  return classifyH264Keyframe(data, options) === true;
+}
+function writeNalLength(buf, offset, len) {
+  buf[offset] = len >> 24 & 255;
+  buf[offset + 1] = len >> 16 & 255;
+  buf[offset + 2] = len >> 8 & 255;
+  buf[offset + 3] = len & 255;
+  return offset + 4;
+}
+function h264NalUnitsForKeyframeDetection(data, options) {
+  return splitH264SampleNalUnits(data, options).nals;
+}
+function splitPartialAvccNalUnits(data, lengthSize = 4) {
+  const nals = [];
+  let i = 0;
+  while (i + lengthSize < data.length) {
+    let len = 0;
+    for (let k = 0; k < lengthSize; k++) len = len << 8 | data[i + k];
+    i += lengthSize;
+    if (len <= 0 || i >= data.length) break;
+    const end = Math.min(i + len, data.length);
+    nals.push(data.subarray(i, end));
+    if (end < i + len) break;
+    i = end;
+  }
+  return nals;
+}
+function isLikelyRawH264NalUnit(data) {
+  if (data.length === 0) return false;
+  const header = data[0];
+  if ((header & 128) !== 0) return false;
+  const nalType = header & 31;
+  return nalType > 0 && nalType < 24;
+}
+function isH264IntraSlice(nal) {
+  const sliceType = readH264SliceType(nal);
+  return sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9;
+}
+function readH264SliceType(nal) {
+  if (nal.length < 2 || (nal[0] & 31) !== 1) return null;
+  const rbsp = removeEmulationPrevention(nal.subarray(1));
+  const state = { bitOffset: 0 };
+  if (readUnsignedExpGolomb(rbsp, state) === null) return null;
+  return readUnsignedExpGolomb(rbsp, state);
+}
+function readUnsignedExpGolomb(data, state) {
+  let leadingZeroBits = 0;
+  while (true) {
+    const bit = readBit(data, state);
+    if (bit === null) return null;
+    if (bit === 1) break;
+    leadingZeroBits++;
+    if (leadingZeroBits > 30) return null;
+  }
+  let suffix = 0;
+  for (let i = 0; i < leadingZeroBits; i++) {
+    const bit = readBit(data, state);
+    if (bit === null) return null;
+    suffix = suffix << 1 | bit;
+  }
+  return (1 << leadingZeroBits) - 1 + suffix;
+}
+function readBit(data, state) {
+  if (state.bitOffset >= data.length * 8) return null;
+  const byte = data[state.bitOffset >> 3];
+  const bit = byte >> 7 - (state.bitOffset & 7) & 1;
+  state.bitOffset++;
+  return bit;
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("codec-utils", () => {
+    describe("isAnnexB", () => {
+      test("4-byte start code", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 0, 1, 101]))).toBe(true);
+      });
+      test("3-byte start code", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 1, 101]))).toBe(true);
+      });
+      test("rejects AVCC", () => {
+        expect(isAnnexB(new Uint8Array([0, 0, 0, 10, 101]))).toBe(false);
+      });
+    });
+    describe("findAnnexBStartCode", () => {
+      test("at offset 0", () => {
+        expect(findAnnexBStartCode(new Uint8Array([0, 0, 0, 1, 101]))).toBe(0);
+      });
+      test("at offset 5", () => {
+        expect(findAnnexBStartCode(new Uint8Array([170, 187, 204, 221, 238, 0, 0, 1, 101]))).toBe(5);
+      });
+      test("returns -1 when none", () => {
+        expect(findAnnexBStartCode(new Uint8Array([170, 187, 204]))).toBe(-1);
+      });
+    });
+    describe("splitAnnexBNalUnits", () => {
+      test("splits two NALs", () => {
+        const data = new Uint8Array([0, 0, 0, 1, 101, 170, 187, 0, 0, 0, 1, 65, 204]);
+        const nals = splitAnnexBNalUnits(data);
+        expect(nals.length).toBe(2);
+        expect(nals[0]).toEqual(new Uint8Array([101, 170, 187]));
+        expect(nals[1]).toEqual(new Uint8Array([65, 204]));
+      });
+      test("handles 3-byte start codes", () => {
+        const nals = splitAnnexBNalUnits(new Uint8Array([0, 0, 1, 103, 66, 0, 0, 1, 104, 1]));
+        expect(nals.length).toBe(2);
+      });
+    });
+    describe("annexBToAvcc", () => {
+      test("converts single NAL", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 65, 170, 187]);
+        const avcc = annexBToAvcc(annexB);
+        expect(avcc[3]).toBe(3);
+        expect(avcc[4]).toBe(65);
+      });
+      test("prepends SPS/PPS", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 101, 1]);
+        const avcc = annexBToAvcc(annexB, { sps: new Uint8Array([103, 66]), pps: new Uint8Array([104, 1]) });
+        expect(avcc[3]).toBe(2);
+        expect(avcc[4]).toBe(103);
+      });
+    });
+    describe("detectH264Keyframe", () => {
+      test("IDR in Annex-B", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 101]))).toBe(true);
+      });
+      test("SPS in Annex-B", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 103]))).toBe(true);
+      });
+      test("IDR in AVCC", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 5, 101, 1, 2, 3, 4]))).toBe(true);
+      });
+      test("IDR after AVCC AUD", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          1,
+          9,
+          0,
+          0,
+          0,
+          2,
+          101,
+          170
+        ]))).toBe(true);
+      });
+      test("non-IDR AVC I-slice in AVCC", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          2,
+          65,
+          136
+        ]))).toBe(true);
+      });
+      test("raw H.264 IDR NAL", () => {
+        expect(detectH264Keyframe(new Uint8Array([101, 136, 132]))).toBe(true);
+      });
+      test("raw H.264 non-IDR I-slice NAL", () => {
+        expect(detectH264Keyframe(new Uint8Array([65, 136]))).toBe(true);
+      });
+      test("classifies partial length-prefixed IDR only when requested", () => {
+        const partial = new Uint8Array([0, 0, 32, 0, 101]);
+        expect(classifyH264Keyframe(partial)).toBeUndefined();
+        expect(classifyH264Keyframe(partial, { allowPartialAvcc: true })).toBe(true);
+      });
+      test("rejects P-frame", () => {
+        expect(detectH264Keyframe(new Uint8Array([0, 0, 0, 1, 65]))).toBe(false);
+      });
+      test("rejects AVCC sample with only non-IDR slices", () => {
+        expect(detectH264Keyframe(new Uint8Array([
+          0,
+          0,
+          0,
+          2,
+          65,
+          192,
+          0,
+          0,
+          0,
+          2,
+          65,
+          192
+        ]))).toBe(false);
+      });
+    });
+    describe("avccToAnnexB", () => {
+      test("converts with SPS/PPS on keyframe", () => {
+        const avcc = new Uint8Array([0, 0, 0, 3, 101, 170, 187]);
+        const spsPps = { sps: new Uint8Array([103, 66]), pps: new Uint8Array([104, 1]) };
+        const annexB = avccToAnnexB(avcc, true, spsPps);
+        expect(annexB[3]).toBe(1);
+        expect(annexB[4]).toBe(103);
+      });
+    });
+    describe("codecStringFromAvcC", () => {
+      test("derives avc1.64002a", () => {
+        expect(codecStringFromAvcC(new Uint8Array([1, 100, 0, 42]))).toBe("avc1.64002a");
+      });
+    });
+    describe("extractAacAscFromInitSegment", () => {
+      function buildMinimalAacInit(asc) {
+        const box2 = (type, payload) => {
+          const sz = 8 + payload.length;
+          const out = new Uint8Array(sz);
+          out[0] = sz >>> 24 & 255;
+          out[1] = sz >>> 16 & 255;
+          out[2] = sz >>> 8 & 255;
+          out[3] = sz & 255;
+          out[4] = type.charCodeAt(0);
+          out[5] = type.charCodeAt(1);
+          out[6] = type.charCodeAt(2);
+          out[7] = type.charCodeAt(3);
+          out.set(payload, 8);
+          return out;
+        };
+        const concat = (...arrs) => {
+          const total = arrs.reduce((n, a) => n + a.length, 0);
+          const out = new Uint8Array(total);
+          let off = 0;
+          for (const a of arrs) {
+            out.set(a, off);
+            off += a.length;
+          }
+          return out;
+        };
+        const ftyp = box2("ftyp", new Uint8Array([
+          105,
+          115,
+          111,
+          53,
+          // 'iso5'
+          0,
+          0,
+          2,
+          0,
+          // minor 0x200
+          105,
+          115,
+          111,
+          53,
+          // 'iso5'
+          105,
+          115,
+          111,
+          54
+          // 'iso6'
+        ]));
+        const dsi = new Uint8Array(2 + asc.length);
+        dsi[0] = 5;
+        dsi[1] = asc.length;
+        dsi.set(asc, 2);
+        const dcd = new Uint8Array(2 + 13 + dsi.length);
+        dcd[0] = 4;
+        dcd[1] = 13 + dsi.length;
+        dcd[2] = 64;
+        dcd[3] = 5 << 2 | 1;
+        dcd.set(dsi, 15);
+        const esd = new Uint8Array(2 + 3 + dcd.length);
+        esd[0] = 3;
+        esd[1] = 3 + dcd.length;
+        esd.set(dcd, 5);
+        const esdsPayload = new Uint8Array(4 + esd.length);
+        esdsPayload.set(esd, 4);
+        const esds = box2("esds", esdsPayload);
+        const mp4aFixed = new Uint8Array(28);
+        mp4aFixed[7] = 1;
+        mp4aFixed[16] = 0;
+        mp4aFixed[17] = 1;
+        mp4aFixed[18] = 0;
+        mp4aFixed[19] = 16;
+        mp4aFixed[24] = 187;
+        mp4aFixed[25] = 128;
+        const mp4a = box2("mp4a", concat(mp4aFixed, esds));
+        const stsdPayload = new Uint8Array(8 + mp4a.length);
+        stsdPayload[7] = 1;
+        stsdPayload.set(mp4a, 8);
+        const stsd = box2("stsd", stsdPayload);
+        const stbl = box2("stbl", stsd);
+        const minf = box2("minf", stbl);
+        const mdia = box2("mdia", minf);
+        const trak = box2("trak", mdia);
+        const moov = box2("moov", trak);
+        return concat(ftyp, moov);
+      }
+      test("extracts AAC-LC mono 48k ASC and derives codec", () => {
+        const asc = new Uint8Array([17, 136]);
+        const init = buildMinimalAacInit(asc);
+        const result = extractAacAscFromInitSegment(init);
+        expect(result).toBeDefined();
+        expect(result.codec).toBe("mp4a.40.2");
+        expect(Array.from(result.description)).toEqual([17, 136]);
+      });
+      test("derives AOT 5 (HE-AAC) from ASC[0] >> 3", () => {
+        const asc = new Uint8Array([41, 136]);
+        const init = buildMinimalAacInit(asc);
+        expect(extractAacAscFromInitSegment(init)?.codec).toBe("mp4a.40.5");
+      });
+      test("rejects data without ftyp/moov magic", () => {
+        expect(extractAacAscFromInitSegment(new Uint8Array(64))).toBeUndefined();
+      });
+      test("rejects ftyp+moov with no audio (no mp4a sample entry)", () => {
+        const ftyp = new Uint8Array([
+          0,
+          0,
+          0,
+          24,
+          102,
+          116,
+          121,
+          112,
+          105,
+          115,
+          111,
+          53,
+          0,
+          0,
+          2,
+          0,
+          105,
+          115,
+          111,
+          53,
+          105,
+          115,
+          111,
+          54
+        ]);
+        const moov = new Uint8Array([0, 0, 0, 8, 109, 111, 111, 118]);
+        const cat = new Uint8Array(ftyp.length + moov.length);
+        cat.set(ftyp);
+        cat.set(moov, ftyp.length);
+        expect(extractAacAscFromInitSegment(cat)).toBeUndefined();
+      });
+    });
+    describe("hevc", () => {
+      const vps = new Uint8Array([
+        64,
+        1,
+        12,
+        1,
+        255,
+        255,
+        1,
+        96,
+        0,
+        0,
+        3,
+        0,
+        144,
+        0,
+        0,
+        3,
+        0,
+        0,
+        3,
+        0,
+        60,
+        146,
+        128,
+        144
+      ]);
+      const sps = new Uint8Array([
+        66,
+        1,
+        1,
+        1,
+        96,
+        0,
+        0,
+        3,
+        0,
+        144,
+        0,
+        0,
+        3,
+        0,
+        0,
+        3,
+        0,
+        60,
+        160,
+        10,
+        8,
+        15,
+        22,
+        89,
+        42,
+        73,
+        50,
+        188,
+        5,
+        160,
+        32,
+        0,
+        0,
+        3,
+        0,
+        32,
+        0,
+        0,
+        3,
+        3,
+        193
+      ]);
+      const pps = new Uint8Array([68, 1, 193, 114, 180, 98, 64]);
+      const idr = new Uint8Array([38, 1, 175, 6]);
+      const lp = (...nals) => {
+        const parts = [];
+        for (const n of nals) {
+          parts.push(n.length >> 24 & 255, n.length >> 16 & 255, n.length >> 8 & 255, n.length & 255, ...n);
+        }
+        return Uint8Array.from(parts);
+      };
+      test("isHevcCodec", () => {
+        expect(isHevcCodec("hev1.1.6.L93.B0")).toBe(true);
+        expect(isHevcCodec("hvc1.1.6.L93.B0")).toBe(true);
+        expect(isHevcCodec("avc1.640033")).toBe(false);
+      });
+      test("removeEmulationPrevention strips 0x03", () => {
+        expect(Array.from(removeEmulationPrevention(new Uint8Array([0, 0, 3, 1])))).toEqual([0, 0, 1]);
+        expect(Array.from(removeEmulationPrevention(new Uint8Array([170, 187])))).toEqual([170, 187]);
+      });
+      test("splitAvccNalUnits splits length-prefixed NALs", () => {
+        const nals = splitAvccNalUnits(lp(vps, sps));
+        expect(nals.length).toBe(2);
+        expect(nals[0]).toEqual(vps);
+        expect(nals[1]).toEqual(sps);
+      });
+      test("isCompleteAvccSample accepts complete length-prefixed NAL samples", () => {
+        expect(isCompleteAvccSample(lp(new Uint8Array([9]), idr))).toBe(true);
+      });
+      test("isCompleteAvccSample rejects Annex-B start-code samples", () => {
+        expect(isCompleteAvccSample(new Uint8Array([0, 0, 0, 1, 101, 170]))).toBe(false);
+      });
+      test("isCompleteAvccSample rejects truncated length-prefixed samples", () => {
+        expect(isCompleteAvccSample(new Uint8Array([0, 0, 0, 4, 101, 170]))).toBe(false);
+      });
+      test("normalizeH264SampleToAvcc leaves complete AVCC samples unchanged", () => {
+        const avcc = lp(new Uint8Array([9]), idr);
+        const normalized = normalizeH264SampleToAvcc(avcc);
+        expect(normalized.format).toBe("avcc");
+        expect(normalized.data).toBe(avcc);
+      });
+      test("normalizeH264SampleToAvcc converts a single raw H.264 NAL to AVCC", () => {
+        const raw = new Uint8Array([101, 136, 132]);
+        const normalized = normalizeH264SampleToAvcc(raw);
+        expect(normalized.format).toBe("raw-nal");
+        expect(normalized.data).toEqual(new Uint8Array([0, 0, 0, 3, 101, 136, 132]));
+      });
+      test("splitH264SampleNalUnits exposes Annex-B NALs without AVCC conversion", () => {
+        const annexB = new Uint8Array([0, 0, 0, 1, 101, 136, 132]);
+        const sample = splitH264SampleNalUnits(annexB);
+        expect(sample.format).toBe("annexb");
+        expect(sample.nals).toHaveLength(1);
+        expect(sample.nals[0]).toEqual(new Uint8Array([101, 136, 132]));
+      });
+      test("splitH264SampleNalUnits exposes single raw H.264 NALs without wrapping", () => {
+        const raw = new Uint8Array([101, 136, 132]);
+        const sample = splitH264SampleNalUnits(raw);
+        expect(sample.format).toBe("raw-nal");
+        expect(sample.nals).toEqual([raw]);
+      });
+      test("splitH264SampleNalUnits can expose partial AVCC NAL headers", () => {
+        const partial = new Uint8Array([0, 0, 0, 5, 101, 136]);
+        const sample = splitH264SampleNalUnits(partial, { allowPartialAvcc: true });
+        expect(sample.format).toBe("partial-avcc");
+        expect(sample.nals).toHaveLength(1);
+        expect(sample.nals[0]).toEqual(new Uint8Array([101, 136]));
+      });
+      test("extractHevcParameterSets finds VPS/SPS/PPS (length-prefixed)", () => {
+        const sets = extractHevcParameterSets(lp(vps, sps, pps, idr));
+        expect(sets.vps).toEqual(vps);
+        expect(sets.sps).toEqual(sps);
+        expect(sets.pps).toEqual(pps);
+      });
+      test("extractHevcParameterSets finds VPS/SPS/PPS (Annex-B)", () => {
+        const sc = new Uint8Array([0, 0, 0, 1]);
+        const annexb = Uint8Array.from([...sc, ...vps, ...sc, ...sps, ...sc, ...pps, ...sc, ...idr]);
+        const sets = extractHevcParameterSets(annexb);
+        expect(sets.vps).toEqual(vps);
+        expect(sets.sps).toEqual(sps);
+        expect(sets.pps).toEqual(pps);
+      });
+      test("generateHvcCFromParameterSets builds a valid hvcC", () => {
+        const hvcc = generateHvcCFromParameterSets({ vps, sps, pps });
+        expect(hvcc).not.toBeNull();
+        expect(hvcc[0]).toBe(1);
+        expect(hvcc[1]).toBe(sps[3]);
+        expect(hvcc[22]).toBe(3);
+        expect(hvcc[23] & 63).toBe(32);
+        expect(hvcc[24] << 8 | hvcc[25]).toBe(1);
+      });
+      test("generateHvcCFromParameterSets returns null without SPS/PPS", () => {
+        expect(generateHvcCFromParameterSets({ vps })).toBeNull();
+      });
+      test("extractHevcCodecDescription end-to-end from keyframe", () => {
+        const desc = extractHevcCodecDescription(lp(vps, sps, pps, idr));
+        expect(desc).not.toBeNull();
+        expect(desc[0]).toBe(1);
+      });
+      test("hevcVclOnly strips parameter-set NALs, keeps VCL", () => {
+        const stripped = hevcVclOnly(lp(vps, sps, pps, idr));
+        const nals = splitAvccNalUnits(stripped);
+        expect(nals.length).toBe(1);
+        expect(nals[0]).toEqual(idr);
+      });
+      test("hevcVclOnly is a no-op for VCL-only length-prefixed input", () => {
+        const vclOnly = lp(idr);
+        expect(hevcVclOnly(vclOnly)).toBe(vclOnly);
+      });
+    });
+  });
+}
+
+// src/authored-timing.ts
+function scaleAuthoredTicks(ticks, mediaTimescale, targetTimescale) {
+  if (!Number.isSafeInteger(mediaTimescale) || mediaTimescale <= 0 || !Number.isSafeInteger(targetTimescale) || targetTimescale <= 0) return null;
+  const negative = ticks < 0n;
+  const numerator = (negative ? -ticks : ticks) * BigInt(targetTimescale);
+  const denominator = BigInt(mediaTimescale);
+  const whole = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (whole > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+  const value = Number(whole) + Number(remainder) / mediaTimescale;
+  return Number.isFinite(value) ? negative ? -value : value : null;
+}
+function scaleAuthoredTiming(timing, targetTimescale) {
+  if (!Number.isSafeInteger(timing.durationTicks) || timing.durationTicks <= 0) return null;
+  const timestamp = scaleAuthoredTicks(
+    timing.presentationTime,
+    timing.mediaTimescale,
+    targetTimescale
+  );
+  const duration = scaleAuthoredTicks(
+    BigInt(timing.durationTicks),
+    timing.mediaTimescale,
+    targetTimescale
+  );
+  if (timestamp === null || duration === null || duration <= 0) return null;
+  return { timestamp, duration };
+}
+
+// src/cmaf-block-assembler.ts
+var INT32_MIN2 = -2147483648;
+var INT32_MAX2 = 2147483647;
+var CmafBlockAssembler = class {
+  constructor(config) {
+    this.#pendingRecovered = /* @__PURE__ */ new Map();
+    this.#sequence = 1;
+    this.#baseTs = -1;
+    /**
+     * Last decoder-proven audio AU, repeated into slots a gap decision names.
+     * It is noted and planned on the AU's authored clock (`AuthoredTiming`
+     * ticks), never on this assembler's CMAF timescale: on the default
+     * 1_000_000 an AAC AU is 1024e6 / sampleRate µs, which is not an integer.
+     */
+    this.#audioConcealer = new AudioGapConcealer();
+    /**
+     * Media timescale of the AU the concealer holds; `'untimed'` when the last
+     * emitted audio AU carried no authored timing, `null` before any AU.
+     */
+    this.#audioConcealClock = null;
+    this.#audioConcealStats = {
+      repeatedUnits: 0,
+      reanchoredGaps: 0,
+      untimedGaps: 0
+    };
+    this.#lastEmittedTs = -1;
+    this.#lastSourceTs = -1;
+    this.#sampleReorderWindow = 0;
+    this.#sampleOrder = { mode: "arrival" };
+    this.#sampleOrderCapacity = 0;
+    this.#sampleReorderQueue = [];
+    this.#recoveredHorizonTs = -1;
+    this.#sampleOrderStats = {
+      staleSamples: 0,
+      duplicateSamples: 0,
+      preRapDeadlineDrops: 0,
+      noRapFlushDrops: 0,
+      forcedReleases: 0,
+      unadmittedAuthoredSamples: 0,
+      unreadableVideoSamples: 0
+    };
+    /** Codec family whose bitstream keyframe rule overrides the metadata flag
+     *  (AVC IDR, HEVC IRAP), or null when the bitstream is not validated. */
+    this.#videoKeyframeFamily = null;
+    /** HEVC sample entry chosen from the catalog codec string. */
+    this.#hevcSampleEntry = null;
+    this.#keyframeRejectDumpCount = 0;
+    /** Callback: emits a complete moof+mdat CMAF segment */
+    this.onSegment = null;
+    /** Callback: emits a gated/deduped raw sample for callers that already own the MSE timeline. */
+    this.onSample = null;
+    /** Callback: emits an init segment (ftyp+moov) */
+    this.onInitSegment = null;
+    // Video keyframe gate (BLO-3035 layer 3): Chrome's CHUNK_DEMUXER rejects a
+    // moof+mdat whose first sample is non-sync with no prior reference frames
+    // ("CHUNK_DEMUXER_ERROR_APPEND_FAILED: Failed to prepare video sample for
+    // decode") and detaches the SourceBuffer for the rest of the session.
+    // Mid-stream join almost guarantees the first FEC blocks are mid-GOP — all
+    // delta frames. Gate emission until the first block containing an IDR;
+    // within that block, splice samples to start at the IDR index. Audio passes
+    // unconditionally — valid for the codecs supported here (AAC, Opus) where
+    // every frame is independently decodable. SBR-only AAC, USAC, or HE-AAC v2
+    // with PCE re-entry would need a similar gate.
+    this.#armedVideo = false;
+    // Cumulative emit counters (see emitStats). They replace the BLO-3035 L4
+    // diagnostics, which hashed and hex-dumped every video keyframe and ran a
+    // 1 s setInterval console aggregate on the MSE path (BLO-36599).
+    this.#emitStats = {
+      emits: 0,
+      samples: 0,
+      keyframes: 0,
+      addedFrames: 0,
+      recoveredBlocks: 0,
+      completedBlocks: 0,
+      failedBlocks: 0
+    };
+    this.#config = {
+      k: config.k,
+      timescale: config.timescale ?? 1e6,
+      trackId: config.trackId ?? 1,
+      trackType: config.trackType,
+      admitAuthoredTiming: config.admitAuthoredTiming ?? true
+    };
+    if (config.fps && config.fps > 0) {
+      this.#frameDuration = Math.round(this.#config.timescale / config.fps);
+    } else if (config.trackType === "audio" && config.sampleRate) {
+      this.#frameDuration = Math.round(this.#config.timescale * 1024 / config.sampleRate);
+    } else {
+      this.#frameDuration = 33333;
+    }
+    const sampleReorderWindow = config.sampleReorderWindow ?? 0;
+    if (!Number.isFinite(sampleReorderWindow) || sampleReorderWindow < 0) {
+      throw new Error("[CmafBlockAssembler] sampleReorderWindow must be finite and non-negative");
+    }
+    if (config.sampleOrder && sampleReorderWindow > 0) {
+      throw new Error("[CmafBlockAssembler] configure sampleOrder or sampleReorderWindow, not both");
+    }
+    this.#sampleReorderWindow = Math.floor(sampleReorderWindow);
+    this.#sampleOrder = config.sampleOrder ?? { mode: "arrival" };
+    if (this.#sampleOrder.mode === "media-window") {
+      const { deliveryWindow, timestampWrapPeriod } = this.#sampleOrder;
+      if (!Number.isSafeInteger(deliveryWindow) || deliveryWindow <= 0) {
+        throw new Error(
+          "[CmafBlockAssembler] media-window deliveryWindow must be a positive safe integer"
+        );
+      }
+      if (timestampWrapPeriod !== void 0 && (!Number.isSafeInteger(timestampWrapPeriod) || timestampWrapPeriod <= deliveryWindow * 2)) {
+        throw new Error(
+          "[CmafBlockAssembler] timestampWrapPeriod must be a safe integer larger than two delivery windows"
+        );
+      }
+      const samplesPerSecond = config.trackType === "audio" && config.sampleRate ? config.sampleRate / 1024 : config.fps;
+      if (!samplesPerSecond || !Number.isFinite(samplesPerSecond) || samplesPerSecond <= 0) {
+        throw new Error(
+          "[CmafBlockAssembler] media-window ordering requires catalog-derived media cadence"
+        );
+      }
+      this.#sampleOrderCapacity = Math.ceil(deliveryWindow * samplesPerSecond / this.#config.timescale) + 1;
+    }
+    const videoSampleEntry = config.trackType === "video" ? resolveVideoSampleEntry(config) : null;
+    this.#videoKeyframeFamily = videoSampleEntry === null ? null : videoSampleEntry === "unvalidated" ? null : videoCodecFamily(videoSampleEntry);
+    this.#hevcSampleEntry = videoSampleEntry === "hev1" || videoSampleEntry === "hvc1" ? videoSampleEntry : null;
+    if (config.trackType === "video") {
+      console.log(
+        `[L4-KF-CONFIG] validate=${this.#videoKeyframeFamily ?? false} codec=${config.codec ?? ""} avcC=${config.avcC?.length ?? 0} hvcC=${config.hvcC?.length ?? 0}`
+      );
+    }
+    this._videoConfig = config.trackType === "video" && config.avcC ? { avcC: config.avcC, width: config.width ?? 0, height: config.height ?? 0 } : config.trackType === "video" && config.hvcC && this.#hevcSampleEntry ? {
+      hvcC: config.hvcC,
+      hevcSampleEntry: this.#hevcSampleEntry,
+      width: config.width ?? 0,
+      height: config.height ?? 0
+    } : null;
+    this._audioConfig = config.trackType === "audio" && config.sampleRate && config.channels ? { sampleRate: config.sampleRate, channels: config.channels, asc: config.asc } : null;
+  }
+  #config;
+  #pendingRecovered;
+  #sequence;
+  #baseTs;
+  #audioConcealer;
+  #audioConcealClock;
+  #audioConcealStats;
+  #frameDuration;
+  #lastEmittedTs;
+  #lastSourceTs;
+  #sampleReorderWindow;
+  #sampleOrder;
+  #sampleOrderCapacity;
+  #sampleReorderQueue;
+  #recoveredHorizonTs;
+  #sampleOrderStats;
+  #videoKeyframeFamily;
+  #hevcSampleEntry;
+  #keyframeRejectDumpCount;
+  #armedVideo;
+  /** Truncate `frames` to start at the first keyframe for video tracks before
+   *  the first emission. Returns the (possibly spliced) frames, or null to
+   *  drop the block entirely. Audio + already-armed video: identity. */
+  #applyVideoKeyframeGate(frames) {
+    const keyedFrames = this.#normalizeVideoKeyframes(frames);
+    if (this.#config.trackType !== "video" || this.#armedVideo) return keyedFrames;
+    const firstKfIdx = keyedFrames.findIndex((f) => f.keyframe);
+    if (firstKfIdx < 0) return null;
+    return firstKfIdx === 0 ? keyedFrames : keyedFrames.slice(firstKfIdx);
+  }
+  #normalizeVideoKeyframes(frames) {
+    if (this.#config.trackType !== "video" || this.#videoKeyframeFamily === null) return frames;
+    const out = [];
+    for (const frame of frames) {
+      const effective = this.#withEffectiveVideoKeyframe(frame);
+      if (effective !== null) out.push(effective);
+    }
+    return out;
+  }
+  /** The frame with its bitstream keyframe (and, for HEVC, mdat framing);
+   *  null when the frame is refused and must not be emitted. */
+  #withEffectiveVideoKeyframe(frame) {
+    if (this.#config.trackType !== "video" || this.#videoKeyframeFamily === null) return frame;
+    if (this.#videoKeyframeFamily === "hevc") {
+      const prepared = prepareHevcCmafSample(frame.data, this.#hevcSampleEntry);
+      if (prepared === null) {
+        this.#sampleOrderStats.unreadableVideoSamples++;
+        return null;
+      }
+      const { keyframe: keyframe2, data } = prepared;
+      if (!keyframe2) this.#dumpRejectedVideoKeyframe(frame.data, frame.keyframe);
+      return keyframe2 === frame.keyframe && data === frame.data ? frame : { ...frame, keyframe: keyframe2, data };
+    }
+    const keyframe = detectH264Keyframe(frame.data);
+    if (!keyframe) this.#dumpRejectedVideoKeyframe(frame.data, frame.keyframe);
+    return keyframe === frame.keyframe ? frame : { ...frame, keyframe };
+  }
+  #dumpRejectedVideoKeyframe(data, metadataKeyframe) {
+    if (this.#keyframeRejectDumpCount >= 12) return;
+    this.#keyframeRejectDumpCount++;
+    if (this.#videoKeyframeFamily === "hevc") {
+      const nals = isCompleteAvccSample(data) ? splitAvccNalUnits(data) : isAnnexB(data) ? splitAnnexBNalUnits(data) : [];
+      console.log(
+        `[L4-KF-GATE] reject#${this.#keyframeRejectDumpCount} len=${data.length} metadataKf=${metadataKeyframe} family=hevc nalTypes=[${nals.slice(0, 16).map((nal) => nal.length >= 2 ? hevcNalUnitType(nal) : -1).join(",")}]`
+      );
+      return;
+    }
+    const sample = splitH264SampleNalUnits(data);
+    const nalTypes = describeH264NalTypes(sample.nals);
+    const classify = classifyH264Keyframe(data);
+    const hex = Array.from(data.subarray(0, Math.min(48, data.length))).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+    console.log(
+      `[L4-KF-GATE] reject#${this.#keyframeRejectDumpCount} len=${data.length} metadataKf=${metadataKeyframe} classify=${classify} format=${sample.format} nalTypes=[${nalTypes.join(",")}] first48=[${hex}]`
+    );
+  }
+  /** Mark video as already synchronized by an external decoder path.
+   *  Used by MoQ→multicast MSE continuity when MoQ has already appended a
+   *  keyframe to the same SourceBuffer timeline before multicast takeover. */
+  markVideoSynced() {
+    if (this.#config.trackType === "video") this.#armedVideo = true;
+  }
+  /** Emit each frame as its own single-sample moof+mdat segment. Matches the
+   *  case-20 path (`MmtpToCmaf.wrapVideoSample` → `encodeDataSegment`) byte-
+   *  for-byte per frame. Working hypothesis (pending Chromium-source
+   *  validation against `media/filters/chunk_demuxer.cc`):
+   *  `encodeMultiSampleSegment` blobs are accepted by ChunkDemuxer in this
+   *  pipeline but only the first sample renders for live, possibly because
+   *  the pipeline expects per-frame moof boundaries. Track in BLO-3035.
+   *
+   *  Stale-tfdt defense-in-depth: drops any frame whose timestamp is older
+   *  than `#lastEmittedTs`. The SBN watermark already prevents out-of-order
+   *  FEC-block emissions, but `addBypassFrame` (oversized MFU / no-FEC path)
+   *  doesn't touch the watermark — a bypass frame at t=T followed by a FEC
+   *  block whose frames precede T would otherwise inject earlier tfdt and
+   *  detach the SourceBuffer. */
+  #ordersSamples() {
+    return this.#sampleOrder.mode === "media-window" || this.#sampleReorderWindow > 0;
+  }
+  #unwrapTimestamp(timestamp) {
+    const wrapPeriod = this.#sampleOrder.mode === "media-window" ? this.#sampleOrder.timestampWrapPeriod : void 0;
+    if (!wrapPeriod) return timestamp;
+    const reference = this.#lastSourceTs >= 0 ? this.#lastSourceTs : this.#recoveredHorizonTs >= 0 ? this.#recoveredHorizonTs : this.#lastEmittedTs;
+    if (reference < 0) return timestamp;
+    return timestamp + Math.round((reference - timestamp) / wrapPeriod) * wrapPeriod;
+  }
+  #emitSample(data, timestamp, duration, keyframe, advancesHorizon, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber, synthetic, gapBefore) {
+    if (authoredTiming !== void 0 && !this.#config.admitAuthoredTiming) {
+      this.#sampleOrderStats.unadmittedAuthoredSamples++;
+      return;
+    }
+    const scaledTiming = authoredTiming === void 0 ? null : scaleAuthoredTiming(authoredTiming, this.#config.timescale);
+    if (authoredTiming !== void 0 && scaledTiming === null) return;
+    const authoredTimestamp = scaledTiming?.timestamp ?? timestamp;
+    const authoredDuration = scaledTiming?.duration ?? duration;
+    let compositionTimeOffset;
+    if (authoredTiming !== void 0) {
+      const scaledOffset = scaleAuthoredTicks(
+        authoredTiming.presentationTime - authoredTiming.decodeTime,
+        authoredTiming.mediaTimescale,
+        this.#config.timescale
+      );
+      if (scaledOffset === null) return;
+      const roundedOffset = Math.round(scaledOffset);
+      if (!Number.isSafeInteger(roundedOffset) || roundedOffset < INT32_MIN2 || roundedOffset > INT32_MAX2) return;
+      compositionTimeOffset = roundedOffset;
+    }
+    const unwrappedTimestamp = this.#unwrapTimestamp(authoredTimestamp);
+    if (unwrappedTimestamp <= this.#lastEmittedTs) {
+      this.#sampleOrderStats.staleSamples++;
+      return;
+    }
+    const sample = this.#withEffectiveVideoKeyframe({
+      data,
+      timestamp: unwrappedTimestamp,
+      duration: authoredDuration,
+      keyframe,
+      ...mmtpTimestamp === void 0 ? {} : { mmtpTimestamp },
+      ...compositionTimeOffset === void 0 ? {} : { compositionTimeOffset },
+      advancesHorizon,
+      ...authoredTiming === void 0 ? {} : { authoredTiming },
+      ...packetSequenceNumber === void 0 ? {} : { packetSequenceNumber },
+      ...packetSequenceNumbers === void 0 ? {} : { packetSequenceNumbers },
+      ...repairedPacketSequenceNumbers === void 0 ? {} : { repairedPacketSequenceNumbers },
+      ...mpuSequenceNumber === void 0 ? {} : { mpuSequenceNumber },
+      ...movieFragmentSequenceNumber === void 0 ? {} : { movieFragmentSequenceNumber },
+      ...sampleNumber === void 0 ? {} : { sampleNumber },
+      ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+      ...deliveryProvenance === void 0 ? {} : { deliveryProvenance },
+      ...synthetic === void 0 ? {} : { synthetic },
+      ...gapBefore === void 0 ? {} : { gapBefore }
+    });
+    if (sample === null) return;
+    if (advancesHorizon && unwrappedTimestamp > this.#lastSourceTs) {
+      this.#lastSourceTs = unwrappedTimestamp;
+    } else if (!advancesHorizon && unwrappedTimestamp > this.#recoveredHorizonTs) {
+      this.#recoveredHorizonTs = unwrappedTimestamp;
+    }
+    if (this.#ordersSamples()) {
+      this.#queueSample(sample);
+      return;
+    }
+    this.#emitArrivalOrdered(sample);
+  }
+  #emitArrivalOrdered(sample) {
+    if (this.#config.trackType === "video" && !this.#armedVideo && !sample.keyframe) {
+      this.#sampleOrderStats.preRapDeadlineDrops++;
+      return;
+    }
+    this.#emitSampleNow(sample);
+  }
+  #queueSample(sample) {
+    if (this.#sampleReorderQueue.some((s) => s.timestamp === sample.timestamp)) {
+      this.#sampleOrderStats.duplicateSamples++;
+      return;
+    }
+    this.#sampleReorderQueue.push(sample);
+    this.#sampleReorderQueue.sort((a, b) => a.timestamp - b.timestamp);
+    this.#drainSampleReorder(false);
+    this.#enforceSampleOrderCapacity();
+  }
+  #releaseHorizon() {
+    return this.#lastSourceTs >= 0 ? this.#lastSourceTs : this.#recoveredHorizonTs;
+  }
+  #sampleIsReleasable(sample, flushAll) {
+    if (flushAll) return true;
+    if (this.#sampleOrder.mode === "media-window") {
+      const horizon = this.#releaseHorizon();
+      return horizon >= 0 && sample.timestamp < horizon - this.#sampleOrder.deliveryWindow;
+    }
+    return this.#sampleReorderQueue.length > this.#sampleReorderWindow;
+  }
+  #dropPreRapSamples(flushAll) {
+    if (this.#config.trackType !== "video" || this.#armedVideo) return false;
+    const firstRap = this.#sampleReorderQueue.findIndex(
+      (sample) => sample.keyframe && this.#sampleIsReleasable(sample, flushAll)
+    );
+    if (firstRap >= 0) {
+      if (firstRap > 0) {
+        this.#sampleOrderStats.preRapDeadlineDrops += firstRap;
+        this.#sampleReorderQueue.splice(0, firstRap);
+      }
+      return false;
+    }
+    let dropped = 0;
+    while (this.#sampleReorderQueue[0] && this.#sampleIsReleasable(this.#sampleReorderQueue[0], flushAll)) {
+      this.#sampleReorderQueue.shift();
+      dropped++;
+    }
+    if (flushAll) this.#sampleOrderStats.noRapFlushDrops += dropped;
+    else this.#sampleOrderStats.preRapDeadlineDrops += dropped;
+    return dropped > 0;
+  }
+  #drainSampleReorder(flushAll) {
+    while (this.#sampleReorderQueue.length > 0) {
+      if (this.#dropPreRapSamples(flushAll) && this.#sampleReorderQueue.length === 0) return;
+      const sample = this.#sampleReorderQueue[0];
+      if (!sample || !this.#sampleIsReleasable(sample, flushAll)) return;
+      this.#sampleReorderQueue.shift();
+      this.#emitQueuedSample(sample);
+    }
+  }
+  #emitQueuedSample(sample) {
+    const next = this.#sampleReorderQueue.find((s) => s.timestamp > sample.timestamp);
+    const duration = sample.authoredTiming ? sample.duration : next ? next.timestamp - sample.timestamp : sample.duration;
+    this.#emitSampleNow({
+      ...sample,
+      duration: duration > 0 ? duration : sample.authoredTiming ? sample.duration : this.#frameDuration
+    });
+  }
+  #enforceSampleOrderCapacity() {
+    if (this.#sampleOrder.mode !== "media-window") return;
+    while (this.#sampleReorderQueue.length > this.#sampleOrderCapacity) {
+      const sample = this.#sampleReorderQueue.shift();
+      if (!sample) return;
+      this.#sampleOrderStats.forcedReleases++;
+      console.warn(
+        `[CmafBlockAssembler] ${this.#config.trackType} media-window queue exceeded ${this.#sampleOrderCapacity} samples; force-releasing timestamp=${sample.timestamp}`
+      );
+      if (this.#config.trackType === "video" && !this.#armedVideo && !sample.keyframe) {
+        this.#sampleOrderStats.preRapDeadlineDrops++;
+        continue;
+      }
+      this.#emitQueuedSample(sample);
+    }
+  }
+  #emitSampleNow(sample) {
+    if (sample.timestamp <= this.#lastEmittedTs) {
+      this.#sampleOrderStats.staleSamples++;
+      return;
+    }
+    this.#concealAudioGapBefore(sample);
+    this.#writeSampleNow(sample, true);
+  }
+  #writeSampleNow(sample, rememberAudio) {
+    const { timestamp, duration, keyframe } = sample;
+    this.#lastEmittedTs = timestamp;
+    if (this.#config.trackType === "video" && keyframe) this.#armedVideo = true;
+    const data = this.#normalizeSampleData(sample.data);
+    if (this.#config.trackType === "audio" && rememberAudio && data.length > 0) {
+      this.#noteAudioAccessUnit(data, sample.authoredTiming);
+    }
+    if (this.onSample) {
+      this.onSample(data === sample.data ? sample : { ...sample, data });
+    } else {
+      const baseTime = this.#rebase(timestamp);
+      const segment = encodeDataSegment(
+        data,
+        baseTime,
+        duration,
+        keyframe,
+        this.#sequence++,
+        this.#config.trackId,
+        sample.compositionTimeOffset
+      );
+      this.onSegment?.(segment);
+    }
+  }
+  /**
+   * Record an emitted audio AU for concealment in its authored media ticks —
+   * the clock libmmt's `audio-gap` decision was computed in, where an AAC AU
+   * is exactly 1024 ticks. An AU with no authored timing has no exact clock,
+   * so nothing is held for it and a later `audio-gap` is counted as untimed.
+   */
+  #noteAudioAccessUnit(data, timing) {
+    if (timing === void 0) {
+      this.#audioConcealer.reset();
+      this.#audioConcealClock = "untimed";
+      return;
+    }
+    this.#audioConcealer.note({
+      payload: data,
+      pts: timing.presentationTime,
+      duration: timing.durationTicks
+    });
+    this.#audioConcealClock = timing.mediaTimescale;
+  }
+  /**
+   * Repeat the last good AU into exactly the slots an `audio-gap` decision
+   * names. A synthesised AAC access unit is not portable across every
+   * AudioSpecificConfig, so only known-good encoded audio is repeated; with
+   * no good AU yet, or on `audio-discontinuity`, the sink re-anchors at the
+   * next sample and nothing is written.
+   *
+   * The gap is sized in authored ticks and each slot is mapped onto this
+   * assembler's timescale by `scaleAuthoredTiming`, the conversion every
+   * source AU goes through, so a slot lands exactly where the AU it replaces
+   * would have. Nothing here can throw into the packet path: a gap that
+   * cannot be sized exactly is re-anchored and counted.
+   */
+  #concealAudioGapBefore(sample) {
+    const decision = sample.gapBefore;
+    if (this.#config.trackType !== "audio" || !decision || decision.trackKind !== "audio") return;
+    const timing = sample.authoredTiming;
+    const clock = this.#audioConcealClock;
+    if (timing === void 0 || clock === "untimed" || clock !== null && clock !== timing.mediaTimescale) {
+      if (decision.reason === "audio-gap") this.#audioConcealStats.untimedGaps++;
+      else this.#audioConcealStats.reanchoredGaps++;
+      return;
+    }
+    const plan = this.#audioConcealer.plan(decision, { pts: timing.presentationTime });
+    if (plan.kind !== "conceal") {
+      this.#audioConcealStats.reanchoredGaps++;
+      return;
+    }
+    for (const slot of plan.repeat) {
+      const scaled = scaleAuthoredTiming({
+        decodeTime: slot.pts,
+        presentationTime: slot.pts,
+        durationTicks: slot.duration,
+        mediaTimescale: timing.mediaTimescale
+      }, this.#config.timescale);
+      if (scaled === null) continue;
+      const slotTimestamp = this.#unwrapTimestamp(scaled.timestamp);
+      if (slotTimestamp <= this.#lastEmittedTs || slotTimestamp >= sample.timestamp) continue;
+      this.#writeSampleNow({
+        data: slot.payload.slice(),
+        timestamp: slotTimestamp,
+        duration: scaled.duration,
+        keyframe: true,
+        synthetic: true
+      }, false);
+      this.#audioConcealStats.repeatedUnits++;
+    }
+  }
+  #emitPerSample(frames, audioDurationOverride, advancesHorizon = false) {
+    for (let i = 0; i < frames.length; i++) {
+      const f = frames[i];
+      let duration;
+      if (this.#config.trackType === "audio") {
+        duration = audioDurationOverride ?? this.#frameDuration;
+      } else if (i < frames.length - 1) {
+        duration = frames[i + 1].timestamp - f.timestamp;
+      } else if (i > 0) {
+        duration = f.timestamp - frames[i - 1].timestamp;
+      } else {
+        duration = audioDurationOverride ?? this.#frameDuration;
+      }
+      if (duration <= 0) duration = audioDurationOverride ?? this.#frameDuration;
+      this.#emitSample(
+        f.data,
+        f.timestamp,
+        duration,
+        f.keyframe,
+        advancesHorizon,
+        f.catalogTrackName,
+        f.mpuSequenceNumber,
+        f.packetSequenceNumber,
+        f.packetSequenceNumbers,
+        f.repairedPacketSequenceNumbers,
+        f.authoredTiming,
+        f.deliveryProvenance,
+        f.mmtpTimestamp,
+        f.movieFragmentSequenceNumber,
+        f.sampleNumber,
+        f.synthetic,
+        f.gapBefore
+      );
+    }
+  }
+  #emitStats;
+  #countEmit(samples) {
+    this.#emitStats.emits++;
+    this.#emitStats.samples += samples.length;
+    for (const sample of samples) if (sample.keyframe) this.#emitStats.keyframes++;
+  }
+  get sampleOrderStats() {
+    return { ...this.#sampleOrderStats };
+  }
+  /** Cumulative emit and block-event counters since construction. */
+  get emitStats() {
+    return { ...this.#emitStats };
+  }
+  /** Cumulative audio gap concealment counters since construction. */
+  get audioConcealStats() {
+    return { ...this.#audioConcealStats };
+  }
+  /** Emit a single frame immediately as a one-sample moof+mdat segment.
+   *
+   *  BLO-3035 layer 4 (4b): the prior SBN-grouped buffering scheme stranded
+   *  frames whenever a multi-packet frame spanned FEC block boundaries —
+   *  intermediate SBNs had packets-but-no-frames and got `completeBlock`
+   *  events that landed on empty `#blocks` (→ `pendingFlush` leak), while
+   *  the SBN where the multi-packet frame finally completed received the
+   *  `addFrame` but its `trackBlock` count never reached K (→ `pendingBlocks`
+   *  leak). Result: ~50% of received frames never reached MSE.
+   *
+   *  This path now mirrors `addBypassFrame` — emit on arrival, no buffering.
+   *  FEC recovery (`addRecoveredBlock`) keeps its SBN-watermark dedup against
+   *  the same SBN being re-emitted from two paths. Out-of-order regression
+   *  is guarded by the per-frame `lastEmittedTs` check (also enforced in
+   *  `#emitPerSample`). The `sbn`/`esi` parameters are kept for the call-site
+   *  signature but no longer affect routing. */
+  addFrame(sbn, esi, data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber, gapBefore) {
+    void sbn;
+    void esi;
+    this.#emitStats.addedFrames++;
+    if (!this.#ordersSamples()) this.#drainRecoveredUpTo(timestamp);
+    this.#emitSample(
+      data,
+      timestamp,
+      this.#frameDuration,
+      keyframe,
+      true,
+      catalogTrackName,
+      mpuSequenceNumber,
+      packetSequenceNumber,
+      packetSequenceNumbers,
+      repairedPacketSequenceNumbers,
+      authoredTiming,
+      deliveryProvenance,
+      mmtpTimestamp,
+      movieFragmentSequenceNumber,
+      sampleNumber,
+      void 0,
+      gapBefore
+    );
+    this.#countEmit([{ keyframe }]);
+  }
+  /** Mark a block as complete (all K source symbols received or FEC recovery succeeded).
+   *  If all frames are already buffered, flushes immediately. Otherwise sets pending-flush. */
+  completeBlock(sbn) {
+    void sbn;
+    this.#emitStats.completedBlocks++;
+  }
+  /**
+   * Record an unrecoverable block. Nothing is synthesised: the release gate
+   * attaches the stall/conceal decision to the next released frame, and the
+   * sink holds the last good frame (video) or repeats the last good AU into
+   * the decided slots (audio).
+   */
+  failBlock(sbn) {
+    void sbn;
+    this.#emitStats.failedBlocks++;
+  }
+  /** Add all frames from a FEC-recovered block at once and emit immediately. */
+  addRecoveredBlock(sbn, frames) {
+    void sbn;
+    this.#emitStats.recoveredBlocks++;
+    if (frames.length === 0) return;
+    const normalized = this.#normalizeVideoKeyframes(frames);
+    if (normalized.length === 0) return;
+    this.#countEmit(normalized);
+    if (this.#ordersSamples()) {
+      this.#emitPerSample(normalized, void 0, false);
+      return;
+    }
+    if (this.#lastSourceTs >= 0) {
+      this.#enqueueRecovered(normalized);
+      this.#drainRecoveredUpTo(this.#lastSourceTs);
+    } else {
+      const gated = this.#applyVideoKeyframeGate(normalized);
+      if (gated) this.#emitPerSample(gated, void 0, false);
+    }
+  }
+  /** Emit a single frame immediately as a one-sample segment (for oversized packets bypassing FEC). */
+  addBypassFrame(data, timestamp, keyframe, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance, mmtpTimestamp, movieFragmentSequenceNumber, sampleNumber, gapBefore) {
+    if (!this.#ordersSamples()) this.#drainRecoveredUpTo(timestamp);
+    this.#emitSample(
+      data,
+      timestamp,
+      this.#frameDuration,
+      keyframe,
+      true,
+      catalogTrackName,
+      mpuSequenceNumber,
+      packetSequenceNumber,
+      packetSequenceNumbers,
+      repairedPacketSequenceNumbers,
+      authoredTiming,
+      deliveryProvenance,
+      mmtpTimestamp,
+      movieFragmentSequenceNumber,
+      sampleNumber,
+      void 0,
+      gapBefore
+    );
+  }
+  /** Build and emit init segment from catalog config. */
+  emitInit() {
+    let init = null;
+    if (this._videoConfig?.avcC) {
+      init = buildVideoInitSegment(
+        this._videoConfig.avcC,
+        this._videoConfig.width,
+        this._videoConfig.height,
+        this.#config.timescale,
+        this.#config.trackId
+      );
+    } else if (this._videoConfig?.hvcC && this._videoConfig.hevcSampleEntry) {
+      init = buildHevcVideoInitSegment(
+        this._videoConfig.hevcSampleEntry,
+        this._videoConfig.hvcC,
+        this._videoConfig.width,
+        this._videoConfig.height,
+        this.#config.timescale,
+        this.#config.trackId
+      );
+    } else if (this._audioConfig) {
+      init = buildAudioInitSegment(
+        this._audioConfig.sampleRate,
+        this._audioConfig.channels,
+        this._audioConfig.asc,
+        this.#config.timescale,
+        this.#config.trackId
+      );
+    }
+    if (init) this.onInitSegment?.(init);
+  }
+  /** Drain all ordered samples at end-of-stream or before reconfiguration. */
+  flush() {
+    if (this.#ordersSamples()) {
+      this.#drainSampleReorder(true);
+      return;
+    }
+    if (this.#pendingRecovered.size === 0) return;
+    const frames = [...this.#pendingRecovered.values()].sort((a, b) => a.timestamp - b.timestamp);
+    this.#pendingRecovered.clear();
+    const gated = this.#applyVideoKeyframeGate(frames);
+    if (gated) this.#emitPerSample(gated, void 0, false);
+    else if (this.#config.trackType === "video") {
+      this.#sampleOrderStats.noRapFlushDrops += frames.length;
+    }
+  }
+  /** Drop all queued state and begin a fresh timestamp epoch. */
+  reset() {
+    this.#pendingRecovered.clear();
+    this.#sequence = 1;
+    this.#baseTs = -1;
+    this.#lastEmittedTs = -1;
+    this.#lastSourceTs = -1;
+    this.#recoveredHorizonTs = -1;
+    this.#audioConcealer.reset();
+    this.#audioConcealClock = null;
+    this.#armedVideo = false;
+    this.#sampleReorderQueue = [];
+  }
+  dispose() {
+    this.reset();
+    this.onSegment = null;
+    this.onSample = null;
+    this.onInitSegment = null;
+  }
+  // ── Private ──
+  /** Rebase an absolute timestamp to relative media time (starting near 0). */
+  #rebase(timestamp) {
+    if (this.#baseTs < 0) this.#baseTs = timestamp;
+    return timestamp - this.#baseTs;
+  }
+  #normalizeSampleData(data) {
+    return this.#config.trackType === "audio" ? normalizeAacSampleForCmaf(data) : data;
+  }
+  #enqueueRecovered(frames) {
+    for (const frame of frames) {
+      if (this.#lastEmittedTs >= 0 && frame.timestamp <= this.#lastEmittedTs) {
+        this.#sampleOrderStats.staleSamples++;
+        continue;
+      }
+      if (this.#pendingRecovered.has(frame.timestamp)) {
+        this.#sampleOrderStats.duplicateSamples++;
+        continue;
+      }
+      this.#pendingRecovered.set(frame.timestamp, frame);
+    }
+  }
+  #drainRecoveredUpTo(horizonTs) {
+    if (this.#pendingRecovered.size === 0) return;
+    const ready = [...this.#pendingRecovered.values()].filter((frame) => frame.timestamp <= horizonTs).sort((a, b) => a.timestamp - b.timestamp);
+    for (const frame of ready) {
+      this.#pendingRecovered.delete(frame.timestamp);
+      this.#emitSample(
+        frame.data,
+        frame.timestamp,
+        this.#frameDuration,
+        frame.keyframe,
+        false,
+        frame.catalogTrackName,
+        frame.mpuSequenceNumber,
+        frame.packetSequenceNumber,
+        frame.packetSequenceNumbers,
+        frame.repairedPacketSequenceNumbers,
+        frame.authoredTiming,
+        frame.deliveryProvenance,
+        frame.mmtpTimestamp,
+        frame.movieFragmentSequenceNumber,
+        frame.sampleNumber,
+        frame.synthetic,
+        frame.gapBefore
+      );
+      this.#countEmit([frame]);
+    }
+  }
+};
+function resolveVideoSampleEntry(config) {
+  if (!config.codec) {
+    if (config.hvcC) {
+      throw new Error("[CmafBlockAssembler] hvcC requires a catalog codec string naming hev1 or hvc1");
+    }
+    return "avc1";
+  }
+  const fourCc = config.codec.split(".")[0];
+  if (fourCc !== "avc1" && fourCc !== "avc3" && fourCc !== "hev1" && fourCc !== "hvc1") {
+    if (config.avcC || config.hvcC) {
+      throw new Error(`[CmafBlockAssembler] codec ${config.codec} contradicts the supplied avcC/hvcC`);
+    }
+    return "unvalidated";
+  }
+  const sampleEntry = videoSampleEntryFromCodecString(config.codec);
+  const family = videoCodecFamily(sampleEntry);
+  if (family === "avc" && config.hvcC || family === "hevc" && config.avcC) {
+    throw new Error(`[CmafBlockAssembler] codec ${config.codec} contradicts the supplied avcC/hvcC`);
+  }
+  return sampleEntry;
+}
+function describeH264NalTypes(nals) {
+  return nals.slice(0, 16).map((nal) => nal[0] !== void 0 ? nal[0] & 31 : -1);
+}
+export {
+  CmafBlockAssembler
+};
+//# sourceMappingURL=cmaf-block-assembler.js.map