hyperframes 0.8.146 → 0.8.148

package/dist/{chunk-WU2B74TL.js → chunk-VC7JBNPS.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-BAKPN2D2.js";
+} from "./chunk-AHBYQRGI.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -55,7 +55,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-Z6FLHIDV.js";
+} from "./chunk-3WD4JNMU.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -6105,20 +6105,26 @@ async function prepareFrameForCapture(session, frameIndex, time, seekOptions, he
     seekOptions?.subFrameDivisions
   );
   const seekStart = Date.now();
+  session.captureStep = "seeking the timeline";
   const hasPendingComposite = await seekPageTimeline(page, quantizedTime, seekOptions);
+  session.captureStep = "decoding CSS background images";
   await decodeDynamicCssBackgroundImages(page);
   const seekMs = Date.now() - seekStart;
   const beforeCaptureStart = Date.now();
   if (session.onBeforeCapture) {
+    session.captureStep = "injecting video frames";
     await session.onBeforeCapture(page, quantizedTime, heldVideoTime);
   }
+  session.captureStep = "waiting for page seek handlers";
   await waitForPendingSeekCompletion(page);
+  session.captureStep = "loading color-grading LUTs";
   await page.evaluate(async () => {
     const runtime = window.__hf?.colorGrading;
     await runtime?.waitForActiveLuts?.();
   });
   const beforeCaptureMs = Date.now() - beforeCaptureStart;
   if (hasPendingComposite && session.captureMode !== "beginframe" && session.captureMode !== "drawelement") {
+    session.captureStep = "compositing the page";
     await page.evaluate(async () => {
       const w = window;
       if (typeof w.__hf_page_composite_prepare === "function") {
@@ -6138,6 +6144,7 @@ async function prepareFrameForCapture(session, frameIndex, time, seekOptions, he
       }
     });
   }
+  session.captureStep = "capturing the frame";
   return { quantizedTime, seekMs, beforeCaptureMs };
 }
 function computeAuthoredClipBoundaryFrames(schedule, fps) {
@@ -6868,10 +6875,12 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan)
   const fps = fpsToNumber(session.options.fps);
   const frameTime = quantizeSeekTime(absFrameIndex / fps, fps);
   const eventfulSeekStart = Date.now();
+  session.captureStep = "seeking the timeline";
   await seekPageTimeline(session.page, frameTime, void 0);
   const totals = { seekMs: Date.now() - eventfulSeekStart, beforeCaptureMs: 0, screenshotMs: 0 };
   if (session.onBeforeCapture) {
     const injectStart = Date.now();
+    session.captureStep = "injecting video frames";
     await session.onBeforeCapture(session.page, frameTime, frameTime);
     totals.beforeCaptureMs += Date.now() - injectStart;
   }
@@ -6910,6 +6919,7 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan)
     accumulator.add(sample.buffer);
   }
   const restoreSeekStart = Date.now();
+  session.captureStep = "seeking the timeline";
   await seekPageTimeline(session.page, frameTime, { suppressEvents: true });
   totals.seekMs += Date.now() - restoreSeekStart;
   const blended = accumulator.finish();
@@ -7083,6 +7093,7 @@ async function captureFramesBatchPipelined(session, frameIndices, times) {
   const startTime = Date.now();
   const fps = fpsToNumber(options.fps);
   const quantized = times.map((t) => quantizeTimeToFrame(t, fps));
+  session.captureStep = "capturing the frame";
   const { encodeResults, failedAt, error } = await produceDrawElementFrameBatch(
     page,
     quantized,
@@ -8352,6 +8363,7 @@ async function extractMediaMetadata(filePath) {
       durationSeconds: containerDuration,
       videoStreamDurationSeconds: effectiveStreamDuration,
       videoStreamStartSeconds: streamStart,
+      videoStreamLeadSeconds: streamLeadSeconds(output, videoStream),
       width: videoStream.width || stillImage()?.width || 0,
       height: videoStream.height || stillImage()?.height || 0,
       fps,
@@ -8456,13 +8468,28 @@ async function extractAudioMetadata(filePath, options) {
       sampleRate,
       channels: audioStream.channels || 2,
       audioCodec,
-      bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0
+      bitrate: output.format.bit_rate ? parseInt(output.format.bit_rate) : void 0,
+      latestStreamLeadSeconds: latestStreamLeadSeconds(output)
     };
   })();
   if (options?.signal) return probePromise;
   writeMetadataCache(audioMetadataCache, filePath, identity, probePromise);
   return probePromise;
 }
