@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-7FMUTGOH.js

@@ -0,0 +1,279 @@
+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/fonts/systemFontLocator.js
+import { execFileSync } from "child_process";
+import { existsSync, lstatSync, readdirSync, realpathSync } from "fs";
+import { homedir, platform } from "os";
+import { join, resolve } from "path";
+var SYSTEM_FONT_SIZE_LIMIT = 5 * 1024 * 1024;
+var FC_MATCH_TIMEOUT_MS = 3e3;
+var FONT_EXT_RE = /\.(otf|ttf|ttc|woff2?)$/i;
+var FORMAT_PRIORITY = {
+  woff2: 0,
+  otf: 1,
+  ttf: 2,
+  woff: 3,
+  ttc: 4
+};
+var STYLE_SUFFIXES = /* @__PURE__ */ new Set([
+  "black",
+  "bold",
+  "book",
+  "condensed",
+  "demi",
+  "demibold",
+  "display",
+  "extra",
+  "extrabold",
+  "hairline",
+  "heavy",
+  "italic",
+  "light",
+  "medium",
+  "normal",
+  "regular",
+  "roman",
+  "semibold",
+  "thin",
+  "ultra",
+  "ultralight"
+]);
+var REGULAR_TOKENS = /* @__PURE__ */ new Set(["regular", "roman", "normal", "book"]);
+var cache = /* @__PURE__ */ new Map();
+var allowedDirsCache = null;
+function getAllowedFontDirs() {
+  if (allowedDirsCache)
+    return allowedDirsCache;
+  allowedDirsCache = fontDirectories().filter((d) => existsSync(d)).map((d) => {
+    try {
+      return realpathSync(d);
+    } catch {
+      return resolve(d);
+    }
+  });
+  return allowedDirsCache;
+}
+function isPathBounded(filePath) {
+  try {
+    const real = realpathSync(filePath);
+    const allowed = getAllowedFontDirs();
+    return allowed.some((dir) => real.startsWith(dir + "/") || real.startsWith(dir + "\\"));
+  } catch {
+    return false;
+  }
+}
+function isRegularFile(filePath) {
+  try {
+    const lst = lstatSync(filePath);
+    if (lst.isSymbolicLink())
+      return isPathBounded(filePath) && lstatSync(realpathSync(filePath)).isFile();
+    return lst.isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizeName(name) {
+  return name.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+}
+function extensionToFormat(ext) {
+  const lower = ext.toLowerCase().replace(/^\./, "");
+  if (lower === "woff2")
+    return "woff2";
+  if (lower === "woff")
+    return "woff";
+  if (lower === "otf")
+    return "otf";
+  if (lower === "ttc")
+    return "ttc";
+  return "ttf";
+}
+function toFamilyName(fileName) {
+  const withoutExt = fileName.replace(FONT_EXT_RE, "");
+  if (!withoutExt || withoutExt.startsWith("."))
+    return null;
+  const spaced = withoutExt.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/\s+/g, " ").trim();
+  const words = spaced.split(" ").filter(Boolean);
+  while (words.length > 1 && STYLE_SUFFIXES.has((words.at(-1) ?? "").toLowerCase())) {
+    words.pop();
+  }
+  const family = words.join(" ").trim();
+  return family.length >= 2 ? family : null;
+}
+function isRegularWeight(fileName) {
+  const lower = fileName.toLowerCase();
+  if (REGULAR_TOKENS.has(lower.replace(FONT_EXT_RE, "").split(/[-_ ]/).pop() ?? ""))
+    return true;
+  return !lower.includes("bold") && !lower.includes("italic") && !lower.includes("light");
+}
+function fontDirectories() {
+  const home = homedir();
+  if (platform() === "darwin") {
+    return [
+      join(home, "Library", "Fonts"),
+      "/Library/Fonts",
+      "/System/Library/Fonts",
+      "/System/Library/Fonts/Supplemental"
+    ];
+  }
+  if (platform() === "win32") {
+    return [
+      join(process.env.WINDIR || "C:\\Windows", "Fonts"),
+      join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Microsoft", "Windows", "Fonts")
+    ];
+  }
+  return [
+    join(home, ".fonts"),
+    join(home, ".local", "share", "fonts"),
+    "/usr/local/share/fonts",
+    "/usr/share/fonts"
+  ];
+}
+function collectFontFileEntries(dir, depth = 0) {
+  if (!existsSync(dir) || depth > 2)
+    return [];
+  const entries = [];
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        entries.push(...collectFontFileEntries(fullPath, depth + 1));
+        continue;
+      }
+      if (!FONT_EXT_RE.test(entry.name))
+        continue;
+      if (!isRegularFile(fullPath))
+        continue;
+      const family = toFamilyName(entry.name);
+      if (family)
+        entries.push({ path: fullPath, fileName: entry.name, family });
+    }
+  } catch {
+  }
+  return entries;
+}
+function collectCandidatesFromDir(dir, targetFamily, depth = 0) {
+  return collectFontFileEntries(dir, depth).filter((e) => normalizeName(e.family) === targetFamily).map((e) => {
+    const ext = e.fileName.match(FONT_EXT_RE)?.[1] ?? "ttf";
+    return {
+      path: e.path,
+      format: extensionToFormat(ext),
+      isRegular: isRegularWeight(e.fileName)
+    };
+  });
+}
+function pickBestCandidate(candidates) {
+  if (candidates.length === 0)
+    return null;
+  candidates.sort((a, b) => {
+    if (a.isRegular !== b.isRegular)
+      return a.isRegular ? -1 : 1;
+    return (FORMAT_PRIORITY[a.format] ?? 9) - (FORMAT_PRIORITY[b.format] ?? 9);
+  });
+  const best = candidates[0];
+  return { path: best.path, format: best.format };
+}
+function locateViaFcMatch(targetFamily) {
+  if (platform() !== "linux")
+    return null;
+  try {
+    const result = execFileSync("fc-match", [targetFamily, "--format=%{file}"], {
+      encoding: "utf8",
+      timeout: FC_MATCH_TIMEOUT_MS
+    }).trim();
+    if (!result || !isRegularFile(result) || !isPathBounded(result))
+      return null;
+    const fileName = result.split("/").pop() ?? "";
+    const derivedFamily = toFamilyName(fileName);
+    if (!derivedFamily || normalizeName(derivedFamily) !== targetFamily)
+      return null;
+    const ext = fileName.match(FONT_EXT_RE)?.[1] ?? "ttf";
+    return { path: result, format: extensionToFormat(ext) };
+  } catch {
+    return null;
+  }
+}
+function locateSystemFont(family) {
+  const normalized = normalizeName(family);
+  if (!normalized)
+    return null;
+  const cached = cache.get(normalized);
+  if (cached !== void 0)
+    return cached;
+  let result = locateViaFcMatch(normalized);
+  if (!result) {
+    const allCandidates = [];
+    for (const dir of fontDirectories()) {
+      allCandidates.push(...collectCandidatesFromDir(dir, normalized));
+    }
+    result = pickBestCandidate(allCandidates);
+  }
+  cache.set(normalized, result);
+  return result;
+}
+var WEIGHT_TOKENS = {
+  thin: "100",
+  hairline: "100",
+  ultralight: "200",
+  extralight: "200",
+  light: "300",
+  regular: "400",
+  normal: "400",
+  book: "400",
+  roman: "400",
+  medium: "500",
+  demibold: "600",
+  semibold: "600",
+  bold: "700",
+  extrabold: "800",
+  ultrabold: "800",
+  heavy: "800",
+  black: "900",
+  ultrablack: "950"
+};
+var WEIGHT_TOKENS_SORTED = Object.entries(WEIGHT_TOKENS).sort(([a], [b]) => b.length - a.length);
+function inferWeightAndStyle(fileName) {
+  const lower = fileName.toLowerCase().replace(FONT_EXT_RE, "");
+  const style = lower.includes("italic") || lower.includes("oblique") ? "italic" : "normal";
+  for (const [token, weight] of WEIGHT_TOKENS_SORTED) {
+    if (lower.includes(token))
+      return { weight, style };
+  }
+  return { weight: "400", style };
+}
+function locateSystemFontVariants(family) {
+  const normalized = normalizeName(family);
+  if (!normalized)
+    return [];
+  const variants = [];
+  const allCandidates = [];
+  for (const dir of fontDirectories()) {
+    allCandidates.push(...collectCandidatesFromDir(dir, normalized));
+  }
+  for (const c of allCandidates) {
+    const { weight, style } = inferWeightAndStyle(c.path);
+    variants.push({ path: c.path, format: c.format, weight, style });
+  }
+  return dedupeVariants(variants);
+}
+function dedupeVariants(variants) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    const key = `${v.weight}:${v.style}`;
+    if (!seen.has(key))
+      seen.set(key, v);
+  }
+  return Array.from(seen.values());
+}
+
+export {
+  SYSTEM_FONT_SIZE_LIMIT,
+  fontDirectories,
+  collectFontFileEntries,
+  locateSystemFont,
+  locateSystemFontVariants
+};

