@storyteller-platform/ghost-story 0.0.1

package/dist/recognition/WhisperCppSTT.d.cts

@@ -0,0 +1,40 @@
+import { AudioFormat } from '../audio/AudioFormat.cjs';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.cjs';
+import { WhisperModel } from '../cli/config.cjs';
+import { Timeline } from '../utilities/Timeline.cjs';
+import { Timing } from '../utilities/Timing.cjs';
+import 'node:fs';
+import 'node:stream';
+
+type InputPreference = "file";
+declare const inputPreference: InputPreference;
+type Language = "af" | "am" | "ar" | "as" | "az" | "ba" | "be" | "bg" | "bn" | "bo" | "br" | "bs" | "ca" | "cs" | "cy" | "da" | "de" | "el" | "en" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "gl" | "gu" | "ha" | "haw" | "he" | "hi" | "hr" | "ht" | "hu" | "hy" | "id" | "is" | "it" | "ja" | "jw" | "ka" | "kk" | "km" | "kn" | "ko" | "la" | "lb" | "ln" | "lo" | "lt" | "lv" | "mg" | "mi" | "mk" | "ml" | "mn" | "mr" | "ms" | "mt" | "my" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "ro" | "ru" | "sa" | "sd" | "si" | "sk" | "sl" | "sn" | "so" | "sq" | "sr" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "th" | "tk" | "tl" | "tr" | "tt" | "uk" | "ur" | "uz" | "vi" | "yi" | "yo" | "zh";
+
+interface WhisperCppOptions {
+    model: WhisperModel;
+    modelDir?: string;
+    installDir?: string;
+    language?: Language;
+    processors?: number;
+    threads?: number;
+    flashAttention?: boolean;
+    suppressNonSpeechTokens?: boolean;
+    tokenLevelTimestamps?: boolean;
+    printOutput?: boolean;
+    autoInstall?: boolean;
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, options?: WhisperCppOptions): Promise<RecognitionResult>;
+declare function ensureWhisperCppInstalled(): Promise<void>;
+declare function ensureModelDownloaded(modelDir: string, modelName: WhisperModel, printOutput: boolean): Promise<void>;
+interface RecognitionResult {
+    transcript: string;
+    timeline: Timeline;
+    language?: string;
+}
+type WhisperCppModelId = "tiny" | "tiny-q5_1" | "tiny.en" | "tiny.en-q5_1" | "tiny.en-q8_0" | "base" | "base-q5_1" | "base.en" | "base.en-q5_1" | "small" | "small-q5_1" | "small.en" | "small.en-q5_1" | "medium" | "medium-q5_0" | "medium.en" | "medium.en-q5_0" | "large" | "large-v1" | "large-v2" | "large-v2-q5_0" | "large-v3" | "large-v3-q5_0" | "large-v3-turbo" | "large-v3-turbo-q5_0";
+
+export { type InputPreference, type Language, type RecognitionResult, type WhisperCppModelId, type WhisperCppOptions, WhisperModel, ensureModelDownloaded, ensureWhisperCppInstalled, inputPreference, recognize };

package/dist/recognition/WhisperCppSTT.d.ts

