hyperframes 0.8.143 → 0.8.144

package/dist/{chunk-LW6HO6U3.js → chunk-7RAYSCYT.js}

@@ -16,7 +16,7 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-4M4EC7JX.js";
+} from "./chunk-3VYNNWVA.js";
 import {
   extractCompositionMetadata
 } from "./chunk-MQZVBHEY.js";

package/dist/{chunk-QRKLPWEX.js → chunk-7SDCIWHQ.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-5VMR4WBS.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-VUJ2FUFK.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
 };

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-BT27OYYX.js → chunk-A53CBD24.js}

@@ -6,24 +6,24 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   serveStaticProjectHtml
-} from "./chunk-5FISWJ37.js";
+} from "./chunk-RVFEDAUV.js";
 import {
   resolveProject
-} from "./chunk-VIVBA6E6.js";
+} from "./chunk-KFKZ3ISO.js";
 import {
   AUDIT_SEEK_OPTIONS,
   installPageFunctionGuard,
   seekCompositionTimeline,
   waitForCompositionFonts,
   waitForRuntimeReady
-} from "./chunk-HMT2RPZU.js";
+} from "./chunk-SLCFKB3Y.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-PJU63L6W.js";
+} from "./chunk-5WADG7PR.js";
 import {
   resolveDiagnosticNavigationTimeoutMs
-} from "./chunk-P7THMINS.js";
+} from "./chunk-GZM2EFOE.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -34,7 +34,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-Y6QL2LGO.js";
+} from "./chunk-P6WH6QTV.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -707,7 +707,7 @@ async function collectTweenBoundaries(page) {
   });
 }
 async function bundleProjectHtml(projectDir) {
-  const { bundleToSingleHtml } = await import("./compiler-TEXQWW6N.js");
+  const { bundleToSingleHtml } = await import("./compiler-JZ4GNFMG.js");
   return bundleToSingleHtml(projectDir);
 }
 async function alignViewportToComposition(page, url) {
@@ -727,10 +727,15 @@ async function alignViewportToComposition(page, url) {
   });
 }
 async function runLayoutAudit(projectDir, opts) {
-  const { ensureBrowser } = await import("./manager-CT3D67CG.js");
+  const { ensureBrowser } = await import("./manager-BPSR6D3V.js");
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-JO5JOV7Y.js");
-  const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalBrowserGpuMode } = await import("./gpuPolicy-7N5MCE2G.js");
+  const { buildChromeArgs } = await import("./src-VUJ2FUFK.js");
+  const {
+    assertWebGpuAdapterAvailable,
+    compositionRequiresWebGpu,
+    resolveLocalBrowserGpuMode,
+    resolveLocalWebGpu
+  } = await import("./gpuPolicy-NBJNWHYS.js");
   const html = await bundleProjectHtml(projectDir);
   const server = await serveStaticProjectHtml(
     projectDir,
@@ -743,12 +748,13 @@ async function runLayoutAudit(projectDir, opts) {
     const requestedGpuMode = resolveLocalBrowserGpuMode();
     const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath);
     const requiresWebGpu = compositionRequiresWebGpu(html);
+    const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
     chromeBrowser = await launchManagedBrowser(puppeteer.default, {
       headless: true,
       executablePath: browser.executablePath,
       args: buildChromeArgs(
         { width: 1920, height: 1080, captureMode: "screenshot", requiresWebGpu },
-        { browserGpuMode: resolvedGpuMode }
+        gpuConfig
       )
     });
     const page = await chromeBrowser.newPage();
@@ -758,7 +764,7 @@ async function runLayoutAudit(projectDir, opts) {
       waitUntil: "domcontentloaded",
       timeout: resolveDiagnosticNavigationTimeoutMs()
     });
-    await assertWebGpuAdapterAvailable(page, requiresWebGpu);
+    await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
     await alignViewportToComposition(page, server.url);
     await waitForRuntimeReady(page, opts.timeout);
     await waitForCompositionFonts(page, 750);

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-HW4AKJ5F.js → chunk-AUBOF2PN.js}

