hyperframes 0.8.148 → 0.8.150

package/dist/{chunk-QX26JK43.js → chunk-6KWA3XPS.js}

@@ -14,13 +14,8 @@ import {
   getInvocationId
 } from "./chunk-54HJ63Q2.js";
 import {
-  CANARIES,
-  canaryEnvVar,
-  canaryFeatureProperties,
-  evaluateCanary,
-  findCanary,
-  parseCanaryOverride
-} from "./chunk-FXMKHHPO.js";
+  c
+} from "./chunk-ZTZA4UWZ.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";
@@ -34,10 +29,15 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-KQESKXAC.js";
+} from "./chunk-I6DATIHC.js";
 import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
+  CANARIES,
+  canaryEnvVar,
+  canaryFeatureProperties,
+  evaluateCanary,
+  findCanary,
+  parseCanaryOverride
+} from "./chunk-FXMKHHPO.js";
 
 // src/telemetry/transport.ts
 import { spawn } from "child_process";

package/dist/{chunk-AY2BONTF.js → chunk-6NPFJ255.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-VC7JBNPS.js";
+} from "./chunk-5NAYNDBT.js";
 import {
   DOMParser,
   parseHTML

package/dist/{chunk-ZK3BQXHC.js → chunk-6QB7F2II.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-PTIV7IVV.js");
+  return await import("./src-S5IZVJUX.js");
 }
 
 export {

package/dist/{chunk-54TV77W5.js → chunk-6SFPQ2RZ.js}

@@ -18,15 +18,13 @@ import {
   sweepStaleStaging
 } from "./chunk-3DKN5WKL.js";
 import {
+  emitWords,
   getPreparedWavDurationSeconds,
   prepareWav
-} from "./chunk-RKBES4XP.js";
-import {
-  emitWords
-} from "./chunk-6IHWCZ3W.js";
+} from "./chunk-XANZ4R4P.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-UTBQSOEC.js";
+} from "./chunk-4WFNTWKZ.js";
 import {
   PARAKEET_MODEL_LABEL,
   SHERPA_ERROR_PREFIX,
@@ -34,7 +32,7 @@ import {
   SHERPA_WINDOW_PREFIX,
   mergeWindowsToWords,
   writeParakeetTranscript
-} from "./chunk-KBB4RG6F.js";
+} from "./chunk-JZIEZCQM.js";
 
 // src/whisper/sherpa.ts
 import { execFile, spawn } from "child_process";
@@ -332,9 +330,9 @@ function decode(wavPath, runtimePath, signal, onWindow) {
     }
   });
 }
