@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

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

@@ -0,0 +1,264 @@
+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 {
+  detectGpuEncoder
+} from "./chunk-TIQB63MX.js";
+import {
+  runCancellableProcess
+} from "./chunk-BL4U6U52.js";
+import {
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
+import {
+  detectWsl
+} from "./chunk-W2LGJSEN.js";
+
+// src/browser/linuxDeps.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+var DISTRO_PACKAGES = {
+  debian: [
+    "libnss3",
+    "libnspr4",
+    "libatk1.0-0",
+    "libatk-bridge2.0-0",
+    "libcups2",
+    "libdrm2",
+    "libxkbcommon0",
+    "libatspi2.0-0",
+    "libxcomposite1",
+    "libxdamage1",
+    "libxfixes3",
+    "libxrandr2",
+    "libgbm1",
+    "libpango-1.0-0",
+    "libcairo2",
+    "libasound2"
+  ],
+  fedora: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "cups-libs",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libXcomposite",
+    "libXdamage",
+    "libXfixes",
+    "libXrandr",
+    "mesa-libgbm",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ],
+  arch: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "libcups",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libxcomposite",
+    "libxdamage",
+    "libxfixes",
+    "libxrandr",
+    "mesa",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ],
+  alpine: [
+    "nss",
+    "nspr",
+    "atk",
+    "at-spi2-atk",
+    "cups-libs",
+    "libdrm",
+    "libxkbcommon",
+    "at-spi2-core",
+    "libxcomposite",
+    "libxdamage",
+    "libxfixes",
+    "libxrandr",
+    "mesa-gbm",
+    "pango",
+    "cairo",
+    "alsa-lib"
+  ]
+};
+var INSTALL_PREFIX = {
+  debian: "sudo apt-get update && sudo apt-get install -y",
+  fedora: "sudo dnf install -y",
+  arch: "sudo pacman -S --needed",
+  alpine: "sudo apk add"
+};
+function distroFamilyFromOsRelease(id, idLike) {
+  const haystack = `${id ?? ""} ${idLike ?? ""}`.toLowerCase();
+  if (/\b(debian|ubuntu|linuxmint|pop|elementary|raspbian|kali)\b/.test(haystack)) return "debian";
+  if (/\b(fedora|rhel|centos|rocky|almalinux|amzn|ol)\b/.test(haystack)) return "fedora";
+  if (/\b(arch|manjaro|endeavouros|garuda)\b/.test(haystack)) return "arch";
+  if (/\b(alpine)\b/.test(haystack)) return "alpine";
+  return "unknown";
+}
+function parseOsRelease(contents) {
+  const out = {};
+  for (const rawLine of contents.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]) {
+      value = value.slice(1, -1);
+    }
+    if (key) out[key] = value;
+  }
+  return out;
+}
+function detectLinuxDistro() {
+  const isWsl = detectWsl();
+  try {
+    const contents = readFileSync("/etc/os-release", "utf-8");
+    const parsed = parseOsRelease(contents);
+    const family = distroFamilyFromOsRelease(parsed["ID"], parsed["ID_LIKE"]);
+    return {
+      family,
+      ...parsed["ID"] ? { id: parsed["ID"] } : {},
+      ...parsed["PRETTY_NAME"] ? { prettyName: parsed["PRETTY_NAME"] } : {},
+      isWsl
+    };
+  } catch {
+    return { family: "unknown", isWsl };
+  }
+}
+function chromeDepsInstallCommand(family) {
+  if (family === "unknown") {
+    return "Install the Chrome headless dependencies for your distro (nss, atk, at-spi2, cups, libdrm, libxkbcommon, gbm, pango, cairo, alsa), then re-run.";
+  }
+  return `${INSTALL_PREFIX[family]} ${DISTRO_PACKAGES[family].join(" ")}`;
+}
+function ffmpegInstallCommand(family) {
+  if (family === "unknown") {
+    return "Install ffmpeg (which includes ffprobe) via your distro package manager, then re-run.";
+  }
+  return `${INSTALL_PREFIX[family]} ffmpeg`;
+}
+function distroLabel(distro) {
+  if (distro.isWsl) return "WSL";
+  return distro.prettyName ?? "Linux";
+}
+function parseLddMissingLibs(lddOutput) {
+  const missing = [];
+  for (const rawLine of lddOutput.split("\n")) {
+    const line = rawLine.trim();
+    if (!/=>\s*not found\b/.test(line)) continue;
+    const soname = line.split("=>")[0]?.trim();
+    if (soname) missing.push(soname);
+  }
+  return { ok: missing.length === 0, missing, probeUnavailable: false };
+}
+function isSharedLibLaunchError(message) {
+  return /cannot open shared object file/i.test(message) || /error while loading shared libraries/i.test(message) || /lib[\w.+-]*\.so[\w.]*: cannot open/i.test(message);
+}
+function chromeLaunchRemediation(errorMessage) {
+  const isLaunchFailure = /Failed to launch the browser process/i.test(errorMessage) || isSharedLibLaunchError(errorMessage);
+  if (!isLaunchFailure) return void 0;
+  if (process.platform !== "linux") return void 0;
+  if (process.arch === "arm64") return void 0;
+  const distro = detectLinuxDistro();
+  const lines = [];
+  lines.push(
+    `Chrome could not launch on ${distroLabel(distro)} \u2014 this is almost always missing system libraries (e.g. libnss3).`
+  );
+  lines.push("Install the Chrome headless dependencies:");
+  lines.push(`  ${chromeDepsInstallCommand(distro.family)}`);
+  lines.push("Then verify with: framey doctor");
+  return lines.join("\n");
+}
+
+// src/browser/ffmpeg.ts
+var H264EncoderUnavailableError = class extends Error {
+  constructor(hevcEncoderAvailable = false) {
+    super("This FFmpeg build has no libx264 and no GPU H.264 encoder that works on this machine.");
+    this.hevcEncoderAvailable = hevcEncoderAvailable;
+    this.name = "H264EncoderUnavailableError";
+  }
+  hevcEncoderAvailable;
+};
+function resolveH264EncoderMode(ffmpegEncodersOutput, gpuRequested, usableGpu) {
+  if (gpuRequested && usableGpu) return "gpu";
+  if (hasLibx264(ffmpegEncodersOutput)) return "software";
+  if (usableGpu) return "gpu";
+  throw new H264EncoderUnavailableError(/\blibx265\b/.test(ffmpegEncodersOutput));
+}
+function hasLibx264(ffmpegEncodersOutput) {
+  return /\blibx264\b/.test(ffmpegEncodersOutput);
+}
+async function detectH264EncoderModeForRender(ffmpegPath, gpuRequested, signal, probeGpu = detectGpuEncoder) {
+  const result = await runCancellableProcess(ffmpegPath, ["-hide_banner", "-encoders"], {
+    signal,
+    timeoutMs: FIRST_LAUNCH_TIMEOUT_MS
+  });
+  const needsGpu = gpuRequested || !hasLibx264(result.stdout);
+  const usableGpu = needsGpu && await probeGpu() !== null;
+  return resolveH264EncoderMode(result.stdout, gpuRequested, usableGpu);
+}
+function findFFmpeg() {
+  return findFfBinary("ffmpeg", { configuredMustExist: true });
+}
+function findFFprobe() {
+  return findFfBinary("ffprobe", { configuredMustExist: true });
+}
+var FIRST_LAUNCH_TIMEOUT_MS = 6e4;
+var FFMPEG_DOWNLOAD_URL = "https://ffmpeg.org/download.html";
+function getFFmpegInstallCommand() {
+  switch (process.platform) {
+    case "darwin":
+      return "brew install ffmpeg";
+    case "linux": {
+      const distro = detectLinuxDistro();
+      if (distro.family === "unknown") return void 0;
+      return ffmpegInstallCommand(distro.family);
+    }
+    // winget ships with Windows 10 1809+ and Windows 11. Machines without it
+    // still get the manual download route from the hint below.
+    case "win32":
+      return "winget install --id Gyan.FFmpeg -e";
+    default:
+      return void 0;
+  }
+}
+function getFFmpegInstallHint() {
+  const command = getFFmpegInstallCommand();
+  if (command && process.platform === "win32") {
+    return `${command}, or download the 64-bit build from ${FFMPEG_DOWNLOAD_URL}#build-windows and add its bin/ directory to PATH.`;
+  }
+  if (command) return command;
+  if (process.platform === "linux") return ffmpegInstallCommand("unknown");
+  return FFMPEG_DOWNLOAD_URL;
+}
+
+export {
+  detectLinuxDistro,
+  chromeDepsInstallCommand,
+  distroLabel,
+  parseLddMissingLibs,
+  chromeLaunchRemediation,
+  H264EncoderUnavailableError,
+  resolveH264EncoderMode,
+  detectH264EncoderModeForRender,
+  findFFmpeg,
+  findFFprobe,
+  FIRST_LAUNCH_TIMEOUT_MS,
+  getFFmpegInstallCommand,
+  getFFmpegInstallHint
+};

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

