@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/catch-up-NEBCL5NO.js

@@ -0,0 +1,106 @@
+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 {
+  filesChangedSince,
+  markSeen,
+  readSeen,
+  unseenTurns
+} from "./chunk-VFZ7W5W7.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/catch-up.ts
+var examples = [
+  ["See what was done in the desktop app since you last looked", "framey catch-up"],
+  ["For another project", "framey catch-up ./my-video"],
+  ["For agents", "framey catch-up --json"]
+];
+var AGENTS = { claude: "Claude Code", codex: "Codex", grok: "Grok" };
+var oneLine = (text) => text.replace(/\s*\n+\s*/g, " ");
+var when = (at) => new Date(at).toLocaleString(void 0, { dateStyle: "medium", timeStyle: "short" });
+function printTurn(turn) {
+  console.log(`   ${c.dim(when(turn.at))}`);
+  if (turn.asked) console.log(`   The person: ${oneLine(turn.asked)}`);
+  if (turn.did)
+    console.log(`   Framey (${AGENTS[turn.engine] ?? "the app"}): ${oneLine(turn.did)}`);
+  if (turn.files.length) console.log(`   ${c.dim(`Changed: ${turn.files.join(", ")}`)}`);
+  console.log();
+}
+function printNotHandedOver(name, dir, json) {
+  if (json) console.log(JSON.stringify({ project: dir, turns: [], files: [] }, null, 2));
+  else
+    console.log(
+      `${c.success("\u25C7")}  ${c.accent(name)} wasn't handed to the desktop app from here, so there's nothing to catch up on.`
+    );
+}
+function printNews(name, turns, files) {
+  if (!turns.length && !files.length) {
+    console.log(`${c.success("\u25C7")}  Nothing new from the desktop app in ${c.accent(name)}.`);
+    return;
+  }
+  console.log(`${c.success("\u25C7")}  In the desktop app since you last looked (${c.accent(name)}):
+`);
+  turns.forEach(printTurn);
+  if (files.length) console.log(`   Files changed since then: ${files.join(", ")}`);
+  console.log(
+    `   ${c.dim("A record of what happened, not a new request. Read changed files again before editing them.")}`
+  );
+}
+var catch_up_default = defineCommand({
+  meta: {
+    name: "catch-up",
+    description: "See what was done in the desktop app since you last looked"
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Project directory (default: current)",
+      required: false
+    },
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  run({ args }) {
+    const project = resolveProject(args.dir);
+    const seen = readSeen(project.dir);
+    if (!seen.at) return printNotHandedOver(project.name, project.dir, args.json);
+    const checking = Date.now();
+    const turns = unseenTurns(project.dir, seen.at, checking);
+    const files = filesChangedSince(project.dir, seen.checked);
+    if (args.json) console.log(JSON.stringify({ project: project.dir, turns, files }, null, 2));
+    else printNews(project.name, turns, files);
+    const newest = Math.max(seen.at, ...turns.map((turn) => Date.parse(turn.at)));
+    markSeen(project.dir, { at: newest, checked: checking });
+  }
+});
+export {
+  catch_up_default as default,
+  examples
+};

package/vendor/framey/dist/check-F5N544ML.js

@@ -0,0 +1,111 @@
+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 {
+  check_default,
+  createCheckCommand,
+  examples,
+  parseCheckRange,
+  parseFrameCheck,
+  parseLayout,
+  prelaunchBrowserForCheck
+} from "./chunk-XTMDWNEC.js";
+import "./chunk-3LM6YPBR.js";
+import "./chunk-UTEIUGAZ.js";
+import "./chunk-IXU6PQSW.js";
+import "./chunk-PURHAXFL.js";
+import "./chunk-IVSUQR2B.js";
+import "./chunk-MLQP2QUF.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-FUFP7A7S.js";
+import "./chunk-WN4XZC5F.js";
+import "./chunk-O4YRB27L.js";
+import "./chunk-O7BGSQ5F.js";
+import "./chunk-C5BO7PMT.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-6DDPOHMK.js";
+import "./chunk-XUHOIDKG.js";
+import "./chunk-THJALHFJ.js";
+import "./chunk-IUONB55J.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-MI5FTLYK.js";
+import "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import "./chunk-SZNTYTIV.js";
+import "./chunk-YOR4CTCE.js";
+import "./chunk-KXTKKBOC.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-LEKZNRKI.js";
+import "./chunk-442JNXRM.js";
+import "./chunk-4BNN5FGX.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-DQBY7FRR.js";
+import "./chunk-WKBM7NDG.js";
+import "./chunk-XX7LTW5Y.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-XPTOJZJF.js";
+import "./chunk-RGLQURIX.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-FLREUEHW.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import "./chunk-U242RTCT.js";
+import "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.js";
+import "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-Q5X2B5WT.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  createCheckCommand,
+  check_default as default,
+  examples,
+  parseCheckRange,
+  parseFrameCheck,
+  parseLayout,
+  prelaunchBrowserForCheck
+};

