hyperframes 0.7.89 → 0.7.90

package/dist/cli.js

@@ -50,7 +50,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.7.89" : "0.0.0-dev";
+    VERSION = true ? "0.7.90" : "0.0.0-dev";
   }
 });
 
@@ -62735,7 +62735,7 @@ function parsePositiveByteLimitMb(content, noLimitCutoffBytes) {
   }
   return Number(bytes / BYTES_PER_MIB_BIGINT);
 }
-function getCgroupLimitMb() {
+function getCgroupMemoryLimitMb() {
   if (_cachedCgroupLimitMb !== void 0) return _cachedCgroupLimitMb;
   if (process.platform !== "linux") {
     _cachedCgroupLimitMb = null;
@@ -62782,7 +62782,7 @@ function warnCgroupReadFailure(path2, error) {
 }
 function getSystemTotalMb() {
   const hostTotalMb = Math.floor(totalmem() / BYTES_PER_MIB);
-  const cgroupLimitMb = getCgroupLimitMb();
+  const cgroupLimitMb = getCgroupMemoryLimitMb();
   return cgroupLimitMb === null ? hostTotalMb : Math.min(hostTotalMb, cgroupLimitMb);
 }
 function isLowMemorySystem(totalMb = getSystemTotalMb()) {
@@ -68812,7 +68812,7 @@ function sanitizeFfprobeDiagnostic(stderr, filePath) {
   if (redacted.length <= FFPROBE_ERROR_MAX_CHARS) return redacted;
   return `\u2026${redacted.slice(-(FFPROBE_ERROR_MAX_CHARS - 1))}`;
 }
-async function runFfprobe(filePath, argsWithoutInput, signal) {
+async function runFfprobe(filePath, argsWithoutInput, signal, stdoutOptions) {
   if (filePath === "-") {
     throw new Error('[FFmpeg] Refusing to probe "-": stdin is not a supported input path.');
   }
@@ -68826,12 +68826,17 @@ async function runFfprobe(filePath, argsWithoutInput, signal) {
   const decoder = new StringDecoder("utf8");
   let stdout2 = "";
   let stdoutTruncated = false;
+  const stdoutMaxChars = stdoutOptions?.maxChars ?? FFPROBE_STDOUT_MAX_CHARS;
   proc.stdout.on("data", (data2) => {
     if (stdoutTruncated) return;
     stdout2 += decoder.write(data2);
-    if (stdout2.length > FFPROBE_STDOUT_MAX_CHARS) {
-      stdoutTruncated = true;
-      stdout2 = "";
+    if (stdout2.length > stdoutMaxChars) {
+      if (stdoutOptions?.retainTail) {
+        stdout2 = stdout2.slice(-stdoutMaxChars);
+      } else {
+        stdoutTruncated = true;
+        stdout2 = "";
+      }
     }
   });
   const managed = new ManagedChildProcess(proc, {
@@ -68843,7 +68848,7 @@ async function runFfprobe(filePath, argsWithoutInput, signal) {
   stdout2 += decoder.end();
   if (stdoutTruncated) {
     throw new Error(
-      `[FFmpeg] ffprobe output exceeded ${FFPROBE_STDOUT_MAX_CHARS} characters; refusing to parse a truncated result.`
+      `[FFmpeg] ffprobe output exceeded ${stdoutMaxChars} characters; refusing to parse a truncated result.`
     );
   }
   if (outcome.reason === "spawn_error") {
@@ -68990,6 +68995,7 @@ async function extractMediaMetadata(filePath) {
         return {
           durationSeconds: 0,
           videoStreamDurationSeconds: 0,
+          videoStreamStartSeconds: 0,
           width: stillImageMeta.width,
           height: stillImageMeta.height,
           fps: 0,
@@ -69021,9 +69027,12 @@ async function extractMediaMetadata(filePath) {
     const hasAlpha = pixelFormatHasAlpha(pixelFormat) || alphaMode === "1";
     const containerDuration = output?.format.duration ? parseFloat(output.format.duration) : 0;
     const streamDuration = videoStream.duration ? parseFloat(videoStream.duration) : 0;
+    const parsedStreamStart = videoStream.start_time ? parseFloat(videoStream.start_time) : 0;
+    const streamStart = Number.isFinite(parsedStreamStart) ? parsedStreamStart : 0;
     return {
       durationSeconds: containerDuration,
       videoStreamDurationSeconds: streamDuration > 0 ? streamDuration : containerDuration,
+      videoStreamStartSeconds: streamStart,
       width: videoStream.width || stillImage()?.width || 0,
       height: videoStream.height || stillImage()?.height || 0,
       fps,
@@ -69042,6 +69051,59 @@ async function extractMediaMetadata(filePath) {
   });
   return probePromise;
 }
+async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
+  const videoDurationSeconds = metadata.videoStreamDurationSeconds;
+  const candidateStreamStart = metadata.videoStreamStartSeconds ?? 0;
+  const videoStreamStartSeconds = Number.isFinite(candidateStreamStart) ? candidateStreamStart : 0;
+  const cacheKey = `${filePath}\0${String(videoStreamStartSeconds)}\0${String(videoDurationSeconds)}`;
+  let probeCache = finalVideoFrameTimestampCache;
+  if (signal) {
+    probeCache = finalVideoFrameTimestampSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
+    finalVideoFrameTimestampSignalCaches.set(signal, probeCache);
+  }
+  const cached2 = probeCache.get(cacheKey);
+  if (cached2) return cached2;
+  const probePromise = (async () => {
+    if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
+      throw new Error(
+        `[FFmpeg] Cannot locate final video frame for invalid duration ${String(videoDurationSeconds)}`
+      );
+    }
+    const streamEnd = videoStreamStartSeconds + videoDurationSeconds;
+    const intervalStart = Math.max(videoStreamStartSeconds, streamEnd - 1);
+    const parseFinalTimestamp = (stdout2) => stdout2.split("\n").map((line2) => line2.trim().split(",")[0]?.trim() ?? "").filter((value) => value.length > 0).map((value) => Number(value)).filter((timestamp2) => Number.isFinite(timestamp2)).at(-1);
+    const probe = async (readInterval) => {
+      const args = [
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "frame=best_effort_timestamp_time",
+        "-of",
+        "csv=p=0"
+      ];
+      if (readInterval) args.splice(2, 0, "-read_intervals", readInterval);
+      const stdout2 = await runFfprobe(filePath, args, signal, {
+        retainTail: true,
+        maxChars: 64 * 1024
+      });
+      return parseFinalTimestamp(stdout2);
+    };
+    const timestamp = await probe(`${intervalStart}%${streamEnd}`) ?? await probe(
+      /* full scan */
+    );
+    if (timestamp === void 0) {
+      throw new Error("[FFmpeg] ffprobe found no decodable final video frame");
+    }
+    return Math.min(Math.max(timestamp - videoStreamStartSeconds, 0), videoDurationSeconds);
+  })();
+  probeCache.set(cacheKey, probePromise);
+  probePromise.catch(() => {
+    if (probeCache.get(cacheKey) === probePromise) {
+      probeCache.delete(cacheKey);
+    }
+  });
+  return probePromise;
+}
 async function extractAudioMetadata(filePath, options) {
   const cached2 = options?.signal ? void 0 : audioMetadataCache.get(filePath);
   if (cached2) return cached2;
@@ -69148,7 +69210,7 @@ async function analyzeKeyframeIntervalsUncached(filePath) {
     isProblematic: maxInterval > 2
   };
 }
-var FFPROBE_STDERR_MAX_BYTES, FFPROBE_STDOUT_MAX_CHARS, FFPROBE_ERROR_MAX_CHARS, videoMetadataCache, audioMetadataCache, AAC_LC_SAMPLES_PER_PACKET, nativeCrc32, extractVideoMetadata, keyframeCache;
+var FFPROBE_STDERR_MAX_BYTES, FFPROBE_STDOUT_MAX_CHARS, FFPROBE_ERROR_MAX_CHARS, videoMetadataCache, finalVideoFrameTimestampCache, finalVideoFrameTimestampSignalCaches, audioMetadataCache, AAC_LC_SAMPLES_PER_PACKET, nativeCrc32, extractVideoMetadata, keyframeCache;
 var init_ffprobe = __esm({
   "../engine/src/utils/ffprobe.ts"() {
     "use strict";
@@ -69160,6 +69222,8 @@ var init_ffprobe = __esm({
     FFPROBE_STDOUT_MAX_CHARS = 8e6;
     FFPROBE_ERROR_MAX_CHARS = 4 * 1024;
     videoMetadataCache = /* @__PURE__ */ new Map();
+    finalVideoFrameTimestampCache = /* @__PURE__ */ new Map();
+    finalVideoFrameTimestampSignalCaches = /* @__PURE__ */ new WeakMap();
     audioMetadataCache = /* @__PURE__ */ new Map();
     AAC_LC_SAMPLES_PER_PACKET = 1024;
     nativeCrc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : void 0;
@@ -83919,20 +83983,21 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   } catch (error) {
     throw classifyVideoExtractionError(error);
   }
-  if (!(metadata.durationSeconds > 0)) {
+  const playableDuration = resolvePlayableVideoDuration(metadata);
+  if (!(playableDuration > 0)) {
     throw new VideoSourceExtractionError(
       "invalid_media",
       false,
       "Video source has no positive duration",
-      `Video source duration is ${metadata.durationSeconds}s`
+      `Playable video stream duration is ${playableDuration}s`
     );
   }
-  if (startTime >= metadata.durationSeconds) {
+  if (startTime >= playableDuration) {
     throw new VideoSourceExtractionError(
       "media_start_out_of_range",
       false,
       "Video media start is outside the source duration",
-      `Video media start ${startTime}s is outside source duration ${metadata.durationSeconds}s`
+      `Video media start ${startTime}s is outside playable video duration ${playableDuration}s`
     );
   }
   const format = resolveFrameFormat(metadata, options.format);
@@ -83947,19 +84012,25 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (codecMayHaveAlpha(metadata.videoCodec)) {
     args.push("-c:v", decoderForCodec(metadata.videoCodec));
   }
-  args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
+  if (options.finalFrameOnly) {
+    args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
+  } else {
+    args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
+  }
   const vfFilters = [];
   if (isHdr && isMacOS) {
     vfFilters.push("format=nv12");
   }
-  if (!metadata.isVFR) {
+  if (!options.finalFrameOnly && !metadata.isVFR) {
     vfFilters.push(`fps=${fps}`);
   }
   if (options.sdrToHdrTransfer) {
     vfFilters.push(SDR_TO_HDR_COLORSPACE_FILTER);
   }
   if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
-  if (metadata.isVFR) args.push("-fps_mode", "cfr", "-r", String(fps));
+  if (!options.finalFrameOnly && metadata.isVFR) {
+    args.push("-fps_mode", "cfr", "-r", String(fps));
+  }
   args.push("-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0");
   if (format === "png") args.push("-compression_level", "1");
   args.push("-y", outputPattern);
@@ -84036,10 +84107,124 @@ function classifyFfmpegSpawnError(error, stderr = "") {
     diagnostic
   );
 }
-function resolveSegmentDuration(requested, mediaStart, metadata) {
+function resolveSegmentDuration(requested, mediaStart, sourceDuration) {
   if (Number.isFinite(requested) && requested > 0) return requested;
-  const sourceRemaining = metadata.durationSeconds - mediaStart;
-  return sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+  const sourceRemaining = sourceDuration - mediaStart;
+  return sourceRemaining > 0 ? sourceRemaining : sourceDuration;
+}
+function resolvePlayableVideoDuration(metadata) {
+  return Number.isFinite(metadata.videoStreamDurationSeconds) && metadata.videoStreamDurationSeconds > 0 ? metadata.videoStreamDurationSeconds : metadata.durationSeconds;
+}
+function resolveTimelineExtractionWindow(video, resolvedDuration, timelineEnd, sourceDuration) {
+  if (timelineEnd === void 0) {
+    return {
+      compositionStart: video.start,
+      mediaStart: video.mediaStart,
+      durationSeconds: resolvedDuration
+    };
+  }
+  if (!Number.isFinite(timelineEnd)) {
+    throw new Error(`Video extraction timelineEnd must be finite; got ${String(timelineEnd)}`);
+  }
+  const compositionStart = Math.max(0, video.start);
+  const trimmedPreroll = compositionStart - video.start;
+  const timelineDuration2 = Math.max(0, timelineEnd - compositionStart);
+  const resolvedVisibleDuration = resolvedDuration - trimmedPreroll;
+  const visibleDuration = Math.max(0, Math.min(resolvedVisibleDuration, timelineDuration2));
+  let mediaStart = video.mediaStart + trimmedPreroll;
+  if (visibleDuration > 0 && sourceDuration !== void 0) {
+    const sourceRemaining = Math.max(0, sourceDuration - video.mediaStart);
+    if (sourceRemaining > 0 && video.loop && Number.isFinite(video.end)) {
+      const phaseOffset = trimmedPreroll % sourceRemaining;
+      const phaseRemaining = sourceRemaining - phaseOffset;
+      if (visibleDuration >= phaseRemaining) {
+        return {
+          compositionStart: video.start,
+          mediaStart: video.mediaStart,
+          durationSeconds: sourceRemaining,
+          preserveTimelinePhase: true
+        };
+      }
+      mediaStart = video.mediaStart + phaseOffset;
+    } else if (sourceRemaining > 0) {
+      const sourceVisibleAfterPreroll = Math.max(0, sourceRemaining - trimmedPreroll);
+      if (visibleDuration <= sourceVisibleAfterPreroll) {
+        return {
+          compositionStart,
+          mediaStart,
+          durationSeconds: visibleDuration
+        };
+      }
+      const extractionDuration = Math.min(
+        sourceRemaining,
+        Math.max(sourceVisibleAfterPreroll, FINAL_FRAME_LOGICAL_DURATION_SECONDS)
+      );
+      const extractionOffset = sourceRemaining - extractionDuration;
+      return {
+        compositionStart: video.start + extractionOffset,
+        mediaStart: video.mediaStart + extractionOffset,
+        durationSeconds: extractionDuration,
+        preserveTimelineEnd: true,
+        ensureFinalFrame: true
+      };
+    }
+  }
+  return {
+    compositionStart,
+    mediaStart,
+    durationSeconds: visibleDuration
+  };
+}
+async function resolveFinalFrameExtractionWindow(videoPath, video, metadata, window3, signal) {
+  if (!window3.ensureFinalFrame) return window3;
+  const playableDuration = resolvePlayableVideoDuration(metadata);
+  const finalFrameTimestamp = await extractFinalVideoFrameTimestamp(
+    videoPath,
+    {
+      videoStreamDurationSeconds: playableDuration,
+      videoStreamStartSeconds: metadata.videoStreamStartSeconds
+    },
+    signal
+  );
+  if (window3.mediaStart < finalFrameTimestamp - 1e-9) return window3;
+  const sourceRemaining = playableDuration - video.mediaStart;
+  const logicalDuration = Math.min(sourceRemaining, FINAL_FRAME_LOGICAL_DURATION_SECONDS);
+  return {
+    compositionStart: Math.max(0, video.start),
+    mediaStart: playableDuration - logicalDuration,
+    extractionMediaStart: finalFrameTimestamp,
+    durationSeconds: logicalDuration,
+    preserveTimelineEnd: true,
+    finalFrameOnly: true
+  };
+}
+function resolveVideoExtractionWindow(video, metadata, timelineEnd) {
+  const playableDuration = resolvePlayableVideoDuration(metadata);
+  if (!(playableDuration > 0)) {
+    throw new VideoSourceExtractionError(
+      "invalid_media",
+      false,
+      "Video source has no positive duration",
+      `Playable video stream duration is ${playableDuration}s`
+    );
+  }
+  if (video.mediaStart >= playableDuration) {
+    throw new VideoSourceExtractionError(
+      "media_start_out_of_range",
+      false,
+      "Video media start is outside the source duration",
+      `Video media start ${video.mediaStart}s is outside playable video duration ${playableDuration}s`
+    );
+  }
+  const resolvedDuration = resolveSegmentDuration(
+    video.end - video.start,
+    video.mediaStart,
+    playableDuration
+  );
+  return resolveTimelineExtractionWindow(video, resolvedDuration, timelineEnd, playableDuration);
+}
+function resolveVideoExtractionDuration(video, metadata, timelineEnd) {
+  return resolveVideoExtractionWindow(video, metadata, timelineEnd).durationSeconds;
 }
 function codecMayHaveAlpha(codec) {
   return ALPHA_CAPABLE_CODECS.has((codec ?? "").toLowerCase());
@@ -84087,7 +84272,13 @@ function linkOrCopyFrame(src, dest) {
   }
 }
 function supersetGroupingKey(work, fps) {
-  return [work.videoPath, String(fps), work.format, work.sdrToHdrTransfer ?? ""].join("\0");
+  return [
+    work.videoPath,
+    String(fps),
+    work.format,
+    work.sdrToHdrTransfer ?? "",
+    work.finalFrameOnly ? "final" : "range"
+  ].join("\0");
 }
 function isIntegralFrameOffset(offsetSeconds, fps) {
   const frames = offsetSeconds * fps;
@@ -84103,6 +84294,7 @@ function windowsOverlapOrTouch(misses, baseStart) {
 }
 function buildSupersetGroup(groupId, misses, fps) {
   if (misses.length < 2) return null;
+  if (misses.some(({ work }) => work.finalFrameOnly)) return null;
   const baseStart = Math.min(...misses.map(({ work }) => work.video.mediaStart));
   if (!misses.every(({ work }) => isIntegralFrameOffset(work.video.mediaStart - baseStart, fps))) {
     return null;
@@ -84203,6 +84395,11 @@ function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
   return candidates.find(existsSync14) ?? join12(baseDir, cleanSrc);
 }
 async function extractAllVideoFrames(videos, baseDir, options, signal, config, compiledDir) {
+  if (options.timelineEnd !== void 0 && !Number.isFinite(options.timelineEnd)) {
+    throw new Error(
+      `Video extraction timelineEnd must be finite; got ${String(options.timelineEnd)}`
+    );
+  }
   const startTime = Date.now();
   const extracted = [];
   const errors = [];
@@ -84232,6 +84429,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   const warnedSrcs = /* @__PURE__ */ new Set();
   for (const video of videos) {
     if (signal?.aborted) break;
+    if (options.timelineEnd !== void 0 && video.start >= options.timelineEnd) continue;
     try {
       let videoPath = video.src;
       if (!isHttpUrl(videoPath)) {
@@ -84283,9 +84481,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       videoPath,
       mtimeMs: stat3.mtimeMs,
       size: stat3.size,
-      mediaStart: video.mediaStart,
-      start: video.start,
-      end: video.end
+      mediaStart: video.mediaStart
     };
   });
   const phase2ProbeStart = Date.now();
@@ -84337,12 +84533,13 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         const entry = resolvedVideos[i2];
         const metadata = videoMetadata[i2];
         if (!entry || !metadata) continue;
-        if (entry.video.mediaStart >= metadata.durationSeconds) {
+        const playableDuration = resolvePlayableVideoDuration(metadata);
+        if (entry.video.mediaStart >= playableDuration) {
           errors.push({
             videoId: entry.video.id,
             kind: "media_start_out_of_range",
             retryable: false,
-            error: `SDR\u2192HDR conversion skipped: mediaStart (${entry.video.mediaStart}s) \u2265 source duration (${metadata.durationSeconds}s)`
+            error: `SDR\u2192HDR conversion skipped: mediaStart (${entry.video.mediaStart}s) \u2265 playable video duration (${playableDuration}s)`
           });
           hdrSkippedIndices.add(i2);
           continue;
@@ -84397,7 +84594,12 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     };
   }
   function scopedExtractionOptions(work) {
-    return { ...options, format: work.format, sdrToHdrTransfer: work.sdrToHdrTransfer };
+    return {
+      ...options,
+      format: work.format,
+      sdrToHdrTransfer: work.sdrToHdrTransfer,
+      finalFrameOnly: work.finalFrameOnly
+    };
   }
   function rehydratePublishedCache(work, target) {
     const rehydrated = rehydrateCacheEntry(target.entry, {
@@ -84413,18 +84615,17 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     if (!cacheRootDir) return { work };
     const keyInput = cacheKeyInputs[work.index];
     if (!keyInput) return { work };
-    const transform = work.sdrToHdrTransfer ? sdrToHdrTransformKey(work.sdrToHdrTransfer) : void 0;
-    const keyDuration = resolveSegmentDuration(
-      keyInput.end - keyInput.start,
-      keyInput.mediaStart,
-      work.metadata
-    );
+    const transformParts = [
+      work.sdrToHdrTransfer ? sdrToHdrTransformKey(work.sdrToHdrTransfer) : void 0,
+      work.finalFrameOnly ? "final-frame" : void 0
+    ].filter((part) => part !== void 0);
+    const transform = transformParts.length > 0 ? transformParts.join("+") : void 0;
     const lookup = lookupCacheEntry(cacheRootDir, {
       videoPath: keyInput.videoPath,
       mtimeMs: keyInput.mtimeMs,
       size: keyInput.size,
       mediaStart: keyInput.mediaStart,
-      duration: keyDuration,
+      duration: work.videoDuration,
       fps: options.fps,
       format: work.format,
       transform
@@ -84447,7 +84648,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
         () => extractVideoFramesRange(
           work.videoPath,
           work.video.id,
-          work.video.mediaStart,
+          work.extractionMediaStart,
           work.videoDuration,
           scopedExtractionOptions(work),
           signal,
@@ -84471,7 +84672,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       () => extractVideoFramesRange(
         work.videoPath,
         work.video.id,
-        work.video.mediaStart,
+        work.extractionMediaStart,
         work.videoDuration,
         scopedExtractionOptions(work),
         signal,
@@ -84571,17 +84772,32 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       }
       try {
         const metadata = videoMetadata[index] ?? await extractMediaMetadata(videoPath);
-        const videoDuration = resolveSegmentDuration(
-          video.end - video.start,
-          video.mediaStart,
-          metadata
+        const initialWindow = resolveVideoExtractionWindow(video, metadata, options.timelineEnd);
+        const window3 = await resolveFinalFrameExtractionWindow(
+          videoPath,
+          video,
+          metadata,
+          initialWindow,
+          signal
         );
-        if (video.end - video.start !== videoDuration) {
-          video.end = video.start + videoDuration;
+        const videoDuration = window3.durationSeconds;
+        if (videoDuration <= 0) {
+          return { skipped: true };
+        }
+        if (!window3.preserveTimelinePhase) {
+          video.start = window3.compositionStart;
+          if (!window3.preserveTimelineEnd) {
+            video.end = window3.compositionStart + videoDuration;
+          }
+          video.mediaStart = window3.mediaStart;
         }
+        const keyInput = cacheKeyInputs[index];
+        const extractionMediaStart = window3.extractionMediaStart ?? window3.mediaStart;
+        if (keyInput) keyInput.mediaStart = extractionMediaStart;
         const format = resolveFrameFormat(metadata, options.format);
         const sdrToHdrTransfer = sdrToHdrTransfers[index];
-        const dedupeKey = `${videoPath}\0${video.mediaStart}\0${videoDuration}\0${options.fps}\0${format}\0${sdrToHdrTransfer ?? ""}`;
+        const finalFrameOnly = window3.finalFrameOnly === true;
+        const dedupeKey = `${videoPath}\0${extractionMediaStart}\0${videoDuration}\0${options.fps}\0${format}\0${sdrToHdrTransfer ?? ""}\0${finalFrameOnly ? "final" : "range"}`;
         return {
           work: {
             video,
@@ -84589,6 +84805,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
             index,
             metadata,
             videoDuration,
+            extractionMediaStart,
+            finalFrameOnly,
             format,
             sdrToHdrTransfer,
             dedupeKey
@@ -84628,25 +84846,35 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   for (const groupOutcomes of supersetOutcomes) {
     for (const [key2, outcome] of groupOutcomes) uniqueOutcomes.set(key2, outcome);
   }
-  const results = preparedExtractions.map((prepared) => {
-    if ("error" in prepared) return prepared;
+  const results = [];
+  for (const prepared of preparedExtractions) {
+    if ("skipped" in prepared) continue;
+    if ("error" in prepared) {
+      results.push(prepared);
+      continue;
+    }
     const outcome = uniqueOutcomes.get(prepared.work.dedupeKey);
-    if (!outcome)
-      return { error: extractionError(prepared.work.video.id, "missing extraction result") };
+    if (!outcome) {
+      results.push({
+        error: extractionError(prepared.work.video.id, "missing extraction result")
+      });
+      continue;
+    }
     if ("error" in outcome) {
       const isFollower = outcome.error.videoId !== prepared.work.video.id;
       const message = isFollower ? `[shared extraction, leader ${outcome.error.videoId}] ${outcome.error.error}` : outcome.error.error;
-      return {
+      results.push({
         error: {
           videoId: prepared.work.video.id,
           kind: outcome.error.kind,
           retryable: outcome.error.retryable,
           error: message
         }
-      };
+      });
+      continue;
     }
-    return { result: { ...outcome.result, videoId: prepared.work.video.id } };
-  });
+    results.push({ result: { ...outcome.result, videoId: prepared.work.video.id } });
+  }
   breakdown.extractMs = Date.now() - phase3Start;
   for (const item of results) {
     if ("error" in item && item.error) {
@@ -84678,7 +84906,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
 function getFrameIndexAtTime(extracted, globalTime, videoStart, loop = false, mediaStart = 0, holdLastFrame = false) {
   let localTime = globalTime - videoStart;
   if (localTime < 0) return null;
-  const loopDuration = Math.max(0, extracted.metadata.durationSeconds - mediaStart);
+  const loopDuration = Math.max(0, resolvePlayableVideoDuration(extracted.metadata) - mediaStart);
   if (loop && loopDuration > 0 && localTime >= loopDuration) {
     localTime %= loopDuration;
   }
@@ -84712,7 +84940,7 @@ function createFrameLookupTable(videos, extracted) {
   }
   return table;
 }
-var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, VideoSourceExtractionError, TRANSIENT_FFMPEG_SPAWN_CODES, ALPHA_CAPABLE_CODECS, FrameLookupTable;
+var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, VideoSourceExtractionError, TRANSIENT_FFMPEG_SPAWN_CODES, FINAL_FRAME_LOGICAL_DURATION_SECONDS, ALPHA_CAPABLE_CODECS, FrameLookupTable;
 var init_videoFrameExtractor = __esm({
   "../engine/src/services/videoFrameExtractor.ts"() {
     "use strict";
@@ -84744,6 +84972,7 @@ var init_videoFrameExtractor = __esm({
       hyperframesVideoSourceExtractionError = true;
     };
     TRANSIENT_FFMPEG_SPAWN_CODES = /* @__PURE__ */ new Set(["EAGAIN", "EMFILE", "ENFILE"]);
+    FINAL_FRAME_LOGICAL_DURATION_SECONDS = 1e-6;
     ALPHA_CAPABLE_CODECS = /* @__PURE__ */ new Set(["vp9", "vp8", "prores"]);
     FrameLookupTable = class {
       videos = /* @__PURE__ */ new Map();
@@ -88349,6 +88578,7 @@ __export(src_exports, {
   executeParallelCapture: () => executeParallelCapture,
   extractAllVideoFrames: () => extractAllVideoFrames,
   extractAudioMetadata: () => extractAudioMetadata,
+  extractFinalVideoFrameTimestamp: () => extractFinalVideoFrameTimestamp,
   extractMediaMetadata: () => extractMediaMetadata,
   extractVideoFramesRange: () => extractVideoFramesRange,
   extractVideoMetadata: () => extractVideoMetadata,
@@ -88356,6 +88586,7 @@ __export(src_exports, {
   formatFfmpegError: () => formatFfmpegError,
   getCapturePerfSummary: () => getCapturePerfSummary,
   getCdpSession: () => getCdpSession,
+  getCgroupMemoryLimitMb: () => getCgroupMemoryLimitMb,
   getCompositionDuration: () => getCompositionDuration,
   getDrawElementVerificationDetails: () => getDrawElementVerificationDetails,
   getEncoderPreset: () => getEncoderPreset,
@@ -88413,8 +88644,13 @@ __export(src_exports, {
   resolveConfig: () => resolveConfig,
   resolveDeVerifyMinDb: () => resolveDeVerifyMinDb,
   resolveExtractCacheDir: () => resolveExtractCacheDir,
+  resolveFinalFrameExtractionWindow: () => resolveFinalFrameExtractionWindow,
   resolveHeadlessShellPath: () => resolveHeadlessShellPath,
+  resolvePlayableVideoDuration: () => resolvePlayableVideoDuration,
   resolveProjectRelativeSrc: () => resolveProjectRelativeSrc,
+  resolveTimelineExtractionWindow: () => resolveTimelineExtractionWindow,
+  resolveVideoExtractionDuration: () => resolveVideoExtractionDuration,
+  resolveVideoExtractionWindow: () => resolveVideoExtractionWindow,
   roundedRectAlpha: () => roundedRectAlpha,
   runFfmpeg: () => runFfmpeg,
   runVideoExtractionWithRetry: () => runVideoExtractionWithRetry,
@@ -112460,7 +112696,7 @@ function expectedFramesForVideo(video, entry, fps) {
   const rounding = entry && !entry.metadata.isVFR ? "nearest" : "ceil";
   const slotFrames = expectedFramesForClip(video.start, video.end, fps, rounding);
   if (!entry) return slotFrames;
-  const sourceDuration = entry.metadata.durationSeconds - video.mediaStart;
+  const sourceDuration = resolvePlayableVideoDuration(entry.metadata) - video.mediaStart;
   if (!Number.isFinite(sourceDuration) || sourceDuration <= 0) return slotFrames;
   const sourceFrames = expectedFramesForClip(0, sourceDuration, fps, rounding);
   return Math.min(slotFrames, sourceFrames);
@@ -112508,6 +112744,7 @@ var init_videoFrameCoverage = __esm({
   "../producer/src/services/render/videoFrameCoverage.ts"() {
     "use strict";
     init_esm10();
+    init_src();
     VideoFrameCoverageError = class extends Error {
       // Read structurally by isVideoFrameCoverageError and cross-module callers.
       // fallow-ignore-next-line unused-class-member
@@ -119211,6 +119448,7 @@ async function runExtractVideosStage(input2) {
         fps: fpsToNumber(job.config.fps),
         outputDir: join47(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
+        timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce"
       },
@@ -119559,17 +119797,26 @@ function closeHdrVideoFrameSource(source, log2) {
     });
   }
 }
+function resolveHdrVideoFrameIndex(time, startTime, fps, frameCount, loop = false) {
+  const frameIndex = Math.round((time - startTime) * fps);
+  if (frameIndex < 0 || frameCount < 1) return null;
+  return loop ? frameIndex % frameCount : Math.min(frameIndex, frameCount - 1);
+}
 function blitHdrVideoLayer(canvas, el, time, fps, hdrVideoFrameSources, hdrStartTimes, width, height, log2, sourceTransfer, targetTransfer, hdrPerf) {
   const frameSource = hdrVideoFrameSources.get(el.id);
   const startTime = hdrStartTimes.get(el.id);
   if (!frameSource || startTime === void 0 || el.opacity <= 0) {
     return;
   }
-  const videoFrameIndex = Math.round((time - startTime) * fps) + 1;
-  if (videoFrameIndex < 1) return;
-  const effectiveIndex = Math.min(videoFrameIndex, frameSource.frameCount);
-  if (effectiveIndex < 1) return;
-  const frameOffset = (effectiveIndex - 1) * frameSource.frameSize;
+  const effectiveIndex = resolveHdrVideoFrameIndex(
+    time,
+    startTime,
+    fps,
+    frameSource.frameCount,
+    frameSource.loop
+  );
+  if (effectiveIndex === null) return;
+  const frameOffset = effectiveIndex * frameSource.frameSize;
   try {
     if (hdrPerf) hdrPerf.hdrVideoLayerBlits += 1;
     const bytesRead = timeHdrPhase(
@@ -119955,8 +120202,402 @@ var init_hdrCompositor = __esm({
   }
 });
 
+// ../producer/src/services/render/stages/captureHdrResources.ts
+import {
+  closeSync as closeSync7,
+  constants as constants3,
+  fstatSync as fstatSync4,
+  mkdirSync as mkdirSync24,
+  mkdtempSync as mkdtempSync6,
+  openSync as openSync6,
+  readFileSync as readFileSync30,
+  rmSync as rmSync15,
+  statfsSync as statfsSync2
+} from "fs";
+import { join as join50 } from "path";
+function tempDirSafePrefix(id) {
+  const safe = id.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
+  return safe || "video";
+}
+function planHdrResources(args) {
+  const { composition, nativeHdrVideoIds, nativeHdrImageIds, projectDir, compiledDir } = args;
+  const hdrVideoIds = composition.videos.filter((v2) => nativeHdrVideoIds.has(v2.id)).map((v2) => v2.id);
+  const hdrVideoSrcPaths = /* @__PURE__ */ new Map();
+  for (const v2 of composition.videos) {
+    if (!hdrVideoIds.includes(v2.id)) continue;
+    let srcPath = v2.src;
+    if (!srcPath.startsWith("/")) {
+      const fromCompiled = join50(compiledDir, srcPath);
+      srcPath = args.existsSync(fromCompiled) ? fromCompiled : join50(projectDir, srcPath);
+    }
+    hdrVideoSrcPaths.set(v2.id, srcPath);
+  }
+  const hdrVideoStartTimes = /* @__PURE__ */ new Map();
+  for (const v2 of composition.videos) {
+    if (hdrVideoIds.includes(v2.id)) hdrVideoStartTimes.set(v2.id, v2.start);
+  }
+  const hdrImageStartTimes = /* @__PURE__ */ new Map();
+  for (const img of composition.images) {
+    if (nativeHdrImageIds.has(img.id)) hdrImageStartTimes.set(img.id, img.start);
+  }
+  return {
+    hdrVideoIds,
+    hdrVideoSrcPaths,
+    hdrVideoStartTimes,
+    hdrImageStartTimes,
+    hdrExtractionDims: /* @__PURE__ */ new Map(),
+    hdrImageFitInfo: /* @__PURE__ */ new Map()
+  };
+}
+async function probeHdrExtractionDims(args) {
+  const { domSession, nativeHdrIds, nativeHdrImageIds, composition, prep } = args;
+  const uniqueStartTimes = [
+    .../* @__PURE__ */ new Set([...prep.hdrVideoStartTimes.values(), ...prep.hdrImageStartTimes.values()])
+  ].sort((a, b2) => a - b2);
+  for (const seekTime of uniqueStartTimes) {
+    await domSession.page.evaluate((t2) => {
+      if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t2);
+    }, seekTime);
+    if (domSession.onBeforeCapture) {
+      await domSession.onBeforeCapture(domSession.page, seekTime);
+    }
+    const stacking = await queryElementStacking(domSession.page, nativeHdrIds);
+    for (const el of stacking) {
+      if (el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0 && !prep.hdrExtractionDims.has(el.id)) {
+        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+      }
+      if (el.isHdr && nativeHdrImageIds.has(el.id) && !prep.hdrImageFitInfo.has(el.id)) {
+        prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
+      }
+    }
+  }
+  for (const [imageId, startTime] of prep.hdrImageStartTimes) {
+    if (prep.hdrExtractionDims.has(imageId)) continue;
+    const img = composition.images.find((i2) => i2.id === imageId);
+    if (!img) continue;
+    const duration = img.end - img.start;
+    const retryTime = startTime + Math.min(0.5, duration * 0.1);
+    await domSession.page.evaluate((t2) => {
+      if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t2);
+    }, retryTime);
+    if (domSession.onBeforeCapture) {
+      await domSession.onBeforeCapture(domSession.page, retryTime);
+    }
+    const retryStacking = await queryElementStacking(domSession.page, nativeHdrIds);
+    for (const el of retryStacking) {
+      if (el.id === imageId && el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0) {
+        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
+        if (!prep.hdrImageFitInfo.has(el.id)) {
+          prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
+        }
+        break;
+      }
+    }
+  }
+}
+function estimateHdrExtractionBytes(videos, fps) {
+  let total = 0;
+  for (const v2 of videos) {
+    const frames = Math.ceil(Math.max(0, v2.durationSeconds) * fps);
+    total += frames * v2.width * v2.height * 6;
+  }
+  return total;
+}
+function resolveHdrExtractionBudgetBytes(raw, cgroupLimitMb = getCgroupMemoryLimitMb()) {
+  let configuredBudget;
+  if (raw !== void 0 && raw.trim() !== "") {
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`${HDR_EXTRACTION_MAX_BYTES_ENV} must be a positive finite byte count`);
+    }
+    configuredBudget = Math.floor(value);
+  }
+  const cgroupBudget = cgroupLimitMb !== null && Number.isFinite(cgroupLimitMb) && cgroupLimitMb > 0 ? Math.floor(cgroupLimitMb * BYTES_PER_MIB2 * HDR_EXTRACTION_CGROUP_BUDGET_FRACTION) : void 0;
+  if (configuredBudget === void 0) return cgroupBudget;
+  if (cgroupBudget === void 0) return configuredBudget;
+  return Math.min(configuredBudget, cgroupBudget);
+}
+function resolveHdrExtractionActiveBudgetBytes(configuredBudgetBytes, freeBytes) {
+  const diskBudgetBytes = Math.floor(freeBytes * HDR_EXTRACTION_HEADROOM_FRACTION);
+  return configuredBudgetBytes === void 0 ? diskBudgetBytes : Math.min(configuredBudgetBytes, diskBudgetBytes);
+}
+function reserveHdrExtractionBytes(estimatedBytes, budgetBytes) {
+  if (!Number.isFinite(estimatedBytes) || estimatedBytes < 0) {
+    throw new Error(`HDR extraction reservation must be a finite non-negative byte count`);
+  }
+  const aggregateBytes = aggregateHdrExtractionReservedBytes + estimatedBytes;
+  if (budgetBytes !== void 0 && aggregateBytes > budgetBytes) {
+    throw new Error(
+      `Concurrent HDR pre-extractions need ~${(aggregateBytes / 1e9).toFixed(1)} GB of raw 16-bit frame scratch, exceeding the active ${(budgetBytes / 1e9).toFixed(1)} GB budget.`
+    );
+  }
+  aggregateHdrExtractionReservedBytes = aggregateBytes;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    aggregateHdrExtractionReservedBytes = Math.max(
+      0,
+      aggregateHdrExtractionReservedBytes - estimatedBytes
+    );
+  };
+}
+function resolveHdrExtractionWindow(video, compositionDuration, metadata) {
+  if (!Number.isFinite(compositionDuration) || compositionDuration <= 0) {
+    throw new Error(
+      `Cannot extract HDR video "${video.id}" with invalid composition duration ${String(compositionDuration)}`
+    );
+  }
+  const window3 = resolveVideoExtractionWindow(video, metadata, compositionDuration);
+  if (!Number.isFinite(window3.durationSeconds)) {
+    throw new Error(
+      `HDR video "${video.id}" has no finite interval inside the ${compositionDuration}s composition`
+    );
+  }
+  if (window3.durationSeconds <= 0) return null;
+  if (!Number.isFinite(window3.mediaStart) || window3.mediaStart < 0) {
+    throw new Error(`HDR video "${video.id}" has invalid mediaStart ${String(window3.mediaStart)}`);
+  }
+  return window3;
+}
+function cleanupHdrFrameDirectory(frameDir, rawPath, log2) {
+  if (process.env.KEEP_TEMP === "1") return;
+  try {
+    rmSync15(frameDir, { recursive: true, force: true });
+  } catch (err) {
+    log2?.warn("Failed to clean up HDR raw frame directory", {
+      frameDir,
+      rawPath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function cleanupHdrVideoFrameSource(source, log2) {
+  closeHdrVideoFrameSource(source, log2);
+  cleanupHdrFrameDirectory(source.dir, source.rawPath, log2);
+}
+function assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fps, log2) {
+  const estimatedBytes = estimateHdrExtractionBytes(plannedVideos, fps);
+  const configuredBudget = resolveHdrExtractionBudgetBytes(
+    process.env[HDR_EXTRACTION_MAX_BYTES_ENV]
+  );
+  const estimatedGb = (estimatedBytes / 1e9).toFixed(1);
+  if (configuredBudget !== void 0 && estimatedBytes > configuredBudget) {
+    throw new Error(
+      `HDR pre-extraction needs ~${estimatedGb} GB of raw 16-bit frames, exceeding the active scratch budget of ${(configuredBudget / 1e9).toFixed(1)} GB. If the composition doesn't need HDR output, re-run with --sdr; otherwise reduce its HDR duration/resolution or use a render container with a larger memory limit.`
+    );
+  }
+  let freeBytes;
+  try {
+    const stat3 = statfsSync2(framesDir);
+    freeBytes = stat3.bavail * stat3.bsize;
+  } catch {
+    return { estimatedBytes, budgetBytes: configuredBudget };
+  }
+  const diskBudgetBytes = Math.floor(freeBytes * HDR_EXTRACTION_HEADROOM_FRACTION);
+  if (estimatedBytes > diskBudgetBytes) {
+    throw new Error(
+      `HDR pre-extraction needs ~${estimatedGb} GB of raw 16-bit frames but only ${(freeBytes / 1e9).toFixed(1)} GB is free at ${framesDir}. If the composition doesn't need HDR output, re-run with --sdr; otherwise free up disk space and retry.`
+    );
+  }
+  if (estimatedBytes > HDR_EXTRACTION_WARN_BYTES) {
+    log2.warn(
+      `HDR pre-extraction will write ~${estimatedGb} GB of raw 16-bit frames (pass --sdr to skip if HDR output isn't needed)`,
+      { estimatedBytes, freeBytes }
+    );
+  }
+  return {
+    estimatedBytes,
+    budgetBytes: resolveHdrExtractionActiveBudgetBytes(configuredBudget, freeBytes)
+  };
+}
+async function extractHdrVideoFrames(args) {
+  const { job, log: log2, framesDir, composition, prep, width, height, abortSignal, hdrDiagnostics } = args;
+  const runFfmpegImpl = args.runFfmpegImpl ?? runFfmpeg;
+  const extractMediaMetadataImpl = args.extractMediaMetadataImpl ?? extractMediaMetadata;
+  const resolveFinalFrameExtractionWindowImpl = args.resolveFinalFrameExtractionWindowImpl ?? resolveFinalFrameExtractionWindow;
+  const out = /* @__PURE__ */ new Map();
+  mkdirSync24(framesDir, { recursive: true });
+  const plannedVideos = [];
+  const extractionWindows = /* @__PURE__ */ new Map();
+  for (const [videoId, srcPath] of prep.hdrVideoSrcPaths) {
+    const video = composition.videos.find((v2) => v2.id === videoId);
+    if (!video) continue;
+    const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
+    const metadata = await extractMediaMetadataImpl(srcPath);
+    const initialWindow = resolveHdrExtractionWindow(video, composition.duration, metadata);
+    if (!initialWindow) continue;
+    const window3 = await resolveFinalFrameExtractionWindowImpl(
+      srcPath,
+      video,
+      metadata,
+      initialWindow,
+      abortSignal
+    );
+    extractionWindows.set(videoId, window3);
+    prep.hdrVideoStartTimes.set(videoId, window3.compositionStart);
+    plannedVideos.push({
+      durationSeconds: window3.durationSeconds,
+      width: dims.width,
+      height: dims.height
+    });
+  }
+  const { estimatedBytes, budgetBytes } = assertHdrExtractionDiskHeadroom(
+    framesDir,
+    plannedVideos,
+    fpsToNumber(job.config.fps),
+    log2
+  );
+  const releaseReservation = reserveHdrExtractionBytes(estimatedBytes, budgetBytes);
+  const createdFrameDirs = /* @__PURE__ */ new Set();
+  try {
+    for (const [videoId, srcPath] of prep.hdrVideoSrcPaths) {
+      const video = composition.videos.find((v2) => v2.id === videoId);
+      const window3 = extractionWindows.get(videoId);
+      if (!video || !window3) continue;
+      mkdirSync24(framesDir, { recursive: true });
+      const frameDir = mkdtempSync6(join50(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      createdFrameDirs.add(frameDir);
+      const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
+      const rawPath = join50(frameDir, "frames.rgb48le");
+      const extractionStart = String(window3.extractionMediaStart ?? window3.mediaStart);
+      const ffmpegArgs = [];
+      if (window3.finalFrameOnly) {
+        ffmpegArgs.push("-i", srcPath, "-ss", extractionStart, "-frames:v", "1");
+      } else {
+        ffmpegArgs.push(
+          "-ss",
+          extractionStart,
+          "-i",
+          srcPath,
+          "-t",
+          String(window3.durationSeconds)
+        );
+      }
+      if (!window3.finalFrameOnly) {
+        ffmpegArgs.push("-r", fpsToFfmpegArg(job.config.fps));
+      }
+      ffmpegArgs.push(
+        "-vf",
+        `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`,
+        "-pix_fmt",
+        "rgb48le",
+        "-f",
+        "rawvideo",
+        "-y",
+        rawPath
+      );
+      const result = await runFfmpegImpl(ffmpegArgs, { signal: abortSignal });
+      if (!result.success) {
+        hdrDiagnostics.videoExtractionFailures += 1;
+        log2.error("HDR frame pre-extraction failed; aborting render", {
+          videoId,
+          srcPath,
+          stderr: result.stderr.slice(-400)
+        });
+        throw new Error(
+          `HDR frame extraction failed for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
+        );
+      }
+      const frameSize = dims.width * dims.height * 6;
+      const fd = openSync6(rawPath, constants3.O_RDONLY | NO_FOLLOW_FLAG);
+      let handedOff = false;
+      try {
+        const frameCount = Math.floor(fstatSync4(fd).size / frameSize);
+        if (frameCount < 1) {
+          hdrDiagnostics.videoExtractionFailures += 1;
+          throw new Error(
+            `HDR frame extraction produced no frames for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
+          );
+        }
+        out.set(videoId, {
+          dir: frameDir,
+          rawPath,
+          fd,
+          width: dims.width,
+          height: dims.height,
+          frameSize,
+          frameCount,
+          scratch: Buffer.allocUnsafe(frameSize),
+          loop: video.loop
+        });
+        handedOff = true;
+      } finally {
+        if (!handedOff) closeSync7(fd);
+      }
+    }
+    return { sources: out, estimatedBytes, releaseReservation };
+  } catch (error) {
+    for (const source of out.values()) {
+      cleanupHdrVideoFrameSource(source, log2);
+      createdFrameDirs.delete(source.dir);
+    }
+    for (const frameDir of createdFrameDirs) {
+      cleanupHdrFrameDirectory(frameDir, void 0, log2);
+    }
+    releaseReservation();
+    throw error;
+  }
+}
+function decodeHdrImageBuffers(args) {
+  const { log: log2, hdrImageSrcPaths, prep, hdrDiagnostics } = args;
+  const out = /* @__PURE__ */ new Map();
+  for (const [imageId, srcPath] of hdrImageSrcPaths) {
+    try {
+      const decoded = decodePngToRgb48le(readFileSync30(srcPath));
+      const layout2 = prep.hdrExtractionDims.get(imageId);
+      const fitInfo = prep.hdrImageFitInfo.get(imageId);
+      if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
+        const fit = normalizeObjectFit(fitInfo?.fit);
+        const resampled = resampleRgb48leObjectFit(
+          decoded.data,
+          decoded.width,
+          decoded.height,
+          layout2.width,
+          layout2.height,
+          fit,
+          fitInfo?.position
+        );
+        out.set(imageId, { data: resampled, width: layout2.width, height: layout2.height });
+      } else {
+        out.set(imageId, {
+          data: Buffer.from(decoded.data),
+          width: decoded.width,
+          height: decoded.height
+        });
+      }
+    } catch (err) {
+      hdrDiagnostics.imageDecodeFailures += 1;
+      log2.error("HDR image decode failed; aborting render", {
+        imageId,
+        srcPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw new Error(
+        `HDR image decode failed for image "${imageId}". Aborting render to avoid shipping missing HDR image layers.`
+      );
+    }
+  }
+  return out;
+}
+var NO_FOLLOW_FLAG, HDR_EXTRACTION_HEADROOM_FRACTION, HDR_EXTRACTION_CGROUP_BUDGET_FRACTION, HDR_EXTRACTION_WARN_BYTES, HDR_EXTRACTION_MAX_BYTES_ENV, BYTES_PER_MIB2, aggregateHdrExtractionReservedBytes;
+var init_captureHdrResources = __esm({
+  "../producer/src/services/render/stages/captureHdrResources.ts"() {
+    "use strict";
+    init_src();
+    init_dist3();
+    init_hdrCompositor();
+    NO_FOLLOW_FLAG = constants3.O_NOFOLLOW ?? 0;
+    HDR_EXTRACTION_HEADROOM_FRACTION = 0.9;
+    HDR_EXTRACTION_CGROUP_BUDGET_FRACTION = 0.5;
+    HDR_EXTRACTION_WARN_BYTES = 1e10;
+    HDR_EXTRACTION_MAX_BYTES_ENV = "HDR_EXTRACTION_MAX_BYTES";
+    BYTES_PER_MIB2 = 1024 * 1024;
+    aggregateHdrExtractionReservedBytes = 0;
+  }
+});
+
 // ../producer/src/services/render/stages/captureHdrFrameShared.ts
-import { rmSync as rmSync15 } from "fs";
 function shouldUseHybridLayeredPath(args) {
   if (args.hasHdrContent) return false;
   if (args.workerCount <= 1) return false;
@@ -120180,17 +120821,7 @@ function cleanupEndedHdrVideos(args) {
       if (!stillNeeded) {
         const frameSource = hdrVideoFrameSources.get(videoId);
         if (frameSource) {
-          closeHdrVideoFrameSource(frameSource, log2);
-          try {
-            rmSync15(frameSource.dir, { recursive: true, force: true });
-          } catch (err) {
-            log2.warn("Failed to clean up HDR raw frame directory", {
-              videoId,
-              frameDir: frameSource.dir,
-              rawPath: frameSource.rawPath,
-              error: err instanceof Error ? err.message : String(err)
-            });
-          }
+          cleanupHdrVideoFrameSource(frameSource, log2);
           hdrVideoFrameSources.delete(videoId);
         }
         cleanedUpVideos.add(videoId);
@@ -120203,6 +120834,7 @@ var init_captureHdrFrameShared = __esm({
     "use strict";
     init_src();
     init_hdrCompositor();
+    init_captureHdrResources();
     init_hdrPerf();
   }
 });
@@ -120210,7 +120842,7 @@ var init_captureHdrFrameShared = __esm({
 // ../producer/src/services/render/stages/captureStreamingStage.ts
 import { mkdtemp as mkdtemp2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 function resolveDeStallTimeoutMs() {
   const raw = process.env.HF_DE_STALL_MS ?? process.env.HF_DE_PARALLEL_STALL_MS;
   const parsed = raw ? Number(raw) : Number.NaN;
@@ -120314,11 +120946,11 @@ function createDrainFrameGuard(args) {
         return buf;
       }
       if (db < verifyMinDb) {
-        const dumpDir = await mkdtemp2(join50(tmpdir7(), "hf-de-verify-fail-")).catch(() => null);
+        const dumpDir = await mkdtemp2(join51(tmpdir7(), "hf-de-verify-fail-")).catch(() => null);
         if (dumpDir) {
           await Promise.all([
-            writeFile2(join50(dumpDir, `frame-${idx}-de.jpg`), buf),
-            writeFile2(join50(dumpDir, `frame-${idx}-truth.jpg`), truth)
+            writeFile2(join51(dumpDir, `frame-${idx}-de.jpg`), buf),
+            writeFile2(join51(dumpDir, `frame-${idx}-truth.jpg`), truth)
           ]).catch(() => {
           });
         }
@@ -120788,263 +121420,6 @@ var init_hdrImageTransferCache = __esm({
   }
 });
 
-// ../producer/src/services/render/stages/captureHdrResources.ts
-import {
-  closeSync as closeSync7,
-  constants as constants3,
-  fstatSync as fstatSync4,
-  mkdirSync as mkdirSync24,
-  mkdtempSync as mkdtempSync6,
-  openSync as openSync6,
-  readFileSync as readFileSync30,
-  statfsSync as statfsSync2
-} from "fs";
-import { join as join51 } from "path";
-function tempDirSafePrefix(id) {
-  const safe = id.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
-  return safe || "video";
-}
-function planHdrResources(args) {
-  const { composition, nativeHdrVideoIds, nativeHdrImageIds, projectDir, compiledDir } = args;
-  const hdrVideoIds = composition.videos.filter((v2) => nativeHdrVideoIds.has(v2.id)).map((v2) => v2.id);
-  const hdrVideoSrcPaths = /* @__PURE__ */ new Map();
-  for (const v2 of composition.videos) {
-    if (!hdrVideoIds.includes(v2.id)) continue;
-    let srcPath = v2.src;
-    if (!srcPath.startsWith("/")) {
-      const fromCompiled = join51(compiledDir, srcPath);
-      srcPath = args.existsSync(fromCompiled) ? fromCompiled : join51(projectDir, srcPath);
-    }
-    hdrVideoSrcPaths.set(v2.id, srcPath);
-  }
-  const hdrVideoStartTimes = /* @__PURE__ */ new Map();
-  for (const v2 of composition.videos) {
-    if (hdrVideoIds.includes(v2.id)) hdrVideoStartTimes.set(v2.id, v2.start);
-  }
-  const hdrImageStartTimes = /* @__PURE__ */ new Map();
-  for (const img of composition.images) {
-    if (nativeHdrImageIds.has(img.id)) hdrImageStartTimes.set(img.id, img.start);
-  }
-  return {
-    hdrVideoIds,
-    hdrVideoSrcPaths,
-    hdrVideoStartTimes,
-    hdrImageStartTimes,
-    hdrExtractionDims: /* @__PURE__ */ new Map(),
-    hdrImageFitInfo: /* @__PURE__ */ new Map()
-  };
-}
-async function probeHdrExtractionDims(args) {
-  const { domSession, nativeHdrIds, nativeHdrImageIds, composition, prep } = args;
-  const uniqueStartTimes = [
-    .../* @__PURE__ */ new Set([...prep.hdrVideoStartTimes.values(), ...prep.hdrImageStartTimes.values()])
-  ].sort((a, b2) => a - b2);
-  for (const seekTime of uniqueStartTimes) {
-    await domSession.page.evaluate((t2) => {
-      if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t2);
-    }, seekTime);
-    if (domSession.onBeforeCapture) {
-      await domSession.onBeforeCapture(domSession.page, seekTime);
-    }
-    const stacking = await queryElementStacking(domSession.page, nativeHdrIds);
-    for (const el of stacking) {
-      if (el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0 && !prep.hdrExtractionDims.has(el.id)) {
-        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
-      }
-      if (el.isHdr && nativeHdrImageIds.has(el.id) && !prep.hdrImageFitInfo.has(el.id)) {
-        prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
-      }
-    }
-  }
-  for (const [imageId, startTime] of prep.hdrImageStartTimes) {
-    if (prep.hdrExtractionDims.has(imageId)) continue;
-    const img = composition.images.find((i2) => i2.id === imageId);
-    if (!img) continue;
-    const duration = img.end - img.start;
-    const retryTime = startTime + Math.min(0.5, duration * 0.1);
-    await domSession.page.evaluate((t2) => {
-      if (window.__hf && typeof window.__hf.seek === "function") window.__hf.seek(t2);
-    }, retryTime);
-    if (domSession.onBeforeCapture) {
-      await domSession.onBeforeCapture(domSession.page, retryTime);
-    }
-    const retryStacking = await queryElementStacking(domSession.page, nativeHdrIds);
-    for (const el of retryStacking) {
-      if (el.id === imageId && el.isHdr && el.layoutWidth > 0 && el.layoutHeight > 0) {
-        prep.hdrExtractionDims.set(el.id, { width: el.layoutWidth, height: el.layoutHeight });
-        if (!prep.hdrImageFitInfo.has(el.id)) {
-          prep.hdrImageFitInfo.set(el.id, { fit: el.objectFit, position: el.objectPosition });
-        }
-        break;
-      }
-    }
-  }
-}
-function estimateHdrExtractionBytes(videos, fps) {
-  let total = 0;
-  for (const v2 of videos) {
-    const frames = Math.ceil(Math.max(0, v2.durationSeconds) * fps);
-    total += frames * v2.width * v2.height * 6;
-  }
-  return total;
-}
-function assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fps, log2) {
-  const estimatedBytes = estimateHdrExtractionBytes(plannedVideos, fps);
-  let freeBytes;
-  try {
-    const stat3 = statfsSync2(framesDir);
-    freeBytes = stat3.bavail * stat3.bsize;
-  } catch {
-    return;
-  }
-  const estimatedGb = (estimatedBytes / 1e9).toFixed(1);
-  if (estimatedBytes > freeBytes * HDR_EXTRACTION_HEADROOM_FRACTION) {
-    throw new Error(
-      `HDR pre-extraction needs ~${estimatedGb} GB of raw 16-bit frames but only ${(freeBytes / 1e9).toFixed(1)} GB is free at ${framesDir}. If the composition doesn't need HDR output, re-run with --sdr; otherwise free up disk space and retry.`
-    );
-  }
-  if (estimatedBytes > HDR_EXTRACTION_WARN_BYTES) {
-    log2.warn(
-      `HDR pre-extraction will write ~${estimatedGb} GB of raw 16-bit frames (pass --sdr to skip if HDR output isn't needed)`,
-      { estimatedBytes, freeBytes }
-    );
-  }
-}
-async function extractHdrVideoFrames(args) {
-  const { job, log: log2, framesDir, composition, prep, width, height, abortSignal, hdrDiagnostics } = args;
-  const out = /* @__PURE__ */ new Map();
-  mkdirSync24(framesDir, { recursive: true });
-  const plannedVideos = [];
-  for (const [videoId] of prep.hdrVideoSrcPaths) {
-    const video = composition.videos.find((v2) => v2.id === videoId);
-    if (!video) continue;
-    const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
-    plannedVideos.push({
-      durationSeconds: video.end - video.start,
-      width: dims.width,
-      height: dims.height
-    });
-  }
-  assertHdrExtractionDiskHeadroom(framesDir, plannedVideos, fpsToNumber(job.config.fps), log2);
-  for (const [videoId, srcPath] of prep.hdrVideoSrcPaths) {
-    const video = composition.videos.find((v2) => v2.id === videoId);
-    if (!video) continue;
-    mkdirSync24(framesDir, { recursive: true });
-    const frameDir = mkdtempSync6(join51(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
-    const duration = video.end - video.start;
-    const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
-    const rawPath = join51(frameDir, "frames.rgb48le");
-    const ffmpegArgs = [
-      "-ss",
-      String(video.mediaStart),
-      "-i",
-      srcPath,
-      "-t",
-      String(duration),
-      "-r",
-      fpsToFfmpegArg(job.config.fps),
-      "-vf",
-      `scale=${dims.width}:${dims.height}:force_original_aspect_ratio=increase,crop=${dims.width}:${dims.height}`,
-      "-pix_fmt",
-      "rgb48le",
-      "-f",
-      "rawvideo",
-      "-y",
-      rawPath
-    ];
-    const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
-    if (!result.success) {
-      hdrDiagnostics.videoExtractionFailures += 1;
-      log2.error("HDR frame pre-extraction failed; aborting render", {
-        videoId,
-        srcPath,
-        stderr: result.stderr.slice(-400)
-      });
-      throw new Error(
-        `HDR frame extraction failed for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
-      );
-    }
-    const frameSize = dims.width * dims.height * 6;
-    const fd = openSync6(rawPath, constants3.O_RDONLY | NO_FOLLOW_FLAG);
-    let handedOff = false;
-    try {
-      const frameCount = Math.floor(fstatSync4(fd).size / frameSize);
-      if (frameCount < 1) {
-        hdrDiagnostics.videoExtractionFailures += 1;
-        throw new Error(
-          `HDR frame extraction produced no frames for video "${videoId}". Aborting render to avoid shipping black HDR layers.`
-        );
-      }
-      out.set(videoId, {
-        dir: frameDir,
-        rawPath,
-        fd,
-        width: dims.width,
-        height: dims.height,
-        frameSize,
-        frameCount,
-        scratch: Buffer.allocUnsafe(frameSize)
-      });
-      handedOff = true;
-    } finally {
-      if (!handedOff) closeSync7(fd);
-    }
-  }
-  return out;
-}
-function decodeHdrImageBuffers(args) {
-  const { log: log2, hdrImageSrcPaths, prep, hdrDiagnostics } = args;
-  const out = /* @__PURE__ */ new Map();
-  for (const [imageId, srcPath] of hdrImageSrcPaths) {
-    try {
-      const decoded = decodePngToRgb48le(readFileSync30(srcPath));
-      const layout2 = prep.hdrExtractionDims.get(imageId);
-      const fitInfo = prep.hdrImageFitInfo.get(imageId);
-      if (layout2 && (layout2.width !== decoded.width || layout2.height !== decoded.height)) {
-        const fit = normalizeObjectFit(fitInfo?.fit);
-        const resampled = resampleRgb48leObjectFit(
-          decoded.data,
-          decoded.width,
-          decoded.height,
-          layout2.width,
-          layout2.height,
-          fit,
-          fitInfo?.position
-        );
-        out.set(imageId, { data: resampled, width: layout2.width, height: layout2.height });
-      } else {
-        out.set(imageId, {
-          data: Buffer.from(decoded.data),
-          width: decoded.width,
-          height: decoded.height
-        });
-      }
-    } catch (err) {
-      hdrDiagnostics.imageDecodeFailures += 1;
-      log2.error("HDR image decode failed; aborting render", {
-        imageId,
-        srcPath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      throw new Error(
-        `HDR image decode failed for image "${imageId}". Aborting render to avoid shipping missing HDR image layers.`
-      );
-    }
-  }
-  return out;
-}
-var NO_FOLLOW_FLAG, HDR_EXTRACTION_HEADROOM_FRACTION, HDR_EXTRACTION_WARN_BYTES;
-var init_captureHdrResources = __esm({
-  "../producer/src/services/render/stages/captureHdrResources.ts"() {
-    "use strict";
-    init_src();
-    init_dist3();
-    NO_FOLLOW_FLAG = constants3.O_NOFOLLOW ?? 0;
-    HDR_EXTRACTION_HEADROOM_FRACTION = 0.9;
-    HDR_EXTRACTION_WARN_BYTES = 1e10;
-  }
-});
-
 // ../producer/src/services/render/stages/captureHdrSequentialLoop.ts
 import { join as join53 } from "path";
 async function runSequentialLayeredFrameLoop(input2) {
@@ -121714,6 +122089,7 @@ async function runCaptureHdrStage(input2) {
   let hdrEncoder = null;
   let hdrEncoderClosed = false;
   let domSessionClosed = false;
+  let releaseHdrExtractionReservation = null;
   const hdrVideoFrameSources = /* @__PURE__ */ new Map();
   try {
     await initializeSession(domSession);
@@ -121790,7 +122166,8 @@ async function runCaptureHdrStage(input2) {
       abortSignal,
       hdrDiagnostics
     });
-    for (const [id, source] of extracted) hdrVideoFrameSources.set(id, source);
+    releaseHdrExtractionReservation = extracted.releaseReservation;
+    for (const [id, source] of extracted.sources) hdrVideoFrameSources.set(id, source);
     const hdrImageBuffers = decodeHdrImageBuffers({
       log: log2,
       hdrImageSrcPaths,
@@ -121939,9 +122316,11 @@ async function runCaptureHdrStage(input2) {
       });
     }
     for (const frameSource of hdrVideoFrameSources.values()) {
-      closeHdrVideoFrameSource(frameSource, log2);
+      cleanupHdrVideoFrameSource(frameSource, log2);
     }
     hdrVideoFrameSources.clear();
+    releaseHdrExtractionReservation?.();
+    releaseHdrExtractionReservation = null;
   }
   return {
     lastBrowserConsole,
@@ -125376,6 +125755,22 @@ function parseServerQuality(value) {
 function parseServerFormat(value) {
   return value === "mp4" || value === "webm" || value === "mov" ? value : void 0;
 }
+function parseServerOutputDynamicRange(value) {
+  return value === "auto" || value === "hdr" || value === "sdr" ? value : void 0;
+}
+function parseLegacyServerHdrMode(value) {
+  return value === "auto" || value === "force-hdr" || value === "force-sdr" ? value : void 0;
+}
+function fromRenderHdrMode(hdrMode) {
+  if (hdrMode === "force-hdr") return "hdr";
+  if (hdrMode === "force-sdr") return "sdr";
+  return hdrMode;
+}
+function toRenderHdrMode(outputDynamicRange) {
+  if (outputDynamicRange === "hdr") return "force-hdr";
+  if (outputDynamicRange === "sdr") return "force-sdr";
+  return outputDynamicRange;
+}
 function parseRenderOptions(body) {
   const fps = parseServerFps(body.fps);
   const quality = parseServerQuality(body.quality);
@@ -125386,6 +125781,7 @@ function parseRenderOptions(body) {
   const outputPath = parseOutputCandidate(body);
   const entryFile = nonEmptyString(body.entryFile);
   const format = parseServerFormat(body.format);
+  const outputDynamicRange = parseServerOutputDynamicRange(body.outputDynamicRange) ?? fromRenderHdrMode(parseLegacyServerHdrMode(body.hdrMode));
   const videoFrameFormat = isVideoFrameFormat(body.videoFrameFormat) ? body.videoFrameFormat : void 0;
   const { variables, outputResolution, outputResolutionAspectAgnostic } = parseRenderOverrides(body);
   return {
@@ -125398,6 +125794,7 @@ function parseRenderOptions(body) {
     strictness,
     entryFile,
     format,
+    outputDynamicRange,
     variables,
     outputResolution,
     outputResolutionAspectAgnostic,
@@ -125430,7 +125827,8 @@ function buildRenderJobConfig(input2, outputPath, log2) {
       variables: input2.variables,
       outputResolution: input2.outputResolution,
       outputResolutionAspectAgnostic: input2.outputResolutionAspectAgnostic,
-      videoFrameFormat: input2.videoFrameFormat
+      videoFrameFormat: input2.videoFrameFormat,
+      hdrMode: toRenderHdrMode(input2.outputDynamicRange)
     }
   });
   return renderConfigFromRequest(request, { logger: log2 });
@@ -125446,6 +125844,17 @@ function validateRenderOverrides(body) {
   if (body.variables !== void 0 && !isPlainObject4(body.variables)) {
     return 'variables must be a JSON object keyed by variable id (e.g. {"title":"Hello"})';
   }
+  if (body.outputDynamicRange !== void 0 && parseServerOutputDynamicRange(body.outputDynamicRange) === void 0) {
+    return 'outputDynamicRange must be one of: "auto", "hdr", "sdr"';
+  }
+  const legacyHdrMode = parseLegacyServerHdrMode(body.hdrMode);
+  if (body.hdrMode !== void 0 && legacyHdrMode === void 0) {
+    return 'legacy hdrMode must be one of: "auto", "force-hdr", "force-sdr"';
+  }
+  const outputDynamicRange = parseServerOutputDynamicRange(body.outputDynamicRange);
+  if (outputDynamicRange !== void 0 && legacyHdrMode !== void 0 && outputDynamicRange !== fromRenderHdrMode(legacyHdrMode)) {
+    return "outputDynamicRange and legacy hdrMode must describe the same output policy";
+  }
   return validateOutputResolutionOverride(body);
 }
 function validateOutputResolutionOverride(body) {
@@ -126386,6 +126795,10 @@ function readVideoMetadata(value, field) {
       record.videoStreamDurationSeconds,
       `${field}.videoStreamDurationSeconds`
     ),
+    // Plans written before stream-start metadata existed implicitly used the
+    // 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`),
     width: readPositiveInteger(record.width, `${field}.width`),
     height: readPositiveInteger(record.height, `${field}.height`),
     fps: readFiniteNumber(record.fps, `${field}.fps`),