hyperframes 0.8.143 → 0.8.145

package/dist/{chunk-U3X3TPBW.js → chunk-MAYCCGMQ.js}

@@ -9,11 +9,11 @@ import {
 } from "./chunk-BHVFTYSI.js";
 import {
   findFFmpeg
-} from "./chunk-TVCRUG2S.js";
+} from "./chunk-ZEUONDQG.js";
 
 // src/whisper/manager.ts
 import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, rmSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "fs";
 import { homedir, platform } from "os";
 import { join } from "path";
 var MODELS_DIR = join(homedir(), ".cache", "hyperframes", "whisper", "models");
@@ -120,6 +120,14 @@ ${stderr.slice(-500)}`;
 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";
@@ -190,6 +198,7 @@ export {
   WhisperUnavailableError,
   isWhisperUnavailable,
   findWhisper,
+  listWhisperModels,
   getInstallInstructions,
   ensureWhisper,
   ensureModel,

package/dist/{chunk-HC7EVDEL.js → chunk-OB5MJR4W.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   updateNoticesSuppressed
-} from "./chunk-Y6QL2LGO.js";
+} from "./chunk-PLR7Z6TC.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";

package/dist/{chunk-N3DQEVSI.js → chunk-OTHDVXOJ.js}

@@ -9,28 +9,31 @@ import {
 } from "./chunk-6IHWCZ3W.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-UICWP23D.js";
+} from "./chunk-FBCULCAL.js";
 import {
   DEFAULT_MODEL,
   ensureModel,
   ensureWhisper,
   hasFFmpeg
-} from "./chunk-U3X3TPBW.js";
+} from "./chunk-MAYCCGMQ.js";
 import {
   findFFmpeg,
   findFFprobe,
   getFFmpegInstallHint
-} from "./chunk-TVCRUG2S.js";
+} from "./chunk-ZEUONDQG.js";
 import {
   findWavChunk
 } from "./chunk-UOFAE5RF.js";
+import {
+  TRANSCRIPT_FILE
+} from "./chunk-IR35BCLK.js";
 
 // src/whisper/transcribe.ts
 import { execFile, execFileSync } from "child_process";
 import { once } from "events";
 import { createInterface } from "readline";
 import { existsSync, readFileSync, mkdirSync, rmSync, statSync, unlinkSync } from "fs";
-import { join, extname } from "path";
+import { basename, join, extname } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
 var WHISPER_TIMEOUT_FLOOR_MS = 3e5;
@@ -297,7 +300,7 @@ async function transcribe(inputPath, outputDir, options) {
     status: "started",
     durationSeconds: wavSeconds
   });
-  const outputBase = join(outputDir, "transcript");
+  const outputBase = join(outputDir, basename(TRANSCRIPT_FILE, ".json"));
   mkdirSync(outputDir, { recursive: true });
   const whisperArgs = [
     "--model",

package/dist/{chunk-Y6QL2LGO.js → chunk-PLR7Z6TC.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   VERSION
-} from "./chunk-W35EKBS6.js";
+} from "./chunk-BFACGEII.js";
 
 // src/utils/updateCheck.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-OBXQRJWQ.js → chunk-QATWIE4K.js}

@@ -18,7 +18,7 @@ import {
   CSS_URL_RE,
   isNonRelativeUrl,
   isPathInside
-} from "./chunk-ZLW2V65P.js";
+} from "./chunk-BSQ7XANM.js";
 import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";

package/dist/{chunk-HLYOEIWM.js → chunk-QLSM7K5S.js}

@@ -20,7 +20,7 @@ import {
   typeDirPath,
   updateRecord,
   withFigmaErrors
-} from "./chunk-LVX6NK36.js";
+} from "./chunk-3IBMBNYY.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -229,7 +229,7 @@ var asset_default = defineCommand({
           rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
         );
       }
-      const { trackFigmaImport } = await import("./telemetry-CXAX3TO3.js");
+      const { trackFigmaImport } = await import("./telemetry-PAOOB4T4.js");
       trackFigmaImport({
         phase: "asset",
         reused: results.every((r) => r.reused),

package/dist/{chunk-LW6HO6U3.js → chunk-R42WWQVB.js}

@@ -16,7 +16,7 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-4M4EC7JX.js";
+} from "./chunk-VRW6EBHV.js";
 import {
   extractCompositionMetadata
 } from "./chunk-MQZVBHEY.js";

package/dist/{chunk-HMT2RPZU.js → chunk-U5QY7KTN.js}

@@ -10,18 +10,19 @@ import {
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-PJU63L6W.js";
+} from "./chunk-4ORLNTET.js";
 import {
   resolveDiagnosticNavigationTimeoutMs,
   windowsChromeCrashRemediation
-} from "./chunk-P7THMINS.js";
+} from "./chunk-FXJJCPPB.js";
 import {
-  resolveLocalBrowserGpuMode
-} from "./chunk-QRKLPWEX.js";
+  resolveLocalBrowserGpuMode,
+  resolveLocalWebGpu
+} from "./chunk-ADF3X6GM.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
-} from "./chunk-33RZPZ4K.js";
+} from "./chunk-UXO2L7HJ.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -100,20 +101,23 @@ async function installPageFunctionGuard(page) {
 }
 async function openSettledCompositionPage(html, url, options) {
   const viewport = resolveCompositionViewportFromHtml(html);
-  const { ensureBrowser, findSystemBrowser } = await import("./manager-CT3D67CG.js");
+  const { ensureBrowser, findSystemBrowser } = await import("./manager-BPSR6D3V.js");
   const browser = await ensureBrowser();
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-JO5JOV7Y.js");
+  const { buildChromeArgs } = await import("./src-BSLKXEGX.js");
   const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
   const requiresWebGpu = compositionRequiresWebGpu(html);
+  let softwareWebGpu = false;
   const launch = async (executablePath) => {
     const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, executablePath);
+    const webGpu = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
+    softwareWebGpu = webGpu.softwareWebGpu;
     return launchManagedBrowser(puppeteer.default, {
       headless: true,
       executablePath,
       args: buildChromeArgs(
         { ...viewport, captureMode: "screenshot", requiresWebGpu },
-        { browserGpuMode: resolvedGpuMode }
+        webGpu.gpuConfig
       )
     });
   };
@@ -153,7 +157,7 @@ ${remediation}`,
       waitUntil: "domcontentloaded",
       timeout: resolveDiagnosticNavigationTimeoutMs(process.env, options.navigationTimeoutMs)
     });
