@invintusmedia/tomp4 1.5.0 → 1.5.1

package/dist/tomp4.js

@@ -1,5 +1,5 @@
 /**
- * toMp4.js v1.5.0
+ * toMp4.js v1.5.1
  * Convert MPEG-TS and fMP4 to standard MP4
  * https://github.com/TVWIT/toMp4.js
  * MIT License
@@ -1186,7 +1186,7 @@
   toMp4.isMpegTs = isMpegTs;
   toMp4.isFmp4 = isFmp4;
   toMp4.isStandardMp4 = isStandardMp4;
-  toMp4.version = '1.5.0';
+  toMp4.version = '1.5.1';
 
   return toMp4;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invintusmedia/tomp4",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Convert MPEG-TS, fMP4, and HLS streams to MP4 with clipping support - pure JavaScript, zero dependencies",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/hls-clip.js

@@ -1,14 +1,16 @@
 /**
  * HLS-to-HLS Clipper
  *
- * Clips an HLS stream to a time range, producing a new HLS stream.
- * Boundary segments are smart-rendered via WebCodecs for frame-accurate
- * start/end. Middle segments use original CDN URLs — completely untouched.
+ * 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.
  *
- * Output format matches input: TS segments stay as TS, fMP4 stays as fMP4.
- * No format conversion needed for middle segments.
+ * 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:
  *
- * Falls back to keyframe-accurate clipping when WebCodecs is unavailable.
+ *   video.currentTime = clip.prerollDuration;
  *
  * @module hls-clip
  *
@@ -18,35 +20,17 @@
  *   endTime: 90,
  * });
  *
- * clip.masterPlaylist      // modified m3u8 text
- * clip.getMediaPlaylist(0) // variant media playlist
- * await clip.getSegment(0, 0) // boundary segment (Uint8Array) or middle URL
+ * clip.prerollDuration       // seconds to seek past for frame accuracy
+ * clip.getMediaPlaylist(0)   // HLS playlist
+ * await clip.getSegment(0, 0) // boundary TS data
  */
 
 import { parseHls, parsePlaylistText } from './hls.js';
 import { TSParser } from './parsers/mpegts.js';
 import { TSMuxer } from './muxers/mpegts.js';
-import { smartRender, isSmartRenderSupported } from './codecs/smart-render.js';
 
 const PTS_PER_SECOND = 90000;
 
