@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-SZNTYTIV.js

@@ -0,0 +1,990 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  inAgentSandbox,
+  isOneProcessOverPipe,
+  machServiceDenied,
+  oneProcessOverPipe,
+  pageNavigationTimeoutMs,
+  pipeLaunchClosedOnMac,
+  sandboxDeniedRemediation,
+  windowsChromeCrashRemediation
+} from "./chunk-YOR4CTCE.js";
+import {
+  resolveCompositionViewportFromHtml
+} from "./chunk-LEKZNRKI.js";
+import {
+  resolveCaptureBrowserGpuMode,
+  resolveLocalBrowserGpuMode,
+  resolveLocalWebGpu
+} from "./chunk-WKBM7NDG.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  requestCliExit
+} from "./chunk-JVBRJMOP.js";
+import {
+  assertWebGpuAdapterAvailable,
+  compositionRequiresWebGpu
+} from "./chunk-TIQB63MX.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import {
+  withHyperframesBrowserMarker
+} from "./chunk-K4MJX7SR.js";
+import {
+  processIsAlive
+} from "./chunk-KGPLIH7B.js";
+
+// src/browser/windowsChromeWatchdog.ts
+import { spawn } from "child_process";
+import { realpathSync } from "fs";
+var SWEEP = `$b=[int]$env:HF_CHROME_PID; $x=$env:HF_CHROME_EXE; $t=[DateTimeOffset]::FromUnixTimeMilliseconds([int64]$env:HF_CHROME_SINCE).UtcDateTime; Get-CimInstance Win32_Process | Where-Object { ($_.ProcessId -eq $b -or $_.ParentProcessId -eq $b) -and $_.ExecutablePath -eq $x -and $_.CreationDate.ToUniversalTime() -ge $t } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`;
+var WATCHDOG = `let clean = false;
+const done = () => {
+  if (!clean) require("node:child_process").spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ${JSON.stringify(SWEEP)}], { windowsHide: true, timeout: 20000 });
+  process.exit(0);
+};
+process.stdin.on("data", (data) => { clean ||= String(data).includes("clean"); });
+process.stdin.on("end", done);
+process.stdin.on("error", done);`;
+function executableOf(chrome) {
+  try {
+    return realpathSync.native(chrome.spawnfile);
+  } catch {
+    return void 0;
+  }
+}
+function watchChromeTree(chrome, launchedAt) {
+  const executable = process.platform === "win32" ? executableOf(chrome) : void 0;
+  if (!executable || chrome.pid === void 0) return void 0;
+  const watchdog = spawn(process.execPath, ["-e", WATCHDOG], {
+    detached: true,
+    env: {
+      ...process.env,
+      HF_CHROME_PID: String(chrome.pid),
+      HF_CHROME_EXE: executable,
+      HF_CHROME_SINCE: String(launchedAt)
+    },
+    stdio: ["pipe", "ignore", "ignore"],
+    windowsHide: true
+  });
+  watchdog.on("error", () => {
+  });
+  watchdog.stdin?.on("error", () => {
+  });
+  watchdog.unref();
+  watchdog.stdin?.unref?.();
+  let released = false;
+  return {
+    release(clean) {
+      if (released) return;
+      released = true;
+      watchdog.stdin?.end(clean ? "clean" : "");
+    }
+  };
+}
+
+// src/browser/launch.ts
+var BrowserCleanupError = class extends AggregateError {
+};
+var browsers = /* @__PURE__ */ new Set();
+var closing = /* @__PURE__ */ new WeakMap();
+var watchdogs = /* @__PURE__ */ new WeakMap();
+var pending = /* @__PURE__ */ new Map();
+var sessionCleanups = /* @__PURE__ */ new Set();
+var CLOSE_GRACE_MS = 1e3;
+var LAUNCH_TIMEOUT_MS = 3e4;
+var EXIT_POLL_MS = 50;
+var listening = false;
+var shutdown;
+function stopForSignal(signal) {
+  if (shutdown) return;
+  shutdown = closeManagedBrowsers();
+  void shutdown.then(
+    () => requestCliExit(signal === "SIGINT" ? 130 : 143),
+    (error) => {
+      console.error("Browser shutdown failed:", error);
+      requestCliExit(1);
+    }
+  );
+}
+function ownSignals() {
+  if (listening) return;
+  listening = true;
+  process.on("SIGINT", () => stopForSignal("SIGINT"));
+  process.on("SIGTERM", () => stopForSignal("SIGTERM"));
+}
+async function resolveManagedGpuMode(requestedMode, chromePath, context = {}) {
+  ownSignals();
+  if (requestedMode === "auto" && inAgentSandbox()) return "software";
+  return resolveCaptureBrowserGpuMode(requestedMode, chromePath, {
+    launch: async (puppeteer, options) => {
+      context.signal?.throwIfAborted();
+      const browser = await launchManagedBrowser(puppeteer, {
+        ...options,
+        ...context.noListen ? oneProcessOverPipe(options) : {},
+        signal: context.signal
+      });
+      try {
+        context.onBrowser?.(browser);
+      } catch (error) {
+        return rethrowAfterBrowserCleanup(browser, error);
+      }
+      return browser;
+    },
+    close: closeManagedBrowser
+  });
+}
+async function launchManagedBrowser(puppeteer, options) {
+  const sandboxed = isOneProcessOverPipe(options) || inAgentSandbox();
+  try {
+    return await launchOwnedBrowser(puppeteer, sandboxed ? oneProcessOverPipe(options) : options);
+  } catch (error) {
+    const unnamedSeatbelt = !sandboxed && (machServiceDenied(normalizeErrorMessage(error)) || pipeLaunchClosedOnMac(error));
+    if (!unnamedSeatbelt) throw withRemediation(error);
+    return launchOwnedBrowser(puppeteer, oneProcessOverPipe(options)).catch(
+      (retryError) => {
+        throw withRemediation(retryError);
+      }
+    );
+  }
+}
+function withRemediation(error) {
+  const remediation = sandboxDeniedRemediation(normalizeErrorMessage(error));
+  return remediation ? new Error(remediation, { cause: error }) : error;
+}
+async function launchOwnedBrowser(puppeteer, options) {
+  if (shutdown) throw new Error("The CLI is stopping; no browser can start.");
+  ownSignals();
+  const abort = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
+  const launchedAt = Date.now();
+  const launch = untilLaunchOrAbort(
+    puppeteer.launch({
+      ...options,
+      args: withHyperframesBrowserMarker(options.args),
+      pipe: true,
+      signal,
+      handleSIGINT: false,
+      handleSIGTERM: false
+    }),
+    signal
+  );
+  const limit = options.timeout ?? LAUNCH_TIMEOUT_MS;
+  const timer = limit > 0 ? setTimeout(
+    () => abort.abort(new Error(`The browser did not finish starting within ${limit} ms.`)),
+    limit
+  ) : void 0;
+  pending.set(launch, abort);
+  try {
+    const browser = await launch;
+    const child = browser.process();
+    if (!child) throw new Error("A launched browser has no owned process.");
+    browsers.add(browser);
+    const watchdog = watchChromeTree(child, launchedAt);
+    if (watchdog) watchdogs.set(browser, watchdog);
+    child.once("exit", () => browsers.delete(browser));
+    return browser;
+  } finally {
+    clearTimeout(timer);
+    pending.delete(launch);
+  }
+}
+function untilLaunchOrAbort(launch, signal) {
+  const aborted = new Promise((_, reject) => {
+    if (signal.aborted) reject(signal.reason);
+    signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+  });
+  void launch.then((late) => signal.aborted ? closeManagedBrowser(late) : void 0).catch(() => void 0);
+  return Promise.race([launch, aborted]);
+}
+async function closeManagedBrowsers() {
+  for (const abort of pending.values()) abort.abort();
+  await Promise.allSettled(pending.keys());
+  const results = await Promise.allSettled([...browsers].map(closeManagedBrowser));
+  results.push(...await Promise.allSettled([...sessionCleanups].map((cleanup) => cleanup())));
+  const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (errors.length) throw new AggregateError(errors, "Browser session shutdown failed.");
+}
+function closeManagedBrowser(browser) {
+  const existing = closing.get(browser);
+  if (existing) return existing;
+  const close = closeBrowser(browser);
+  closing.set(browser, close);
+  return close;
+}
+async function rethrowAfterBrowserCleanup(browser, error) {
+  if (browser) {
+    try {
+      await closeManagedBrowser(browser);
+    } catch (cleanupError) {
+      throw new BrowserCleanupError(
+        [error, cleanupError],
+        `${normalizeErrorMessage(error)}; browser cleanup failed: ${normalizeErrorMessage(cleanupError)}`
+      );
+    }
+  }
+  throw error;
+}
+async function closeBrowser(browser) {
+  let clean = false;
+  try {
+    clean = await closedWithoutKill(browser);
+  } finally {
+    watchdogs.get(browser)?.release(clean);
+  }
+}
+async function closedWithoutKill(browser) {
+  const child = browser.process();
+  if (!child) throw new Error("A managed browser lost its owned process.");
+  if (child.exitCode !== null || child.signalCode !== null) return false;
+  const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+  let timer;
+  let poll;
+  const grace = new Promise((resolve) => {
+    timer = setTimeout(resolve, CLOSE_GRACE_MS);
+  });
+  try {
+    await Promise.race([
+      browser.close().catch((error) => console.warn("Browser close failed:", error)),
+      grace
+    ]);
+    const clean = child.exitCode !== null || child.signalCode !== null;
+    if (!clean) child.kill("SIGKILL");
+    clearTimeout(timer);
+    const exitLimit = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error("Browser process did not exit after forced shutdown.")),
+        CLOSE_GRACE_MS
+      );
+    });
+    const goneBeforeExitEvent = new Promise((resolve) => {
+      poll = setInterval(() => {
+        if (child.pid === void 0 || !processIsAlive(child.pid)) resolve();
+      }, EXIT_POLL_MS);
+    });
+    await Promise.race([exited, goneBeforeExitEvent, exitLimit]);
+    return clean;
+  } finally {
+    clearTimeout(timer);
+    clearInterval(poll);
+  }
+}
+
+// src/capture/captureCompositionFrame.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/capture/captureTimeout.ts
+var StageBudgetTimeoutError = class extends Error {
+  budgetMs;
+  constructor(label, budgetMs) {
+    super(`stage budget exceeded while ${label} (${budgetMs}ms)`);
+    this.name = "StageBudgetTimeoutError";
+    this.budgetMs = budgetMs;
+  }
+};
+async function withRemainingBudget(work, remainingMs, label, timeoutError = () => new StageBudgetTimeoutError(label, Math.max(0, remainingMs))) {
+  if (!(remainingMs > 0)) {
+    throw timeoutError();
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+          reject(timeoutError());
+        }, remainingMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  }
+}
+
+// src/capture/navigateForCapture.ts
+var PUPPETEER_LAUNCH_DEFAULT_TIMEOUT_MS = 3e4;
+var PAGE_LOAD_BLOCKING_TYPES = /* @__PURE__ */ new Set(["Document", "Script", "Stylesheet"]);
+var NAMED_BLOCKING_REQUESTS = 3;
+var SENT_OR_ANSWERED_WITHOUT_NETWORK = [
+  "Network.requestWillBeSentExtraInfo",
+  "Network.responseReceived"
+];
+async function gotoWhenSent(page, url, timeoutMs, coldChromeFirstRequestTimeoutMs = PUPPETEER_LAUNCH_DEFAULT_TIMEOUT_MS) {
+  const { TimeoutError } = await import("puppeteer-core");
+  const cdp = await page.createCDPSession();
+  try {
+    await cdp.send("Network.enable");
+    const sent = documentRequestSent(cdp);
+    const unfinished = unfinishedPageLoadRequests(cdp);
+    const navigation = page.goto(url, { waitUntil: "domcontentloaded", timeout: 0 });
+    const navigationAwaitedBelow = navigation.catch(() => void 0);
+    await withRemainingBudget(
+      Promise.race([sent, navigationAwaitedBelow]),
+      coldChromeFirstRequestTimeoutMs,
+      "sending the page request",
+      () => new TimeoutError(
+        `Navigation timeout: Chrome did not send the page request within ${coldChromeFirstRequestTimeoutMs} ms`
+      )
+    );
+    return await withRemainingBudget(
+      navigation,
+      timeoutMs,
+      "loading the page",
+      () => new TimeoutError(pageLoadTimeoutMessage(timeoutMs, url, unfinished()))
+    );
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+function documentRequestSent(cdp) {
+  const documents = /* @__PURE__ */ new Set();
+  const sent = /* @__PURE__ */ new Set();
+  return new Promise((resolve) => {
+    const settle = (requestId) => {
+      if (documents.has(requestId) && sent.has(requestId)) resolve();
+    };
+    cdp.on("Network.requestWillBeSent", ({ requestId, type }) => {
+      if (type === "Document") documents.add(requestId);
+      settle(requestId);
+    });
+    for (const event of SENT_OR_ANSWERED_WITHOUT_NETWORK) {
+      cdp.on(event, ({ requestId }) => {
+        sent.add(requestId);
+        settle(requestId);
+      });
+    }
+  });
+}
+function unfinishedPageLoadRequests(cdp) {
+  const unfinished = /* @__PURE__ */ new Map();
+  cdp.on("Network.requestWillBeSent", ({ requestId, request, type }) => {
+    if (type && PAGE_LOAD_BLOCKING_TYPES.has(type)) unfinished.set(requestId, request.url);
+  });
+  for (const event of ["Network.loadingFinished", "Network.loadingFailed"]) {
+    cdp.on(event, ({ requestId }) => unfinished.delete(requestId));
+  }
+  return () => [...unfinished.values()];
+}
+function urlWithoutSecrets(raw) {
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return `${url.protocol}\u2026`;
+    return `${url.origin}${url.pathname}${url.search ? "?\u2026" : ""}`;
+  } catch {
+    return "(unreadable URL)";
+  }
+}
+function originOf(raw) {
+  try {
+    return new URL(raw).origin;
+  } catch {
+    return null;
+  }
+}
+function pageLoadTimeoutMessage(timeoutMs, pageUrl, waitingOn) {
+  const exceeded = `Navigation timeout of ${timeoutMs} ms exceeded`;
+  if (waitingOn.length === 0) return exceeded;
+  const named = waitingOn.slice(0, NAMED_BLOCKING_REQUESTS).map(urlWithoutSecrets).join(", ");
+  const unnamed = waitingOn.length - NAMED_BLOCKING_REQUESTS;
+  const more = unnamed > 0 ? ` and ${unnamed} more` : "";
+  const pageOrigin = new URL(pageUrl).origin;
+  const fromAnotherServer = waitingOn.some((request) => originOf(request) !== pageOrigin);
+  const advice = fromAnotherServer ? " A <script> or stylesheet from another server holds the page until it arrives; serve it from the project instead." : "";
+  return `${exceeded} while the page was still loading ${named}${more}.${advice}`;
+}
+
+// src/capture/captureCompositionFrame.ts
+var SHADER_TRANSITIONS_TIMEOUT_MS = 9e4;
+var CAPTURE_SETTLE_MS = 1500;
+var NETWORK_IDLE_MS = 100;
+var PREFERRED_SEEK_TARGET_WAIT_MS = 500;
+var DEFAULT_POST_SEEK_FONT_WAIT_MS = 500;
+var AUDIT_SEEK_OPTIONS = {
+  fallbackToBridgeAndTimelines: true,
+  animationFrameSettle: "double",
+  waitForFontsMs: 500
+};
+var SCREENSHOT_IMAGE_WAIT_MS = 3e3;
+var SCREENSHOT_SEEK_OPTIONS = {
+  ...AUDIT_SEEK_OPTIONS,
+  waitForImagesMs: SCREENSHOT_IMAGE_WAIT_MS
+};
+var ALL_IMAGES_SETTLED = { pending: [], failed: [] };
+var DENSE_GEOMETRY_SEEK_OPTIONS = {
+  ...AUDIT_SEEK_OPTIONS,
+  animationFrameSettle: "none",
+  waitForFontsMs: 0,
+  settleMs: 0,
+  waitForVideoFrames: false,
+  skipWebglDraws: true
+};
+function launchKey(html, noListen, options) {
+  const viewport = resolveCompositionViewportFromHtml(html);
+  const gpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
+  return JSON.stringify([viewport, compositionRequiresWebGpu(html), noListen, gpuMode]);
+}
+function prelaunchCompositionBrowser(html, browserGpuMode) {
+  const abort = new AbortController();
+  const options = { browserGpuMode, signal: abort.signal };
+  const key = launchKey(html, false, options);
+  const launched = launchCompositionBrowser(html, false, options).catch(() => void 0);
+  let taken = false;
+  const discard = async () => {
+    if (taken) return;
+    taken = true;
+    abort.abort();
+    await (await launched)?.browser.close().catch(() => void 0);
+  };
+  return {
+    launched,
+    take: async (wanted) => {
+      if (wanted !== key) return discard().then(() => void 0);
+      taken = true;
+      const result = await launched;
+      if (result?.browser.connected) return result;
+      await result?.browser.close().catch(() => void 0);
+      return void 0;
+    },
+    discard
+  };
+}
+function resolveCliChromeGpuMode(envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
+  return resolveLocalBrowserGpuMode(void 0, envMode);
+}
+function compositionRuntimeReadyInBrowser() {
+  return Boolean(Reflect.get(window, "__renderReady")) || typeof Reflect.get(window, "__hfStartupError") === "string";
+}
+function shaderTransitionsReadyInBrowser() {
+  function shaderTransitionRegistryReady() {
+    const hf = Reflect.get(window, "__hf");
+    if (typeof hf !== "object" || hf === null) return void 0;
+    const shaderTransitions = Reflect.get(hf, "shaderTransitions");
+    if (typeof shaderTransitions !== "object" || shaderTransitions === null) return void 0;
+    for (const key of Object.keys(shaderTransitions)) {
+      const entry = Reflect.get(shaderTransitions, key);
+      if (typeof entry !== "object" || entry === null) return false;
+      if (Reflect.get(entry, "ready") !== true) return false;
+    }
+    return true;
+  }
+  function shaderLoadingOverlayReady() {
+    const overlay = document.querySelector("[data-hyper-shader-loading]");
+    if (!overlay) return true;
+    if (!(overlay instanceof HTMLElement)) return true;
+    return window.getComputedStyle(overlay).display === "none";
+  }
+  return shaderTransitionRegistryReady() ?? shaderLoadingOverlayReady();
+}
+async function waitForRuntimeReady(page, timeoutMs) {
+  const settled = await page.waitForFunction(compositionRuntimeReadyInBrowser, { timeout: timeoutMs }).then(() => true).catch(() => false);
+  const startupError = await page.evaluate(() => Reflect.get(window, "__hfStartupError")).catch(() => void 0);
+  if (typeof startupError === "string") throw new Error(startupError);
+  return settled;
+}
+async function waitForCompositionSettle(page, options) {
+  const runtimeReady = await waitForRuntimeReady(page, options.renderReadyTimeoutMs);
+  if (!runtimeReady) {
+    console.warn(
+      `
+   ${c.warn("\u26A0")} Runtime did not become render-ready within ${options.renderReadyTimeoutMs}ms \u2014 ${options.renderReadyWarningSuffix}`
+    );
+  }
+  await page.waitForFunction(shaderTransitionsReadyInBrowser, {
+    timeout: SHADER_TRANSITIONS_TIMEOUT_MS
+  }).catch(() => {
+    console.warn(`   ${c.warn("\u26A0")} Shader transitions did not finish pre-rendering`);
+  });
+  await waitForLateSubresources(page, options.lateSubresourceTimeoutMs ?? CAPTURE_SETTLE_MS);
+  const { resolveConfig, waitForImagesReady } = await import("./src-Z5PGEMXB.js");
+  const imageTimeoutMs = resolveConfig().playerReadyTimeout;
+  await waitForImagesReady(
+    page,
+    imageTimeoutMs,
+    (sources) => console.warn(
+      `   ${c.warn("\u26A0")} Some images did not load within ${imageTimeoutMs}ms: ${sources}. They may show blank.`
+    )
+  );
+  return runtimeReady;
+}
+async function waitForLateSubresources(page, timeoutMs) {
+  let cap;
+  const deadline = Date.now() + timeoutMs;
+  const ready = (async () => {
+    await page.waitForFunction(() => document.readyState === "complete", {
+      timeout: timeoutMs
+    });
+    await page.waitForNetworkIdle({
+      idleTime: NETWORK_IDLE_MS,
+      timeout: Math.max(1, deadline - Date.now())
+    });
+    await page.evaluate(async () => {
+      await Promise.all(Array.from(document.images, (image) => image.decode().catch(() => {
+      })));
+      await document.fonts.ready;
+    });
+  })();
+  try {
+    await Promise.race([
+      ready,
+      new Promise((resolveCap) => {
+        cap = setTimeout(resolveCap, timeoutMs);
+      })
+    ]);
+  } catch {
+    await new Promise((resolveCap) => setTimeout(resolveCap, Math.max(0, deadline - Date.now())));
+  } finally {
+    clearTimeout(cap);
+    ready.catch(() => {
+    });
+  }
+}
+async function installPageFunctionGuard(page) {
+  await page.evaluateOnNewDocument("self.__name = self.__name || ((fn) => fn);");
+}
+async function openSettledCompositionPage(html, url, options) {
+  const viewport = resolveCompositionViewportFromHtml(html);
+  const requiresWebGpu = compositionRequiresWebGpu(html);
+  const answer = (await import("./staticProjectServer-DFVZOUGI.js")).inProcessAnswer(url);
+  const noListen = answer !== void 0;
+  let chromeBrowser;
+  try {
+    const launched = await options.prelaunched?.take(launchKey(html, noListen, options)) ?? await launchCompositionBrowser(html, noListen, options);
+    chromeBrowser = launched.browser;
+    const softwareWebGpu = launched.softwareWebGpu;
+    options.onBrowser?.(chromeBrowser);
+    options.onBrowserReady?.();
+    const page = await chromeBrowser.newPage();
+    await installPageFunctionGuard(page);
+    const { installMediaRenderIdBridge } = await import("./src-Z5PGEMXB.js");
+    await installMediaRenderIdBridge(page);
+    await page.setViewport(viewport);
+    if (answer) await answerPageInProcess(page, url, answer);
+    await options.beforeNavigate?.(page);
+    await gotoWhenSent(page, url, pageNavigationTimeoutMs(options.navigationTimeoutMs));
+    await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
+    options.onLoaded?.();
+    const renderReadyTimedOut = !await waitForCompositionSettle(page, options);
+    return { browser: chromeBrowser, page, renderReadyTimedOut };
+  } catch (err) {
+    return rethrowAfterBrowserCleanup(chromeBrowser, err);
+  }
+}
+async function launchCompositionBrowser(html, noListen, options) {
+  const viewport = resolveCompositionViewportFromHtml(html);
+  const { ensureBrowser, findSystemBrowser } = await import("./manager-CD6LJ7ZN.js");
+  const browser = await ensureBrowser({ signal: options.signal });
+  const puppeteer = await import("puppeteer-core");
+  const { buildChromeArgs } = await import("./src-Z5PGEMXB.js");
+  const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
+  const requiresWebGpu = compositionRequiresWebGpu(html);
+  let softwareWebGpu = false;
+  const launch = async (executablePath) => {
+    options.signal?.throwIfAborted();
+    const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, executablePath, {
+      signal: options.signal,
+      onBrowser: options.onBrowser,
+      noListen
+    });
+    options.signal?.throwIfAborted();
+    const webGpu = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
+    softwareWebGpu = webGpu.softwareWebGpu;
+    const args = buildChromeArgs(
+      { ...viewport, captureMode: "screenshot", requiresWebGpu },
+      webGpu.gpuConfig
+    );
+    return launchManagedBrowser(puppeteer.default, {
+      headless: true,
+      signal: options.signal,
+      executablePath,
+      ...noListen ? oneProcessOverPipe({ args }) : { args }
+    });
+  };
+  let chromeBrowser;
+  try {
+    chromeBrowser = await launch(browser.executablePath);
+  } catch (launchError) {
+    const message = normalizeErrorMessage(launchError);
+    const remediation = windowsChromeCrashRemediation(message);
+    if (!remediation) throw launchError;
+    const systemBrowser = browser.source === "cache" || browser.source === "download" ? findSystemBrowser() : void 0;
+    if (!systemBrowser || systemBrowser.executablePath === browser.executablePath) {
+      throw new Error(`${message}
+
+${remediation}`, { cause: launchError });
+    }
+    console.warn(
+      `[hyperframes] Managed chrome-headless-shell crashed at launch; retrying once with system Chrome at ${systemBrowser.executablePath}.`
+    );
+    try {
+      chromeBrowser = await launch(systemBrowser.executablePath);
+    } catch (fallbackError) {
+      throw new Error(
+        `System Chrome fallback also failed: ${normalizeErrorMessage(fallbackError)}
+
+${remediation}`,
+        { cause: fallbackError }
+      );
+    }
+  }
+  return { browser: chromeBrowser, softwareWebGpu };
+}
+function seekInPage(t, fallbackToBridgeAndTimelines, exactTime, skipDraws) {
+  const getProperty = (target, key) => {
+    if ((typeof target !== "object" || target === null) && typeof target !== "function") {
+      return void 0;
+    }
+    return Reflect.get(target, key);
+  };
+  const call = (fn, receiver, args) => {
+    if (typeof fn !== "function") return false;
+    Reflect.apply(fn, receiver, args);
+    return true;
+  };
+  const player = Reflect.get(window, "__player");
+  if (!player && !fallbackToBridgeAndTimelines) return;
+  const safe = Math.max(0, Number(t) || 0);
+  const renderSeek = getProperty(player, "renderSeek");
+  const playerSeek = getProperty(player, "seek");
+  const hf = Reflect.get(window, "__hf");
+  const bridgeSeek = getProperty(hf, "seek");
+  const gsap = Reflect.get(window, "gsap");
+  const ticker = getProperty(gsap, "ticker");
+  const seekTo = (time) => {
+    if (call(renderSeek, player, exactTime ? [time, { exact: true }] : [time])) {
+    } else if (fallbackToBridgeAndTimelines && call(bridgeSeek, hf, [time])) {
+    } else if (call(playerSeek, player, [time])) {
+    } else if (fallbackToBridgeAndTimelines) {
+      const timelines = Reflect.get(window, "__timelines");
+      if (typeof timelines === "object" && timelines !== null) {
+        for (const key of Object.keys(timelines)) {
+          const timeline = Reflect.get(timelines, key);
+          call(getProperty(timeline, "pause"), timeline, []);
+          call(getProperty(timeline, "seek"), timeline, [time]);
+        }
+      }
+    }
+    call(getProperty(ticker, "tick"), ticker, []);
+  };
+  const gateSlot = /* @__PURE__ */ Symbol.for("hyperframes.webglDrawGate");
+  let gate = Reflect.get(window, gateSlot);
+  if (skipDraws && !gate) {
+    const installed = { skip: false, skipped: false };
+    for (const name of ["WebGLRenderingContext", "WebGL2RenderingContext"]) {
+      const proto = getProperty(Reflect.get(window, name), "prototype");
+      if (!proto) continue;
+      for (const method of [
+        "clear",
+        "drawArrays",
+        "drawElements",
+        "drawArraysInstanced",
+        "drawElementsInstanced",
+        "drawRangeElements",
+        "blitFramebuffer"
+      ]) {
+        const draw = getProperty(proto, method);
+        if (typeof draw !== "function") continue;
+        Reflect.set(proto, method, function(...args) {
+          if (!installed.skip) return Reflect.apply(draw, this, args);
+          installed.skipped = true;
+          return void 0;
+        });
+      }
+    }
+    Reflect.set(window, gateSlot, installed);
+    gate = installed;
+  }
+  const seekWithoutDraws = (time) => {
+    if (!gate) return seekTo(time);
+    gate.skip = true;
+    try {
+      seekTo(time);
+    } finally {
+      gate.skip = false;
+    }
+  };
+  if (skipDraws) {
+    seekWithoutDraws(safe);
+    return;
+  }
+  if (gate?.skipped) {
+    seekWithoutDraws(safe >= 1e-3 ? safe - 1e-3 : safe + 1e-3);
+    gate.skipped = false;
+  }
+  seekTo(safe);
+}
+async function seekCompositionTimeline(page, timeSeconds, options = {}) {
+  await seekCompositionTimelineOnly(page, timeSeconds, options);
+  await settleCompositionSeek(page, options);
+}
+async function seekCompositionTimelineOnly(page, timeSeconds, options = {}) {
+  if (options.waitForPreferredSeekTargetMs !== void 0) {
+    await waitForPreferredSeekTarget(page, options.waitForPreferredSeekTargetMs);
+  }
+  await page.evaluate(
+    seekInPage,
+    timeSeconds,
+    options.fallbackToBridgeAndTimelines === true,
+    options.exactTime === true,
+    options.skipWebglDraws === true
+  );
+}
+async function settleCompositionSeek(page, options = {}) {
+  await page.evaluate(
+    async (barrier) => {
+      const waitForCompletion = Reflect.get(window, "__hfWaitForSeekCompletion");
+      if (typeof waitForCompletion === "function") {
+        await Reflect.apply(waitForCompletion, window, [barrier]);
+      }
+    },
+    { videoFrames: options.waitForVideoFrames !== false }
+  );
+  const animationFrameSettle = options.animationFrameSettle ?? "race";
+  const waitForFontsMs = options.waitForFontsMs ?? DEFAULT_POST_SEEK_FONT_WAIT_MS;
+  if (animationFrameSettle === "race") {
+    await page.evaluate(`new Promise(function(r) {
+      var settled = false;
+      function finish() { if (settled) return; settled = true; r(); }
+      window.setTimeout(finish, 100);
+      requestAnimationFrame(function() { requestAnimationFrame(finish); });
+    })`);
+  } else if (animationFrameSettle === "double" && !(waitForFontsMs > 0)) {
+    await page.evaluate(
+      () => new Promise(
+        (resolveFrame) => requestAnimationFrame(() => requestAnimationFrame(() => resolveFrame()))
+      )
+    );
+  }
+  if (waitForFontsMs > 0) {
+    await waitForCompositionFonts(page, waitForFontsMs, animationFrameSettle === "double" ? 2 : 1);
+  }
+  const images = options.waitForImagesMs ? await waitForCompositionImages(page, options.waitForImagesMs) : ALL_IMAGES_SETTLED;
+  if (options.settleMs !== void 0) {
+    const settleMs = Math.max(0, options.settleMs);
+    await new Promise((resolveSettle) => setTimeout(resolveSettle, settleMs));
+  }
+  return images;
+}
+async function waitForPreferredSeekTarget(page, timeoutMs = PREFERRED_SEEK_TARGET_WAIT_MS) {
+  if (!page.waitForFunction) return;
+  try {
+    await page.waitForFunction(
+      () => {
+        const player = Reflect.get(window, "__player");
+        const hf = Reflect.get(window, "__hf");
+        const renderSeek = typeof player === "object" && player !== null ? Reflect.get(player, "renderSeek") : void 0;
+        const bridgeSeek = typeof hf === "object" && hf !== null ? Reflect.get(hf, "seek") : void 0;
+        return typeof renderSeek === "function" || typeof bridgeSeek === "function";
+      },
+      { timeout: timeoutMs }
+    );
+  } catch {
+  }
+}
+async function waitForCompositionImages(page, timeoutMs) {
+  const unsettled = await page.evaluate(
+    // fallow-ignore-next-line complexity
+    async (ms) => {
+      const layers = /* @__PURE__ */ new Map();
+      const add = (src, image) => {
+        if (src && !layers.has(src)) layers.set(src, image ?? Object.assign(new Image(), { src }));
+      };
+      const absolute = (href) => new URL(href, document.baseURI).href;
+      for (const element of document.querySelectorAll("*")) {
+        const style = getComputedStyle(element);
+        if (style.display === "none" || style.visibility === "hidden") continue;
+        if (element instanceof HTMLImageElement) add(element.currentSrc || element.src, element);
+        if (element instanceof SVGImageElement && element.href.baseVal) {
+          add(absolute(element.href.baseVal));
+        }
+        for (const match of style.backgroundImage.matchAll(
+          /url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*))\s*\)/g
+        )) {
+          const href = match[1] ?? match[2] ?? match[3];
+          if (href) add(absolute(href));
+        }
+      }
+      const state = /* @__PURE__ */ new Map();
+      const decodes = [...layers].map(([src, image]) => {
+        state.set(src, "pending");
+        return image.decode().then(
+          () => void state.set(src, "ready"),
+          () => void state.set(src, "failed")
+        );
+      });
+      let timer;
+      await Promise.race([
+        Promise.all(decodes),
+        new Promise((resolveWait) => {
+          timer = setTimeout(resolveWait, ms);
+        })
+      ]);
+      clearTimeout(timer);
+      const named = (want) => [...state].filter(([, value]) => value === want).map(([src]) => src.startsWith("data:") ? `${src.slice(0, 40)}...` : src);
+      return { pending: named("pending"), failed: named("failed") };
+    },
+    timeoutMs
+  );
+  return unsettled;
+}
+async function waitForCompositionFonts(page, timeoutMs, frames = 1) {
+  await page.evaluate(
+    ({ ms, frames: count }) => {
+      const fonts = Reflect.get(document, "fonts");
+      void document.body?.offsetHeight;
+      const afterFrames = (left, then) => {
+        requestAnimationFrame(() => left > 1 ? afterFrames(left - 1, then) : then());
+      };
+      return new Promise((resolveWait) => {
+        const deadline = setTimeout(resolveWait, ms);
+        afterFrames(count, () => {
+          const status = fonts ? Reflect.get(fonts, "status") : void 0;
+          const ready = fonts ? Reflect.get(fonts, "ready") : void 0;
+          if (status !== "loading" || !ready) {
+            clearTimeout(deadline);
+            resolveWait();
+            return;
+          }
+          Promise.resolve(ready).then(() => {
+            clearTimeout(deadline);
+            resolveWait();
+          });
+        });
+      });
+    },
+    { ms: timeoutMs, frames }
+  ).catch(() => {
+  });
+}
+var ZOOM_REGION_PATTERN = /^-?\d+(?:\.\d+)?(?:,-?\d+(?:\.\d+)?){3}$/;
+var DEFAULT_ZOOM_PADDING_PX = 24;
+var DEFAULT_ZOOM_SCALE = 3;
+function parseZoomTarget(value) {
+  const trimmed = value.trim();
+  if (ZOOM_REGION_PATTERN.test(trimmed)) {
+    const [x, y, width, height] = trimmed.split(",").map(Number);
+    return { kind: "region", region: { x, y, width, height } };
+  }
+  return { kind: "selector", selector: trimmed };
+}
+function clampCropRegion(region, canvas) {
+  const x = Math.max(0, Math.min(region.x, canvas.width));
+  const y = Math.max(0, Math.min(region.y, canvas.height));
+  const x2 = Math.max(x + 1, Math.min(region.x + region.width, canvas.width));
+  const y2 = Math.max(y + 1, Math.min(region.y + region.height, canvas.height));
+  return { x, y, width: x2 - x, height: y2 - y };
+}
+function padCropRegion(region, canvas, paddingPx) {
+  return clampCropRegion(
+    {
+      x: region.x - paddingPx,
+      y: region.y - paddingPx,
+      width: region.width + paddingPx * 2,
+      height: region.height + paddingPx * 2
+    },
+    canvas
+  );
+}
+var MIN_CROP_REGION_PX = 8;
+async function resolveCropRegion(page, target, canvas, paddingPx = DEFAULT_ZOOM_PADDING_PX) {
+  if (target.kind === "region") return clampCropRegion(target.region, canvas);
+  const bbox = await page.evaluate((selector) => {
+    const element = document.querySelector(selector);
+    if (!element) return null;
+    const rect = element.getBoundingClientRect();
+    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+  }, target.selector);
+  if (!bbox) throw new Error(`--zoom selector matched no element: ${target.selector}`);
+  const region = padCropRegion(bbox, canvas, paddingPx);
+  if (region.width < MIN_CROP_REGION_PX || region.height < MIN_CROP_REGION_PX) return null;
+  return region;
+}
+async function captureRegionCrop(page, region, scale) {
+  const original = page.viewport();
+  if (original) await page.setViewport({ ...original, deviceScaleFactor: scale });
+  try {
+    const shot = await page.screenshot({ clip: region, type: "png", omitBackground: true });
+    return Buffer.isBuffer(shot) ? shot : Buffer.from(shot);
+  } finally {
+    if (original) await page.setViewport(original);
+  }
+}
+async function runFfmpegOnce(ffmpegPath, args, timeoutMs) {
+  return await new Promise((resolvePromise) => {
+    const ff = spawn2(ffmpegPath, args, { windowsHide: true });
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      ff.kill("SIGTERM");
+    }, timeoutMs);
+    ff.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    ff.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ code, stderr, timedOut });
+    });
+    ff.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ code: null, stderr: "ffmpeg spawn failed", timedOut });
+    });
+  });
+}
+async function answerPageInProcess(page, url, answer) {
+  const origin = new URL(url).origin;
+  await page.setRequestInterception(true);
+  page.on("request", (request) => {
+    if (request.isInterceptResolutionHandled()) return;
+    const target = new URL(request.url());
+    if (target.origin !== origin) return void request.continue().catch(() => {
+    });
+    answer({
+      method: request.method(),
+      path: target.pathname + target.search,
+      headers: request.headers()
+    }).then((response) => request.respond(response)).catch(() => request.abort("failed").catch(() => {
+    }));
+  });
+}
+
+export {
+  BrowserCleanupError,
+  resolveManagedGpuMode,
+  launchManagedBrowser,
+  closeManagedBrowser,
+  withRemainingBudget,
+  gotoWhenSent,
+  AUDIT_SEEK_OPTIONS,
+  SCREENSHOT_IMAGE_WAIT_MS,
+  SCREENSHOT_SEEK_OPTIONS,
+  DENSE_GEOMETRY_SEEK_OPTIONS,
+  prelaunchCompositionBrowser,
+  resolveCliChromeGpuMode,
+  waitForRuntimeReady,
+  installPageFunctionGuard,
+  openSettledCompositionPage,
+  seekInPage,
+  seekCompositionTimeline,
+  seekCompositionTimelineOnly,
+  settleCompositionSeek,
+  waitForPreferredSeekTarget,
+  waitForCompositionFonts,
+  DEFAULT_ZOOM_PADDING_PX,
+  DEFAULT_ZOOM_SCALE,
+  parseZoomTarget,
+  clampCropRegion,
+  padCropRegion,
+  resolveCropRegion,
+  captureRegionCrop,
+  runFfmpegOnce
+};