@storyteller-platform/align 0.0.1

package/dist/transcribe/transcribe.cjs

@@ -0,0 +1,400 @@
+"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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var transcribe_exports = {};
+__export(transcribe_exports, {
+  transcribe: () => transcribe,
+  transcribeFile: () => transcribeFile
+});
+module.exports = __toCommonJS(transcribe_exports);
+var import_promises = require("node:fs/promises");
+var os = __toESM(require("node:os"), 1);
+var import_node_path = require("node:path");
+var import_async_semaphore = require("@esfx/async-semaphore");
+var import_audiobook = require("@storyteller-platform/audiobook");
+var import_ghost_story = require("@storyteller-platform/ghost-story");
+async function transcribe(input, output, locale, options) {
+  var _a;
+  if (process.env["DEBUG_TRANSCRIBE"] === "true") {
+    const inspector = await import("node:inspector");
+    inspector.open(9231, "0.0.0.0", true);
+  }
+  const semaphore = new import_async_semaphore.AsyncSemaphore(options.parallelism ?? 1);
+  const controller = new AbortController();
+  const signal = AbortSignal.any([
+    options.signal ?? new AbortSignal(),
+    controller.signal
+  ]);
+  await (0, import_promises.mkdir)(output, { recursive: true });
+  const allFiles = await (0, import_promises.readdir)(input, { recursive: true });
+  const filenames = allFiles.filter((f) => (0, import_audiobook.isAudioFile)(f));
+  if (!filenames.length) {
+    throw new Error(
+      `Failed to transcribe audio: found no audio files in ${input}`
+    );
+  }
+  const engine = options.engine ?? "whisper.cpp";
+  const model = options.model ?? "tiny.en";
+  if (engine === "whisper.cpp") {
+    await (0, import_ghost_story.ensureWhisperInstalled)({
+      model,
+      printOutput: ["debug", "info"].includes(
+        ((_a = options.logger) == null ? void 0 : _a.level) ?? "silent"
+      ),
+      signal
+    });
+  }
+  const transcriptions = [];
+  function aborted() {
+    return signal.aborted;
+  }
+  const perFileProgress = /* @__PURE__ */ new Map();
+  const timing = (0, import_ghost_story.createAggregator)();
+  timing.setMetadata("engine", engine);
+  timing.setMetadata("parallelization", options.parallelism ?? 1);
+  timing.setMetadata("processors", options.processors ?? 1);
+  timing.setMetadata("threads", options.threads ?? 4);
+  await Promise.all(
+    filenames.map(async (filename) => {
+      var _a2, _b, _c;
+      var _stack = [];
+      try {
+        if (aborted()) throw new Error("Aborted");
+        const filepath = (0, import_node_path.join)(input, filename);
+        const transcriptionFilepath = (0, import_node_path.join)(
+          output,
+          `${(0, import_node_path.basename)(filename, (0, import_node_path.extname)(filename))}.json`
+        );
+        try {
+          await (0, import_promises.readFile)(transcriptionFilepath, {
+            encoding: "utf-8",
+            signal
+          });
+          (_a2 = options.logger) == null ? void 0 : _a2.info(`Found existing transcription for ${filepath}`);
+          transcriptions.push(transcriptionFilepath);
+        } catch {
+        }
+        if (aborted()) throw new Error("Aborted");
+        const stack = __using(_stack, new DisposableStack());
+        stack.defer(() => {
+          semaphore.release();
+        });
+        await semaphore.wait();
+        function onFileProgress(progress) {
+          var _a3, _b2;
+          perFileProgress.set(filename, progress);
+          const updatedProgress = Array.from(perFileProgress.values()).reduce((acc, p) => acc + p) / filenames.length;
+          (_a3 = options.logger) == null ? void 0 : _a3.info(
+            `Progress: ${Math.floor(updatedProgress * 100)}%`
+          );
+          (_b2 = options.onProgress) == null ? void 0 : _b2.call(options, updatedProgress);
+        }
+        const transcription = await transcribeFile(filepath, locale, {
+          ...options,
+          signal,
+          engine,
+          model,
+          processors: options.processors ?? 1,
+          threads: options.threads ?? 4,
+          onProgress: onFileProgress
+        });
+        (_b = options.logger) == null ? void 0 : _b.info(
+          (0, import_ghost_story.formatSingleReport)(
+            transcription.timing,
+            `Transcription Timing Report for ${filepath}`
+          )
+        );
+        timing.add(transcription.timing);
+        await (0, import_promises.writeFile)(
+          transcriptionFilepath,
+          JSON.stringify({
+            transcript: transcription.transcript,
+            timeline: transcription.timeline
+          }),
+          { signal }
+        );
+        transcriptions.push(transcriptionFilepath);
+        (_c = options.onProgress) == null ? void 0 : _c.call(options, (transcriptions.length + 1) / filenames.length);
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    }).map(
+      (p) => p.catch((e) => {
+        controller.abort(e);
+        throw e;
+      })
+    )
+  );
+  return timing;
+}
+async function transcribeFile(input, locale, options) {
+  var _a, _b;
+  const audioFilepath = (0, import_node_path.resolve)(process.cwd(), input);
+  const sharedOptions = {
+    signal: options.signal,
+    language: locale.language
+  };
+  switch (options.engine) {
+    case "whisper.cpp": {
+      const fallbackVariant = getCpuOverrideVariant(
+        options.whisperCpuOverride ?? null
+      );
+      const whisperOptions = await (0, import_ghost_story.ensureWhisperInstalled)({
+        model: options.model,
+        variant: fallbackVariant,
+        printOutput: ["debug", "info"].includes(
+          ((_a = options.logger) == null ? void 0 : _a.level) ?? "silent"
+        ),
+        signal: options.signal
+      });
+      (_b = options.logger) == null ? void 0 : _b.info(`Transcribing audio file ${audioFilepath}`);
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: options.engine,
+        options: {
+          flashAttention: true,
+          model: getWhisperCppModelId(sharedOptions.language, options.model),
+          processors: options.processors,
+          threads: options.threads,
+          onProgress: (progress) => {
+            var _a2;
+            if (options.onProgress) {
+              options.onProgress(progress);
+              return;
+            }
+            (_a2 = options.logger) == null ? void 0 : _a2.info(
+              `Transcribing ${audioFilepath} progress: ${Math.floor(progress * 100)}%`
+            );
+          },
+          ...whisperOptions
+        },
+        ...sharedOptions
+      });
+    }
+    case "google-cloud": {
+      if (!options.googleCloudApiKey) {
+        throw new Error(
+          "Failed to start transcription with engine google-cloud: missing API key"
+        );
+      }
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "google-cloud",
+        options: {
+          apiKey: options.googleCloudApiKey
+        },
+        ...sharedOptions
+      });
+    }
+    case "microsoft-azure": {
+      if (!options.azureServiceRegion) {
+        throw new Error(
+          "Failed to start transcription with engine microsoft-azure: missing service region"
+        );
+      }
+      if (!options.azureSubscriptionKey) {
+        throw new Error(
+          "Failed to start transcription with engine microsoft-azure: missing subscription key"
+        );
+      }
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "microsoft-azure",
+        options: {
+          serviceRegion: options.azureServiceRegion,
+          subscriptionKey: options.azureSubscriptionKey
+        },
+        ...sharedOptions
+      });
+    }
+    case "amazon-transcribe": {
+      if (!options.amazonTranscribeRegion) {
+        throw new Error(
+          "Failed to start transcription with engine amazon-transcribe: missing region"
+        );
+      }
+      if (!options.amazonTranscribeAccessKeyId) {
+        throw new Error(
+          "Failed to start transcription with engine amazon-transcribe: missing access key id"
+        );
+      }
+      if (!options.amazonTranscribeSecretAccessKey) {
+        throw new Error(
+          "Failed to start transcription with engine amazon-transcribe: missing access secret access key"
+        );
+      }
+      if (!options.amazonTranscribeBucketName) {
+        throw new Error(
+          "Failed to start transcription with engine amazon-transcribe: missing bucket name"
+        );
+      }
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "amazon-transcribe",
+        options: {
+          region: options.amazonTranscribeRegion,
+          accessKeyId: options.amazonTranscribeAccessKeyId,
+          secretAccessKey: options.amazonTranscribeSecretAccessKey,
+          bucketName: options.amazonTranscribeBucketName
+        },
+        ...sharedOptions
+      });
+    }
+    case "openai-cloud": {
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "openai-cloud",
+        options: {
+          ...options.openAiApiKey && { apiKey: options.openAiApiKey },
+          ...options.openAiOrganization && {
+            organization: options.openAiOrganization
+          },
+          ...options.openAiBaseUrl && { baseURL: options.openAiBaseUrl },
+          model: options.openAiModelName ?? "whisper-1"
+        },
+        ...sharedOptions
+      });
+    }
+    case "whisper-server": {
+      if (!options.whisperServerUrl) {
+        throw new Error(
+          "Failed to start transcription with engine whisper-server: missing server url"
+        );
+      }
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "whisper-server",
+        options: {
+          baseURL: options.whisperServerUrl,
+          ...options.whisperServerApiKey && {
+            apiKey: options.whisperServerApiKey
+          }
+        },
+        ...sharedOptions
+      });
+    }
+    case "deepgram": {
+      if (!options.deepgramApiKey) {
+        throw new Error(
+          "Failed to start transcription with engine deepgram: missing api key"
+        );
+      }
+      return (0, import_ghost_story.recognize)(audioFilepath, {
+        engine: "deepgram",
+        options: {
+          apiKey: options.deepgramApiKey,
+          // nova-3 is just as cheap as nova-2 and has better performance
+          model: options.deepgramModel ?? "nova-3",
+          punctuate: true
+        },
+        ...sharedOptions
+      });
+    }
+    default: {
+      throw new Error(
+        `Unknown transcription engine: ${options.engine}`
+      );
+    }
+  }
+}
+function getWhisperCppModelId(language, modelType) {
+  if (modelType === "large") return "large-v3-turbo";
+  if (language !== "en" || modelType.startsWith("large")) return modelType;
+  if (modelType.includes(".en")) return modelType;
+  const quant = modelType.indexOf("-q");
+  if (quant === -1) return `${modelType}.en`;
+  return `${modelType.slice(0, quant)}.en${modelType.slice(quant)}`;
+}
+function getCpuOverrideVariant(override) {
+  if (!override) return void 0;
+  const platform = os.platform();
+  const arch = os.arch();
+  if (platform === "linux" && arch === "x64") {
+    const variant = override === "blas" ? "linux-x64-blas" : "linux-x64-cpu";
+    return (0, import_ghost_story.applyLegacyCpuFallback)(variant);
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return "linux-arm64-cpu";
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return "darwin-arm64-cpu";
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return "darwin-x64-cpu";
+  }
+  if (platform === "win32") {
+    return "windows-x64-cpu";
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transcribe,
+  transcribeFile
+});

