@bendyline/squisq 2.11.5 → 2.11.6

package/dist/chunk-44BJ42GT.js

@@ -0,0 +1,165 @@
+import {
+  estimateTimeFromText
+} from "./chunk-GHOPHGOK.js";
+
+// src/timing/captions.ts
+var DEFAULT_VERSION = 1;
+var DEFAULT_TARGET_WORDS = 10;
+var DEFAULT_MIN_DURATION = 1.5;
+var DEFAULT_MAX_DURATION = 6;
+var DEFAULT_WORDS_PER_SECOND = 2.5;
+function phrasesFromTiming(source, segmentIndex, targetWords) {
+  const { segment, timing } = source;
+  if (!timing || timing.bookmarks.length === 0) return [];
+  const segmentEnd = segment.startTime + segment.duration;
+  const phrases = [];
+  let words = [];
+  let phraseText = "";
+  for (let index = 0; index < timing.bookmarks.length; index += 1) {
+    const bookmark = timing.bookmarks[index];
+    const text = bookmark.textFragment?.trim() ?? "";
+    if (!text) continue;
+    const next = timing.bookmarks[index + 1];
+    const startTime = Math.min(
+      segmentEnd,
+      Math.max(segment.startTime, segment.startTime + bookmark.time)
+    );
+    const endTime = Math.min(
+      segmentEnd,
+      Math.max(startTime, segment.startTime + (next?.time ?? timing.duration))
+    );
+    const word = {
+      text,
+      startTime,
+      endTime
+    };
+    words.push(word);
+    phraseText += `${phraseText ? " " : ""}${text}`;
+    const flush = /[.!?]$/.test(text) && words.length >= 4 || /[,;:]$/.test(text) && words.length >= targetWords - 2 || words.length >= targetWords + 3 || index === timing.bookmarks.length - 1;
+    if (flush) {
+      phrases.push({
+        text: phraseText,
+        startTime: words[0].startTime,
+        endTime: words[words.length - 1].endTime,
+        audioSegment: segmentIndex,
+        words
+      });
+      words = [];
+      phraseText = "";
+    }
+  }
+  return phrases;
+}
+function phrasesFromText(source, segmentIndex, options) {
+  const { segment } = source;
+  const sourceText = source.text?.trim();
+  if (!sourceText) return [];
+  const prefix = source.spokenPrefix ?? "";
+  const prefixWords = prefix.split(/\s+/).filter(Boolean).length;
+  const prefixDuration = Math.min(
+    segment.duration,
+    prefixWords / options.wordsPerSecond + (prefix.match(/\n\n/g)?.length ?? 0) * 0.5
+  );
+  const contentDuration = Math.max(0, segment.duration - prefixDuration);
+  const phrases = [];
+  const prefixText = prefix.replace(/\n+/g, " ").trim();
+  if (prefixText && prefixDuration > 0.5) {
+    phrases.push({
+      text: prefixText,
+      startTime: segment.startTime,
+      endTime: Math.min(segment.startTime + segment.duration, segment.startTime + prefixDuration),
+      audioSegment: segmentIndex
+    });
+  }
+  const sentences = sourceText.replace(/\n+/g, " ").split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter(Boolean);
+  let phraseText = "";
+  let phraseWordCount = 0;
+  let phraseStartOffset = 0;
+  let currentOffset = 0;
+  const flush = () => {
+    if (!phraseText) return;
+    const startTime = segment.startTime + prefixDuration + estimateTimeFromText(sourceText, phraseStartOffset, contentDuration);
+    const estimatedEnd = segment.startTime + prefixDuration + estimateTimeFromText(sourceText, currentOffset, contentDuration);
+    phrases.push({
+      text: phraseText,
+      startTime,
+      endTime: Math.min(
+        segment.startTime + segment.duration,
+        Math.min(
+          Math.max(startTime + options.minPhraseDuration, estimatedEnd),
+          startTime + options.maxPhraseDuration
+        )
+      ),
+      audioSegment: segmentIndex
+    });
+    phraseText = "";
+    phraseWordCount = 0;
+    phraseStartOffset = currentOffset;
+  };
+  for (const sentence of sentences) {
+    const sentenceWords = sentence.split(/\s+/).filter(Boolean).length;
+    if (phraseWordCount > 0 && phraseWordCount + sentenceWords > options.targetWordsPerPhrase * 1.5) {
+      flush();
+    }
+    phraseText += `${phraseText ? " " : ""}${sentence}`;
+    phraseWordCount += sentenceWords;
+    currentOffset += sentence.length + 1;
+    if (phraseWordCount >= options.targetWordsPerPhrase) flush();
+  }
+  flush();
+  return phrases;
+}
+function buildCaptionTrack(sources, options = {}) {
+  const targetWordsPerPhrase = options.targetWordsPerPhrase ?? DEFAULT_TARGET_WORDS;
+  const textOptions = {
+    targetWordsPerPhrase,
+    minPhraseDuration: options.minPhraseDuration ?? DEFAULT_MIN_DURATION,
+    maxPhraseDuration: options.maxPhraseDuration ?? DEFAULT_MAX_DURATION,
+    wordsPerSecond: options.wordsPerSecond ?? DEFAULT_WORDS_PER_SECOND
+  };
+  if (!Number.isInteger(targetWordsPerPhrase) || targetWordsPerPhrase < 1) {
+    throw new Error("targetWordsPerPhrase must be a positive integer");
+  }
+  if (!Number.isFinite(textOptions.wordsPerSecond) || textOptions.wordsPerSecond <= 0) {
+    throw new Error("wordsPerSecond must be a positive finite number");
+  }
+  if (!Number.isFinite(textOptions.minPhraseDuration) || !Number.isFinite(textOptions.maxPhraseDuration) || textOptions.minPhraseDuration < 0 || textOptions.maxPhraseDuration < textOptions.minPhraseDuration) {
+    throw new Error(
+      "caption phrase durations must be finite with max greater than or equal to min"
+    );
+  }
+  const phrases = sources.flatMap((source, segmentIndex) => {
+    const timed = phrasesFromTiming(source, segmentIndex, targetWordsPerPhrase);
+    return timed.length > 0 ? timed : phrasesFromText(source, segmentIndex, textOptions);
+  });
+  if (options.closePhraseGaps ?? true) {
+    for (let index = 0; index < phrases.length - 1; index += 1) {
+      if (phrases[index].audioSegment === phrases[index + 1].audioSegment) {
+        phrases[index].endTime = Math.max(phrases[index].startTime, phrases[index + 1].startTime);
+      }
+    }
+    for (let segmentIndex = 0; segmentIndex < sources.length; segmentIndex += 1) {
+      const segment = sources[segmentIndex].segment;
+      let last;
+      for (let index = phrases.length - 1; index >= 0; index -= 1) {
+        if (phrases[index].audioSegment === segmentIndex) {
+          last = phrases[index];
+          break;
+        }
+      }
+      if (last) {
+        const segmentEnd = segment.startTime + segment.duration;
+        last.endTime = Math.min(segmentEnd, Math.max(last.endTime, segmentEnd - 0.05));
+      }
+    }
+  }
+  return {
+    phrases,
+    ...options.generatedAt ? { generatedAt: options.generatedAt } : {},
+    version: options.version ?? DEFAULT_VERSION
+  };
+}
+
+export {
+  buildCaptionTrack
+};