-/** Wrap raw AAC frame data with a 7-byte ADTS header. */
-function wrapADTS(aacData, sampleRate, channels) {
-  const RATES = [96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000,7350];
-  const sampleRateIndex = RATES.indexOf(sampleRate);
-  const frameLength = aacData.length + 7;
-  const adts = new Uint8Array(7 + aacData.length);
-  adts[0] = 0xFF;
-  adts[1] = 0xF1; // MPEG-4, Layer 0, no CRC
-  adts[2] = ((1) << 6) | ((sampleRateIndex < 0 ? 4 : sampleRateIndex) << 2) | ((channels >> 2) & 1); // AAC-LC
-  adts[3] = ((channels & 3) << 6) | ((frameLength >> 11) & 3);
-  adts[4] = (frameLength >> 3) & 0xFF;
-  adts[5] = ((frameLength & 7) << 5) | 0x1F;
-  adts[6] = 0xFC;
-  adts.set(aacData, 7);
-  return adts;
-}
-
 // ── helpers ───────────────────────────────────────────────
 
 function parseTs(tsData) {
@@ -63,13 +47,25 @@ function isKeyframe(au) {
   return false;
 }
 
-/**
- * Mux video + audio access units into an MPEG-TS segment.
- */
+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();
 
-  // Extract SPS/PPS for the muxer
   let sps = null, pps = null;
   for (const au of videoAUs) {
     for (const nal of au.nalUnits) {
@@ -82,17 +78,13 @@ function muxToTs(videoAUs, audioAUs, audioSampleRate, audioChannels) {
   if (sps && pps) muxer.setSpsPps(sps, pps);
   muxer.setHasAudio(audioAUs.length > 0);
 
-  // Add audio samples (wrap raw AAC with ADTS headers)
   const sr = audioSampleRate || 48000;
   const ch = audioChannels || 2;
   for (const au of audioAUs) {
-    // Check if already has ADTS header
     const hasADTS = au.data.length > 1 && au.data[0] === 0xFF && (au.data[1] & 0xF0) === 0xF0;
-    const adtsData = hasADTS ? au.data : wrapADTS(au.data, sr, ch);
-    muxer.addAudioSample(adtsData, au.pts);
+    muxer.addAudioSample(hasADTS ? au.data : wrapADTS(au.data, sr, ch), au.pts);
   }
 
-  // Add video samples
   for (const au of videoAUs) {
     muxer.addVideoNalUnits(au.nalUnits, isKeyframe(au), au.pts, au.dts);
   }
@@ -101,54 +93,79 @@ function muxToTs(videoAUs, audioAUs, audioSampleRate, audioChannels) {
 }
 
 /**
- * Clip a parsed TS segment at the start and/or end.
- * Uses smart rendering (WebCodecs) when available for frame-accurate start.
- * Falls back to keyframe-accurate when WebCodecs is unavailable.
+ * Clip a parsed TS segment. Starts at nearest keyframe, ends at endTime.
+ * Returns the preroll (time from keyframe to requested start).
  */
-async function clipSegment(parser, startTime, endTime) {
-  const result = await smartRender(parser, startTime || 0, { endTime });
+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;
+  const audioAUs = parser.audioAccessUnits;
+
+  if (videoAUs.length === 0) return null;
+
+  // 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;
+  }
+
+  // Find end
+  let endIdx = videoAUs.length;
+  for (let i = keyframeIdx; i < videoAUs.length; i++) {
+    if (videoAUs[i].pts >= endPts) { endIdx = i; break; }
+  }
+
+  const clipped = videoAUs.slice(keyframeIdx, endIdx);
+  if (clipped.length === 0) return null;
 
-  if (result.videoAUs.length === 0) return null;
+  const keyframePts = clipped[0].pts;
+  const prerollPts = Math.max(0, startPts - keyframePts);
 
-  // Calculate duration from the actual content
-  const firstPts = result.videoAUs[0].pts;
-  const lastPts = result.videoAUs[result.videoAUs.length - 1].pts;
-  const frameDuration = result.videoAUs.length > 1
-    ? result.videoAUs[1].dts - result.videoAUs[0].dts
-    : 3003;
-  const duration = (lastPts - firstPts + frameDuration) / PTS_PER_SECOND;
+  // 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);
 
-  // Normalize timestamps to start at 0
-  const offset = firstPts;
-  for (const au of result.videoAUs) { au.pts -= offset; au.dts -= offset; }
-  for (const au of result.audioAUs) { au.pts -= offset; }
+  // 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; }
 
-  // Mux to TS (wrap raw AAC with ADTS headers)
-  const tsData = muxToTs(result.videoAUs, result.audioAUs, parser.audioSampleRate, parser.audioChannels);
+  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 tsData = muxToTs(clipped, clippedAudio, parser.audioSampleRate, parser.audioChannels);
 
   return {
     data: tsData,
     duration,
-    smartRendered: (result.smartRenderedFrames || 0) > 0,
-    smartRenderedFrames: result.smartRenderedFrames || 0,
+    preroll: prerollPts / PTS_PER_SECOND,
   };
 }
 
 // ── HlsClipResult ─────────────────────────────────────────
 
 class HlsClipResult {
-  constructor({ variants, duration, startTime, endTime }) {
+  /**
+   * @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;
   }
 
   get variantCount() {
     return this._variants.length;
   }
 
-  /** Master playlist m3u8 text */
   get masterPlaylist() {
     if (this._variants.length === 1) return this.getMediaPlaylist(0);
     let m3u8 = '#EXTM3U\n';
@@ -161,11 +178,6 @@ class HlsClipResult {
     return m3u8;
   }
 
-  /**
-   * Get media playlist for a variant.
-   * Boundary segments use custom URLs (served from memory).
-   * Middle segments use original CDN URLs.
-   */
   getMediaPlaylist(variantIndex = 0) {
     const variant = this._variants[variantIndex];
     if (!variant) throw new Error(`Variant ${variantIndex} not found`);
@@ -181,70 +193,37 @@ class HlsClipResult {
     for (let i = 0; i < variant.segments.length; i++) {
       const seg = variant.segments[i];
       m3u8 += `#EXTINF:${seg.duration.toFixed(6)},\n`;
-      if (seg.originalUrl) {
-        // Middle segment: original CDN URL (untouched)
-        m3u8 += `${seg.originalUrl}\n`;
-      } else {
-        // Boundary segment: served from memory
-        m3u8 += `segment-${variantIndex}-${i}.ts\n`;
-      }
+      m3u8 += seg.originalUrl || `segment-${variantIndex}-${i}.ts\n`;
     }
     m3u8 += '#EXT-X-ENDLIST\n';
     return m3u8;
   }
 
-  /**
-   * Get a segment's TS data.
-   * Boundary segments: return from memory.
-   * Middle segments: return null (use originalUrl from playlist).
-   */
   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`);
-
     if (seg.data) return seg.data;
-
-    // Middle segment: fetch from CDN (for cases where caller needs the data)
     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 null;
   }
-
-  /**
-   * Get all segment data (fetches middle segments from CDN).
-   */
-  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));
-    }
-    return results;
-  }
 }
 
-// ── main function ─────────────────────────────────────────
+// ── main ──────────────────────────────────────────────────
 
 /**
  * Clip an HLS stream to a time range.
  *
- * Output is a new HLS stream where:
- * - Boundary segments are smart-rendered (WebCodecs) or keyframe-accurate
- * - Middle segments use original CDN URLs (completely untouched)
+ * 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|HlsStream} source - HLS URL or parsed HlsStream
- * @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
- * @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;
@@ -255,7 +234,6 @@ export async function clipHls(source, options = {}) {
   log('Parsing HLS playlist...');
   const stream = typeof source === 'string' ? await parseHls(source, { onProgress: log }) : source;
 
-  // Resolve variants
   let variantsToProcess = [];
   if (stream.isMaster) {
     const sorted = stream.qualities;
@@ -264,40 +242,30 @@ export async function clipHls(source, options = {}) {
     else if (typeof quality === 'number') { stream.select(quality); variantsToProcess = [stream.selected]; }
     else variantsToProcess = sorted;
   } else {
-    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)...`);
-  if (isSmartRenderSupported()) {
-    log('Smart rendering: enabled (WebCodecs)');
-  } else {
-    log('Smart rendering: unavailable (keyframe-accurate fallback)');
-  }
 
   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
     let segments;
     if (variant._segments) {
       segments = variant._segments;
     } 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;
     }
 
     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');
 
@@ -307,56 +275,52 @@ export async function clipHls(source, options = {}) {
 
     log(`Segments: ${overlapping.length} (${firstSeg.startTime.toFixed(1)}s – ${lastSeg.endTime.toFixed(1)}s)`);
 
-    // Download and clip boundary segments
+    // Download and clip first boundary segment
     log('Downloading boundary segments...');
     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 = await clipSegment(firstParser, firstRelStart, firstRelEnd);
+    const firstClipped = clipSegment(firstParser, firstRelStart, firstRelEnd);
     if (!firstClipped) throw new Error('First segment clip produced no samples');
 
+    // Preroll from the first variant (all variants have similar GOP structure)
+    if (vi === 0) prerollDuration = firstClipped.preroll;
+
     const clipSegments = [];
 
-    // First segment (boundary, in memory)
     clipSegments.push({
       duration: firstClipped.duration,
       data: firstClipped.data,
       originalUrl: null,
-      isBoundary: true,
-      smartRendered: firstClipped.smartRendered,
     });
 
-    // Middle segments (original CDN URLs, untouched)
+    // 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,
-        isBoundary: false,
       });
     }
 
-    // Last segment (boundary, if different from first)
+    // 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 = await clipSegment(lastParser, undefined, lastRelEnd);
+      const lastClipped = clipSegment(lastParser, undefined, lastRelEnd);
       if (lastClipped && lastClipped.data) {
         clipSegments.push({
           duration: lastClipped.duration,
           data: lastClipped.data,
           originalUrl: null,
-          isBoundary: true,
-          smartRendered: lastClipped.smartRendered,
         });
       }
     }
 
     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,
@@ -370,6 +334,7 @@ export async function clipHls(source, options = {}) {
     duration: endTime - startTime,
     startTime,
     endTime,
+    prerollDuration,
   });
 }
 

package/src/index.js

@@ -339,7 +339,7 @@ toMp4.TSParser = TSParser;
 toMp4.RemoteMp4 = RemoteMp4;
 
 // Version (injected at build time for dist, read from package.json for ESM)
-toMp4.version = '1.5.0';
+toMp4.version = '1.5.1';
 
 // Export
 export {

package/src/codecs/smart-render.js

@@ -1,447 +0,0 @@
-/**
- * Smart Rendering via WebCodecs
- *
- * Re-encodes the boundary GOP of an HLS segment using the browser's
- * native WebCodecs API. Decodes preroll frames, re-encodes the target
- * frame as a new keyframe, and re-encodes subsequent frames until the
- * next original keyframe. Original compressed data is used from the
- * next keyframe onward.
- *
- * Falls back to keyframe-accurate clipping when WebCodecs is unavailable
- * (e.g., Node.js).
- *
- * @module codecs/smart-render
- */
-
-/**
- * Check if WebCodecs is available in the current environment.
- */
-export function isSmartRenderSupported() {
-  return typeof VideoDecoder !== 'undefined' && typeof VideoEncoder !== 'undefined';
-}
-
-/**
- * Smart-render a TS segment to produce a frame-accurate cut.
- *
- * Decodes from the keyframe before targetTime, re-encodes frames from
- * targetTime onward as new H.264 NAL units (starting with an IDR keyframe),
- * and uses original data from the next keyframe onward.
- *
- * @param {object} parser - Parsed TS segment (TSParser output)
- * @param {number} targetStartTime - Start time in seconds (relative to segment)
- * @param {object} [options]
- * @param {number} [options.endTime] - End time in seconds (relative to segment)
- * @param {number} [options.bitrate] - Encoding bitrate (default: auto from source)
- * @returns {Promise<object>} { videoAUs, audioAUs, actualStartTime }
- */
-export async function smartRender(parser, targetStartTime, options = {}) {
-  if (!isSmartRenderSupported()) {
-    return keyframeAccurateFallback(parser, targetStartTime, options);
-  }
-
-  const { endTime = Infinity } = options;
-  const PTS = 90000;
-  const targetPts = targetStartTime * PTS;
-  const endPts = endTime * PTS;
-  const videoAUs = parser.videoAccessUnits;
-  const audioAUs = parser.audioAccessUnits;
-
-  if (videoAUs.length === 0) {
-    return { videoAUs: [], audioAUs: [], actualStartTime: targetStartTime };
-  }
-
-  // Find keyframe at or before targetTime
-  let keyframeIdx = 0;
-  for (let i = 0; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts > targetPts) break;
-    if (_isKeyframe(videoAUs[i])) keyframeIdx = i;
-  }
-
-  // Find target frame (first frame at or after targetTime)
-  let targetIdx = keyframeIdx;
-  for (let i = keyframeIdx; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts >= targetPts) { targetIdx = i; break; }
-  }
-
-  // If target IS the keyframe, no smart rendering needed
-  if (targetIdx === keyframeIdx) {
-    return keyframeAccurateFallback(parser, targetStartTime, options);
-  }
-
-  // Find next keyframe after target
-  let nextKeyframeIdx = videoAUs.length;
-  for (let i = targetIdx + 1; i < videoAUs.length; i++) {
-    if (_isKeyframe(videoAUs[i])) { nextKeyframeIdx = i; break; }
-  }
-
-  // Find end frame
-  let endIdx = videoAUs.length;
-  for (let i = 0; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts >= endPts) { endIdx = i; break; }
-  }
-
-  // Extract SPS/PPS for decoder configuration
-  let sps = null, pps = null;
-  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) {
-    return keyframeAccurateFallback(parser, targetStartTime, options);
-  }
-
-  // Parse dimensions from SPS (simplified — just need width/height for encoder config)
-  const { width, height } = _parseSPSDimensions(sps);
-
-  // Estimate bitrate from the original segment
-  let totalBytes = 0;
-  for (const au of videoAUs) {
-    for (const nal of au.nalUnits) totalBytes += nal.length;
-  }
-  const segDuration = videoAUs.length > 1
-    ? (videoAUs[videoAUs.length - 1].pts - videoAUs[0].pts) / PTS
-    : 1;
-  const estimatedBitrate = options.bitrate || Math.round((totalBytes * 8) / segDuration);
-
-  try {
-    // ── Step 1: Decode preroll frames using VideoDecoder ──
-    const decodedFrames = await _decodeFrames(videoAUs, keyframeIdx, Math.min(nextKeyframeIdx, endIdx), sps, pps, width, height);
-
-    // ── Step 2: Re-encode from targetIdx onward using VideoEncoder ──
-    const reEncodedNALs = await _encodeFrames(
-      decodedFrames, targetIdx - keyframeIdx, Math.min(nextKeyframeIdx, endIdx) - keyframeIdx,
-      width, height, estimatedBitrate
-    );
-
-    // ── Step 3: Build output access units ──
-    const outputVideo = [];
-    const targetPtsActual = videoAUs[targetIdx].pts;
-
-    // Re-encoded frames (targetIdx to nextKeyframeIdx)
-    for (let i = 0; i < reEncodedNALs.length; i++) {
-      const srcIdx = targetIdx + i;
-      if (srcIdx >= endIdx) break;
-      outputVideo.push({
-        nalUnits: i === 0
-          ? [sps, pps, ...reEncodedNALs[i]] // First frame gets SPS/PPS
-          : reEncodedNALs[i],
-        pts: videoAUs[srcIdx].pts,
-        dts: videoAUs[srcIdx].dts,
-      });
-    }
-
-    // Original frames from next keyframe onward
-    for (let i = nextKeyframeIdx; i < endIdx; i++) {
-      outputVideo.push(videoAUs[i]);
-    }
-
-    // Clip audio to match
-    const audioStartPts = targetPtsActual;
-    const audioEndPts = endIdx < videoAUs.length ? videoAUs[endIdx - 1].pts + PTS : Infinity;
-    const outputAudio = audioAUs.filter(au => au.pts >= audioStartPts && au.pts < audioEndPts);
-
-    // Clean up decoded frames
-    for (const frame of decodedFrames) {
-      if (frame && typeof frame.close === 'function') frame.close();
-    }
-
-    return {
-      videoAUs: outputVideo,
-      audioAUs: outputAudio,
-      actualStartTime: targetPtsActual / PTS,
-      smartRenderedFrames: reEncodedNALs.length,
-      originalFrames: Math.max(0, endIdx - nextKeyframeIdx),
-    };
-  } catch (e) {
-    // WebCodecs failed — fall back to keyframe-accurate
-    console.warn('Smart render failed, falling back to keyframe-accurate:', e.message);
-    return keyframeAccurateFallback(parser, targetStartTime, options);
-  }
-}
-
-// ── WebCodecs decode ──────────────────────────────────────
-
-async function _decodeFrames(videoAUs, startIdx, endIdx, sps, pps, width, height) {
-  const frames = [];
-  let resolveFrame;
-
-  const decoder = new VideoDecoder({
-    output(frame) {
-      frames.push(frame);
-      if (resolveFrame) resolveFrame();
-    },
-    error(e) {
-      console.error('VideoDecoder error:', e);
-    },
-  });
-
-  // Build avcC description for decoder config
-  const description = _buildAvcCDescription(sps, pps);
-
-  decoder.configure({
-    codec: 'avc1.' + _avcProfileString(sps),
-    codedWidth: width,
-    codedHeight: height,
-    description,
-    optimizeForLatency: true,
-  });
-
-  // Feed frames from keyframe to endIdx
-  for (let i = startIdx; i < endIdx; i++) {
-    const au = videoAUs[i];
-    const isKey = _isKeyframe(au);
-
-    // Convert NAL units to AVCC format (4-byte length prefix)
-    const avccData = _nalUnitsToAVCC(au.nalUnits);
-
-    const chunk = new EncodedVideoChunk({
-      type: isKey ? 'key' : 'delta',
-      timestamp: au.pts, // microseconds for WebCodecs? No, we use our PTS
-      data: avccData,
-    });
-
-    const framePromise = new Promise(r => { resolveFrame = r; });
-    decoder.decode(chunk);
-    await framePromise;
-  }
-
-  await decoder.flush();
-  decoder.close();
-
-  return frames;
-}
-
-// ── WebCodecs encode ──────────────────────────────────────
-
-async function _encodeFrames(decodedFrames, startOffset, endOffset, width, height, bitrate) {
-  const encodedNALs = [];
-  let resolveChunk;
-
-  const encoder = new VideoEncoder({
-    output(chunk, metadata) {
-      // Extract H.264 NAL units from the encoded chunk
-      const buffer = new Uint8Array(chunk.byteLength);
-      chunk.copyTo(buffer);
-
-      // The encoder output is in AVCC format — convert to NAL units
-      const nals = _avccToNALUnits(buffer);
-      encodedNALs.push(nals);
-      if (resolveChunk) resolveChunk();
-    },
-    error(e) {
-      console.error('VideoEncoder error:', e);
-    },
-  });
-
-  encoder.configure({
-    codec: 'avc1.640028', // High profile, level 4.0
-    width,
-    height,
-    bitrate,
-    framerate: 30,
-    latencyMode: 'quality',
-    avc: { format: 'annexb' }, // Get Annex B output (start codes)
-  });
-
-  for (let i = startOffset; i < Math.min(endOffset, decodedFrames.length); i++) {
-    const frame = decodedFrames[i];
-    if (!frame) continue;
-
-    const chunkPromise = new Promise(r => { resolveChunk = r; });
-    encoder.encode(frame, { keyFrame: i === startOffset }); // First frame = keyframe
-    await chunkPromise;
-  }
-
-  await encoder.flush();
-  encoder.close();
-
-  return encodedNALs;
-}
-
-// ── Keyframe-accurate fallback ────────────────────────────
-
-function keyframeAccurateFallback(parser, targetStartTime, options = {}) {
-  const { endTime = Infinity } = options;
-  const PTS = 90000;
-  const targetPts = targetStartTime * PTS;
-  const endPts = endTime * PTS;
-  const videoAUs = parser.videoAccessUnits;
-  const audioAUs = parser.audioAccessUnits;
-
-  if (videoAUs.length === 0) {
-    return { videoAUs: [], audioAUs: [], actualStartTime: targetStartTime };
-  }
-
-  // Find keyframe at or before targetTime
-  let keyframeIdx = 0;
-  for (let i = 0; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts > targetPts) break;
-    if (_isKeyframe(videoAUs[i])) keyframeIdx = i;
-  }
-
-  // Find end
-  let endIdx = videoAUs.length;
-  for (let i = 0; i < videoAUs.length; i++) {
-    if (videoAUs[i].pts >= endPts) { endIdx = i; break; }
-  }
-
-  const clippedVideo = videoAUs.slice(keyframeIdx, endIdx);
-  const startPts = clippedVideo.length > 0 ? clippedVideo[0].pts : 0;
-  const endVideoPts = endIdx < videoAUs.length ? videoAUs[endIdx - 1].pts + PTS : Infinity;
-  const clippedAudio = audioAUs.filter(au => au.pts >= startPts && au.pts < endVideoPts);
-
-  return {
-    videoAUs: clippedVideo,
-    audioAUs: clippedAudio,
-    actualStartTime: startPts / PTS,
-    smartRenderedFrames: 0,
-    originalFrames: clippedVideo.length,
-  };
-}
-
-// ── Helpers ───────────────────────────────────────────────
-
-function _isKeyframe(au) {
-  for (const nal of au.nalUnits) {
-    if ((nal[0] & 0x1F) === 5) return true;
-  }
-  return false;
-}
-
-function _parseSPSDimensions(sps) {
-  // Minimal SPS dimension parsing (reuses logic from muxers/mp4.js parseSPS)
-  let width = 1920, height = 1080;
-  if (!sps || sps.length < 4) return { width, height };
-
-  try {
-    let offset = 1;
-    const profile = sps[offset++];
-    offset += 2; // constraint flags + level
-
-    let bitPos = offset * 8;
-    const getBit = () => (sps[Math.floor(bitPos / 8)] >> (7 - (bitPos++ % 8))) & 1;
-    const readUE = () => {
-      let z = 0;
-      while (bitPos < sps.length * 8 && getBit() === 0) z++;
-      let v = (1 << z) - 1;
-      for (let i = 0; i < z; i++) v += getBit() << (z - 1 - i);
-      return v;
-    };
-
-    readUE(); // sps_id
-    if ([100, 110, 122, 244, 44, 83, 86, 118, 128].includes(profile)) {
-      const cf = readUE(); if (cf === 3) getBit();
-      readUE(); readUE(); getBit();
-      if (getBit()) { for (let i = 0; i < (cf !== 3 ? 8 : 12); i++) { if (getBit()) { const s = i < 6 ? 16 : 64; let ls = 8, ns = 8; for (let j = 0; j < s; j++) { if (ns !== 0) { const ds = readUE(); // readSE actually
-        ns = (ls + ds + 256) % 256; } ls = ns === 0 ? ls : ns; } } } }
-    }
-    readUE(); // log2_max_frame_num
-    const pocType = readUE();
-    if (pocType === 0) readUE();
-    else if (pocType === 1) { getBit(); readUE(); readUE(); const n = readUE(); for (let i = 0; i < n; i++) readUE(); }
-    readUE(); getBit(); // max_ref_frames, gaps
-
-    const mbW = readUE() + 1;
-    const mbH = readUE() + 1;
-    const frameMbsOnly = getBit();
-    if (!frameMbsOnly) getBit();
-    getBit(); // direct_8x8
-
-    let cropL = 0, cropR = 0, cropT = 0, cropB = 0;
-    if (getBit()) { cropL = readUE(); cropR = readUE(); cropT = readUE(); cropB = readUE(); }
-
-    width = mbW * 16 - (cropL + cropR) * 2;
-    height = (2 - frameMbsOnly) * mbH * 16 - (cropT + cropB) * (frameMbsOnly ? 2 : 4);
-  } catch (e) { /* use defaults */ }
-
-  return { width, height };
-}
-
-function _avcProfileString(sps) {
-  return [sps[1], sps[2], sps[3]].map(b => b.toString(16).padStart(2, '0')).join('');
-}
-
-function _buildAvcCDescription(sps, pps) {
-  const data = new Uint8Array(11 + sps.length + pps.length);
-  const view = new DataView(data.buffer);
-  data[0] = 1; data[1] = sps[1]; data[2] = sps[2]; data[3] = sps[3];
-  data[4] = 0xFF; data[5] = 0xE1;
-  view.setUint16(6, sps.length); data.set(sps, 8);
-  data[8 + sps.length] = 1;
-  view.setUint16(9 + sps.length, pps.length);
-  data.set(pps, 11 + sps.length);
-  return data;
-}
-
-function _nalUnitsToAVCC(nalUnits) {
-  // Filter out SPS/PPS/AUD/SEI — decoder config handles those
-  const videoNals = nalUnits.filter(nal => {
-    const t = nal[0] & 0x1F;
-    return t === 1 || t === 5; // non-IDR or IDR slice
-  });
-
-  let totalSize = 0;
-  for (const nal of videoNals) totalSize += 4 + nal.length;
-  const result = new Uint8Array(totalSize);
-  const view = new DataView(result.buffer);
-  let offset = 0;
-  for (const nal of videoNals) {
-    view.setUint32(offset, nal.length);
-    result.set(nal, offset + 4);
-    offset += 4 + nal.length;
-  }
-  return result;
-}
-
-function _avccToNALUnits(data) {
-  // Parse Annex B format (start codes) or AVCC (length-prefixed)
-  const nals = [];
-
-  // Check for Annex B (0x00000001 or 0x000001)
-  if (data.length >= 4 && data[0] === 0 && data[1] === 0) {
-    let i = 0;
-    while (i < data.length - 3) {
-      // Find start code
-      let scLen = 0;
-      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 1) scLen = 3;
-      else if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0 && data[i + 3] === 1) scLen = 4;
-
-      if (scLen > 0) {
-        const nalStart = i + scLen;
-        // Find next start code
-        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) {
-          nals.push(data.slice(nalStart, nalEnd));
-        }
-        i = nalEnd;
-      } else {
-        i++;
-      }
-    }
-  } else {
-    // AVCC format (4-byte length prefix)
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    let offset = 0;
-    while (offset + 4 < data.length) {
-      const len = view.getUint32(offset);
-      if (len > 0 && offset + 4 + len <= data.length) {
-        nals.push(data.slice(offset + 4, offset + 4 + len));
-      }
-      offset += 4 + len;
-    }
-  }
-
-  return nals;
-}
-
-export default smartRender;