@storyteller-platform/align 0.0.1

package/dist/process/processAudiobook.cjs

@@ -0,0 +1,220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 processAudiobook_exports = {};
+__export(processAudiobook_exports, {
+  processAudiobook: () => processAudiobook,
+  processFile: () => processFile
+});
+module.exports = __toCommonJS(processAudiobook_exports);
+var import_promises = require("node:fs/promises");
+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");
+var import_ffmpeg = require("../common/ffmpeg.cjs");
+var import_ranges = require("./ranges.cjs");
+async function processAudiobook(input, output, options) {
+  var _a, _b, _c;
+  const timing = (0, import_ghost_story.createAggregator)();
+  timing.setMetadata("codec", ((_a = options.encoding) == null ? void 0 : _a.codec) ?? "unspecified");
+  timing.setMetadata("bitrate", ((_b = options.encoding) == null ? void 0 : _b.bitrate) ?? "unspecified");
+  timing.setMetadata("max-length", `${(options.maxLength ?? 2) * 60} minutes`);
+  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) || (0, import_audiobook.isZipArchive)(f));
+  (_c = options.logger) == null ? void 0 : _c.debug(`Found ${filenames.length} files to process`);
+  const outputFiles = [];
+  const controller = new AbortController();
+  const signal = AbortSignal.any([
+    options.signal ?? new AbortSignal(),
+    controller.signal
+  ]);
+  const semaphore = new import_async_semaphore.AsyncSemaphore(options.parallelism ?? 1);
+  const perFileProgress = /* @__PURE__ */ new Map();
+  await Promise.all(
+    filenames.map(async (filename, index) => {
+      if (signal.aborted) throw new Error("Aborted");
+      const filepath = (0, import_node_path.join)(input, filename);
+      function onFileProgress(progress) {
+        var _a2, _b2;
+        perFileProgress.set(index, progress);
+        const updatedProgress = Array.from(perFileProgress.values()).reduce(
+          (acc, p) => acc + p
+        );
+        (_a2 = options.logger) == null ? void 0 : _a2.info(
+          `Progress: ${Math.floor(updatedProgress * 100)}%`
+        );
+        (_b2 = options.onProgress) == null ? void 0 : _b2.call(options, updatedProgress);
+      }
+      const fileOptions = {
+        ...options,
+        signal,
+        lock: semaphore,
+        onProgress: onFileProgress
+      };
+      const { processedFiles, timing: fileTiming } = await processFile(
+        filepath,
+        output,
+        (index + 1).toString().padStart(5, "0") + "-",
+        fileOptions
+      );
+      timing.add(fileTiming.summary());
+      outputFiles.push(...processedFiles);
+    }).map(
+      (p) => p.catch((e) => {
+        controller.abort(e);
+        throw e;
+      })
+    )
+  );
+  return timing;
+}
+async function processFile(input, output, prefix, options) {
+  var _stack = [];
+  try {
+    const timing = (0, import_ghost_story.createTiming)();
+    const outputFiles = [];
+    const audiobook = __using(_stack, await import_audiobook.Audiobook.from(input));
+    const maxHours = options.maxLength ?? 2;
+    const maxSeconds = 60 * 60 * maxHours;
+    const duration = await audiobook.getDuration();
+    const chapters = await audiobook.getChapters();
+    const ranges = await (0, import_ranges.getSafeChapterRanges)(
+      input,
+      duration,
+      chapters,
+      maxSeconds,
+      options.signal,
+      options.logger
+    );
+    await Promise.all(
+      ranges.map(async (range, index) => {
+        var _a, _b;
+        var _stack2 = [];
+        try {
+          const outputExtension = determineExtension(
+            range.filepath,
+            (_a = options.encoding) == null ? void 0 : _a.codec
+          );
+          const outputFilename = `${prefix}${(index + 1).toString().padStart(5, "0")}${outputExtension}`;
+          const outputFilepath = (0, import_node_path.join)(output, outputFilename);
+          const stack = __using(_stack2, new DisposableStack());
+          stack.defer(() => {
+            options.lock.release();
+          });
+          await options.lock.wait();
+          if ((_b = options.signal) == null ? void 0 : _b.aborted) throw new Error("Aborted");
+          await timing.timeAsync(
+            `${range.filepath},${range.start}:${range.end}`,
+            async () => {
+              var _a2;
+              const wasSplit = await (0, import_ffmpeg.splitFile)(
+                range.filepath,
+                outputFilepath,
+                range.start,
+                range.end,
+                options.encoding,
+                options.signal,
+                options.logger
+              );
+              if (wasSplit) {
+                outputFiles.push(outputFilename);
+                (_a2 = options.onProgress) == null ? void 0 : _a2.call(options, (outputFiles.length + 1) / ranges.length);
+              }
+            }
+          );
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
+      })
+    );
+    return { processedFiles: outputFiles, timing };
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function determineExtension(input, codec) {
+  if (codec === "libmp3lame") {
+    return ".mp3";
+  }
+  if (codec === "aac" || codec === "libopus") {
+    return ".mp4";
+  }
+  if (import_audiobook.MP3_FILE_EXTENSIONS.some((ext) => input.endsWith(ext))) {
+    return ".mp3";
+  }
+  if (import_audiobook.MPEG4_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || import_audiobook.OGG_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || import_audiobook.OPUS_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || import_audiobook.AAC_FILE_EXTENSIONS.some((ext) => input.endsWith(ext))) {
+    return ".mp4";
+  }
+  return (0, import_node_path.extname)(input);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processAudiobook,
+  processFile
+});

package/dist/process/processAudiobook.d.cts

@@ -0,0 +1,24 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { AsyncSemaphore } from '@esfx/async-semaphore';
+import { Logger } from 'pino';
+import { AudioEncoding } from './AudioEncoding.cjs';
+
+interface ProcessOptions {
+    maxLength?: number | null | undefined;
+    encoding?: AudioEncoding | null | undefined;
+    parallelism?: number | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    onProgress?: ((progress: number) => void) | null | undefined;
+    logger?: Logger | null | undefined;
+}
+declare function processAudiobook(input: string, output: string, options: ProcessOptions): Promise<TimingAggregator>;
+interface ProcessFileOptions extends Omit<ProcessOptions, "parallelism"> {
+    lock: AsyncSemaphore;
+}
+declare function processFile(input: string, output: string, prefix: string, options: ProcessFileOptions): Promise<{
+    processedFiles: string[];
+    timing: _storyteller_platform_ghost_story.Timing;
+}>;
+
+export { type ProcessOptions, processAudiobook, processFile };

package/dist/process/processAudiobook.d.ts

@@ -0,0 +1,24 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { AsyncSemaphore } from '@esfx/async-semaphore';
+import { Logger } from 'pino';
+import { AudioEncoding } from './AudioEncoding.js';
+
+interface ProcessOptions {
+    maxLength?: number | null | undefined;
+    encoding?: AudioEncoding | null | undefined;
+    parallelism?: number | null | undefined;
+    signal?: AbortSignal | null | undefined;
+    onProgress?: ((progress: number) => void) | null | undefined;
+    logger?: Logger | null | undefined;
+}
+declare function processAudiobook(input: string, output: string, options: ProcessOptions): Promise<TimingAggregator>;
+interface ProcessFileOptions extends Omit<ProcessOptions, "parallelism"> {
+    lock: AsyncSemaphore;
+}
+declare function processFile(input: string, output: string, prefix: string, options: ProcessFileOptions): Promise<{
+    processedFiles: string[];
+    timing: _storyteller_platform_ghost_story.Timing;
+}>;
+
+export { type ProcessOptions, processAudiobook, processFile };

package/dist/process/processAudiobook.js

@@ -0,0 +1,166 @@
+import {
+  __callDispose,
+  __using
+} from "../chunk-BIEQXUOY.js";
+import { mkdir, readdir } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { AsyncSemaphore } from "@esfx/async-semaphore";
+import {
+  AAC_FILE_EXTENSIONS,
+  Audiobook,
+  MP3_FILE_EXTENSIONS,
+  MPEG4_FILE_EXTENSIONS,
+  OGG_FILE_EXTENSIONS,
+  OPUS_FILE_EXTENSIONS,
+  isAudioFile,
+  isZipArchive
+} from "@storyteller-platform/audiobook";
+import {
+  createAggregator,
+  createTiming
+} from "@storyteller-platform/ghost-story";
+import { splitFile } from "../common/ffmpeg.js";
+import { getSafeChapterRanges } from "./ranges.js";
+async function processAudiobook(input, output, options) {
+  var _a, _b, _c;
+  const timing = createAggregator();
+  timing.setMetadata("codec", ((_a = options.encoding) == null ? void 0 : _a.codec) ?? "unspecified");
+  timing.setMetadata("bitrate", ((_b = options.encoding) == null ? void 0 : _b.bitrate) ?? "unspecified");
+  timing.setMetadata("max-length", `${(options.maxLength ?? 2) * 60} minutes`);
+  await mkdir(output, { recursive: true });
+  const allFiles = await readdir(input, { recursive: true });
+  const filenames = allFiles.filter((f) => isAudioFile(f) || isZipArchive(f));
+  (_c = options.logger) == null ? void 0 : _c.debug(`Found ${filenames.length} files to process`);
+  const outputFiles = [];
+  const controller = new AbortController();
+  const signal = AbortSignal.any([
+    options.signal ?? new AbortSignal(),
+    controller.signal
+  ]);
+  const semaphore = new AsyncSemaphore(options.parallelism ?? 1);
+  const perFileProgress = /* @__PURE__ */ new Map();
+  await Promise.all(
+    filenames.map(async (filename, index) => {
+      if (signal.aborted) throw new Error("Aborted");
+      const filepath = join(input, filename);
+      function onFileProgress(progress) {
+        var _a2, _b2;
+        perFileProgress.set(index, progress);
+        const updatedProgress = Array.from(perFileProgress.values()).reduce(
+          (acc, p) => acc + p
+        );
+        (_a2 = options.logger) == null ? void 0 : _a2.info(
+          `Progress: ${Math.floor(updatedProgress * 100)}%`
+        );
+        (_b2 = options.onProgress) == null ? void 0 : _b2.call(options, updatedProgress);
+      }
+      const fileOptions = {
+        ...options,
+        signal,
+        lock: semaphore,
+        onProgress: onFileProgress
+      };
+      const { processedFiles, timing: fileTiming } = await processFile(
+        filepath,
+        output,
+        (index + 1).toString().padStart(5, "0") + "-",
+        fileOptions
+      );
+      timing.add(fileTiming.summary());
+      outputFiles.push(...processedFiles);
+    }).map(
+      (p) => p.catch((e) => {
+        controller.abort(e);
+        throw e;
+      })
+    )
+  );
+  return timing;
+}
+async function processFile(input, output, prefix, options) {
+  var _stack = [];
+  try {
+    const timing = createTiming();
+    const outputFiles = [];
+    const audiobook = __using(_stack, await Audiobook.from(input));
+    const maxHours = options.maxLength ?? 2;
+    const maxSeconds = 60 * 60 * maxHours;
+    const duration = await audiobook.getDuration();
+    const chapters = await audiobook.getChapters();
+    const ranges = await getSafeChapterRanges(
+      input,
+      duration,
+      chapters,
+      maxSeconds,
+      options.signal,
+      options.logger
+    );
+    await Promise.all(
+      ranges.map(async (range, index) => {
+        var _a, _b;
+        var _stack2 = [];
+        try {
+          const outputExtension = determineExtension(
+            range.filepath,
+            (_a = options.encoding) == null ? void 0 : _a.codec
+          );
+          const outputFilename = `${prefix}${(index + 1).toString().padStart(5, "0")}${outputExtension}`;
+          const outputFilepath = join(output, outputFilename);
+          const stack = __using(_stack2, new DisposableStack());
+          stack.defer(() => {
+            options.lock.release();
+          });
+          await options.lock.wait();
+          if ((_b = options.signal) == null ? void 0 : _b.aborted) throw new Error("Aborted");
+          await timing.timeAsync(
+            `${range.filepath},${range.start}:${range.end}`,
+            async () => {
+              var _a2;
+              const wasSplit = await splitFile(
+                range.filepath,
+                outputFilepath,
+                range.start,
+                range.end,
+                options.encoding,
+                options.signal,
+                options.logger
+              );
+              if (wasSplit) {
+                outputFiles.push(outputFilename);
+                (_a2 = options.onProgress) == null ? void 0 : _a2.call(options, (outputFiles.length + 1) / ranges.length);
+              }
+            }
+          );
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
+      })
+    );
+    return { processedFiles: outputFiles, timing };
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function determineExtension(input, codec) {
+  if (codec === "libmp3lame") {
+    return ".mp3";
+  }
+  if (codec === "aac" || codec === "libopus") {
+    return ".mp4";
+  }
+  if (MP3_FILE_EXTENSIONS.some((ext) => input.endsWith(ext))) {
+    return ".mp3";
+  }
+  if (MPEG4_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || OGG_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || OPUS_FILE_EXTENSIONS.some((ext) => input.endsWith(ext)) || AAC_FILE_EXTENSIONS.some((ext) => input.endsWith(ext))) {
+    return ".mp4";
+  }
+  return extname(input);
+}
+export {
+  processAudiobook,
+  processFile
+};

package/dist/process/ranges.cjs

@@ -0,0 +1,203 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 ranges_exports = {};
+__export(ranges_exports, {
+  getSafeChapterRanges: () => getSafeChapterRanges,
+  getSafeRanges: () => getSafeRanges
+});
+module.exports = __toCommonJS(ranges_exports);
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_vad = require("@storyteller-platform/ghost-story/vad");
+var import_ffmpeg = require("../common/ffmpeg.cjs");
+async function getSafeChapterRanges(input, duration, chapters, maxSeconds, signal, logger) {
+  if (!chapters.length) {
+    logger == null ? void 0 : logger.info(
+      `Track is longer than ${maxSeconds / 60} minutes (${duration / 60}m); using VAD to determine safe split points.`
+    );
+    const ranges2 = await getSafeRanges(input, duration, maxSeconds, 0, signal);
+    return ranges2.map((r) => ({ filepath: input, ...r }));
+  }
+  const initialRanges = chapters.map((chapter, index) => {
+    const next = chapters[index + 1];
+    if (!next)
+      return {
+        filepath: chapter.filename,
+        start: chapter.start ?? 0,
+        end: duration
+      };
+    const end = next.filename === chapter.filename ? next.start ?? duration : duration;
+    return {
+      filepath: chapter.filename,
+      start: chapter.start ?? 0,
+      end
+    };
+  });
+  const ranges = [];
+  for (const range of initialRanges) {
+    const chapterDuration = range.end - range.start;
+    if (chapterDuration <= maxSeconds) {
+      ranges.push(range);
+      continue;
+    }
+    logger == null ? void 0 : logger.info(
+      `Chapter is longer than ${maxSeconds / 60} minutes (${duration / 60}m); using VAD to determine safe split points.`
+    );
+    const chapterRanges = await getSafeRanges(
+      range.filepath,
+      chapterDuration,
+      maxSeconds,
+      range.start,
+      signal,
+      logger
+    );
+    ranges.push(
+      ...chapterRanges.map((r) => ({ filepath: range.filepath, ...r }))
+    );
+  }
+  return ranges;
+}
+async function getSafeRanges(input, duration, maxSeconds, start = 0, signal, logger) {
+  var _stack = [];
+  try {
+    const ext = (0, import_node_path.extname)(input);
+    const rawFilename = (0, import_node_path.basename)(input, ext);
+    const tmpDir = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `storyteller-align-silence-${(0, import_node_crypto.randomUUID)()}`);
+    const stack = __using(_stack, new AsyncDisposableStack(), true);
+    stack.defer(async () => {
+      await (0, import_promises.rm)(tmpDir, { recursive: true, force: true });
+    });
+    const ranges = [{ start, end: duration + start }];
+    for (let i = 0; i + 1 < duration / maxSeconds; i++) {
+      if (signal == null ? void 0 : signal.aborted) throw new Error("Aborted");
+      const tmpFilepath = (0, import_node_path.join)(tmpDir, i.toString(), `${rawFilename}.wav`);
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)(tmpFilepath), { recursive: true });
+      const approxCutPoint = start + maxSeconds * (i + 1);
+      const searchStart = approxCutPoint - 120;
+      const searchEnd = approxCutPoint;
+      await (0, import_ffmpeg.splitFile)(
+        input,
+        tmpFilepath,
+        searchStart,
+        searchEnd,
+        {},
+        signal,
+        logger
+      );
+      const vadTimeline = await (0, import_vad.detectVoiceActivity)(tmpFilepath, {
+        engine: "active-gate-og"
+      });
+      if (vadTimeline.length === 0) {
+        break;
+      }
+      const silenceTimeline = vadTimeline.reduce((acc, entry) => {
+        const lastEntry = acc.at(-1);
+        if (!lastEntry) {
+          return [
+            ...acc,
+            {
+              start: entry.endTime + searchStart,
+              end: entry.endTime + searchStart
+            }
+          ];
+        }
+        return [
+          ...acc.slice(0, -1),
+          {
+            ...lastEntry,
+            end: entry.startTime + searchStart
+          },
+          {
+            start: entry.endTime + searchStart,
+            end: entry.endTime + searchStart
+          }
+        ];
+      }, []);
+      const nearestLikelySentenceBreak = silenceTimeline.reduce((acc, entry) => {
+        const currLength = acc.end - acc.start;
+        const entryLength = entry.end - entry.start;
+        return currLength > entryLength ? acc : entry;
+      });
+      const lastRange = ranges.at(-1);
+      lastRange.end = nearestLikelySentenceBreak.start;
+      ranges.push({
+        start: nearestLikelySentenceBreak.end,
+        end: duration + start
+      });
+    }
+    return ranges;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSafeChapterRanges,
+  getSafeRanges
+});

package/dist/process/ranges.d.cts

@@ -0,0 +1,15 @@
+import { Logger } from 'pino';
+import { AudiobookChapter } from '@storyteller-platform/audiobook';
+
+declare function getSafeChapterRanges(input: string, duration: number, chapters: AudiobookChapter[], maxSeconds: number, signal?: AbortSignal | null, logger?: Logger | null): Promise<{
+    start: number;
+    end: number;
+    filepath: string;
+}[]>;
+interface Range {
+    start: number;
+    end: number;
+}
+declare function getSafeRanges(input: string, duration: number, maxSeconds: number, start?: number, signal?: AbortSignal | null, logger?: Logger | null): Promise<Range[]>;
+
+export { getSafeChapterRanges, getSafeRanges };

package/dist/process/ranges.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from 'pino';
+import { AudiobookChapter } from '@storyteller-platform/audiobook';
+
+declare function getSafeChapterRanges(input: string, duration: number, chapters: AudiobookChapter[], maxSeconds: number, signal?: AbortSignal | null, logger?: Logger | null): Promise<{
+    start: number;
+    end: number;
+    filepath: string;
+}[]>;
+interface Range {
+    start: number;
+    end: number;
+}
+declare function getSafeRanges(input: string, duration: number, maxSeconds: number, start?: number, signal?: AbortSignal | null, logger?: Logger | null): Promise<Range[]>;
+
+export { getSafeChapterRanges, getSafeRanges };