@invintusmedia/tomp4 1.4.3 → 1.5.1

package/src/hls-clip.js

@@ -1,10 +1,16 @@
 /**
  * HLS-to-HLS Clipper
  *
- * Clips an HLS stream to a time range, producing a new HLS stream with
- * CMAF (fMP4) segments. Boundary segments are pre-clipped with edit lists
- * for frame-accurate start/end. Middle segments are remuxed on-demand
- * from the original CDN source.
+ * Clips an HLS stream to a time range, producing a new HLS playlist.
+ * Middle segments use original CDN URLs (completely untouched).
+ * Boundary segments are re-muxed from the keyframe nearest to the
+ * requested start/end times.
+ *
+ * The result includes `prerollDuration` — the time between the actual
+ * start (keyframe) and the requested start. The player should seek
+ * past this on load for frame-accurate playback:
+ *
+ *   video.currentTime = clip.prerollDuration;
  *
  * @module hls-clip
  *
@@ -14,87 +20,83 @@
  *   endTime: 90,
  * });
  *
- * clip.masterPlaylist      // modified m3u8 text
- * clip.getMediaPlaylist(0) // variant media playlist
- * clip.getInitSegment(0)   // fMP4 init segment (Uint8Array)
- * await clip.getSegment(0, 0) // fMP4 media segment (Uint8Array)
+ * clip.prerollDuration       // seconds to seek past for frame accuracy
+ * clip.getMediaPlaylist(0)   // HLS playlist
+ * await clip.getSegment(0, 0) // boundary TS data
  */
 
-import { parseHls, isHlsUrl, parsePlaylistText, toAbsoluteUrl } from './hls.js';
-import { TSParser, getCodecInfo } from './parsers/mpegts.js';
-import { createInitSegment, createFragment } from './muxers/fmp4.js';
-import { convertFmp4ToMp4 } from './fmp4/converter.js';
-import { parseBoxes, findBox, parseChildBoxes, createBox } from './fmp4/utils.js';
-import { smartRender } from './codecs/smart-render.js';
-
-// ── constants ─────────────────────────────────────────────
+import { parseHls, parsePlaylistText } from './hls.js';
+import { TSParser } from './parsers/mpegts.js';
+import { TSMuxer } from './muxers/mpegts.js';
 
 const PTS_PER_SECOND = 90000;
 
 // ── helpers ───────────────────────────────────────────────
 
