hyperframes 0.8.142 → 0.8.144

package/dist/{chunk-IDX52YJN.js → chunk-5VMR4WBS.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-YFT3BL7N.js";
+} from "./chunk-3VYNNWVA.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -55,7 +55,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-J4UX3RS3.js";
+} from "./chunk-WJB7WI4J.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -70,7 +70,7 @@ import {
 import {
   isWithinProjectRoot,
   resolveProjectRelativeSrc
-} from "./chunk-JFKL3WAE.js";
+} from "./chunk-IWFLMU2N.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -79,10 +79,10 @@ import {
 import {
   parseNumeric,
   parseStartExpression
-} from "./chunk-TQFG7HTI.js";
+} from "./chunk-3RM2ETQT.js";
 import {
   parseHTML
-} from "./chunk-GK4AIFIH.js";
+} from "./chunk-SDYDNHEE.js";
 
 // ../engine/src/config.ts
 import { tmpdir } from "os";
@@ -553,9 +553,97 @@ function applyConcreteGpuScreenshotClamp(currentForceScreenshot, resolvedGpuMode
   });
 }
 
+// ../engine/src/utils/sdrCaptureColor.ts
+var SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
+var SDR_CAPTURE_TO_BT709_FILTER = `scale=in_color_matrix=bt601:in_range=pc:flags=neighbor,format=gbrp,${SDR_RGB_TO_BT709_FILTER}`;
+
+// ../parsers/dist/htmlAttributeSpans.js
+function readAttributeValue(html, at) {
+  while (/[\t\n\f\r ]/.test(html.charAt(at))) at++;
+  const quote = ['"', "'"].includes(html.charAt(at)) ? html.charAt(at) : "";
+  if (quote) at++;
+  const valueStart = at;
+  if (quote) {
+    const closing = html.indexOf(quote, at);
+    at = closing === -1 ? html.length : closing;
+  } else {
+    while (at < html.length && !/[\t\n\f\r >]/.test(html[at])) at++;
+  }
+  const valueEnd = at;
+  const end = quote ? Math.min(valueEnd + 1, html.length) : valueEnd;
+  return { value: html.slice(valueStart, valueEnd), valueStart, valueEnd, quote, end };
+}
+function readAttribute(html, start) {
+  let at = start;
+  while (at < html.length && !/[\t\n\f\r =/>]/.test(html[at])) at++;
+  if (at === start) return null;
+  const name = html.slice(start, at).toLowerCase();
+  const nameEnd = at;
+  while (/[\t\n\f\r ]/.test(html[at] ?? "")) at++;
+  if (html[at] !== "=") return { kind: "boolean", name, start, end: nameEnd };
+  return { kind: "value", name, start, ...readAttributeValue(html, at + 1) };
+}
+function readOpeningTag(html, start, name, at) {
+  const attributes = [];
+  while (at < html.length) {
+    while (/[\t\n\f\r /]/.test(html[at] ?? "")) at++;
+    if (at >= html.length || html[at] === ">") break;
+    const attribute = readAttribute(html, at);
+    if (attribute === null) {
+      at++;
+      continue;
+    }
+    attributes.push(attribute);
+    at = attribute.end;
+  }
+  const closed = html[at] === ">";
+  return {
+    name: name.toLowerCase(),
+    start,
+    bodyEnd: at,
+    end: closed ? at + 1 : at,
+    closed,
+    rawTextEnd: null,
+    attributes
+  };
+}
+function scanHtmlOpeningTags(html) {
+  const tags = [];
+  const opening = /<!--[\s\S]*?(?:--!?>|$)|<([a-z][^\t\n\f\r />]*)/gi;
+  let match;
+  while ((match = opening.exec(html)) !== null) {
+    if (!match[1]) continue;
+    const tag = readOpeningTag(html, match.index, match[1], opening.lastIndex);
+    tags.push(tag);
+    opening.lastIndex = tag.end;
+    if ([
+      "script",
+      "style",
+      "textarea",
+      "title",
+      "xmp",
+      "iframe",
+      "noembed",
+      "noframes",
+      "plaintext"
+    ].includes(tag.name)) {
+      if (tag.name === "plaintext") {
+        tag.rawTextEnd = html.length;
+        break;
+      }
+      const closing = new RegExp(`</${tag.name}(?=[\\t\\n\\f\\r />])`, "gi");
+      closing.lastIndex = tag.end;
+      const end = closing.exec(html);
+      tag.rawTextEnd = end?.index ?? html.length;
+      opening.lastIndex = tag.rawTextEnd;
+    }
+  }
+  return tags;
+}
+
 // ../engine/src/services/browserManager.ts
 import { execSync } from "child_process";
-import { existsSync, readdirSync } from "fs";
+import { existsSync, readdirSync, statSync } from "fs";
 import { join as join2 } from "path";
 import { homedir } from "os";
 
@@ -797,6 +885,7 @@ async function getPuppeteer() {
   if (!_puppeteer) throw new Error("Neither puppeteer nor puppeteer-core found");
   return _puppeteer;
 }
