@storyteller-platform/ghost-story 0.0.1

package/dist/recognition/OpenAICloudSTT.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var OpenAICloudSTT_exports = {};
+__export(OpenAICloudSTT_exports, {
+  inputPreference: () => inputPreference,
+  recognize: () => recognize
+});
+module.exports = __toCommonJS(OpenAICloudSTT_exports);
+var import_node_fs = require("node:fs");
+var import_audio = require("../audio/index.cjs");
+var import_ObjectUtilities = require("../utilities/ObjectUtilities.cjs");
+const SERVICE_ID = "openai-cloud";
+const inputPreference = "stream";
+const defaultOptions = {
+  apiKey: void 0,
+  organization: void 0,
+  baseURL: void 0,
+  model: void 0,
+  temperature: 0,
+  prompt: void 0,
+  timeout: void 0,
+  maxRetries: 10,
+  requestWordTimestamps: void 0
+};
+async function recognize(input, languageCode, options) {
+  const opts = (0, import_ObjectUtilities.extendDeep)(defaultOptions, options);
+  const timing = opts.timing;
+  if (opts.requestWordTimestamps === void 0) {
+    opts.requestWordTimestamps = opts.baseURL === void 0;
+  }
+  if (opts.model === void 0) {
+    if (opts.baseURL === void 0) {
+      opts.model = "whisper-1";
+    } else {
+      throw new Error(
+        "A custom provider for the OpenAI Cloud API requires specifying a model name"
+      );
+    }
+  }
+  const source = (0, import_audio.isAudioSource)(input) ? input : (0, import_audio.normalizeToAudioSource)(input, opts.inputFormat);
+  const doPrepare = () => (0, import_audio.prepareForService)(source, { service: SERVICE_ID, preferFile: true });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  const conversionOccurred = source.format !== prepared.source.format;
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionOccurred);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", prepared.source.format);
+  try {
+    const { default: OpenAI } = await import("openai");
+    const openai = new OpenAI(opts);
+    const filePath = (0, import_audio.toFilePath)(prepared.source);
+    if (!filePath) {
+      throw new Error(
+        "OpenAI Cloud STT requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    const file = (0, import_node_fs.createReadStream)(filePath);
+    const timestamp_granularities = opts.requestWordTimestamps ? ["word", "segment"] : void 0;
+    const doUpload = () => openai.audio.transcriptions.create({
+      file,
+      model: opts.model,
+      language: languageCode,
+      prompt: opts.prompt,
+      response_format: "verbose_json",
+      temperature: opts.temperature,
+      timestamp_granularities,
+      stream: false
+    });
+    const response = timing ? await timing.timeAsync("upload", doUpload) : await doUpload();
+    const verboseResponse = response;
+    const transcript = verboseResponse.text.trim();
+    const timeline = extractTimeline(verboseResponse);
+    if (!timeline) {
+      throw new Error("Failed to extract timeline from OpenAI Cloud response");
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+function extractTimeline(response) {
+  var _a;
+  if (response.words) {
+    return response.words.map((entry) => ({
+      type: "word",
+      text: entry.word,
+      startTime: entry.start,
+      endTime: entry.end
+    }));
+  }
+  const hasNestedWords = response.segments.length > 0 && ((_a = response.segments[0]) == null ? void 0 : _a.words) && response.segments[0].words.length > 0;
+  if (hasNestedWords) {
+    return extractWordTimelineFromSegments(response.segments);
+  }
+  return response.segments.map((entry) => ({
+    type: "segment",
+    text: entry.text,
+    startTime: entry.start,
+    endTime: entry.end
+  }));
+}
+function extractWordTimelineFromSegments(segments) {
+  var _a, _b;
+  if (segments.length === 0) {
+    return [];
+  }
+  const splitOffsets = findSplitOffsets(segments);
+  const wordTimeline = [];
+  let currentOffsetIndex = 0;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!(segment == null ? void 0 : segment.words) || segment.words.length === 0 || !segment.words[0]) {
+      continue;
+    }
+    while (currentOffsetIndex < splitOffsets.length - 1 && i >= (((_a = splitOffsets[currentOffsetIndex + 1]) == null ? void 0 : _a.segmentIndex) ?? -1)) {
+      currentOffsetIndex++;
+    }
+    const timeOffset = currentOffsetIndex < splitOffsets.length ? ((_b = splitOffsets[currentOffsetIndex]) == null ? void 0 : _b.offset) ?? 0 : 0;
+    for (const word of segment.words) {
+      const text = word.word.trim();
+      if (text === "" || text.includes("BLANK_AUDIO")) {
+        continue;
+      }
+      wordTimeline.push({
+        type: "word",
+        text,
+        startTime: word.start + timeOffset,
+        endTime: word.end + timeOffset,
+        confidence: word.probability ?? 0
+      });
+    }
+  }
+  return wordTimeline;
+}
+function findSplitOffsets(segments) {
+  var _a;
+  const splitOffsets = [];
+  let lastWordEnd = -1;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!(segment == null ? void 0 : segment.words) || segment.words.length === 0 || !segment.words[0]) {
+      continue;
+    }
+    const firstWordStart = segment.words[0].start;
+    if (firstWordStart < lastWordEnd - 0.5 || lastWordEnd === -1) {
+      splitOffsets.push({ segmentIndex: i, offset: segment.start });
+    }
+    lastWordEnd = ((_a = segment.words[segment.words.length - 1]) == null ? void 0 : _a.end) ?? -1;
+  }
+  return splitOffsets;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inputPreference,
+  recognize
+});