@@ -8,7 +8,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-TAMQYQGJ.js";
+} from "./chunk-I5KY7EZP.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {

package/dist/{chunk-ZLW2V65P.js → chunk-BSQ7XANM.js}

@@ -144,8 +144,9 @@ function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
   const compDir = dirname(compSrcPath);
   if (!compDir || compDir === ".") return relativePath;
   const { basePath, suffix } = splitUrlSuffix(relativePath);
-  if (!basePath) return relativePath;
-  const filePath = decodeWellFormedEscapes(basePath);
+  const slashed = basePath.replace(/\\/g, "/");
+  if (!slashed || slashed.startsWith("/")) return relativePath;
+  const filePath = decodeWellFormedEscapes(slashed);
   const sibling = resolve2("/", join(compDir, filePath)).slice(1);
   if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
   return encodeUrlPath(sibling) + suffix;

package/dist/{chunk-LCSMOLGX.js → chunk-BYSBRF24.js}

@@ -4,6 +4,9 @@ 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 {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
 
 // src/utils/processTree.ts
 import { execFileSync, spawn } from "child_process";
@@ -121,6 +124,57 @@ async function terminateProcessTree(pid, options = {}) {
   return options.processGroup ? terminateProcessGroup(pid, signal) : terminatePidTree(pid, signal);
 }
 
+// src/renderSetupWorkerLifecycle.ts
+var RENDER_SETUP_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var RENDER_SETUP_RESULT_PREFIX = "HYPERFRAMES_RENDER_SETUP_RESULT:";
+var RENDER_SETUP_ERROR_PREFIX = "HYPERFRAMES_RENDER_SETUP_ERROR:";
+function installRenderSetupSignalHandlers(signalTarget, releaseLock, resendSignal, handleHangup = true) {
+  const handlers = /* @__PURE__ */ new Map();
+  const handledSignals = handleHangup ? RENDER_SETUP_SIGNALS : RENDER_SETUP_SIGNALS.filter((signal) => signal !== "SIGHUP");
+  for (const signal of handledSignals) {
+    const handler = () => {
+      releaseLock();
+      signalTarget.off(signal, handler);
+      resendSignal(signal);
+    };
+    handlers.set(signal, handler);
+    signalTarget.on(signal, handler);
+  }
+  return () => {
+    for (const [signal, handler] of handlers) signalTarget.off(signal, handler);
+  };
+}
+function prefixedLine(prefix, value) {
+  return prefix + JSON.stringify(value) + "\n";
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function prefixedValue(output, prefix) {
+  const line = output.split(/\r?\n/).find((text) => text.startsWith(prefix));
+  return line === void 0 ? void 0 : parseJson(line.slice(prefix.length));
+}
+function renderSetupResultLine(result) {
+  return prefixedLine(RENDER_SETUP_RESULT_PREFIX, result);
+}
+function renderSetupResultFrom(stdout) {
+  return prefixedValue(stdout, RENDER_SETUP_RESULT_PREFIX);
+}
+function renderSetupErrorLine(error) {
+  return "\n" + prefixedLine(RENDER_SETUP_ERROR_PREFIX, normalizeErrorMessage(error));
+}
+function renderSetupFailureFrom(stderr) {
+  const lines = stderr.split(/\r?\n/);
+  const at = lines.findIndex((text) => text.startsWith(RENDER_SETUP_ERROR_PREFIX));
+  const reason = at === -1 ? void 0 : parseJson(lines[at].slice(RENDER_SETUP_ERROR_PREFIX.length));
+  if (typeof reason !== "string" || reason === "") return void 0;
+  return { reason, earlierOutput: lines.slice(0, at).join("\n") };
+}
+
 // src/utils/cancellableProcess.ts
 import { spawn as spawn2 } from "child_process";
 import { fileURLToPath } from "url";
@@ -269,7 +323,14 @@ function runCancellableProcess(command, args, options = {}) {
     }
   });
 }