package/vendor/framey/dist/checkBrowser-LZ66CMJG.js

@@ -0,0 +1,110 @@
+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 {
+  captureFindingCrops,
+  captureOverviewShot,
+  collectSeekClock,
+  createPageDriver,
+  dropFailedProxyEchoes,
+  keepBrokenImageAborts,
+  matchComponentFindings,
+  mergeHelperDrafts,
+  preResolveHostileMediaProxies,
+  runBrowserCheck,
+  samplingBrowserCount
+} from "./chunk-MLQP2QUF.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-FUFP7A7S.js";
+import "./chunk-WN4XZC5F.js";
+import "./chunk-O4YRB27L.js";
+import "./chunk-O7BGSQ5F.js";
+import "./chunk-C5BO7PMT.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-6DDPOHMK.js";
+import "./chunk-XUHOIDKG.js";
+import "./chunk-THJALHFJ.js";
+import "./chunk-IUONB55J.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-MI5FTLYK.js";
+import "./chunk-YPRBGITP.js";
+import "./chunk-7JQFJ6JJ.js";
+import "./chunk-SZNTYTIV.js";
+import "./chunk-YOR4CTCE.js";
+import "./chunk-KXTKKBOC.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-LEKZNRKI.js";
+import "./chunk-442JNXRM.js";
+import "./chunk-4BNN5FGX.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-WKBM7NDG.js";
+import "./chunk-XX7LTW5Y.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-XPTOJZJF.js";
+import "./chunk-RGLQURIX.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-FLREUEHW.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.js";
+import "./chunk-TIQB63MX.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-K4MJX7SR.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-M2WBOQ2Q.js";
+export {
+  captureFindingCrops,
+  captureOverviewShot,
+  collectSeekClock,
+  createPageDriver,
+  dropFailedProxyEchoes,
+  keepBrokenImageAborts,
+  matchComponentFindings,
+  mergeHelperDrafts,
+  preResolveHostileMediaProxies,
+  runBrowserCheck,
+  samplingBrowserCount
+};

package/vendor/framey/dist/chunk-2K7Z2HVP.js

