hyperframes 0.8.79 → 0.8.81

package/dist/fontLocalizeCli.js

@@ -54099,7 +54099,20 @@ function quantizeSeekTime(timeSeconds, fps, subFrameDivisions) {
   const grid = safeFps(fps) * divisions;
   return Math.round(safeTime(timeSeconds) * grid) / grid;
 }
-var MEDIA_VISUAL_STYLE_PROPERTIES;
+function snapTimeToFrameBoundary(timeSeconds, fps) {
+  const grid = safeFps(fps);
+  const time = safeTime(timeSeconds);
+  const framePosition = time * grid;
+  const nearestFrame = Math.round(framePosition);
+  return Math.abs(framePosition - nearestFrame) <= FRAME_BOUNDARY_EPSILON ? nearestFrame / grid : time;
+}
+function exportClipWindow(start, end, fps) {
+  return {
+    start: snapTimeToFrameBoundary(start, fps),
+    end: Number.isFinite(end) ? snapTimeToFrameBoundary(end, fps) : end
+  };
+}
+var MEDIA_VISUAL_STYLE_PROPERTIES, FRAME_BOUNDARY_EPSILON;
 var init_parityContract = __esm({
   "../core/dist/inline-scripts/parityContract.js"() {
     "use strict";
@@ -54134,6 +54147,7 @@ var init_parityContract = __esm({
       "scale",
       "box-sizing"
     ];
+    FRAME_BOUNDARY_EPSILON = 1e-3;
   }
 });
 
@@ -54443,10 +54457,28 @@ var init_startResolver = __esm({
   }
 });
 
+// ../core/dist/clipFacts.js
+function sameInstant(a, b) {
+  if (!Number.isFinite(a) || !Number.isFinite(b))
+    return a === b;
+  return Math.abs(a - b) <= instantTolerance(Math.max(Math.abs(a), Math.abs(b)));
+}
+var instantTolerance;
+var init_clipFacts = __esm({
+  "../core/dist/clipFacts.js"() {
+    "use strict";
+    instantTolerance = (time) => 4 * Number.EPSILON * Math.max(1, Math.abs(time));
+  }
+});
+
 // ../core/dist/runtime/clipWindow.js
+var hasClipStarted, isInClipWindow;
 var init_clipWindow = __esm({
   "../core/dist/runtime/clipWindow.js"() {
     "use strict";
+    init_clipFacts();
+    hasClipStarted = (time, start) => time >= start || sameInstant(time, start);
+    isInClipWindow = (time, start, end) => hasClipStarted(time, start) && time < end && !sameInstant(time, end);
   }
 });
 
@@ -63199,6 +63231,16 @@ var init_evenDimensions = __esm({
   }
 });
 
+// ../engine/src/utils/sdrCaptureColor.ts
+var SDR_RGB_TO_BT709_FILTER, SDR_CAPTURE_TO_BT709_FILTER;
+var init_sdrCaptureColor = __esm({
+  "../engine/src/utils/sdrCaptureColor.ts"() {
+    "use strict";
+    SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
+    SDR_CAPTURE_TO_BT709_FILTER = `scale=in_color_matrix=bt601:in_range=pc:flags=neighbor,format=gbrp,${SDR_RGB_TO_BT709_FILTER}`;
+  }
+});
+
 // ../engine/src/utils/runFfmpeg.ts
 import { spawn as spawn2 } from "child_process";
 function isExternalFfmpegInterruption(result) {
@@ -63235,21 +63277,20 @@ ${tail}` : windowsMessage;
 ffmpeg stderr (tail):
 ${tail}` : `FFmpeg exited with code ${exitCode}`;
 }
