@wirecat/zoom-cli 0.56.0 → 0.57.0

package/dist/bundle/chunk-I4VQDXFR.js

@@ -0,0 +1,100 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  VAD,
+  isInstalled,
+  modelPath,
+  modelsDirectory,
+  speechModel,
+  vadPath
+} from "./chunk-NW3X3G5X.js";
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/speech/local.js
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { setImmediate } from "node:timers/promises";
+var cancelled = /* @__PURE__ */ __name((signal) => {
+  if (!signal?.aborted)
+    return;
+  if (signal.reason instanceof CliError)
+    throw signal.reason;
+  const timeout = signal.reason instanceof Error && signal.reason.name === "TimeoutError";
+  throw new CliError(timeout ? "timeout" : "cancelled", "local speech recognition was interrupted");
+}, "cancelled");
+var localSpeechRecognitionModel = /* @__PURE__ */ __name((id) => {
+  const model = speechModel(id);
+  const version = createHash("sha256").update(JSON.stringify({
+    format: "pcm-window-v1",
+    files: model.files.map((file) => [file.name, file.sha256]),
+    vad: VAD.sha256,
+    featureDim: model.featureDim
+  })).digest("hex");
+  return Object.freeze({ engine: "sherpa-onnx", model: model.id, version, sampleRate: 16e3, maxChunkSamples: 48e4 });
+}, "localSpeechRecognitionModel");
+var openLocalSpeechRecognizer = /* @__PURE__ */ __name(async (id, input = {}) => {
+  const options = { ...input };
+  const description = localSpeechRecognitionModel(id);
+  const model = speechModel(description.model);
+  const directory = options.directory ?? modelsDirectory(options.env);
+  const maxTextBytes = options.maxTextBytes ?? 65536;
+  if (typeof directory !== "string" || !isAbsolute(directory) || /[\0\r\n]/.test(directory) || !Number.isSafeInteger(maxTextBytes) || maxTextBytes < 1 || maxTextBytes > 4 * 1024 ** 2)
+    throw new CliError("validation_error", "local speech requires an absolute model directory and bounded output bytes");
+  cancelled(options.signal);
+  if (!isInstalled(model, directory))
+    throw new CliError("not_found", `speech model ${description.model} is not installed; download it explicitly with a WireCat messenger's models download command`, { reason: "model.not-downloaded", model: description.model });
+  const { openRecognizer, toModelRate } = await import("./recognize-QXGE7YJH.js");
+  cancelled(options.signal);
+  const engine = (options.open ?? openRecognizer)(model, modelPath(directory, model), vadPath(directory));
+  let closing = false;
+  let active;
+  let closed;
+  return {
+    ...description,
+    async recognize(pcm, request = {}) {
+      if (closing)
+        throw new CliError("configuration_error", "local speech recognizer is closed");
+      if (active)
+        throw new CliError("configuration_error", "local speech recognizer accepts one window at a time");
+      const signal = options.signal && request.signal ? AbortSignal.any([options.signal, request.signal]) : options.signal ?? request.signal;
+      cancelled(signal);
+      if (!(pcm instanceof Float32Array) || pcm.length < 1 || pcm.length > description.maxChunkSamples)
+        throw new CliError("validation_error", "speech recognition requires at most 30 seconds of mono 16 kHz PCM");
+      const samples = new Float32Array(pcm);
+      if (samples.some((value) => !Number.isFinite(value) || Math.abs(value) > 1))
+        throw new CliError("validation_error", "speech PCM samples must be finite and normalized");
+      active = (async () => {
+        await setImmediate();
+        cancelled(signal);
+        const text = engine.recognize(toModelRate(samples, description.sampleRate));
+        cancelled(signal);
+        if (typeof text !== "string" || text.includes("\0") || text.length > maxTextBytes || new TextEncoder().encode(text).byteLength > maxTextBytes)
+          throw new CliError("invalid_response", "local speech output exceeds its text budget or is invalid");
+        return text.trim();
+      })();
+      try {
+        return await active;
+      } finally {
+        active = void 0;
+      }
+    },
+    close() {
+      closing = true;
+      closed ??= (async () => {
+        await active?.catch(() => void 0);
+        engine.free();
+      })();
+      return closed;
+    }
+  };
+}, "openLocalSpeechRecognizer");
+
+export {
+  localSpeechRecognitionModel,
+  openLocalSpeechRecognizer
+};