@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/benchmark-RWCWHI5Z.js

@@ -0,0 +1,230 @@
+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 {
+  ft
+} from "./chunk-WMQNIQDJ.js";
+import {
+  loadProducer
+} from "./chunk-PURHAXFL.js";
+import {
+  withMeta
+} from "./chunk-O4YRB27L.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import {
+  errorBox,
+  formatBytes,
+  formatDuration
+} from "./chunk-P5ZBLXJ6.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 {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import {
+  fpsToFfmpegArg
+} from "./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-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/benchmark.ts
+import { existsSync, statSync } from "fs";
+import { resolve, join } from "path";
+var examples = [
+  ["Run benchmarks with default settings (3 runs)", "framey benchmark"],
+  ["Run 5 iterations per config", "framey benchmark --runs 5"],
+  ["Output results as JSON", "framey benchmark --json"]
+];
+var FPS_30 = { num: 30, den: 1 };
+var FPS_60 = { num: 60, den: 1 };
+var DEFAULT_CONFIGS = [
+  { label: "30fps \xB7 draft \xB7 2w", fps: FPS_30, quality: "draft", workers: 2 },
+  { label: "30fps \xB7 standard \xB7 2w", fps: FPS_30, quality: "standard", workers: 2 },
+  { label: "30fps \xB7 high \xB7 2w", fps: FPS_30, quality: "high", workers: 2 },
+  { label: "30fps \xB7 standard \xB7 4w", fps: FPS_30, quality: "standard", workers: 4 },
+  { label: "60fps \xB7 standard \xB7 4w", fps: FPS_60, quality: "standard", workers: 4 }
+];
+var benchmark_default = defineCommand({
+  meta: {
+    name: "benchmark",
+    description: "Render with preset fps/quality/worker configs and compare speed and file size"
+  },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    runs: { type: "string", description: "Number of runs per config", default: "3" },
+    json: { type: "boolean", description: "Output results as JSON", default: false }
+  },
+  async run({ args }) {
+    const project = resolveProject(args.dir);
+    const runsPerConfig = parseInt(args.runs ?? "3", 10);
+    if (isNaN(runsPerConfig) || runsPerConfig < 1 || runsPerConfig > 20) {
+      errorBox("Invalid runs", `Got "${args.runs ?? "3"}". Must be between 1 and 20.`);
+      failCommand();
+    }
+    const jsonOutput = args.json ?? false;
+    const benchDir = resolve("renders", ".benchmark");
+    let producer = null;
+    try {
+      producer = await loadProducer();
+    } catch {
+      if (jsonOutput) {
+        console.log(
+          JSON.stringify({ error: "Producer module not available. Is the project built?" })
+        );
+      } else {
+        errorBox(
+          "Producer module not available",
+          "The rendering pipeline could not be loaded.",
+          "Ensure @framey/producer is built and linked."
+        );
+      }
+      failCommand();
+    }
+    if (!jsonOutput) {
+      console.log("");
+      console.log(
+        c.accent("\u25C6") + "  Benchmarking " + c.accent(project.name) + c.dim(` (${runsPerConfig} runs each)`)
+      );
+      console.log("");
+    }
+    const results = [];
+    for (const config of DEFAULT_CONFIGS) {
+      const runs = [];
+      let failures = 0;
+      const s = !jsonOutput ? ft() : void 0;
+      s?.start(`Benchmarking ${config.label}...`);
+      for (let i = 0; i < runsPerConfig; i++) {
+        s?.message(`${config.label} \u2014 run ${i + 1}/${runsPerConfig}`);
+        const outputPath = join(
+          benchDir,
+          `${config.label.replace(/[^a-zA-Z0-9]/g, "_")}_run${i}.mp4`
+        );
+        try {
+          const startTime = Date.now();
+          const job = producer.createRenderJob({
+            fps: config.fps,
+            quality: config.quality,
+            workers: config.workers
+          });
+          await producer.executeRenderJob(job, project.dir, outputPath);
+          const elapsedMs = Date.now() - startTime;
+          let fileSize = null;
+          if (existsSync(outputPath)) {
+            const stat = statSync(outputPath);
+            fileSize = stat.size;
+          }
+          runs.push({ elapsedMs, fileSize });
+        } catch {
+          failures++;
+        }
+      }
+      s?.stop(`${config.label} \u2014 ${runs.length} runs${failures > 0 ? `, ${failures} failed` : ""}`);
+      const successfulRuns = runs.filter((r) => r.elapsedMs > 0);
+      const avgTime = successfulRuns.length > 0 ? successfulRuns.reduce((sum, r) => sum + r.elapsedMs, 0) / successfulRuns.length : null;
+      const sizesWithValues = runs.map((r) => r.fileSize).filter((s2) => s2 != null);
+      const avgSize = sizesWithValues.length > 0 ? sizesWithValues.reduce((sum, s2) => sum + s2, 0) / sizesWithValues.length : null;
+      results.push({ config, runs, failures, avgTime, avgSize });
+    }
+    if (results.every((result) => result.runs.length === 0)) {
+      setCommandExitCode(1);
+    }
+    if (jsonOutput) {
+      console.log(
+        JSON.stringify(
+          withMeta({
+            results: results.map((r) => ({
+              config: r.config.label,
+              // Emit fps in the on-the-wire form so the JSON payload is
+              // round-trippable through `parseFps` (e.g. "30000/1001" stays
+              // exact; integer fps stays integer).
+              fps: fpsToFfmpegArg(r.config.fps),
+              quality: r.config.quality,
+              workers: r.config.workers,
+              avgTimeMs: r.avgTime,
+              avgSizeBytes: r.avgSize,
+              failures: r.failures,
+              runs: r.runs
+            }))
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const configColWidth = 26;
+    const timeColWidth = 10;
+    const sizeColWidth = 10;
+    const header = "   " + c.bold("Config".padEnd(configColWidth)) + c.bold("Time".padEnd(timeColWidth)) + c.bold("Size".padEnd(sizeColWidth));
+    const separator = "   " + c.dim("\u2500".repeat(configColWidth + timeColWidth + sizeColWidth));
+    console.log(header);
+    console.log(separator);
+    for (const result of results) {
+      const timeStr = result.avgTime != null ? formatDuration(result.avgTime) : c.dim("failed");
+      const sizeStr = result.avgSize != null ? formatBytes(result.avgSize) : c.dim("n/a");
+      const failStr = result.failures > 0 ? c.warn(` (${result.failures} failed)`) : "";
+      console.log(
+        "   " + result.config.label.padEnd(configColWidth) + timeStr.padEnd(timeColWidth) + sizeStr.padEnd(sizeColWidth) + failStr
+      );
+    }
+    const successfulResults = results.filter((r) => r.avgTime != null);
+    if (successfulResults.length > 0) {
+      let fastest = successfulResults[0];
+      for (const r of successfulResults) {
+        if (fastest == null || r.avgTime == null) continue;
+        if (fastest.avgTime == null || r.avgTime < fastest.avgTime) {
+          fastest = r;
+        }
+      }
+      if (fastest?.avgTime != null) {
+        console.log("");
+        console.log(
+          c.success("\u25C7") + "  Fastest: " + c.accent(fastest.config.label) + c.dim(` (${formatDuration(fastest.avgTime)})`)
+        );
+      }
+    } else {
+      console.log("");
+      console.log(
+        c.error("\u2717") + "  All configurations failed. Ensure the rendering pipeline is set up."
+      );
+    }
+    console.log("");
+  }
+});
+export {
+  benchmark_default as default,
+  examples
+};

package/vendor/framey/dist/browser-ECYET3Q2.js

@@ -0,0 +1,206 @@
+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 {
+  R,
+  ft,
+  ge,
+  ye
+} from "./chunk-WMQNIQDJ.js";
+import {
+  formatBytes
+} from "./chunk-P5ZBLXJ6.js";
+import {
+  trackBrowserInstall
+} from "./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 {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-AHX34EFP.js";
+import {
+  CACHE_DIR,
+  clearBrowser,
+  ensureBrowser,
+  findBrowser,
+  isLinuxArm
+} from "./chunk-ND46XKK3.js";
+import "./chunk-BL4U6U52.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import {
+  managedChromeVersion
+} from "./chunk-4UMPIPCQ.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/browser.ts
+var examples = [
+  ["Find or download Chrome for rendering", "framey browser ensure"],
+  ["Purge a stale/partial download and re-download", "framey browser ensure --force"],
+  ["Print the Chrome executable path", "framey browser path"],
+  ["Remove cached Chrome download", "framey browser clear"]
+];
+function failSpinner(s, label, err) {
+  s.stop(c.error(label));
+  R.error(normalizeErrorMessage(err));
+  failCommand(1, err);
+}
+function printBrowser(browser) {
+  console.log();
+  console.log(`   ${c.dim("Source:")}  ${c.bold(browser.source)}`);
+  console.log(`   ${c.dim("Path:")}    ${c.bold(browser.executablePath)}`);
+  console.log();
+}
+async function runEnsure(options) {
+  ge(c.bold("framey browser ensure"));
+  if (isLinuxArm()) {
+    const s2 = ft();
+    s2.start("Linux ARM64 detected \u2014 looking for system Chromium...");
+    const existing = await findBrowser().catch(
+      (err) => failSpinner(s2, "Browser lookup failed", err)
+    );
+    if (existing) {
+      s2.stop(c.success("System Chromium found"));
+      printBrowser(existing);
+      ye(c.success("Ready to render."));
+      return;
+    }
+    s2.stop(c.warn("No Chromium found \u2014 attempting auto-install via apt-get..."));
+    console.log();
+    try {
+      const result2 = await ensureBrowser();
+      printBrowser(result2);
+      ye(c.success("Chromium ready. You can now render on ARM64."));
+    } catch (err) {
+      R.error(err instanceof Error ? err.message : String(err));
+      ye(c.warn("Manual setup required (see instructions above)."));
+      failCommand(1, err);
+    }
+    return;
+  }
+  const downloading = `Downloading Chrome Headless Shell ${c.dim("v" + managedChromeVersion())}`;
+  const s = ft();
+  s.start(options?.force ? `${downloading}...` : "Looking for an existing browser...");
+  let lastPct = -1;
+  let result;
+  try {
+    result = await ensureBrowser({
+      force: options?.force,
+      preferManagedChrome: true,
+      onProgress: (downloaded, total) => {
+        if (total <= 0) return;
+        const pct = Math.floor(downloaded / total * 100);
+        if (pct > lastPct) {
+          lastPct = pct;
+          s.message(
+            `${downloading} \u2014 ${c.progress(pct + "%")} ${c.dim("(" + formatBytes(downloaded) + " / " + formatBytes(total) + ")")}`
+          );
+        }
+      }
+    });
+  } catch (err) {
+    failSpinner(s, "Browser not available", err);
+  }
+  if (result.source === "download") trackBrowserInstall();
+  s.stop(c.success(result.source === "download" ? "Download complete" : "Browser found"));
+  printBrowser(result);
+  ye(c.success("Ready to render."));
+}
+async function runPath() {
+  const result = await findBrowser();
+  if (!result) {
+    try {
+      const ensured = await ensureBrowser();
+      process.stdout.write(ensured.executablePath + "\n");
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : "Failed to find browser");
+      failCommand(1, err);
+    }
+    return;
+  }
+  process.stdout.write(result.executablePath + "\n");
+}
+function runClear() {
+  ge(c.bold("framey browser clear"));
+  const removed = clearBrowser();
+  if (removed) {
+    ye(c.success("Removed cached browser from ") + c.dim(CACHE_DIR));
+  } else {
+    ye(c.dim("No cached browser to remove."));
+  }
+}
+var browser_default = defineCommand({
+  meta: { name: "browser", description: "Manage the Chrome browser used for rendering" },
+  args: {
+    subcommand: {
+      type: "positional",
+      description: "ensure = find or download Chrome, path = print executable path, clear = remove cached download",
+      required: false
+    },
+    force: {
+      type: "boolean",
+      description: "ensure only: purge any cached download (including a stale/partial one) and re-download from scratch",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const subcommand = args.subcommand;
+    if (!subcommand || subcommand === "") {
+      console.log(`
+${c.bold("framey browser")} ${c.dim("<subcommand>")}
+
+Manage the Chrome browser used for rendering.
+
+${c.bold("SUBCOMMANDS:")}
+  ${c.accent("ensure")}   ${c.dim("Find or download Chrome for rendering")}
+  ${c.accent("path")}     ${c.dim("Print browser executable path (for scripting)")}
+  ${c.accent("clear")}    ${c.dim("Remove cached Chrome download")}
+
+${c.bold("EXAMPLES:")}
+  ${c.accent("framey browser ensure")}           ${c.dim("Download Chrome if needed")}
+  ${c.accent("framey browser ensure --force")}   ${c.dim("Purge a stale/partial download and re-download")}
+  ${c.accent("framey browser path")}             ${c.dim("Print path for scripts")}
+  ${c.accent("framey browser clear")}            ${c.dim("Remove cached browser")}
+`);
+      return;
+    }
+    switch (subcommand) {
+      case "ensure":
+        return runEnsure({ force: args.force });
+      case "path":
+        return runPath();
+      case "clear":
+        return runClear();
+      default:
+        console.error(
+          `${c.error("Unknown subcommand:")} ${subcommand}
+
+Run ${c.accent("framey browser --help")} for usage.`
+        );
+        failCommand(1, `Unknown subcommand: ${subcommand}`);
+    }
+  }
+});
+export {
+  browser_default as default,
+  examples
+};

package/vendor/framey/dist/bundleWithLocalizedFonts-ALYBQEQT.js

@@ -0,0 +1,52 @@
+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 {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/utils/bundleWithLocalizedFonts.ts
+async function bundleWithLocalizedFonts(projectDir, localizeFonts = localizeWithProducer) {
+  const { bundleToSingleHtml } = await import("./compiler-TM3W6GYF.js");
+  const html = await bundleToSingleHtml(projectDir);
+  return localizeFonts(html);
+}
+async function loadFontInjector() {
+  try {
+    const { loadProducer } = await import("./producer-SKU5EV3J.js");
+    const mod = await loadProducer();
+    return mod.injectDeterministicFontFaces ?? null;
+  } catch {
+    return null;
+  }
+}
+var warnedFontLocalizationFailures = /* @__PURE__ */ new Set();
+function __resetFontLocalizationWarningsForTests() {
+  warnedFontLocalizationFailures.clear();
+}
+async function localizeWithProducer(html, loadInjector = loadFontInjector, warn = (m) => console.warn(`   ${c.warn("\u26A0")} ${m}`)) {
+  const inject = await loadInjector();
+  if (!inject) return html;
+  try {
+    return await inject(html);
+  } catch (err) {
+    const message = `Font localization failed; capturing with remote/fallback fonts instead: ${normalizeErrorMessage(err)}`;
+    if (!warnedFontLocalizationFailures.has(message)) {
+      warnedFontLocalizationFailures.add(message);
+      warn(message);
+    }
+    return html;
+  }
+}
+export {
+  __resetFontLocalizationWarningsForTests,
+  bundleWithLocalizedFonts,
+  localizeWithProducer
+};

package/vendor/framey/dist/captureCompositionFrame-4DA6SEH2.js

@@ -0,0 +1,94 @@
+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 {
+  AUDIT_SEEK_OPTIONS,
+  DEFAULT_ZOOM_PADDING_PX,
+  DEFAULT_ZOOM_SCALE,
+  DENSE_GEOMETRY_SEEK_OPTIONS,
+  SCREENSHOT_IMAGE_WAIT_MS,
+  SCREENSHOT_SEEK_OPTIONS,
+  captureRegionCrop,
+  clampCropRegion,
+  installPageFunctionGuard,
+  openSettledCompositionPage,
+  padCropRegion,
+  parseZoomTarget,
+  prelaunchCompositionBrowser,
+  resolveCliChromeGpuMode,
+  resolveCropRegion,
+  runFfmpegOnce,
+  seekCompositionTimeline,
+  seekCompositionTimelineOnly,
+  seekInPage,
+  settleCompositionSeek,
+  waitForCompositionFonts,
+  waitForPreferredSeekTarget,
+  waitForRuntimeReady
+} from "./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-WKBM7NDG.js";
+import "./chunk-VORQIH64.js";
+import "./chunk-JVBRJMOP.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-T2EUWCJE.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 {
+  AUDIT_SEEK_OPTIONS,
+  DEFAULT_ZOOM_PADDING_PX,
+  DEFAULT_ZOOM_SCALE,
+  DENSE_GEOMETRY_SEEK_OPTIONS,
+  SCREENSHOT_IMAGE_WAIT_MS,
+  SCREENSHOT_SEEK_OPTIONS,
+  captureRegionCrop,
+  clampCropRegion,
+  installPageFunctionGuard,
+  openSettledCompositionPage,
+  padCropRegion,
+  parseZoomTarget,
+  prelaunchCompositionBrowser,
+  resolveCliChromeGpuMode,
+  resolveCropRegion,
+  runFfmpegOnce,
+  seekCompositionTimeline,
+  seekCompositionTimelineOnly,
+  seekInPage,
+  settleCompositionSeek,
+  waitForCompositionFonts,
+  waitForPreferredSeekTarget,
+  waitForRuntimeReady
+};