-function prepareSherpaWav(inputPath, onProgress) {
+async function prepareSherpaWav(inputPath, onProgress, signal) {
   try {
-    return prepareWav(inputPath, onProgress);
+    return await prepareWav(inputPath, onProgress, signal);
   } catch (err) {
     if (err.cancelled) {
       throw new DecodeCancelled("Transcription cancelled");

package/dist/{chunk-YQK445YQ.js → chunk-73RBX2E7.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-X2G54Y2V.js";
+} from "./chunk-3UAIVF4L.js";
 import {
   shouldTrack
-} from "./chunk-QX26JK43.js";
+} from "./chunk-6KWA3XPS.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS

package/dist/chunk-7E4VHPKJ.js

@@ -0,0 +1,329 @@
+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 {
+  parakeetRunner
+} from "./chunk-2KAL22B5.js";
+import {
+  DecodeCancelled,
+  prepareSherpaWav,
+  sherpaUnsupportedReason,
+  transcribeWithSherpa
+} from "./chunk-6SFPQ2RZ.js";
+import {
+  initialModelForLanguage,
+  transcribe
+} from "./chunk-XANZ4R4P.js";
+import {
+  createRenderCancellationScope,
+  stoppedByCancelSignal
+} from "./chunk-4WFNTWKZ.js";
+import {
+  formatSrt,
+  formatVtt,
+  loadTranscript,
+  patchCaptionHtml
+} from "./chunk-VHZ6DL3M.js";
+import {
+  DEFAULT_MODEL,
+  isWhisperUnavailable
+} from "./chunk-CZQLCBWY.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-KNU5COPB.js";
+import {
+  PARAKEET_INSTALL_COMMAND,
+  PARAKEET_LANGUAGES,
+  parakeetSpeaks,
+  transcribeWithParakeet
+} from "./chunk-JZIEZCQM.js";
+import {
+  TRANSCRIPT_FILE
+} from "./chunk-IR35BCLK.js";
+
+// src/api/transcribe.ts
+import { existsSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, extname, join, resolve } from "path";
+var MIN_TIMEOUT_MS = 5e3;
+var TranscribeError = class extends Error {
+  code;
+  /** whisper_unavailable: the command that installs Parakeet, when Parakeet would cover this run. */
+  install;
+  /** caption_write_failed after transcribing: the transcript, which was saved. */
+  transcriptPath;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "TranscribeError";
+    this.code = code;
+    if (options.install !== void 0) this.install = options.install;
+    if (options.transcriptPath !== void 0) this.transcriptPath = options.transcriptPath;
+  }
+};
+async function runTranscribe(options) {
+  if (options.signal?.aborted) {
+    throw new TranscribeError("cancelled", "Transcription cancelled", {
+      cause: options.signal.reason
+    });
+  }
+  const inputPath = resolve(options.input);
+  if (!existsSync(inputPath)) {
+    throw new TranscribeError("input_not_found", `File not found: ${options.input}`);
+  }
+  const dir = resolve(options.dir ?? dirname(inputPath));
+  const ext = extname(inputPath).toLowerCase();
+  const isImport = ext === ".json" || ext === ".srt" || ext === ".vtt";
+  const sidecar = parseSidecar(options.captions, inputPath, dir);
+  if (sidecar && isImport) return exportTranscript(inputPath, sidecar);
+  if (isImport) return importTranscript(inputPath, dir);
+  const { timeoutMs } = options;
+  if (timeoutMs !== void 0 && !(Number.isInteger(timeoutMs) && timeoutMs >= MIN_TIMEOUT_MS)) {
+    throw new TranscribeError(
+      "invalid_timeout",
+      `Invalid timeoutMs: ${timeoutMs}. Must be an integer >= ${MIN_TIMEOUT_MS} (ms).`
+    );
+  }
+  return transcribeAudio(inputPath, dir, sidecar, options);
+}
+function parseExportFormat(value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (normalized === "srt" || normalized === "vtt") return normalized;
+  throw new TranscribeError(
+    "invalid_option",
+    `Unsupported caption export format: ${value}. Use srt or vtt.`
+  );
+}
+function parseSidecar(captions, inputPath, dir) {
+  const to = parseExportFormat(captions?.format);
+  if (!to) return void 0;
+  const output = captions?.outputPath;
+  const outPath = resolve(output ?? join(dir, `transcript.${to}`));
+  const keep = [inputPath, join(dir, TRANSCRIPT_FILE)];
+  const problem = output !== void 0 && outputProblem(output, outPath, to) || overwriteProblem(outPath, keep);
+  if (problem) throw new TranscribeError("invalid_option", problem);
+  return { to, outPath, preserveCues: captions?.preserveCues === true, keep };
+}
+function outputProblem(output, outPath, to) {
+  if (!output) return "--output needs a file path";
+  const folder = dirname(outPath);
+  if (!existsSync(folder) || !statSync(folder).isDirectory()) {
+    return `Output folder not found: ${folder}`;
+  }
+  if (/[\\/]$/.test(output) || existsSync(outPath) && statSync(outPath).isDirectory()) {
+    return `--output is a folder; give a file path such as ${join(outPath, `transcript.${to}`)}`;
+  }
+  return void 0;
+}
+function overwriteProblem(outPath, keep) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  return hit && `The caption file would overwrite ${hit}; choose another file with --output`;
+}
+function sameFile(out, file) {
+  if (existsSync(out) && existsSync(file)) {
+    const [a, b] = [statSync(out, { bigint: true }), statSync(file, { bigint: true })];
+    if (a.ino !== 0n && b.ino !== 0n) return a.dev === b.dev && a.ino === b.ino;
+    return realpathSync.native(out) === realpathSync.native(file);
+  }
+  const realDir = (p) => existsSync(dirname(p)) ? realpathSync.native(dirname(p)) : dirname(p);
+  return realDir(out) === realDir(file) && basename(out).toLowerCase() === basename(file).toLowerCase();
+}
+function readTranscript(inputPath) {
+  let transcript;
+  try {
+    transcript = loadTranscript(inputPath);
+  } catch (err) {
+    throw new TranscribeError("invalid_transcript", normalizeErrorMessage(err), { cause: err });
+  }
+  if (transcript.words.length === 0) {
+    throw new TranscribeError("no_words", "No words found in transcript.");
+  }
+  return transcript;
+}
+function importTranscript(inputPath, dir) {
+  const { words, format } = readTranscript(inputPath);
+  const transcriptPath = join(dir, TRANSCRIPT_FILE);
+  writeFileSync(transcriptPath, JSON.stringify(words, null, 2));
+  patchCaptionHtml(dir, words);
+  return { kind: "imported", format, wordCount: words.length, transcriptPath };
+}
+function exportTranscript(inputPath, sidecar) {
+  const { words, format } = readTranscript(inputPath);
+  try {
+    writeCaptionSidecar(words, sidecar, format === "srt" || format === "vtt" || void 0);
+  } catch (err) {
+    throw new TranscribeError(
+      "caption_write_failed",
+      `The caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+      { cause: err }
+    );
+  }
+  return {
+    kind: "exported",
+    format: sidecar.to,
+    wordCount: words.length,
+    outputPath: sidecar.outPath
+  };
+}
+function writeCaptionSidecar(words, { to, outPath, preserveCues, keep }, phraseLevelSource) {
+  const hit = keep.find((file) => sameFile(outPath, file));
+  if (hit) throw new Error(`it is the same file as ${hit}`);
+  const preGrouped = preserveCues || phraseLevelSource;
+  const content = to === "srt" ? formatSrt(words, { preGrouped }) : formatVtt(words, { preGrouped });
+  writeFileSync(outPath, content);
+}
+function pickRunner(engine, parakeet, language) {
+  if (engine === "whisper" || !parakeetSpeaks(language)) return "whisper";
+  return parakeet() ?? "whisper";
+}
+var parakeetFallsBack = (engine) => engine === "auto";
+function withoutTrailingDots(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === ".") end--;
+  return text.slice(0, end);
+}
+var engineOf = (runner) => runner === "whisper" ? "whisper" : "parakeet";
+function failureMessage(err) {
+  const base = err instanceof Error ? err.message : String(err);
+  const stderr = err && typeof err === "object" && "stderr" in err && err.stderr ? String(err.stderr).trim().split("\n").slice(-3).filter((line) => !base.includes(line)).join("\n") : "";
+  return stderr ? `${base}
+${stderr}` : base;
+}
+async function transcribeAudio(inputPath, dir, sidecar, options) {
+  const engine = (options.engine ?? "auto").toLowerCase();
+  if (engine !== "auto" && engine !== "parakeet" && engine !== "whisper") {
+    throw new TranscribeError(
+      "invalid_option",
+      `Unknown --engine: ${options.engine}. Use auto, parakeet, or whisper.`
+    );
+  }
+  const unsupported = sherpaUnsupportedReason();
+  let runner = pickRunner(engine, () => parakeetRunner({ unsupported }), options.language);
+  if (engine === "parakeet" && runner === "whisper") {
+    throw new TranscribeError(
+      "parakeet_unavailable",
+      !parakeetSpeaks(options.language) ? `Parakeet does not transcribe --language ${options.language}; it covers ${PARAKEET_LANGUAGES.split(" ").join(", ")}. Use --engine whisper.` : unsupported ?? `Parakeet is not installed. Install it with: ${PARAKEET_INSTALL_COMMAND} (or use --engine whisper)`
+    );
+  }
+  const model = options.model ?? DEFAULT_MODEL;
+  const whisperModel = initialModelForLanguage(model, options.language);
+  options.onEngine?.({ runner, engine: engineOf(runner), model: whisperModel });
+  const { onStatus, onProgress } = options;
+  const startScope = () => options.stopOnProcessSignals ? createRenderCancellationScope() : { signal: options.signal ?? new AbortController().signal, dispose: () => {
+  } };
+  let wavPath = inputPath;
+  let cancellation = runner === "sherpa" || !options.stopOnProcessSignals ? startScope() : null;
+  const librarySignal = options.stopOnProcessSignals ? void 0 : cancellation?.signal;
+  const run = (r) => {
+    switch (r) {
+      case "sherpa":
+        return transcribeWithSherpa(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: cancellation.signal
+        });
+      case "parakeet-mlx":
+        return transcribeWithParakeet(wavPath, dir, {
+          onProgress: onStatus,
+          onEvent: onProgress,
+          signal: librarySignal
+        });
+      case "whisper":
+        return transcribe(wavPath, dir, {
+          model,
+          language: options.language,
+          onProgress: onStatus,
+          onEvent: onProgress,
+          timeoutMs: options.timeoutMs,
+          installRuntime: options.installRuntime,
+          signal: librarySignal,
+          startCancellation: () => (cancellation ??= startScope()).signal
+        });
+      default: {
+        const unreachable = r;
+        throw new Error(`Unknown transcription runner: ${unreachable}`);
+      }
+    }
+  };
+  try {
+    if (runner === "sherpa") {
+      wavPath = await prepareSherpaWav(inputPath, onStatus, librarySignal);
+    }
+    let result;
+    try {
+      result = await run(runner);
+    } catch (err) {
+      if (runner !== "sherpa" || err instanceof DecodeCancelled) throw err;
+      const reason = withoutTrailingDots(normalizeErrorMessage(err));
+      const parakeetError = `Parakeet failed: ${reason}. To repair it, run: ${PARAKEET_INSTALL_COMMAND}`;
+      if (!parakeetFallsBack(engine)) throw new Error(parakeetError);
+      runner = pickRunner(
+        engine,
+        () => parakeetRunner({ unsupported, skipSherpa: true }),
+        options.language
+      );
+      options.onEngine?.({
+        runner,
+        engine: engineOf(runner),
+        model: whisperModel,
+        fallbackReason: parakeetError
+      });
+      try {
+        result = await run(runner);
+      } catch (fallbackErr) {
+        if (stoppedByCancelSignal(fallbackErr)) {
+          throw new DecodeCancelled("Transcription cancelled");
+        }
+        const why = normalizeErrorMessage(fallbackErr);
+        throw new Error(`${parakeetError}. The ${runner} fallback failed too: ${why}`);
+      }
+    }
+    const { words } = loadTranscript(result.transcriptPath);
+    writeFileSync(result.transcriptPath, JSON.stringify(words, null, 2));
+    patchCaptionHtml(dir, words);
+    if (sidecar) {
+      try {
+        writeCaptionSidecar(words, sidecar, false);
+      } catch (err) {
+        throw new TranscribeError(
+          "caption_write_failed",
+          `Transcript saved to ${result.transcriptPath}, but the caption file ${sidecar.outPath} could not be written: ${normalizeErrorMessage(err)}`,
+          { cause: err, transcriptPath: result.transcriptPath }
+        );
+      }
+    }
+    return {
+      kind: "transcribed",
+      engine: engineOf(runner),
+      model: result.model,
+      detectedLanguage: result.detectedLanguage,
+      wordCount: words.length,
+      durationSeconds: result.durationSeconds,
+      speechOnsetSeconds: result.speechOnsetSeconds,
+      transcriptPath: result.transcriptPath,
+      ...sidecar && { captions: { format: sidecar.to, outputPath: sidecar.outPath } }
+    };
+  } catch (err) {
+    if (err instanceof TranscribeError) throw err;
+    if (err instanceof DecodeCancelled || cancellation?.signal.aborted) {
+      throw new TranscribeError("cancelled", "Transcription cancelled", { cause: err });
+    }
+    const message = failureMessage(err);
+    if (isWhisperUnavailable(err)) {
+      const install = engine === "auto" && parakeetSpeaks(options.language) && !unsupported ? PARAKEET_INSTALL_COMMAND : void 0;
+      throw new TranscribeError("whisper_unavailable", message, { cause: err, install });
+    }
+    throw new TranscribeError("failed", message, { cause: err });
+  } finally {
+    cancellation?.dispose();
+    if (wavPath !== inputPath) rmSync(wavPath, { force: true });
+  }
+}
+
+export {
+  MIN_TIMEOUT_MS,
+  TranscribeError,
+  runTranscribe
+};

package/dist/{chunk-A6S35NYA.js → chunk-7IEGPJ4P.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   runRenderSetupWorker
-} from "./chunk-BYSBRF24.js";
+} from "./chunk-XPQSL5VS.js";
 import {
   chromeMajorCeiling,
   exceedsChromeCeiling

package/dist/{chunk-NT7EK6ET.js → chunk-7JTFPUMA.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-33GOPHSS.js");
+        const { trackCommandFailure } = await import("./events-T4YFQC5G.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-VHJPGKUW.js → chunk-A6ZO4BX7.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   getMimeType
-} from "./chunk-C24LU5XD.js";
+} from "./chunk-UVVI2NJQ.js";
 import {
   injectTagsAtHeadStart
-} from "./chunk-3WD4JNMU.js";
+} from "./chunk-CEND6BLF.js";
 
 // src/utils/compositionServer.ts
 import { createHash } from "crypto";

package/dist/{chunk-ASEJ2FBO.js → chunk-AFRXL75S.js}

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

package/dist/{chunk-QIJLIULK.js → chunk-AKYQGZLU.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   resolveConfig,
   usesSoftwareWebGpu
-} from "./chunk-VC7JBNPS.js";
+} from "./chunk-5NAYNDBT.js";
 
 // src/browser/gpuPolicy.ts
 function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCER_BROWSER_GPU_MODE) {
@@ -17,7 +17,7 @@ function resolveLocalBrowserGpuMode(browserGpuArg, envMode = process.env.PRODUCE
   return "auto";
 }
 async function resolveCaptureBrowserGpuMode(requestedMode, chromePath) {
-  const { resolveBrowserGpuMode } = await import("./src-VMTHSARJ.js");
+  const { resolveBrowserGpuMode } = await import("./src-7V6LBC56.js");
   return resolveBrowserGpuMode(requestedMode, { chromePath });
 }
 function resolveLocalWebGpu(browserGpuMode, requiresWebGpu) {

package/dist/{chunk-4S4VUXW3.js → chunk-AXPNVC3N.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-QIJLIULK.js";
+} from "./chunk-AKYQGZLU.js";
 import {
   requestCliExit
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-A4Q7W4LV.js → chunk-B3XLIBFL.js}

@@ -5,9 +5,11 @@ var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
-  runRenderSetupWorker,
+  runRenderSetupWorker
+} from "./chunk-XPQSL5VS.js";
+import {
   terminateProcessTree
-} from "./chunk-BYSBRF24.js";
+} from "./chunk-KGPLIH7B.js";
 
 // src/utils/orphanCleanup.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-PR7QQBSC.js → chunk-BLRJKBKP.js}

@@ -8,7 +8,7 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemManifest,
   fetchRegistryManifest
-} from "./chunk-K35E45SI.js";
+} from "./chunk-OQ7XMM3S.js";
 
 // src/registry/resolver.ts
 function defaultWarn(message) {