hyperframes 0.8.143 → 0.8.145

package/dist/{chunk-LAOCA3MQ.js → chunk-A4Q7W4LV.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   runRenderSetupWorker,
   terminateProcessTree
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 
 // src/utils/orphanCleanup.ts
 import { execFileSync } from "child_process";
@@ -62,17 +62,19 @@ function processIdentity(pid) {
     return null;
   }
 }
+var holdsReusedPid = (parent, child) => parent.startedAt !== void 0 && child?.startedAt !== void 0 && parent.startedAt > child.startedAt;
 function recordsToAncestors(pid, records) {
   const byPid = new Map(records.map((record) => [record.pid, record]));
   const ancestors = [];
   const visited = /* @__PURE__ */ new Set([pid]);
   let current = pid;
   for (let depth = 0; depth < 64; depth++) {
-    const parent = byPid.get(current)?.parentPid;
+    const child = byPid.get(current);
+    const parent = child?.parentPid;
     if (parent === void 0 || parent <= 1 || visited.has(parent)) break;
     visited.add(parent);
     const ancestor = byPid.get(parent);
-    if (!ancestor) break;
+    if (!ancestor || holdsReusedPid(ancestor, child)) break;
     ancestors.push({ pid: ancestor.pid, identity: ancestor.identity });
     current = parent;
   }
@@ -92,11 +94,14 @@ function processAncestorSnapshot(pid) {
         ],
         { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "ignore"], windowsHide: true }
       );