-function isKeyframe(accessUnit) {
-  for (const nalUnit of accessUnit.nalUnits) {
-    if ((nalUnit[0] & 0x1F) === 5) return true;
+function parseTs(tsData) {
+  const parser = new TSParser();
+  parser.parse(tsData);
+  parser.finalize();
+  return parser;
+}
+
+function isKeyframe(au) {
+  for (const nal of au.nalUnits) {
+    if ((nal[0] & 0x1F) === 5) return true;
   }
   return false;
 }
 
-function extractCodecInfo(parser) {
+function wrapADTS(aacData, sampleRate, channels) {
+  const RATES = [96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000,7350];
+  const sri = RATES.indexOf(sampleRate);
+  const len = aacData.length + 7;
+  const adts = new Uint8Array(len);
+  adts[0] = 0xFF;
+  adts[1] = 0xF1;
+  adts[2] = (1 << 6) | ((sri < 0 ? 4 : sri) << 2) | ((channels >> 2) & 1);
+  adts[3] = ((channels & 3) << 6) | ((len >> 11) & 3);
+  adts[4] = (len >> 3) & 0xFF;
+  adts[5] = ((len & 7) << 5) | 0x1F;
+  adts[6] = 0xFC;
+  adts.set(aacData, 7);
+  return adts;
+}
+
+function muxToTs(videoAUs, audioAUs, audioSampleRate, audioChannels) {
+  const muxer = new TSMuxer();
+
   let sps = null, pps = null;
-  for (const au of parser.videoAccessUnits) {
-    for (const nalUnit of au.nalUnits) {
-      const nalType = nalUnit[0] & 0x1F;
-      if (nalType === 7 && !sps) sps = nalUnit;
-      if (nalType === 8 && !pps) pps = nalUnit;
-      if (sps && pps) return { sps, pps };
+  for (const au of videoAUs) {
+    for (const nal of au.nalUnits) {
+      const t = nal[0] & 0x1F;
+      if (t === 7 && !sps) sps = nal;
+      if (t === 8 && !pps) pps = nal;
     }
+    if (sps && pps) break;
+  }
+  if (sps && pps) muxer.setSpsPps(sps, pps);
+  muxer.setHasAudio(audioAUs.length > 0);
+
+  const sr = audioSampleRate || 48000;
+  const ch = audioChannels || 2;
+  for (const au of audioAUs) {
+    const hasADTS = au.data.length > 1 && au.data[0] === 0xFF && (au.data[1] & 0xF0) === 0xF0;
+    muxer.addAudioSample(hasADTS ? au.data : wrapADTS(au.data, sr, ch), au.pts);
   }
-  return { sps, pps };
-}
 
-/**
- * Parse a TS segment and return the parsed data.
- */
-function parseTs(tsData) {
-  const parser = new TSParser();
-  parser.parse(tsData);
-  parser.finalize();
-  return parser;
-}
+  for (const au of videoAUs) {
+    muxer.addVideoNalUnits(au.nalUnits, isKeyframe(au), au.pts, au.dts);
+  }
 
-/**
- * Remux parsed TS data into an fMP4 fragment.
- * Normalizes timestamps to start at the given base times.
- */
-function remuxToFragment(parser, sequenceNumber, videoBaseTime, audioBaseTime, audioTimescale) {
-  return createFragment({
-    videoSamples: parser.videoAccessUnits,
-    audioSamples: parser.audioAccessUnits,
-    sequenceNumber,
-    videoTimescale: PTS_PER_SECOND,
-    audioTimescale,
-    videoBaseTime,
-    audioBaseTime,
-    audioSampleDuration: 1024,
-  });
+  return muxer.build();
 }
 
 /**
- * Clip a parsed TS segment at the start and/or end.
- *
- * Uses smart rendering when clipping at the start: re-encodes the
- * boundary GOP so the segment starts with a new keyframe at the
- * exact requested time. No preroll, no edit list, frame-accurate.
- *
- * @param {TSParser} parser - Parsed TS segment
- * @param {number} [startTime] - Start time in seconds (relative to segment)
- * @param {number} [endTime] - End time in seconds (relative to segment)
- * @param {object} [options]
- * @param {number} [options.qp=20] - Encoding quality for smart-rendered frames
+ * Clip a parsed TS segment. Starts at nearest keyframe, ends at endTime.
+ * Returns the preroll (time from keyframe to requested start).
  */
-function clipSegment(parser, startTime, endTime, options = {}) {
-  const { qp = 20 } = options;
+function clipSegment(parser, startTime, endTime) {
   const startPts = (startTime !== undefined ? startTime : 0) * PTS_PER_SECOND;
   const endPts = (endTime !== undefined ? endTime : Infinity) * PTS_PER_SECOND;
   const videoAUs = parser.videoAccessUnits;
@@ -102,91 +104,70 @@ function clipSegment(parser, startTime, endTime, options = {}) {
 
   if (videoAUs.length === 0) return null;
 
-  // Check if startTime falls between keyframes (needs smart rendering)
+  // Find keyframe at or before startTime
   let keyframeIdx = 0;
   for (let i = 0; i < videoAUs.length; i++) {
     if (videoAUs[i].pts > startPts) break;
     if (isKeyframe(videoAUs[i])) keyframeIdx = i;
   }
 
-  let targetIdx = keyframeIdx;
+  // Find end
+  let endIdx = videoAUs.length;
   for (let i = keyframeIdx; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts >= startPts) { targetIdx = i; break; }
+    if (videoAUs[i].pts >= endPts) { endIdx = i; break; }
   }
 
-  // Smart rendering is available but currently disabled for HLS output
-  // because the JS H.264 encoder's CAVLC output has bugs at high resolutions
-  // (works at 288x160 but fails at 1080p). Fall back to keyframe-accurate.
-  // TODO: Fix CAVLC encoding for high-resolution frames to re-enable.
-  const needsSmartRender = false;
+  const clipped = videoAUs.slice(keyframeIdx, endIdx);
+  if (clipped.length === 0) return null;
 
-  let clippedVideo, clippedAudio, startOffset;
+  const keyframePts = clipped[0].pts;
+  const prerollPts = Math.max(0, startPts - keyframePts);
 
-  if (needsSmartRender) {
-    // Smart render: re-encode boundary GOP for frame-accurate start
-    const result = smartRender(parser, startTime, { endTime, qp });
-    clippedVideo = result.videoAUs;
-    startOffset = result.videoAUs.length > 0 ? result.videoAUs[0].pts : 0;
+  // Audio from keyframe (same timeline as video for A/V sync)
+  const lastVideoPts = clipped[clipped.length - 1].pts;
+  const audioEndPts = Math.min(endPts, lastVideoPts + PTS_PER_SECOND);
+  const clippedAudio = audioAUs.filter(au => au.pts >= keyframePts && au.pts < audioEndPts);
 
-    // Clip audio to match smart-rendered video
-    const audioEnd = endPts < Infinity ? Math.min(endPts, videoAUs[videoAUs.length - 1].pts + PTS_PER_SECOND) : Infinity;
-    clippedAudio = audioAUs.filter(au => au.pts >= startOffset && au.pts < audioEnd);
-  } else {
-    // Start is at a keyframe — no smart rendering needed
-    let endIdx = videoAUs.length;
-    for (let i = keyframeIdx; i < videoAUs.length; i++) {
-      if (videoAUs[i].pts >= endPts) { endIdx = i; break; }
-    }
+  // Normalize to PTS 0
+  const offset = keyframePts;
+  for (const au of clipped) { au.pts -= offset; au.dts -= offset; }
+  for (const au of clippedAudio) { au.pts -= offset; }
 
-    clippedVideo = videoAUs.slice(keyframeIdx, endIdx);
-    if (clippedVideo.length === 0) return null;
-    startOffset = clippedVideo[0].pts;
+  const frameDur = clipped.length > 1 ? clipped[1].dts - clipped[0].dts : 3003;
+  const duration = (clipped[clipped.length - 1].dts - clipped[0].dts + frameDur) / PTS_PER_SECOND;
 
-    const lastVideoPts = clippedVideo[clippedVideo.length - 1].pts;
-    const audioEndPts = Math.min(endPts, lastVideoPts + PTS_PER_SECOND);
-    clippedAudio = audioAUs.filter(au => au.pts >= startOffset && au.pts < audioEndPts);
-  }
-
-  if (clippedVideo.length === 0) return null;
-
-  // Normalize timestamps to start at 0
-  for (const au of clippedVideo) { au.pts -= startOffset; au.dts -= startOffset; }
-  for (const au of clippedAudio) { au.pts -= startOffset; }
-
-  // Duration from actual content
-  const duration = clippedVideo.length > 1
-    ? clippedVideo[clippedVideo.length - 1].dts - clippedVideo[0].dts +
-      (clippedVideo.length > 1 ? clippedVideo[1].dts - clippedVideo[0].dts : 3003)
-    : 3003;
+  const tsData = muxToTs(clipped, clippedAudio, parser.audioSampleRate, parser.audioChannels);
 
   return {
-    videoSamples: clippedVideo,
-    audioSamples: clippedAudio,
-    duration: duration / PTS_PER_SECOND,
-    smartRendered: needsSmartRender,
+    data: tsData,
+    duration,
+    preroll: prerollPts / PTS_PER_SECOND,
   };
 }
 
 // ── HlsClipResult ─────────────────────────────────────────
 
 class HlsClipResult {
-  constructor({ variants, duration, startTime, endTime }) {
-    this._variants = variants; // array of VariantClip
+  /**
+   * @param {object} opts
+   * @param {number} opts.prerollDuration - Seconds to seek past for frame accuracy
+   */
+  constructor({ variants, duration, startTime, endTime, prerollDuration }) {
+    this._variants = variants;
     this.duration = duration;
     this.startTime = startTime;
     this.endTime = endTime;
+    /** Seconds between the keyframe start and the requested startTime.
+     *  The player should set video.currentTime = prerollDuration on load. */
+    this.prerollDuration = prerollDuration;
   }
 
-  /** Number of quality variants */
   get variantCount() {
     return this._variants.length;
   }
 
-  /** Master playlist m3u8 text */
   get masterPlaylist() {
-    if (this._variants.length === 1) {
-      return this.getMediaPlaylist(0);
-    }
+    if (this._variants.length === 1) return this.getMediaPlaylist(0);
     let m3u8 = '#EXTM3U\n';
     for (let i = 0; i < this._variants.length; i++) {
       const v = this._variants[i];
@@ -197,11 +178,6 @@ class HlsClipResult {
     return m3u8;
   }
 
-  /**
-   * Get CMAF media playlist for a variant.
-   * @param {number} variantIndex
-   * @returns {string} m3u8 text
-   */
   getMediaPlaylist(variantIndex = 0) {
     const variant = this._variants[variantIndex];
     if (!variant) throw new Error(`Variant ${variantIndex} not found`);
@@ -209,295 +185,45 @@ class HlsClipResult {
     const maxDur = Math.max(...variant.segments.map(s => s.duration));
 
     let m3u8 = '#EXTM3U\n';
-    m3u8 += '#EXT-X-VERSION:7\n';
+    m3u8 += '#EXT-X-VERSION:3\n';
     m3u8 += `#EXT-X-TARGETDURATION:${Math.ceil(maxDur)}\n`;
     m3u8 += '#EXT-X-PLAYLIST-TYPE:VOD\n';
     m3u8 += '#EXT-X-MEDIA-SEQUENCE:0\n';
-    m3u8 += `#EXT-X-MAP:URI="init-${variantIndex}.m4s"\n`;
 
     for (let i = 0; i < variant.segments.length; i++) {
       const seg = variant.segments[i];
       m3u8 += `#EXTINF:${seg.duration.toFixed(6)},\n`;
-      m3u8 += `segment-${variantIndex}-${i}.m4s\n`;
+      m3u8 += seg.originalUrl || `segment-${variantIndex}-${i}.ts\n`;
     }
     m3u8 += '#EXT-X-ENDLIST\n';
     return m3u8;
   }
 
-  /**
-   * Get the CMAF init segment for a variant.
-   * @param {number} variantIndex
-   * @returns {Uint8Array}
-   */
-  getInitSegment(variantIndex = 0) {
-    return this._variants[variantIndex]?.initSegment ?? null;
-  }
-
-  /**
-   * Get a media segment as fMP4 data.
-   * Boundary segments are returned from memory (pre-clipped).
-   * Middle segments are fetched from CDN and remuxed on-demand.
-   *
-   * @param {number} variantIndex
-   * @param {number} segmentIndex
-   * @returns {Promise<Uint8Array>}
-   */
   async getSegment(variantIndex = 0, segmentIndex = 0) {
     const variant = this._variants[variantIndex];
     if (!variant) throw new Error(`Variant ${variantIndex} not found`);
     const seg = variant.segments[segmentIndex];
     if (!seg) throw new Error(`Segment ${segmentIndex} not found`);
-
-    // Pre-clipped boundary segments are already in memory
     if (seg.data) return seg.data;
-
-    // Middle segment: fetch from CDN
-    const resp = await fetch(seg.originalUrl);
-    if (!resp.ok) throw new Error(`Segment fetch failed: ${resp.status}`);
-    const rawData = new Uint8Array(await resp.arrayBuffer());
-
-    // fMP4 segments pass through unchanged (already correct format)
-    if (seg._sourceFormat === 'fmp4') return rawData;
-
-    // TS segments: remux to fMP4
-    const parser = parseTs(rawData);
-    const audioTimescale = seg._audioTimescale || parser.audioSampleRate || 48000;
-
-    const firstVideoPts = parser.videoAccessUnits[0]?.pts ?? 0;
-    for (const au of parser.videoAccessUnits) { au.pts -= firstVideoPts; au.dts -= firstVideoPts; }
-    for (const au of parser.audioAccessUnits) { au.pts -= firstVideoPts; }
-
-    const videoBaseTime = Math.round(seg.timelineOffset * PTS_PER_SECOND);
-    const audioBaseTime = Math.round(seg.timelineOffset * audioTimescale);
-
-    return remuxToFragment(parser, segmentIndex + 1, videoBaseTime, audioBaseTime, audioTimescale);
-  }
-
-  /**
-   * Get all segment data for a variant (fetches middle segments).
-   * Useful for downloading the full clip.
-   * @param {number} variantIndex
-   * @returns {Promise<Uint8Array[]>}
-   */
-  async getAllSegments(variantIndex = 0) {
-    const variant = this._variants[variantIndex];
-    const results = [];
-    for (let i = 0; i < variant.segments.length; i++) {
-      results.push(await this.getSegment(variantIndex, i));
+    if (seg.originalUrl) {
+      const resp = await fetch(seg.originalUrl);
+      if (!resp.ok) throw new Error(`Segment fetch failed: ${resp.status}`);
+      return new Uint8Array(await resp.arrayBuffer());
     }
-    return results;
-  }
-}
-
-// ── format detection ──────────────────────────────────────
-
-function _detectSegmentFormat(data) {
-  if (data.length < 8) return 'unknown';
-  // Check for TS sync byte
-  if (data[0] === 0x47) return 'ts';
-  for (let i = 0; i < Math.min(188, data.length); i++) {
-    if (data[i] === 0x47 && i + 188 < data.length && data[i + 188] === 0x47) return 'ts';
+    return null;
   }
-  // Check for fMP4 (moof, styp, or ftyp box)
-  const type = String.fromCharCode(data[4], data[5], data[6], data[7]);
-  if (['moof', 'styp', 'ftyp', 'mdat'].includes(type)) return 'fmp4';
-  return 'unknown';
 }
 
-// ── TS variant processing ─────────────────────────────────
-
-function _processTsVariant({ firstSegData, lastSegData, overlapping, isSingleSegment, startTime, endTime, firstSeg, lastSeg, log }) {
-  const firstParser = parseTs(firstSegData);
-  const lastParser = !isSingleSegment && lastSegData ? parseTs(lastSegData) : null;
-
-  const { sps, pps } = extractCodecInfo(firstParser);
-  if (!sps || !pps) throw new Error('Could not extract SPS/PPS from video');
-  const audioSampleRate = firstParser.audioSampleRate || 48000;
-  const audioChannels = firstParser.audioChannels || 2;
-  const hasAudio = firstParser.audioAccessUnits.length > 0;
-  const audioTimescale = audioSampleRate;
-
-  const initSegment = createInitSegment({
-    sps, pps, audioSampleRate, audioChannels, hasAudio,
-    videoTimescale: PTS_PER_SECOND, audioTimescale,
-  });
-
-  const clipSegments = [];
-  let timelineOffset = 0;
-
-  // First segment (smart-rendered)
-  const firstRelStart = startTime - firstSeg.startTime;
-  const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
-  const firstClipped = clipSegment(firstParser, firstRelStart, firstRelEnd);
-  if (!firstClipped) throw new Error('First segment clip produced no samples');
-
-  const firstFragment = createFragment({
-    videoSamples: firstClipped.videoSamples,
-    audioSamples: firstClipped.audioSamples,
-    sequenceNumber: 1,
-    videoTimescale: PTS_PER_SECOND, audioTimescale,
-    videoBaseTime: 0, audioBaseTime: 0, audioSampleDuration: 1024,
-  });
-
-  clipSegments.push({
-    duration: firstClipped.duration, data: firstFragment,
-    originalUrl: null, timelineOffset: 0, isBoundary: true,
-  });
-  timelineOffset += firstClipped.duration;
-
-  // Middle segments
-  for (let i = 1; i < overlapping.length - 1; i++) {
-    clipSegments.push({
-      duration: overlapping[i].duration, data: null,
-      originalUrl: overlapping[i].url, timelineOffset, isBoundary: false,
-      _sourceFormat: 'ts', _audioTimescale: audioTimescale,
-    });
-    timelineOffset += overlapping[i].duration;
-  }
-
-  // Last segment
-  if (!isSingleSegment && lastParser) {
-    const lastRelEnd = endTime - lastSeg.startTime;
-    const lastClipped = clipSegment(lastParser, undefined, lastRelEnd);
-    if (lastClipped && lastClipped.videoSamples.length > 0) {
-      const lastFragment = createFragment({
-        videoSamples: lastClipped.videoSamples,
-        audioSamples: lastClipped.audioSamples,
-        sequenceNumber: overlapping.length,
-        videoTimescale: PTS_PER_SECOND, audioTimescale,
-        videoBaseTime: Math.round(timelineOffset * PTS_PER_SECOND),
-        audioBaseTime: Math.round(timelineOffset * audioTimescale),
-        audioSampleDuration: 1024,
-      });
-      clipSegments.push({
-        duration: lastClipped.duration, data: lastFragment,
-        originalUrl: null, timelineOffset, isBoundary: true,
-      });
-    }
-  }
-
-  return { initSegment, clipSegments, audioTimescale };
-}
-
-// ── fMP4 variant processing ───────────────────────────────
-
-function _processFmp4Variant({ firstSegData, lastSegData, fmp4Init, overlapping, isSingleSegment, startTime, endTime, firstSeg, lastSeg, log }) {
-  // For fMP4 sources: the init segment already has the moov with codec info.
-  // We pass it through as-is. Boundary segments are clipped using the fMP4
-  // converter. Middle segments pass through unchanged.
-
-  if (!fmp4Init) throw new Error('fMP4 source requires an init segment (#EXT-X-MAP)');
-
-  // Use the source init segment directly (it has the correct moov)
-  const initSegment = fmp4Init;
-
-  // Detect audio timescale from the init segment's moov
-  let audioTimescale = 48000;
-  try {
-    const boxes = parseBoxes(fmp4Init);
-    const moov = findBox(boxes, 'moov');
-    if (moov) {
-      const moovChildren = parseChildBoxes(moov);
-      for (const child of moovChildren) {
-        if (child.type === 'trak') {
-          const trakChildren = parseChildBoxes(child);
-          for (const tc of trakChildren) {
-            if (tc.type === 'mdia') {
-              const mdiaChildren = parseChildBoxes(tc);
-              let isSoun = false;
-              for (const mc of mdiaChildren) {
-                if (mc.type === 'hdlr' && mc.data.byteLength >= 20) {
-                  const handler = String.fromCharCode(mc.data[16], mc.data[17], mc.data[18], mc.data[19]);
-                  if (handler === 'soun') isSoun = true;
-                }
-                if (mc.type === 'mdhd' && isSoun) {
-                  const v = new DataView(mc.data.buffer, mc.data.byteOffset, mc.data.byteLength);
-                  audioTimescale = mc.data[8] === 0 ? v.getUint32(20) : v.getUint32(28);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  } catch (e) { /* use default */ }
-
-  const clipSegments = [];
-  let timelineOffset = 0;
-
-  // First segment: clip using fMP4 converter
-  const firstRelStart = startTime - firstSeg.startTime;
-  const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
-
-  // Combine init + first segment for the converter
-  const firstCombined = new Uint8Array(fmp4Init.byteLength + firstSegData.byteLength);
-  firstCombined.set(fmp4Init, 0);
-  firstCombined.set(firstSegData, fmp4Init.byteLength);
-
-  try {
-    // Use convertFmp4ToMp4 with clipping, then re-fragment
-    // Actually, we can just pass the raw fMP4 segment through — for boundary
-    // segments, we trim at the keyframe level (no smart rendering for fMP4 yet).
-    // The segment already starts at a keyframe (HLS requirement).
-
-    // For the first segment, just pass through — the startTime cut is at keyframe
-    // For frame accuracy with fMP4, we'd need to add edit lists to the init segment
-    // or do smart rendering. For now, keyframe-accurate is the fMP4 path.
-    clipSegments.push({
-      duration: (firstRelEnd || firstSeg.duration) - firstRelStart,
-      data: firstSegData, // pass through the fMP4 segment
-      originalUrl: null, timelineOffset: 0, isBoundary: true,
-      _sourceFormat: 'fmp4',
-    });
-    timelineOffset += clipSegments[0].duration;
-  } catch (e) {
-    log('fMP4 first segment processing error: ' + e.message);
-    // Fallback: pass through as-is
-    clipSegments.push({
-      duration: firstSeg.duration, data: firstSegData,
-      originalUrl: null, timelineOffset: 0, isBoundary: true,
-      _sourceFormat: 'fmp4',
-    });
-    timelineOffset += firstSeg.duration;
-  }
-
-  // Middle segments: pass through unchanged (already fMP4!)
-  for (let i = 1; i < overlapping.length - 1; i++) {
-    clipSegments.push({
-      duration: overlapping[i].duration, data: null,
-      originalUrl: overlapping[i].url, timelineOffset, isBoundary: false,
-      _sourceFormat: 'fmp4',
-    });
-    timelineOffset += overlapping[i].duration;
-  }
-
-  // Last segment: pass through (truncation at end is handled by player)
-  if (!isSingleSegment && lastSegData) {
-    const lastRelEnd = endTime - lastSeg.startTime;
-    clipSegments.push({
-      duration: Math.min(lastRelEnd, lastSeg.duration),
-      data: lastSegData,
-      originalUrl: null, timelineOffset, isBoundary: true,
-      _sourceFormat: 'fmp4',
-    });
-  }
-
-  return { initSegment, clipSegments, audioTimescale };
-}
-
-// ── main function ─────────────────────────────────────────
+// ── main ──────────────────────────────────────────────────
 
 /**
- * Clip an HLS stream to a time range, producing a new HLS stream
- * with CMAF (fMP4) segments.
+ * Clip an HLS stream to a time range.
+ *
+ * Boundary segments start at the nearest keyframe. The result includes
+ * `prerollDuration` — the player should seek to this time on load for
+ * frame-accurate start.
  *
- * @param {string} source - HLS URL (master or media playlist)
- * @param {object} options
- * @param {number} options.startTime - Start time in seconds
- * @param {number} options.endTime - End time in seconds
- * @param {string|number} [options.quality] - 'highest', 'lowest', or bandwidth (default: all)
- * @param {function} [options.onProgress] - Progress callback
- * @returns {Promise<HlsClipResult>}
+ * Middle segments use original CDN URLs (completely untouched).
  */
 export async function clipHls(source, options = {}) {
   const { startTime, endTime, quality, onProgress: log = () => {} } = options;
@@ -508,50 +234,38 @@ export async function clipHls(source, options = {}) {
   log('Parsing HLS playlist...');
   const stream = typeof source === 'string' ? await parseHls(source, { onProgress: log }) : source;
 
-  // Resolve variants to process
   let variantsToProcess = [];
-
   if (stream.isMaster) {
-    const sorted = stream.qualities; // sorted by bandwidth desc
-    if (quality === 'highest') {
-      variantsToProcess = [sorted[0]];
-    } else if (quality === 'lowest') {
-      variantsToProcess = [sorted[sorted.length - 1]];
-    } else if (typeof quality === 'number') {
-      stream.select(quality);
-      variantsToProcess = [stream.selected];
-    } else {
-      variantsToProcess = sorted; // all variants
-    }
+    const sorted = stream.qualities;
+    if (quality === 'highest') variantsToProcess = [sorted[0]];
+    else if (quality === 'lowest') variantsToProcess = [sorted[sorted.length - 1]];
+    else if (typeof quality === 'number') { stream.select(quality); variantsToProcess = [stream.selected]; }
+    else variantsToProcess = sorted;
   } else {
-    // Single media playlist — treat as one variant
-    variantsToProcess = [{ url: null, bandwidth: 0, resolution: null, _segments: stream.segments, _initSegmentUrl: stream.initSegmentUrl }];
+    variantsToProcess = [{ url: null, bandwidth: 0, resolution: null, _segments: stream.segments }];
   }
 
   log(`Processing ${variantsToProcess.length} variant(s)...`);
 
   const variants = [];
+  let prerollDuration = 0;
+
   for (let vi = 0; vi < variantsToProcess.length; vi++) {
     const variant = variantsToProcess[vi];
     log(`Variant ${vi}: ${variant.resolution || variant.bandwidth || 'default'}`);
 
-    // Get segment list for this variant
-    let segments, initSegmentUrl;
+    let segments;
     if (variant._segments) {
       segments = variant._segments;
-      initSegmentUrl = variant._initSegmentUrl;
     } else {
-      const mediaResp = await fetch(variant.url);
-      if (!mediaResp.ok) throw new Error(`Failed to fetch media playlist: ${mediaResp.status}`);
-      const mediaText = await mediaResp.text();
-      const parsed = parsePlaylistText(mediaText, variant.url);
+      const resp = await fetch(variant.url);
+      if (!resp.ok) throw new Error(`Failed to fetch media playlist: ${resp.status}`);
+      const parsed = parsePlaylistText(await resp.text(), variant.url);
       segments = parsed.segments;
-      initSegmentUrl = parsed.initSegmentUrl;
     }
 
     if (!segments.length) throw new Error('No segments found');
 
-    // Find overlapping segments
     const overlapping = segments.filter(seg => seg.endTime > startTime && seg.startTime < endTime);
     if (!overlapping.length) throw new Error('No segments overlap the clip range');
 
@@ -561,71 +275,66 @@ export async function clipHls(source, options = {}) {
 
     log(`Segments: ${overlapping.length} (${firstSeg.startTime.toFixed(1)}s – ${lastSeg.endTime.toFixed(1)}s)`);
 
-    // Download first boundary segment to detect format
+    // Download and clip first boundary segment
     log('Downloading boundary segments...');
-    const firstSegData = new Uint8Array(await (await fetch(firstSeg.url)).arrayBuffer());
+    const firstData = new Uint8Array(await (await fetch(firstSeg.url)).arrayBuffer());
+    const firstParser = parseTs(firstData);
+    const firstRelStart = startTime - firstSeg.startTime;
+    const firstRelEnd = isSingleSegment ? endTime - firstSeg.startTime : undefined;
+    const firstClipped = clipSegment(firstParser, firstRelStart, firstRelEnd);
+    if (!firstClipped) throw new Error('First segment clip produced no samples');
 
-    // Detect source format: TS or fMP4
-    const sourceFormat = _detectSegmentFormat(firstSegData);
-    const isFmp4Source = sourceFormat === 'fmp4';
+    // Preroll from the first variant (all variants have similar GOP structure)
+    if (vi === 0) prerollDuration = firstClipped.preroll;
 
-    log(`Source format: ${isFmp4Source ? 'fMP4 (CMAF)' : 'MPEG-TS'}`);
+    const clipSegments = [];
 
-    // Download fMP4 init segment if needed
-    let fmp4Init = null;
-    if (isFmp4Source && initSegmentUrl) {
-      const initResp = await fetch(initSegmentUrl);
-      if (initResp.ok) {
-        fmp4Init = new Uint8Array(await initResp.arrayBuffer());
-      }
-    }
+    clipSegments.push({
+      duration: firstClipped.duration,
+      data: firstClipped.data,
+      originalUrl: null,
+    });
 
-    let lastSegData = null;
-    if (!isSingleSegment) {
-      lastSegData = new Uint8Array(await (await fetch(lastSeg.url)).arrayBuffer());
+    // Middle segments: original CDN URLs
+    for (let i = 1; i < overlapping.length - 1; i++) {
+      clipSegments.push({
+        duration: overlapping[i].duration,
+        data: null,
+        originalUrl: overlapping[i].url,
+      });
     }
 
-    let initSegment, clipSegments, audioTimescale;
-
-    if (isFmp4Source) {
-      // ── fMP4 source path ────────────────────────────────
-      const result = _processFmp4Variant({
-        firstSegData, lastSegData, fmp4Init,
-        overlapping, isSingleSegment,
-        startTime, endTime, firstSeg, lastSeg, log,
-      });
-      initSegment = result.initSegment;
-      clipSegments = result.clipSegments;
-      audioTimescale = result.audioTimescale;
-    } else {
-      // ── TS source path (existing smart-render pipeline) ──
-      const result = _processTsVariant({
-        firstSegData, lastSegData,
-        overlapping, isSingleSegment,
-        startTime, endTime, firstSeg, lastSeg, log,
-      });
-      initSegment = result.initSegment;
-      clipSegments = result.clipSegments;
-      audioTimescale = result.audioTimescale;
+    // Last boundary segment
+    if (!isSingleSegment) {
+      const lastData = new Uint8Array(await (await fetch(lastSeg.url)).arrayBuffer());
+      const lastParser = parseTs(lastData);
+      const lastRelEnd = endTime - lastSeg.startTime;
+      const lastClipped = clipSegment(lastParser, undefined, lastRelEnd);
+      if (lastClipped && lastClipped.data) {
+        clipSegments.push({
+          duration: lastClipped.duration,
+          data: lastClipped.data,
+          originalUrl: null,
+        });
+      }
     }
 
     const totalDuration = clipSegments.reduce((sum, s) => sum + s.duration, 0);
-    log(`Clip ready: ${totalDuration.toFixed(2)}s (${clipSegments.length} segments)`);
+    log(`Clip ready: ${totalDuration.toFixed(2)}s (${clipSegments.length} segments, preroll: ${firstClipped.preroll.toFixed(2)}s)`);
 
     variants.push({
       bandwidth: variant.bandwidth || 0,
       resolution: variant.resolution || null,
-      initSegment,
       segments: clipSegments,
     });
   }
 
-  const clipDuration = endTime - startTime;
   return new HlsClipResult({
     variants,
-    duration: clipDuration,
+    duration: endTime - startTime,
     startTime,
     endTime,
+    prerollDuration,
   });
 }