@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

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

@@ -0,0 +1,514 @@
+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 {
+  CACHE_DIR,
+  PINNED_PACKAGES,
+  install,
+  installedPackagePath,
+  isInstalled,
+  pinnedPackageBesideCli,
+  runNpm,
+  sweepStaleStaging
+} from "./chunk-VMC4WSH5.js";
+import {
+  emitWords,
+  getPreparedWavDurationSeconds,
+  prepareWav
+} from "./chunk-HTUHQKDB.js";
+import {
+  stoppedByCancelSignal
+} from "./chunk-HFQ4CWHA.js";
+import {
+  verifies
+} from "./chunk-HPDTCOKE.js";
+import {
+  resolveWritePath
+} from "./chunk-EOVYQ3IG.js";
+import {
+  PARAKEET_MODEL_LABEL,
+  SHERPA_ERROR_PREFIX,
+  SHERPA_RESULT_PREFIX,
+  SHERPA_WINDOW_PREFIX,
+  mergeWindowsToWords,
+  writeParakeetTranscript
+} from "./chunk-II3J3WXK.js";
+
+// src/whisper/sherpa.ts
+import { execFile, spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync2, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+
+// src/cloud/download.ts
+import { chmodSync, mkdirSync, mkdtempSync, renameSync, rmSync, statSync } from "fs";
+import { open } from "fs/promises";
+import { dirname, join } from "path";
+import { setTimeout as sleep } from "timers/promises";
+var PART_BYTES = 8 * 1024 * 1024;
+var CONNECTIONS = 8;
+var RETRIES = 3;
+async function downloadToFile(url, destPath, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const partBytes = options.partBytes ?? PART_BYTES;
+  const failFast = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, failFast.signal]) : failFast.signal;
+  const get = async (range) => fetchImpl(url, { signal, headers: range ? { range } : {} });
+  let first = await get(`bytes=0-${partBytes - 1}`);
+  if (first.status === 416 || first.status === 206 && contentRangeTotal(first) === void 0) {
+    await first.body?.cancel();
+    first = await get();
+  }
+  assertOk(first, url);
+  const ranged = first.status === 206;
+  const total = ranged ? contentRangeTotal(first) : contentLength(first);
+  mkdirSync(dirname(destPath), { recursive: true });
+  const destination = resolveWritePath(destPath);
+  const previous = statSync(destination, { throwIfNoEntry: false });
+  const stage = mkdtempSync(join(dirname(destination), ".hf-download-"));
+  const stagedFile = join(stage, "download");
+  let bytes = 0;
+  let firstError;
+  try {
+    const file = await open(stagedFile, "wx");
+    const pump = async (res, part) => {
+      for await (const chunk of res.body) {
+        await file.write(chunk, 0, chunk.byteLength, part.at);
+        part.at += chunk.byteLength;
+        bytes += chunk.byteLength;
+        signal.throwIfAborted();
+        options.onProgress?.(bytes, total);
+      }
+    };
+    const fetchRange = async (start, end, res) => {
+      const part = { at: start };
+      for (let attempt = 0; ; attempt++) {
+        try {
+          res ??= await get(`bytes=${part.at}-${end}`);
+          assertOk(res, url);
+          if (res.status !== 206) throw new Error(`Failed to download ${url}: range ignored`);
+          await pump(res, part);
+          if (part.at > end) return;
+          throw new Error(`connection closed at byte ${part.at}`);
+        } catch (error) {
+          if (signal.aborted) throw error;
+          if (attempt === RETRIES) {
+            throw new Error(
+              `Failed to download ${url}: bytes ${start}-${end} dropped ${RETRIES + 1} times`,
+              { cause: error }
+            );
+          }
+          res?.body?.cancel().catch(() => {
+          });
+          res = void 0;
+          await sleep(250 * 2 ** attempt, void 0, { signal });
+        }
+      }
+    };
+    const parts = [];
+    if (ranged && total !== void 0) {
+      parts.push(fetchRange(0, Math.min(partBytes, total) - 1, first));
+      const rest = total - partBytes;
+      const size = Math.ceil(rest / Math.min(CONNECTIONS - 1, Math.ceil(rest / partBytes)));
+      for (let start = partBytes; start < total; start += size) {
+        parts.push(fetchRange(start, Math.min(start + size, total) - 1));
+      }
+    } else {
+      const part = { at: 0 };
+      parts.push(
+        pump(first, part).then(() => {
+          if (total !== void 0 && part.at !== total) {
+            throw new Error(
+              `Truncated download: got ${part.at} bytes, expected ${total} (content-length). The presigned URL may have expired mid-transfer \u2014 refetch via \`hyperframes cloud get\`.`
+            );
+          }
+        })
+      );
+    }
+    await Promise.all(
+      parts.map(
+        (part) => part.catch((error) => {
+          firstError ??= error;
+          failFast.abort(error);
+        })
+      )
+    );
+    await file.close();
+    if (firstError !== void 0) throw firstError;
+    options.signal?.throwIfAborted();
+    if (previous?.isFile()) chmodSync(stagedFile, previous.mode & 511);
+    renameSync(stagedFile, destination);
+  } catch (error) {
+    const reason = options.signal?.reason;
+    if (options.signal?.aborted && reason instanceof Error) throw reason;
+    throw error;
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+  return { path: destPath, bytes };
+}
+function assertOk(res, url) {
+  if (!res.ok) {
+    throw new Error(`Failed to download ${url}: HTTP ${res.status} ${res.statusText}`);
+  }
+  if (!res.body) {
+    throw new Error(`Failed to download ${url}: empty response body`);
+  }
+}
+function contentLength(res) {
+  const total = Number.parseInt(res.headers.get("content-length") ?? "", 10);
+  return Number.isFinite(total) ? total : void 0;
+}
+function contentRangeTotal(res) {
+  const match = /^bytes \d+-\d+\/(\d+)$/.exec(res.headers.get("content-range") ?? "");
+  return match ? Number(match[1]) : void 0;
+}
+
+// src/whisper/sherpa.ts
+var RUNTIME = "sherpa-onnx-node";
+var RUNTIME_VERSION = PINNED_PACKAGES[RUNTIME];
+var SHERPA_RUNTIME_DIR = join2(
+  CACHE_DIR,
+  `${RUNTIME}@${RUNTIME_VERSION}-${process.platform}-${process.arch}`
+);
+var MODEL_REPO = "csukuangfj/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8";
+var MODEL_REVISION = "2bda32ec70b097a55adaa07d9a7173915b43cc78";
+var PARAKEET_MODEL_DIR = join2(
+  homedir(),
+  ".cache",
+  "hyperframes",
+  "parakeet",
+  "parakeet-tdt-0.6b-v3-int8"
+);
+var PARAKEET_MODEL_FILES = [
+  {
+    name: "encoder.int8.onnx",
+    bytes: 652184281,
+    sha256: "acfc2b4456377e15d04f0243af540b7fe7c992f8d898d751cf134c3a55fd2247"
+  },
+  {
+    name: "decoder.int8.onnx",
+    bytes: 11845275,
+    sha256: "179e50c43d1a9de79c8a24149a2f9bac6eb5981823f2a2ed88d655b24248db4e"
+  },
+  {
+    name: "joiner.int8.onnx",
+    bytes: 6355277,
+    sha256: "3164c13fc2821009440d20fcb5fdc78bff28b4db2f8d0f0b329101719c0948b3"
+  },
+  {
+    name: "tokens.txt",
+    bytes: 93939,
+    sha256: "d58544679ea4bc6ac563d1f545eb7d474bd6cfa467f0a6e2c1dc1c7d37e3c35d"
+  }
+];
+var decodeTimeoutMs = (audioSeconds) => Math.min(2 ** 31 - 1, Math.max(18e5, Math.ceil(audioSeconds * 2e3)));
+var SUPPORTED_TARGETS = [
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-x64",
+  "linux-arm64",
+  "win32-x64",
+  "win32-ia32"
+];
+function currentHost() {
+  const report = process.report.getReport();
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    glibc: report.header?.glibcVersionRuntime
+  };
+}
+function sherpaUnsupportedReason(host = currentHost()) {
+  const target = `${host.platform}-${host.arch}`;
+  if (!SUPPORTED_TARGETS.includes(target)) {
+    return `Parakeet runs on ${SUPPORTED_TARGETS.join(", ")}; this system is ${target}.`;
+  }
+  if (host.platform !== "linux") return null;
+  if (!host.glibc) return "Parakeet needs glibc 2.32 or newer; this Linux has no glibc (musl?).";
+  const [major = 0, minor = 0] = host.glibc.split(".").map(Number);
+  if (major > 2 || major === 2 && minor >= 32) return null;
+  return `Parakeet needs glibc 2.32 or newer; this system has glibc ${host.glibc}.`;
+}
+var nativePackageName = (platform, arch) => `sherpa-onnx-${platform === "win32" ? "win" : platform}-${arch}`;
+var LOAD_RUNTIME = `try {
+  require(process.env.HF_SHERPA_RUNTIME_PATH);
+} catch (e) {
+  process.stderr.write(String(e && e.message).replace(/\\s+/g, " "));
+  process.exitCode = 1;
+}`;
+function runtimeLoadError(runtimePath, timeoutMs, signal) {
+  if (signal?.aborted)
+    return Promise.reject(new DecodeCancelled("Parakeet runtime check cancelled"));
+  return new Promise((resolve, reject) => {
+    const probe = spawn(process.execPath, ["-e", LOAD_RUNTIME], {
+      env: { ...process.env, HF_SHERPA_RUNTIME_PATH: runtimePath },
+      stdio: ["ignore", "ignore", "pipe"],
+      timeout: timeoutMs,
+      signal
+    });
+    let stderr = "";
+    probe.stderr.setEncoding("utf8");
+    probe.stderr.on("data", (chunk) => {
+      stderr = bounded(stderr + chunk);
+    });
+    probe.on("error", (error) => {
+      if (signal?.aborted) reject(new DecodeCancelled("Parakeet runtime check cancelled"));
+      else resolve(bounded(error.message));
+    });
+    probe.on("close", (code, childSignal) => {
+      if (signal?.aborted || stoppedByCancelSignal({ code, signal: childSignal, killed: probe.killed })) {
+        reject(new DecodeCancelled("Parakeet runtime check cancelled"));
+        return;
+      }
+      if (code === 0 && !probe.killed) {
+        resolve(null);
+        return;
+      }
+      let reason;
+      if (probe.killed) reason = `loading it timed out after ${timeoutMs / 1e3} s`;
+      else if (childSignal) reason = `loading it crashed (${childSignal})`;
+      else reason = `it exited ${code} with no output`;
+      resolve(bounded(stderr.trim() || reason));
+    });
+  });
+}
+async function cachedRuntime(dir, timeoutMs, signal) {
+  let path;
+  try {
+    path = installedPackagePath(dir, RUNTIME);
+  } catch (err) {
+    return {
+      status: "unavailable",
+      error: bounded(err instanceof Error ? err.message : String(err))
+    };
+  }
+  if (path === null)
+    return { status: "unavailable", error: `${RUNTIME} is not installed in ${dir}` };
+  const error = await runtimeLoadError(path, timeoutMs, signal);
+  return error === null ? { status: "ready", path } : { status: "unavailable", error };
+}
+async function selectRuntime(dir, cliUrl, timeoutMs = 6e4, signal) {
+  if (signal?.aborted) throw new DecodeCancelled("Parakeet runtime check cancelled");
+  const copy = pinnedPackageBesideCli(RUNTIME, cliUrl);
+  if (copy !== null) {
+    const path = copy.path;
+    const error = await runtimeLoadError(path, timeoutMs, signal);
+    if (error === null) return { status: "ready", path };
+    console.error(
+      `Parakeet runtime at ${path.replace(/\s+/g, " ")} did not load: ${error.replace(/\s+/g, " ")}`
+    );
+  }
+  return cachedRuntime(dir, timeoutMs, signal);
+}
+async function sherpaRuntimeLoadError(dir = SHERPA_RUNTIME_DIR, timeoutMs = 6e4, cliUrl = import.meta.url, signal) {
+  const selected = await selectRuntime(dir, cliUrl, timeoutMs, signal);
+  return selected.status === "ready" ? null : selected.error;
+}
+function sherpaPlatformPackage(platform = process.platform, arch = process.arch) {
+  return `${nativePackageName(platform, arch)}@${RUNTIME_VERSION}`;
+}
+async function installSherpaRuntime({
+  run = runNpm,
+  signal,
+  dir = SHERPA_RUNTIME_DIR,
+  cliUrl = import.meta.url
+} = {}) {
+  const present = await selectRuntime(dir, cliUrl, 6e4, signal);
+  if (present.status === "ready") return { installed: false, runtimePath: present.path };
+  rmSync2(dir, { recursive: true, force: true });
+  const native = sherpaPlatformPackage();
+  await install(dir, RUNTIME, RUNTIME_VERSION, (args) => run([...args, native], signal));
+  const selected = await cachedRuntime(dir, 6e4, signal);
+  if (selected.status === "unavailable") {
+    throw new Error(
+      `The sherpa-onnx runtime was reinstalled but still does not load (${selected.error}). Use --engine whisper for now.`
+    );
+  }
+  return { installed: true, runtimePath: selected.path };
+}
+function sherpaParakeetInstalled(cliUrl = import.meta.url) {
+  return (pinnedPackageBesideCli(RUNTIME, cliUrl) !== null || isInstalled(SHERPA_RUNTIME_DIR, RUNTIME)) && PARAKEET_MODEL_FILES.every(
+    (f) => statSync2(join2(PARAKEET_MODEL_DIR, f.name), { throwIfNoEntry: false })?.size === f.bytes
+  );
+}
+async function ensureParakeetModel({
+  dir = PARAKEET_MODEL_DIR,
+  files = PARAKEET_MODEL_FILES,
+  download = downloadToFile,
+  onBytes,
+  signal
+} = {}) {
+  sweepStaleStaging(dir);
+  const missing = [];
+  for (const file of files) if (!await verifies(join2(dir, file.name), file)) missing.push(file);
+  const total = missing.reduce((sum, f) => sum + f.bytes, 0);
+  const staging = `${dir}.tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+  let done = 0;
+  try {
+    for (const file of missing) {
+      signal?.throwIfAborted();
+      const dest = join2(dir, file.name);
+      const temp = join2(staging, file.name);
+      rmSync2(dest, { force: true });
+      const url = `https://huggingface.co/${MODEL_REPO}/resolve/${MODEL_REVISION}/${file.name}`;
+      await download(url, temp, {
+        signal,
+        onProgress: (bytes) => onBytes?.(done + bytes, total)
+      }).catch((err) => {
+        if (signal?.aborted) throw err;
+        const why = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Could not download ${file.name} from huggingface.co (${why}). Check your network and re-run.`,
+          { cause: err }
+        );
+      });
+      if (!await verifies(temp, file)) {
+        throw new Error(
+          `${file.name} did not match its pinned size and sha256, so it was discarded. Re-run to retry.`
+        );
+      }
+      mkdirSync2(dir, { recursive: true });
+      renameSync2(temp, dest);
+      done += file.bytes;
+    }
+  } finally {
+    rmSync2(staging, { recursive: true, force: true });
+  }
+  return missing.length > 0;
+}
+function recognizerConfig() {
+  const [encoder, decoder, joiner, tokens] = PARAKEET_MODEL_FILES.map(
+    (f) => join2(PARAKEET_MODEL_DIR, f.name)
+  );
+  return {
+    featConfig: { sampleRate: 16e3, featureDim: 80 },
+    modelConfig: {
+      transducer: { encoder, decoder, joiner },
+      tokens,
+      numThreads: 4,
+      provider: "cpu",
+      debug: 0,
+      modelType: "nemo_transducer"
+    },
+    decodingMethod: "greedy_search"
+  };
+}
+var DecodeCancelled = class extends Error {
+};
+var MAX_REASON_CHARS = 600;
+var bounded = (why) => why.length > MAX_REASON_CHARS ? `${why.slice(0, MAX_REASON_CHARS)}\u2026` : why;
+function failureReason(err, stderr) {
+  const how = !err ? "exited without a result" : err.killed ? "was stopped (timeout or output limit)" : err.signal ? `crashed (${err.signal})` : `exited with code ${err.code}`;
+  const lines = stderr.split("\n").map((line) => line.trim()).filter(Boolean);
+  const why = lines.find((line) => line.startsWith(SHERPA_ERROR_PREFIX))?.slice(SHERPA_ERROR_PREFIX.length) ?? lines.at(-1);
+  if (!why) return how;
+  return `${how}: ${bounded(why)}`;
+}
+function decode(wavPath, runtimePath, signal, onWindow) {
+  const sourceMode = import.meta.url.endsWith(".ts");
+  const worker = new URL(sourceMode ? "./sherpaWorker.ts" : "./sherpaWorker.js", import.meta.url);
+  const args = [...sourceMode ? ["--import", "tsx"] : [], fileURLToPath(worker)];
+  const input = { wavPath, runtimePath, config: recognizerConfig() };
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      process.execPath,
+      args,
+      {
+        env: { ...process.env, HYPERFRAMES_PARAKEET_INPUT: JSON.stringify(input) },
+        maxBuffer: 256 * 1024 * 1024,
+        timeout: decodeTimeoutMs(getPreparedWavDurationSeconds(wavPath) ?? 0),
+        signal
+      },
+      (err, stdout, stderr) => {
+        if (signal.aborted || err && stoppedByCancelSignal(err)) {
+          reject(new DecodeCancelled("Transcription cancelled"));
+          return;
+        }
+        const line = stdout.split("\n").find((l) => l.startsWith(SHERPA_RESULT_PREFIX));
+        if (!err && line) resolve(JSON.parse(line.slice(SHERPA_RESULT_PREFIX.length)));
+        else reject(new Error(`Parakeet decoder ${failureReason(err, stderr)}`));
+      }
+    );
+    if (onWindow && child.stdout) {
+      createInterface({ input: child.stdout }).on("line", (l) => {
+        if (!l.startsWith(SHERPA_WINDOW_PREFIX)) return;
+        let streamed;
+        try {
+          streamed = JSON.parse(l.slice(SHERPA_WINDOW_PREFIX.length));
+        } catch {
+          return;
+        }
+        onWindow(streamed.window, streamed.through);
+      });
+    }
+  });
+}
+async function prepareSherpaWav(inputPath, onProgress, signal) {
+  try {
+    return await prepareWav(inputPath, onProgress, signal);
+  } catch (err) {
+    if (err.cancelled) {
+      throw new DecodeCancelled("Transcription cancelled");
+    }
+    throw err;
+  }
+}
+async function transcribeWithSherpa(wavPath, dir, options) {
+  options.onProgress?.("Transcribing with Parakeet...");
+  options.onEvent?.({
+    type: "progress",
+    phase: "transcription",
+    model: PARAKEET_MODEL_LABEL,
+    status: "started",
+    durationSeconds: getPreparedWavDurationSeconds(wavPath)
+  });
+  if (options.signal.aborted) throw new DecodeCancelled("Transcription cancelled");
+  const selected = await selectRuntime(
+    options.runtimeDir ?? SHERPA_RUNTIME_DIR,
+    options.cliUrl ?? import.meta.url,
+    6e4,
+    options.signal
+  );
+  if (selected.status === "unavailable") {
+    throw new Error(
+      `Parakeet runtime does not load (${selected.error}). Run framey models install parakeet to repair it, or use --engine whisper.`
+    );
+  }
+  const onEvent = options.onEvent;
+  const windows = await decode(
+    wavPath,
+    selected.path,
+    options.signal,
+    onEvent && ((window, through) => emitWords(onEvent, PARAKEET_MODEL_LABEL, mergeWindowsToWords([window]), through))
+  );
+  const result = writeParakeetTranscript(dir, mergeWindowsToWords(windows));
+  options.onEvent?.({
+    type: "progress",
+    phase: "transcription",
+    model: result.model,
+    status: "completed"
+  });
+  return result;
+}
+
+export {
+  SHERPA_RUNTIME_DIR,
+  PARAKEET_MODEL_DIR,
+  decodeTimeoutMs,
+  sherpaUnsupportedReason,
+  sherpaRuntimeLoadError,
+  sherpaPlatformPackage,
+  installSherpaRuntime,
+  sherpaParakeetInstalled,
+  ensureParakeetModel,
+  DecodeCancelled,
+  prepareSherpaWav,
+  transcribeWithSherpa
+};