package/dist/recognition/OpenAICloudSTT.d.cts

@@ -0,0 +1,29 @@
+import { AudioFormat } from '../audio/AudioFormat.cjs';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.cjs';
+import { Timeline } from '../utilities/Timeline.cjs';
+import { Timing } from '../utilities/Timing.cjs';
+import 'node:fs';
+import 'node:stream';
+
+type InputPreference = "stream";
+declare const inputPreference: InputPreference;
+interface OpenAICloudSTTOptions {
+    model?: "whisper-1" | undefined;
+    apiKey?: string | undefined;
+    organization?: string | undefined;
+    baseURL?: string | undefined;
+    temperature?: number | undefined;
+    prompt?: string | undefined;
+    timeout?: number | undefined;
+    maxRetries?: number | undefined;
+    requestWordTimestamps?: boolean | undefined;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+interface RecognitionResult {
+    transcript: string;
+    timeline?: Timeline;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options: OpenAICloudSTTOptions): Promise<RecognitionResult>;
+
+export { type InputPreference, type OpenAICloudSTTOptions, type RecognitionResult, inputPreference, recognize };

package/dist/recognition/OpenAICloudSTT.d.ts

@@ -0,0 +1,29 @@
+import { AudioFormat } from '../audio/AudioFormat.js';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.js';
+import { Timeline } from '../utilities/Timeline.js';
+import { Timing } from '../utilities/Timing.js';
+import 'node:fs';
+import 'node:stream';
+
+type InputPreference = "stream";
+declare const inputPreference: InputPreference;
+interface OpenAICloudSTTOptions {
+    model?: "whisper-1" | undefined;
+    apiKey?: string | undefined;
+    organization?: string | undefined;
+    baseURL?: string | undefined;
+    temperature?: number | undefined;
+    prompt?: string | undefined;
+    timeout?: number | undefined;
+    maxRetries?: number | undefined;
+    requestWordTimestamps?: boolean | undefined;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+interface RecognitionResult {
+    transcript: string;
+    timeline?: Timeline;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options: OpenAICloudSTTOptions): Promise<RecognitionResult>;
+
+export { type InputPreference, type OpenAICloudSTTOptions, type RecognitionResult, inputPreference, recognize };

package/dist/recognition/OpenAICloudSTT.js

@@ -0,0 +1,150 @@
+import { createReadStream } from "node:fs";
+import {
+  isAudioSource,
+  normalizeToAudioSource,
+  prepareForService,
+  toFilePath
+} from "../audio/index.js";
+import { extendDeep } from "../utilities/ObjectUtilities.js";
+const SERVICE_ID = "openai-cloud";
+const inputPreference = "stream";
+const defaultOptions = {
+  apiKey: void 0,
+  organization: void 0,
+  baseURL: void 0,
+  model: void 0,
+  temperature: 0,
+  prompt: void 0,
+  timeout: void 0,
+  maxRetries: 10,
+  requestWordTimestamps: void 0
+};
+async function recognize(input, languageCode, options) {
+  const opts = extendDeep(defaultOptions, options);
+  const timing = opts.timing;
+  if (opts.requestWordTimestamps === void 0) {
+    opts.requestWordTimestamps = opts.baseURL === void 0;
+  }
+  if (opts.model === void 0) {
+    if (opts.baseURL === void 0) {
+      opts.model = "whisper-1";
+    } else {
+      throw new Error(
+        "A custom provider for the OpenAI Cloud API requires specifying a model name"
+      );
+    }
+  }
+  const source = isAudioSource(input) ? input : normalizeToAudioSource(input, opts.inputFormat);
+  const doPrepare = () => prepareForService(source, { service: SERVICE_ID, preferFile: true });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  const conversionOccurred = source.format !== prepared.source.format;
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionOccurred);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", prepared.source.format);
+  try {
+    const { default: OpenAI } = await import("openai");
+    const openai = new OpenAI(opts);
+    const filePath = toFilePath(prepared.source);
+    if (!filePath) {
+      throw new Error(
+        "OpenAI Cloud STT requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    const file = createReadStream(filePath);
+    const timestamp_granularities = opts.requestWordTimestamps ? ["word", "segment"] : void 0;
+    const doUpload = () => openai.audio.transcriptions.create({
+      file,
+      model: opts.model,
+      language: languageCode,
+      prompt: opts.prompt,
+      response_format: "verbose_json",
+      temperature: opts.temperature,
+      timestamp_granularities,
+      stream: false
+    });
+    const response = timing ? await timing.timeAsync("upload", doUpload) : await doUpload();
+    const verboseResponse = response;
+    const transcript = verboseResponse.text.trim();
+    const timeline = extractTimeline(verboseResponse);
+    if (!timeline) {
+      throw new Error("Failed to extract timeline from OpenAI Cloud response");
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+function extractTimeline(response) {
+  var _a;
+  if (response.words) {
+    return response.words.map((entry) => ({
+      type: "word",
+      text: entry.word,
+      startTime: entry.start,
+      endTime: entry.end
+    }));
+  }
+  const hasNestedWords = response.segments.length > 0 && ((_a = response.segments[0]) == null ? void 0 : _a.words) && response.segments[0].words.length > 0;
+  if (hasNestedWords) {
+    return extractWordTimelineFromSegments(response.segments);
+  }
+  return response.segments.map((entry) => ({
+    type: "segment",
+    text: entry.text,
+    startTime: entry.start,
+    endTime: entry.end
+  }));
+}
+function extractWordTimelineFromSegments(segments) {
+  var _a, _b;
+  if (segments.length === 0) {
+    return [];
+  }
+  const splitOffsets = findSplitOffsets(segments);
+  const wordTimeline = [];
+  let currentOffsetIndex = 0;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!(segment == null ? void 0 : segment.words) || segment.words.length === 0 || !segment.words[0]) {
+      continue;
+    }
+    while (currentOffsetIndex < splitOffsets.length - 1 && i >= (((_a = splitOffsets[currentOffsetIndex + 1]) == null ? void 0 : _a.segmentIndex) ?? -1)) {
+      currentOffsetIndex++;
+    }
+    const timeOffset = currentOffsetIndex < splitOffsets.length ? ((_b = splitOffsets[currentOffsetIndex]) == null ? void 0 : _b.offset) ?? 0 : 0;
+    for (const word of segment.words) {
+      const text = word.word.trim();
+      if (text === "" || text.includes("BLANK_AUDIO")) {
+        continue;
+      }
+      wordTimeline.push({
+        type: "word",
+        text,
+        startTime: word.start + timeOffset,
+        endTime: word.end + timeOffset,
+        confidence: word.probability ?? 0
+      });
+    }
+  }
+  return wordTimeline;
+}
+function findSplitOffsets(segments) {
+  var _a;
+  const splitOffsets = [];
+  let lastWordEnd = -1;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!(segment == null ? void 0 : segment.words) || segment.words.length === 0 || !segment.words[0]) {
+      continue;
+    }
+    const firstWordStart = segment.words[0].start;
+    if (firstWordStart < lastWordEnd - 0.5 || lastWordEnd === -1) {
+      splitOffsets.push({ segmentIndex: i, offset: segment.start });
+    }
+    lastWordEnd = ((_a = segment.words[segment.words.length - 1]) == null ? void 0 : _a.end) ?? -1;
+  }
+  return splitOffsets;
+}
+export {
+  inputPreference,
+  recognize
+};

package/dist/recognition/WhisperCppSTT.cjs

@@ -0,0 +1,296 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WhisperCppSTT_exports = {};
+__export(WhisperCppSTT_exports, {
+  ensureModelDownloaded: () => ensureModelDownloaded,
+  ensureWhisperCppInstalled: () => ensureWhisperCppInstalled,
+  inputPreference: () => inputPreference,
+  recognize: () => recognize
+});
+module.exports = __toCommonJS(WhisperCppSTT_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_fs_extra = require("fs-extra");
+var import_audio = require("../audio/index.cjs");
+var import_config = require("../cli/config.cjs");
+var import_install = require("../cli/install.cjs");
+var import_WhisperTimeline = require("../utilities/WhisperTimeline.cjs");
+const inputPreference = "file";
+const defaultOptions = {
+  processors: 1,
+  threads: 4,
+  flashAttention: true,
+  suppressNonSpeechTokens: true,
+  tokenLevelTimestamps: true,
+  printOutput: false,
+  model: "tiny.en",
+  autoInstall: true
+};
+const acceptedFormats = ["wav", "flac", "ogg", "mp3"];
+async function recognize(input, options) {
+  const opts = { ...defaultOptions, ...options };
+  const timing = opts.timing;
+  const modelDir = opts.modelDir ?? (0, import_config.getModelDir)();
+  const installDir = opts.installDir ?? (0, import_config.getInstallDir)();
+  const source = (0, import_audio.isAudioSource)(input) ? input : (0, import_audio.normalizeToAudioSource)(input, opts.inputFormat);
+  await (0, import_fs_extra.ensureDir)(modelDir);
+  const doInstall = async () => {
+    await ensureWhisperCppInstalled();
+    await ensureModelDownloaded(modelDir, opts.model, opts.printOutput);
+  };
+  if (opts.autoInstall) {
+    if (timing) {
+      await timing.timeAsync("installation", doInstall);
+    } else {
+      await doInstall();
+    }
+  }
+  const conversionNeeded = !acceptedFormats.includes(source.format);
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", conversionNeeded ? "wav" : source.format);
+  const doPrepare = async () => {
+    if (!conversionNeeded) return { source, cleanup: async () => {
+    } };
+    return (0, import_audio.prepareWavForService)(source, { sampleRate: 16e3, channels: 1 });
+  };
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const inputPath = (0, import_audio.toFilePath)(prepared.source);
+    if (!inputPath) {
+      throw new Error(
+        "whisper.cpp requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    if (!(0, import_node_fs.existsSync)(inputPath)) {
+      throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+    const audioDuration = await (0, import_audio.getAudioDuration)(inputPath);
+    const effectiveProcessors = (0, import_WhisperTimeline.calculateEffectiveProcessors)(
+      audioDuration,
+      opts.processors
+    );
+    const doTranscribe = () => transcribe({
+      inputPath,
+      model: opts.model,
+      installDir,
+      modelFolder: modelDir,
+      language: opts.language ?? null,
+      tokenLevelTimestamps: opts.tokenLevelTimestamps,
+      printOutput: opts.printOutput,
+      flashAttention: opts.flashAttention,
+      suppressNonSpeechTokens: opts.suppressNonSpeechTokens,
+      processors: effectiveProcessors,
+      threads: opts.threads,
+      onProgress: opts.onProgress ?? null,
+      signal: opts.signal ?? null
+    });
+    const transcription = timing ? await timing.timeAsync("transcription", doTranscribe) : await doTranscribe();
+    const rawSegments = (0, import_WhisperTimeline.parseWhisperCppOutput)(transcription.transcription);
+    const splitBoundaries = effectiveProcessors > 1 ? (0, import_WhisperTimeline.calculateWhisperSplits)(audioDuration, effectiveProcessors) : [];
+    const timeline = (0, import_WhisperTimeline.extractCorrectedTimeline)(rawSegments, {
+      splitBoundaries: splitBoundaries.length > 0 ? splitBoundaries : void 0
+    });
+    const transcript = transcription.transcription.map((s) => s.text).join("").trim();
+    return {
+      transcript,
+      timeline,
+      language: transcription.result.language
+    };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function ensureWhisperCppInstalled() {
+  await (0, import_install.installBinary)({ printOutput: false });
+}
+async function ensureModelDownloaded(modelDir, modelName, printOutput) {
+  const modelPath = (0, import_config.getModelPath)(modelName, modelDir);
+  if ((0, import_node_fs.existsSync)(modelPath)) {
+    return;
+  }
+  await (0, import_install.installModel)({
+    model: modelName,
+    modelDir,
+    printOutput
+  });
+}
+function getModelPath(folder, model) {
+  return import_node_path.default.join(folder, `ggml-${model}.bin`);
+}
+async function transcribe(options) {
+  const {
+    inputPath,
+    model,
+    installDir,
+    modelFolder,
+    language,
+    tokenLevelTimestamps,
+    printOutput,
+    flashAttention,
+    suppressNonSpeechTokens,
+    processors,
+    threads,
+    onProgress,
+    signal
+  } = options;
+  const executable = (0, import_config.getWhisperExecutablePath)(installDir);
+  const modelPath = getModelPath(modelFolder, model);
+  if (!(0, import_node_fs.existsSync)(executable)) {
+    throw new Error(`Whisper executable not found at ${executable}`);
+  }
+  if (!(0, import_node_fs.existsSync)(modelPath)) {
+    throw new Error(`Model not found at ${modelPath}`);
+  }
+  const tmpDir = import_node_path.default.join(import_node_os.default.tmpdir(), "ghost-story-whisper");
+  await (0, import_fs_extra.ensureDir)(tmpDir);
+  const tmpJsonPath = import_node_path.default.join(tmpDir, `transcription-${Date.now()}`);
+  const args = buildTranscribeArgs({
+    inputPath,
+    modelPath,
+    outputPath: tmpJsonPath,
+    model,
+    language,
+    tokenLevelTimestamps,
+    flashAttention,
+    suppressNonSpeechTokens,
+    processors,
+    threads
+  });
+  try {
+    const outputPath = await runWhisperProcess({
+      executable,
+      args,
+      cwd: installDir,
+      printOutput,
+      onProgress,
+      signal,
+      expectedOutputPath: `${tmpJsonPath}.json`
+    });
+    const json = JSON.parse(
+      await import_node_fs.default.promises.readFile(outputPath, "utf8")
+    );
+    import_node_fs.default.promises.unlink(outputPath).catch(() => {
+    });
+    return json;
+  } catch (error) {
+    await import_node_fs.default.promises.unlink(`${tmpJsonPath}.json`).catch(() => {
+    });
+    throw error;
+  }
+}
+function buildTranscribeArgs(options) {
+  const args = [
+    "--file",
+    options.inputPath,
+    "--output-file",
+    options.outputPath,
+    "--output-json-full",
+    "--model",
+    options.modelPath,
+    "--print-progress",
+    options.language ? ["--language", options.language.toLowerCase()] : null,
+    options.flashAttention ? ["--flash-attn"] : null,
+    options.suppressNonSpeechTokens ? ["--suppress-nst", "--no-prints"] : null,
+    ["--processors", String(options.processors)],
+    ["--threads", String(options.threads)]
+  ];
+  return args.flat().filter((arg) => arg !== null);
+}
+function runWhisperProcess(options) {
+  const {
+    executable,
+    args,
+    cwd,
+    printOutput,
+    onProgress,
+    signal,
+    expectedOutputPath
+  } = options;
+  if (signal == null ? void 0 : signal.aborted) {
+    return Promise.reject(new Error("Signal aborted"));
+  }
+  return new Promise((resolve, reject) => {
+    const task = (0, import_node_child_process.spawn)(executable, args, { cwd, signal: signal ?? void 0 });
+    let output = "";
+    const handleData = (data) => {
+      const str = data.toString("utf-8");
+      output += str;
+      if (str.includes("progress =")) {
+        const match = str.match(/progress\s*=\s*([\d.]+)/);
+        if (match == null ? void 0 : match[1]) {
+          onProgress == null ? void 0 : onProgress(parseFloat(match[1]) / 100);
+        }
+      }
+    };
+    task.stdout.on("data", (data) => {
+      handleData(data);
+      if (printOutput) {
+        process.stdout.write(data);
+      }
+    });
+    task.stderr.on("data", (data) => {
+      handleData(data);
+      if (printOutput) {
+        process.stderr.write(data);
+      }
+    });
+    task.on("exit", (code, exitSignal) => {
+      if ((0, import_node_fs.existsSync)(expectedOutputPath)) {
+        onProgress == null ? void 0 : onProgress(1);
+        resolve(expectedOutputPath);
+        return;
+      }
+      if (exitSignal) {
+        reject(new Error(`Process killed with signal ${exitSignal}: ${output}`));
+        return;
+      }
+      if (output.includes("must be 16 kHz")) {
+        reject(
+          new Error(
+            "Audio file must be 16 kHz. Convert your audio to 16-bit, 16KHz WAV format."
+          )
+        );
+        return;
+      }
+      reject(new Error(`Transcription failed (exit code ${code}): ${output}`));
+    });
+    task.on("error", (err) => {
+      reject(new Error(`Failed to start whisper process: ${err.message}`));
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureModelDownloaded,
+  ensureWhisperCppInstalled,
+  inputPreference,
+  recognize
+});