-    await assertWebGpuAdapterAvailable(page, requiresWebGpu);
+    await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
     const renderReadyTimedOut = !await waitForCompositionSettle(page, options);
     return { browser: chromeBrowser, page, renderReadyTimedOut };
   } catch (err) {

package/dist/chunk-UPFUC4DB.js

@@ -0,0 +1,136 @@
+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 {
+  CliUsageError
+} from "./chunk-PBN6GBJE.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+
+// src/utils/reject-unknown-flags.ts
+var ALWAYS_KNOWN = /* @__PURE__ */ new Set(["help", "h", "version", "v", "json"]);
+function nameVariants(name) {
+  const kebab = name.replace(/[A-Z]/g, (c2) => "-" + c2.toLowerCase());
+  const camel = name.replace(/-([a-z])/g, (_, c2) => c2.toUpperCase());
+  return [name, kebab, camel];
+}
+function* spellingsOf(name, def) {
+  yield* nameVariants(name);
+  const alias = def && "alias" in def ? def.alias : void 0;
+  if (typeof alias === "string") yield alias;
+  else if (Array.isArray(alias)) yield* alias;
+}
+function knownFlags(args) {
+  const known = new Set(ALWAYS_KNOWN);
+  for (const [name, def] of Object.entries(args ?? {})) {
+    for (const s of spellingsOf(name, def)) known.add(s);
+  }
+  return known;
+}
+function longFlagName(tok) {
+  const name = tok.slice(2).split("=")[0] ?? "";
+  return name.startsWith("no-") ? name.slice(3) : name;
+}
+function unknownFlagIn(tok, known) {
+  if (tok === "-" || !tok.startsWith("-")) return null;
+  if (tok.startsWith("--")) {
+    const name = longFlagName(tok);
+    return name && !known.has(name) ? `--${name}` : null;
+  }
+  for (const ch of tok.slice(1).split("=")[0] ?? "") {
+    if (!known.has(ch)) return `-${ch}`;
+  }
+  return null;
+}
+function assertKnownFlags(cmd, rawArgs) {
+  if (!Array.isArray(rawArgs)) return;
+  const rawDef = cmd.args;
+  const args = rawDef && typeof rawDef === "object" ? rawDef : void 0;
+  const known = knownFlags(args);
+  for (const tok of rawArgs) {
+    if (tok === "--") break;
+    const bad = unknownFlagIn(tok, known);
+    if (bad) throw new Error(`Unknown flag: ${bad}`);
+  }
+}
+function stringValueFlagOwners(args, ignore) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(args ?? {})) {
+    if (def?.type !== "string" && def?.type !== "enum") continue;
+    if (ignore?.has(name)) continue;
+    for (const s of spellingsOf(name, def)) owners.set(s, name);
+  }
+  return owners;
+}
+function ownableFlagSpelling(tok) {
+  if (tok.includes("=")) return null;
+  if (tok.startsWith("--")) return tok.slice(2);
+  if (tok.length === 2 && tok.startsWith("-")) return tok.slice(1);
+  return null;
+}
+var SWALLOW_REWRITE_FLAGS = {
+  check: /* @__PURE__ */ new Set(["frame-check"])
+};
+var SWALLOW_IGNORE_FLAGS = {
+  upgrade: /* @__PURE__ */ new Set(["project"])
+};
+function swallowedValueMessage(flagName, next, hint) {
+  if (next === "--")
+    return `Missing value for --${flagName}: "--" ends option parsing here; ${hint}`;
+  return `Missing value for --${flagName}: value "${next}" appears to have swallowed the next option; ${hint}`;
+}
+function swallowedFlagUsageError(flagName, next) {
+  const hint = `use --${flagName}= or move --${flagName} to the end`;
+  return new CliUsageError(swallowedValueMessage(flagName, next, hint));
+}
+function throwSwallowedFlagError(flagName, next) {
+  const hint = `pass one: --${flagName} <value> or --${flagName}=<value>`;
+  const message = swallowedValueMessage(flagName, next, hint);
+  console.error(c.error(message));
+  throw new CliUsageError(message, { presented: true });
+}
+function looksLikeSwallowedFlag(next, known) {
+  if (next === void 0 || next === "-") return false;
+  return next === "--" || next.startsWith("-") && unknownFlagIn(next, known) === null;
+}
+function swallowingArgName(tok, next, owners, known) {
+  const spelling = ownableFlagSpelling(tok);
+  const ownerArgName = spelling ? owners.get(spelling) : void 0;
+  return ownerArgName && looksLikeSwallowedFlag(next, known) ? ownerArgName : void 0;
+}
+function rewriteArgName(tok, after, owners, rewriteFlags) {
+  if (!after?.startsWith("--no-")) return void 0;
+  const spelling = ownableFlagSpelling(tok);
+  const name = spelling ? owners.get(spelling) : void 0;
+  return name && rewriteFlags?.has(name) ? name : void 0;
+}
+function guardSwallowedFlagValues(cmd, path, rawArgs) {
+  if (!Array.isArray(rawArgs)) return { rawArgs, rewritten: false };
+  const rawDef = cmd?.args;
+  const argsDef = rawDef && typeof rawDef === "object" ? rawDef : void 0;
+  const known = knownFlags(argsDef);
+  const owners = stringValueFlagOwners(argsDef, SWALLOW_IGNORE_FLAGS[path]);
+  const rewriteFlags = SWALLOW_REWRITE_FLAGS[path];
+  let out;
+  for (const [i, tok] of rawArgs.entries()) {
+    if (tok === "--") break;
+    const next = rawArgs.slice(i + 1).find((t) => !t.startsWith("--no-"));
+    const ownerArgName = swallowingArgName(tok, next, owners, known);
+    const rewrite = rewriteArgName(tok, rawArgs[i + 1], owners, rewriteFlags) ?? ownerArgName;
+    if (!rewrite) continue;
+    if (!rewriteFlags?.has(rewrite)) throwSwallowedFlagError(rewrite, next);
+    out ??= rawArgs.slice();
+    out[i] = `${tok}=`;
+  }
+  return { rawArgs: out ?? rawArgs, rewritten: out !== void 0 };
+}
+
+export {
+  assertKnownFlags,
+  swallowedFlagUsageError,
+  guardSwallowedFlagValues
+};