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

package/dist/cmaf-block-assembler.js

@@ -0,0 +1,1755 @@
+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);
+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 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 generateGreenFillNAL(avcC, width, height) {
+  if (avcC.length < 8) return new Uint8Array(0);
+  const lengthSize = (avcC[4] & 3) + 1;
+  let offset = 5;
+  const numSPS = avcC[offset++] & 31;
+  const nals = [];
+  for (let i = 0; i < numSPS; i++) {
+    if (offset + 2 > avcC.length) break;
+    const spsLen = avcC[offset] << 8 | avcC[offset + 1];
+    offset += 2;
+    if (offset + spsLen > avcC.length) break;
+    const sps = avcC.subarray(offset, offset + spsLen);
+    const framed = new Uint8Array(4 + sps.length);
+    new DataView(framed.buffer).setUint32(0, sps.length);
+    framed.set(sps, 4);
+    nals.push(framed);
+    offset += spsLen;
+  }
+  if (offset < avcC.length) {
+    const numPPS = avcC[offset++];
+    for (let i = 0; i < numPPS; i++) {
+      if (offset + 2 > avcC.length) break;
+      const ppsLen = avcC[offset] << 8 | avcC[offset + 1];
+      offset += 2;
+      if (offset + ppsLen > avcC.length) break;
+      const pps = avcC.subarray(offset, offset + ppsLen);
+      const framed = new Uint8Array(4 + pps.length);
+      new DataView(framed.buffer).setUint32(0, pps.length);
+      framed.set(pps, 4);
+      nals.push(framed);
+      offset += ppsLen;
+    }
+  }
+  const mbWidth = Math.ceil(width / 16);
+  const mbHeight = Math.ceil(height / 16);
+  const totalMBs = mbWidth * mbHeight;
+  const idrSlice = new Uint8Array([
+    101,
+    // nal_ref_idc=3, nal_type=5 (IDR)
+    136,
+    // slice header: first_mb_in_slice=0, slice_type=7 (I)
+    128,
+    // pps_id=0, frame_num=0, idr_pic_id=0
+    64
+    // slice data: mb_skip_run covering remaining MBs
+    // Truncated — decoder will error-conceal remaining MBs as green/gray
+  ]);
+  const idrFramed = new Uint8Array(4 + idrSlice.length);
+  new DataView(idrFramed.buffer).setUint32(0, idrSlice.length);
+  idrFramed.set(idrSlice, 4);
+  nals.push(idrFramed);
+  let totalLen = 0;
+  for (const n of nals) totalLen += n.length;
+  const result = new Uint8Array(totalLen);
+  let p = 0;
+  for (const n of nals) {
+    result.set(n, p);
+    p += n.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) {
+  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 avcCBox = box("avcC", avcC);
+  const avc1Body = new Uint8Array(78 + avcCBox.length);
+  const avc1View = new DataView(avc1Body.buffer);
+  avc1View.setUint16(6, 1);
+  avc1View.setUint16(24, width);
+  avc1View.setUint16(26, height);
+  avc1View.setUint32(28, 4718592);
+  avc1View.setUint32(32, 4718592);
+  avc1View.setUint16(40, 1);
+  avc1View.setUint16(74, 24);
+  avc1View.setInt16(76, -1);
+  avc1Body.set(avcCBox, 78);
+  const avc1 = box("avc1", avc1Body);
+  const stsd = fullBox("stsd", 0, 0, u32(1), avc1);
+  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), 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;
+  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/codec-utils.ts
+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 && i + 1 < rbsp.length && rbsp[i + 1] <= 3) {
+      zeros = 0;
+      continue;
+    }
+    out.push(b);
+    zeros = b === 0 ? zeros + 1 : 0;
+  }
+  return Uint8Array.from(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 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]);
+      const sps = new Uint8Array([66, 1, 1, 1, 96, 0, 0, 0, 144, 0, 0, 0, 0, 0, 60, 160, 5, 2]);
+      const pps = new Uint8Array([68, 1, 193, 114, 180, 98]);
+      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 _config, _blocks, _pendingFlush, _pendingRecovered, _sequence, _baseTs, _fillFrame, _lastDecodableAudioFrame, _frameDuration, _lastEmittedTs, _lastSourceTs, _sampleReorderWindow, _sampleOrder, _sampleOrderCapacity, _sampleReorderQueue, _recoveredHorizonTs, _sampleOrderStats, _validateH264Keyframes, _keyframeRejectDumpCount, _armedVideo, _lastEmittedSbn, _CmafBlockAssembler_instances, claimSbnEmission_fn, applyVideoKeyframeGate_fn, normalizeVideoKeyframes_fn, withEffectiveVideoKeyframe_fn, dumpRejectedVideoKeyframe_fn, ordersSamples_fn, unwrapTimestamp_fn, emitSample_fn, emitArrivalOrdered_fn, queueSample_fn, releaseHorizon_fn, sampleIsReleasable_fn, dropPreRapSamples_fn, drainSampleReorder_fn, emitQueuedSample_fn, enforceSampleOrderCapacity_fn, emitSampleNow_fn, writeSampleNow_fn, emitAudioGapFillNowBefore_fn, emitPerSample_fn, _dumpCount, _emitCount, _sampleCount, _keyframeCount, _addFrameCount, _recoveredBlockCount, _completeBlockCount, _failBlockCount, _aggregateTimer, startAggregateTimer_fn, dumpEmit_fn, rebase_fn, normalizeSampleData_fn, enqueueRecovered_fn, drainRecoveredUpTo_fn, flushBlock_fn, flushBlockWithFill_fn;
+var CmafBlockAssembler = class {
+  constructor(config) {
+    __privateAdd(this, _CmafBlockAssembler_instances);
+    __privateAdd(this, _config);
+    __privateAdd(this, _blocks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _pendingFlush, /* @__PURE__ */ new Set());
+    __privateAdd(this, _pendingRecovered, /* @__PURE__ */ new Map());
+    __privateAdd(this, _sequence, 1);
+    __privateAdd(this, _baseTs, -1);
+    __privateAdd(this, _fillFrame);
+    __privateAdd(this, _lastDecodableAudioFrame, null);
+    __privateAdd(this, _frameDuration);
+    __privateAdd(this, _lastEmittedTs, -1);
+    __privateAdd(this, _lastSourceTs, -1);
+    __privateAdd(this, _sampleReorderWindow, 0);
+    __privateAdd(this, _sampleOrder, { mode: "arrival" });
+    __privateAdd(this, _sampleOrderCapacity, 0);
+    __privateAdd(this, _sampleReorderQueue, []);
+    __privateAdd(this, _recoveredHorizonTs, -1);
+    __privateAdd(this, _sampleOrderStats, {
+      staleSamples: 0,
+      duplicateSamples: 0,
+      preRapDeadlineDrops: 0,
+      noRapFlushDrops: 0,
+      forcedReleases: 0
+    });
+    __privateAdd(this, _validateH264Keyframes, false);
+    __privateAdd(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.
+    __privateAdd(this, _armedVideo, false);
+    // Legacy SBN emission watermark for the old block-buffered path. Direct
+    // source emission is now timestamp-ordered instead; recovered frames are
+    // queued by media timestamp so they can fill gaps without racing ahead of
+    // source frames.
+    __privateAdd(this, _lastEmittedSbn, -1);
+    // [BLO-3035-LAYER4-DIAG] Byte-dump for the first 6 video emits + 1Hz
+    // aggregate counters that survive the whole run. The counters tell us
+    // whether "emits=low" (assembler emits too few segments) or
+    // "addFrame=low" (parser delivers too few frames) — which routes the
+    // root-cause hunt to assembler vs router vs publisher.
+    __privateAdd(this, _dumpCount, 0);
+    __privateAdd(this, _emitCount, 0);
+    __privateAdd(this, _sampleCount, 0);
+    __privateAdd(this, _keyframeCount, 0);
+    __privateAdd(this, _addFrameCount, 0);
+    __privateAdd(this, _recoveredBlockCount, 0);
+    __privateAdd(this, _completeBlockCount, 0);
+    __privateAdd(this, _failBlockCount, 0);
+    __privateAdd(this, _aggregateTimer, null);
+    __privateSet(this, _config, {
+      k: config.k,
+      timescale: config.timescale ?? 1e6,
+      trackId: config.trackId ?? 1,
+      trackType: config.trackType
+    });
+    if (config.fps && config.fps > 0) {
+      __privateSet(this, _frameDuration, Math.round(__privateGet(this, _config).timescale / config.fps));
+    } else if (config.trackType === "audio" && config.sampleRate) {
+      __privateSet(this, _frameDuration, Math.round(__privateGet(this, _config).timescale * 1024 / config.sampleRate));
+    } else {
+      __privateSet(this, _frameDuration, 33333);
+    }
+    if (config.trackType === "video" && config.avcC && config.width && config.height) {
+      __privateSet(this, _fillFrame, generateGreenFillNAL(config.avcC, config.width, config.height));
+    } else {
+      __privateSet(this, _fillFrame, new Uint8Array(0));
+    }
+    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");
+    }
+    __privateSet(this, _sampleReorderWindow, Math.floor(sampleReorderWindow));
+    __privateSet(this, _sampleOrder, config.sampleOrder ?? { mode: "arrival" });
+    if (__privateGet(this, _sampleOrder).mode === "media-window") {
+      const { deliveryWindow, timestampWrapPeriod } = __privateGet(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"
+        );
+      }
+      __privateSet(this, _sampleOrderCapacity, Math.ceil(deliveryWindow * samplesPerSecond / __privateGet(this, _config).timescale) + 1);
+    }
+    __privateSet(this, _validateH264Keyframes, config.trackType === "video" && (!!config.avcC || !config.codec || isH264Codec(config.codec)));
+    if (config.trackType === "video") {
+      console.log(
+        `[L4-KF-CONFIG] validate=${__privateGet(this, _validateH264Keyframes)} codec=${config.codec ?? ""} avcC=${config.avcC?.length ?? 0}`
+      );
+    }
+    this._videoConfig = config.trackType === "video" && config.avcC ? { avcC: config.avcC, 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;
+  }
+  /** 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 (__privateGet(this, _config).trackType === "video") __privateSet(this, _armedVideo, true);
+  }
+  get sampleOrderStats() {
+    return { ...__privateGet(this, _sampleOrderStats) };
+  }
+  /** 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) {
+    void sbn;
+    void esi;
+    __privateWrapper(this, _addFrameCount)._++;
+    __privateMethod(this, _CmafBlockAssembler_instances, startAggregateTimer_fn).call(this);
+    if (!__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) __privateMethod(this, _CmafBlockAssembler_instances, drainRecoveredUpTo_fn).call(this, timestamp);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "addFrame-direct", [{ data, timestamp, 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;
+    __privateWrapper(this, _completeBlockCount)._++;
+    __privateMethod(this, _CmafBlockAssembler_instances, startAggregateTimer_fn).call(this);
+  }
+  /** Handle block timeout — emit whatever frames we have + fill for missing slots. */
+  failBlock(sbn) {
+    __privateWrapper(this, _failBlockCount)._++;
+    __privateMethod(this, _CmafBlockAssembler_instances, startAggregateTimer_fn).call(this);
+    __privateGet(this, _pendingFlush).delete(sbn);
+    const block = __privateGet(this, _blocks).get(sbn);
+    if (!block || block.size === 0) {
+      __privateGet(this, _blocks).delete(sbn);
+      return;
+    }
+    __privateMethod(this, _CmafBlockAssembler_instances, flushBlockWithFill_fn).call(this, sbn);
+  }
+  /** Add all frames from a FEC-recovered block at once and emit immediately. */
+  addRecoveredBlock(sbn, frames) {
+    void sbn;
+    __privateWrapper(this, _recoveredBlockCount)._++;
+    __privateMethod(this, _CmafBlockAssembler_instances, startAggregateTimer_fn).call(this);
+    __privateGet(this, _pendingFlush).delete(sbn);
+    __privateGet(this, _blocks).delete(sbn);
+    if (frames.length === 0) return;
+    const normalized = __privateMethod(this, _CmafBlockAssembler_instances, normalizeVideoKeyframes_fn).call(this, frames);
+    __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "addRecoveredBlock", normalized, sbn);
+    if (__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) {
+      __privateMethod(this, _CmafBlockAssembler_instances, emitPerSample_fn).call(this, normalized, void 0, false);
+      return;
+    }
+    if (__privateGet(this, _lastSourceTs) >= 0) {
+      __privateMethod(this, _CmafBlockAssembler_instances, enqueueRecovered_fn).call(this, normalized);
+      __privateMethod(this, _CmafBlockAssembler_instances, drainRecoveredUpTo_fn).call(this, __privateGet(this, _lastSourceTs));
+    } else {
+      const gated = __privateMethod(this, _CmafBlockAssembler_instances, applyVideoKeyframeGate_fn).call(this, normalized);
+      if (gated) __privateMethod(this, _CmafBlockAssembler_instances, emitPerSample_fn).call(this, 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) {
+    if (!__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) __privateMethod(this, _CmafBlockAssembler_instances, drainRecoveredUpTo_fn).call(this, timestamp);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, data, timestamp, __privateGet(this, _frameDuration), keyframe, true, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance);
+  }
+  /** 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,
+        __privateGet(this, _config).timescale,
+        __privateGet(this, _config).trackId
+      );
+    } else if (this._audioConfig) {
+      init = buildAudioInitSegment(
+        this._audioConfig.sampleRate,
+        this._audioConfig.channels,
+        this._audioConfig.asc,
+        __privateGet(this, _config).timescale,
+        __privateGet(this, _config).trackId
+      );
+    }
+    if (init) this.onInitSegment?.(init);
+  }
+  /** Drain all ordered samples at end-of-stream or before reconfiguration. */
+  flush() {
+    if (__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) {
+      __privateMethod(this, _CmafBlockAssembler_instances, drainSampleReorder_fn).call(this, true);
+      return;
+    }
+    if (__privateGet(this, _pendingRecovered).size === 0) return;
+    const frames = [...__privateGet(this, _pendingRecovered).values()].sort((a, b) => a.timestamp - b.timestamp);
+    __privateGet(this, _pendingRecovered).clear();
+    const gated = __privateMethod(this, _CmafBlockAssembler_instances, applyVideoKeyframeGate_fn).call(this, frames);
+    if (gated) __privateMethod(this, _CmafBlockAssembler_instances, emitPerSample_fn).call(this, gated, void 0, false);
+    else if (__privateGet(this, _config).trackType === "video") {
+      __privateGet(this, _sampleOrderStats).noRapFlushDrops += frames.length;
+    }
+  }
+  /** Drop all queued state and begin a fresh timestamp epoch. */
+  reset() {
+    __privateGet(this, _blocks).clear();
+    __privateGet(this, _pendingFlush).clear();
+    __privateGet(this, _pendingRecovered).clear();
+    __privateSet(this, _sequence, 1);
+    __privateSet(this, _baseTs, -1);
+    __privateSet(this, _lastEmittedTs, -1);
+    __privateSet(this, _lastSourceTs, -1);
+    __privateSet(this, _recoveredHorizonTs, -1);
+    __privateSet(this, _lastDecodableAudioFrame, null);
+    __privateSet(this, _armedVideo, false);
+    __privateSet(this, _lastEmittedSbn, -1);
+    __privateSet(this, _sampleReorderQueue, []);
+  }
+  dispose() {
+    this.reset();
+    this.onSegment = null;
+    this.onSample = null;
+    this.onInitSegment = null;
+    if (__privateGet(this, _aggregateTimer)) {
+      clearInterval(__privateGet(this, _aggregateTimer));
+      __privateSet(this, _aggregateTimer, null);
+    }
+  }
+};
+_config = new WeakMap();
+_blocks = new WeakMap();
+_pendingFlush = new WeakMap();
+_pendingRecovered = new WeakMap();
+_sequence = new WeakMap();
+_baseTs = new WeakMap();
+_fillFrame = new WeakMap();
+_lastDecodableAudioFrame = new WeakMap();
+_frameDuration = new WeakMap();
+_lastEmittedTs = new WeakMap();
+_lastSourceTs = new WeakMap();
+_sampleReorderWindow = new WeakMap();
+_sampleOrder = new WeakMap();
+_sampleOrderCapacity = new WeakMap();
+_sampleReorderQueue = new WeakMap();
+_recoveredHorizonTs = new WeakMap();
+_sampleOrderStats = new WeakMap();
+_validateH264Keyframes = new WeakMap();
+_keyframeRejectDumpCount = new WeakMap();
+_armedVideo = new WeakMap();
+_lastEmittedSbn = new WeakMap();
+_CmafBlockAssembler_instances = new WeakSet();
+/** Attempt to claim emission for `sbn`. Returns true if `sbn` is past
+ *  the watermark (and advances it); false if this sbn has already been
+ *  claimed or is older (caller should drop). */
+claimSbnEmission_fn = function(sbn) {
+  if (sbn <= __privateGet(this, _lastEmittedSbn)) return false;
+  __privateSet(this, _lastEmittedSbn, sbn);
+  return true;
+};
+/** 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_fn = function(frames) {
+  const keyedFrames = __privateMethod(this, _CmafBlockAssembler_instances, normalizeVideoKeyframes_fn).call(this, frames);
+  if (__privateGet(this, _config).trackType !== "video" || __privateGet(this, _armedVideo)) return keyedFrames;
+  const firstKfIdx = keyedFrames.findIndex((f) => f.keyframe);
+  if (firstKfIdx < 0) return null;
+  return firstKfIdx === 0 ? keyedFrames : keyedFrames.slice(firstKfIdx);
+};
+normalizeVideoKeyframes_fn = function(frames) {
+  if (__privateGet(this, _config).trackType !== "video" || !__privateGet(this, _validateH264Keyframes)) return frames;
+  return frames.map((frame) => __privateMethod(this, _CmafBlockAssembler_instances, withEffectiveVideoKeyframe_fn).call(this, frame));
+};
+withEffectiveVideoKeyframe_fn = function(frame) {
+  if (__privateGet(this, _config).trackType !== "video" || !__privateGet(this, _validateH264Keyframes)) return frame;
+  const keyframe = detectH264Keyframe(frame.data);
+  if (!keyframe) __privateMethod(this, _CmafBlockAssembler_instances, dumpRejectedVideoKeyframe_fn).call(this, frame.data, frame.keyframe);
+  return keyframe === frame.keyframe ? frame : { ...frame, keyframe };
+};
+dumpRejectedVideoKeyframe_fn = function(data, metadataKeyframe) {
+  if (__privateGet(this, _keyframeRejectDumpCount) >= 12) return;
+  __privateWrapper(this, _keyframeRejectDumpCount)._++;
+  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#${__privateGet(this, _keyframeRejectDumpCount)} len=${data.length} metadataKf=${metadataKeyframe} classify=${classify} format=${sample.format} nalTypes=[${nalTypes.join(",")}] first48=[${hex}]`
+  );
+};
+/** 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_fn = function() {
+  return __privateGet(this, _sampleOrder).mode === "media-window" || __privateGet(this, _sampleReorderWindow) > 0;
+};
+unwrapTimestamp_fn = function(timestamp) {
+  const wrapPeriod = __privateGet(this, _sampleOrder).mode === "media-window" ? __privateGet(this, _sampleOrder).timestampWrapPeriod : void 0;
+  if (!wrapPeriod) return timestamp;
+  const reference = __privateGet(this, _lastSourceTs) >= 0 ? __privateGet(this, _lastSourceTs) : __privateGet(this, _recoveredHorizonTs) >= 0 ? __privateGet(this, _recoveredHorizonTs) : __privateGet(this, _lastEmittedTs);
+  if (reference < 0) return timestamp;
+  return timestamp + Math.round((reference - timestamp) / wrapPeriod) * wrapPeriod;
+};
+emitSample_fn = function(data, timestamp, duration, keyframe, advancesHorizon, catalogTrackName, mpuSequenceNumber, packetSequenceNumber, packetSequenceNumbers, repairedPacketSequenceNumbers, authoredTiming, deliveryProvenance) {
+  const scaledTiming = authoredTiming === void 0 ? null : scaleAuthoredTiming(authoredTiming, __privateGet(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,
+      __privateGet(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 = __privateMethod(this, _CmafBlockAssembler_instances, unwrapTimestamp_fn).call(this, authoredTimestamp);
+  if (unwrappedTimestamp <= __privateGet(this, _lastEmittedTs)) {
+    __privateGet(this, _sampleOrderStats).staleSamples++;
+    return;
+  }
+  const sample = __privateMethod(this, _CmafBlockAssembler_instances, withEffectiveVideoKeyframe_fn).call(this, {
+    data,
+    timestamp: unwrappedTimestamp,
+    duration: authoredDuration,
+    keyframe,
+    ...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 },
+    ...catalogTrackName === void 0 ? {} : { catalogTrackName },
+    ...deliveryProvenance === void 0 ? {} : { deliveryProvenance }
+  });
+  if (advancesHorizon && unwrappedTimestamp > __privateGet(this, _lastSourceTs)) {
+    __privateSet(this, _lastSourceTs, unwrappedTimestamp);
+  } else if (!advancesHorizon && unwrappedTimestamp > __privateGet(this, _recoveredHorizonTs)) {
+    __privateSet(this, _recoveredHorizonTs, unwrappedTimestamp);
+  }
+  if (__privateMethod(this, _CmafBlockAssembler_instances, ordersSamples_fn).call(this)) {
+    __privateMethod(this, _CmafBlockAssembler_instances, queueSample_fn).call(this, sample);
+    return;
+  }
+  __privateMethod(this, _CmafBlockAssembler_instances, emitArrivalOrdered_fn).call(this, sample);
+};
+emitArrivalOrdered_fn = function(sample) {
+  if (__privateGet(this, _config).trackType === "video" && !__privateGet(this, _armedVideo) && !sample.keyframe) {
+    __privateGet(this, _sampleOrderStats).preRapDeadlineDrops++;
+    return;
+  }
+  __privateMethod(this, _CmafBlockAssembler_instances, emitSampleNow_fn).call(this, sample);
+};
+queueSample_fn = function(sample) {
+  if (__privateGet(this, _sampleReorderQueue).some((s) => s.timestamp === sample.timestamp)) {
+    __privateGet(this, _sampleOrderStats).duplicateSamples++;
+    return;
+  }
+  __privateGet(this, _sampleReorderQueue).push(sample);
+  __privateGet(this, _sampleReorderQueue).sort((a, b) => a.timestamp - b.timestamp);
+  __privateMethod(this, _CmafBlockAssembler_instances, drainSampleReorder_fn).call(this, false);
+  __privateMethod(this, _CmafBlockAssembler_instances, enforceSampleOrderCapacity_fn).call(this);
+};
+releaseHorizon_fn = function() {
+  return __privateGet(this, _lastSourceTs) >= 0 ? __privateGet(this, _lastSourceTs) : __privateGet(this, _recoveredHorizonTs);
+};
+sampleIsReleasable_fn = function(sample, flushAll) {
+  if (flushAll) return true;
+  if (__privateGet(this, _sampleOrder).mode === "media-window") {
+    const horizon = __privateMethod(this, _CmafBlockAssembler_instances, releaseHorizon_fn).call(this);
+    return horizon >= 0 && sample.timestamp < horizon - __privateGet(this, _sampleOrder).deliveryWindow;
+  }
+  return __privateGet(this, _sampleReorderQueue).length > __privateGet(this, _sampleReorderWindow);
+};
+dropPreRapSamples_fn = function(flushAll) {
+  if (__privateGet(this, _config).trackType !== "video" || __privateGet(this, _armedVideo)) return false;
+  const firstRap = __privateGet(this, _sampleReorderQueue).findIndex(
+    (sample) => sample.keyframe && __privateMethod(this, _CmafBlockAssembler_instances, sampleIsReleasable_fn).call(this, sample, flushAll)
+  );
+  if (firstRap >= 0) {
+    if (firstRap > 0) {
+      __privateGet(this, _sampleOrderStats).preRapDeadlineDrops += firstRap;
+      __privateGet(this, _sampleReorderQueue).splice(0, firstRap);
+    }
+    return false;
+  }
+  let dropped = 0;
+  while (__privateGet(this, _sampleReorderQueue)[0] && __privateMethod(this, _CmafBlockAssembler_instances, sampleIsReleasable_fn).call(this, __privateGet(this, _sampleReorderQueue)[0], flushAll)) {
+    __privateGet(this, _sampleReorderQueue).shift();
+    dropped++;
+  }
+  if (flushAll) __privateGet(this, _sampleOrderStats).noRapFlushDrops += dropped;
+  else __privateGet(this, _sampleOrderStats).preRapDeadlineDrops += dropped;
+  return dropped > 0;
+};
+drainSampleReorder_fn = function(flushAll) {
+  while (__privateGet(this, _sampleReorderQueue).length > 0) {
+    if (__privateMethod(this, _CmafBlockAssembler_instances, dropPreRapSamples_fn).call(this, flushAll) && __privateGet(this, _sampleReorderQueue).length === 0) return;
+    const sample = __privateGet(this, _sampleReorderQueue)[0];
+    if (!sample || !__privateMethod(this, _CmafBlockAssembler_instances, sampleIsReleasable_fn).call(this, sample, flushAll)) return;
+    __privateGet(this, _sampleReorderQueue).shift();
+    __privateMethod(this, _CmafBlockAssembler_instances, emitQueuedSample_fn).call(this, sample);
+  }
+};
+emitQueuedSample_fn = function(sample) {
+  const next = __privateGet(this, _sampleReorderQueue).find((s) => s.timestamp > sample.timestamp);
+  const duration = sample.authoredTiming ? sample.duration : next ? next.timestamp - sample.timestamp : sample.duration;
+  __privateMethod(this, _CmafBlockAssembler_instances, emitSampleNow_fn).call(this, {
+    ...sample,
+    duration: duration > 0 ? duration : sample.authoredTiming ? sample.duration : __privateGet(this, _frameDuration)
+  });
+};
+enforceSampleOrderCapacity_fn = function() {
+  if (__privateGet(this, _sampleOrder).mode !== "media-window") return;
+  while (__privateGet(this, _sampleReorderQueue).length > __privateGet(this, _sampleOrderCapacity)) {
+    const sample = __privateGet(this, _sampleReorderQueue).shift();
+    if (!sample) return;
+    __privateGet(this, _sampleOrderStats).forcedReleases++;
+    console.warn(
+      `[CmafBlockAssembler] ${__privateGet(this, _config).trackType} media-window queue exceeded ${__privateGet(this, _sampleOrderCapacity)} samples; force-releasing timestamp=${sample.timestamp}`
+    );
+    if (__privateGet(this, _config).trackType === "video" && !__privateGet(this, _armedVideo) && !sample.keyframe) {
+      __privateGet(this, _sampleOrderStats).preRapDeadlineDrops++;
+      continue;
+    }
+    __privateMethod(this, _CmafBlockAssembler_instances, emitQueuedSample_fn).call(this, sample);
+  }
+};
+emitSampleNow_fn = function(sample) {
+  if (sample.timestamp <= __privateGet(this, _lastEmittedTs)) {
+    __privateGet(this, _sampleOrderStats).staleSamples++;
+    return;
+  }
+  __privateMethod(this, _CmafBlockAssembler_instances, emitAudioGapFillNowBefore_fn).call(this, sample.timestamp);
+  __privateMethod(this, _CmafBlockAssembler_instances, writeSampleNow_fn).call(this, sample, true);
+};
+writeSampleNow_fn = function(sample, rememberAudio) {
+  const { timestamp, duration, keyframe } = sample;
+  __privateSet(this, _lastEmittedTs, timestamp);
+  if (__privateGet(this, _config).trackType === "video" && keyframe) __privateSet(this, _armedVideo, true);
+  const data = __privateMethod(this, _CmafBlockAssembler_instances, normalizeSampleData_fn).call(this, sample.data);
+  if (__privateGet(this, _config).trackType === "audio" && rememberAudio && data.length > 0) {
+    __privateSet(this, _lastDecodableAudioFrame, data.slice());
+  }
+  if (this.onSample) {
+    this.onSample(data === sample.data ? sample : { ...sample, data });
+  } else {
+    const baseTime = __privateMethod(this, _CmafBlockAssembler_instances, rebase_fn).call(this, timestamp);
+    const segment = encodeDataSegment(
+      data,
+      baseTime,
+      duration,
+      keyframe,
+      __privateWrapper(this, _sequence)._++,
+      __privateGet(this, _config).trackId,
+      sample.compositionTimeOffset
+    );
+    this.onSegment?.(segment);
+  }
+};
+emitAudioGapFillNowBefore_fn = function(timestamp) {
+  if (__privateGet(this, _config).trackType !== "audio" || __privateGet(this, _lastEmittedTs) < 0 || __privateGet(this, _lastDecodableAudioFrame) === null) return;
+  const gap = timestamp - __privateGet(this, _lastEmittedTs);
+  if (gap <= __privateGet(this, _frameDuration) * 1.5) return;
+  const missingFrames = Math.max(0, Math.round(gap / __privateGet(this, _frameDuration)) - 1);
+  for (let i = 0; i < missingFrames; i++) {
+    const fillTs = __privateGet(this, _lastEmittedTs) + __privateGet(this, _frameDuration);
+    __privateMethod(this, _CmafBlockAssembler_instances, writeSampleNow_fn).call(this, {
+      data: __privateGet(this, _lastDecodableAudioFrame).slice(),
+      timestamp: fillTs,
+      duration: __privateGet(this, _frameDuration),
+      keyframe: true
+    }, false);
+  }
+};
+emitPerSample_fn = function(frames, audioDurationOverride, advancesHorizon = false) {
+  for (let i = 0; i < frames.length; i++) {
+    const f = frames[i];
+    let duration;
+    if (__privateGet(this, _config).trackType === "audio") {
+      duration = audioDurationOverride ?? __privateGet(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 ?? __privateGet(this, _frameDuration);
+    }
+    if (duration <= 0) duration = audioDurationOverride ?? __privateGet(this, _frameDuration);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, f.data, f.timestamp, duration, f.keyframe, advancesHorizon, f.catalogTrackName, f.mpuSequenceNumber, f.packetSequenceNumber, f.packetSequenceNumbers, f.repairedPacketSequenceNumbers, f.authoredTiming, f.deliveryProvenance);
+  }
+};
+_dumpCount = new WeakMap();
+_emitCount = new WeakMap();
+_sampleCount = new WeakMap();
+_keyframeCount = new WeakMap();
+_addFrameCount = new WeakMap();
+_recoveredBlockCount = new WeakMap();
+_completeBlockCount = new WeakMap();
+_failBlockCount = new WeakMap();
+_aggregateTimer = new WeakMap();
+startAggregateTimer_fn = function() {
+  if (__privateGet(this, _aggregateTimer)) return;
+  __privateSet(this, _aggregateTimer, setInterval(() => {
+    console.log(
+      `[L4-AGG-${__privateGet(this, _config).trackType}] emits=${__privateGet(this, _emitCount)} samples=${__privateGet(this, _sampleCount)} kf=${__privateGet(this, _keyframeCount)} addFrame=${__privateGet(this, _addFrameCount)} recovered=${__privateGet(this, _recoveredBlockCount)} complete=${__privateGet(this, _completeBlockCount)} fail=${__privateGet(this, _failBlockCount)} pendingBlocks=${__privateGet(this, _blocks).size} pendingFlushes=${__privateGet(this, _pendingFlush).size} armedVideo=${__privateGet(this, _armedVideo)}`
+    );
+    __privateSet(this, _emitCount, 0);
+    __privateSet(this, _sampleCount, 0);
+    __privateSet(this, _keyframeCount, 0);
+    __privateSet(this, _addFrameCount, 0);
+    __privateSet(this, _recoveredBlockCount, 0);
+    __privateSet(this, _completeBlockCount, 0);
+    __privateSet(this, _failBlockCount, 0);
+  }, 1e3));
+};
+dumpEmit_fn = function(path, samples, sbn) {
+  __privateWrapper(this, _emitCount)._++;
+  __privateSet(this, _sampleCount, __privateGet(this, _sampleCount) + samples.length);
+  __privateSet(this, _keyframeCount, __privateGet(this, _keyframeCount) + samples.filter((s) => s.keyframe).length);
+  const anyKf = __privateGet(this, _config).trackType === "video" && samples.some((s) => s.keyframe);
+  if (__privateGet(this, _config).trackType !== "video" || __privateGet(this, _dumpCount) >= 6 && !anyKf) return;
+  __privateWrapper(this, _dumpCount)._++;
+  const s0 = samples[0];
+  if (!s0) return;
+  const d = s0.data;
+  const hex = Array.from(d.subarray(0, Math.min(48, d.length))).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+  let h = 5381;
+  for (let i = 0; i < d.length; i++) h = h * 33 + d[i] | 0;
+  const hash = (h >>> 0).toString(16).padStart(8, "0");
+  const ts0 = s0.timestamp ?? -1;
+  const tsN = samples[samples.length - 1]?.timestamp ?? -1;
+  console.log(
+    `[L4-DIAG] EMIT#${__privateGet(this, _dumpCount)} path=${path}${sbn !== void 0 ? ` sbn=${sbn}` : ""} samples=${samples.length} s0.kf=${s0.keyframe} s0.len=${d.length} ts0=${ts0} tsN=${tsN} dur=${tsN - ts0} hash=${hash} first48=[${hex}]`
+  );
+};
+// ── Private ──
+/** Rebase an absolute timestamp to relative media time (starting near 0). */
+rebase_fn = function(timestamp) {
+  if (__privateGet(this, _baseTs) < 0) __privateSet(this, _baseTs, timestamp);
+  return timestamp - __privateGet(this, _baseTs);
+};
+normalizeSampleData_fn = function(data) {
+  return __privateGet(this, _config).trackType === "audio" ? normalizeAacSampleForCmaf(data) : data;
+};
+enqueueRecovered_fn = function(frames) {
+  for (const frame of frames) {
+    if (__privateGet(this, _lastEmittedTs) >= 0 && frame.timestamp <= __privateGet(this, _lastEmittedTs)) {
+      __privateGet(this, _sampleOrderStats).staleSamples++;
+      continue;
+    }
+    if (__privateGet(this, _pendingRecovered).has(frame.timestamp)) {
+      __privateGet(this, _sampleOrderStats).duplicateSamples++;
+      continue;
+    }
+    __privateGet(this, _pendingRecovered).set(frame.timestamp, frame);
+  }
+};
+drainRecoveredUpTo_fn = function(horizonTs) {
+  if (__privateGet(this, _pendingRecovered).size === 0) return;
+  const ready = [...__privateGet(this, _pendingRecovered).values()].filter((frame) => frame.timestamp <= horizonTs).sort((a, b) => a.timestamp - b.timestamp);
+  for (const frame of ready) {
+    __privateGet(this, _pendingRecovered).delete(frame.timestamp);
+    __privateMethod(this, _CmafBlockAssembler_instances, emitSample_fn).call(this, frame.data, frame.timestamp, __privateGet(this, _frameDuration), frame.keyframe, false, frame.catalogTrackName, frame.mpuSequenceNumber, frame.packetSequenceNumber, frame.packetSequenceNumbers, frame.repairedPacketSequenceNumbers, frame.authoredTiming, frame.deliveryProvenance);
+    __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "recovered-drain", [frame]);
+  }
+};
+/** Flush a block's buffered frames as a multi-sample CMAF segment. */
+flushBlock_fn = function(sbn) {
+  const block = __privateGet(this, _blocks).get(sbn);
+  if (!block || block.size === 0) {
+    __privateGet(this, _blocks).delete(sbn);
+    return;
+  }
+  const entries = [...block.entries()].sort((a, b) => a[0] - b[0]);
+  const sortedFrames = entries.map(([, f]) => f);
+  __privateGet(this, _blocks).delete(sbn);
+  if (!__privateMethod(this, _CmafBlockAssembler_instances, claimSbnEmission_fn).call(this, sbn)) return;
+  const frames = __privateMethod(this, _CmafBlockAssembler_instances, applyVideoKeyframeGate_fn).call(this, sortedFrames);
+  if (!frames) return;
+  __privateMethod(this, _CmafBlockAssembler_instances, dumpEmit_fn).call(this, "flushBlock", frames, sbn);
+  __privateMethod(this, _CmafBlockAssembler_instances, emitPerSample_fn).call(this, frames);
+};
+/** Flush a block with fill frames for missing ESI slots (FEC timeout path). */
+flushBlockWithFill_fn = function(sbn) {
+  const block = __privateGet(this, _blocks).get(sbn);
+  if (!block) return;
+  const k = __privateGet(this, _config).k;
+  const isVideo = __privateGet(this, _config).trackType === "video";
+  const firstAudioFrame = !isVideo ? [...block.values()].sort((a, b) => a.timestamp - b.timestamp)[0]?.data : void 0;
+  const audioConcealmentFrame = __privateGet(this, _lastDecodableAudioFrame) ?? firstAudioFrame;
+  const allFrames = [];
+  let lastRealTs = -1;
+  let firstRealTs = -1;
+  for (const [, f] of block) {
+    if (firstRealTs < 0 || f.timestamp < firstRealTs) firstRealTs = f.timestamp;
+    if (f.timestamp > lastRealTs) lastRealTs = f.timestamp;
+  }
+  const estimatedBlockDuration = block.size > 1 ? (lastRealTs - firstRealTs) / (block.size - 1) * k : __privateGet(this, _frameDuration) * k;
+  for (let esi = 0; esi < k; esi++) {
+    const real = block.get(esi);
+    if (real) {
+      allFrames.push(real);
+    } else {
+      const interpolatedTs = firstRealTs >= 0 ? firstRealTs + Math.round(esi * estimatedBlockDuration / k) : __privateGet(this, _lastEmittedTs) >= 0 ? __privateGet(this, _lastEmittedTs) + __privateGet(this, _frameDuration) * (esi + 1) : 0;
+      allFrames.push({
+        // A synthesized AAC access unit is not portable across every
+        // AudioSpecificConfig. Repeat known-good encoded audio instead;
+        // if this is the first block, use its earliest received sample.
+        data: isVideo ? __privateGet(this, _fillFrame) : audioConcealmentFrame?.slice() ?? new Uint8Array(0),
+        timestamp: interpolatedTs,
+        // Video: first fill is keyframe (IDR). Audio: all fill marked keyframe.
+        keyframe: isVideo ? !block.has(0) && esi === 0 : true
+      });
+    }
+  }
+  __privateGet(this, _blocks).delete(sbn);
+  if (!__privateMethod(this, _CmafBlockAssembler_instances, claimSbnEmission_fn).call(this, sbn)) return;
+  const gatedFrames = __privateMethod(this, _CmafBlockAssembler_instances, applyVideoKeyframeGate_fn).call(this, allFrames);
+  if (!gatedFrames) return;
+  __privateMethod(this, _CmafBlockAssembler_instances, emitPerSample_fn).call(this, gatedFrames);
+};
+function isH264Codec(codec) {
+  const c = codec?.toLowerCase();
+  return c?.startsWith("avc1") === true || c?.startsWith("avc3") === true;
+}
+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