package/dist/chunk-764WHWKM.js

@@ -0,0 +1,332 @@
+import {
+  flattenRenderableBlocks,
+  getBlockBodyText
+} from "./chunk-WAGJK36Q.js";
+import {
+  estimateSpokenWordCount
+} from "./chunk-GHOPHGOK.js";
+
+// src/narration/syllables.ts
+var BOUNDARY_PUNCT = /^[.,!?;:'"()[\]{}]+|[.,!?;:'"()[\]{}]+$/g;
+var SYLLABLES_PER_SPOKEN_WORD = 1.4;
+function estimateSyllables(token) {
+  const stripped = token.replace(BOUNDARY_PUNCT, "");
+  if (!stripped) return 1;
+  if (/^[-+]?[\d.,]+$/.test(stripped)) {
+    const num = parseFloat(stripped.replace(/,/g, ""));
+    if (!Number.isNaN(num) && Number.isFinite(num)) {
+      return Math.max(1, Math.round(estimateSpokenWordCount(stripped) * SYLLABLES_PER_SPOKEN_WORD));
+    }
+  }
+  if (/^[A-Z]{2,5}$/.test(stripped) && !/[AEIOUY]/.test(stripped)) {
+    return stripped.length;
+  }
+  const parts = stripped.toLowerCase().split(/[^a-z']+/).filter((p) => p.length > 0);
+  if (parts.length === 0) return 1;
+  let total = 0;
+  for (const part of parts) {
+    total += countAlphaSyllables(part.replace(/'/g, ""));
+  }
+  return Math.max(1, total);
+}
+function countAlphaSyllables(word) {
+  if (!word) return 0;
+  const groups = word.match(/[aeiouy]+/g);
+  let count = groups ? groups.length : 0;
+  if (count === 0) return 1;
+  if (count > 1 && /[^aeiouy]e$/.test(word)) {
+    count -= 1;
+  }
+  if (count > 1 && /[^aeiouy]ed$/.test(word) && !/[td]ed$/.test(word)) {
+    count -= 1;
+  }
+  if (count > 1 && /[^aeiouy]es$/.test(word) && !/(?:[sxz]|[cs]h)es$/.test(word)) {
+    count -= 1;
+  }
+  if (/[^aeiouy]le$/.test(word)) {
+    count += 1;
+  }
+  return Math.max(1, count);
+}
+
+// src/narration/script.ts
+function blockSpokenText(block, includeTitles) {
+  const title = includeTitles && block.title ? block.title.trim() : "";
+  const body = getBlockBodyText(block);
+  if (title && body) return `${title}
+${body}`;
+  return title || body;
+}
+function buildNarrationScript(doc, options) {
+  const includeTitles = options?.includeTitles ?? true;
+  const separator = options?.blockSeparator ?? "\n\n";
+  const pieces = [];
+  for (const block of flattenRenderableBlocks(doc.blocks)) {
+    const text = blockSpokenText(block, includeTitles);
+    if (!text) continue;
+    pieces.push({
+      blockId: block.id,
+      heading: block.title || void 0,
+      text
+    });
+  }
+  let sourceText = "";
+  const blocks = [];
+  for (let i = 0; i < pieces.length; i++) {
+    if (i > 0) sourceText += separator;
+    const charStart = sourceText.length;
+    sourceText += pieces[i].text;
+    blocks.push({
+      blockId: pieces[i].blockId,
+      ...pieces[i].heading !== void 0 ? { heading: pieces[i].heading } : {},
+      tokenStart: 0,
+      tokenEnd: 0,
+      charStart,
+      charEnd: sourceText.length
+    });
+  }
+  const tokens = [];
+  const tokenRe = /\S+/g;
+  let blockIndex = 0;
+  let match;
+  while ((match = tokenRe.exec(sourceText)) !== null) {
+    const charOffset = match.index;
+    const charEnd = charOffset + match[0].length;
+    while (blockIndex < blocks.length - 1 && charOffset >= blocks[blockIndex].charEnd) {
+      blockIndex++;
+    }
+    const spoken = hasSpokenContent(match[0]);
+    tokens.push({
+      text: match[0],
+      charOffset,
+      charEnd,
+      blockId: blocks[blockIndex]?.blockId ?? "",
+      blockIndex,
+      syllables: spoken ? estimateSyllables(match[0]) : 0,
+      spokenWordEquiv: spoken ? estimateSpokenWordCount(stripBoundaryPunct(match[0])) : 0,
+      pauseAfter: 0,
+      spoken
+    });
+  }
+  for (const range of blocks) {
+    range.tokenStart = tokens.length;
+    range.tokenEnd = 0;
+  }
+  for (let i = 0; i < tokens.length; i++) {
+    const range = blocks[tokens[i].blockIndex];
+    if (range) {
+      if (i < range.tokenStart) range.tokenStart = i;
+      range.tokenEnd = i + 1;
+    }
+  }
+  for (const range of blocks) {
+    if (range.tokenStart > range.tokenEnd) {
+      range.tokenStart = range.tokenEnd;
+    }
+  }
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    if (!next || next.blockIndex !== token.blockIndex) {
+      token.pauseAfter = 3;
+    } else if (sourceText.slice(token.charEnd, next.charOffset).includes("\n")) {
+      token.pauseAfter = 2;
+    } else if (endsWithClausePunctuation(token.text)) {
+      token.pauseAfter = 1;
+    }
+  }
+  const cumulativeSyllables = new Array(tokens.length + 1);
+  cumulativeSyllables[0] = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    cumulativeSyllables[i + 1] = cumulativeSyllables[i] + tokens[i].syllables;
+  }
+  return {
+    sourceText,
+    tokens,
+    blocks,
+    totalSyllables: cumulativeSyllables[tokens.length],
+    cumulativeSyllables
+  };
+}
+var TRAILING_CLOSERS = /["')\]}»”’]+$/;
+function hasSpokenContent(token) {
+  return /[\p{L}\p{N}]/u.test(token);
+}
+function stripBoundaryPunct(token) {
+  return token.replace(/^[.,!?;:'"()[\]{}]+|[.,!?;:'"()[\]{}]+$/g, "");
+}
+function endsWithClausePunctuation(token) {
+  const bare = token.replace(TRAILING_CLOSERS, "");
+  const last = bare.charAt(bare.length - 1);
+  if (!last) return false;
+  if (last === ",") {
+    return true;
+  }
+  return last === "." || last === ";" || last === ":" || last === "!" || last === "?";
+}
+function clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
+function expectedSyllablesAt(script, wordPos) {
+  const n = script.tokens.length;
+  if (n === 0) return 0;
+  const pos = clamp(wordPos, 0, n);
+  const idx = Math.floor(pos);
+  if (idx >= n) return script.totalSyllables;
+  return script.cumulativeSyllables[idx] + (pos - idx) * script.tokens[idx].syllables;
+}
+function wordPosAtExpectedSyllables(script, syllables) {
+  const n = script.tokens.length;
+  if (n === 0) return 0;
+  const target = clamp(syllables, 0, script.totalSyllables);
+  let lo = 0;
+  let hi = n;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (script.cumulativeSyllables[mid] <= target) lo = mid;
+    else hi = mid - 1;
+  }
+  if (lo >= n) return n;
+  const within = target - script.cumulativeSyllables[lo];
+  const sylls = script.tokens[lo].syllables;
+  return lo + (sylls > 0 ? within / sylls : 0);
+}
+function wordIndexAtChar(script, charOffset) {
+  const tokens = script.tokens;
+  if (tokens.length === 0) return 0;
+  let lo = 0;
+  let hi = tokens.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (tokens[mid].charEnd <= charOffset) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function wordIndexAtTime(words, tSec) {
+  if (words.length === 0) return 0;
+  let lo = 0;
+  let hi = words.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (words[mid].tSec <= tSec) lo = mid;
+    else hi = mid - 1;
+  }
+  return words[lo].tSec <= tSec ? lo : 0;
+}
+
+// src/narration/sidecar.ts
+function buildNarrationTimingJson(script, alignment, durationSec, options) {
+  const bookmarks = alignment.words.map((word) => {
+    const token = script.tokens[word.tokenIndex];
+    return {
+      id: `word-${word.tokenIndex}`,
+      time: word.tSec,
+      charOffset: token?.charOffset ?? 0,
+      textFragment: token?.text ?? ""
+    };
+  });
+  const blocks = alignment.blocks.map((range) => ({
+    ...range.blockId ? { blockId: range.blockId } : {},
+    ...range.heading !== void 0 ? { heading: range.heading } : {},
+    blockIndex: range.blockIndex,
+    charStart: range.charStart,
+    charEnd: range.charEnd,
+    startSec: range.startSec,
+    endSec: range.endSec
+  }));
+  return {
+    version: 3,
+    sourceText: script.sourceText,
+    duration: Number.isFinite(durationSec) && durationSec >= 0 ? durationSec : 0,
+    bookmarks,
+    blocks,
+    // Write only what `parseNarrationTimingJson` will read back, so the codec
+    // is a round-trip pair. A non-finite value would serialize to `null`
+    // (JSON has no NaN) and be dropped on parse anyway — omitting it here
+    // keeps the emitted sidecar honest rather than carrying a dead field.
+    ...finiteNumber(options?.cameraOffsetSec) ? { cameraOffsetSec: options.cameraOffsetSec } : {},
+    generator: {
+      name: "squisq-teleprompter",
+      method: "dsp-align",
+      ...options?.baseWpm !== void 0 ? { baseWpm: options.baseWpm } : {}
+    }
+  };
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parseNarrationTimingJson(data) {
+  try {
+    const text = typeof data === "string" ? data : new TextDecoder().decode(data instanceof Uint8Array ? data : new Uint8Array(data));
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const raw = parsed;
+    if (typeof raw.sourceText !== "string" || !finiteNonNegative(raw.duration)) return null;
+    const bookmarks = Array.isArray(raw.bookmarks) ? raw.bookmarks.flatMap((b) => {
+      if (typeof b !== "object" || b === null) return [];
+      const bookmark = b;
+      if (!finiteNonNegative(bookmark.time) || !finiteNonNegative(bookmark.charOffset)) {
+        return [];
+      }
+      return [
+        {
+          id: typeof bookmark.id === "string" ? bookmark.id : `bookmark-${bookmark.charOffset}`,
+          time: bookmark.time,
+          charOffset: bookmark.charOffset,
+          ...typeof bookmark.textFragment === "string" ? { textFragment: bookmark.textFragment } : {}
+        }
+      ];
+    }) : [];
+    let blocks = Array.isArray(raw.blocks) ? raw.blocks.flatMap((b) => {
+      if (typeof b !== "object" || b === null) return [];
+      const block = b;
+      if (!finiteNonNegative(block.startSec) || !finiteNonNegative(block.endSec) || !finiteNonNegative(block.charStart) || !finiteNonNegative(block.charEnd)) {
+        return [];
+      }
+      return [
+        {
+          ...typeof block.blockId === "string" ? { blockId: block.blockId } : {},
+          ...typeof block.heading === "string" ? { heading: block.heading } : {},
+          blockIndex: finiteNonNegative(block.blockIndex) ? block.blockIndex : 0,
+          charStart: block.charStart,
+          charEnd: block.charEnd,
+          startSec: block.startSec,
+          endSec: Math.max(block.startSec, block.endSec)
+        }
+      ];
+    }) : [];
+    blocks = blocks.sort((a, b) => a.startSec - b.startSec);
+    let cursor = 0;
+    for (const block of blocks) {
+      if (block.startSec < cursor) block.startSec = cursor;
+      if (block.endSec < block.startSec) block.endSec = block.startSec;
+      cursor = block.startSec;
+    }
+    return {
+      version: 3,
+      sourceText: raw.sourceText,
+      duration: raw.duration,
+      bookmarks,
+      blocks,
+      ...finiteNumber(raw.cameraOffsetSec) ? { cameraOffsetSec: raw.cameraOffsetSec } : {},
+      ...typeof raw.generator === "object" && raw.generator !== null ? { generator: raw.generator } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  estimateSyllables,
+  buildNarrationScript,
+  expectedSyllablesAt,
+  wordPosAtExpectedSyllables,
+  wordIndexAtChar,
+  wordIndexAtTime,
+  buildNarrationTimingJson,
+  parseNarrationTimingJson
+};

package/dist/{chunk-XV4SF2N5.js → chunk-BUJ5RV2P.js}

@@ -15,7 +15,7 @@ import {
   relativeLuminance,
   resolveFontFamily,
   withAlpha
-} from "./chunk-RXYKU6EX.js";
+} from "./chunk-Y4D6TDZT.js";
 
 // src/schemas/Doc.ts
 function calculateDuration(audio) {

package/dist/{chunk-67L6WRJN.js → chunk-GHOPHGOK.js}

@@ -118,11 +118,38 @@ function estimateNarrationDuration(text, wordsPerSecond = DEFAULT_WORDS_PER_SECO
   return spokenWords / wordsPerSecond;
 }
 
+// src/timing/readingTime.ts
+var DEFAULT_READING_WPM = 200;
+function estimateReadingTime(text, options) {
+  const configuredWpm = options?.wordsPerMinute;
+  const wpm = typeof configuredWpm === "number" && configuredWpm > 0 ? configuredWpm : DEFAULT_READING_WPM;
+  const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+  const minutes = words / wpm;
+  return {
+    words,
+    minutes,
+    seconds: Math.round(minutes * 60)
+  };
+}
+function estimateNarrationTime(text, options) {
+  const providedWps = options?.wordsPerSecond;
+  const wps = typeof providedWps === "number" && providedWps > 0 ? providedWps : DEFAULT_WORDS_PER_SECOND;
+  const spokenWords = countSpokenWords(text);
+  const totalSeconds = spokenWords / wps;
+  return {
+    spokenWords,
+    minutes: totalSeconds / 60,
+    seconds: Math.round(totalSeconds)
+  };
+}
+
 export {
   DEFAULT_WORDS_PER_SECOND,
   estimateSpokenWordCount,
   countSpokenWords,
   estimateTimeFromText,
   calculatePrefixDuration,
-  estimateNarrationDuration
+  estimateNarrationDuration,
+  estimateReadingTime,
+  estimateNarrationTime
 };

package/dist/{chunk-NUS5YAI5.js → chunk-GRGLZF4A.js}

@@ -1,7 +1,10 @@
+import {
+  buildNarrationScript,
+  parseNarrationTimingJson
+} from "./chunk-764WHWKM.js";
 import {
   SHAPE_NAMES,
   buildChartData,
-  buildNarrationScript,
   buildRegistry,
   coerceTemplateParams,
   deriveTemplateInputs,
@@ -22,7 +25,6 @@ import {
   nearestName,
   normalizeShapeKind,
   parseDataFence,
-  parseNarrationTimingJson,
   parseStandaloneAnnotation,
   placeLayersInRect,
   readCustomThemesFromFrontmatter,
@@ -30,7 +32,7 @@ import {
   templateRegistry,
   writeCustomTemplatesToFrontmatter,
   writeCustomThemesToFrontmatter
-} from "./chunk-AIB5WEK2.js";
+} from "./chunk-WAGJK36Q.js";
 import {
   iconMarker
 } from "./chunk-7ZAAICW4.js";
@@ -59,21 +61,19 @@ import {
   DEFAULT_THEME,
   FRONTMATTER_CUSTOM_TEMPLATES_KEY,
   FRONTMATTER_CUSTOM_THEMES_KEY,
+  VIEWPORT_PRESETS,
+  calculateFontScale,
+  createTemplateContext,
+  getViewportOrientation,
   hexHueDegrees,
+  isTemplateBlock,
   oklchDarken,
   oklchLighten,
   relativeLuminance,
   resolveFontFamily,
   resolveTheme,
   withAlpha
-} from "./chunk-RXYKU6EX.js";
-import {
-  VIEWPORT_PRESETS,
-  calculateFontScale,
-  createTemplateContext,
-  getViewportOrientation,
-  isTemplateBlock
-} from "./chunk-BAOV476U.js";
+} from "./chunk-Y4D6TDZT.js";
 import {
   parseMarkdown
 } from "./chunk-CW24CH7I.js";
@@ -94,7 +94,7 @@ import {
 } from "./chunk-X7BNDUNI.js";
 import {
   estimateTimeFromText
-} from "./chunk-67L6WRJN.js";
+} from "./chunk-GHOPHGOK.js";
 
 // src/doc/utils/animationUtils.ts
 function getAnimationStyle(animation, _currentTime = 0) {
@@ -4216,6 +4216,7 @@ function autoMatchBlocks(blocks, audioFiles) {
 async function resolveAudioMapping(doc, container) {
   const narration = await applyNarrationTiming(doc, container);
   doc = narration.doc;
+  if (doc.audio?.segments?.length > 0) return doc;
   const audioFiles = await discoverNarrationAudio(container);
   const scheduledSrcs = new Set(resolveMediaSchedule(doc).map((clip) => clip.src));
   const available = audioFiles.filter((f) => !scheduledSrcs.has(f.path));