+var GPU_PROBE_TIMEOUT_MS = 15e3;
 async function probeHardwareWebGlInfo(ppt, options) {
   let probeBrowser;
   try {
@@ -806,37 +895,44 @@ async function probeHardwareWebGlInfo(ppt, options) {
       args: options.args,
       defaultViewport: { width: 64, height: 64 },
       executablePath: options.executablePath,
-      timeout: options.browserTimeout
-    });
-    const page = await probeBrowser.newPage();
-    return await page.evaluate(() => {
-      const unavailable = { hasWebGL: false, vendor: "", renderer: "" };
-      const c = document.createElement("canvas");
-      let gl = c.getContext("webgl");
-      if (gl === null) {
-        gl = c.getContext("experimental-webgl");
-      }
-      if (gl === null) return unavailable;
-      const ext = gl.getExtension("WEBGL_debug_renderer_info");
-      let vendorParam = gl.VENDOR;
-      let rendererParam = gl.RENDERER;
-      if (ext !== null) {
-        vendorParam = ext.UNMASKED_VENDOR_WEBGL;
-        rendererParam = ext.UNMASKED_RENDERER_WEBGL;
-      }
-      const vendor = gl.getParameter(vendorParam);
-      const renderer = gl.getParameter(rendererParam);
-      return {
-        hasWebGL: true,
-        vendor: vendor == null ? "" : String(vendor),
-        renderer: renderer == null ? "" : String(renderer)
-      };
+      timeout: options.browserTimeout,
+      waitForInitialPage: false
     });
+    return await rejectAfter(
+      readWebGlInfo(probeBrowser),
+      GPU_PROBE_TIMEOUT_MS,
+      `GPU probe page did not answer within ${GPU_PROBE_TIMEOUT_MS}ms`
+    );
   } finally {
-    await probeBrowser?.close().catch(() => {
-    });
+    if (probeBrowser) await closeBrowserAfterFailedProbe(probeBrowser);
   }
 }