@@ -0,0 +1,42 @@
+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);
+
+// src/whisper/wav.ts
+import { readFileSync } from "fs";
+function findWavChunk(buf, want) {
+  if (buf.length < 12) return null;
+  let pos = 12;
+  while (pos + 8 <= buf.length) {
+    const id = buf.toString("ascii", pos, pos + 4);
+    const size = buf.readUInt32LE(pos + 4);
+    if (id === want) return { offset: pos + 8, size: Math.min(size, buf.length - pos - 8) };
+    pos += 8 + size;
+    if (size % 2 !== 0) pos++;
+  }
+  return null;
+}
+var PCM = 1;
+var EXTENSIBLE = 65534;
+function readWav(path) {
+  const buf = readFileSync(path);
+  const riff = buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WAVE";
+  const fmt = riff ? findWavChunk(buf, "fmt ") : null;
+  const data = fmt && findWavChunk(buf, "data");
+  const format = fmt && buf.readUInt16LE(fmt.offset);
+  if (!fmt || !data || format !== PCM && format !== EXTENSIBLE || buf.readUInt16LE(fmt.offset + 2) !== 1 || buf.readUInt16LE(fmt.offset + 14) !== 16) {
+    throw new Error(`${path} is not a 16-bit mono PCM WAV`);
+  }
+  const samples = new Float32Array(data.size >> 1);
+  for (let i = 0; i < samples.length; i++)
+    samples[i] = buf.readInt16LE(data.offset + 2 * i) / 32768;
+  return { samples, sampleRate: buf.readUInt32LE(fmt.offset + 4) };
+}
+
+export {
+  findWavChunk,
+  readWav
+};

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

@@ -0,0 +1,29 @@
+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 {
+  withOwner
+} from "./chunk-IXU6PQSW.js";
+import {
+  HistoryBusyError,
+  beginArtifactCapture
+} from "./chunk-YPRBGITP.js";
+
+// src/utils/artifactCapture.ts
+var SKIP_BUSY_HISTORY = { ownerWaitMs: 0 };
+function unlessAnotherProcessKeepsTheHistory(error) {
+  if (!(error instanceof HistoryBusyError)) throw error;
+}
+async function captureArtifactRevision(projectDir) {
+  await withOwner(projectDir, (owner) => owner.checkpoint(), SKIP_BUSY_HISTORY).catch(
+    unlessAnotherProcessKeepsTheHistory
+  );
+  return beginArtifactCapture(projectDir);
+}
+
+export {
+  captureArtifactRevision
+};

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

@@ -0,0 +1,138 @@
+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);
+
+// ../parsers/dist/ffBinaries.js
+import { execFileSync } from "child_process";
+import { accessSync, constants, existsSync } from "fs";
+import { createRequire } from "module";
+import { delimiter, dirname, join, resolve } from "path";
+var FFMPEG_PATH_ENV = "HYPERFRAMES_FFMPEG_PATH";
+var FFPROBE_PATH_ENV = "HYPERFRAMES_FFPROBE_PATH";
+var ENV_BY_NAME = {
+  ffmpeg: FFMPEG_PATH_ENV,
+  ffprobe: FFPROBE_PATH_ENV
+};
+var pathLookupCache = /* @__PURE__ */ new Map();
+var MISS_TTL_MS = 5e3;
+var lastMissAt = /* @__PURE__ */ new Map();
+function candidateFileName(candidate) {
+  return candidate.split(/[\\/]/).at(-1)?.toLowerCase() ?? candidate.toLowerCase();
+}
+function chooseBestPathCandidate(name, candidates) {
+  const normalized = candidates.map((candidate) => candidate.trim()).filter(Boolean);
+  return normalized.find((candidate) => candidateFileName(candidate) === `${name}.exe`) ?? normalized.find((candidate) => candidateFileName(candidate) === name) ?? normalized.find((candidate) => !candidateFileName(candidate).match(/\.(cmd|bat)$/i)) ?? normalized[0];
+}
+function isExecutablePathCandidate(candidate) {
+  if (process.platform === "win32") return existsSync(candidate);
+  try {
+    accessSync(candidate, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function scanPath(name) {
+  const pathValue = process.env.PATH;
+  const searchDirs = [
+    ...process.platform === "win32" ? [process.cwd()] : [],
+    ...pathValue ? pathValue.split(delimiter) : []
+  ].filter(Boolean);
+  if (searchDirs.length === 0) return void 0;
+  const extensions = process.platform === "win32" ? [
+    ".exe",
+    ...new Set(
+      (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean)
+    ),
+    ""
+  ] : [""];
+  const candidates = [];
+  for (const dir of new Set(searchDirs)) {
+    for (const ext of extensions) {
+      const candidate = join(dir, `${name}${ext}`);
+      if (isExecutablePathCandidate(candidate)) candidates.push(candidate);
+    }
+  }
+  return chooseBestPathCandidate(name, candidates);
+}
+var COMMON_BIN_DIRS = process.platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/snap/bin"];
+function findInCommonDirsOrInstallerPackage(name) {
+  for (const dir of COMMON_BIN_DIRS) {
+    const candidate = `${dir}/${name}`;
+    if (existsSync(candidate)) return candidate;
+  }
+  return findInInstallerPackage(name);
+}
+function binaryFileName(name) {
+  return process.platform === "win32" ? `${name}.exe` : name;
+}
+function findInProjectLocalBin(name) {
+  const candidate = resolve(".hyperframes", "bin", binaryFileName(name));
+  return existsSync(candidate) ? candidate : void 0;
+}
+function tryResolve(fromFile, request) {
+  try {
+    return createRequire(fromFile).resolve(request);
+  } catch {
+    return void 0;
+  }
+}
+function findInInstallerPackage(name) {
+  const project = resolve("package.json");
+  const platformManifest = `@${name}-installer/${process.platform}-${process.arch}/package.json`;
+  const installer = tryResolve(project, `@${name}-installer/${name}/package.json`);
+  const manifest = (installer && tryResolve(installer, platformManifest)) ?? tryResolve(project, platformManifest);
+  const candidate = manifest && join(dirname(manifest), binaryFileName(name));
+  return candidate && isExecutablePathCandidate(candidate) ? candidate : void 0;
+}
+function searchSystem(name) {
+  let found;
+  if (process.platform === "win32") {
+    found = scanPath(name);
+  } else {
+    try {
+      const output = execFileSync("which", [name], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      const candidate = chooseBestPathCandidate(name, output.split(/\r?\n/));
+      found = candidate && isExecutablePathCandidate(candidate) ? candidate : scanPath(name);
+    } catch {
+      found = scanPath(name);
+    }
+  }
+  found ??= findInProjectLocalBin(name);
+  found ??= findInCommonDirsOrInstallerPackage(name);
+  return found;
+}
+function lookupOnSystem(name) {
+  const cached = pathLookupCache.get(name);
+  if (cached) return cached;
+  if (Date.now() - (lastMissAt.get(name) ?? -Infinity) < MISS_TTL_MS) return void 0;
+  const found = searchSystem(name);
+  if (!found) {
+    lastMissAt.set(name, Date.now());
+    return void 0;
+  }
+  const resolved = resolve(found);
+  pathLookupCache.set(name, resolved);
+  return resolved;
+}
+function findFfBinary(name, options = {}) {
+  const configured = process.env[ENV_BY_NAME[name]]?.trim();
+  if (configured) {
+    if (options.configuredMustExist && !existsSync(configured)) return void 0;
+    return resolve(configured);
+  }
+  return lookupOnSystem(name);
+}
+
+export {
+  FFMPEG_PATH_ENV,
+  FFPROBE_PATH_ENV,
+  findFfBinary
+};

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

@@ -0,0 +1,27 @@
+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);
+
+// ../core/dist/tokenSlug.js
+function slugify(name) {
+  const collapsed = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  let start = 0;
+  let end = collapsed.length;
+  while (start < end && collapsed[start] === "-")
+    start++;
+  while (end > start && collapsed[end - 1] === "-")
+    end--;
+  const slug = collapsed.slice(start, end);
+  return slug.length > 0 ? slug : "node";
+}
+function cssVariableName(id) {
+  return `--${slugify(id)}`;
+}
+
+export {
+  slugify,
+  cssVariableName
+};