-async function runFfmpeg(args, opts) {
-  const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
+function spawnFfmpeg(args) {
   const ffmpeg = spawn2(getFfmpegBinary(), args, { windowsHide: true });
   trackChildProcess(ffmpeg);
-  const managed = new ManagedChildProcess(ffmpeg, {
-    signal: opts?.signal,
-    deadlineAtMs: Date.now() + timeout,
-    onStderr: opts?.onStderr
-  });
-  const outcome = await managed.wait();
+  return ffmpeg;
+}
+function succeeded(outcome) {
+  return outcome.reason === "exit" && outcome.exitCode === 0;
+}
+function toResult(outcome, stderr = outcome.stderr) {
   const result = {
-    success: outcome.reason === "exit" && outcome.exitCode === 0,
+    success: succeeded(outcome),
     exitCode: outcome.exitCode,
     signal: outcome.signal,
-    stderr: outcome.stderr,
+    stderr,
     durationMs: outcome.durationMs,
     terminationReason: outcome.reason,
     error: outcome.error
@@ -63259,6 +63300,43 @@ async function runFfmpeg(args, opts) {
   }
   return result;
 }
+async function runFfmpeg(args, opts) {
+  const timeout = opts?.timeout ?? DEFAULT_TIMEOUT;
+  const managed = new ManagedChildProcess(spawnFfmpeg(args), {
+    signal: opts?.signal,
+    deadlineAtMs: Date.now() + timeout,
+    onStderr: opts?.onStderr
+  });
+  return toResult(await managed.wait());
+}
+async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
+  const deadlineAtMs = Date.now() + (opts?.timeout ?? DEFAULT_TIMEOUT);
+  const producer = spawnFfmpeg(producerArgs);
+  const consumer = spawnFfmpeg(consumerArgs);
+  consumer.stdin?.on("error", () => {
+  });
+  for (const event of ["close", "error"]) {
+    consumer.once(event, () => producer.stdout?.destroy());
+    producer.once(event, () => consumer.stdin?.end());
+  }
+  if (consumer.stdin) producer.stdout?.pipe(consumer.stdin);
+  const settleOrder = [];
+  const outcomes = await Promise.all(
+    [producer, consumer].map(
+      (child) => new ManagedChildProcess(child, {
+        signal: opts?.signal,
+        deadlineAtMs,
+        onStderr: opts?.onStderr
+      }).wait().then((outcome) => {
+        settleOrder.push(outcome);
+        return outcome;
+      })
+    )
+  );
+  const reported = settleOrder.find((outcome) => !succeeded(outcome)) ?? outcomes[1];
+  const stderr = [...outcomes.filter((outcome) => outcome !== reported), reported].map((outcome) => outcome.stderr).join("");
+  return toResult(reported, stderr);
+}
 var FFMPEG_SIGTERM_EXIT_LINE, DEFAULT_TIMEOUT, DEFAULT_STDERR_TAIL_LINES;
 var init_runFfmpeg = __esm({
   "../engine/src/utils/runFfmpeg.ts"() {
@@ -63664,6 +63742,8 @@ async function extractMediaMetadata(filePath) {
       isVFR,
       hasAlpha,
       colorSpace,
+      colorRange: videoStream.color_range,
+      pixelFormat,
       frames
     };
   })();
@@ -64207,23 +64287,20 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
         "tv"
       );
     }
+    const sdrFilter = options.hdr ? void 0 : SDR_CAPTURE_TO_BT709_FILTER;
+    const captureFilter = sdrFilter ?? "scale=in_range=pc:out_range=tv";
     if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
-        args[vfIdx + 1] = `scale=in_range=pc:out_range=tv,${args[vfIdx + 1]}`;
+        args[vfIdx + 1] = `${captureFilter},${args[vfIdx + 1]}`;
       }
     } else if (shouldUseGpu) {
-      const vf = withEvenDimensionPad("", pixelFormat, options.width, options.height);
+      const vf = withEvenDimensionPad(sdrFilter ?? "", pixelFormat, options.width, options.height);
       if (vf) args.push("-vf", vf);
     } else {
       args.push(
         "-vf",
-        withEvenDimensionPad(
-          "scale=in_range=pc:out_range=tv",
-          pixelFormat,
-          options.width,
-          options.height
-        )
+        withEvenDimensionPad(captureFilter, pixelFormat, options.width, options.height)
       );
     }
     args.push("-video_track_timescale", "90000");