package/vendor/framey/dist/chunk-7JQFJ6JJ.js

@@ -0,0 +1,291 @@
+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 {
+  RENDER_TEMP_DIR,
+  STUDIO_MANUAL_EDITS_PATH
+} from "./chunk-EVMY7IPL.js";
+import {
+  realpath,
+  resolveWithinProject
+} from "./chunk-OFQWTKPW.js";
+
+// ../studio-server/dist/chunk-L3HJVTQE.js
+var STUDIO_MOTION_PATH = ".hyperframes/studio-motion.json";
+function hasStudioMotionEntries(manifestContent) {
+  try {
+    const parsed = JSON.parse(manifestContent);
+    return Array.isArray(parsed.motions) && parsed.motions.length > 0;
+  } catch {
+    return false;
+  }
+}
+function createStudioMotionRenderBodyScript(manifestContent, options = {}) {
+  if (!manifestContent.trim() || !hasStudioMotionEntries(manifestContent)) return null;
+  return `(${studioMotionRenderRuntime.toString()})(${JSON.stringify(manifestContent)}, ${JSON.stringify(options.activeCompositionPath ?? null)});`;
+}
+function studioMotionRenderRuntime(manifestContent, activeCompositionPath) {
+  const STUDIO_MOTION_TIMELINE_ID = "studio-motion";
+  const STUDIO_MOTION_ATTR = "data-hf-studio-motion";
+  const ORIGINAL_TRANSFORM_ATTR = "data-hf-studio-motion-original-transform";
+  const ORIGINAL_OPACITY_ATTR = "data-hf-studio-motion-original-opacity";
+  const ORIGINAL_VISIBILITY_ATTR = "data-hf-studio-motion-original-visibility";
+  const objectRecord = (value) => value && typeof value === "object" ? value : null;
+  const finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  const runtimeWindow = window;
+  const parseMotionValues = (value) => {
+    const record = objectRecord(value);
+    if (!record) return null;
+    const parsed = {};
+    for (const key of ["x", "y", "scale", "rotation", "opacity", "autoAlpha"]) {
+      const next = finiteNumber(record[key]);
+      if (next != null) parsed[key] = next;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : null;
+  };
+  const parseCustomEase = (value) => {
+    const record = objectRecord(value);
+    if (!record) return null;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    const data = typeof record.data === "string" ? record.data.trim() : "";
+    if (!id || !data) return null;
+    return { id, data };
+  };
+  const parsedManifest = (() => {
+    try {
+      return objectRecord(JSON.parse(manifestContent));
+    } catch {
+      return null;
+    }
+  })();
+  const manifestMotions = Array.isArray(parsedManifest?.motions) ? parsedManifest.motions : [];
+  const sourceFileForElement = (element) => {
+    let current = element;
+    while (current) {
+      const sourceFile = current.getAttribute("data-composition-file") ?? current.getAttribute("data-composition-src");
+      if (sourceFile) return sourceFile;
+      current = current.parentElement;
+    }
+    return activeCompositionPath ?? "index.html";
+  };
+  const elementMatchesSourceFile = (element, sourceFile) => sourceFileForElement(element) === sourceFile;
+  const isHTMLElement = (element) => element instanceof HTMLElement;
+  const querySelectorCandidates = (selector) => {
+    const className = selector.match(/^\.([A-Za-z0-9_-]+)$/)?.[1];
+    if (className) {
+      return Array.from(document.getElementsByTagName("*")).filter(
+        (element) => isHTMLElement(element) && element.classList.contains(className)
+      );
+    }
+    if (/^[A-Za-z][A-Za-z0-9-]*$/.test(selector)) {
+      return Array.from(document.getElementsByTagName(selector)).filter(isHTMLElement);
+    }
+    return Array.from(document.querySelectorAll(selector)).filter(isHTMLElement);
+  };
+  const resolveTarget = (targetRecord) => {
+    const sourceFile = typeof targetRecord.sourceFile === "string" ? targetRecord.sourceFile : "";
+    if (!sourceFile) return null;
+    const id = typeof targetRecord.id === "string" ? targetRecord.id : "";
+    if (id) {
+      const byId = document.getElementById(id);
+      if (isHTMLElement(byId) && elementMatchesSourceFile(byId, sourceFile)) return byId;
+    }
+    const selector = typeof targetRecord.selector === "string" ? targetRecord.selector : "";
+    if (!selector) return null;
+    try {
+      const selectorIndex = Math.max(0, Math.floor(finiteNumber(targetRecord.selectorIndex) ?? 0));
+      return querySelectorCandidates(selector).filter(
+        (element) => elementMatchesSourceFile(element, sourceFile)
+      )[selectorIndex] ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const restoreElement = (element) => {
+    runtimeWindow.gsap?.set?.(element, { clearProps: "transform,opacity,visibility" });
+    element.style.transform = element.getAttribute(ORIGINAL_TRANSFORM_ATTR) ?? "";
+    element.style.opacity = element.getAttribute(ORIGINAL_OPACITY_ATTR) ?? "";
+    element.style.visibility = element.getAttribute(ORIGINAL_VISIBILITY_ATTR) ?? "";
+    element.removeAttribute(STUDIO_MOTION_ATTR);
+    element.removeAttribute(ORIGINAL_TRANSFORM_ATTR);
+    element.removeAttribute(ORIGINAL_OPACITY_ATTR);
+    element.removeAttribute(ORIGINAL_VISIBILITY_ATTR);
+  };
+  const restoreStudioMotionElements = () => {
+    for (const element of Array.from(document.querySelectorAll(`[${STUDIO_MOTION_ATTR}]`))) {
+      if (isHTMLElement(element)) restoreElement(element);
+    }
+  };
+  const readCurrentTime = () => {
+    try {
+      const playerTime = runtimeWindow.__player?.getTime?.();
+      if (typeof playerTime === "number" && Number.isFinite(playerTime)) {
+        return Math.max(0, playerTime);
+      }
+    } catch {
+    }
+    try {
+      const timelineTime = runtimeWindow.__timeline?.time?.();
+      if (typeof timelineTime === "number" && Number.isFinite(timelineTime)) {
+        return Math.max(0, timelineTime);
+      }
+    } catch {
+    }
+    return 0;
+  };
+  const resolveEase = (motion) => {
+    const fallback = typeof motion.ease === "string" && motion.ease.trim() ? motion.ease.trim() : "none";
+    const customEase = parseCustomEase(motion.customEase);
+    const customEasePlugin = runtimeWindow.CustomEase;
+    if (!customEase || typeof customEasePlugin?.create !== "function") return fallback;
+    try {
+      runtimeWindow.gsap?.registerPlugin?.(customEasePlugin);
+      customEasePlugin.create(customEase.id, customEase.data);
+      return customEase.id;
+    } catch {
+      return fallback;
+    }
+  };
+  const applyManifest = () => {
+    runtimeWindow.__timelines = runtimeWindow.__timelines ?? {};
+    runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID]?.kill?.();
+    delete runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID];
+    restoreStudioMotionElements();
+    const gsap = runtimeWindow.gsap;
+    if (!gsap?.timeline || manifestMotions.length === 0) return 0;
+    const timeline = gsap.timeline({ paused: true, defaults: { overwrite: "auto" } });
+    let applied = 0;
+    for (const motionValue of manifestMotions) {
+      const motion = objectRecord(motionValue);
+      if (!motion || motion.kind !== "gsap-motion") continue;
+      const targetRecord = objectRecord(motion.target);
+      if (!targetRecord) continue;
+      const target = resolveTarget(targetRecord);
+      if (!target || typeof timeline.fromTo !== "function") continue;
+      const start = finiteNumber(motion.start);
+      const duration = finiteNumber(motion.duration);
+      if (start == null || duration == null || start < 0 || duration <= 0) continue;
+      const from = parseMotionValues(motion.from);
+      const to = parseMotionValues(motion.to);
+      if (!from || !to) continue;
+      if (!target.hasAttribute(STUDIO_MOTION_ATTR)) {
+        target.setAttribute(ORIGINAL_TRANSFORM_ATTR, target.style.transform);
+        target.setAttribute(ORIGINAL_OPACITY_ATTR, target.style.opacity);
+        target.setAttribute(ORIGINAL_VISIBILITY_ATTR, target.style.visibility);
+      }
+      target.setAttribute(STUDIO_MOTION_ATTR, "true");
+      timeline.fromTo(
+        target,
+        from,
+        { ...to, duration, ease: resolveEase(motion), overwrite: "auto", immediateRender: false },
+        start
+      );
+      applied += 1;
+    }
+    if (applied === 0) {
+      timeline.kill?.();
+      return 0;
+    }
+    runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID] = timeline;
+    timeline.pause?.();
+    const currentTime = readCurrentTime();
+    if (typeof timeline.totalTime === "function") timeline.totalTime(currentTime, false);
+    else timeline.time?.(currentTime);
+    return applied;
+  };
+  runtimeWindow.__hfStudioMotionApply = applyManifest;
+  applyManifest();
+}
+
+// ../studio-server/dist/chunk-AD2PUAS3.js
+import { basename, dirname, isAbsolute, join, relative, sep } from "path";
+import { readdirSync } from "fs";
+function resolveWithinProject2(base, relativePath) {
+  const resolved = resolveWithinProject(base, relativePath);
+  return resolved && !isPrivateProjectFile(base, resolved) ? resolved : null;
+}
+function realFilePath(filePath) {
+  try {
+    return realpath(filePath);
+  } catch {
+    const dir = dirname(filePath);
+    return dir === filePath ? filePath : join(realFilePath(dir), basename(filePath));
+  }
+}
+var STUDIO_FILES = /* @__PURE__ */ new Set([STUDIO_MOTION_PATH, STUDIO_MANUAL_EDITS_PATH]);
+var STUDIO_FOLDERS = [".hyperframes/prepared-assets", ".hyperframes/requests"];
+function isPrivateProjectPath(relPath) {
+  const path = relPath.toLowerCase();
+  return (path === ".hyperframes" || path.startsWith(".hyperframes/")) && !STUDIO_FILES.has(path) && !STUDIO_FOLDERS.some((folder) => path === folder || path.startsWith(`${folder}/`));
+}
+function isPrivateProjectFile(projectDir, filePath) {
+  const rel = (from, to) => relative(from, to).split(sep).join("/");
+  return [rel(projectDir, filePath), rel(realFilePath(projectDir), realFilePath(filePath))].some(
+    isPrivateProjectPath
+  );
+}
+function pinWithinProject(base, relativePath) {
+  return pinResolved(base, resolveWithinProject2(base, relativePath));
+}
+function pinProjectRecord(base, relativePath) {
+  return pinResolved(base, resolveWithinProject(base, relativePath));
+}
+function pinResolved(base, checked) {
+  if (!checked) return null;
+  const inside = relative(realFilePath(base), realFilePath(checked));
+  const escapes = inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
+  return escapes ? null : join(base, inside);
+}
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".thumbnails",
+  ".transcode-cache",
+  ".waveform-cache",
+  "node_modules",
+  ".git"
+]);
+function shouldIgnoreDir(rel) {
+  return rel === ".hyperframes/backup";
+}
+function isInHiddenOrVendorDir(relPath) {
+  const segments = relPath.split("/");
+  return segments.slice(0, -1).some((seg) => seg.startsWith(".") || seg === "node_modules");
+}
+var UNREADABLE_DIR_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "ENOENT", "ENOTDIR"]);
+function walkDir(dir, prefix = "") {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (!prefix || !code || !UNREADABLE_DIR_CODES.has(code)) throw err;
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (IGNORE_DIRS.has(entry.name) || RENDER_TEMP_DIR.test(entry.name) || shouldIgnoreDir(rel))
+      continue;
+    if (entry.isDirectory()) {
+      files.push(...walkDir(join(dir, entry.name), rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+
+export {
+  STUDIO_MOTION_PATH,
+  createStudioMotionRenderBodyScript,
+  resolveWithinProject2 as resolveWithinProject,
+  realFilePath,
+  isPrivateProjectPath,
+  isPrivateProjectFile,
+  pinWithinProject,
+  pinProjectRecord,
+  isInHiddenOrVendorDir,
+  walkDir
+};

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

@@ -0,0 +1,113 @@
+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";
+
+// src/tts/manager.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "tts");
+var MODELS_DIR = join(CACHE_DIR, "models");
+var VOICES_DIR = join(CACHE_DIR, "voices");
+var DEFAULT_MODEL = "kokoro-v1.0";
+var MODEL_URLS = {
+  "kokoro-v1.0": "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx"
+};
+var VOICES_URL = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/voices-v1.0.bin";
+var SUPPORTED_LANGS = [
+  "en-us",
+  "en-gb",
+  "es",
+  "fr-fr",
+  "hi",
+  "it",
+  "pt-br",
+  "ja",
+  "zh"
+];
+var VOICE_PREFIX_LANG = {
+  a: "en-us",
+  // American English
+  b: "en-gb",
+  // British English
+  e: "es",
+  // Spanish
+  f: "fr-fr",
+  // French
+  h: "hi",
+  // Hindi
+  i: "it",
+  // Italian
+  j: "ja",
+  // Japanese
+  p: "pt-br",
+  // Brazilian Portuguese
+  z: "zh"
+  // Mandarin
+};
+function inferLangFromVoiceId(voiceId) {
+  const first = voiceId.charAt(0).toLowerCase();
+  return VOICE_PREFIX_LANG[first] ?? "en-us";
+}
+function isSupportedLang(value) {
+  return SUPPORTED_LANGS.includes(value);
+}
+var BUNDLED_VOICES = [
+  { id: "af_heart", label: "Heart", language: "en-US", gender: "female" },
+  { id: "af_nova", label: "Nova", language: "en-US", gender: "female" },
+  { id: "af_sky", label: "Sky", language: "en-US", gender: "female" },
+  { id: "am_adam", label: "Adam", language: "en-US", gender: "male" },
+  { id: "am_michael", label: "Michael", language: "en-US", gender: "male" },
+  { id: "bf_emma", label: "Emma", language: "en-GB", gender: "female" },
+  { id: "bf_isabella", label: "Isabella", language: "en-GB", gender: "female" },
+  { id: "bm_george", label: "George", language: "en-GB", gender: "male" },
+  { id: "ef_dora", label: "Dora", language: "es", gender: "female" },
+  { id: "ff_siwis", label: "Siwis", language: "fr-FR", gender: "female" },
+  { id: "jf_alpha", label: "Alpha", language: "ja", gender: "female" },
+  { id: "zf_xiaobei", label: "Xiaobei", language: "zh", gender: "female" }
+];
+var DEFAULT_VOICE = "af_heart";
+async function ensureModel(model = DEFAULT_MODEL, options) {
+  const modelPath = join(MODELS_DIR, `${model}.onnx`);
+  if (existsSync(modelPath)) return modelPath;
+  const url = MODEL_URLS[model];
+  if (!url) {
+    throw new Error(
+      `Unknown TTS model: ${model}. Available: ${Object.keys(MODEL_URLS).join(", ")}`
+    );
+  }
+  mkdirSync(MODELS_DIR, { recursive: true });
+  options?.onProgress?.(`Downloading TTS model ${model} (~311 MB)...`);
+  await downloadFile(url, modelPath);
+  if (!existsSync(modelPath)) {
+    throw new Error(`Model download failed: ${model}`);
+  }
+  return modelPath;
+}
+async function ensureVoices(options) {
+  const voicesPath = join(VOICES_DIR, "voices-v1.0.bin");
+  if (existsSync(voicesPath)) return voicesPath;
+  mkdirSync(VOICES_DIR, { recursive: true });
+  options?.onProgress?.("Downloading voice data (~27 MB)...");
+  await downloadFile(VOICES_URL, voicesPath);
+  if (!existsSync(voicesPath)) {
+    throw new Error("Voice data download failed");
+  }
+  return voicesPath;
+}
+
+export {
+  SUPPORTED_LANGS,
+  inferLangFromVoiceId,
+  isSupportedLang,
+  BUNDLED_VOICES,
+  DEFAULT_VOICE,
+  ensureModel,
+  ensureVoices
+};

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

@@ -0,0 +1,15 @@
+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/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+export {
+  VERSION,
+  PRODUCER_VERSION
+};