@storyteller-platform/align 0.1.57 → 0.1.58

package/dist/snapshot/ctc/snapshot.cjs

@@ -0,0 +1,261 @@
+"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 snapshot_exports = {};
+__export(snapshot_exports, {
+  createAlignmentSnapshot: () => createAlignmentSnapshot,
+  snapshotCtcAlignment: () => snapshotCtcAlignment
+});
+module.exports = __toCommonJS(snapshot_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_posix = require("node:path/posix");
+var import_epub = require("@storyteller-platform/epub");
+var import_greedyDecode = require("../../align/ctc/greedyDecode.cjs");
+var import_slugify = require("../../align/slugify.cjs");
+var import_fs = require("../../emit/fs.cjs");
+var import_parseDom = require("../../markup/parseDom.cjs");
+var import_segmentation = require("../../markup/segmentation.cjs");
+var import_transform = require("../../markup/transform.cjs");
+async function snapshotCtcAlignment(epubPath, emissionsPath, outputPath) {
+  var _stack = [];
+  try {
+    const emissionFilepaths = await (0, import_promises.readdir)(emissionsPath).then(
+      (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => (0, import_node_path.join)(emissionsPath, f))
+    );
+    const epub = __using(_stack, await import_epub.Epub.from(epubPath));
+    const snapshot = await createAlignmentSnapshot(
+      epub,
+      emissionFilepaths,
+      "id-fragment"
+    );
+    await (0, import_promises.writeFile)(outputPath, snapshot, { encoding: "utf-8" });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function secondsToFrame(seconds, timings) {
+  const chunk = Math.floor(seconds / timings.secondsPerChunk);
+  const localFrame = Math.round(
+    (seconds - chunk * timings.secondsPerChunk) / timings.secondsPerFrame
+  );
+  return chunk * timings.framesPerChunk + Math.min(localFrame, timings.framesPerChunk - 1);
+}
+async function loadDecodedEmissions(filepath) {
+  const emissionsReader = await import_fs.EmissionsReader.from(filepath);
+  const { text, frames } = await (0, import_greedyDecode.ctcGreedyDecode)(emissionsReader);
+  return {
+    text,
+    frames,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...emissionsReader.timings[0]
+  };
+}
+async function createAlignmentSnapshot(epub, emissionFilepaths, textRef, transliterate) {
+  let newSnapshot = "";
+  const decodedEmissionsCache = /* @__PURE__ */ new Map();
+  function getDecodedEmissions(filepath) {
+    let cached = decodedEmissionsCache.get(filepath);
+    if (!cached) {
+      cached = loadDecodedEmissions(filepath);
+      decodedEmissionsCache.set(filepath, cached);
+    }
+    return cached;
+  }
+  const locale = await epub.getLanguage() ?? new Intl.Locale("en-US");
+  const spine = await epub.getSpineItems();
+  const manifest = await epub.getManifest();
+  const mediaOverlayItems = spine.map((item) => item.mediaOverlay).filter((mediaOverlayId) => !!mediaOverlayId).map((id) => manifest[id]);
+  const mediaOverlays = [];
+  for (const item of mediaOverlayItems) {
+    const contents = await epub.readItemContents(item.id, "utf-8");
+    const parsed = import_epub.Epub.xmlParser.parse(contents);
+    mediaOverlays.push(parsed);
+    const smil = import_epub.Epub.findXmlChildByName("smil", parsed);
+    if (!smil) continue;
+    const body = import_epub.Epub.findXmlChildByName("body", import_epub.Epub.getXmlChildren(smil));
+    if (!body) continue;
+    const seq = import_epub.Epub.findXmlChildByName("seq", import_epub.Epub.getXmlChildren(body));
+    if (!seq) continue;
+    const textref = seq[":@"]?.["@_epub:textref"];
+    if (!textref) continue;
+    newSnapshot += `// ${(0, import_posix.basename)(textref)}
+
+`;
+    const chapterContents = await epub.readFileContents(
+      textref,
+      item.href,
+      "utf-8"
+    );
+    const chapterXml = import_epub.Epub.xhtmlParser.parse(chapterContents);
+    const original = (0, import_parseDom.parseDom)(import_epub.Epub.getXhtmlBody(chapterXml));
+    const inlined = (0, import_transform.inlineFootnotes)(original);
+    const lifted = (0, import_transform.liftText)(inlined.root);
+    const segmentation = await (0, import_segmentation.segmentChapter)(lifted.result, {
+      primaryLocale: new Intl.Locale("en-US")
+    });
+    let lastChapterSentence = -1;
+    const chapterSentences = segmentation.filter((s) => s.text.match(/\S/));
+    const pars = findAll("par", import_epub.Epub.getXmlChildren(seq));
+    for (const par of pars) {
+      newSnapshot += `
+`;
+      const text = import_epub.Epub.findXmlChildByName("text", import_epub.Epub.getXmlChildren(par));
+      if (!text) continue;
+      const audio = import_epub.Epub.findXmlChildByName("audio", import_epub.Epub.getXmlChildren(par));
+      if (!audio) continue;
+      const textSrc = text[":@"]?.["@_src"];
+      if (!textSrc) continue;
+      const result = textRef === "id-fragment" ? getTextSentenceIndexByIdFragment(textSrc) : getTextSentenceIndexByTextFragment(
+        textSrc,
+        chapterSentences,
+        lastChapterSentence
+      );
+      if (result === null) continue;
+      const { fragment, sentenceId } = result;
+      const textSentence = chapterSentences[sentenceId]?.text.replace(/\n/, "");
+      if (!textSentence) continue;
+      lastChapterSentence = sentenceId;
+      if (textRef === "text-fragment") {
+        newSnapshot += `${fragment}
+`;
+      }
+      newSnapshot += `Text:  ${transliterate ? (await (0, import_slugify.slugify)(textSentence, locale)).result : textSentence}
+`;
+      const audioSrc = audio[":@"]?.["@_src"];
+      if (!audioSrc) continue;
+      const audioStart = audio[":@"]?.["@_clipBegin"];
+      const audioEnd = audio[":@"]?.["@_clipEnd"];
+      if (!audioStart || !audioEnd) continue;
+      const audioStartTime = parseFloat(audioStart.slice(0, -1));
+      const audioEndTime = parseFloat(audioEnd.slice(0, -1));
+      const audioFilename = (0, import_posix.basename)(audioSrc, (0, import_posix.extname)(audioSrc));
+      const emissionFilepath = emissionFilepaths.find((f) => {
+        const withoutJson = (0, import_node_path.basename)(f, (0, import_node_path.extname)(f));
+        return (0, import_node_path.basename)(withoutJson, (0, import_node_path.extname)(withoutJson)) === audioFilename;
+      });
+      if (!emissionFilepath) continue;
+      const decoded = await getDecodedEmissions(emissionFilepath);
+      const startFrame = secondsToFrame(audioStartTime, decoded);
+      const endFrame = secondsToFrame(audioEndTime, decoded);
+      let decodedSentence = "";
+      for (let i = 0; i < decoded.frames.length; i++) {
+        const frame = decoded.frames[i];
+        if (frame > endFrame) break;
+        if (frame >= startFrame) {
+          decodedSentence += decoded.text[i];
+        }
+      }
+      newSnapshot += `Audio: ${decodedSentence}
+`;
+    }
+    newSnapshot += `
+`;
+  }
+  return newSnapshot;
+}
+function getTextSentenceIndexByTextFragment(textSrc, chapterSentences, lastChapterSentence) {
+  const textSrcMatch = textSrc.match(/#:~:text=(.+)$/);
+  if (!textSrcMatch) return null;
+  const textFragment = textSrcMatch[1];
+  if (textFragment === void 0) return null;
+  const textFragmentParts = textFragment.split(",");
+  const textFragmentPrefix = textFragmentParts[0]?.endsWith("-") ? decodeURIComponent(textFragmentParts[0]).slice(0, -1) : "";
+  const textFragmentStart = decodeURIComponent(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    textFragmentPrefix ? textFragmentParts[1] : textFragmentParts[0]
+  );
+  const textSentenceIndex = chapterSentences.slice(lastChapterSentence + 1).findIndex((s, i) => {
+    const prev = chapterSentences[lastChapterSentence + i];
+    return (!prev || prev.text.replace("\n", " ").toLowerCase().endsWith(textFragmentPrefix)) && s.text.replace("\n", " ").toLowerCase().startsWith(textFragmentStart);
+  });
+  if (textSentenceIndex === -1) return null;
+  return {
+    fragment: textSrcMatch[0],
+    sentenceId: textSentenceIndex + lastChapterSentence + 1
+  };
+}
+function getTextSentenceIndexByIdFragment(textSrc) {
+  const match = textSrc.match(/#.*s([0-9]+)$/);
+  if (!match) return null;
+  const [fragment, sentenceId] = match;
+  return { fragment, sentenceId: parseInt(sentenceId, 10) };
+}
+function findAll(name, xml) {
+  const result = [];
+  for (const child of xml) {
+    if (import_epub.Epub.isXmlTextNode(child)) continue;
+    if (import_epub.Epub.getXmlElementName(child) === name) {
+      result.push(child);
+    }
+    result.push(...findAll(name, import_epub.Epub.getXmlChildren(child)));
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAlignmentSnapshot,
+  snapshotCtcAlignment
+});

package/dist/snapshot/ctc/snapshot.d.cts

@@ -0,0 +1,6 @@
+import { Epub } from '@storyteller-platform/epub';
+
+declare function snapshotCtcAlignment(epubPath: string, emissionsPath: string, outputPath: string): Promise<void>;
+declare function createAlignmentSnapshot(epub: Epub, emissionFilepaths: string[], textRef: "id-fragment" | "text-fragment", transliterate?: boolean): Promise<string>;
+
+export { createAlignmentSnapshot, snapshotCtcAlignment };

package/dist/snapshot/ctc/snapshot.d.ts

@@ -0,0 +1,6 @@
+import { Epub } from '@storyteller-platform/epub';
+
+declare function snapshotCtcAlignment(epubPath: string, emissionsPath: string, outputPath: string): Promise<void>;
+declare function createAlignmentSnapshot(epub: Epub, emissionFilepaths: string[], textRef: "id-fragment" | "text-fragment", transliterate?: boolean): Promise<string>;
+
+export { createAlignmentSnapshot, snapshotCtcAlignment };

package/dist/snapshot/ctc/snapshot.js

@@ -0,0 +1,200 @@
+import {
+  __callDispose,
+  __using
+} from "../../chunk-BIEQXUOY.js";
+import { readdir, writeFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import {
+  basename as posixBasename,
+  extname as posixExtname
+} from "node:path/posix";
+import {
+  Epub
+} from "@storyteller-platform/epub";
+import { ctcGreedyDecode } from "../../align/ctc/greedyDecode.js";
+import { slugify } from "../../align/slugify.js";
+import { EmissionsReader } from "../../emit/fs.js";
+import { parseDom } from "../../markup/parseDom.js";
+import { segmentChapter } from "../../markup/segmentation.js";
+import { inlineFootnotes, liftText } from "../../markup/transform.js";
+async function snapshotCtcAlignment(epubPath, emissionsPath, outputPath) {
+  var _stack = [];
+  try {
+    const emissionFilepaths = await readdir(emissionsPath).then(
+      (filenames) => filenames.filter((f) => f.endsWith(".json")).map((f) => join(emissionsPath, f))
+    );
+    const epub = __using(_stack, await Epub.from(epubPath));
+    const snapshot = await createAlignmentSnapshot(
+      epub,
+      emissionFilepaths,
+      "id-fragment"
+    );
+    await writeFile(outputPath, snapshot, { encoding: "utf-8" });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function secondsToFrame(seconds, timings) {
+  const chunk = Math.floor(seconds / timings.secondsPerChunk);
+  const localFrame = Math.round(
+    (seconds - chunk * timings.secondsPerChunk) / timings.secondsPerFrame
+  );
+  return chunk * timings.framesPerChunk + Math.min(localFrame, timings.framesPerChunk - 1);
+}
+async function loadDecodedEmissions(filepath) {
+  const emissionsReader = await EmissionsReader.from(filepath);
+  const { text, frames } = await ctcGreedyDecode(emissionsReader);
+  return {
+    text,
+    frames,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...emissionsReader.timings[0]
+  };
+}
+async function createAlignmentSnapshot(epub, emissionFilepaths, textRef, transliterate) {
+  let newSnapshot = "";
+  const decodedEmissionsCache = /* @__PURE__ */ new Map();
+  function getDecodedEmissions(filepath) {
+    let cached = decodedEmissionsCache.get(filepath);
+    if (!cached) {
+      cached = loadDecodedEmissions(filepath);
+      decodedEmissionsCache.set(filepath, cached);
+    }
+    return cached;
+  }
+  const locale = await epub.getLanguage() ?? new Intl.Locale("en-US");
+  const spine = await epub.getSpineItems();
+  const manifest = await epub.getManifest();
+  const mediaOverlayItems = spine.map((item) => item.mediaOverlay).filter((mediaOverlayId) => !!mediaOverlayId).map((id) => manifest[id]);
+  const mediaOverlays = [];
+  for (const item of mediaOverlayItems) {
+    const contents = await epub.readItemContents(item.id, "utf-8");
+    const parsed = Epub.xmlParser.parse(contents);
+    mediaOverlays.push(parsed);
+    const smil = Epub.findXmlChildByName("smil", parsed);
+    if (!smil) continue;
+    const body = Epub.findXmlChildByName("body", Epub.getXmlChildren(smil));
+    if (!body) continue;
+    const seq = Epub.findXmlChildByName("seq", Epub.getXmlChildren(body));
+    if (!seq) continue;
+    const textref = seq[":@"]?.["@_epub:textref"];
+    if (!textref) continue;
+    newSnapshot += `// ${posixBasename(textref)}
+
+`;
+    const chapterContents = await epub.readFileContents(
+      textref,
+      item.href,
+      "utf-8"
+    );
+    const chapterXml = Epub.xhtmlParser.parse(chapterContents);
+    const original = parseDom(Epub.getXhtmlBody(chapterXml));
+    const inlined = inlineFootnotes(original);
+    const lifted = liftText(inlined.root);
+    const segmentation = await segmentChapter(lifted.result, {
+      primaryLocale: new Intl.Locale("en-US")
+    });
+    let lastChapterSentence = -1;
+    const chapterSentences = segmentation.filter((s) => s.text.match(/\S/));
+    const pars = findAll("par", Epub.getXmlChildren(seq));
+    for (const par of pars) {
+      newSnapshot += `
+`;
+      const text = Epub.findXmlChildByName("text", Epub.getXmlChildren(par));
+      if (!text) continue;
+      const audio = Epub.findXmlChildByName("audio", Epub.getXmlChildren(par));
+      if (!audio) continue;
+      const textSrc = text[":@"]?.["@_src"];
+      if (!textSrc) continue;
+      const result = textRef === "id-fragment" ? getTextSentenceIndexByIdFragment(textSrc) : getTextSentenceIndexByTextFragment(
+        textSrc,
+        chapterSentences,
+        lastChapterSentence
+      );
+      if (result === null) continue;
+      const { fragment, sentenceId } = result;
+      const textSentence = chapterSentences[sentenceId]?.text.replace(/\n/, "");
+      if (!textSentence) continue;
+      lastChapterSentence = sentenceId;
+      if (textRef === "text-fragment") {
+        newSnapshot += `${fragment}
+`;
+      }
+      newSnapshot += `Text:  ${transliterate ? (await slugify(textSentence, locale)).result : textSentence}
+`;
+      const audioSrc = audio[":@"]?.["@_src"];
+      if (!audioSrc) continue;
+      const audioStart = audio[":@"]?.["@_clipBegin"];
+      const audioEnd = audio[":@"]?.["@_clipEnd"];
+      if (!audioStart || !audioEnd) continue;
+      const audioStartTime = parseFloat(audioStart.slice(0, -1));
+      const audioEndTime = parseFloat(audioEnd.slice(0, -1));
+      const audioFilename = posixBasename(audioSrc, posixExtname(audioSrc));
+      const emissionFilepath = emissionFilepaths.find((f) => {
+        const withoutJson = basename(f, extname(f));
+        return basename(withoutJson, extname(withoutJson)) === audioFilename;
+      });
+      if (!emissionFilepath) continue;
+      const decoded = await getDecodedEmissions(emissionFilepath);
+      const startFrame = secondsToFrame(audioStartTime, decoded);
+      const endFrame = secondsToFrame(audioEndTime, decoded);
+      let decodedSentence = "";
+      for (let i = 0; i < decoded.frames.length; i++) {
+        const frame = decoded.frames[i];
+        if (frame > endFrame) break;
+        if (frame >= startFrame) {
+          decodedSentence += decoded.text[i];
+        }
+      }
+      newSnapshot += `Audio: ${decodedSentence}
+`;
+    }
+    newSnapshot += `
+`;
+  }
+  return newSnapshot;
+}
+function getTextSentenceIndexByTextFragment(textSrc, chapterSentences, lastChapterSentence) {
+  const textSrcMatch = textSrc.match(/#:~:text=(.+)$/);
+  if (!textSrcMatch) return null;
+  const textFragment = textSrcMatch[1];
+  if (textFragment === void 0) return null;
+  const textFragmentParts = textFragment.split(",");
+  const textFragmentPrefix = textFragmentParts[0]?.endsWith("-") ? decodeURIComponent(textFragmentParts[0]).slice(0, -1) : "";
+  const textFragmentStart = decodeURIComponent(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    textFragmentPrefix ? textFragmentParts[1] : textFragmentParts[0]
+  );
+  const textSentenceIndex = chapterSentences.slice(lastChapterSentence + 1).findIndex((s, i) => {
+    const prev = chapterSentences[lastChapterSentence + i];
+    return (!prev || prev.text.replace("\n", " ").toLowerCase().endsWith(textFragmentPrefix)) && s.text.replace("\n", " ").toLowerCase().startsWith(textFragmentStart);
+  });
+  if (textSentenceIndex === -1) return null;
+  return {
+    fragment: textSrcMatch[0],
+    sentenceId: textSentenceIndex + lastChapterSentence + 1
+  };
+}
+function getTextSentenceIndexByIdFragment(textSrc) {
+  const match = textSrc.match(/#.*s([0-9]+)$/);
+  if (!match) return null;
+  const [fragment, sentenceId] = match;
+  return { fragment, sentenceId: parseInt(sentenceId, 10) };
+}
+function findAll(name, xml) {
+  const result = [];
+  for (const child of xml) {
+    if (Epub.isXmlTextNode(child)) continue;
+    if (Epub.getXmlElementName(child) === name) {
+      result.push(child);
+    }
+    result.push(...findAll(name, Epub.getXmlChildren(child)));
+  }
+  return result;
+}
+export {
+  createAlignmentSnapshot,
+  snapshotCtcAlignment
+};

package/dist/snapshot/parse.cjs

@@ -25,22 +25,35 @@ module.exports = __toCommonJS(parse_exports);
 var import_core = require("@optique/core");
 var import_run = require("@optique/run");
 var import_parse = require("../common/parse.cjs");
-const snapshotParser = (0, import_core.object)("Snapshot", {
-  transcriptions: (0, import_core.option)(
-    "--transcriptions",
-    (0, import_run.path)({ mustExist: true, type: "directory" })
-  ),
-  epub: (0, import_core.option)(
-    "--epub",
-    (0, import_run.path)({ mustExist: true, type: "file", extensions: [".epub"] }),
-    {
-      description: import_core.message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
-    }
-  ),
-  output: (0, import_core.argument)((0, import_run.path)({ type: "file", metavar: "OUTPUT_PATH" }), {
-    description: import_core.message`Path to save the snapshot.`
-  })
-});
+const snapshotParser = (0, import_core.merge)(
+  (0, import_core.object)("Snapshot", {
+    epub: (0, import_core.option)(
+      "--epub",
+      (0, import_run.path)({ mustExist: true, type: "file", extensions: [".epub"] }),
+      {
+        description: import_core.message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
+      }
+    ),
+    output: (0, import_core.argument)((0, import_run.path)({ type: "file", metavar: "OUTPUT_PATH" }), {
+      description: import_core.message`Path to save the snapshot.`
+    })
+  }),
+  (0, import_core.or)(
+    (0, import_core.object)({
+      transcriptions: (0, import_core.option)(
+        "--transcriptions",
+        (0, import_run.path)({ mustExist: true, type: "directory" })
+      )
+    }),
+    (0, import_core.object)({
+      ctc: (0, import_core.flag)("--ctc"),
+      emissions: (0, import_core.option)(
+        "--emissions",
+        (0, import_run.path)({ mustExist: true, type: "directory" })
+      )
+    })
+  )
+);
 const snapshotCommand = (0, import_core.command)(
   "snapshot",
   (0, import_core.merge)(

package/dist/snapshot/parse.d.cts

@@ -1,24 +1,28 @@
 import * as _optique_core from '@optique/core';
 
 declare const snapshotParser: _optique_core.Parser<"sync", {
-    readonly transcriptions: string;
     readonly epub: string;
     readonly output: string;
-}, {
-    readonly transcriptions: _optique_core.ValueParserResult<string> | undefined;
-    readonly epub: _optique_core.ValueParserResult<string> | undefined;
-    readonly output: _optique_core.ValueParserResult<string> | undefined;
-}>;
+} & ({
+    readonly transcriptions: string;
+} | {
+    readonly ctc: true;
+    readonly emissions: string;
+}), Record<string | symbol, unknown>>;
 declare const snapshotCommand: _optique_core.Parser<"sync", {
     readonly action: "snapshot";
-} & {
-    readonly transcriptions: string;
+} & (({
     readonly epub: string;
     readonly output: string;
-} & {
+} & ({
+    readonly transcriptions: string;
+} | {
+    readonly ctc: true;
+    readonly emissions: string;
+})) & {
     readonly noProgress: boolean;
     readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
     readonly time: boolean;
-}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+}), ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
 
 export { snapshotCommand, snapshotParser };

package/dist/snapshot/parse.d.ts

@@ -1,24 +1,28 @@
 import * as _optique_core from '@optique/core';
 
 declare const snapshotParser: _optique_core.Parser<"sync", {
-    readonly transcriptions: string;
     readonly epub: string;
     readonly output: string;
-}, {
-    readonly transcriptions: _optique_core.ValueParserResult<string> | undefined;
-    readonly epub: _optique_core.ValueParserResult<string> | undefined;
-    readonly output: _optique_core.ValueParserResult<string> | undefined;
-}>;
+} & ({
+    readonly transcriptions: string;
+} | {
+    readonly ctc: true;
+    readonly emissions: string;
+}), Record<string | symbol, unknown>>;
 declare const snapshotCommand: _optique_core.Parser<"sync", {
     readonly action: "snapshot";
-} & {
-    readonly transcriptions: string;
+} & (({
     readonly epub: string;
     readonly output: string;
-} & {
+} & ({
+    readonly transcriptions: string;
+} | {
+    readonly ctc: true;
+    readonly emissions: string;
+})) & {
     readonly noProgress: boolean;
     readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
     readonly time: boolean;
-}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+}), ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
 
 export { snapshotCommand, snapshotParser };

package/dist/snapshot/parse.js

@@ -3,29 +3,44 @@ import {
   argument,
   command,
   constant,
+  flag,
   merge,
   message,
   object,
-  option
+  option,
+  or
 } from "@optique/core";
 import { path } from "@optique/run";
 import { loggingParser } from "../common/parse.js";
-const snapshotParser = object("Snapshot", {
-  transcriptions: option(
-    "--transcriptions",
-    path({ mustExist: true, type: "directory" })
-  ),
-  epub: option(
-    "--epub",
-    path({ mustExist: true, type: "file", extensions: [".epub"] }),
-    {
-      description: message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
-    }
-  ),
-  output: argument(path({ type: "file", metavar: "OUTPUT_PATH" }), {
-    description: message`Path to save the snapshot.`
-  })
-});
+const snapshotParser = merge(
+  object("Snapshot", {
+    epub: option(
+      "--epub",
+      path({ mustExist: true, type: "file", extensions: [".epub"] }),
+      {
+        description: message`Path to an EPUB file to snapshot. This EPUB must have Media Overlays and audio files corresponding to the transcription files passed to --transcriptions.`
+      }
+    ),
+    output: argument(path({ type: "file", metavar: "OUTPUT_PATH" }), {
+      description: message`Path to save the snapshot.`
+    })
+  }),
+  or(
+    object({
+      transcriptions: option(
+        "--transcriptions",
+        path({ mustExist: true, type: "directory" })
+      )
+    }),
+    object({
+      ctc: flag("--ctc"),
+      emissions: option(
+        "--emissions",
+        path({ mustExist: true, type: "directory" })
+      )
+    })
+  )
+);
 const snapshotCommand = command(
   "snapshot",
   merge(