package/dist/transcribe/transcribe.d.cts

@@ -0,0 +1,41 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { RecognitionEngine, WhisperModel, TimingAggregator } from '@storyteller-platform/ghost-story';
+import { Logger } from 'pino';
+
+type WhisperCpuOverride = "blas" | "cpu" | null;
+interface TranscribeOptions {
+    onProgress?: ((progress: number) => void) | null | undefined;
+    parallelism?: number | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    engine?: RecognitionEngine | null | undefined;
+    model?: WhisperModel | null | undefined;
+    processors?: number | null | undefined;
+    threads?: number | null | undefined;
+    whisperCpuOverride?: WhisperCpuOverride | null | undefined;
+    logger?: Logger | null | undefined;
+    googleCloudApiKey?: string | null | undefined;
+    azureServiceRegion?: string | null | undefined;
+    azureSubscriptionKey?: string | null | undefined;
+    amazonTranscribeRegion?: string | null | undefined;
+    amazonTranscribeAccessKeyId?: string | null | undefined;
+    amazonTranscribeSecretAccessKey?: string | null | undefined;
+    amazonTranscribeBucketName?: string | null | undefined;
+    openAiApiKey?: string | null | undefined;
+    openAiOrganization?: string | null | undefined;
+    openAiBaseUrl?: string | null | undefined;
+    openAiModelName?: string | null | undefined;
+    whisperServerUrl?: string | null | undefined;
+    whisperServerApiKey?: string | null | undefined;
+    deepgramApiKey?: string | null | undefined;
+    deepgramModel?: string | null | undefined;
+}
+declare function transcribe(input: string, output: string, locale: Intl.Locale, options: TranscribeOptions): Promise<TimingAggregator>;
+interface TranscribeFileOptions extends Omit<TranscribeOptions, "engine" | "model" | "processors" | "threads"> {
+    engine: RecognitionEngine;
+    model: WhisperModel;
+    processors: number;
+    threads: number;
+}
+declare function transcribeFile(input: string, locale: Intl.Locale, options: TranscribeFileOptions): Promise<_storyteller_platform_ghost_story.RecognitionResult>;
+
+export { type TranscribeFileOptions, type TranscribeOptions, transcribe, transcribeFile };

