@storyteller-platform/ghost-story 0.0.1

package/dist/api/VoiceActivityDetection.cjs

@@ -0,0 +1,77 @@
+"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 VoiceActivityDetection_exports = {};
+__export(VoiceActivityDetection_exports, {
+  detectVoiceActivity: () => detectVoiceActivity
+});
+module.exports = __toCommonJS(VoiceActivityDetection_exports);
+var import_ObjectUtilities = require("../utilities/ObjectUtilities.cjs");
+const defaultVoiceActivityDetectionOptions = {
+  engine: "active-gate-og"
+};
+async function detectVoiceActivity(inputPath, options = defaultVoiceActivityDetectionOptions) {
+  const opts = (0, import_ObjectUtilities.extendDeep)(defaultVoiceActivityDetectionOptions, options);
+  switch (opts.engine) {
+    case "silero": {
+      const SileroVAD = await import("../vad/Silero.cjs");
+      const sileroOpts = "silero" in opts ? opts.silero : void 0;
+      return SileroVAD.detectVoiceActivity(inputPath, sileroOpts);
+    }
+    case "active-gate-og": {
+      const ActiveGateOgVAD = await import("../vad/ActiveGateOg.cjs");
+      const activeGateOgOpts = "activeGateOg" in opts ? opts.activeGateOg : void 0;
+      const timeline = await ActiveGateOgVAD.detectVoiceActivity(
+        inputPath,
+        activeGateOgOpts
+      );
+      return timeline.map((seg) => ({
+        startTime: seg.startTime,
+        endTime: seg.endTime,
+        isSpeech: seg.type === "segment" && seg.text === "active"
+      }));
+    }
+    case "active-gate": {
+      const ActiveGateVAD = await import("../vad/ActiveGate.cjs");
+      const activeGateOpts = "activeGate" in opts ? opts.activeGate : void 0;
+      const segments = await ActiveGateVAD.vadFromFile(
+        inputPath,
+        activeGateOpts
+      );
+      return segments.map((seg) => ({
+        startTime: seg.startTime,
+        endTime: seg.endTime,
+        isSpeech: seg.isActive
+      }));
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectVoiceActivity
+});

package/dist/api/VoiceActivityDetection.d.cts

@@ -0,0 +1,24 @@
+import { StreamOptions } from '../vad/ActiveGate.cjs';
+import { AdaptiveGateVADOptions } from '../vad/ActiveGateOg.cjs';
+import { SileroOptions } from '../vad/Silero.cjs';
+import 'node:stream';
+import '../utilities/Timeline.cjs';
+
+interface VadSegment {
+    startTime: number;
+    endTime: number;
+    isSpeech: boolean;
+}
+type VoiceActivityDetectionOptions = {
+    engine: "silero";
+    silero?: SileroOptions;
+} | {
+    engine: "active-gate";
+    activeGate?: StreamOptions;
+} | {
+    engine: "active-gate-og";
+    activeGateOg?: AdaptiveGateVADOptions;
+};
+declare function detectVoiceActivity(inputPath: string, options?: VoiceActivityDetectionOptions): Promise<VadSegment[]>;
+
+export { type VadSegment, type VoiceActivityDetectionOptions, detectVoiceActivity };

package/dist/api/VoiceActivityDetection.d.ts

@@ -0,0 +1,24 @@
+import { StreamOptions } from '../vad/ActiveGate.js';
+import { AdaptiveGateVADOptions } from '../vad/ActiveGateOg.js';
+import { SileroOptions } from '../vad/Silero.js';
+import 'node:stream';
+import '../utilities/Timeline.js';
+
+interface VadSegment {
+    startTime: number;
+    endTime: number;
+    isSpeech: boolean;
+}
+type VoiceActivityDetectionOptions = {
+    engine: "silero";
+    silero?: SileroOptions;
+} | {
+    engine: "active-gate";
+    activeGate?: StreamOptions;
+} | {
+    engine: "active-gate-og";
+    activeGateOg?: AdaptiveGateVADOptions;
+};
+declare function detectVoiceActivity(inputPath: string, options?: VoiceActivityDetectionOptions): Promise<VadSegment[]>;
+
+export { type VadSegment, type VoiceActivityDetectionOptions, detectVoiceActivity };

package/dist/api/VoiceActivityDetection.js

@@ -0,0 +1,43 @@
+import { extendDeep } from "../utilities/ObjectUtilities.js";
+const defaultVoiceActivityDetectionOptions = {
+  engine: "active-gate-og"
+};
+async function detectVoiceActivity(inputPath, options = defaultVoiceActivityDetectionOptions) {
+  const opts = extendDeep(defaultVoiceActivityDetectionOptions, options);
+  switch (opts.engine) {
+    case "silero": {
+      const SileroVAD = await import("../vad/Silero.js");
+      const sileroOpts = "silero" in opts ? opts.silero : void 0;
+      return SileroVAD.detectVoiceActivity(inputPath, sileroOpts);
+    }
+    case "active-gate-og": {
+      const ActiveGateOgVAD = await import("../vad/ActiveGateOg.js");
+      const activeGateOgOpts = "activeGateOg" in opts ? opts.activeGateOg : void 0;
+      const timeline = await ActiveGateOgVAD.detectVoiceActivity(
+        inputPath,
+        activeGateOgOpts
+      );
+      return timeline.map((seg) => ({
+        startTime: seg.startTime,
+        endTime: seg.endTime,
+        isSpeech: seg.type === "segment" && seg.text === "active"
+      }));
+    }
+    case "active-gate": {
+      const ActiveGateVAD = await import("../vad/ActiveGate.js");
+      const activeGateOpts = "activeGate" in opts ? opts.activeGate : void 0;
+      const segments = await ActiveGateVAD.vadFromFile(
+        inputPath,
+        activeGateOpts
+      );
+      return segments.map((seg) => ({
+        startTime: seg.startTime,
+        endTime: seg.endTime,
+        isSpeech: seg.isActive
+      }));
+    }
+  }
+}
+export {
+  detectVoiceActivity
+};

package/dist/audio/AudioConverter.cjs

@@ -0,0 +1,331 @@
+"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 AudioConverter_exports = {};
+__export(AudioConverter_exports, {
+  convertToBuffer: () => convertToBuffer,
+  convertToFile: () => convertToFile,
+  convertToStream: () => convertToStream,
+  createStreamForUpload: () => createStreamForUpload,
+  createStreamingConversion: () => createStreamingConversion,
+  getAudioDuration: () => getAudioDuration,
+  prepareForService: () => prepareForService,
+  prepareWavForService: () => prepareWavForService
+});
+module.exports = __toCommonJS(AudioConverter_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_promises2 = require("node:stream/promises");
+var import_node_util = require("node:util");
+var import_ffmpeg_stream = require("ffmpeg-stream");
+var import_config = require("../config.cjs");
+var import_AudioFormat = require("./AudioFormat.cjs");
+var import_AudioSource = require("./AudioSource.cjs");
+const execFilePromisified = (0, import_node_util.promisify)(import_node_child_process.execFile);
+async function execFileAsync(cmd, args) {
+  return execFilePromisified(cmd, args);
+}
+function getFFmpegFormatOptions(format, sampleRate, channels) {
+  const opts = {};
+  switch (format) {
+    case "wav":
+      opts["f"] = "wav";
+      opts["acodec"] = "pcm_s16le";
+      break;
+    case "flac":
+      opts["f"] = "flac";
+      opts["acodec"] = "flac";
+      break;
+    case "opus":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libopus";
+      break;
+    case "ogg":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libvorbis";
+      break;
+    case "mp3":
+      opts["f"] = "mp3";
+      opts["acodec"] = "libmp3lame";
+      break;
+    default:
+      opts["f"] = format;
+  }
+  if (sampleRate) {
+    opts["ar"] = String(sampleRate);
+  }
+  if (channels) {
+    opts["ac"] = String(channels);
+  }
+  return opts;
+}
+function getFFmpegInputFormat(format) {
+  switch (format) {
+    case "pcm":
+      return { f: "s16le", ar: "16000", ac: "1" };
+    default:
+      return {};
+  }
+}
+async function convertToFile(source, options) {
+  const tempPath = (0, import_node_path.join)(
+    (0, import_node_os.tmpdir)(),
+    `audio-convert-${Date.now()}${(0, import_AudioFormat.formatToExtension)(options.targetFormat)}`
+  );
+  const converter = new import_ffmpeg_stream.Converter();
+  const inputPath = (0, import_AudioSource.toFilePath)(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = (0, import_AudioSource.toReadStream)(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  converter.createOutputToFile(tempPath, outputOpts);
+  await converter.run();
+  return {
+    source: (0, import_AudioSource.audioSourceFromFile)(tempPath, options.targetFormat),
+    cleanup: async () => {
+      await (0, import_promises.rm)(tempPath, { force: true }).catch(() => {
+      });
+    }
+  };
+}
+async function convertToBuffer(source, options) {
+  const converter = new import_ffmpeg_stream.Converter();
+  const inputPath = (0, import_AudioSource.toFilePath)(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = (0, import_AudioSource.toReadStream)(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  const chunks = [];
+  outputStream.on("data", (chunk) => chunks.push(chunk));
+  const bufferPromise = new Promise((resolve, reject) => {
+    outputStream.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    outputStream.on("error", reject);
+  });
+  await converter.run();
+  const buffer = await bufferPromise;
+  return {
+    source: (0, import_AudioSource.audioSourceFromBuffer)(buffer, options.targetFormat),
+    cleanup: async () => {
+    }
+  };
+}
+function convertToStream(source, options) {
+  const converter = new import_ffmpeg_stream.Converter();
+  const inputPath = (0, import_AudioSource.toFilePath)(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = (0, import_AudioSource.toReadStream)(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  return {
+    stream: outputStream,
+    runConversion: () => converter.run()
+  };
+}
+async function prepareForService(source, options) {
+  const caps = import_AudioFormat.serviceCapabilities[options.service];
+  if (!caps) {
+    throw new Error(`Unknown service: ${options.service}`);
+  }
+  const inputFormat = source.format;
+  const requiresConversion = (0, import_AudioFormat.needsConversion)(inputFormat, options.service);
+  const targetFormat = (0, import_AudioFormat.getTargetFormat)(inputFormat, options.service);
+  if (!requiresConversion) {
+    if (caps.requiresFile && source.type !== "file") {
+      return writeToTempFile(source);
+    }
+    return { source, cleanup: async () => {
+    } };
+  }
+  const conversionOptions = {
+    targetFormat,
+    sampleRate: caps.preferredSampleRate,
+    channels: caps.preferredChannels
+  };
+  if (caps.requiresFile || options.preferFile) {
+    return convertToFile(source, conversionOptions);
+  }
+  if (caps.requiresBase64) {
+    return convertToBuffer(source, conversionOptions);
+  }
+  return convertToFile(source, conversionOptions);
+}
+async function writeToTempFile(source) {
+  const tempPath = (0, import_node_path.join)(
+    (0, import_node_os.tmpdir)(),
+    `audio-temp-${Date.now()}${(0, import_AudioFormat.formatToExtension)(source.format)}`
+  );
+  const readable = (0, import_AudioSource.toReadStream)(source);
+  const writable = (0, import_node_fs.createWriteStream)(tempPath);
+  await (0, import_promises2.pipeline)(readable, writable);
+  return {
+    source: (0, import_AudioSource.audioSourceFromFile)(tempPath, source.format),
+    cleanup: async () => {
+      await (0, import_promises.rm)(tempPath, { force: true }).catch(() => {
+      });
+    }
+  };
+}
+async function prepareWavForService(source, options = {}) {
+  if (source.format === "wav" && source.type === "file") {
+    return { source, cleanup: async () => {
+    } };
+  }
+  return convertToFile(source, {
+    targetFormat: "wav",
+    sampleRate: options.sampleRate ?? 16e3,
+    channels: options.channels ?? 1
+  });
+}
+function createStreamingConversion(source, options) {
+  const { stream, runConversion } = convertToStream(source, options);
+  return { stream, start: runConversion };
+}
+async function createStreamForUpload(options) {
+  const mode = options.mode ?? (0, import_config.getConversionMode)();
+  const needsConvert = options.source.format !== options.targetFormat;
+  if (!needsConvert) {
+    const stream = (0, import_AudioSource.toReadStream)(options.source);
+    return {
+      stream,
+      format: options.source.format,
+      cleanup: async () => {
+      },
+      mode
+    };
+  }
+  if (mode === "file-first") {
+    const tempPath = (0, import_node_path.join)(
+      (0, import_node_os.tmpdir)(),
+      `upload-${Date.now()}${(0, import_AudioFormat.formatToExtension)(options.targetFormat)}`
+    );
+    const converter2 = new import_ffmpeg_stream.Converter();
+    const inputPath2 = (0, import_AudioSource.toFilePath)(options.source);
+    if (inputPath2) {
+      converter2.createInputFromFile(inputPath2);
+    } else {
+      const inputOpts = getFFmpegInputFormat(options.source.format);
+      const inputStream = converter2.createInputStream(inputOpts);
+      const readable = (0, import_AudioSource.toReadStream)(options.source);
+      readable.pipe(inputStream);
+    }
+    const outputOpts2 = getFFmpegFormatOptions(
+      options.targetFormat,
+      options.sampleRate,
+      options.channels
+    );
+    converter2.createOutputToFile(tempPath, outputOpts2);
+    await converter2.run();
+    const stream = (0, import_node_fs.createReadStream)(tempPath);
+    return {
+      stream,
+      format: options.targetFormat,
+      cleanup: async () => {
+        await (0, import_promises.rm)(tempPath, { force: true }).catch(() => {
+        });
+      },
+      mode
+    };
+  }
+  const converter = new import_ffmpeg_stream.Converter();
+  const inputPath = (0, import_AudioSource.toFilePath)(options.source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(options.source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = (0, import_AudioSource.toReadStream)(options.source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  return {
+    stream: outputStream,
+    format: options.targetFormat,
+    cleanup: async () => {
+    },
+    start: () => converter.run(),
+    mode
+  };
+}
+async function getAudioDuration(filePath) {
+  const { stdout } = await execFileAsync("ffprobe", [
+    "-v",
+    "quiet",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "default=noprint_wrappers=1:nokey=1",
+    filePath
+  ]);
+  const duration = parseFloat(stdout.trim());
+  if (Number.isNaN(duration)) {
+    throw new Error(
+      `Failed to parse audio duration from ffprobe output: ${stdout}`
+    );
+  }
+  return duration;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToBuffer,
+  convertToFile,
+  convertToStream,
+  createStreamForUpload,
+  createStreamingConversion,
+  getAudioDuration,
+  prepareForService,
+  prepareWavForService
+});

package/dist/audio/AudioConverter.d.cts

@@ -0,0 +1,53 @@
+import { AudioFormat } from './AudioFormat.cjs';
+import { AudioSource } from './AudioSource.cjs';
+import { Readable } from 'node:stream';
+import { ConversionMode } from '../config.cjs';
+import 'node:fs';
+
+interface ConversionOptions {
+    targetFormat: AudioFormat;
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+}
+interface PreparedAudio {
+    source: AudioSource;
+    cleanup: () => Promise<void>;
+}
+declare function convertToFile(source: AudioSource, options: ConversionOptions): Promise<PreparedAudio>;
+declare function convertToBuffer(source: AudioSource, options: ConversionOptions): Promise<PreparedAudio>;
+declare function convertToStream(source: AudioSource, options: ConversionOptions): {
+    stream: Readable;
+    runConversion: () => Promise<void>;
+};
+interface PrepareForServiceOptions {
+    service: string;
+    preferFile?: boolean;
+    preferStream?: boolean;
+}
+declare function prepareForService(source: AudioSource, options: PrepareForServiceOptions): Promise<PreparedAudio>;
+declare function prepareWavForService(source: AudioSource, options?: {
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+}): Promise<PreparedAudio>;
+declare function createStreamingConversion(source: AudioSource, options: ConversionOptions): {
+    stream: Readable;
+    start: () => Promise<void>;
+};
+interface StreamForUploadOptions {
+    source: AudioSource;
+    targetFormat: AudioFormat;
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+    mode?: ConversionMode | undefined;
+}
+interface StreamForUploadResult {
+    stream: Readable;
+    format: AudioFormat;
+    cleanup: () => Promise<void>;
+    start?: () => Promise<void>;
+    mode: ConversionMode;
+}
+declare function createStreamForUpload(options: StreamForUploadOptions): Promise<StreamForUploadResult>;
+declare function getAudioDuration(filePath: string): Promise<number>;
+
+export { type ConversionOptions, type PrepareForServiceOptions, type PreparedAudio, type StreamForUploadOptions, type StreamForUploadResult, convertToBuffer, convertToFile, convertToStream, createStreamForUpload, createStreamingConversion, getAudioDuration, prepareForService, prepareWavForService };

package/dist/audio/AudioConverter.d.ts

@@ -0,0 +1,53 @@
+import { AudioFormat } from './AudioFormat.js';
+import { AudioSource } from './AudioSource.js';
+import { Readable } from 'node:stream';
+import { ConversionMode } from '../config.js';
+import 'node:fs';
+
+interface ConversionOptions {
+    targetFormat: AudioFormat;
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+}
+interface PreparedAudio {
+    source: AudioSource;
+    cleanup: () => Promise<void>;
+}
+declare function convertToFile(source: AudioSource, options: ConversionOptions): Promise<PreparedAudio>;
+declare function convertToBuffer(source: AudioSource, options: ConversionOptions): Promise<PreparedAudio>;
+declare function convertToStream(source: AudioSource, options: ConversionOptions): {
+    stream: Readable;
+    runConversion: () => Promise<void>;
+};
+interface PrepareForServiceOptions {
+    service: string;
+    preferFile?: boolean;
+    preferStream?: boolean;
+}
+declare function prepareForService(source: AudioSource, options: PrepareForServiceOptions): Promise<PreparedAudio>;
+declare function prepareWavForService(source: AudioSource, options?: {
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+}): Promise<PreparedAudio>;
+declare function createStreamingConversion(source: AudioSource, options: ConversionOptions): {
+    stream: Readable;
+    start: () => Promise<void>;
+};
+interface StreamForUploadOptions {
+    source: AudioSource;
+    targetFormat: AudioFormat;
+    sampleRate?: number | undefined;
+    channels?: number | undefined;
+    mode?: ConversionMode | undefined;
+}
+interface StreamForUploadResult {
+    stream: Readable;
+    format: AudioFormat;
+    cleanup: () => Promise<void>;
+    start?: () => Promise<void>;
+    mode: ConversionMode;
+}
+declare function createStreamForUpload(options: StreamForUploadOptions): Promise<StreamForUploadResult>;
+declare function getAudioDuration(filePath: string): Promise<number>;
+
+export { type ConversionOptions, type PrepareForServiceOptions, type PreparedAudio, type StreamForUploadOptions, type StreamForUploadResult, convertToBuffer, convertToFile, convertToStream, createStreamForUpload, createStreamingConversion, getAudioDuration, prepareForService, prepareWavForService };