@@ -64593,6 +64670,7 @@ var init_chunkEncoder = __esm({
     init_gpuEncoder();
     init_hdr();
     init_evenDimensions();
+    init_sdrCaptureColor();
     init_runFfmpeg();
     init_ffprobe();
     init_dist2();
@@ -64885,25 +64963,15 @@ function buildStreamingArgs(options, outputPath, gpuEncoder = null) {
         "tv"
       );
     }
-    if (options.rawInputFormat) {
+    const sdrFilter = options.rawInputFormat ? SDR_RGB_TO_BT709_FILTER : SDR_CAPTURE_TO_BT709_FILTER;
+    if (options.rawInputFormat && options.hdr) {
     } else if (gpuEncoder === "vaapi") {
       const vfIdx = args.indexOf("-vf");
       if (vfIdx !== -1) {
-        args[vfIdx + 1] = `scale=in_range=pc:out_range=tv,${args[vfIdx + 1]}`;
+        args[vfIdx + 1] = `${sdrFilter},${args[vfIdx + 1]}`;
       }
-    } else if (shouldUseGpu) {
-      const vf = withEvenDimensionPad("", pixelFormat, options.width, options.height);
-      if (vf) args.push("-vf", vf);
     } else {
-      args.push(
-        "-vf",
-        withEvenDimensionPad(
-          "scale=in_range=pc:out_range=tv",
-          pixelFormat,
-          options.width,
-          options.height
-        )
-      );
+      args.push("-vf", withEvenDimensionPad(sdrFilter, pixelFormat, options.width, options.height));
     }
     args.push("-video_track_timescale", "90000");
   }
@@ -65068,6 +65136,7 @@ var init_streamingEncoder = __esm({
     init_ffmpegBinaries();
     init_hdr();
     init_evenDimensions();
+    init_sdrCaptureColor();
     init_config();
     init_dist2();
     init_vp9Options();
@@ -79184,6 +79253,7 @@ var init_inlineSubCompositions = __esm({
 });
 
 // ../core/dist/compiler/htmlBundler.js
+import { AsyncLocalStorage } from "async_hooks";
 import { transformSync } from "esbuild";
 function cssAttributeSelector(attr, value) {
   const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\3c ");
@@ -79360,7 +79430,7 @@ function declarerVariableRules(document2, layerFor) {
   }
   return rules;
 }
-var MAX_INLINE_ASSET_BYTES;
+var bundleReads, MAX_INLINE_ASSET_BYTES;
 var init_htmlBundler = __esm({
   "../core/dist/compiler/htmlBundler.js"() {
     "use strict";
@@ -79384,6 +79454,7 @@ var init_htmlBundler = __esm({
     init_cssSelector();
     init_safePath();
     init_colorGrading();
+    bundleReads = new AsyncLocalStorage();
     MAX_INLINE_ASSET_BYTES = 2 * 1024 * 1024;
   }
 });
@@ -79749,7 +79820,7 @@ var init_extractionCache = __esm({
     init_extractedFrameIndex();
     COMPLETE_SENTINEL = ".hf-complete";
     GC_MARKER = ".hf-last-gc";
-    SCHEMA_PREFIX = "hfcache-v4-";
+    SCHEMA_PREFIX = "hfcache-v5-";
     KEY_HEX_CHARS = 16;
     CACHE_GENERATION_PREFIX = "hfcache-v";
   }
@@ -80097,6 +80168,21 @@ function parseImageElements(html) {
   }
   return images;
 }
+function chromeGuessForUntaggedMatrix(metadata) {
+  const matrix = metadata.colorSpace?.colorSpace;
+  if (matrix && matrix !== "unknown") return [];
+  const hd = metadata.height >= 720 && !CHROME_BT601_UNTAGGED_CODECS.has(metadata.videoCodec);
+  return [`setparams=colorspace=${hd ? "bt709" : "smpte170m"}`];
+}
+function restoreSourceColourFilter(metadata) {
+  const tags = [
+    ["range", metadata.colorRange],
+    ["colorspace", metadata.colorSpace?.colorSpace],
+    ["color_primaries", metadata.colorSpace?.colorPrimaries],
+    ["color_trc", metadata.colorSpace?.colorTransfer]
+  ].filter(([, value]) => value && value !== "unknown" && value !== "reserved");
+  return tags.length > 0 ? [`setparams=${tags.map(([key2, value]) => `${key2}=${value}`).join(":")}`] : [];
+}
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { outputDir, quality = 95 } = options;
@@ -80158,14 +80244,37 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.toneMapHdrToSdr && isHdr && !isMacOS) {
     vfFilters.push(HDR_TO_SDR_TONEMAP_FILTER);
   }
-  if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
-  if (!options.finalFrameOnly && metadata.isVFR) {
-    args.push("-fps_mode", "cfr", "-r", ffmpegFps);
+  if (!isHdr && !options.sdrToHdrTransfer) {
+    vfFilters.push(...chromeGuessForUntaggedMatrix(metadata), SDR_CANVAS_PASSTHROUGH_FILTER);
+    if (format === "jpg") vfFilters.push(SDR_JPEG_AS_BT601_FULL_RANGE_FILTER);
+  }
+  const encodeArgs = ["-q:v", format === "jpg" ? String(Math.ceil((100 - quality) / 3)) : "0"];
+  if (format === "png") encodeArgs.push("-compression_level", "1");
+  encodeArgs.push("-y", outputPattern);
+  const runOptions = { signal, timeout: ffmpegProcessTimeout };
+  const resampleVfrToCfr = !options.finalFrameOnly && metadata.isVFR;
+  if (resampleVfrToCfr) args.push("-fps_mode", "cfr", "-r", ffmpegFps);
+  let processResult;
+  if (resampleVfrToCfr && vfFilters.length > 0 && !isHdr && NUT_RAW_PIXEL_FORMATS.has(metadata.pixelFormat ?? "")) {
+    processResult = await runFfmpegPipeline(
+      [...args, "-an", "-sn", "-dn", "-c:v", "rawvideo", "-f", "nut", "pipe:1"],
+      [
+        "-f",
+        "nut",
+        "-i",
+        "pipe:0",
+        "-vf",
+        [...restoreSourceColourFilter(metadata), ...vfFilters].join(","),
+        "-fps_mode",
+        "passthrough",
+        ...encodeArgs
+      ],
+      runOptions
+    );
+  } else {
+    if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
+    processResult = await runFfmpeg([...args, ...encodeArgs], runOptions);
   }
-  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);
-  const processResult = await runFfmpeg(args, { signal, timeout: ffmpegProcessTimeout });
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
       "external_interruption",
@@ -81081,8 +81190,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
   };
 }
 function getFrameIndexAtTime(extracted, globalTime, videoStart, loop = false, mediaStart = 0, holdLastFrame = false, playbackRate = 1) {
-  let localTime = globalTime - videoStart;
-  if (localTime < 0) return null;
+  let localTime = Math.max(0, globalTime - videoStart);
   const normalizedPlaybackRate = normalizeRateSpec(playbackRate);
   const loopDuration = timeAtSourceTime(
     normalizedPlaybackRate,
@@ -81104,6 +81212,7 @@ function getFrameIndexAtTime(extracted, globalTime, videoStart, loop = false, me
   return frameIndex;
 }
 function getFrameAtTime(extracted, globalTime, videoStart, loop = false, mediaStart = 0) {
+  if (!hasClipStarted(globalTime, videoStart)) return null;
   const frameIndex = getFrameIndexAtTime(extracted, globalTime, videoStart, loop, mediaStart);
   return frameIndex == null ? null : extracted.framePaths.get(frameIndex) || null;
 }
@@ -81116,8 +81225,8 @@ function analyzeClipMediaFit(params) {
   if (shortfallSeconds <= toleranceSeconds) return null;
   return { shortfallSeconds, toleranceSeconds };
 }
-function createFrameLookupTable(videos, extracted) {
-  const table = new FrameLookupTable();
+function createFrameLookupTable(videos, extracted, fps) {
+  const table = new FrameLookupTable(fps);
   const extractedMap = /* @__PURE__ */ new Map();
   for (const ext of extracted) extractedMap.set(ext.videoId, ext);
   for (const video of videos) {
@@ -81128,7 +81237,7 @@ function createFrameLookupTable(videos, extracted) {
   }
   return table;
 }
-var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, HDR_TO_SDR_TONEMAP_FILTER, HDR_TO_SDR_TRANSFORM_KEY, VideoSourceExtractionError, TRANSIENT_FFMPEG_SPAWN_CODES, FINAL_FRAME_LOGICAL_DURATION_SECONDS, ALPHA_CAPABLE_CODECS, FrameLookupTable;
+var VIDEO_FRAME_FORMATS, EXTRACT_CACHE_MIN_AGE_MS, GC_STALENESS_MS, SDR_TO_HDR_COLORSPACE_FILTER, HDR_TO_SDR_TONEMAP_FILTER, HDR_TO_SDR_TRANSFORM_KEY, SDR_CANVAS_PASSTHROUGH_FILTER, SDR_JPEG_AS_BT601_FULL_RANGE_FILTER, VideoSourceExtractionError, CHROME_BT601_UNTAGGED_CODECS, NUT_RAW_PIXEL_FORMATS, TRANSIENT_FFMPEG_SPAWN_CODES, FINAL_FRAME_LOGICAL_DURATION_SECONDS, ALPHA_CAPABLE_CODECS, FrameLookupTable;
 var init_videoFrameExtractor = __esm({
   "../engine/src/services/videoFrameExtractor.ts"() {
     "use strict";
@@ -81151,6 +81260,8 @@ var init_videoFrameExtractor = __esm({
     SDR_TO_HDR_COLORSPACE_FILTER = "colorspace=all=bt2020:iall=bt709:range=tv";
     HDR_TO_SDR_TONEMAP_FILTER = "zscale=t=linear:npl=100,tonemap=hable:desat=0,zscale=p=bt709:t=bt709:m=bt709:r=tv";
     HDR_TO_SDR_TRANSFORM_KEY = "hdr2sdr-hable-bt709";
+    SDR_CANVAS_PASSTHROUGH_FILTER = "setparams=color_primaries=bt709:color_trc=iec61966-2-1";
+    SDR_JPEG_AS_BT601_FULL_RANGE_FILTER = "scale=flags=neighbor,format=gbrp,scale=out_color_matrix=bt601:out_range=pc:flags=neighbor,format=yuv420p";
     VideoSourceExtractionError = class extends Error {
       constructor(kind, retryable, message, diagnostic = message) {
         super(message);
@@ -81164,10 +81275,56 @@ var init_videoFrameExtractor = __esm({
       diagnostic;
       hyperframesVideoSourceExtractionError = true;
     };
+    CHROME_BT601_UNTAGGED_CODECS = /* @__PURE__ */ new Set(["vp9", "av1"]);
+    NUT_RAW_PIXEL_FORMATS = /* @__PURE__ */ new Set([
+      "yuv420p",
+      "yuvj420p",
+      "yuv422p",
+      "yuvj422p",
+      "yuv444p",
+      "yuvj444p",
+      "yuva420p",
+      "yuva444p",
+      "yuv440p",
+      "yuv411p",
+      "yuv410p",
+      "yuva422p",
+      "yuv420p10le",
+      "yuv422p10le",
+      "yuv444p10le",
+      "yuva420p10le",
+      "yuva444p10le",
+      "yuv420p12le",
+      "nv12",
+      "nv21",
+      "yuyv422",
+      "uyvy422",
+      "gray",
+      "gray10le",
+      "ya8",
+      "gbrp",
+      "gbrap",
+      "gbrp10le",
+      "gbrp12le",
+      "gbrap10le",
+      "rgb24",
+      "bgr24",
+      "rgba",
+      "bgra",
+      "argb",
+      "abgr",
+      "rgb48le",
+      "rgba64le"
+    ]);
     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 {
+      /** The render's `fps`, so a clip shows in exactly export visibility's frames; omit for authored times. */
+      constructor(fps) {
+        this.fps = fps;
+      }
+      fps;
       videos = /* @__PURE__ */ new Map();
       orderedVideos = [];
       activeVideoIds = /* @__PURE__ */ new Set();
@@ -81177,18 +81334,18 @@ var init_videoFrameExtractor = __esm({
         this.videos.set(extracted.videoId, {
           extracted,
           start,
-          end,
+          clipWindow: this.fps ? exportClipWindow(start, end, this.fps) : { start, end },
           mediaStart,
           loop,
           playbackRate: normalizeRateSpec(playbackRate)
         });
-        this.orderedVideos = Array.from(this.videos.entries()).map(([videoId, video]) => ({ videoId, ...video })).sort((a, b) => a.start - b.start);
+        this.orderedVideos = Array.from(this.videos.entries()).map(([videoId, video]) => ({ videoId, ...video })).sort((a, b) => a.clipWindow.start - b.clipWindow.start);
         this.resetActiveState();
       }
       getFrame(videoId, globalTime) {
         const video = this.videos.get(videoId);
         if (!video) return null;
-        if (globalTime < video.start || globalTime > video.end) return null;
+        if (!isInClipWindow(globalTime, video.clipWindow.start, video.clipWindow.end)) return null;
         const frameIndex = getFrameIndexAtTime(
           video.extracted,
           globalTime,
@@ -81210,14 +81367,11 @@ var init_videoFrameExtractor = __esm({
           this.activeVideoIds.clear();
           this.startCursor = 0;
           for (const entry of this.orderedVideos) {
-            if (entry.start <= globalTime && globalTime <= entry.end) {
+            if (!hasClipStarted(globalTime, entry.clipWindow.start)) break;
+            if (isInClipWindow(globalTime, entry.clipWindow.start, entry.clipWindow.end)) {
               this.activeVideoIds.add(entry.videoId);
             }
-            if (entry.start <= globalTime) {
-              this.startCursor += 1;
-            } else {
-              break;
-            }
+            this.startCursor += 1;
           }
           this.lastTime = globalTime;
           return;
@@ -81225,17 +81379,17 @@ var init_videoFrameExtractor = __esm({
         while (this.startCursor < this.orderedVideos.length) {
           const candidate = this.orderedVideos[this.startCursor];
           if (!candidate) break;
-          if (candidate.start > globalTime) {
+          if (!hasClipStarted(globalTime, candidate.clipWindow.start)) {
             break;
           }
-          if (globalTime <= candidate.end) {
+          if (isInClipWindow(globalTime, candidate.clipWindow.start, candidate.clipWindow.end)) {
             this.activeVideoIds.add(candidate.videoId);
           }
           this.startCursor += 1;
         }
         for (const videoId of Array.from(this.activeVideoIds)) {
           const video = this.videos.get(videoId);
-          if (!video || globalTime < video.start || globalTime > video.end) {
+          if (!video || !isInClipWindow(globalTime, video.clipWindow.start, video.clipWindow.end)) {
             this.activeVideoIds.delete(videoId);
           }
         }
@@ -97587,11 +97741,11 @@ function resolveCaptureImageFormat(input) {
 }
 
 // ../producer/src/services/render/stages/probeStage.ts
-var FRAME_BOUNDARY_EPSILON = 1e-3;
+var FRAME_BOUNDARY_EPSILON2 = 1e-3;
 function durationToFrameCount(duration, fps) {
   const rawFrameCount = duration * fps;
   const nearestFrame = Math.round(rawFrameCount);
-  return Math.abs(rawFrameCount - nearestFrame) <= FRAME_BOUNDARY_EPSILON ? nearestFrame : Math.ceil(rawFrameCount);
+  return Math.abs(rawFrameCount - nearestFrame) <= FRAME_BOUNDARY_EPSILON2 ? nearestFrame : Math.ceil(rawFrameCount);
 }
 function hasScriptedAudioVolumeAutomation(html, audioCount) {
   if (audioCount <= 0) return false;
@@ -98471,7 +98625,11 @@ async function runExtractVideosStage(input) {
       materializeSymlinks
     });
     if (extractionResult.extracted.length > 0) {
-      frameLookup = createFrameLookupTable(composition.videos, extractionResult.extracted);
+      frameLookup = createFrameLookupTable(
+        composition.videos,
+        extractionResult.extracted,
+        resolveRenderFpsConfig(job.config.fps).value
+      );
     }
     videoReadinessSkipIds = collectVideoReadinessSkipIds(
       nativeHdrVideoIds,
@@ -104579,8 +104737,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.79" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.79" : "0.0.0-dev";
+var VERSION = true ? "0.8.81" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.81" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {