@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

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

@@ -0,0 +1,59 @@
+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 {
+  VERSION
+} from "./chunk-AHX34EFP.js";
+
+// src/registry/compatibility.ts
+import { compareVersions } from "compare-versions";
+var DEV_VERSION = "0.0.0-dev";
+function checkRegistryItemCompatibility(item, currentCliVersion = VERSION) {
+  const warnings = [];
+  if (item.deprecated) {
+    warnings.push(`Registry item "${item.name}" is deprecated: ${item.deprecated}`);
+  }
+  const minCliVersion = item.minCliVersion?.trim();
+  if (!minCliVersion || currentCliVersion === DEV_VERSION) {
+    return { warnings };
+  }
+  try {
+    if (compareVersions(currentCliVersion, minCliVersion) >= 0) {
+      return { warnings };
+    }
+  } catch {
+    return {
+      warnings,
+      error: `Registry item "${item.name}" declares invalid minCliVersion "${minCliVersion}".`
+    };
+  }
+  return {
+    warnings,
+    error: `Registry item "${item.name}" requires framey >= ${minCliVersion} (current: ${currentCliVersion}). Rebuild Framey from a newer checkout to add it.`
+  };
+}
+var RegistryCompatibilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryCompatibilityError";
+  }
+};
+function gateRegistryItemsCompatibility(items, currentCliVersion = VERSION) {
+  const warnings = [];
+  for (const item of items) {
+    const result = checkRegistryItemCompatibility(item, currentCliVersion);
+    if (result.error) {
+      throw new RegistryCompatibilityError(result.error);
+    }
+    warnings.push(...result.warnings);
+  }
+  return warnings;
+}
+
+export {
+  RegistryCompatibilityError,
+  gateRegistryItemsCompatibility
+};

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

@@ -0,0 +1,40 @@
+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 {
+  findCompositionDimensions
+} from "./chunk-LEKZNRKI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+
+// src/commands/lambda/_dimensions.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function warnOnDimensionMismatch(args) {
+  if (args.quiet) return;
+  if (args.outputResolution) return;
+  let html;
+  try {
+    html = readFileSync(join(args.projectDir, "index.html"), "utf-8");
+  } catch {
+    return;
+  }
+  const composition = findCompositionDimensions(html);
+  if (!composition) return;
+  if (composition.width === args.cliWidth && composition.height === args.cliHeight) return;
+  console.warn(
+    c.warn(
+      `--width/--height (${args.cliWidth}\xD7${args.cliHeight}) disagrees with the composition's data-width/data-height (${composition.width}\xD7${composition.height}). The runtime lays out the page at the composition's authored dimensions, so your output will be ${composition.width}\xD7${composition.height}, not ${args.cliWidth}\xD7${args.cliHeight}.
+  To supersample to a higher resolution, pass --output-resolution (e.g. \`--output-resolution=4k\`).
+  To truly change layout dimensions, edit the composition's data-width/data-height in index.html.`
+    )
+  );
+}
+
+export {
+  warnOnDimensionMismatch
+};

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

@@ -0,0 +1,170 @@
+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/commands/lambda/sam.ts
+import { execFileSync, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function assertSamAvailable() {
+  try {
+    execFileSync("sam", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "`sam` CLI not found on PATH. Install AWS SAM CLI from https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html and retry."
+    );
+  }
+}
+function assertAwsCliAvailable() {
+  try {
+    execFileSync("aws", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "`aws` CLI not found on PATH. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html and configure credentials before retrying."
+    );
+  }
+}
+function locateSamTemplate(repoRoot) {
+  const candidate = join(repoRoot, "examples", "aws-lambda", "template.yaml");
+  if (!existsSync(candidate)) {
+    throw new Error(
+      `[lambda] SAM template not found at ${candidate}. \`framey lambda deploy\` needs a Framey repo checkout: run it from one, or set HYPERFRAMES_REPO_ROOT to point at one.`
+    );
+  }
+  return candidate;
+}
+function parseReservedConcurrency(raw) {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  if (raw === "none") return -1;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(
+      `[lambda] --concurrency must be a positive integer or "none"; got ${String(raw)}`
+    );
+  }
+  return n;
+}
+function samDeploy(opts) {
+  assertSamAvailable();
+  const paramOverrides = [
+    `ChromeSource=${opts.chromeSource ?? "sparticuz"}`,
+    // Always sent: omitted, SAM's UsePreviousValue would keep a video function the user dropped.
+    `VideoImageUri=${opts.videoImageUri ?? '""'}`
+  ];
+  if (opts.reservedConcurrency !== void 0) {
+    paramOverrides.push(`ReservedConcurrency=${opts.reservedConcurrency}`);
+  }
+  if (opts.lambdaMemoryMb !== void 0) {
+    paramOverrides.push(`LambdaMemoryMb=${opts.lambdaMemoryMb}`);
+  }
+  const args = [
+    "deploy",
+    "--stack-name",
+    opts.stackName,
+    "--region",
+    opts.region,
+    "--resolve-s3",
+    "--capabilities",
+    "CAPABILITY_IAM",
+    "--no-confirm-changeset",
+    "--no-fail-on-empty-changeset",
+    "--parameter-overrides",
+    ...paramOverrides
+  ];
+  if (opts.awsProfile) {
+    args.push("--profile", opts.awsProfile);
+  }
+  const result = spawnSync("sam", args, { cwd: opts.samDir, stdio: opts.stdio ?? "inherit" });
+  if (result.status !== 0) {
+    throw new Error(
+      `[lambda] sam deploy exited with code ${result.status ?? "unknown"}
+If a prior attempt left a stack in ROLLBACK_COMPLETE, CloudFormation can't reuse it. Delete it before retrying:
+  aws cloudformation delete-stack --stack-name aws-sam-cli-managed-default --region ${opts.region}
+  aws cloudformation delete-stack --stack-name ${opts.stackName} --region ${opts.region}
+(the first is SAM's managed artifacts stack from --resolve-s3; the second is the render stack).`
+    );
+  }
+}
+function samDelete(opts) {
+  assertSamAvailable();
+  const args = ["delete", "--stack-name", opts.stackName, "--region", opts.region, "--no-prompts"];
+  if (opts.awsProfile) {
+    args.push("--profile", opts.awsProfile);
+  }
+  const result = spawnSync("sam", args, { cwd: opts.samDir, stdio: opts.stdio ?? "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`[lambda] sam delete exited with code ${result.status ?? "unknown"}`);
+  }
+}
+function fetchStackOutputs(opts) {
+  assertAwsCliAvailable();
+  const args = [
+    "cloudformation",
+    "describe-stacks",
+    "--stack-name",
+    opts.stackName,
+    "--region",
+    opts.region,
+    "--query",
+    "Stacks[0]",
+    "--output",
+    "json"
+  ];
+  if (opts.awsProfile) {
+    args.unshift("--profile", opts.awsProfile);
+  }
+  const out = execFileSync("aws", args, { encoding: "utf-8" });
+  const stack = JSON.parse(out);
+  const byKey = new Map((stack.Outputs ?? []).map((o) => [o.OutputKey, o.OutputValue]));
+  const reserved = Number(
+    stack.Parameters?.find((p) => p.ParameterKey === "ReservedConcurrency")?.ParameterValue
+  );
+  const bucketName = byKey.get("RenderBucketName");
+  const functionName = byKey.get("RenderFunctionArn");
+  const stateMachineArn = byKey.get("RenderStateMachineArn");
+  if (!bucketName || !functionName || !stateMachineArn) {
+    throw new Error(
+      `[lambda] stack ${opts.stackName} is missing one of RenderBucketName/RenderFunctionArn/RenderStateMachineArn. Got keys: ${[...byKey.keys()].join(", ")}`
+    );
+  }
+  return {
+    bucketName,
+    // RenderFunctionArn is the full ARN; the Lambda function name is the
+    // last colon-segment, which downstream `getRenderProgress` calls use
+    // for cost math + CloudWatch lookups.
+    functionName: functionName.split(":").pop() ?? functionName,
+    stateMachineArn,
+    reservedConcurrency: reserved > 0 ? reserved : void 0,
+    videoFunctionName: byKey.get("VideoFunctionArn")?.split(":").pop()
+  };
+}
+function deleteEcrRepository(opts) {
+  assertAwsCliAvailable();
+  const args = [
+    "ecr",
+    "delete-repository",
+    "--repository-name",
+    opts.repositoryName,
+    "--force",
+    "--region",
+    opts.region
+  ];
+  if (opts.awsProfile) args.push("--profile", opts.awsProfile);
+  const result = spawnSync("aws", args, { encoding: "utf-8" });
+  if (result.status === 0 || result.stderr?.includes("RepositoryNotFoundException")) return;
+  throw new Error(
+    `[lambda] aws ecr delete-repository ${opts.repositoryName} exited with code ${result.status ?? "unknown"}: ${result.stderr ?? ""}`
+  );
+}
+
+export {
+  locateSamTemplate,
+  parseReservedConcurrency,
+  samDeploy,
+  samDelete,
+  fetchStackOutputs,
+  deleteEcrRepository
+};

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

@@ -0,0 +1,118 @@
+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 {
+  setHostHandlesSigint
+} from "./chunk-TIQB63MX.js";
+import {
+  processAncestorSnapshot,
+  processIdentity,
+  processParentPid
+} from "./chunk-LTGTN2TH.js";
+import {
+  processIsAlive
+} from "./chunk-KGPLIH7B.js";
+
+// src/utils/renderCancellation.ts
+var RENDER_CANCELLATION_SIGNALS = [
+  "SIGINT",
+  "SIGTERM",
+  "SIGHUP"
+];
+function stoppedByCancelSignal(stop) {
+  if (stop.code || stop.killed || stop.error) return false;
+  return RENDER_CANCELLATION_SIGNALS.some((signal) => signal === stop.signal);
+}
+function captureAncestors(pid, lookupParentPid, lookupIdentity, isAlive) {
+  const ancestors = [];
+  const visited = /* @__PURE__ */ new Set([pid]);
+  let current = pid;
+  for (let depth = 0; depth < 64; depth++) {
+    const parent = lookupParentPid(current);
+    if (parent === null || parent <= 1 || visited.has(parent)) break;
+    visited.add(parent);
+    if (!isAlive(parent)) break;
+    const identity = lookupIdentity(parent);
+    if (identity === null) break;
+    ancestors.push({ pid: parent, identity });
+    current = parent;
+  }
+  return ancestors;
+}
+function captureRenderAncestors(options, platform, pid, lookupIdentity, isAlive) {
+  if (options.detached ?? process.env.HYPERFRAMES_RENDER_DETACHED === "1") return [];
+  if (platform !== "linux" && options.parentPid === void 0 && options.identity === void 0) {
+    return (options.ancestorSnapshot ?? processAncestorSnapshot)(pid);
+  }
+  return captureAncestors(pid, options.parentPid ?? processParentPid, lookupIdentity, isAlive);
+}
+function installSignalHandlers(detached, signalTarget, abort) {
+  const signalHandlers = /* @__PURE__ */ new Map();
+  const handledSignals = detached ? RENDER_CANCELLATION_SIGNALS.filter((signal) => signal !== "SIGHUP") : RENDER_CANCELLATION_SIGNALS;
+  for (const signal of handledSignals) {
+    const handler = () => abort(`render_cancelled_by_${signal.toLowerCase()}`);
+    signalHandlers.set(signal, handler);
+    signalTarget.on(signal, handler);
+  }
+  return signalHandlers;
+}
+function createRenderCancellationScope(options = {}) {
+  const controller = new AbortController();
+  const signalTarget = options.signalTarget ?? process;
+  const abort = (reason) => {
+    if (!controller.signal.aborted) controller.abort(new Error(reason));
+  };
+  const detached = options.detached ?? process.env.HYPERFRAMES_RENDER_DETACHED === "1";
+  const signalHandlers = installSignalHandlers(detached, signalTarget, abort);
+  setHostHandlesSigint(true);
+  const lookupIdentity = options.identity ?? processIdentity;
+  const isAlive = options.isAlive ?? processIsAlive;
+  const platform = options.platform ?? process.platform;
+  const pid = options.pid ?? process.pid;
+  const ancestors = captureRenderAncestors(options, platform, pid, lookupIdentity, isAlive);
+  const checkAncestorLiveness = () => {
+    for (const ancestor of ancestors) {
+      if (!isAlive(ancestor.pid)) {
+        abort("render_cancelled_parent_exited");
+        return false;
+      }
+    }
+    return true;
+  };
+  const checkAncestors = () => {
+    if (!checkAncestorLiveness()) return;
+    if (platform !== "linux") return;
+    for (const ancestor of ancestors) {
+      const currentIdentity = lookupIdentity(ancestor.pid);
+      if (currentIdentity !== null && currentIdentity !== ancestor.identity) {
+        abort("render_cancelled_parent_exited");
+        return;
+      }
+    }
+  };
+  const defaultPollIntervalMs = ancestors.length > 0 && platform === "linux" ? 250 : 2e3;
+  const watchdogTimer = setInterval(
+    platform === "linux" ? checkAncestors : () => void checkAncestorLiveness(),
+    options.parentPollIntervalMs ?? defaultPollIntervalMs
+  );
+  let disposed = false;
+  return {
+    signal: controller.signal,
+    checkAncestors,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      if (watchdogTimer !== void 0) clearInterval(watchdogTimer);
+      for (const [signal, handler] of signalHandlers) signalTarget.off(signal, handler);
+      setHostHandlesSigint(false);
+    }
+  };
+}
+
+export {
+  stoppedByCancelSignal,
+  createRenderCancellationScope
+};

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

@@ -0,0 +1,304 @@
+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 {
+  downloadFile
+} from "./chunk-WQ6ZXHFQ.js";
+import {
+  findFFmpeg
+} from "./chunk-UMD3V7CU.js";
+import {
+  stoppableExecFile
+} from "./chunk-HU2SPFNG.js";
+
+// src/whisper/manager.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync as statSync2 } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+
+// src/whisper/modelFile.ts
+import { createHash } from "crypto";
+import { createReadStream, statSync } from "fs";
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function verifies(path, file) {
+  if (statSync(path, { throwIfNoEntry: false })?.size !== file.bytes) return false;
+  return await sha256File(path) === file.sha256;
+}
+
+// src/whisper/manager.ts
+var MODELS_DIR = join(homedir(), ".cache", "hyperframes", "whisper", "models");
+var DEFAULT_MODEL = "small.en";
+var WhisperUnavailableError = class extends Error {
+  code = "WHISPER_UNAVAILABLE";
+  constructor(message) {
+    super(message);
+    this.name = "WhisperUnavailableError";
+  }
+};
+function isWhisperUnavailable(err) {
+  if (err instanceof WhisperUnavailableError) return true;
+  return err instanceof Error && "code" in err && err.code === "WHISPER_UNAVAILABLE";
+}
+var MODEL_REVISION = "5359861c739e955e79d9a303bcbc70fb988958b1";
+function getModelUrl(model) {
+  return `https://huggingface.co/ggerganov/whisper.cpp/resolve/${MODEL_REVISION}/ggml-${model}.bin`;
+}
+var pinned = (model, bytes, sha256) => [
+  model,
+  { name: `ggml-${model}.bin`, bytes, sha256 }
+];
+var PINNED_MODELS = new Map([
+  pinned("tiny", 77691713, "be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21"),
+  pinned("tiny.en", 77704715, "921e4cf8686fdd993dcd081a5da5b6c365bfde1162e72b08d75ac75289920b1f"),
+  pinned("base", 147951465, "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe"),
+  pinned(
+    "base.en",
+    147964211,
+    "a03779c86df3323075f5e796cb2ce5029f00ec8869eee3fdfb897afe36c6d002"
+  ),
+  pinned("small", 487601967, "1be3a9b2063867b937e64e2ec7483364a79917e157fa98c5d94b5c1fffea987b"),
+  pinned(
+    "small.en",
+    487614201,
+    "c6138d6d58ecc8322097e0f987c32f1be8bb0a18532a3f88f734d1bbf9c41e5d"
+  ),
+  pinned(
+    "medium",
+    1533763059,
+    "6c14d5adee5f86394037b4e4e8b59f1673b6cee10e3cf0b11bbdbee79c156208"
+  ),
+  pinned(
+    "medium.en",
+    1533774781,
+    "cc37e93478338ec7700281a7ac30a10128929eb8f427dda2e865faa8f6da4356"
+  ),
+  pinned(
+    "large-v1",
+    3094623691,
+    "7d99f41a10525d0206bddadd86760181fa920438b6b33237e3118ff6c83bb53d"
+  ),
+  pinned(
+    "large-v2",
+    3094623691,
+    "9a423fe4d40c82774b6af34115b8b935f34152246eb19e80e376071d3f999487"
+  ),
+  pinned(
+    "large-v3",
+    3095033483,
+    "64d182b440b98d5203c4f9bd541544d84c605196c4f7b845dfa11fb23594d1e2"
+  ),
+  pinned(
+    "large-v3-turbo",
+    1624555275,
+    "1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69"
+  )
+]);
+function pinnedWhisperModel(model) {
+  return PINNED_MODELS.get(model);
+}
+function whichBinary(name) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const output = execFileSync(cmd, [name], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    const first = output.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+    return first || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function findFromEnv() {
+  const envPath = process.env["HYPERFRAMES_WHISPER_PATH"];
+  if (envPath && existsSync(envPath)) {
+    return { executablePath: envPath, source: "env" };
+  }
+  return void 0;
+}
+function findFromSystem() {
+  const path = whichBinary("whisper-cli");
+  if (path) return { executablePath: path, source: "system" };
+  if (platform() === "darwin") {
+    for (const p of ["/opt/homebrew/bin/whisper-cli", "/usr/local/bin/whisper-cli"]) {
+      if (existsSync(p)) return { executablePath: p, source: "system" };
+    }
+  }
+  return void 0;
+}
+var BUILD_DIR = join(homedir(), ".cache", "hyperframes", "whisper", "whisper.cpp");
+var WHISPER_REPO = "https://github.com/ggml-org/whisper.cpp.git";
+function findBuiltBinary() {
+  for (const p of [
+    join(BUILD_DIR, "build", "bin", "whisper-cli"),
+    join(BUILD_DIR, "build", "whisper-cli")
+  ]) {
+    if (existsSync(p)) return { executablePath: p, source: "build" };
+  }
+  return void 0;
+}
+async function buildFromSource(onProgress, signal) {
+  if (existsSync(BUILD_DIR) && !findBuiltBinary()) {
+    rmSync(BUILD_DIR, { recursive: true, force: true });
+  }
+  if (!existsSync(BUILD_DIR)) {
+    onProgress?.("Downloading whisper.cpp...");
+    mkdirSync(join(homedir(), ".cache", "hyperframes", "whisper"), {
+      recursive: true
+    });
+    await stoppableExecFile("git", ["clone", "--depth", "1", WHISPER_REPO, BUILD_DIR], {
+      stdio: "ignore",
+      timeout: 6e4,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+      signal
+    });
+  }
+  onProgress?.("Building whisper.cpp (this may take a minute)...");
+  try {
+    await stoppableExecFile("cmake", ["-B", "build"], {
+      cwd: BUILD_DIR,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4,
+      signal
+    });
+    await stoppableExecFile("cmake", ["--build", "build", "--config", "Release", "-j"], {
+      cwd: BUILD_DIR,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e5,
+      signal
+    });
+  } catch (err) {
+    let detail = "";
+    if (err && typeof err === "object" && "stderr" in err) {
+      const stderr = String(err.stderr).trim();
+      if (stderr) detail = `
+${stderr.slice(-500)}`;
+    }
+    rmSync(BUILD_DIR, { recursive: true, force: true });
+    throw new Error(
+      `whisper-cpp build failed. Ensure cmake and a C compiler are installed.${detail}`
+    );
+  }
+  const result = findBuiltBinary();
+  if (!result) throw new Error("Build completed but whisper-cli not found");
+  return result;
+}
+function findWhisper() {
+  return findFromEnv() ?? findFromSystem() ?? findBuiltBinary();
+}
+function listWhisperModels() {
+  if (!existsSync(MODELS_DIR)) return [];
+  return readdirSync(MODELS_DIR).flatMap((file) => {
+    const model = /^ggml-(.+)\.bin$/.exec(file)?.[1];
+    const path = join(MODELS_DIR, file);
+    return model && existsSync(path) ? [{ model, path }] : [];
+  }).sort((a, b) => a.model.localeCompare(b.model));
+}
+function getInstallInstructions() {
+  if (platform() === "darwin") {
+    return "brew install whisper-cpp";
+  }
+  if (platform() === "linux") {
+    return "Build from source: https://github.com/ggml-org/whisper.cpp#building (requires cmake and a C compiler)";
+  }
+  if (platform() === "win32") {
+    return "Build with cmake: https://github.com/ggml-org/whisper.cpp#building";
+  }
+  return "See https://github.com/ggml-org/whisper.cpp#building";
+}
+function hasBrew() {
+  return whichBinary("brew") !== void 0;
+}
+function hasGit() {
+  return whichBinary("git") !== void 0;
+}
+function hasCmake() {
+  return whichBinary("cmake") !== void 0;
+}
+async function ensureWhisper(options) {
+  const signal = options?.signal;
+  const existing = findWhisper();
+  if (existing) return existing;
+  if (options?.installRuntime === false) {
+    throw new WhisperUnavailableError(
+      "whisper-cpp not found; runtime installation is disabled by --no-runtime-install."
+    );
+  }
+  if (platform() === "darwin" && hasBrew()) {
+    options?.onProgress?.("Installing whisper-cpp via Homebrew...");
+    try {
+      await stoppableExecFile("brew", ["install", "whisper-cpp"], {
+        stdio: "ignore",
+        timeout: 3e5,
+        signal
+      });
+      const installed = findFromSystem();
+      if (installed) return { ...installed, source: "brew" };
+    } catch {
+    }
+    signal?.throwIfAborted();
+  }
+  if (hasGit() && hasCmake()) {
+    try {
+      return await buildFromSource(options?.onProgress, signal);
+    } catch {
+    }
+    signal?.throwIfAborted();
+  }
+  throw new WhisperUnavailableError(`whisper-cpp not found. Install: ${getInstallInstructions()}`);
+}
+async function ensureModel(model = DEFAULT_MODEL, options) {
+  const modelPath = join(MODELS_DIR, `ggml-${model}.bin`);
+  const pin = PINNED_MODELS.get(model);
+  const cachedBytes = statSync2(modelPath, { throwIfNoEntry: false })?.size;
+  if (cachedBytes !== void 0 && (!pin || cachedBytes === pin.bytes)) return modelPath;
+  mkdirSync(MODELS_DIR, { recursive: true });
+  rmSync(modelPath, { force: true });
+  options?.onProgress?.(
+    cachedBytes === void 0 ? `Downloading model ${model}...` : `Model ${model} is incomplete; downloading it again...`
+  );
+  const downloaded = `${modelPath}.${process.pid}.download`;
+  try {
+    await downloadFile(getModelUrl(model), downloaded, {
+      signal: options?.signal,
+      onProgress: options?.onDownloadProgress
+    });
+    if (pin && !await verifies(downloaded, pin)) {
+      throw new Error(
+        `${pin.name} did not match its pinned size and sha256, so it was discarded. Re-run to retry.`
+      );
+    }
+    renameSync(downloaded, modelPath);
+  } finally {
+    rmSync(downloaded, { force: true });
+  }
+  return modelPath;
+}
+function hasFFmpeg() {
+  return findFFmpeg() !== void 0;
+}
+
+export {
+  sha256File,
+  verifies,
+  MODELS_DIR,
+  DEFAULT_MODEL,
+  WhisperUnavailableError,
+  isWhisperUnavailable,
+  pinnedWhisperModel,
+  findWhisper,
+  listWhisperModels,
+  getInstallInstructions,
+  ensureWhisper,
+  ensureModel,
+  hasFFmpeg
+};