-var SETUP_RESULT_PREFIX = "HYPERFRAMES_RENDER_SETUP_RESULT:";
+function renderSetupError(error) {
+  if (!(error instanceof CancellableProcessError)) return error;
+  const failure = renderSetupFailureFrom(error.stderr);
+  if (failure?.earlierOutput.trim()) process.stderr.write(`${failure.earlierOutput.trimEnd()}
+`);
+  const reason = failure?.reason ?? error.stderr.trim();
+  return reason ? new Error(reason, { cause: error }) : error;
+}
 async function runRenderSetupWorker(mode, input, options) {
   const sourceMode = import.meta.url.endsWith(".ts");
   const workerUrl = new URL(
@@ -293,20 +354,20 @@ async function runRenderSetupWorker(mode, input, options) {
     );
   } catch (error) {
     if (options.signal?.aborted) options.signal.throwIfAborted();
-    if (error instanceof CancellableProcessError && error.stderr.trim()) {
-      throw new Error(error.stderr.trim(), { cause: error });
-    }
-    throw error;
+    throw renderSetupError(error);
   }
   if (result.stderr) process.stderr.write(result.stderr);
-  const encoded = result.stdout.split(/\r?\n/).find((line) => line.startsWith(SETUP_RESULT_PREFIX))?.slice(SETUP_RESULT_PREFIX.length);
-  if (!encoded) throw new Error(`${mode} setup process exited without a result`);
-  return JSON.parse(encoded);
+  const value = renderSetupResultFrom(result.stdout);
+  if (value === void 0) throw new Error(`${mode} setup process exited without a result`);
+  return value;
 }
 
 export {
   processIsAlive,
   terminateProcessTree,
+  installRenderSetupSignalHandlers,
+  renderSetupResultLine,
+  renderSetupErrorLine,
   runCancellableProcess,
   runRenderSetupWorker
 };

package/dist/{chunk-BFDJ63J5.js → chunk-DDIVWXN7.js}

@@ -19,7 +19,7 @@ import {
   decodeWellFormedEscapes,
   decodedUrlPath,
   readMediaOffsetSeconds
-} from "./chunk-ZLW2V65P.js";
+} from "./chunk-BSQ7XANM.js";
 
 // ../studio-server/dist/chunk-32IH7WBY.js
 import { execFile } from "child_process";

package/dist/{chunk-KOEWEFHK.js → chunk-DIRJ322I.js}

@@ -10,22 +10,25 @@ import {
   distroLabel,
   getFFmpegInstallHint,
   parseLddMissingLibs
-} from "./chunk-TVCRUG2S.js";
+} from "./chunk-ZEUONDQG.js";
 import {
   getFreeDiskMb
 } from "./chunk-GQJZORQP.js";
 import {
   ensureBrowser,
   findBrowser
-} from "./chunk-4PFZPP2N.js";
+} from "./chunk-A6S35NYA.js";
 import {
   runCancellableProcess
-} from "./chunk-LCSMOLGX.js";
+} from "./chunk-BYSBRF24.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
 
 // src/browser/preflight.ts
 import { existsSync } from "fs";
@@ -254,11 +257,13 @@ async function checkChrome(browserPath, signal) {
     };
   }
   let info;
+  let failure;
   try {
     info = signal ? await ensureBrowser({ preferManagedChrome: true, signal }) : await findBrowser();
-  } catch {
+  } catch (error) {
     if (signal?.aborted) signal.throwIfAborted();
     info = void 0;
+    failure = normalizeErrorMessage(error);
   }
   if (info) {
     return chromeLaunchOutcome(
@@ -278,7 +283,7 @@ async function checkChrome(browserPath, signal) {
     ok: false,
     level: "error",
     title: "Chrome not found",
-    detail: "Chrome Headless Shell is required for local rendering.",
+    detail: failure ?? "Chrome Headless Shell is required for local rendering.",
     hint: "Run: npx hyperframes browser ensure"
   };
 }

package/dist/{chunk-PAGIICKN.js → chunk-EX6C672Y.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-33RZPZ4K.js";
+} from "./chunk-5VMR4WBS.js";
 import {
   DOMParser,
   parseHTML