-      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(([processId, parentProcessId, creationDate]) => ({
-        pid: Number(processId),
-        parentPid: Number(parentProcessId),
-        identity: creationDate ? `windows:${creationDate}` : ""
-      })).filter(
+      const records2 = output2.split(/\r?\n/).map((line) => line.trim().split(/\s+/)).map(
+        ([processId, parentProcessId, creationDate]) => ({
+          pid: Number(processId),
+          parentPid: Number(parentProcessId),
+          identity: creationDate ? `windows:${creationDate}` : "",
+          startedAt: creationDate && /^\d+$/.test(creationDate) ? BigInt(creationDate) : void 0
+        })
+      ).filter(
         (record) => Number.isInteger(record.pid) && record.pid > 0 && Number.isInteger(record.parentPid) && record.parentPid > 0 && record.identity !== ""
       );
       return recordsToAncestors(pid, records2);

package/dist/{chunk-4PFZPP2N.js → chunk-A6S35NYA.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   runRenderSetupWorker
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 import {
   chromeMajorCeiling,
   exceedsChromeCeiling
@@ -30,6 +30,7 @@ import {
   writeFileSync
 } from "fs";
 import { homedir } from "os";
+import { debuglog } from "util";
 import { basename, dirname, join, relative } from "path";
 async function loadPuppeteerBrowsers() {
   try {
@@ -234,7 +235,7 @@ async function findFromHyperframesCache() {
   const match = installed.find(
     (b) => b.browser === Browser.CHROMEHEADLESSSHELL && b.buildId === managedChromeVersion() && b.platform === hostPlatform
   );
-  if (match && existsSync(match.executablePath)) {
+  if (match && isUsableExecutable(match.executablePath)) {
     return { result: { executablePath: match.executablePath, source: "cache" } };
   }
   if (match) {
@@ -301,7 +302,7 @@ function findFromPuppeteerCache() {
   for (const version of versions) {
     if (exceedsChromeCeiling(version, ceiling)) continue;
     const binary = join(PUPPETEER_CACHE_DIR, version, ...executable);
-    if (existsSync(binary)) {
+    if (isUsableExecutable(binary)) {
       return { executablePath: binary, source: "cache" };
     }
   }
@@ -345,14 +346,14 @@ async function findBrowser() {
   if (fromCache.result) return fromCache.result;
   if (fromCache.staleHyperframesCachePath) {
     console.warn(
-      `[browser] Cached binary missing at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
+      `[browser] Cached binary unusable (missing, empty or not a file) at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
     );
     try {
       return await withInstallLock(() => downloadBrowser());
     } catch (err) {
       const cause = normalizeErrorMessage(err);
       throw new Error(
-        `Cached Chrome binary was missing at ${fromCache.staleHyperframesCachePath}, and re-download failed: ${cause}
+        `Cached Chrome binary was unusable at ${fromCache.staleHyperframesCachePath}, and re-download failed: ${cause}
 Run \`hyperframes browser ensure --force\` to re-download.`
       );
     }
@@ -414,7 +415,7 @@ async function ensureBrowserInCurrentProcess(options) {
     if (fromCache.result) return fromCache.result;
     if (fromCache.staleHyperframesCachePath) {
       console.warn(
-        `[browser] Cached binary missing at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
+        `[browser] Cached binary unusable (missing, empty or not a file) at ${fromCache.staleHyperframesCachePath} \u2014 re-downloading...`
       );
       return withInstallLock(() => downloadBrowser(options));
     }
@@ -478,10 +479,11 @@ function browserPathHintForPlatform() {
   }
   return "/usr/bin/google-chrome";
 }
-function wrapDownloadFailureWithBrowserPathHint(cause) {
+function wrapDownloadFailureWithBrowserPathHint(cause, unzipLog) {
   const original = normalizeErrorMessage(cause);
+  const unzipErrors = unzipLog.length > 0 ? ` Unzip errors: ${unzipLog.join("; ")}` : "";
   const example = browserPathHintForPlatform();
-  const message = `Failed to download chrome-headless-shell ${managedChromeVersion()}: ${original}
+  const message = `Failed to install chrome-headless-shell ${managedChromeVersion()}: ${original}${unzipErrors}
 
 Point hyperframes at an already-installed Chrome/Chromium instead:
 
@@ -502,13 +504,27 @@ async function downloadBrowser(options) {
   removeInstallLeftovers();
   const stagingDir = join(CACHE_ROOT_DIR, `${STAGING_PREFIX}${randomUUID()}`);
   const clearStaging = () => rmSync(stagingDir, { recursive: true, force: true });
-  const runInstall = () => install({
-    cacheDir: stagingDir,
-    browser: Browser.CHROMEHEADLESSSHELL,
-    buildId: managedChromeVersion(),
-    platform,
-    downloadProgressCallback: options?.onProgress
-  });
+  let unzipLog = [];
+  const runInstall = () => {
+    unzipLog = [];
+    return install({
+      cacheDir: stagingDir,
+      browser: Browser.CHROMEHEADLESSSHELL,
+      buildId: managedChromeVersion(),
+      platform,
+      downloadProgressCallback: options?.onProgress,
+      logger: (prefix) => {
+        const debug = debuglog(prefix);
+        const isUnzip = prefix === "puppeteer:browsers:fileUtil";
+        if (!isUnzip && !debug.enabled) return void 0;
+        return (...args) => {
+          const line = args.join(" ");
+          if (isUnzip) unzipLog.push(line);
+          if (debug.enabled) debug(line);
+        };
+      }
+    });
+  };
   try {
     const staged = await installWithCorruptArchiveRecovery(
       runInstall,
@@ -517,13 +533,35 @@ async function downloadBrowser(options) {
         `[hyperframes] Downloaded browser archive was corrupt (${normalizeErrorMessage(err)}); re-downloading.`
       )
     );
+    assertExecutableUnpacked(stagingDir, staged.executablePath);
+    unzipLog = [];
     return { executablePath: moveStagedInstallIntoCache(stagingDir, staged), source: "download" };
   } catch (err) {
-    throw wrapDownloadFailureWithBrowserPathHint(err);
+    throw wrapDownloadFailureWithBrowserPathHint(err, unzipLog);
   } finally {
     clearStaging();
   }
 }
+function executableState(path) {
+  const stat = statSync(path, { throwIfNoEntry: false });
+  if (!stat) return "is missing";
+  if (!stat.isFile()) return "is not a file";
+  return stat.size > 0 ? "usable" : "is empty";
+}
+function isUsableExecutable(path) {
+  try {
+    return executableState(path) === "usable";
+  } catch {
+    return false;
+  }
+}
+function assertExecutableUnpacked(stagingDir, executablePath) {
+  const state = executableState(executablePath);
+  if (state === "usable") return;
+  throw new Error(
+    `the archive downloaded, but ${relative(stagingDir, executablePath)} ${state} after unzipping.`
+  );
+}
 function moveStagedInstallIntoCache(stagingDir, staged) {
   const target = join(CACHE_DIR, relative(stagingDir, staged.path));
   const aside = join(CACHE_ROOT_DIR, `${REPLACED_PREFIX}${randomUUID()}`);

package/dist/{chunk-QRKLPWEX.js → chunk-ADF3X6GM.js}

@@ -4,6 +4,10 @@ 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 {
+  resolveConfig,
+  usesSoftwareWebGpu
+} from "./chunk-UXO2L7HJ.js";
 
 // src/browser/gpuPolicy.ts
 function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
@@ -13,11 +17,16 @@ function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCE
   return "auto";
 }
 async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
-  const { resolveBrowserGpuMode } = await import("./src-JO5JOV7Y.js");
+  const { resolveBrowserGpuMode } = await import("./src-BSLKXEGX.js");
   return resolveBrowserGpuMode(requestedMode, { chromePath });
 }
+function resolveLocalWebGpu(browserGpuMode, requiresWebGpu) {
+  const gpuConfig = { browserGpuMode, allowSoftwareWebGpu: resolveConfig().allowSoftwareWebGpu };
+  return { gpuConfig, softwareWebGpu: usesSoftwareWebGpu(requiresWebGpu, gpuConfig) };
+}
 
 export {
   resolveLocalBrowserGpuMode,
-  resolveCaptureBrowserGpuMode
+  resolveCaptureBrowserGpuMode,
+  resolveLocalWebGpu
 };