package/dist/transcribe/transcribe.d.ts

@@ -0,0 +1,41 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { RecognitionEngine, WhisperModel, TimingAggregator } from '@storyteller-platform/ghost-story';
+import { Logger } from 'pino';
+
+type WhisperCpuOverride = "blas" | "cpu" | null;
+interface TranscribeOptions {
+    onProgress?: ((progress: number) => void) | null | undefined;
+    parallelism?: number | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    engine?: RecognitionEngine | null | undefined;
+    model?: WhisperModel | null | undefined;
+    processors?: number | null | undefined;
+    threads?: number | null | undefined;
+    whisperCpuOverride?: WhisperCpuOverride | null | undefined;
+    logger?: Logger | null | undefined;
+    googleCloudApiKey?: string | null | undefined;
+    azureServiceRegion?: string | null | undefined;
+    azureSubscriptionKey?: string | null | undefined;
+    amazonTranscribeRegion?: string | null | undefined;
+    amazonTranscribeAccessKeyId?: string | null | undefined;
+    amazonTranscribeSecretAccessKey?: string | null | undefined;
+    amazonTranscribeBucketName?: string | null | undefined;
+    openAiApiKey?: string | null | undefined;
+    openAiOrganization?: string | null | undefined;
+    openAiBaseUrl?: string | null | undefined;
+    openAiModelName?: string | null | undefined;
+    whisperServerUrl?: string | null | undefined;
+    whisperServerApiKey?: string | null | undefined;
+    deepgramApiKey?: string | null | undefined;
+    deepgramModel?: string | null | undefined;
+}
+declare function transcribe(input: string, output: string, locale: Intl.Locale, options: TranscribeOptions): Promise<TimingAggregator>;
+interface TranscribeFileOptions extends Omit<TranscribeOptions, "engine" | "model" | "processors" | "threads"> {
+    engine: RecognitionEngine;
+    model: WhisperModel;
+    processors: number;
+    threads: number;
+}
+declare function transcribeFile(input: string, locale: Intl.Locale, options: TranscribeFileOptions): Promise<_storyteller_platform_ghost_story.RecognitionResult>;
+
+export { type TranscribeFileOptions, type TranscribeOptions, transcribe, transcribeFile };