+async function readWebGlInfo(browser) {
+  const page = await browser.newPage();
+  return await page.evaluate(() => {
+    const unavailable = { hasWebGL: false, vendor: "", renderer: "" };
+    const c = document.createElement("canvas");
+    let gl = c.getContext("webgl");
+    if (gl === null) {
+      gl = c.getContext("experimental-webgl");
+    }
+    if (gl === null) return unavailable;
+    const ext = gl.getExtension("WEBGL_debug_renderer_info");
+    let vendorParam = gl.VENDOR;
+    let rendererParam = gl.RENDERER;
+    if (ext !== null) {
+      vendorParam = ext.UNMASKED_VENDOR_WEBGL;
+      rendererParam = ext.UNMASKED_RENDERER_WEBGL;
+    }
+    const vendor = gl.getParameter(vendorParam);
+    const renderer = gl.getParameter(rendererParam);
+    return {
+      hasWebGL: true,
+      vendor: vendor == null ? "" : String(vendor),
+      renderer: renderer == null ? "" : String(renderer)
+    };
+  });
+}
 function compareBrowserVersionsDescending(left, right) {
   const parse = (value) => {
     const version = value.slice(value.indexOf("-") + 1);
@@ -867,6 +963,14 @@ var CACHED_HEADLESS_SHELL_EXECUTABLES = {
 function cachedHeadlessShellExecutable(hostPlatform = process.platform, hostArch = process.arch) {
   return CACHED_HEADLESS_SHELL_EXECUTABLES[`${hostPlatform}/${hostArch}`];
 }
+function isNonEmptyFile(path) {
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    return stat?.isFile() === true && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
 function findCachedHeadlessShell(baseDir) {
   if (!existsSync(baseDir)) return void 0;
   const executable = cachedHeadlessShellExecutable();
@@ -877,7 +981,7 @@ function findCachedHeadlessShell(baseDir) {
     for (const version of versions) {
       if (exceedsChromeCeiling(version, ceiling)) continue;
       const binary = join2(baseDir, version, ...executable);
-      if (existsSync(binary)) return binary;
+      if (isNonEmptyFile(binary)) return binary;
     }
   } catch {
   }
@@ -933,15 +1037,15 @@ async function awaitBeforeDeadline(operation, deadline, label) {
   if (remainingMs <= 0) {
     throw new Error(`beginFrame probe timeout before ${label}`);
   }
+  return rejectAfter(operation, remainingMs, `beginFrame probe timeout during ${label}`);
+}
+async function rejectAfter(operation, timeoutMs, message) {
   let timeout;
   try {
     return await Promise.race([
       operation,
       new Promise((_, reject) => {
-        timeout = setTimeout(
-          () => reject(new Error(`beginFrame probe timeout during ${label}`)),
-          remainingMs
-        );
+        timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
       })
     ]);
   } finally {
@@ -1355,8 +1459,9 @@ function buildChromeArgs(options, config) {
   return chromeArgs;
 }
 function compositionRequiresWebGpu(html) {
-  for (const [tag] of html.matchAll(/<(?:[^<>"']|"[^"]*"|'[^']*')*>/g)) {
-    if (/\bdata-composition-id\b/i.test(tag)) return /\bdata-requires-webgpu(?:\s|=|>)/i.test(tag);
+  for (const tag of scanHtmlOpeningTags(html)) {
+    const names = tag.attributes.map((attribute) => attribute.name);
+    if (names.includes("data-composition-id")) return names.includes("data-requires-webgpu");
   }
   return false;
 }
@@ -1959,7 +2064,7 @@ function parseObjectPositionAxis(value, axis) {
   if (lower === "center" || lower === "") return 0.5;
   if (lower.endsWith("%")) {
     const pct = parseFloat(lower) / 100;
-    return Number.isFinite(pct) ? Math.max(0, Math.min(1, pct)) : 0.5;
+    return Number.isFinite(pct) ? pct : 0.5;
   }
   if (axis === "x" || axis === "y") return 0.5;
   return 0.5;
@@ -5166,6 +5271,7 @@ async function constructCaptureSession(input) {
     browserConsoleBuffer: [],
     scriptLoadFailures: [],
     pageErrors: [],
+    subTimelineWaitMemo: sessionOptions.subTimelineWaitMemo ?? {},
     warnings: [],
     capturePerf: {
       frames: 0,
@@ -5314,15 +5420,52 @@ async function pollHfReady(page, timeoutMs, intervalMs = 100) {
   State: __hf=${diag.hasHf}, seek=${diag.hasSeek}, player=${diag.hasPlayer}, renderReady=${diag.renderReady}, duration=${diag.duration}`
   );
 }
-async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, getScriptLoadFailures, scriptFailureGraceMs = 2e3, onPending, shouldStop) {
+async function listUnregisteredTimelineIds(page) {
+  const evaluated = await page.evaluate(`(function() {
+    var hosts = document.querySelectorAll("[data-composition-id]");
+    var timelines = window.__timelines || {};
+    var m = [];
+    for (var i = 0; i < hosts.length; i++) {
+      if (hosts[i].hasAttribute("data-no-timeline")) continue;
+      var id = hosts[i].getAttribute("data-composition-id");
+      if (id && !timelines[id]) m.push(id);
+    }
+    return m;
+  })()`);
+  return Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
+}
+async function waitForSubCompositionTimelines(session, page, timeoutMs) {
+  const memo = session.subTimelineWaitMemo;
+  session.subTimelineWaitOutcome = await pollSubCompositionTimelines(page, timeoutMs, {
+    getScriptLoadFailures: () => session.scriptLoadFailures,
+    onPending: (ids) => {
+      session.pendingTimelineIds = [...ids];
+    },
+    shouldStop: () => session.vfxFailure !== void 0,
+    knownUnregisteredIds: memo.unregisteredIds
+  });
+  const cleanTimeout = session.subTimelineWaitOutcome === "timeout" && session.vfxFailure === void 0 && session.pageErrors.length === 0 && session.scriptLoadFailures.length === 0;
+  if (cleanTimeout) {
+    memo.unregisteredIds = session.pendingTimelineIds ?? [];
+  }
+}
+async function pollSubCompositionTimelines(page, timeoutMs, {
+  intervalMs = 150,
+  getScriptLoadFailures,
+  scriptFailureGraceMs = 2e3,
+  onPending,
+  shouldStop,
+  knownUnregisteredIds = []
+} = {}) {
   const expression = `(function() {
     var hosts = document.querySelectorAll("[data-composition-id]");
     if (hosts.length === 0) return true;
     var timelines = window.__timelines || {};
+    var known = ${JSON.stringify(knownUnregisteredIds)};
     for (var i = 0; i < hosts.length; i++) {
       if (hosts[i].hasAttribute("data-no-timeline")) continue;
       var id = hosts[i].getAttribute("data-composition-id");
-      if (!id) continue;
+      if (!id || known.indexOf(id) !== -1) continue;
       if (!timelines[id]) return false;
     }
     return true;
@@ -5346,7 +5489,11 @@ async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, ge
     }
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
-  if (ready) {
+  const pendingIds = ready && knownUnregisteredIds.length === 0 ? [] : await listUnregisteredTimelineIds(page);
+  if (ready && pendingIds.length > 0 && (getScriptLoadFailures?.() ?? []).length > 0) {
+    scriptFailureBail = true;
+  }
+  if (ready && pendingIds.length === 0) {
     await page.evaluate(`(function() {
       if (typeof window.__hfForceTimelineRebind === "function") {
         window.__hfForceTimelineRebind();
@@ -5354,18 +5501,6 @@ async function pollSubCompositionTimelines(page, timeoutMs, intervalMs = 150, ge
     })()`);
     return "ready";
   }
-  const evaluated = await page.evaluate(`(function() {
-    var hosts = document.querySelectorAll("[data-composition-id]");
-    var timelines = window.__timelines || {};
-    var m = [];
-    for (var i = 0; i < hosts.length; i++) {
-      if (hosts[i].hasAttribute("data-no-timeline")) continue;
-      var id = hosts[i].getAttribute("data-composition-id");
-      if (id && !timelines[id]) m.push(id);
-    }
-    return m;
-  })()`);
-  const pendingIds = Array.isArray(evaluated) ? evaluated.map((id) => String(id)) : [];
   onPending?.(pendingIds);
   const missing = pendingIds.join(", ");
   if (scriptFailureBail) {
@@ -5735,17 +5870,7 @@ async function initializeSession(session) {
     const pageReadyTimeout = session.config?.playerReadyTimeout ?? DEFAULT_CONFIG.playerReadyTimeout;
     await pollHfReady(page, pageReadyTimeout);
     logInitPhase("pollHfReady complete");
-    session.subTimelineWaitOutcome = await pollSubCompositionTimelines(
-      page,
-      pageReadyTimeout,
-      void 0,
-      () => session.scriptLoadFailures,
-      void 0,
-      (ids) => {
-        session.pendingTimelineIds = [...ids];
-      },
-      () => session.vfxFailure !== void 0
-    );
+    await waitForSubCompositionTimelines(session, page, pageReadyTimeout);
     logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
     assertVfxIntact(session);
     recordSubTimelineWarning(session, pageReadyTimeout);
@@ -5851,17 +5976,7 @@ async function initializeSession(session) {
     const pageReadyTimeout = session.config?.playerReadyTimeout ?? DEFAULT_CONFIG.playerReadyTimeout;
     await pollHfReady(page, pageReadyTimeout);
     logInitPhase("pollHfReady complete");
-    session.subTimelineWaitOutcome = await pollSubCompositionTimelines(
-      page,
-      pageReadyTimeout,
-      void 0,
-      () => session.scriptLoadFailures,
-      void 0,
-      (ids) => {
-        session.pendingTimelineIds = [...ids];
-      },
-      () => session.vfxFailure !== void 0
-    );
+    await waitForSubCompositionTimelines(session, page, pageReadyTimeout);
     logInitPhase(`pollSubCompositionTimelines complete (${session.subTimelineWaitOutcome})`);
     assertVfxIntact(session);
     recordSubTimelineWarning(session, pageReadyTimeout);
@@ -6298,7 +6413,10 @@ async function createStaticVerificationPage(session) {
     });
     await page.evaluate(`window.__hfFlushSync?.()`);
     await pollHfReady(page, pageReadyTimeout);
-    await pollSubCompositionTimelines(page, pageReadyTimeout);
+    await pollSubCompositionTimelines(page, pageReadyTimeout, {
+      getScriptLoadFailures: () => session.scriptLoadFailures,
+      knownUnregisteredIds: session.subTimelineWaitMemo.unregisteredIds
+    });
     await applyVideoMetadataHints(page, session.options.videoMetadataHints);
     const skipVideoIds = session.options.skipReadinessVideoIds ?? [];
     await Promise.all([
@@ -7006,7 +7124,7 @@ async function captureFramesBatchPipelined(session, frameIndices, times) {
   return results;
 }
 async function discardWarmupCapture(session, frameIndex = 0, time = 0, innerCapture = captureFrameCore) {
-  const perfBefore = { ...session.capturePerf };
+  const perfBefore = { ...session.capturePerf, frameMs: [...session.capturePerf.frameMs] };
   const hasDamageBefore = session.beginFrameHasDamageCount;
   const noDamageBefore = session.beginFrameNoDamageCount;
   const dedupCountBefore = session.staticDedupCount;
@@ -7227,7 +7345,7 @@ import {
   openSync,
   readFileSync as readFileSync3,
   readdirSync as readdirSync2,
-  statSync as statSync2,
+  statSync as statSync3,
   writeFileSync as writeFileSync2,
   writeSync
 } from "fs";
@@ -7421,7 +7539,7 @@ var H264_ENCODER_BY_GPU = {
   qsv: "h264_qsv",
   amf: "h264_amf"
 };
-var GPU_PROBE_TIMEOUT_MS = 2e3;
+var GPU_PROBE_TIMEOUT_MS2 = 2e3;
 var GPU_PROBE_KILL_GRACE_MS = 1e3;
 function getCompiledGpuEncoders(ffmpegEncodersStdout) {
   return GPU_ENCODER_CANDIDATES.filter(
@@ -7538,7 +7656,7 @@ async function canUseGpuEncoder(encoder) {
   });
   trackChildProcess(ffmpeg);
   const outcome = await new ManagedChildProcess(ffmpeg, {
-    deadlineAtMs: Date.now() + GPU_PROBE_TIMEOUT_MS,
+    deadlineAtMs: Date.now() + GPU_PROBE_TIMEOUT_MS2,
     terminationGraceMs: GPU_PROBE_KILL_GRACE_MS
   }).wait();
   const usable = outcome.reason === "exit" && outcome.exitCode === 0;
@@ -7554,7 +7672,7 @@ async function canUseGpuEncoder(encoder) {
 function logGpuProbeFailure(encoder, result) {
   if (!isGpuProbeDebugEnabled()) return;
   if (result.code === 0 && !result.error && !result.timedOut) return;
-  const reason = result.error ? result.error.message : result.timedOut ? `timed out after ${GPU_PROBE_TIMEOUT_MS}ms` : `exit=${String(result.code)} signal=${String(result.signal ?? "")}`;
+  const reason = result.error ? result.error.message : result.timedOut ? `timed out after ${GPU_PROBE_TIMEOUT_MS2}ms` : `exit=${String(result.code)} signal=${String(result.signal ?? "")}`;
   const stderr = result.stderr?.trim();
   console.warn(`[gpuEncoder] ${encoder} probe failed: ${reason}${stderr ? `
 ${stderr}` : ""}`);
@@ -7661,10 +7779,6 @@ function withEvenDimensionPad(vfChain, pixelFormat, width, height) {
   return vfChain ? `${vfChain},${EVEN_DIMENSION_PAD}` : EVEN_DIMENSION_PAD;
 }
 
-// ../engine/src/utils/sdrCaptureColor.ts
-var SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
-var 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";
 var FFMPEG_SIGTERM_EXIT_LINE = /^Exiting normally, received signal 15\.?\r?$/m;
@@ -7783,7 +7897,7 @@ async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
-import { createReadStream, readFileSync, statSync } from "fs";
+import { createReadStream, readFileSync, statSync as statSync2 } from "fs";
 import { StringDecoder } from "string_decoder";
 import { basename } from "path";
 var FFPROBE_STDERR_MAX_BYTES = 8 * 1024;
@@ -7886,7 +8000,8 @@ var audioMetadataCache = /* @__PURE__ */ new Map();
 var mediaProbeOutputCache = /* @__PURE__ */ new Map();
 var mediaProbeOutputSignalCaches = /* @__PURE__ */ new WeakMap();
 var MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES = 128;
-var AAC_LC_SAMPLES_PER_PACKET = 1024;
+var AUDIO_DURATION_PROBE_MARGIN_SECONDS = 0.05;
+var AUDIO_DURATION_PROBE_TAIL_SECONDS = 1;
 var STILL_IMAGE_DEMUXERS = /* @__PURE__ */ new Set([
   "apng",
   "bmp_pipe",
@@ -7938,12 +8053,28 @@ function isPngImageProbe(output) {
 }
 function mediaFileIdentity(filePath) {
   try {
-    const stat = statSync(filePath, { bigint: true });
+    const stat = statSync2(filePath, { bigint: true });
     return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
   } catch {
     return null;
   }
 }
+function readMetadataCache(cache, key, identity) {
+  const cached = cache.get(key);
+  return cached?.identity === identity ? cached.promise : void 0;
+}
+function writeMetadataCache(cache, key, identity, promise) {
+  const entry = { identity, promise };
+  cache.set(key, entry);
+  void promise.then(
+    () => {
+      if (identity === null && cache.get(key) === entry) cache.delete(key);
+    },
+    () => {
+      if (cache.get(key) === entry) cache.delete(key);
+    }
+  );
+}
 async function probeMediaOutput(filePath, signal) {
   let cache = mediaProbeOutputCache;
   if (signal) {
@@ -7995,7 +8126,7 @@ async function readFileRange(filePath, start, length, signal) {
 async function hasCompletePngStructure(filePath, signal) {
   try {
     signal?.throwIfAborted();
-    const fileSize = statSync(filePath).size;
+    const fileSize = statSync2(filePath).size;
     const signature = await readFileRange(filePath, 0, 8, signal);
     signal?.throwIfAborted();
     if (signature.length !== 8 || !signature.equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
@@ -8126,7 +8257,8 @@ function parseFrameRate(frameRateStr) {
   return rounded > 0 ? rounded : 0.01;
 }
 async function extractMediaMetadata(filePath) {
-  const cached = videoMetadataCache.get(filePath);
+  const identity = mediaFileIdentity(filePath);
+  const cached = readMetadataCache(videoMetadataCache, filePath, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     let stillImageMetaMemo;
@@ -8210,12 +8342,7 @@ async function extractMediaMetadata(filePath) {
       frames
     };
   })();
-  videoMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (videoMetadataCache.get(filePath) === probePromise) {
-      videoMetadataCache.delete(filePath);
-    }
-  });
+  writeMetadataCache(videoMetadataCache, filePath, identity, probePromise);
   return probePromise;
 }
 function resolveStreamWindow(filePath, metadata) {
@@ -8231,12 +8358,13 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     videoStreamDurationSeconds: videoDurationSeconds,
     cacheKey
   } = resolveStreamWindow(filePath, metadata);
+  const identity = mediaFileIdentity(filePath);
   let probeCache = finalVideoFrameTimestampCache;
   if (signal) {
     probeCache = finalVideoFrameTimestampSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
     finalVideoFrameTimestampSignalCaches.set(signal, probeCache);
   }
-  const cached = probeCache.get(cacheKey);
+  const cached = readMetadataCache(probeCache, cacheKey, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
@@ -8271,17 +8399,13 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     }
     return Math.min(Math.max(timestamp - videoStreamStartSeconds, 0), videoDurationSeconds);
   })();
-  probeCache.set(cacheKey, probePromise);
-  probePromise.catch(() => {
-    if (probeCache.get(cacheKey) === probePromise) {
-      probeCache.delete(cacheKey);
-    }
-  });
+  writeMetadataCache(probeCache, cacheKey, identity, probePromise);
   return probePromise;
 }
 var extractVideoMetadata = extractMediaMetadata;
 async function extractAudioMetadata(filePath, options) {
-  const cached = options?.signal ? void 0 : audioMetadataCache.get(filePath);
+  const identity = mediaFileIdentity(filePath);
+  const cached = options?.signal ? void 0 : readMetadataCache(audioMetadataCache, filePath, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     const output = await probeMediaOutput(filePath, options?.signal);
@@ -8291,29 +8415,16 @@ async function extractAudioMetadata(filePath, options) {
     const streamDuration = audioStream.duration ? parseFloat(audioStream.duration) : void 0;
     const sampleRate = audioStream.sample_rate ? parseInt(audioStream.sample_rate) : 44100;
     const audioCodec = audioStream.codec_name || "unknown";
-    const isAacLc = /^\s*LC\s*$/i.test(audioStream.profile ?? "");
-    if (audioCodec === "aac" && isAacLc && sampleRate > 0) {
-      try {
-        const packetStdout = await runFfprobe(
-          filePath,
-          [
-            "-select_streams",
-            "a:0",
-            "-count_packets",
-            "-show_entries",
-            "stream=nb_read_packets",
-            "-print_format",
-            "json"
-          ],
-          options?.signal
-        );
-        const packetOutput = parseProbeJson(packetStdout);
-        const packetCount = Number(packetOutput.streams[0]?.nb_read_packets);
-        if (Number.isFinite(packetCount) && packetCount > 0) {
-          durationSeconds = packetCount * AAC_LC_SAMPLES_PER_PACKET / sampleRate;
-        }
-      } catch (error) {
-        if (options?.signal?.aborted) throw error;
+    if (sampleRate > 0) {
+      const decoded = await probeDecodedAudioDuration(
+        filePath,
+        sampleRate,
+        audioStartSeconds(audioStream, output.format),
+        durationSeconds,
+        options?.signal
+      );
+      if (decoded !== null) {
+        durationSeconds = reconcileAudioDuration(durationSeconds, decoded, output.format);
       }
     }
     return {
@@ -8326,14 +8437,58 @@ async function extractAudioMetadata(filePath, options) {
     };
   })();
   if (options?.signal) return probePromise;
-  audioMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (audioMetadataCache.get(filePath) === probePromise) {
-      audioMetadataCache.delete(filePath);
-    }
-  });
+  writeMetadataCache(audioMetadataCache, filePath, identity, probePromise);
   return probePromise;
 }
+function audioStartSeconds(stream, format) {
+  const start = parseFloat(stream.start_time ?? format.start_time ?? "");
+  return Number.isFinite(start) ? start : 0;
+}
+function reconcileAudioDuration(containerSeconds, decodedSeconds, format) {
+  const difference = decodedSeconds - containerSeconds;
+  const trustShorter = format.format_name === "aac";
+  if (difference > AUDIO_DURATION_PROBE_MARGIN_SECONDS) return decodedSeconds;
+  if (trustShorter && difference < -AUDIO_DURATION_PROBE_MARGIN_SECONDS) return decodedSeconds;
+  return containerSeconds;
+}
+async function probeDecodedAudioDuration(filePath, sampleRate, startSeconds, containerDurationSeconds, signal) {
+  const probe = async (readInterval) => {
+    const args = [
+      "-select_streams",
+      "a:0",
+      "-show_entries",
+      "frame=best_effort_timestamp_time,nb_samples",
+      "-of",
+      "csv=p=0"
+    ];
+    if (readInterval) args.unshift("-read_intervals", readInterval);
+    try {
+      const stdout = await runFfprobe(
+        filePath,
+        args,
+        signal,
+        // CSV, not JSON: a tail truncated under the size cap still parses.
+        { retainTail: true, maxChars: 64 * 1024 }
+      );
+      return stdout.split("\n").map((line) => {
+        const [timestampText, samplesText] = line.trim().split(",");
+        const timestamp = Number(timestampText);
+        const nbSamples = Number(samplesText);
+        return Number.isFinite(timestamp) && Number.isFinite(nbSamples) ? { timestamp, nbSamples } : void 0;
+      }).filter((frame) => frame !== void 0).at(-1);
+    } catch (error) {
+      if (signal?.aborted) throw signal.reason ?? error;
+      return void 0;
+    }
+  };
+  const tailStart = Math.max(
+    startSeconds,
+    startSeconds + containerDurationSeconds - AUDIO_DURATION_PROBE_TAIL_SECONDS
+  );
+  const lastFrame = await probe(`${tailStart}%`) ?? await probe();
+  if (!lastFrame) return null;
+  return lastFrame.timestamp + lastFrame.nbSamples / sampleRate - startSeconds;
+}
 var keyframeCache = /* @__PURE__ */ new Map();
 var PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS = 2;
 async function analyzeKeyframeIntervals(filePath, metadata) {
@@ -8781,7 +8936,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       failureReason: isExternalFfmpegInterruption(result) ? "external_interruption" : void 0
     };
   }
-  const fileSize = existsSync4(outputPath) ? statSync2(outputPath).size : 0;
+  const fileSize = existsSync4(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -8915,7 +9070,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       failureReason: concatResult.externalInterruption ? "external_interruption" : void 0
     };
   }
-  const fileSize = existsSync4(outputPath) ? statSync2(outputPath).size : 0;
+  const fileSize = existsSync4(outputPath) ? statSync3(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -9147,7 +9302,7 @@ function quantizationTableError(buffer, start, end) {
 // ../engine/src/services/streamingEncoder.ts
 import { spawn as spawn4 } from "child_process";
 import { once } from "events";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, statSync as statSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, statSync as statSync4 } from "fs";
 import { dirname as dirname3 } from "path";
 function createFrameReorderBuffer(startFrame, endFrame) {
   let cursor = startFrame;
@@ -9512,7 +9667,7 @@ FFmpeg stopped after ${streamingTimeout} ms without consuming a frame.` : "";
           }) ? "external_interruption" : void 0
         };
       }
-      const fileSize = existsSync5(outputPath) ? statSync3(outputPath).size : 0;
+      const fileSize = existsSync5(outputPath) ? statSync4(outputPath).size : 0;
       return { success: true, durationMs, fileSize };
     },
     getExitStatus: () => exitStatus,
@@ -9608,6 +9763,7 @@ function isMemberGroupHidden(groupsById, el) {
 // ../engine/src/services/videoFrameExtractor.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync8, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
 import { join as join10 } from "path";
+import { cpus } from "os";
 
 // ../engine/src/services/referenceResolver.ts
 function findReferenceTargetEl(doc, refId) {
@@ -9731,7 +9887,7 @@ import {
   readdirSync as readdirSync3,
   rmdirSync,
   rmSync as rmSync2,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync
 } from "fs";
 import { createHash, randomUUID } from "crypto";
@@ -10341,7 +10497,7 @@ async function fetchToPartial(url, partialPath, controller, options) {
   const readableStream = Readable.fromWeb(response.body);
   const fileStream = createWriteStream(partialPath, { flags: "wx" });
   await pipeline(readableStream, inspector, fileStream, { signal: controller.signal });
-  const localSize = statSync4(partialPath).size;
+  const localSize = statSync5(partialPath).size;
   const sha256Bytes = sha256.digest();
   const localSha256 = sha256Bytes.toString("hex");
   const md5Base64 = md5.digest("base64");
@@ -10755,7 +10911,7 @@ import {
   readdirSync as readdirSync5,
   renameSync,
   rmSync as rmSync3,
-  statSync as statSync5,
+  statSync as statSync6,
   utimesSync,
   writeFileSync as writeFileSync3
 } from "fs";
@@ -10782,7 +10938,7 @@ function extractedFrameIndex(file, format) {
   }
   return ordinal - 1;
 }
-function framePathsFromDirectory(outputDir, format) {
+function framePathsFromDirectory(outputDir, format, allowGaps = false) {
   const suffix = `.${format}`;
   const indexed = /* @__PURE__ */ new Map();
   for (const file of readdirSync4(outputDir)) {
@@ -10795,6 +10951,7 @@ function framePathsFromDirectory(outputDir, format) {
     }
     indexed.set(index, join8(outputDir, file));
   }
+  if (allowGaps) return new Map([...indexed].sort(([a], [b]) => a - b));
   const ordered = /* @__PURE__ */ new Map();
   for (let index = 0; index < indexed.size; index += 1) {
     const path = indexed.get(index);
@@ -10815,7 +10972,7 @@ var SCHEMA_PREFIX = "hfcache-v6-";
 var KEY_HEX_CHARS = 16;
 function readKeyStat(videoPath) {
   try {
-    const stat = statSync5(videoPath);
+    const stat = statSync6(videoPath);
     return { mtimeMs: Math.floor(stat.mtimeMs), size: stat.size };
   } catch {
     return null;
@@ -10949,7 +11106,7 @@ function removeDir(path) {
 }
 function collectGcEntry(dir, name, now, minAgeMs, stats, remove) {
   try {
-    const dirStat = statSync5(dir);
+    const dirStat = statSync6(dir);
     if (isPartialChild(name) && now - dirStat.mtimeMs >= minAgeMs) {
       remove(dir);
       stats.agedPartialsRemoved += 1;
@@ -10957,7 +11114,7 @@ function collectGcEntry(dir, name, now, minAgeMs, stats, remove) {
     }
     let lastUseMs = dirStat.mtimeMs;
     try {
-      lastUseMs = statSync5(join9(dir, COMPLETE_SENTINEL)).mtimeMs;
+      lastUseMs = statSync6(join9(dir, COMPLETE_SENTINEL)).mtimeMs;
     } catch {
     }
     return { dir, size: directorySizeBytes(dir), lastUseMs, ageMs: now - lastUseMs };
@@ -10967,7 +11124,7 @@ function collectGcEntry(dir, name, now, minAgeMs, stats, remove) {
 }
 function gcSweepDue(rootDir, maxAgeMs) {
   try {
-    return Date.now() - statSync5(join9(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
+    return Date.now() - statSync6(join9(rootDir, GC_MARKER)).mtimeMs > maxAgeMs;
   } catch {
     return true;
   }
@@ -11465,6 +11622,69 @@ function restoreSourceColourFilter(metadata) {
   ].filter(([, value]) => value && value !== "unknown" && value !== "reserved");
   return tags.length > 0 ? [`setparams=${tags.map(([key, value]) => `${key}=${value}`).join(":")}`] : [];
 }
+var EXTRACTION_SEGMENT_SECONDS = 120;
+function splitFrameRanges(ranges, segmentFrames) {
+  const segments = [];
+  for (const range of ranges) {
+    for (let offset = 0; offset < range.frames; offset += segmentFrames) {
+      segments.push({
+        firstFrame: range.firstFrame + offset,
+        frames: Math.min(segmentFrames, range.frames - offset)
+      });
+    }
+  }
+  return segments;
+}
+async function runSegmentedExtraction(job) {
+  const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments } = job;
+  const segmentCount = segments.length;
+  const failed = new AbortController();
+  const signal = job.runOptions.signal ? AbortSignal.any([job.runOptions.signal, failed.signal]) : failed.signal;
+  const results = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < segmentCount && !signal.aborted) {
+      const index = next++;
+      const { firstFrame, frames } = segments[index];
+      const result = await runFfmpeg(
+        [
+          ...decodeArgs,
+          "-noaccurate_seek",
+          "-ss",
+          String(startTime + firstFrame / fps),
+          "-i",
+          videoPath,
+          // Read one frame past the segment and keep exactly its own frames.
+          "-t",
+          String((frames + 1) / fps),
+          "-frames:v",
+          String(frames),
+          "-start_number",
+          String(firstFrame + 1),
+          ...filterAndEncodeArgs
+        ],
+        { ...job.runOptions, signal }
+      );
+      results[index] = result;
+      if (!result.success) failed.abort();
+    }
+  };
+  const workers = Math.min(segmentCount, Math.max(1, Math.floor(cpus().length / 2)));
+  await Promise.all(Array.from({ length: workers }, worker));
+  const ran = results.filter(Boolean);
+  const failure = ran.find((r) => !r.success && r.terminationReason !== "abort") ?? ran.find((r) => !r.success);
+  if (failure) return failure;
+  if (ran.length < segmentCount) {
+    return {
+      success: false,
+      exitCode: null,
+      stderr: "",
+      durationMs: 0,
+      terminationReason: "abort"
+    };
+  }
+  return ran[ran.length - 1];
+}
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { outputDir, quality = 95 } = options;
@@ -11504,6 +11724,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const toneMappedToSdr = options.toneMapHdrToSdr === true && isHdr && await toneMapsWithZscale();
   const decodeWithVideoToolbox = isHdr && isMacOS && !toneMappedToSdr;
   const sampleCfrAtOutputFps = !options.finalFrameOnly && !metadata.isVFR;
+  if (options.frameRanges && !sampleCfrAtOutputFps) {
+    throw new Error("frameRanges extraction needs a constant-frame-rate source");
+  }
   const args = [];
   if (decodeWithVideoToolbox) {
     args.push("-hwaccel", "videotoolbox");
@@ -11511,6 +11734,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (codecMayHaveAlpha(metadata.videoCodec)) {
     args.push("-c:v", decoderForCodec(metadata.videoCodec));
   }
+  const decodeArgs = [...args];
   if (options.finalFrameOnly) {
     args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
   } else {
@@ -11566,8 +11790,21 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       runOptions
     );
   } else {
-    if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
-    processResult = await runFfmpeg([...args, ...encodeArgs], runOptions);
+    const filterArgs = vfFilters.length > 0 ? ["-vf", vfFilters.join(",")] : [];
+    const segmentFrames = Math.round(EXTRACTION_SEGMENT_SECONDS * fps);
+    const totalFrames = extractionFrameCountForDuration(duration, normalizedFps, false);
+    processResult = sampleCfrAtOutputFps && (options.frameRanges || totalFrames > segmentFrames) ? await runSegmentedExtraction({
+      decodeArgs,
+      filterAndEncodeArgs: [...filterArgs, ...encodeArgs],
+      videoPath,
+      startTime,
+      fps,
+      segments: splitFrameRanges(
+        options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
+        segmentFrames
+      ),
+      runOptions
+    }) : await runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions);
   }
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
@@ -11606,7 +11843,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       diagnostic
     );
   }
-  const framePaths = framePathsFromDirectory(videoOutputDir, format);
+  const framePaths = framePathsFromDirectory(videoOutputDir, format, !!options.frameRanges);
   if (framePaths.size === 0 && duration > 0) {
     throw new VideoSourceExtractionError(
       "zero_output",
@@ -11615,7 +11852,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       `FFmpeg exited successfully but produced no frames (start=${startTime}, duration=${duration})`
     );
   }
-  if (framePaths.size > 0 && duration > 0 && !options.finalFrameOnly) {
+  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;
@@ -12298,6 +12535,57 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
     return rehydratePublishedCache(work, cacheTarget);
   }
+  async function deferExtraction(work) {
+    if (work.finalFrameOnly || work.metadata.isVFR || work.sdrToHdrTransfer !== void 0 || work.hdrToSdrTransformKey !== void 0) {
+      return null;
+    }
+    const expectedFrames = extractionFrameCountForDuration(
+      work.videoDuration,
+      configuredFps,
+      false
+    );
+    const tailFrames = Math.min(expectedFrames, Math.ceil(fps));
+    if (expectedFrames <= tailFrames) return null;
+    const probeDir = join10(options.outputDir, `${work.video.id}.tail-probe`);
+    try {
+      const tail = await extractVideoFramesRange(
+        work.videoPath,
+        work.video.id,
+        work.extractionMediaStart,
+        work.videoDuration,
+        {
+          ...scopedExtractionOptions(work),
+          frameRanges: [{ firstFrame: expectedFrames - tailFrames, frames: tailFrames }]
+        },
+        signal,
+        config,
+        probeDir
+      );
+      const totalFrames = expectedFrames - tailFrames + tail.totalFrames;
+      if (totalFrames <= expectedFrames * 0.6) return null;
+      const outputDir = join10(options.outputDir, work.video.id);
+      mkdirSync6(outputDir, { recursive: true });
+      return {
+        videoId: work.video.id,
+        srcPath: work.videoPath,
+        outputDir,
+        framePattern: `${FRAME_FILENAME_PREFIX}%05d.${work.format}`,
+        fps,
+        totalFrames,
+        metadata: work.metadata,
+        framePaths: /* @__PURE__ */ new Map(),
+        deferredRange: {
+          startTime: work.extractionMediaStart,
+          durationSeconds: work.videoDuration,
+          format: work.format
+        }
+      };
+    } catch {
+      return null;
+    } finally {
+      rmSync4(probeDir, { recursive: true, force: true });
+    }
+  }
   async function executeDirectMiss(miss, maxTransientRetries = options.maxTransientRetries ?? 0) {
     try {
       return { result: await extractDirectMiss(miss, maxTransientRetries) };
@@ -12422,8 +12710,17 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
   }
   const uniqueOutcomes = /* @__PURE__ */ new Map();
+  if (options.deferRangeExtraction) {
+    const works = [...uniqueWorks.values()];
+    const deferred = await Promise.all(works.map(deferExtraction));
+    works.forEach((work, i) => {
+      const result = deferred[i];
+      if (result) uniqueOutcomes.set(work.dedupeKey, { result });
+    });
+  }
   const cacheMisses = [];
   for (const work of uniqueWorks.values()) {
+    if (uniqueOutcomes.has(work.dedupeKey)) continue;
     const lookup = lookupCacheFor(work);
     if ("work" in lookup) {
       cacheMisses.push(lookup);
@@ -12479,7 +12776,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       errors.push(item.error);
     } else if ("result" in item) {
       extracted.push(item.result);
-      totalFramesExtracted += item.result.totalFrames;
+      if (!item.result.deferredRange) totalFramesExtracted += item.result.totalFrames;
     }
   }
   const sweepDue = breakdown.cacheMisses > 0 || cacheRootDir !== void 0 && gcSweepDue(cacheRootDir, GC_STALENESS_MS);
@@ -14716,7 +15013,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 }
 
 // ../engine/src/services/parallelCoordinator.ts
-import { cpus, freemem } from "os";
+import { cpus as cpus2, freemem } from "os";
 import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
 import { join as join15 } from "path";
@@ -14831,7 +15128,7 @@ var MIN_WORKERS = 1;
 var MAX_WORKER_DIAGNOSTIC_LINES = 8;
 var ABSOLUTE_MAX_WORKERS = 24;
 function defaultSafeMaxWorkers() {
-  return Math.max(6, Math.min(16, Math.floor(cpus().length / 8)));
+  return Math.max(6, Math.min(16, Math.floor(cpus2().length / 8)));
 }
 var MIN_FRAMES_PER_WORKER = 30;
 function shouldDisableBrowserPoolForParallelWorker({
@@ -14876,7 +15173,7 @@ function formatWorkerFailure(result) {
   return `${base}; diagnostics: ${diagnostics}`;
 }
 function computeWorkerSizing(totalFrames, requested, config) {
-  const cpuCount = cpus().length;
+  const cpuCount = cpus2().length;
   const totalMemoryMb = getSystemTotalMb();
   const heapLimitMb = Math.round(getHeapStatistics().heap_size_limit / (1024 * 1024));
   const heapBasedWorkers = Math.max(
@@ -15434,7 +15731,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
 }
 function getSystemResources() {
   return {
-    cpuCores: cpus().length,
+    cpuCores: cpus2().length,
     totalMemoryMB: getSystemTotalMb(),
     freeMemoryMB: Math.round(freemem() / (1024 * 1024)),
     recommendedWorkers: calculateOptimalWorkers(1e3)
@@ -15444,7 +15741,7 @@ function getSystemResources() {
 // ../engine/src/services/fileServer.ts
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync7, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync6, constants } from "fs";
+import { readFileSync as readFileSync7, openSync as openSync4, fstatSync, closeSync as closeSync4, statSync as statSync7, constants } from "fs";
 import { join as join16, extname as extname3 } from "path";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -15481,7 +15778,7 @@ function readRegularFile(filePath) {
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR"))
       return null;
-    if (!statSync6(filePath, { throwIfNoEntry: false })?.isFile()) return null;
+    if (!statSync7(filePath, { throwIfNoEntry: false })?.isFile()) return null;
     throw error;
   }
   try {
@@ -15909,6 +16206,7 @@ export {
   resolveConfig,
   shouldClampToScreenshotForConcreteGpu,
   applyConcreteGpuScreenshotClamp,
+  SDR_RGB_TO_BT709_FILTER,
   BrowserLeasePool,
   setHostHandlesSigint,
   resolveHeadlessShellPath,
@@ -15918,6 +16216,7 @@ export {
   releaseBrowser,
   drainBrowserPool,
   closeBrowserPool,
+  usesSoftwareWebGpu,
   buildChromeArgs,
   compositionRequiresWebGpu,
   WebGpuUnavailableError,