+function audioVideoStreamStarts(output) {
+  return (output?.streams ?? []).filter(
+    (s) => (s.codec_type === "audio" || s.codec_type === "video") && s.disposition?.attached_pic !== 1
+  ).map((s) => parseFloat(s.start_time ?? "")).filter(Number.isFinite);
+}
+function streamLeadSeconds(output, stream) {
+  const starts = audioVideoStreamStarts(output);
+  const start = parseFloat(stream.start_time ?? "");
+  return Number.isFinite(start) && starts.length > 0 ? Math.max(0, start - Math.min(...starts)) : 0;
+}
+function latestStreamLeadSeconds(output) {
+  const starts = audioVideoStreamStarts(output);
+  return starts.length > 0 ? Math.max(...starts) - Math.min(...starts) : 0;
+}
 function audioStartSeconds(stream, format) {
   const start = parseFloat(stream.start_time ?? format.start_time ?? "");
   return Number.isFinite(start) ? start : 0;
@@ -11930,9 +11957,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (framePaths.size > 0 && duration > 0 && !options.finalFrameOnly && !options.frameRanges) {
     const expectedAtFps = extractionFrameCountForDuration(duration, normalizedFps, metadata.isVFR);
     if (expectedAtFps > 0 && framePaths.size <= expectedAtFps * 0.6) {
-      const correctedDuration = startTime + framePaths.size / fps;
-      if (correctedDuration < metadata.videoStreamDurationSeconds) {
-        metadata.videoStreamDurationSeconds = correctedDuration;
+      const correctedStreamDuration = startTime + framePaths.size / fps - (metadata.videoStreamLeadSeconds ?? 0);
+      if (correctedStreamDuration < metadata.videoStreamDurationSeconds) {
+        metadata.videoStreamDurationSeconds = correctedStreamDuration;
       }
     }
   }
@@ -11973,7 +12000,7 @@ function resolveSegmentDuration(requested, mediaStart, sourceDuration) {
   return sourceRemaining > 0 ? sourceRemaining : sourceDuration;
 }
 function resolvePlayableVideoDuration(metadata) {
-  return Number.isFinite(metadata.videoStreamDurationSeconds) && metadata.videoStreamDurationSeconds > 0 ? metadata.videoStreamDurationSeconds : metadata.durationSeconds;
+  return Number.isFinite(metadata.videoStreamDurationSeconds) && metadata.videoStreamDurationSeconds > 0 ? (metadata.videoStreamLeadSeconds ?? 0) + metadata.videoStreamDurationSeconds : metadata.durationSeconds;
 }
 function canHoldFinalFramePastEof(video) {
   const timelineDuration = video.end - video.start;
@@ -12087,10 +12114,11 @@ function resolveTimelineExtractionWindow(video, resolvedDuration, timelineEnd, s
 async function resolveFinalFrameExtractionWindow(videoPath, video, metadata, window2, signal) {
   if (!window2.ensureFinalFrame) return window2;
   const playableDuration = resolvePlayableVideoDuration(metadata);
-  const finalFrameTimestamp = await extractFinalVideoFrameTimestamp(
+  const videoStreamLead = metadata.videoStreamLeadSeconds ?? 0;
+  const finalFrameTimestamp = videoStreamLead + await extractFinalVideoFrameTimestamp(
     videoPath,
     {
-      videoStreamDurationSeconds: playableDuration,
+      videoStreamDurationSeconds: playableDuration - videoStreamLead,
       videoStreamStartSeconds: metadata.videoStreamStartSeconds
     },
     signal
@@ -12903,6 +12931,10 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     phaseBreakdown: breakdown
   };
 }
+var BROWSER_SHOWS_UPCOMING_FIRST_FRAME_WITHIN_SECONDS = 1;
+function isVideoHiddenBeforeStreamStart(videoStreamLeadSeconds, mediaTime) {
+  return (videoStreamLeadSeconds ?? 0) - mediaTime >= BROWSER_SHOWS_UPCOMING_FIRST_FRAME_WITHIN_SECONDS - 1e-6;
+}
 function getFrameIndexAtTime(extracted, globalTime, videoStart, loop = false, mediaStart = 0, holdLastFrame = false, playbackRate = 1) {
   let localTime = Math.max(0, globalTime - videoStart);
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
@@ -12920,6 +12952,12 @@ function getFrameIndexAtTime(extracted, globalTime, videoStart, loop = false, me
   }
   const frameIndex = Math.floor(sourceTime * extracted.fps + 1e-9);
   if (frameIndex < 0 || extracted.totalFrames <= 0) return null;
+  if (isVideoHiddenBeforeStreamStart(
+    extracted.metadata.videoStreamLeadSeconds,
+    mediaStart + sourceTime
+  )) {
+    return null;
+  }
   if (frameIndex >= extracted.totalFrames) {
     return loop || holdLastFrame ? extracted.totalFrames - 1 : null;
   }
@@ -14258,11 +14296,11 @@ function buildAtempoFilter(playbackRate) {
 }
 var RAMP_SLICE_SECONDS = 0.25;
 var MAX_RAMP_SLICES = 240;
-function buildRampFilterComplex(lane, duration, tailFilter) {
+function buildRampFilterComplex(lane, duration, headFilter, tailFilter) {
   const slices = Math.min(MAX_RAMP_SLICES, Math.max(1, Math.ceil(duration / RAMP_SLICE_SECONDS)));
   const step = duration / slices;
   const split = Array.from({ length: slices }, (_, i) => `[s${i}]`).join("");
-  const parts = [`[0:a]asplit=${slices}${split}`];
+  const parts = [`[0:a]${headFilter ? `${headFilter},` : ""}asplit=${slices}${split}`];
   for (let i = 0; i < slices; i += 1) {
     const from = sourceTimeAt(lane, i * step);
     const to = sourceTimeAt(lane, (i + 1) * step);
@@ -14282,24 +14320,16 @@ function buildRampFilterComplex(lane, duration, tailFilter) {
   if (tailFilter) parts.push(`[cat]${tailFilter}[out]`);
   return parts.join(";");
 }
-function preparedAudioOutputArgs(srcPath, playbackRate, duration = 0) {
-  return stereoOutputArgs(srcPath).then((channelArgs) => {
-    const filters = [];
-    const outputArgs = [];
-    if (channelArgs[0] === "-af" && channelArgs[1]) {
-      filters.push(channelArgs[1]);
-    } else {
-      outputArgs.push(...channelArgs);
-    }
-    if (typeof playbackRate === "object") {
-      const graph = buildRampFilterComplex(playbackRate, duration, filters.join(",") || null);
-      return ["-filter_complex", graph, "-map", "[out]", ...outputArgs];
-    }
-    const atempo = buildAtempoFilter(playbackRate);
-    if (atempo) filters.push(atempo);
-    if (filters.length > 0) outputArgs.push("-af", filters.join(","));
-    return outputArgs;
-  });
+function preparedAudioOutputArgs(metadata, playbackRate, duration, headFilter) {
+  const channelFilter = metadata?.channels === 1 ? STEREO_CHANNEL_FILTER : null;
+  const outputArgs = channelFilter ? [] : ["-ac", "2"];
+  if (typeof playbackRate === "object") {
+    const graph = buildRampFilterComplex(playbackRate, duration, headFilter, channelFilter);
+    return ["-filter_complex", graph, "-map", "[out]", ...outputArgs];
+  }
+  const filters = [headFilter, channelFilter, buildAtempoFilter(playbackRate)].filter(Boolean);
+  if (filters.length > 0) outputArgs.push("-af", filters.join(","));
+  return outputArgs;
 }
 function escapeExpressionCommas(expression) {
   return expression.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
@@ -14310,14 +14340,6 @@ function legacyFilterScriptOptionIsUnsupported(stderr) {
 var MAX_VOLUME_SEGMENTS = 32;
 var VOLUME_SIMPLIFY_EPSILON = 5e-3;
 var STEREO_CHANNEL_FILTER = "pan=stereo|FL=FL+FC|FR=FR+FC";
-async function stereoOutputArgs(srcPath) {
-  try {
-    const { channels } = await extractAudioMetadata(srcPath);
-    if (channels === 1) return ["-af", STEREO_CHANNEL_FILTER];
-  } catch {
-  }
-  return ["-ac", "2"];
-}
 function simplifyVolumeKeyframes(keyframes) {
   if (keyframes.length < 3) return keyframes;
   const keep = new Array(keyframes.length).fill(false);
@@ -14581,71 +14603,24 @@ function parseAudioElements(html) {
   }
   return elements;
 }
-async function extractAudioFromVideo(videoPath, outputPath, options, signal, config) {
-  const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
-  const outputDir = dirname6(outputPath);
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
-  const playbackRate = normalizeRateSpec(options?.playbackRate);
-  const args = [];
-  if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
-  if (options?.duration !== void 0) {
-    args.push("-t", String(sourceTimeAt(playbackRate, options.duration)));
-  }
-  args.push("-i", videoPath);
-  const outputArgs = await preparedAudioOutputArgs(videoPath, playbackRate, options?.duration);
-  args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
-  if (playbackRate !== 1 && options?.duration !== void 0) {
-    args.push("-t", String(options.duration));
-  }
-  args.push("-y", outputPath);
-  const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
-  if (signal?.aborted) {
-    const failure = {
-      stage: "cancelled",
-      reason: "cancelled",
-      owner: "user",
-      retryable: false,
-      detail: "Audio extract cancelled"
-    };
-    return {
-      success: false,
-      outputPath,
-      durationMs: result.durationMs,
-      error: failure.detail,
-      failure
-    };
-  }
-  if (!result.success) {
-    const failure = ffmpegFailure("extract", result);
-    return {
-      success: false,
-      outputPath,
-      durationMs: result.durationMs,
-      error: failure.detail,
-      failure
-    };
-  }
-  return { success: true, outputPath, durationMs: result.durationMs };
-}
-async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, playbackRate = 1, signal, config) {
+async function extractAudioSegment(srcPath, outputPath, stage, mediaStart, duration, playbackRate = 1, signal, config) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname6(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
-  const outputArgs = await preparedAudioOutputArgs(srcPath, normalizedPlaybackRate, duration);
-  const args = [
-    "-ss",
-    String(mediaStart),
-    "-t",
-    String(sourceTimeAt(normalizedPlaybackRate, duration)),
-    "-i",
-    srcPath,
-    "-acodec",
-    "pcm_s16le",
-    "-ar",
-    "48000",
-    ...outputArgs
-  ];
+  const sourceDuration = sourceTimeAt(normalizedPlaybackRate, duration);
+  const metadata = await extractAudioMetadata(srcPath).catch(() => null);
+  const inputSeek = mediaStart >= (metadata?.latestStreamLeadSeconds ?? 0);
+  const start = formatFilterNumber(mediaStart);
+  const timestampTrim = inputSeek ? null : `atrim=start=${start}:end=${formatFilterNumber(mediaStart + sourceDuration)},asetpts=PTS-${start}/TB,aresample=async=1:first_pts=0`;
+  const outputArgs = preparedAudioOutputArgs(
+    metadata,
+    normalizedPlaybackRate,
+    duration,
+    timestampTrim
+  );
+  const args = inputSeek ? ["-ss", String(mediaStart), "-t", String(sourceDuration), "-i", srcPath] : ["-i", srcPath];
+  args.push("-vn", "-acodec", "pcm_s16le", "-ar", "48000", ...outputArgs);
   if (normalizedPlaybackRate !== 1) args.push("-t", String(duration));
   args.push("-y", outputPath);
   const result = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
@@ -14655,7 +14630,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, play
       reason: "cancelled",
       owner: "user",
       retryable: false,
-      detail: "Audio prepare cancelled"
+      detail: `Audio ${stage} cancelled`
     };
     return {
       success: false,
@@ -14665,7 +14640,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, play
       failure: failure2
     };
   }
-  const failure = !result.success ? ffmpegFailure("prepare", result) : void 0;
+  const failure = !result.success ? ffmpegFailure(stage, result) : void 0;
   return {
     success: result.success,
     outputPath,
@@ -15007,14 +14982,13 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         let audioSrcPath = srcPath;
         if (element.type === "video") {
           const extractedPath = join13(workDir, `${element.id}-extracted.wav`);
-          const extractResult = await extractAudioFromVideo(
+          const extractResult = await extractAudioSegment(
             srcPath,
             extractedPath,
-            {
-              startTime: element.mediaStart,
-              duration: element.end - element.start,
-              playbackRate: element.playbackRate
-            },
+            "extract",
+            element.mediaStart,
+            element.end - element.start,
+            element.playbackRate,
             effectiveSignal,
             config
           );
@@ -15034,9 +15008,10 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           audioSrcPath = extractedPath;
         } else {
           const trimmedPath = join13(workDir, `${element.id}-trimmed.wav`);
-          const prepResult = await prepareAudioTrack(
+          const prepResult = await extractAudioSegment(
             srcPath,
             trimmedPath,
+            "prepare",
             element.mediaStart,
             element.end - element.start,
             element.playbackRate,
@@ -16616,6 +16591,7 @@ export {
   resolveVideoExtractionWindow,
   resolveVideoExtractionDuration,
   extractAllVideoFrames,
+  isVideoHiddenBeforeStreamStart,
   getFrameAtTime,
   analyzeClipMediaFit,
   FrameLookupTable,

package/dist/{chunk-ZVZSFDW3.js → chunk-VHJPGKUW.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   getMimeType
-} from "./chunk-Z5C4LEAD.js";
+} from "./chunk-C24LU5XD.js";
 import {
   injectTagsAtHeadStart
-} from "./chunk-Z6FLHIDV.js";
+} from "./chunk-3WD4JNMU.js";
 
 // src/utils/compositionServer.ts
 import { createHash } from "crypto";

package/dist/{chunk-R6R74HNZ.js → chunk-VXM4BH23.js}

@@ -16,7 +16,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-KG265HQ7.js";
+} from "./chunk-K4RIT6PX.js";
 import {
   createStudioPositionSeekReapplyScript
 } from "./chunk-EOOEC32M.js";
@@ -105,6 +105,7 @@ import {
   isNotMediaPayload,
   isTransientBrowserError,
   isVideoFrameFormat,
+  isVideoHiddenBeforeStreamStart,
   isVideoPastTimelineEnd,
   mergeWorkerFrames,
   muxVideoWithAudio,
@@ -145,7 +146,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-WU2B74TL.js";
+} from "./chunk-VC7JBNPS.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -158,7 +159,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-JBQJKC23.js";
+} from "./chunk-62RUQJ5J.js";
 import {
   LOW_MEMORY_TOTAL_MB_THRESHOLD,
   getCgroupMemoryLimitMb,
@@ -179,7 +180,7 @@ import {
   resolveAbsoluteMediaStartSeconds,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-BAKPN2D2.js";
+} from "./chunk-AHBYQRGI.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -206,7 +207,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-Z6FLHIDV.js";
+} from "./chunk-3WD4JNMU.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-YA62XGXS.js";
@@ -2216,6 +2217,8 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrVideoFrameSources, hdrStart
     frameSource.loop
   );
   if (effectiveIndex === null) return;
+  const mediaTime = (frameSource.mediaStart ?? 0) + effectiveIndex / fps;
+  if (isVideoHiddenBeforeStreamStart(frameSource.videoStreamLeadSeconds, mediaTime)) return;
   const frameOffset = effectiveIndex * frameSource.frameSize;
   try {
     if (hdrPerf) hdrPerf.hdrVideoLayerBlits += 1;
@@ -2824,7 +2827,10 @@ async function extractHdrVideoFrames(args) {
       initialWindow,
       abortSignal
     );
-    extractionWindows.set(videoId, window2);
+    extractionWindows.set(videoId, {
+      window: window2,
+      videoStreamLeadSeconds: metadata.videoStreamLeadSeconds
+    });
     prep.hdrVideoStartTimes.set(videoId, window2.compositionStart);
     plannedVideos.push({
       durationSeconds: window2.durationSeconds,
@@ -2843,14 +2849,16 @@ async function extractHdrVideoFrames(args) {
   try {
     for (const [videoId, srcPath] of prep.hdrVideoSrcPaths) {
       const video = composition.videos.find((v) => v.id === videoId);
-      const window2 = extractionWindows.get(videoId);
-      if (!video || !window2) continue;
+      const planned = extractionWindows.get(videoId);
+      if (!video || !planned) continue;
+      const { window: window2 } = planned;
       mkdirSync2(framesDir, { recursive: true });
       const frameDir = mkdtempSync2(join7(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
       const rawPath = join7(frameDir, "frames.rgb48le");
-      const extractionStart = String(window2.extractionMediaStart ?? window2.mediaStart);
+      const extractionMediaStart = window2.extractionMediaStart ?? window2.mediaStart;
+      const extractionStart = String(extractionMediaStart);
       const ffmpegArgs = [];
       if (window2.finalFrameOnly) {
         ffmpegArgs.push("-i", srcPath, "-ss", extractionStart, "-frames:v", "1");
@@ -2910,7 +2918,9 @@ async function extractHdrVideoFrames(args) {
           frameSize,
           frameCount,
           scratch: Buffer.allocUnsafe(frameSize),
-          loop: video.loop
+          loop: video.loop,
+          mediaStart: extractionMediaStart,
+          videoStreamLeadSeconds: planned.videoStreamLeadSeconds
         });
         handedOff = true;
       } finally {
@@ -3476,12 +3486,13 @@ function buildRenderPerfSummary(input) {
 // ../producer/src/services/render/stages/captureStreamingStage.ts
 var DEFAULT_CAPTURE_STALL_MS = 6e4;
 var DE_STALL_POLL_MS = 5e3;
+var STALL_ADVICE = "Chrome stopped answering. If another app is keeping the GPU or CPU busy (a 3D render, a game, another export), let it finish or render one job at a time, then retry.";
 var ParallelCaptureStallError = class extends Error {
   variant;
   constructor(args) {
     const phases = args.phaseSummary ? ` Last worker phases: ${args.phaseSummary}.` : "";
     super(
-      args.variant === "drain" ? `[Render] Parallel ${args.captureLabel} capture stalled: no frame progress for ${args.stallTimeoutMs}ms (stuck at ${args.lastCapturedFrames}/${args.totalFrames}).${phases}` : `[Render] Parallel ${args.captureLabel} capture stalled after ${args.stallTimeoutMs}ms with no frame progress (last frame ${args.lastCapturedFrames}/${args.totalFrames}); retrying on a fresh screenshot session.${phases}`
+      (args.variant === "drain" ? `[Render] Parallel ${args.captureLabel} capture stalled: no frame progress for ${args.stallTimeoutMs}ms (stuck at ${args.lastCapturedFrames}/${args.totalFrames}).${phases}` : `[Render] Parallel ${args.captureLabel} capture stalled after ${args.stallTimeoutMs}ms with no frame progress (last frame ${args.lastCapturedFrames}/${args.totalFrames}); retrying on a fresh screenshot session.${phases}`) + ` ${STALL_ADVICE}`
     );
     this.name = "ParallelCaptureStallError";
     this.variant = args.variant;
@@ -3499,12 +3510,13 @@ function captureModeLabel(mode) {
 }
 var SequentialCaptureStallError = class extends Error {
   captureMode;
-  constructor(captureMode, stallTimeoutMs, frameIndex, totalFrames) {
+  constructor(session, stallTimeoutMs, frameIndex, totalFrames) {
+    const step = session.captureStep ? ` while ${session.captureStep}` : "";
     super(
-      `[Render] Sequential ${captureModeLabel(captureMode)} capture stalled: no frame progress for ${stallTimeoutMs}ms (stuck at frame ${frameIndex}/${totalFrames}).`
+      `[Render] Sequential ${captureModeLabel(session.captureMode)} capture stalled: no frame progress for ${stallTimeoutMs}ms (stuck at frame ${frameIndex}/${totalFrames}${step}). ` + STALL_ADVICE
     );
     this.name = "SequentialCaptureStallError";
-    this.captureMode = captureMode;
+    this.captureMode = session.captureMode;
   }
 };
 function raceAgainstStall(promise, deadlineMs, input, signal) {
@@ -3513,9 +3525,9 @@ function raceAgainstStall(promise, deadlineMs, input, signal) {
       () => {
         reject(
           signal?.aborted ? new Error(
-            `[Render] Sequential ${captureModeLabel(input.captureMode)} capture aborted while a capture call was in flight (frame ${input.frameIndex}/${input.totalFrames}).`
+            `[Render] Sequential ${captureModeLabel(input.session.captureMode)} capture aborted while a capture call was in flight (frame ${input.frameIndex}/${input.totalFrames}).`
           ) : new SequentialCaptureStallError(
-            input.captureMode,
+            input.session,
             input.stallTimeoutMs,
             input.frameIndex,
             input.totalFrames
@@ -3643,7 +3655,7 @@ async function runWorkerEncodePipelineLoop(session, totalFrames, job, currentEnc
   const captureWithStallGuard = (idx, promise) => raceAgainstStall(
     promise,
     stallTimeoutMs - (Date.now() - lastProgressAt),
-    { captureMode: session.captureMode, frameIndex: idx, totalFrames, stallTimeoutMs },
+    { session, frameIndex: idx, totalFrames, stallTimeoutMs },
     abortSignal
   );
   const drainPrev = async () => {
@@ -3997,7 +4009,7 @@ async function runCaptureStreamingStage(input) {
             const { buffer } = await raceAgainstStall(
               captureFrameToBuffer(session, i, time),
               stallTimeoutMs - (Date.now() - lastProgressAt),
-              { captureMode: session.captureMode, frameIndex: i, totalFrames, stallTimeoutMs },
+              { session, frameIndex: i, totalFrames, stallTimeoutMs },
               abortSignal
             );
             await reorderBuffer.waitForFrame(i);
@@ -4086,7 +4098,7 @@ async function captureSegmentFrames(ctx, segment, encoder) {
       ctx.captureFrame(ctx.session, i, time),
       ctx.stallTimeoutMs - (Date.now() - lastProgressAt),
       {
-        captureMode: ctx.session.captureMode,
+        session: ctx.session,
         frameIndex: i,
         totalFrames: ctx.totalFrames,
         stallTimeoutMs: ctx.stallTimeoutMs
@@ -14308,7 +14320,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-LIERUCFW.js");
+    const { drainBrowserPool } = await import("./src-VMTHSARJ.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -14802,6 +14814,7 @@ function readVideoMetadata(value, field) {
     // overwhelmingly common start-at-zero domain. Preserve that compatibility
     // while carrying non-zero edit-list/transport timestamps in new plans.
     videoStreamStartSeconds: record.videoStreamStartSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamStartSeconds, `${field}.videoStreamStartSeconds`),
+    videoStreamLeadSeconds: record.videoStreamLeadSeconds === void 0 ? 0 : readFiniteNumber(record.videoStreamLeadSeconds, `${field}.videoStreamLeadSeconds`),
     width: readPositiveInteger(record.width, `${field}.width`),
     height: readPositiveInteger(record.height, `${field}.height`),
     fps: readFiniteNumber(record.fps, `${field}.fps`),
@@ -15493,7 +15506,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-LIERUCFW.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-VMTHSARJ.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {

package/dist/{chunk-QSSPIATO.js → chunk-X2G54Y2V.js}

@@ -8,7 +8,7 @@ import {
   flush,
   shouldTrack,
   trackEvent
-} from "./chunk-2NAUEDA6.js";
+} from "./chunk-QX26JK43.js";
 import {
   getPowerState
 } from "./chunk-XBSPQ52S.js";

package/dist/{chunk-4RUILXS6.js → chunk-XIL7KT5Q.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-QSSPIATO.js";
+} from "./chunk-X2G54Y2V.js";
 import {
   shouldTrack
-} from "./chunk-2NAUEDA6.js";
+} from "./chunk-QX26JK43.js";
 import {
   detectAgentRuntime
 } from "./chunk-XBSPQ52S.js";

package/dist/{chunk-UZUUVYAO.js → chunk-YQK445YQ.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-QSSPIATO.js";
+} from "./chunk-X2G54Y2V.js";
 import {
   shouldTrack
-} from "./chunk-2NAUEDA6.js";
+} from "./chunk-QX26JK43.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS

package/dist/{chunk-AJ5R4GM6.js → chunk-ZK3BQXHC.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-ZZQJOKO6.js");
+  return await import("./src-PTIV7IVV.js");
 }
 
 export {