@@ -0,0 +1,40 @@
+import { AudioFormat } from '../audio/AudioFormat.js';
+import { RawAudioInput, AudioSource } from '../audio/AudioSource.js';
+import { WhisperModel } from '../cli/config.js';
+import { Timeline } from '../utilities/Timeline.js';
+import { Timing } from '../utilities/Timing.js';
+import 'node:fs';
+import 'node:stream';
+
+type InputPreference = "file";
+declare const inputPreference: InputPreference;
+type Language = "af" | "am" | "ar" | "as" | "az" | "ba" | "be" | "bg" | "bn" | "bo" | "br" | "bs" | "ca" | "cs" | "cy" | "da" | "de" | "el" | "en" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "gl" | "gu" | "ha" | "haw" | "he" | "hi" | "hr" | "ht" | "hu" | "hy" | "id" | "is" | "it" | "ja" | "jw" | "ka" | "kk" | "km" | "kn" | "ko" | "la" | "lb" | "ln" | "lo" | "lt" | "lv" | "mg" | "mi" | "mk" | "ml" | "mn" | "mr" | "ms" | "mt" | "my" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "ro" | "ru" | "sa" | "sd" | "si" | "sk" | "sl" | "sn" | "so" | "sq" | "sr" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "th" | "tk" | "tl" | "tr" | "tt" | "uk" | "ur" | "uz" | "vi" | "yi" | "yo" | "zh";
+
+interface WhisperCppOptions {
+    model: WhisperModel;
+    modelDir?: string;
+    installDir?: string;
+    language?: Language;
+    processors?: number;
+    threads?: number;
+    flashAttention?: boolean;
+    suppressNonSpeechTokens?: boolean;
+    tokenLevelTimestamps?: boolean;
+    printOutput?: boolean;
+    autoInstall?: boolean;
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+declare function recognize(input: RawAudioInput | AudioSource, options?: WhisperCppOptions): Promise<RecognitionResult>;
+declare function ensureWhisperCppInstalled(): Promise<void>;
+declare function ensureModelDownloaded(modelDir: string, modelName: WhisperModel, printOutput: boolean): Promise<void>;
+interface RecognitionResult {
+    transcript: string;
+    timeline: Timeline;
+    language?: string;
+}
+type WhisperCppModelId = "tiny" | "tiny-q5_1" | "tiny.en" | "tiny.en-q5_1" | "tiny.en-q8_0" | "base" | "base-q5_1" | "base.en" | "base.en-q5_1" | "small" | "small-q5_1" | "small.en" | "small.en-q5_1" | "medium" | "medium-q5_0" | "medium.en" | "medium.en-q5_0" | "large" | "large-v1" | "large-v2" | "large-v2-q5_0" | "large-v3" | "large-v3-q5_0" | "large-v3-turbo" | "large-v3-turbo-q5_0";
+
+export { type InputPreference, type Language, type RecognitionResult, type WhisperCppModelId, type WhisperCppOptions, WhisperModel, ensureModelDownloaded, ensureWhisperCppInstalled, inputPreference, recognize };

package/dist/recognition/WhisperCppSTT.js

@@ -0,0 +1,275 @@
+import { spawn } from "node:child_process";
+import fs, { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ensureDir } from "fs-extra";
+import {
+  getAudioDuration,
+  isAudioSource,
+  normalizeToAudioSource,
+  prepareWavForService,
+  toFilePath
+} from "../audio/index.js";
+import {
+  getInstallDir,
+  getModelDir,
+  getModelPath as getModelPathFromConfig,
+  getWhisperExecutablePath
+} from "../cli/config.js";
+import { installBinary, installModel } from "../cli/install.js";
+import {
+  calculateEffectiveProcessors,
+  calculateWhisperSplits,
+  extractCorrectedTimeline,
+  parseWhisperCppOutput
+} from "../utilities/WhisperTimeline.js";
+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 ?? getModelDir();
+  const installDir = opts.installDir ?? getInstallDir();
+  const source = isAudioSource(input) ? input : normalizeToAudioSource(input, opts.inputFormat);
+  await 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 prepareWavForService(source, { sampleRate: 16e3, channels: 1 });
+  };
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const inputPath = toFilePath(prepared.source);
+    if (!inputPath) {
+      throw new Error(
+        "whisper.cpp requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    if (!existsSync(inputPath)) {
+      throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+    const audioDuration = await getAudioDuration(inputPath);
+    const effectiveProcessors = 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 = parseWhisperCppOutput(transcription.transcription);
+    const splitBoundaries = effectiveProcessors > 1 ? calculateWhisperSplits(audioDuration, effectiveProcessors) : [];
+    const timeline = 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 installBinary({ printOutput: false });
+}
+async function ensureModelDownloaded(modelDir, modelName, printOutput) {
+  const modelPath = getModelPathFromConfig(modelName, modelDir);
+  if (existsSync(modelPath)) {
+    return;
+  }
+  await installModel({
+    model: modelName,
+    modelDir,
+    printOutput
+  });
+}
+function getModelPath(folder, model) {
+  return path.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 = getWhisperExecutablePath(installDir);
+  const modelPath = getModelPath(modelFolder, model);
+  if (!existsSync(executable)) {
+    throw new Error(`Whisper executable not found at ${executable}`);
+  }
+  if (!existsSync(modelPath)) {
+    throw new Error(`Model not found at ${modelPath}`);
+  }
+  const tmpDir = path.join(os.tmpdir(), "ghost-story-whisper");
+  await ensureDir(tmpDir);
+  const tmpJsonPath = path.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 fs.promises.readFile(outputPath, "utf8")
+    );
+    fs.promises.unlink(outputPath).catch(() => {
+    });
+    return json;
+  } catch (error) {
+    await fs.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 = 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 (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}`));
+    });
+  });
+}
+export {
+  ensureModelDownloaded,
+  ensureWhisperCppInstalled,
+  inputPreference,
+  recognize
+};

package/dist/recognition/WhisperServerSTT.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WhisperServerSTT_exports = {};
+__export(WhisperServerSTT_exports, {
+  inputPreference: () => inputPreference,
+  recognize: () => recognize
+});
+module.exports = __toCommonJS(WhisperServerSTT_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_audio = require("../audio/index.cjs");
+var import_WhisperTimeline = require("../utilities/WhisperTimeline.cjs");
+const inputPreference = "file";
+const defaultOptions = {
+  baseURL: "http://localhost:8080",
+  inferencePath: "/audio/transcriptions",
+  temperature: 0
+};
+async function recognize(input, languageCode, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const timing = opts.timing;
+  const source = (0, import_audio.isAudioSource)(input) ? input : (0, import_audio.normalizeToAudioSource)(input, opts.inputFormat);
+  const conversionNeeded = source.format !== "wav";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", "wav");
+  const doPrepare = () => (0, import_audio.prepareWavForService)(source, { sampleRate: 16e3, channels: 1 });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const filePath = (0, import_audio.toFilePath)(prepared.source);
+    if (!filePath) {
+      throw new Error(
+        "Whisper server requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    const filename = (0, import_node_path.basename)(filePath);
+    const blob = await (0, import_node_fs.openAsBlob)(filePath);
+    const form = new FormData();
+    form.append("file", blob, filename);
+    form.append("temperature", String(opts.temperature));
+    form.append("response_format", "verbose_json");
+    if (languageCode) {
+      form.append("language", languageCode);
+    }
+    const url = `${opts.baseURL}${opts.inferencePath}`;
+    const headers = {};
+    if (opts.apiKey) {
+      headers["Authorization"] = `Bearer ${opts.apiKey}`;
+    }
+    const doUpload = () => fetch(url, { method: "POST", body: form, headers });
+    const response = timing ? await timing.timeAsync("upload", doUpload) : await doUpload();
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Whisper server error: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    const { timeline, transcript } = await extractTimelineAndTranscript(
+      data,
+      filePath
+    );
+    if (!timeline) {
+      throw new Error("Failed to extract timeline from Whisper server response");
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function extractTimelineAndTranscript(response, audioPath) {
+  var _a, _b, _c, _d;
+  if (response.segments.length === 0) {
+    return { timeline: void 0, transcript: ((_a = response.text) == null ? void 0 : _a.trim()) ?? "" };
+  }
+  const hasNestedWords = (((_c = (_b = response.segments[0]) == null ? void 0 : _b.words) == null ? void 0 : _c.length) ?? 0) > 0;
+  if (hasNestedWords) {
+    const rawSegments = (0, import_WhisperTimeline.parseWhisperServerOutput)(response.segments);
+    const splitBoundaries = await detectSplitBoundaries(rawSegments, audioPath);
+    const timeline2 = (0, import_WhisperTimeline.extractCorrectedTimeline)(rawSegments, { splitBoundaries });
+    const transcript = timeline2.map((entry) => entry.text).join(" ");
+    return { timeline: timeline2, transcript };
+  }
+  const timeline = response.segments.map((seg) => ({
+    type: "segment",
+    text: seg.text.trim(),
+    startTime: seg.start,
+    endTime: seg.end
+  }));
+  return { timeline, transcript: ((_d = response.text) == null ? void 0 : _d.trim()) ?? "" };
+}
+async function detectSplitBoundaries(rawSegments, audioPath) {
+  const boundaryCount = (0, import_WhisperTimeline.countProcessorBoundaries)(rawSegments);
+  if (boundaryCount === 0) return void 0;
+  try {
+    const audioDuration = await (0, import_audio.getAudioDuration)(audioPath);
+    return (0, import_WhisperTimeline.calculateWhisperSplits)(audioDuration, boundaryCount + 1);
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inputPreference,
+  recognize
+});

package/dist/recognition/WhisperServerSTT.d.cts

@@ -0,0 +1,24 @@
+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 = "file";
+declare const inputPreference: InputPreference;
+interface WhisperServerOptions {
+    baseURL?: string;
+    inferencePath?: string;
+    temperature?: number;
+    apiKey?: string;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+interface RecognitionResult {
+    transcript: string;
+    timeline?: Timeline;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options?: WhisperServerOptions): Promise<RecognitionResult>;
+
+export { type InputPreference, type RecognitionResult, type WhisperServerOptions, inputPreference, recognize };

package/dist/recognition/WhisperServerSTT.d.ts

@@ -0,0 +1,24 @@
+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 = "file";
+declare const inputPreference: InputPreference;
+interface WhisperServerOptions {
+    baseURL?: string;
+    inferencePath?: string;
+    temperature?: number;
+    apiKey?: string;
+    inputFormat?: AudioFormat;
+    timing?: Timing | undefined;
+}
+interface RecognitionResult {
+    transcript: string;
+    timeline?: Timeline;
+}
+declare function recognize(input: RawAudioInput | AudioSource, languageCode: string, options?: WhisperServerOptions): Promise<RecognitionResult>;
+
+export { type InputPreference, type RecognitionResult, type WhisperServerOptions, inputPreference, recognize };

package/dist/recognition/WhisperServerSTT.js

@@ -0,0 +1,105 @@
+import { openAsBlob } from "node:fs";
+import { basename } from "node:path";
+import {
+  getAudioDuration,
+  isAudioSource,
+  normalizeToAudioSource,
+  prepareWavForService,
+  toFilePath
+} from "../audio/index.js";
+import {
+  calculateWhisperSplits,
+  countProcessorBoundaries,
+  extractCorrectedTimeline,
+  parseWhisperServerOutput
+} from "../utilities/WhisperTimeline.js";
+const inputPreference = "file";
+const defaultOptions = {
+  baseURL: "http://localhost:8080",
+  inferencePath: "/audio/transcriptions",
+  temperature: 0
+};
+async function recognize(input, languageCode, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const timing = opts.timing;
+  const source = isAudioSource(input) ? input : normalizeToAudioSource(input, opts.inputFormat);
+  const conversionNeeded = source.format !== "wav";
+  timing == null ? void 0 : timing.setMetadata("conversionRequired", conversionNeeded);
+  timing == null ? void 0 : timing.setMetadata("targetFormat", "wav");
+  const doPrepare = () => prepareWavForService(source, { sampleRate: 16e3, channels: 1 });
+  const prepared = timing ? await timing.timeAsync("conversion", doPrepare) : await doPrepare();
+  try {
+    const filePath = toFilePath(prepared.source);
+    if (!filePath) {
+      throw new Error(
+        "Whisper server requires a file path. The audio could not be prepared as a file."
+      );
+    }
+    const filename = basename(filePath);
+    const blob = await openAsBlob(filePath);
+    const form = new FormData();
+    form.append("file", blob, filename);
+    form.append("temperature", String(opts.temperature));
+    form.append("response_format", "verbose_json");
+    if (languageCode) {
+      form.append("language", languageCode);
+    }
+    const url = `${opts.baseURL}${opts.inferencePath}`;
+    const headers = {};
+    if (opts.apiKey) {
+      headers["Authorization"] = `Bearer ${opts.apiKey}`;
+    }
+    const doUpload = () => fetch(url, { method: "POST", body: form, headers });
+    const response = timing ? await timing.timeAsync("upload", doUpload) : await doUpload();
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Whisper server error: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    const { timeline, transcript } = await extractTimelineAndTranscript(
+      data,
+      filePath
+    );
+    if (!timeline) {
+      throw new Error("Failed to extract timeline from Whisper server response");
+    }
+    return { transcript, timeline };
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function extractTimelineAndTranscript(response, audioPath) {
+  var _a, _b, _c, _d;
+  if (response.segments.length === 0) {
+    return { timeline: void 0, transcript: ((_a = response.text) == null ? void 0 : _a.trim()) ?? "" };
+  }
+  const hasNestedWords = (((_c = (_b = response.segments[0]) == null ? void 0 : _b.words) == null ? void 0 : _c.length) ?? 0) > 0;
+  if (hasNestedWords) {
+    const rawSegments = parseWhisperServerOutput(response.segments);
+    const splitBoundaries = await detectSplitBoundaries(rawSegments, audioPath);
+    const timeline2 = extractCorrectedTimeline(rawSegments, { splitBoundaries });
+    const transcript = timeline2.map((entry) => entry.text).join(" ");
+    return { timeline: timeline2, transcript };
+  }
+  const timeline = response.segments.map((seg) => ({
+    type: "segment",
+    text: seg.text.trim(),
+    startTime: seg.start,
+    endTime: seg.end
+  }));
+  return { timeline, transcript: ((_d = response.text) == null ? void 0 : _d.trim()) ?? "" };
+}
+async function detectSplitBoundaries(rawSegments, audioPath) {
+  const boundaryCount = countProcessorBoundaries(rawSegments);
+  if (boundaryCount === 0) return void 0;
+  try {
+    const audioDuration = await getAudioDuration(audioPath);
+    return calculateWhisperSplits(audioDuration, boundaryCount + 1);
+  } catch {
+    return void 0;
+  }
+}
+export {
+  inputPreference,
+  recognize
+};