hyperframes 0.8.155 → 0.8.156

package/dist/{chunk-TLC4GYT5.js → chunk-YUTUYCGK.js}

@@ -10,8 +10,9 @@ import {
   isLowMemorySystem
 } from "./chunk-JYVGYKXG.js";
 import {
-  describeWslGpuAccess
-} from "./chunk-7KDQAD2W.js";
+  describeWslGpuAccess,
+  detectWsl
+} from "./chunk-OBXWIVYN.js";
 import {
   MEDIA_VISUAL_STYLE_PROPERTIES,
   RENDER_FRAME_ID_PREFIX,
@@ -29,7 +30,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-ZDEEHQ2Y.js";
+} from "./chunk-3THJEW7G.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -58,7 +59,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-GV7I3ZSQ.js";
+} from "./chunk-OE4WEQMH.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -1025,6 +1026,43 @@ function resolveHeadlessShellPath(config) {
     join2(home, ".cache", "hyperframes", "chrome", "chrome-headless-shell")
   ) ?? findCachedHeadlessShell(join2(home, ".cache", "puppeteer", "chrome-headless-shell"));
 }
+function resolveFullChromePath() {
+  const baseDir = join2(homedir(), ".cache", "puppeteer", "chrome");
+  let versions;
+  try {
+    versions = readdirSync(baseDir).sort(compareBrowserVersionsDescending);
+  } catch {
+    return void 0;
+  }
+  for (const version of versions) {
+    const candidates = [
+      join2(
+        baseDir,
+        version,
+        "chrome-mac-arm64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join2(
+        baseDir,
+        version,
+        "chrome-mac-x64",
+        "Google Chrome for Testing.app",
+        "Contents",
+        "MacOS",
+        "Google Chrome for Testing"
+      ),
+      join2(baseDir, version, "chrome-linux64", "chrome"),
+      join2(baseDir, version, "chrome-win64", "chrome.exe")
+    ];
+    for (const binary of candidates) {
+      if (existsSync(binary)) return binary;
+    }
+  }
+  return void 0;
+}
 var ENABLE_BROWSER_POOL = DEFAULT_CONFIG.enableBrowserPool;
 var BEGINFRAME_ONLY_FLAGS = /* @__PURE__ */ new Set([
   "--deterministic-mode",
@@ -1203,33 +1241,45 @@ function formatProbeFailure(err) {
   return `probe failed (${err instanceof Error ? err.message : String(err)})`;
 }
 async function probeAutoBrowserGpuMode(options) {
-  const platform = options.platform ?? process.platform;
-  const browserTimeout = options.browserTimeout ?? DEFAULT_CONFIG.browserTimeout;
   const executablePath = options.chromePath ?? resolveHeadlessShellPath({});
   const ppt = await getPuppeteerOrNull();
   if (ppt === null) {
     logResolvedBrowserGpuMode("software", "puppeteer unavailable");
     return { mode: "software", cause: "probe-error" };
   }
+  const probed = await probeWebGlMode(ppt, executablePath, options);
+  if (probed.mode === "hardware" || !detectWsl(options.wslHost)) return probed;
+  return probeWslFullChrome(ppt, executablePath, options, probed);
+}
+async function probeWslFullChrome(ppt, shellPath, options, shellOutcome) {
+  const fullChrome = (options.findFullChrome ?? resolveFullChromePath)();
+  let route = { state: "missing" };
+  if (fullChrome) {
+    const viaFullChrome = fullChrome === shellPath ? shellOutcome : await probeWebGlMode(ppt, fullChrome, options, "full Chrome: ");
+    if (viaFullChrome.mode === "hardware") return { mode: "hardware", browserPath: fullChrome };
+    route = { state: viaFullChrome.cause ?? "no-gpu", path: fullChrome };
+  }
+  return { ...shellOutcome, wslAccess: describeWslGpuAccess(options.wslHost, route) ?? void 0 };
+}
+async function probeWebGlMode(ppt, executablePath, options, label = "") {
   try {
     const info = await probeHardwareWebGlInfo(ppt, {
-      args: getHardwareGpuProbeArgs(platform),
-      browserTimeout,
+      args: getHardwareGpuProbeArgs(options.platform ?? process.platform),
+      browserTimeout: options.browserTimeout ?? DEFAULT_CONFIG.browserTimeout,
       executablePath,
       probeLifecycle: options.probeLifecycle
     });
     const resolved = resolveWebGlProbeMode(info);
-    logResolvedBrowserGpuMode(resolved, describeWebGlProbe(info));
-    if (resolved === "hardware") return { mode: "hardware" };
-    return { mode: "software", cause: "no-gpu", ...wslAccess(options) };
+    logResolvedBrowserGpuMode(resolved, label + describeWebGlProbe(info));
+    return resolved === "hardware" ? { mode: "hardware" } : { mode: "software", cause: "no-gpu" };
   } catch (err) {
-    logResolvedBrowserGpuMode("software", formatProbeFailure(err));
-    return { mode: "software", cause: "probe-error", ...wslAccess(options) };
+    logResolvedBrowserGpuMode("software", label + formatProbeFailure(err));
+    return { mode: "software", cause: "probe-error" };
   }
 }
-function wslAccess(options) {
-  const lines = describeWslGpuAccess(options.wslHost);
-  return lines ? { wslAccess: lines } : {};
+async function resolveCaptureBrowserPath(resolvedMode, config) {
+  const probed = resolvedMode === "hardware" ? await _autoBrowserGpuModeCache : void 0;
+  return probed?.browserPath ?? resolveHeadlessShellPath(config);
 }
 function resolveBrowserGpuMode(mode, options = {}) {
   if (mode === "software") return Promise.resolve(mode);
@@ -1253,19 +1303,19 @@ function resolveBrowserGpuMode(mode, options = {}) {
 }
 var _unverifiedHardwareGpuWarned = false;
 var _wslSoftwareNoteLogged = false;
-function buildWslSoftwareNote({ cause, wslAccess: wslAccess2 = [] }) {
+function buildWslSoftwareNote({ cause, wslAccess = [] }) {
   const check = cause === "probe-error" ? "the GPU check could not finish (see the probe line above)" : "the GPU check found no hardware GPU";
   return [
     `[hyperframes] WSL: ${check}, so this render uses software WebGL (SwiftShader) and runs at CPU speed.`,
-    ...wslAccess2,
+    ...wslAccess,
     "  Pass --no-browser-gpu to skip the GPU check and render in software."
   ].join("\n");
 }
-function buildUnverifiedHardwareGpuWarning(platform, { cause, wslAccess: wslAccess2 }) {
+function buildUnverifiedHardwareGpuWarning(platform, { cause, wslAccess }) {
   if (cause === "probe-error") {
-    return "[hyperframes] browserGpuMode=hardware was requested, but the GPU probe could not run, so hardware acceleration is UNVERIFIED. If Chrome falls back to software WebGL the capture will run at CPU speed. Honouring the explicit request anyway.\n  This is a probe failure, not evidence of a missing GPU: see the `browserGpuMode probe \u2192 software (probe failed ...)` line above for the underlying error, which usually means Chrome could not launch (bad HYPERFRAMES_BROWSER_PATH, missing shared libraries, or a denied sandbox) rather than a GPU problem.\n  Run `hyperframes doctor` to check the Chrome install." + (wslAccess2 ? ["", "  Under WSL, a GPU path that is slow to start or unreachable can also cause it:"].concat(wslAccess2).join("\n") : "");
+    return "[hyperframes] browserGpuMode=hardware was requested, but the GPU probe could not run, so hardware acceleration is UNVERIFIED. If Chrome falls back to software WebGL the capture will run at CPU speed. Honouring the explicit request anyway.\n  This is a probe failure, not evidence of a missing GPU: see the `browserGpuMode probe \u2192 software (probe failed ...)` line above for the underlying error, which usually means Chrome could not launch (bad HYPERFRAMES_BROWSER_PATH, missing shared libraries, or a denied sandbox) rather than a GPU problem.\n  Run `hyperframes doctor` to check the Chrome install." + (wslAccess ? ["", "  Under WSL, a GPU path that is slow to start or unreachable can also cause it:"].concat(wslAccess).join("\n") : "");
   }
-  const remediation = wslAccess2?.join("\n") ?? (platform === "linux" ? "  Inside Docker, the container needs GPU passthrough: `--gpus all` with the NVIDIA Container Toolkit installed, or `--device /dev/dri` for Mesa/AMD/Intel. The image also needs the matching userspace driver + libEGL. Verify with `hyperframes render --browser-gpu` and watch for this warning disappearing." : "  Check that the host exposes a GPU to this process and that the graphics drivers are installed.");
+  const remediation = wslAccess?.join("\n") ?? (platform === "linux" ? "  Inside Docker, the container needs GPU passthrough: `--gpus all` with the NVIDIA Container Toolkit installed, or `--device /dev/dri` for Mesa/AMD/Intel. The image also needs the matching userspace driver + libEGL. Verify with `hyperframes render --browser-gpu` and watch for this warning disappearing." : "  Check that the host exposes a GPU to this process and that the graphics drivers are installed.");
   return `[hyperframes] browserGpuMode=hardware was requested, but the WebGL probe found no hardware GPU, so Chrome will silently fall back to software WebGL and the capture will run at CPU speed. Honouring the explicit request anyway.
 ${remediation}
   Pass --no-browser-gpu to select deterministic SwiftShader instead of waiting on a hardware path that is not there.`;
@@ -5265,14 +5315,16 @@ async function createCaptureSession(serverUrl, outputDir, options, onBeforeCaptu
     resolvedGpuMode,
     config
   );
-  const preMode = headlessShell && isLinux && !effectiveForceScreenshot && !supersampling && !drawElementTransparent ? "beginframe" : "screenshot";
+  const browserPath = await resolveCaptureBrowserPath(resolvedGpuMode, config);
+  const wslFullChromeHasNoBeginFrame = browserPath !== headlessShell;
+  const preMode = headlessShell && !wslFullChromeHasNoBeginFrame && isLinux && !effectiveForceScreenshot && !supersampling && !drawElementTransparent ? "beginframe" : "screenshot";
   const requiresWebGpu = options.requiresWebGpu ?? await fetch(`${serverUrl}/index.html`, { signal: AbortSignal.timeout(5e3) }).then((res) => res.text()).then(compositionRequiresWebGpu).catch(() => false);
   const gpuConfig = { ...config, browserGpuMode: resolvedGpuMode };
   const chromeArgs = buildChromeArgs(
     { width: options.width, height: options.height, captureMode: preMode, requiresWebGpu },
     gpuConfig
   );
-  const browserLease = await acquireBrowser(chromeArgs, config);
+  const browserLease = await acquireBrowser(chromeArgs, { ...config, chromePath: browserPath });
   return constructCaptureSessionWithRollback({
     browserLease,
     serverUrl,
@@ -8031,35 +8083,6 @@ async function runFfmpeg(args, opts) {
   });
   return toResult(await managed.wait());
 }
-async function runFfmpegPipeline(producerArgs, consumerArgs, opts) {
-  if (opts?.signal?.aborted) return { ...ABORTED_BEFORE_START };
-  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);
-}
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn3 } from "child_process";
@@ -11194,7 +11217,7 @@ function framePathsFromDirectory(outputDir, format, allowGaps = false) {
 // ../engine/src/services/extractionCache.ts
 var COMPLETE_SENTINEL = ".hf-complete";
 var GC_MARKER = ".hf-last-gc";
-var SCHEMA_PREFIX = "hfcache-v6-";
+var SCHEMA_PREFIX = "hfcache-v7-";
 var KEY_HEX_CHARS = 16;
 async function readContentSha256(path, signal) {
   try {
@@ -11809,55 +11832,6 @@ function chromeGuessForUntaggedMatrix(metadata) {
   const hd = metadata.height >= 720 && !CHROME_BT601_UNTAGGED_CODECS.has(metadata.videoCodec);
   return [`setparams=colorspace=${hd ? "bt709" : "smpte170m"}`];
 }
-var 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"
-]);
-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(([key, value]) => `${key}=${value}`).join(":")}`] : [];
-}
 var EXTRACTION_SEGMENT_SECONDS = 120;
 var EXTRACTION_SLOTS = Math.max(1, Math.floor(cpus().length / 2));
 var inExtractionSlot = createConcurrencyLimit(EXTRACTION_SLOTS);
@@ -11964,8 +11938,8 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const isMacOS = process.platform === "darwin";
   const toneMappedToSdr = options.toneMapHdrToSdr === true && isHdr && await toneMapsWithZscale();
   const decodeWithVideoToolbox = isHdr && isMacOS && !toneMappedToSdr;
-  const sampleCfrAtOutputFps = !options.finalFrameOnly && !metadata.isVFR;
-  if (options.frameRanges && !sampleCfrAtOutputFps) {
+  const sampleAtOutputFps = !options.finalFrameOnly;
+  if (options.frameRanges && (!sampleAtOutputFps || metadata.isVFR)) {
     throw new Error("frameRanges extraction needs a constant-frame-rate source");
   }
   const args = [];
@@ -11979,14 +11953,14 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (options.finalFrameOnly) {
     args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
   } else {
-    if (sampleCfrAtOutputFps) args.push("-noaccurate_seek");
+    if (sampleAtOutputFps) args.push("-noaccurate_seek");
     args.push("-ss", String(startTime), "-i", videoPath, "-t", String(duration));
   }
   const vfFilters = [];
   if (decodeWithVideoToolbox) {
     vfFilters.push("format=nv12");
   }
-  if (sampleCfrAtOutputFps) {
+  if (sampleAtOutputFps) {
     vfFilters.push(
       "settb=intb/2",
       "setpts=PTS-lte(TB\\,0.001)",
@@ -12011,48 +11985,25 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   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 inExtractionSlot(
-      () => 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
-      ),
-      signal
-    );
-  } else {
-    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 inExtractionSlot(
-      () => runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions),
-      signal
-    );
-  }
+  const filterArgs = vfFilters.length > 0 ? ["-vf", vfFilters.join(",")] : [];
+  const segmentFrames = Math.round(EXTRACTION_SEGMENT_SECONDS * fps);
+  const totalFrames = extractionFrameCountForDuration(duration, normalizedFps, metadata.isVFR);
+  const boundVfrFrameCount = metadata.isVFR && totalFrames > 0;
+  const processResult = sampleAtOutputFps && (options.frameRanges || boundVfrFrameCount || totalFrames > segmentFrames) ? await runSegmentedExtraction({
+    decodeArgs,
+    filterAndEncodeArgs: [...filterArgs, ...encodeArgs],
+    videoPath,
+    startTime,
+    fps,
+    segments: splitFrameRanges(
+      options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
+      segmentFrames
+    ),
+    runOptions
+  }) : await inExtractionSlot(
+    () => runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions),
+    signal
+  );
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
       "external_interruption",
@@ -14799,10 +14750,11 @@ function buildFadeFilters(track) {
   }
   return stages.length ? `,${stages.join(",")}` : "";
 }
-function buildTrackInputFilter(track, index, volumeFilter, totalDuration) {
+function buildTrackInputFilter(track, index, volumeFilter, totalDuration, padToDuration = true) {
   const delayMs = Math.round(track.start * 1e3);
   const trimDuration = track.end - track.start + (track.tailSeconds ?? 0);
-  return `[${index}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter}${buildFadeFilters(track)},adelay=${delayMs}|${delayMs},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[a${index}]`;
+  const filters = `[${index}:a]atrim=0:${formatFilterNumber(trimDuration)},${volumeFilter}${buildFadeFilters(track)},adelay=${delayMs}|${delayMs}`;
+  return `${filters}${padToDuration ? `,apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}` : ""}[a${index}]`;
 }
 function missingSourceMessage(elementId, src, baseDir, resolvedPath) {
   const relativePath = relative(baseDir, resolvedPath).replace(/\\/g, "/");
@@ -15079,26 +15031,26 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
   }
   const outputDir = dirname6(outputPath);
   if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
-  const buildFilterComplex = (ignoreAutomation) => {
+  const buildFilterComplex = (ignoreAutomation, useNormalize2) => {
     const filterParts = [];
     tracks.forEach((track, i) => {
       const volumeFilter = buildVolumeExpression(track, ignoreAutomation);
-      filterParts.push(buildTrackInputFilter(track, i, volumeFilter, totalDuration));
+      filterParts.push(buildTrackInputFilter(track, i, volumeFilter, totalDuration, !useNormalize2));
     });
     const mixInputs = tracks.map((_, i) => `[a${i}]`).join("");
-    const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0[mixed]`;
-    const compensatedGain = masterOutputGain * tracks.length;
-    const postMixGainFilter = `[mixed]volume=${formatFilterNumber(compensatedGain)}[out]`;
+    const mixFilter = `${mixInputs}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0${useNormalize2 ? ":normalize=0" : ""}[mixed]`;
+    const gain = masterOutputGain * (useNormalize2 ? 1 : tracks.length);
+    const postMixGainFilter = useNormalize2 ? `[mixed]volume=${formatFilterNumber(gain)},apad,asetpts=N/SR/TB,atrim=0:${formatFilterNumber(totalDuration)}[out]` : `[mixed]volume=${formatFilterNumber(gain)}[out]`;
     return [...filterParts, mixFilter, postMixGainFilter].join(";");
   };
-  const runMix = async (ignoreAutomation) => {
+  const runMix = async (ignoreAutomation, useNormalize2) => {
     const inputs = [];
     tracks.forEach((track) => inputs.push("-i", track.srcPath));
     const scriptDir = mkdtempSync6(join13(outputDir, ".filter-complex-"));
     const scriptPath = join13(scriptDir, "graph.txt");
     const fd = openSync4(scriptPath, "wx", 384);
     try {
-      writeFileSync6(fd, buildFilterComplex(ignoreAutomation));
+      writeFileSync6(fd, buildFilterComplex(ignoreAutomation, useNormalize2));
     } finally {
       closeSync4(fd);
     }
@@ -15126,11 +15078,16 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config,
       rmSync7(scriptDir, { recursive: true, force: true });
     }
   };
-  let result = await runMix(false);
+  let useNormalize = true;
+  let result = await runMix(false, useNormalize);
+  if (!result.success && result.failureReason !== "external_interruption" && !signal?.aborted && groupNormalizeOptionUnsupported(result.stderr)) {
+    useNormalize = false;
+    result = await runMix(false, useNormalize);
+  }
   let degradedAutomation = false;
   const hasAutomation = tracks.some((track) => (track.volumeKeyframes?.length ?? 0) > 0);
   if (!result.success && result.failureReason !== "external_interruption" && !signal?.aborted && hasAutomation) {
-    const retry = await runMix(true);
+    const retry = await runMix(true, useNormalize);
     if (retry.success) {
       result = retry;
       degradedAutomation = true;
@@ -16645,9 +16602,6 @@ function verifyGpuParity(a, b, options = {}) {
 }
 
 // ../engine/src/services/hdrCapture.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7 } from "fs";
-import { join as join17 } from "path";
-import { homedir as homedir2 } from "os";
 var PQ_M1 = 0.1593017578125;
 var PQ_M2 = 78.84375;
 var PQ_C1 = 0.8359375;
@@ -16768,39 +16722,6 @@ function float16ToPqRgb(rawBuffer, bytesPerRow, width, height) {
   }
   return output;
 }
-function resolveHeadedChromePath() {
-  const baseDir = join17(homedir2(), ".cache", "puppeteer", "chrome");
-  if (!existsSync12(baseDir)) return void 0;
-  const versions = readdirSync7(baseDir).sort().reverse();
-  for (const version of versions) {
-    const candidates = [
-      join17(
-        baseDir,
-        version,
-        "chrome-mac-arm64",
-        "Google Chrome for Testing.app",
-        "Contents",
-        "MacOS",
-        "Google Chrome for Testing"
-      ),
-      join17(
-        baseDir,
-        version,
-        "chrome-mac-x64",
-        "Google Chrome for Testing.app",
-        "Contents",
-        "MacOS",
-        "Google Chrome for Testing"
-      ),
-      join17(baseDir, version, "chrome-linux64", "chrome"),
-      join17(baseDir, version, "chrome-win64", "chrome.exe")
-    ];
-    for (const binary of candidates) {
-      if (existsSync12(binary)) return binary;
-    }
-  }
-  return void 0;
-}
 async function launchHdrBrowser(width, height) {
   let ppt;
   try {
@@ -16815,7 +16736,7 @@ async function launchHdrBrowser(width, height) {
     ppt = mod.default;
   }
   if (!ppt) throw new Error("Neither puppeteer nor puppeteer-core found");
-  const chromePath = resolveHeadedChromePath();
+  const chromePath = resolveFullChromePath();
   if (!chromePath) {
     throw new Error(
       "[HDR] No Chrome binary found. Install: npx @puppeteer/browsers install chrome@stable"

package/dist/{chunk-6ENZIL42.js → chunk-YZEHYWOH.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   sherpaParakeetInstalled,
   sherpaUnsupportedReason
-} from "./chunk-PCBCTD7M.js";
+} from "./chunk-DDSQBREC.js";
 import {
   findParakeet
 } from "./chunk-JZIEZCQM.js";

package/dist/{clean-J3IRHNY5.js → clean-4HTCYML6.js}

@@ -6,14 +6,14 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   redactHome
-} from "./chunk-AVGGHUVK.js";
+} from "./chunk-HBKKW3NL.js";
 import "./chunk-Z27A7NUB.js";
 import "./chunk-5ETJX6WM.js";
 import {
   loadProducer
-} from "./chunk-ECFNYTEM.js";
-import "./chunk-PSDTKP6K.js";
-import "./chunk-WQMTHPTK.js";
+} from "./chunk-IOBKVP27.js";
+import "./chunk-VK5JRYJL.js";
+import "./chunk-DSX7R5M7.js";
 import "./chunk-C6TPGUWD.js";
 import {
   DEFAULT_HISTORY_ROOT,
@@ -23,14 +23,14 @@ import {
 import {
   CACHE_DIR_NAME,
   cleanupProxyCache
-} from "./chunk-PVGDU7SE.js";
+} from "./chunk-7U27WUMQ.js";
 import "./chunk-FFDC5OWV.js";
 import {
   formatBytes
 } from "./chunk-K2FLNJVB.js";
-import "./chunk-45FUWHHV.js";
+import "./chunk-VY23BB2D.js";
 import "./chunk-5CS4T6C6.js";
-import "./chunk-QWQ6GQTI.js";
+import "./chunk-7FFGZC2X.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -46,29 +46,29 @@ import "./chunk-TJSTGSAW.js";
 import "./chunk-LBT4AMSF.js";
 import {
   withMeta
-} from "./chunk-5GZLD7OW.js";
+} from "./chunk-COBIO7VC.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-Q3BS3MN5.js";
+import "./chunk-SO44ETGW.js";
 import "./chunk-3DKN5WKL.js";
 import "./chunk-EOVYQ3IG.js";
 import "./chunk-6BEFEWFB.js";
-import "./chunk-KEGTYA7V.js";
+import "./chunk-SCOXM5LP.js";
 import "./chunk-XT6MXC7A.js";
 import {
   EXTRACT_CACHE_MIN_AGE_MS,
   directorySizeBytes,
   gcExtractionCache,
   resolveExtractCacheDir
-} from "./chunk-TLC4GYT5.js";
-import "./chunk-V6UUZGP6.js";
+} from "./chunk-YUTUYCGK.js";
+import "./chunk-2K5YII2L.js";
 import "./chunk-NE55C6S5.js";
 import "./chunk-JYVGYKXG.js";
-import "./chunk-7KDQAD2W.js";
-import "./chunk-ZDEEHQ2Y.js";
-import "./chunk-GV7I3ZSQ.js";
+import "./chunk-OBXWIVYN.js";
+import "./chunk-3THJEW7G.js";
+import "./chunk-OE4WEQMH.js";
 import "./chunk-VC76R6W2.js";
 import "./chunk-UJKQWGFF.js";
 import "./chunk-VYKPBRCB.js";