@@ -0,0 +1,372 @@
+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 {
+  FIRST_LAUNCH_TIMEOUT_MS,
+  chromeDepsInstallCommand,
+  detectLinuxDistro,
+  distroLabel,
+  getFFmpegInstallHint,
+  parseLddMissingLibs
+} from "./chunk-UMD3V7CU.js";
+import {
+  ensureBrowser,
+  findBrowser
+} from "./chunk-ND46XKK3.js";
+import {
+  runCancellableProcess
+} from "./chunk-BL4U6U52.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import {
+  getFreeDiskMb
+} from "./chunk-T6AGUTZJ.js";
+import {
+  FFMPEG_PATH_ENV,
+  FFPROBE_PATH_ENV,
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
+
+// src/browser/preflight.ts
+import { existsSync } from "fs";
+import { platform } from "os";
+
+// src/browser/installFacts.ts
+var BUILD_IN_PATH = /[\\/]chrome(?:-headless-shell)?[\\/][a-z0-9_]+-(\d+\.\d+\.\d+\.\d+)[\\/]/i;
+function driveOf(path) {
+  if (path.startsWith("\\\\") || path.startsWith("//")) return "unc";
+  const letter = /^([A-Za-z]):[\\/]/.exec(path)?.[1];
+  if (!letter) return "posix";
+  return letter.toUpperCase() === "C" ? "windows_c" : "windows_other";
+}
+function lengthBucket(length) {
+  if (length < 120) return "under_120";
+  if (length < 200) return "120_to_199";
+  return length < 260 ? "200_to_259" : "260_plus";
+}
+function describeBrowserInstall(executablePath) {
+  const build = BUILD_IN_PATH.exec(executablePath)?.[1];
+  return {
+    ...build ? { build } : {},
+    pathAscii: new RegExp("^\\p{ASCII}*$", "u").test(executablePath),
+    pathLength: lengthBucket(executablePath.length),
+    drive: driveOf(executablePath)
+  };
+}
+
+// src/browser/preflight.ts
+function parseToolVersion(raw) {
+  const m = raw.match(/(ffmpeg|ffprobe)\s+version\s+(n?\d[\d.\-\w]*)/i);
+  return m ? `${m[1]} ${m[2]}` : raw.trim();
+}
+function extractMajorVersion(raw) {
+  const m = raw.match(/\bn?(\d+)\.\d+/);
+  return m?.[1] ? Number(m[1]) : void 0;
+}
+function configuredMissingDetail(envName) {
+  const configured = process.env[envName]?.trim();
+  if (!configured || existsSync(configured)) return void 0;
+  return `Configured path does not exist: ${envName}="${configured}"`;
+}
+async function readToolVersion(binaryPath, signal) {
+  try {
+    const output = (await runCancellableProcess(binaryPath, ["-version"], {
+      signal,
+      timeoutMs: FIRST_LAUNCH_TIMEOUT_MS
+    })).stdout;
+    const raw = output.split("\n")[0] ?? "";
+    const version = parseToolVersion(raw);
+    return {
+      ok: true,
+      detail: version ? `${version} at ${binaryPath}` : binaryPath,
+      majorVersion: extractMajorVersion(raw)
+    };
+  } catch (error) {
+    if (signal?.aborted) signal.throwIfAborted();
+    const status = typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
+    const exitDetail = typeof status === "number" ? ` (exit code ${status})` : "";
+    return {
+      ok: false,
+      detail: `Failed to run "${binaryPath}" -version${exitDetail}.`
+    };
+  }
+}
+async function checkFFmpeg(signal) {
+  const missingConfigured = configuredMissingDetail(FFMPEG_PATH_ENV);
+  if (missingConfigured) {
+    return {
+      name: "FFmpeg",
+      ok: false,
+      level: "error",
+      title: "FFmpeg not found",
+      detail: missingConfigured,
+      hint: getFFmpegInstallHint()
+    };
+  }
+  const path = findFfBinary("ffmpeg", { configuredMustExist: true });
+  if (path) {
+    const version = await readToolVersion(path, signal);
+    if (!version.ok) {
+      return {
+        name: "FFmpeg",
+        ok: false,
+        level: "error",
+        title: "FFmpeg cannot start",
+        detail: version.detail,
+        hint: process.platform === "win32" ? "Install a working 64-bit FFmpeg build with all required runtime DLLs." : getFFmpegInstallHint(),
+        path
+      };
+    }
+    return {
+      name: "FFmpeg",
+      ok: true,
+      level: "ok",
+      detail: version.detail,
+      path,
+      versionMajor: version.majorVersion
+    };
+  }
+  return {
+    name: "FFmpeg",
+    ok: false,
+    level: "error",
+    title: "FFmpeg not found",
+    // Second sentence dropped: "the render cannot proceed" is already said by
+    // the error this accompanies, and in Studio by the disabled Export button.
+    detail: "FFmpeg is required to encode video.",
+    hint: getFFmpegInstallHint()
+  };
+}
+async function checkFFprobe(signal) {
+  const missingConfigured = configuredMissingDetail(FFPROBE_PATH_ENV);
+  if (missingConfigured) {
+    return {
+      name: "FFprobe",
+      ok: false,
+      level: "error",
+      title: "FFprobe not found",
+      detail: missingConfigured,
+      hint: getFFmpegInstallHint()
+    };
+  }
+  const path = findFfBinary("ffprobe", { configuredMustExist: true });
+  if (path) {
+    const version = await readToolVersion(path, signal);
+    return { name: "FFprobe", ok: true, level: "ok", detail: version.detail, path };
+  }
+  return {
+    name: "FFprobe",
+    ok: false,
+    level: "error",
+    title: "FFprobe not found",
+    detail: "FFprobe is required to probe media assets. It ships with FFmpeg but was not found on PATH.",
+    hint: getFFmpegInstallHint()
+  };
+}
+async function chromeSharedLibOutcome(executablePath, found, signal) {
+  if (process.platform !== "linux") return found;
+  let probe;
+  if (!existsSync(executablePath)) {
+    probe = { ok: true, missing: [], probeUnavailable: true };
+  } else {
+    try {
+      const result = await runCancellableProcess("ldd", [executablePath], {
+        signal,
+        timeoutMs: 5e3
+      });
+      probe = parseLddMissingLibs(result.stdout);
+    } catch (error) {
+      if (signal?.aborted) signal.throwIfAborted();
+      const stdout = typeof error === "object" && error !== null && "stdout" in error ? String(error.stdout ?? "") : "";
+      const killed = typeof error === "object" && error !== null && "killed" in error && error.killed === true;
+      probe = stdout && !killed ? parseLddMissingLibs(stdout) : { ok: true, missing: [], probeUnavailable: true };
+    }
+  }
+  if (probe.probeUnavailable || probe.ok) return found;
+  const distro = detectLinuxDistro();
+  return {
+    name: "Chrome",
+    ok: false,
+    level: "error",
+    title: "Chrome cannot launch (missing system libraries)",
+    detail: `Chrome at ${executablePath} is missing shared libraries on ${distroLabel(distro)}: ${probe.missing.join(", ")}`,
+    hint: chromeDepsInstallCommand(distro.family),
+    path: executablePath
+  };
+}
+function chromeLaunchFailureDetails(error) {
+  if (typeof error !== "object" || error === null) return "";
+  const status = "status" in error ? error.status : void 0;
+  const signal = "signal" in error ? error.signal : void 0;
+  const code = "code" in error ? error.code : void 0;
+  return [
+    typeof status === "number" ? `exit code ${status}` : "",
+    typeof signal === "string" ? `signal ${signal}` : "",
+    typeof code === "string" ? code : ""
+  ].filter(Boolean).join(", ");
+}
+async function chromeLaunchOutcome(executablePath, found, signal) {
+  const libraries = await chromeSharedLibOutcome(executablePath, found, signal);
+  if (!libraries.ok) return libraries;
+  try {
+    const { stdout } = await runCancellableProcess(executablePath, ["--version"], {
+      signal,
+      timeoutMs: FIRST_LAUNCH_TIMEOUT_MS,
+      maxBufferBytes: 64 * 1024
+    });
+    return { ...found, versionMajor: extractMajorVersion(stdout) };
+  } catch (error) {
+    if (signal?.aborted) signal.throwIfAborted();
+    const details = chromeLaunchFailureDetails(error);
+    return {
+      name: "Chrome",
+      ok: false,
+      level: "error",
+      title: "Chrome cannot start",
+      detail: `Failed to run "${executablePath}" --version${details ? ` (${details})` : ""}.`,
+      hint: "Select a working Chrome/Chromium binary for this OS and architecture with HYPERFRAMES_BROWSER_PATH, or reinstall with: npx hyperframes browser ensure --force",
+      path: executablePath
+    };
+  }
+}
+async function checkChrome(browserPath, signal) {
+  if (browserPath) {
+    if (existsSync(browserPath)) {
+      return chromeLaunchOutcome(
+        browserPath,
+        {
+          name: "Chrome",
+          ok: true,
+          level: "ok",
+          detail: `explicit: ${browserPath}`,
+          path: browserPath
+        },
+        signal
+      );
+    }
+    return {
+      name: "Chrome",
+      ok: false,
+      level: "error",
+      title: "Chrome not found",
+      detail: `Chrome binary not found at "${browserPath}".`,
+      hint: "Run: framey browser ensure"
+    };
+  }
+  let info;
+  let failure;
+  try {
+    info = signal ? await ensureBrowser({ preferManagedChrome: true, signal }) : await findBrowser();
+  } catch (error) {
+    if (signal?.aborted) signal.throwIfAborted();
+    info = void 0;
+    failure = normalizeErrorMessage(error);
+  }
+  if (info) {
+    return chromeLaunchOutcome(
+      info.executablePath,
+      {
+        name: "Chrome",
+        ok: true,
+        level: "ok",
+        detail: `${info.source}: ${info.executablePath}`,
+        path: info.executablePath
+      },
+      signal
+    );
+  }
+  return {
+    name: "Chrome",
+    ok: false,
+    level: "error",
+    title: "Chrome not found",
+    detail: failure ?? "Chrome Headless Shell is required for local rendering.",
+    hint: "Run: framey browser ensure"
+  };
+}
+async function resolveRenderBrowser(signal) {
+  const { outcomes, browser } = await runEnvironmentChecks({ includeBrowser: true, signal });
+  if (browser) return browser;
+  const chrome = outcomes.find((outcome) => outcome.name === "Chrome");
+  const headline = [chrome?.title, chrome?.detail].filter(Boolean).join(": ");
+  throw new Error(
+    [headline, chrome?.hint].filter(Boolean).join(" ") || "Chrome Headless Shell could not be resolved for rendering."
+  );
+}
+function checkDisk(path = ".", freeDiskMb = getFreeDiskMb) {
+  const freeMb = freeDiskMb(path);
+  if (freeMb === null) {
+    return { name: "Disk", ok: true, level: "ok", detail: "Unable to check" };
+  }
+  const freeGb = (freeMb / 1024).toFixed(1);
+  if (freeMb < 1024) {
+    return {
+      name: "Disk",
+      ok: false,
+      level: "error",
+      title: "Low disk space",
+      detail: `${freeGb} GB free at ${path}`,
+      hint: "Renders produce large temp files. Free disk space before rendering."
+    };
+  }
+  return { name: "Disk", ok: true, level: "ok", detail: `${freeGb} GB free at ${path}` };
+}
+function checkWindowsUncPath(projectDir = process.cwd()) {
+  if (platform() !== "win32") return void 0;
+  if (!projectDir.startsWith("\\\\")) return void 0;
+  return {
+    name: "Windows path",
+    ok: true,
+    level: "warn",
+    detail: `UNC path: ${projectDir}`,
+    hint: "Chrome may fail to launch from a network share. Use a local drive if render startup fails."
+  };
+}
+async function runEnvironmentChecks(options = {}) {
+  const outcomes = [];
+  const ffmpeg = await checkFFmpeg(options.signal);
+  outcomes.push(ffmpeg);
+  const ffprobe = await checkFFprobe(options.signal);
+  outcomes.push(ffprobe);
+  let browser;
+  let browserVersionMajor;
+  if (options.includeBrowser) {
+    const chrome = await checkChrome(options.browserPath, options.signal);
+    outcomes.push(chrome);
+    if (chrome.ok && chrome.path) {
+      browser = {
+        executablePath: chrome.path,
+        source: options.browserPath ? "env" : "cache"
+      };
+    }
+    browserVersionMajor = chrome.versionMajor;
+  }
+  if (options.includeDisk) {
+    const diskPaths = [...new Set(options.diskPaths ?? [options.projectDir ?? "."])];
+    outcomes.push(...diskPaths.map((path) => checkDisk(path)));
+  }
+  if (options.includeWindowsUnc) {
+    const unc = checkWindowsUncPath(options.projectDir);
+    if (unc) outcomes.push(unc);
+  }
+  return {
+    outcomes,
+    ...ffmpeg.ok && ffmpeg.path ? { ffmpegPath: ffmpeg.path } : {},
+    ...ffprobe.path ? { ffprobePath: ffprobe.path } : {},
+    ...browser ? { browser, browserInstall: describeBrowserInstall(browser.executablePath) } : {},
+    ...ffmpeg.versionMajor != null ? { ffmpegVersionMajor: ffmpeg.versionMajor } : {},
+    ...browserVersionMajor != null ? { browserVersionMajor } : {}
+  };
+}
+
+export {
+  parseToolVersion,
+  extractMajorVersion,
+  resolveRenderBrowser,
+  checkDisk,
+  runEnvironmentChecks
+};