@storyteller-platform/align 0.0.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shane Friedman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @storyteller-platform/align
+
+A library and CLI for forced alignment of ebooks and audiobooks.

package/dist/align/align.cjs

@@ -0,0 +1,525 @@
+"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 align_exports = {};
+__export(align_exports, {
+  Aligner: () => Aligner,
+  align: () => align,
+  concatTranscriptions: () => concatTranscriptions
+});
+module.exports = __toCommonJS(align_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_posix = require("node:path/posix");
+var import_memoize = __toESM(require("memoize"), 1);
+var import_audiobook = require("@storyteller-platform/audiobook");
+var import_epub = require("@storyteller-platform/epub");
+var import_ghost_story = require("@storyteller-platform/ghost-story");
+var import_ffmpeg = require("../common/ffmpeg.cjs");
+var import_segmentation = require("../markup/segmentation.cjs");
+var import_fuzzy = require("./fuzzy.cjs");
+var import_getSentenceRanges = require("./getSentenceRanges.cjs");
+const OFFSET_SEARCH_WINDOW_SIZE = 5e3;
+async function align(input, output, transcriptionsDir, audiobookDir, options) {
+  var _stack = [];
+  try {
+    await (0, import_promises.copyFile)(input, output);
+    const audiobookFiles = await (0, import_promises.readdir)(audiobookDir).then(
+      (filenames) => filenames.filter((f) => (0, import_audiobook.isAudioFile)(f)).map((f) => (0, import_node_path.join)(audiobookDir, f))
+    );
+    const epub = __using(_stack, await import_epub.Epub.from(output));
+    const transcriptions = await (0, import_promises.readdir)(transcriptionsDir).then(
+      (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => (0, import_node_path.join)(transcriptionsDir, f))
+    ).then(
+      (filepaths) => Promise.all(
+        filepaths.map(async (p) => (0, import_promises.readFile)(p, { encoding: "utf-8" }))
+      )
+    ).then(
+      (contents) => contents.map(
+        (c) => JSON.parse(c)
+      )
+    );
+    const aligner = new Aligner(
+      epub,
+      audiobookFiles,
+      transcriptions,
+      options.granularity,
+      options.primaryLocale,
+      options.logger
+    );
+    const timing = await aligner.alignBook(options.onProgress);
+    if (options.reportsPath) {
+      await (0, import_promises.mkdir)((0, import_node_path.dirname)(options.reportsPath), { recursive: true });
+      await (0, import_promises.writeFile)(
+        options.reportsPath,
+        JSON.stringify(aligner.report, null, 2),
+        {
+          encoding: "utf-8"
+        }
+      );
+    }
+    return timing;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+class Aligner {
+  constructor(epub, audiofiles, transcriptions, granularity, languageOverride, logger) {
+    this.epub = epub;
+    this.languageOverride = languageOverride;
+    this.logger = logger;
+    this.transcription = concatTranscriptions(transcriptions, audiofiles);
+    this.getChapterSentences = (0, import_memoize.default)(this.getChapterSentences.bind(this));
+    this.granularity = granularity ?? "sentence";
+  }
+  transcription;
+  totalDuration = 0;
+  alignedChapters = [];
+  timing = (0, import_ghost_story.createAggregator)();
+  granularity;
+  report = {
+    chapters: []
+  };
+  findBestOffset(epubSentences, transcriptionText, lastMatchOffset) {
+    let i = 0;
+    while (i < transcriptionText.length) {
+      let startSentence = 0;
+      const proposedStartIndex = (lastMatchOffset + i) % transcriptionText.length;
+      const proposedEndIndex = (proposedStartIndex + OFFSET_SEARCH_WINDOW_SIZE) % transcriptionText.length;
+      const wrapping = proposedEndIndex < proposedStartIndex;
+      let endIndex = wrapping ? transcriptionText.length : proposedEndIndex;
+      let startIndex = proposedStartIndex;
+      let startSeen = null;
+      let endSeen = null;
+      for (const aligned of this.alignedChapters) {
+        if (startSeen !== null && endSeen === aligned.startOffset) {
+          endSeen = aligned.endOffset;
+        } else {
+          startSeen = aligned.startOffset;
+          endSeen = aligned.endOffset;
+        }
+        if (startIndex >= startSeen && startIndex < endSeen) {
+          startIndex = endSeen;
+        }
+        if (endIndex >= startSeen && endIndex <= endSeen) {
+          endIndex = startSeen;
+        }
+      }
+      if (startIndex < endIndex) {
+        const transcriptionTextSlice = transcriptionText.slice(
+          startIndex,
+          endIndex
+        );
+        while (startSentence < epubSentences.length) {
+          const queryString = epubSentences.slice(startSentence, startSentence + 6).join(" ");
+          const firstMatch = (0, import_fuzzy.findNearestMatch)(
+            queryString.toLowerCase(),
+            transcriptionTextSlice.toLowerCase(),
+            Math.max(Math.floor(0.1 * queryString.length), 1)
+          );
+          if (firstMatch) {
+            return {
+              startSentence,
+              transcriptionOffset: (firstMatch.index + startIndex) % transcriptionText.length
+            };
+          }
+          startSentence += 3;
+        }
+      }
+      if (wrapping) {
+        i += transcriptionText.length - proposedStartIndex;
+      } else {
+        i += Math.floor(OFFSET_SEARCH_WINDOW_SIZE / 2);
+      }
+    }
+    return { startSentence: 0, transcriptionOffset: null };
+  }
+  async getChapterSentences(chapterId) {
+    const chapterXml = await this.epub.readXhtmlItemContents(chapterId);
+    const segmentation = await (0, import_segmentation.getXhtmlSegmentation)(
+      import_epub.Epub.getXhtmlBody(chapterXml),
+      {
+        primaryLocale: this.languageOverride ?? await this.epub.getLanguage()
+      }
+    );
+    return segmentation.sentences.map((s) => s.text);
+  }
+  async writeAlignedChapter(alignedChapter) {
+    const { chapter, sentenceRanges, xml } = alignedChapter;
+    const audiofiles = Array.from(
+      new Set(sentenceRanges.map(({ audiofile }) => audiofile))
+    );
+    await Promise.all(
+      audiofiles.map(async (audiofile) => {
+        const { name, base } = (0, import_posix.parse)(audiofile);
+        const id = `audio_${name}`;
+        const manifest = await this.epub.getManifest();
+        if (id in manifest) return;
+        const epubAudioFilename = `Audio/${base}`;
+        const duration = await (0, import_ffmpeg.getTrackDuration)(audiofile);
+        this.totalDuration += duration;
+        const audio = await (0, import_promises.readFile)(audiofile);
+        const mediaType = (0, import_audiobook.lookupAudioMime)(base) ?? void 0;
+        await this.epub.addManifestItem(
+          {
+            id,
+            href: epubAudioFilename,
+            mediaType
+          },
+          audio
+        );
+      })
+    );
+    const { name: chapterStem } = (0, import_posix.parse)(chapter.href);
+    const mediaOverlayId = `${chapter.id}_overlay`;
+    await this.epub.addManifestItem(
+      {
+        id: mediaOverlayId,
+        href: `MediaOverlays/${chapterStem}.smil`,
+        mediaType: "application/smil+xml"
+      },
+      createMediaOverlay(chapter, sentenceRanges),
+      "xml"
+    );
+    await this.epub.updateManifestItem(chapter.id, {
+      ...chapter,
+      mediaOverlay: mediaOverlayId
+    });
+    await this.epub.writeXhtmlItemContents(chapter.id, xml);
+    const chapterDuration = (0, import_getSentenceRanges.getChapterDuration)(sentenceRanges);
+    await this.epub.addMetadata({
+      type: "meta",
+      properties: {
+        property: "media:duration",
+        refines: `#${mediaOverlayId}`
+      },
+      value: import_epub.Epub.formatSmilDuration(chapterDuration)
+    });
+  }
+  addChapterReport(chapter, chapterSentences, sentenceRanges, startSentence, transcriptionOffset) {
+    this.report.chapters.push({
+      href: chapter.href,
+      transcriptionOffset,
+      transcriptionContext: {
+        before: this.transcription.transcript.slice(
+          Math.max(0, transcriptionOffset - 30),
+          transcriptionOffset
+        ),
+        after: this.transcription.transcript.slice(
+          transcriptionOffset,
+          Math.min(
+            transcriptionOffset + 30,
+            this.transcription.transcript.length - 1
+          )
+        )
+      },
+      firstMatchedSentenceId: startSentence,
+      firstMatchedSentenceContext: {
+        prevSentence: chapterSentences[startSentence - 1] ?? null,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        matchedSentence: chapterSentences[startSentence],
+        nextSentence: chapterSentences[startSentence + 1] ?? null
+      },
+      audioFiles: sentenceRanges.reduce((acc, range) => {
+        const existing = acc.find(
+          (context) => context.filepath === range.audiofile
+        );
+        if (existing) {
+          existing.end = range.end;
+          return acc;
+        }
+        acc.push({
+          filepath: range.audiofile,
+          start: range.start,
+          end: range.end
+        });
+        return acc;
+      }, [])
+    });
+  }
+  async alignChapter(startSentence, chapterId, transcriptionOffset, lastSentenceRange) {
+    const timing = (0, import_ghost_story.createTiming)();
+    timing.start("read contents");
+    const manifest = await this.epub.getManifest();
+    const chapter = manifest[chapterId];
+    if (!chapter)
+      throw new Error(
+        `Failed to align chapter: could not find chapter with id ${chapterId} in manifest`
+      );
+    const chapterXml = await this.epub.readXhtmlItemContents(chapterId);
+    timing.end("read contents");
+    timing.start("split to sentences");
+    const chapterSentences = await this.getChapterSentences(chapterId);
+    timing.end("split to sentences");
+    timing.start("align sentences");
+    const { sentenceRanges, transcriptionOffset: endTranscriptionOffset } = await (0, import_getSentenceRanges.getSentenceRanges)(
+      startSentence,
+      this.transcription,
+      chapterSentences,
+      transcriptionOffset,
+      lastSentenceRange
+    );
+    timing.end("align sentences");
+    timing.start("expand ranges");
+    const interpolated = await (0, import_getSentenceRanges.interpolateSentenceRanges)(
+      sentenceRanges,
+      lastSentenceRange
+    );
+    const expanded = (0, import_getSentenceRanges.expandEmptySentenceRanges)(interpolated);
+    timing.end("expand ranges");
+    const storytellerStylesheetUrl = (0, import_posix.relative)(
+      (0, import_posix.dirname)(chapter.href),
+      "Styles/storyteller-readaloud.css"
+    );
+    import_epub.Epub.addLinkToXhtmlHead(chapterXml, {
+      rel: "stylesheet",
+      href: storytellerStylesheetUrl,
+      type: "text/css"
+    });
+    this.alignedChapters.push({
+      chapter,
+      xml: chapterXml,
+      sentenceRanges: expanded,
+      startOffset: transcriptionOffset,
+      endOffset: endTranscriptionOffset
+    });
+    this.addChapterReport(
+      chapter,
+      chapterSentences,
+      expanded,
+      startSentence,
+      transcriptionOffset
+    );
+    return {
+      lastSentenceRange: expanded[expanded.length - 1] ?? null,
+      endTranscriptionOffset,
+      timing
+    };
+  }
+  async alignBook(onProgress) {
+    var _a, _b, _c, _d, _e, _f;
+    this.timing.setMetadata(
+      "language",
+      ((_a = this.languageOverride ?? await this.epub.getLanguage()) == null ? void 0 : _a.language) ?? "unknown"
+    );
+    this.timing.setMetadata("granularity", this.granularity);
+    const spine = await this.epub.getSpineItems();
+    const transcriptionText = this.transcription.transcript;
+    let lastTranscriptionOffset = 0;
+    let lastSentenceRange = null;
+    for (let index = 0; index < spine.length; index++) {
+      onProgress == null ? void 0 : onProgress(index / spine.length);
+      const spineItem = spine[index];
+      (_b = this.logger) == null ? void 0 : _b.info(
+        `Aligning epub item #${index} : ${(0, import_posix.basename)(spineItem.href)}`
+      );
+      const chapterId = spineItem.id;
+      const chapterSentences = await this.getChapterSentences(chapterId);
+      if (chapterSentences.length === 0) {
+        (_c = this.logger) == null ? void 0 : _c.info(`Chapter #${index} has no text; skipping`);
+        continue;
+      }
+      if (chapterSentences.length < 2 && // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      chapterSentences[0].split(" ").length < 4) {
+        (_d = this.logger) == null ? void 0 : _d.info(
+          `Chapter #${index} is fewer than four words; skipping`
+        );
+        continue;
+      }
+      const { startSentence, transcriptionOffset } = this.findBestOffset(
+        chapterSentences,
+        transcriptionText,
+        lastTranscriptionOffset
+      );
+      if (transcriptionOffset === null) {
+        (_e = this.logger) == null ? void 0 : _e.info(
+          `Couldn't find matching transcription for chapter #${index}`
+        );
+        continue;
+      }
+      (_f = this.logger) == null ? void 0 : _f.info(
+        `Chapter #${index} best matches transcription at offset ${transcriptionOffset}, starting at sentence ${startSentence}`
+      );
+      const result = await this.alignChapter(
+        startSentence,
+        chapterId,
+        transcriptionOffset,
+        lastSentenceRange
+      );
+      lastSentenceRange = result.lastSentenceRange;
+      lastTranscriptionOffset = result.endTranscriptionOffset;
+      this.timing.add(result.timing.summary());
+    }
+    if (lastSentenceRange) {
+      lastSentenceRange.end = await (0, import_ffmpeg.getTrackDuration)(
+        lastSentenceRange.audiofile
+      );
+    }
+    for (const alignedChapter of this.alignedChapters) {
+      await this.writeAlignedChapter(alignedChapter);
+    }
+    await this.epub.addMetadata({
+      type: "meta",
+      properties: { property: "media:duration" },
+      value: import_epub.Epub.formatSmilDuration(this.totalDuration)
+    });
+    await this.epub.addMetadata({
+      type: "meta",
+      properties: { property: "media:active-class" },
+      value: "-epub-media-overlay-active"
+    });
+    await this.epub.addManifestItem(
+      {
+        id: "storyteller_readaloud_styles",
+        href: "Styles/storyteller-readaloud.css",
+        mediaType: "text/css"
+      },
+      `
+.-epub-media-overlay-active {
+  background-color: #ffb;
+}
+      `,
+      "utf-8"
+    );
+    return this.timing;
+  }
+}
+function createMediaOverlay(chapter, sentenceRanges) {
+  return [
+    import_epub.Epub.createXmlElement(
+      "smil",
+      {
+        xmlns: "https://www.w3.org/ns/SMIL",
+        "xmlns:epub": "http://www.idpf.org/2007/ops",
+        version: "3.0"
+      },
+      [
+        import_epub.Epub.createXmlElement("body", {}, [
+          import_epub.Epub.createXmlElement(
+            "seq",
+            {
+              id: `${chapter.id}_overlay`,
+              "epub:textref": `../${chapter.href}`,
+              "epub:type": "chapter"
+            },
+            sentenceRanges.map(
+              (sentenceRange) => import_epub.Epub.createXmlElement(
+                "par",
+                {
+                  id: `${chapter.id}-s${sentenceRange.id}`
+                },
+                [
+                  import_epub.Epub.createXmlElement("text", {
+                    src: `../${chapter.href}#${chapter.id}-s${sentenceRange.id}`
+                  }),
+                  import_epub.Epub.createXmlElement("audio", {
+                    src: `../Audio/${(0, import_posix.basename)(sentenceRange.audiofile)}`,
+                    clipBegin: `${sentenceRange.start.toFixed(3)}s`,
+                    clipEnd: `${sentenceRange.end.toFixed(3)}s`
+                  })
+                ]
+              )
+            )
+          )
+        ])
+      ]
+    )
+  ];
+}
+function concatTranscriptions(transcriptions, audiofiles) {
+  return transcriptions.reduce(
+    (acc, transcription, index) => ({
+      ...acc,
+      transcript: acc.transcript + " " + transcription.transcript,
+      timeline: [
+        ...acc.timeline,
+        ...transcription.timeline.map((entry) => ({
+          ...entry,
+          startOffsetUtf16: (entry.startOffsetUtf16 ?? 0) + acc.transcript.length + 1,
+          endOffsetUtf16: (entry.endOffsetUtf16 ?? 0) + acc.transcript.length + 1,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          audiofile: audiofiles[index]
+        }))
+      ]
+    }),
+    { transcript: "", timeline: [] }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Aligner,
+  align,
+  concatTranscriptions
+});

package/dist/align/align.d.cts

@@ -0,0 +1,58 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { Logger } from 'pino';
+import { Epub } from '@storyteller-platform/epub';
+import { RecognitionResult } from '@storyteller-platform/ghost-story/recognition';
+import { StorytellerTranscription } from './getSentenceRanges.cjs';
+
+interface AudioFileContext {
+    start: number;
+    end: number;
+    filepath: string;
+}
+interface ChapterReport {
+    href: string;
+    transcriptionOffset: number;
+    transcriptionContext: {
+        before: string;
+        after: string;
+    };
+    firstMatchedSentenceId: number;
+    firstMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    audioFiles: AudioFileContext[];
+}
+interface Report {
+    chapters: ChapterReport[];
+}
+interface AlignOptions {
+    reportsPath?: string | null | undefined;
+    granularity: "sentence" | "word" | null | undefined;
+    primaryLocale?: Intl.Locale | null | undefined;
+    logger?: Logger | null | undefined;
+    onProgress?: ((progress: number) => void) | null | undefined;
+}
+declare function align(input: string, output: string, transcriptionsDir: string, audiobookDir: string, options: AlignOptions): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+declare class Aligner {
+    epub: Epub;
+    private languageOverride?;
+    private logger?;
+    private transcription;
+    private totalDuration;
+    private alignedChapters;
+    private timing;
+    private granularity;
+    report: Report;
+    constructor(epub: Epub, audiofiles: string[], transcriptions: Pick<RecognitionResult, "transcript" | "timeline">[], granularity: "sentence" | "word" | null | undefined, languageOverride?: (Intl.Locale | null) | undefined, logger?: (Logger | null) | undefined);
+    private findBestOffset;
+    private getChapterSentences;
+    private writeAlignedChapter;
+    private addChapterReport;
+    private alignChapter;
+    alignBook(onProgress?: ((progress: number) => void) | null): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+}
+declare function concatTranscriptions(transcriptions: Pick<RecognitionResult, "transcript" | "timeline">[], audiofiles: string[]): StorytellerTranscription;
+
+export { type AlignOptions, Aligner, align, concatTranscriptions };

package/dist/align/align.d.ts

@@ -0,0 +1,58 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { Logger } from 'pino';
+import { Epub } from '@storyteller-platform/epub';
+import { RecognitionResult } from '@storyteller-platform/ghost-story/recognition';
+import { StorytellerTranscription } from './getSentenceRanges.js';
+
+interface AudioFileContext {
+    start: number;
+    end: number;
+    filepath: string;
+}
+interface ChapterReport {
+    href: string;
+    transcriptionOffset: number;
+    transcriptionContext: {
+        before: string;
+        after: string;
+    };
+    firstMatchedSentenceId: number;
+    firstMatchedSentenceContext: {
+        prevSentence: string | null;
+        matchedSentence: string;
+        nextSentence: string | null;
+    };
+    audioFiles: AudioFileContext[];
+}
+interface Report {
+    chapters: ChapterReport[];
+}
+interface AlignOptions {
+    reportsPath?: string | null | undefined;
+    granularity: "sentence" | "word" | null | undefined;
+    primaryLocale?: Intl.Locale | null | undefined;
+    logger?: Logger | null | undefined;
+    onProgress?: ((progress: number) => void) | null | undefined;
+}
+declare function align(input: string, output: string, transcriptionsDir: string, audiobookDir: string, options: AlignOptions): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+declare class Aligner {
+    epub: Epub;
+    private languageOverride?;
+    private logger?;
+    private transcription;
+    private totalDuration;
+    private alignedChapters;
+    private timing;
+    private granularity;
+    report: Report;
+    constructor(epub: Epub, audiofiles: string[], transcriptions: Pick<RecognitionResult, "transcript" | "timeline">[], granularity: "sentence" | "word" | null | undefined, languageOverride?: (Intl.Locale | null) | undefined, logger?: (Logger | null) | undefined);
+    private findBestOffset;
+    private getChapterSentences;
+    private writeAlignedChapter;
+    private addChapterReport;
+    private alignChapter;
+    alignBook(onProgress?: ((progress: number) => void) | null): Promise<_storyteller_platform_ghost_story.TimingAggregator>;
+}
+declare function concatTranscriptions(transcriptions: Pick<RecognitionResult, "transcript" | "timeline">[], audiofiles: string[]): StorytellerTranscription;
+
+export { type AlignOptions, Aligner, align, concatTranscriptions };