@bendyline/squisq 2.13.4 → 2.13.6

package/dist/{Doc-DnRFE0EI.d.ts → Doc-BQUVDooL.d.ts}

@@ -2348,6 +2348,15 @@ interface StartBlockConfig {
      * (so a square crop, such as a social link card, shows all of it).
      */
     coverStyle?: 'scrim' | 'frosted';
+    /**
+     * Where a frosted cover puts its subtitle. `'stacked'` (default): under the title, on the
+     * title's plate. `'split'`: the title on a plate near the top of the frame and the
+     * subtitle, set as a display deck, on a plate of its own near the bottom — a vertical
+     * cover's name and its hook. Both plates stay inside the middle 3:4 that feeds crop a
+     * 9:16 frame to, with even room above the title and below the subtitle. A split that would crowd the frame (two plates closer than half
+     * the title's size) stacks instead. No effect without a subtitle or with the scrim style.
+     */
+    coverLayout?: 'stacked' | 'split';
 }
 /**
  * A structural problem detected while converting or validating a document.

package/dist/{ImageEditDoc-CadNz387.d.ts → ImageEditDoc-glA5UUau.d.ts}

@@ -1,4 +1,4 @@
-import { a3 as ImageLayer, by as TextLayer, bj as ShapeLayer, aZ as PathLayer } from './Doc-DnRFE0EI.js';
+import { a3 as ImageLayer, by as TextLayer, bj as ShapeLayer, aZ as PathLayer } from './Doc-BQUVDooL.js';
 
 /**
  * ImageEditDoc — JSON document describing a layered, editable image.

package/dist/{chunk-DRHJD6U4.js → chunk-4O26IMVA.js}

@@ -4,15 +4,21 @@ import {
   flattenRenderableBlocks,
   getPinnedBlockMeta,
   markdownToDoc
-} from "./chunk-J2NFT7GH.js";
+} from "./chunk-VQXOX3YN.js";
 import {
   deriveTemplateInputs,
+  extractEmbeddedVideos,
   extractImages,
   isAsciiDiagramFence,
   isAsciiTimelineFence,
+  isExplicitDiagramLang,
+  isExplicitTimelineLang,
+  isExplicitTreeLang,
   isPictureFence,
+  isPictureParagraph,
+  isStandaloneHtmlVideo,
   isTreeFence
-} from "./chunk-POZCKPCO.js";
+} from "./chunk-CSR6VCSJ.js";
 import {
   extractContent,
   mapElementToBlock,
@@ -20,19 +26,22 @@ import {
 } from "./chunk-SVN7T6BK.js";
 import {
   cloneAndFreezeData,
+  cloneData,
   isTemplateBlock
 } from "./chunk-WNEH3BZP.js";
 import {
   parseMarkdown
-} from "./chunk-D3JQMZUT.js";
+} from "./chunk-CPD3MFX7.js";
 import {
   isContainerTemplate
 } from "./chunk-DOOUVVOM.js";
 import {
   extractPlainText,
+  findBlockVideoEmbed,
   getChildren,
+  parseTimeSeconds,
   stringifyHtmlNodes
-} from "./chunk-6NWVLLMI.js";
+} from "./chunk-KVEOD57Z.js";
 import {
   parseBuildSpec
 } from "./chunk-P53Z4RYC.js";
@@ -57,7 +66,8 @@ var PRESENTATION_LAYOUTS = [
 var PRESENTATION_LIMITS = {
   sourceCharacters: 4e4,
   beats: 80,
-  serializedCharacters: 16e4
+  serializedCharacters: 16e4,
+  mediaPerBeat: 4
 };
 function record(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -90,13 +100,15 @@ function parsePresentationPlan(input) {
     if (!record(beat) || !keys(
       beat,
       ["id", "sourceStart", "sourceEnd", "layout", "headline", "points"],
-      ["imageSrc"]
+      ["imageSrc", "media"]
     ) || !text(beat.id, 80) || ids.has(beat.id) || !Number.isInteger(beat.sourceStart) || !Number.isInteger(beat.sourceEnd) || typeof beat.sourceStart !== "number" || typeof beat.sourceEnd !== "number" || beat.sourceStart < end || beat.sourceEnd <= beat.sourceStart || beat.sourceEnd > value.sourceText.length || value.sourceText.slice(end, beat.sourceStart).trim() || !PRESENTATION_LAYOUTS.includes(beat.layout) || !text(beat.headline, 110) || !Array.isArray(beat.points) || beat.points.length > 4 || !beat.points.every((point) => text(point, 180)))
       return null;
     if (["comparison", "steps", "list"].includes(String(beat.layout)) && beat.points.length < 2)
       return null;
     if (beat.layout === "comparison" && beat.points.length !== 2) return null;
     if (beat.layout === "image" ? !text(beat.imageSrc, 2048) : "imageSrc" in beat) return null;
+    if ("media" in beat && (!Array.isArray(beat.media) || !beat.media.length || beat.media.length > PRESENTATION_LIMITS.mediaPerBeat || new Set(beat.media).size !== beat.media.length || !beat.media.every((ref) => text(ref, 1100))))
+      return null;
     ids.add(beat.id);
     end = beat.sourceEnd;
     beats.push({
@@ -106,7 +118,8 @@ function parsePresentationPlan(input) {
       layout: beat.layout,
       headline: beat.headline,
       points: [...beat.points],
-      ...beat.layout === "image" ? { imageSrc: beat.imageSrc } : {}
+      ...beat.layout === "image" ? { imageSrc: beat.imageSrc } : {},
+      ..."media" in beat ? { media: [...beat.media] } : {}
     });
   }
   if (value.sourceText.slice(end).trim()) return null;
@@ -1638,6 +1651,55 @@ function videoBlock(video, index, segmentId, duration) {
   };
 }
 
+// src/transform/presentationMedia.ts
+function mediaKind(node) {
+  if (node.type === "code")
+    return isPictureFence(node) || isExplicitDiagramLang(node.lang) || isExplicitTreeLang(node.lang) || isExplicitTimelineLang(node.lang) ? { kind: "diagram", continuous: true } : null;
+  if (isStandaloneHtmlVideo(node)) return { kind: "video", continuous: true };
+  if (findBlockVideoEmbed(node) || isPictureParagraph(node) && extractEmbeddedVideos([node]).length > 0)
+    return { kind: "video", continuous: false };
+  return null;
+}
+function collectPresentationMedia(doc, sectionIds) {
+  const sections = new Set(sectionIds);
+  const result = /* @__PURE__ */ new Map();
+  let owner = sectionIds[0];
+  for (const block of flattenRenderableBlocks(doc.blocks)) {
+    if (sections.has(block.id)) owner = block.id;
+    if (!owner) continue;
+    for (const node of block.contents ?? []) {
+      const kind = mediaKind(node);
+      if (!kind) continue;
+      const items = result.get(owner) ?? [];
+      items.push({ ...kind, ref: `${owner}#${items.length}`, node });
+      result.set(owner, items);
+    }
+  }
+  return result;
+}
+function videoElements(node, found = []) {
+  if (!node || typeof node !== "object") return found;
+  const value = node;
+  if (value.type === "htmlElement" && value.tagName === "video") found.push(value);
+  for (const key of ["children", "htmlChildren"])
+    if (Array.isArray(value[key])) for (const child of value[key]) videoElements(child, found);
+  return found;
+}
+function presentationMediaNode(item, elapsed) {
+  const node = cloneData(item.node);
+  if (item.kind !== "video" || elapsed <= 0) return node;
+  for (const element of videoElements(node)) {
+    const attributes = element.attributes ?? {};
+    const seconds = (name) => attributes[name] ? parseTimeSeconds(attributes[name]) : null;
+    const from = (seconds("data-squisq-video-clip-start") ?? 0) + Math.max(0, elapsed - (seconds("data-squisq-video-start-at") ?? 0));
+    const until = seconds("data-squisq-video-clip-end");
+    if (until !== null && from >= until) return null;
+    delete attributes["data-squisq-video-start-at"];
+    element.attributes = { ...attributes, "data-squisq-video-clip-start": String(from) };
+  }
+  return node;
+}
+
 // src/transform/presentationPlanner.ts
 var SENTENCE_END = /[.!?][”"')\]]?$/u;
 var SENTENCE_START = /^[\p{Lu}\p{N}"“‘'([]/u;
@@ -1847,6 +1909,27 @@ function createPresentationPlan(doc, hints = defaultPresentationHints()) {
     throw new Error(
       "This document has too many sections for one presentation. Split it into shorter documents."
     );
+  const sectionMedia = collectPresentationMedia(
+    doc,
+    script.blocks.map((block) => block.blockId)
+  );
+  for (const block of script.blocks) {
+    const items = sectionMedia.get(block.blockId);
+    if (!items?.length) continue;
+    const own = beats.filter(
+      (beat) => beat.sourceStart >= block.charStart && beat.sourceStart < block.charEnd
+    );
+    const open = own.filter((beat) => beat !== beats[0] && beat.layout !== "image");
+    const slots = open.length ? open : own;
+    const shown = /* @__PURE__ */ new Set();
+    slots.forEach((beat, slot) => {
+      const from = Math.floor(slot * items.length / slots.length);
+      const to = Math.max(from + 1, Math.floor((slot + 1) * items.length / slots.length));
+      const refs = items.slice(from, to).filter((item) => item.continuous || !shown.has(item.ref)).slice(0, PRESENTATION_LIMITS.mediaPerBeat).map((item) => item.ref);
+      for (const ref of refs) shown.add(ref);
+      if (refs.length) beat.media = refs;
+    });
+  }
   const closing = beats[beats.length - 1];
   if (beats.length > 2 && closing?.layout === "statement" && !hints.blocks.some(
     (hint) => hint.layout && script.blocks.some(
@@ -1875,6 +1958,7 @@ function createPresentationPlan(doc, hints = defaultPresentationHints()) {
       beat.headline = hint.wording.headline ?? beat.headline;
       beat.points = hint.wording.points ?? beat.points;
     }
+    if (beat.media && beat.layout === "steps" && hint?.layout !== "steps") beat.layout = "list";
     if (["steps", "list", "comparison"].includes(beat.layout) && (beat.points.length < 2 || beat.layout === "comparison" && beat.points.length !== 2))
       beat.layout = "statement";
     if (beat.layout !== "image") delete beat.imageSrc;
@@ -1913,6 +1997,18 @@ function compilePresentationPlan(doc, plan) {
     throw new Error(
       "A presentation image is no longer in the document. Make the presentation again."
     );
+  const media = new Map(
+    [
+      ...collectPresentationMedia(
+        doc,
+        script.blocks.map((block) => block.blockId)
+      ).values()
+    ].flat().map((item) => [item.ref, item])
+  );
+  if (checked.beats.some((beat) => beat.media?.some((ref) => !media.has(ref))))
+    throw new Error(
+      "A presentation video or diagram is no longer in the document. Make the presentation again."
+    );
   const duration = narration ? narration.startTime + narration.duration : Math.max(4, script.tokens.length / 2.5);
   const bookmarks = (narration?.bookmarks ?? []).filter(
     (word) => Number.isFinite(word.time) && word.time >= 0 && word.time <= duration && Number.isInteger(word.charOffset) && word.charOffset >= 0 && word.charOffset < script.sourceText.length
@@ -1932,17 +2028,53 @@ function compilePresentationPlan(doc, plan) {
   });
   const authoredBlocks = flattenRenderableBlocks(doc.blocks);
   const buildHints = parsePresentationHints(doc.frontmatter?.[PRESENTATION_HINTS_KEY]);
+  const sourceOf = (beat) => script.blocks.find(
+    (block) => beat.sourceStart >= block.charStart && beat.sourceStart < block.charEnd
+  );
+  const sectionEnds = /* @__PURE__ */ new Map();
+  checked.beats.forEach((beat, index) => {
+    const section = sourceOf(beat)?.blockId;
+    if (section) sectionEnds.set(section, starts[index + 1] ?? duration);
+  });
+  const clipsPlaced = /* @__PURE__ */ new Set();
+  const mediaStarts = /* @__PURE__ */ new Map();
   const blocks = [];
   checked.beats.forEach((beat, index) => {
     const start = starts[index];
     const end = starts[index + 1] ?? duration;
     if (end <= start) return;
-    const source = script.blocks.find(
-      (block2) => beat.sourceStart >= block2.charStart && beat.sourceStart < block2.charEnd
-    );
+    const source = sourceOf(beat);
     const build = buildHints?.blocks.find((hint) => hint.blockId === source?.blockId)?.build ?? authoredBlocks.find((block2) => block2.id === source?.blockId)?.build;
+    const contents = (beat.media ?? []).flatMap((ref) => {
+      const first = mediaStarts.get(ref) ?? start;
+      mediaStarts.set(ref, first);
+      const node = presentationMediaNode(media.get(ref), start - first);
+      return node ? [node] : [];
+    });
+    let clips = [];
+    if (source && !clipsPlaced.has(source.blockId)) {
+      clipsPlaced.add(source.blockId);
+      const sectionEnd = sectionEnds.get(source.blockId) ?? end;
+      clips = (authoredBlocks.find((block2) => block2.id === source.blockId)?.media ?? []).flatMap(
+        (clip2) => {
+          if (clip2.spillover) return [clip2];
+          const room = sectionEnd - start - clip2.startAt;
+          if (room <= 0) return [];
+          const clipStart = clip2.clipStart ?? 0;
+          return [
+            {
+              ...clip2,
+              spillover: true,
+              clipEnd: Math.min(clip2.clipEnd ?? Infinity, clipStart + room)
+            }
+          ];
+        }
+      );
+    }
     const base = {
       ...build ? { build } : {},
+      ...contents.length ? { contents } : {},
+      ...clips.length ? { media: clips } : {},
       id: beat.id,
       duration: end - start,
       startTime: start,
@@ -1980,7 +2112,14 @@ function visualBlock(beat, base, index) {
         explanation: beat.points.join("\n\n")
       };
     case "list":
-      return { ...base, template: "list", title: beat.headline, items: beat.points, colorScheme };
+      return {
+        ...base,
+        template: "list",
+        title: beat.headline,
+        items: beat.points,
+        ordered: false,
+        colorScheme
+      };
     case "comparison":
       return {
         ...base,
@@ -2069,6 +2208,7 @@ export {
   allocateTiming,
   applyTransform,
   transformNarratedSegment,
+  collectPresentationMedia,
   createPresentationPlan,
   compilePresentationPlan,
   applySavedPresentation

package/dist/{chunk-FIPRGGXD.js → chunk-B2MOGSWY.js}

@@ -5,10 +5,11 @@ import {
 } from "./chunk-NEWNNLWN.js";
 import {
   buildNarrationScript,
+  estimateSyllables,
   expectedSyllablesAt,
   flattenRenderableBlocks,
   wordPosAtExpectedSyllables
-} from "./chunk-J2NFT7GH.js";
+} from "./chunk-VQXOX3YN.js";
 
 // src/narration/types.ts
 var DEFAULT_FEATURE_CONFIG = Object.freeze({
@@ -839,6 +840,333 @@ function proportionalAlignment(script, effectiveDuration, takeDuration, c, detec
   return { words, blocks, detectedSyllables, cost: 0 };
 }
 
+// src/narration/transcriptAlign.ts
+var MAX_DP_CELLS = 1e6;
+var ANCHOR_GRAM = 3;
+var EXACT_SCORE = 2;
+var NEAR_SCORE = 1;
+var MISMATCH_SCORE = -1;
+var GAP_SCORE = -1;
+var NEAR_SIMILARITY = 0.75;
+var ISOLATED_MATCH_MAX_LENGTH = 3;
+var NON_SPEECH = /^\s*[[(].*[\])]\s*$/u;
+function transcriptWordKeys(text) {
+  return text.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase().replace(/['’]/gu, "").split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function clampTime(value, durationSec) {
+  return Number.isFinite(value) ? Math.min(Math.max(0, value), durationSec) : 0;
+}
+function heardFromSegments(segments, durationSec) {
+  const heard = [];
+  const units = [];
+  const add = (text, startSec, endSec) => {
+    if (NON_SPEECH.test(text)) return;
+    const keys = transcriptWordKeys(text);
+    if (!keys.length) return;
+    for (const key of keys) units.push({ key, index: heard.length });
+    heard.push({ startSec, endSec: Math.max(startSec, endSec) });
+  };
+  const ordered = [...segments].sort((a, b) => a.startSec - b.startSec);
+  for (const segment of ordered) {
+    const start = clampTime(segment.startSec, durationSec);
+    const end = Math.max(start, clampTime(segment.endSec, durationSec));
+    if (segment.words?.length) {
+      for (const word of segment.words) {
+        const wordStart = clampTime(word.startSec, durationSec);
+        add(word.text, wordStart, clampTime(word.endSec, durationSec));
+      }
+      continue;
+    }
+    const pieces = segment.text.split(/\s+/u).filter((piece) => piece && !NON_SPEECH.test(piece));
+    const weights = pieces.map((piece) => estimateSyllables(piece));
+    const total = weights.reduce((sum, weight) => sum + weight, 0) || 1;
+    let before = 0;
+    pieces.forEach((piece, i) => {
+      const from = start + before / total * (end - start);
+      before += weights[i];
+      add(piece, from, start + before / total * (end - start));
+    });
+  }
+  let running = 0;
+  for (const word of heard) {
+    word.startSec = Math.max(running, word.startSec);
+    word.endSec = Math.max(word.startSec, word.endSec);
+    running = word.startSec;
+  }
+  return { heard, units };
+}
+function scriptUnits(script) {
+  const units = [];
+  script.tokens.forEach((token, index) => {
+    if (!token.spoken) return;
+    for (const key of transcriptWordKeys(token.text)) units.push({ key, index });
+  });
+  return units;
+}
+function uniqueGrams(units) {
+  const grams = /* @__PURE__ */ new Map();
+  for (let i = 0; i + ANCHOR_GRAM <= units.length; i++) {
+    const gram = units.slice(i, i + ANCHOR_GRAM).map((unit) => unit.key).join(" ");
+    grams.set(gram, grams.has(gram) ? -1 : i);
+  }
+  return grams;
+}
+function anchorChain(script, heard) {
+  const heardGrams = uniqueGrams(heard);
+  const pairs = [];
+  for (const [gram, s] of uniqueGrams(script)) {
+    const t = heardGrams.get(gram);
+    if (s >= 0 && t !== void 0 && t >= 0) pairs.push([s, t]);
+  }
+  pairs.sort((a, b) => a[0] - b[0]);
+  const tails = [];
+  const previous = new Int32Array(pairs.length).fill(-1);
+  for (let i = 0; i < pairs.length; i++) {
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (pairs[tails[mid]][1] < pairs[i][1]) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo > 0) previous[i] = tails[lo - 1];
+    tails[lo] = i;
+  }
+  const chain = [];
+  for (let i = tails.length ? tails[tails.length - 1] : -1; i >= 0; i = previous[i]) {
+    chain.push(pairs[i]);
+  }
+  return chain.reverse();
+}
+function editDistance(a, b) {
+  let row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const next = [i];
+    for (let j = 1; j <= b.length; j++) {
+      next[j] = Math.min(
+        row[j] + 1,
+        next[j - 1] + 1,
+        row[j - 1] + (a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1)
+      );
+    }
+    row = next;
+  }
+  return row[b.length];
+}
+function createScorer() {
+  const near = /* @__PURE__ */ new Map();
+  return (a, b) => {
+    if (a === b) return EXACT_SCORE;
+    if (a.length < 4 || b.length < 4 || a[0] !== b[0] || Math.abs(a.length - b.length) > 3)
+      return MISMATCH_SCORE;
+    const key = a < b ? `${a} ${b}` : `${b} ${a}`;
+    let similar = near.get(key);
+    if (similar === void 0) {
+      similar = 1 - editDistance(a, b) / Math.max(a.length, b.length) >= NEAR_SIMILARITY;
+      near.set(key, similar);
+    }
+    return similar ? NEAR_SCORE : MISMATCH_SCORE;
+  };
+}
+function alignStretch(script, sFrom, sTo, heard, tFrom, tTo, score) {
+  const rows = sTo - sFrom;
+  const cols = tTo - tFrom;
+  if (rows <= 0 || cols <= 0 || rows * cols > MAX_DP_CELLS) return [];
+  const width = cols + 1;
+  const moves = new Uint8Array((rows + 1) * width);
+  let prev = new Float64Array(width);
+  for (let j2 = 1; j2 <= cols; j2++) {
+    prev[j2] = j2 * GAP_SCORE;
+    moves[j2] = 2;
+  }
+  for (let i2 = 1; i2 <= rows; i2++) {
+    const row = new Float64Array(width);
+    row[0] = i2 * GAP_SCORE;
+    moves[i2 * width] = 1;
+    const key = script[sFrom + i2 - 1].key;
+    for (let j2 = 1; j2 <= cols; j2++) {
+      const diagonal = prev[j2 - 1] + score(key, heard[tFrom + j2 - 1].key);
+      const up = prev[j2] + GAP_SCORE;
+      const left = row[j2 - 1] + GAP_SCORE;
+      if (diagonal >= up && diagonal >= left) {
+        row[j2] = diagonal;
+        moves[i2 * width + j2] = 0;
+      } else if (up >= left) {
+        row[j2] = up;
+        moves[i2 * width + j2] = 1;
+      } else {
+        row[j2] = left;
+        moves[i2 * width + j2] = 2;
+      }
+    }
+    prev = row;
+  }
+  const pairs = [];
+  let i = rows;
+  let j = cols;
+  while (i > 0 || j > 0) {
+    const move = moves[i * width + j];
+    if (move === 0) {
+      const s = sFrom + i - 1;
+      const t = tFrom + j - 1;
+      if (score(script[s].key, heard[t].key) > 0) pairs.push([s, t]);
+      i--;
+      j--;
+    } else if (move === 1) i--;
+    else j--;
+  }
+  return pairs.reverse();
+}
+function matchUnits(script, heard) {
+  const anchored = [];
+  let lastS = -1;
+  let lastT = -1;
+  for (const [s, t] of anchorChain(script, heard)) {
+    for (let k = 0; k < ANCHOR_GRAM; k++) {
+      if (s + k > lastS && t + k > lastT) {
+        anchored.push([s + k, t + k]);
+        lastS = s + k;
+        lastT = t + k;
+      }
+    }
+  }
+  const score = createScorer();
+  const pairs = [];
+  let from = [-1, -1];
+  for (const to of [...anchored, [script.length, heard.length]]) {
+    pairs.push(...alignStretch(script, from[0] + 1, to[0], heard, from[1] + 1, to[1], score));
+    if (to[0] < script.length) pairs.push(to);
+    from = to;
+  }
+  return pairs.filter(([s, t], i) => {
+    if (script[s].key.length > ISOLATED_MATCH_MAX_LENGTH) return true;
+    const before = pairs[i - 1];
+    const after = pairs[i + 1];
+    return before !== void 0 && before[0] === s - 1 && before[1] === t - 1 || after !== void 0 && after[0] === s + 1 && after[1] === t + 1;
+  });
+}
+function placeWords(script, matched, heard, speechEnd, durationSec, gapMinSec) {
+  const n = script.tokens.length;
+  const cumulative = script.cumulativeSyllables;
+  if (!heard.length) {
+    const total = Math.max(1, script.totalSyllables);
+    return script.tokens.map((_, k) => ({
+      tokenIndex: k,
+      tSec: cumulative[k] / total * durationSec,
+      interpolated: true
+    }));
+  }
+  const startOf = (h) => h < heard.length ? heard[h].startSec : speechEnd;
+  const words = new Array(n);
+  let leftToken = -1;
+  let leftHeard = -1;
+  const fill = (rightToken, rightHeard) => {
+    const from = leftToken + 1;
+    const between = rightHeard - leftHeard - 1;
+    const leftBlock = leftToken >= 0 ? script.tokens[leftToken].blockIndex : -1;
+    let leftCount = 0;
+    let rightCount = 0;
+    for (let u = from; u < rightToken; u++) {
+      if (!script.tokens[u].spoken) continue;
+      if (script.tokens[u].blockIndex === leftBlock) leftCount++;
+      else rightCount++;
+    }
+    if (between > 0 && between >= leftCount + rightCount) {
+      let rightFloor = rightHeard - rightCount;
+      for (let h = rightHeard; h > rightFloor && h > 0; h--) {
+        if (startOf(h) - heard[h - 1].endSec >= gapMinSec) {
+          rightFloor = h;
+          break;
+        }
+      }
+      let leftRank = 0;
+      let rightRank = 0;
+      for (let u = from; u < rightToken; u++) {
+        const token = script.tokens[u];
+        const left = token.blockIndex === leftBlock;
+        const position = left ? leftHeard + 1 + leftRank : Math.max(rightFloor, rightHeard - rightCount + rightRank);
+        words[u] = { tokenIndex: u, tSec: startOf(position), interpolated: true };
+        if (token.spoken && left) leftRank++;
+        else if (token.spoken) rightRank++;
+      }
+      return;
+    }
+    const base = cumulative[from] ?? 0;
+    const span = (rightToken < n ? cumulative[rightToken] : script.totalSyllables) - base;
+    for (let u = from; u < rightToken; u++) {
+      let tSec = startOf(rightHeard);
+      if (between > 0) {
+        const fraction = span > 0 ? (cumulative[u] - base) / span : (u - from) / (rightToken - from);
+        const position = leftHeard + 1 + fraction * between;
+        const index = Math.floor(position);
+        tSec = startOf(index) + (position - index) * (startOf(index + 1) - startOf(index));
+      }
+      words[u] = { tokenIndex: u, tSec, interpolated: true };
+    }
+  };
+  for (let k = 0; k < n; k++) {
+    const h = matched[k];
+    if (h === void 0) continue;
+    fill(k, h);
+    words[k] = { tokenIndex: k, tSec: heard[h].startSec, interpolated: false };
+    leftToken = k;
+    leftHeard = h;
+  }
+  fill(n, heard.length);
+  let running = 0;
+  for (const word of words) {
+    running = Math.max(running, word.tSec);
+    word.tSec = running;
+  }
+  return words;
+}
+function alignTranscript(input, config) {
+  const c = { ...DEFAULT_ALIGN_CONFIG, ...config };
+  const { script } = input;
+  const durationSec = Number.isFinite(input.durationSec) && input.durationSec > 0 ? input.durationSec : 0;
+  if (script.tokens.length > c.maxScriptTokens) {
+    throw new RangeError(`Narration script exceeds the ${c.maxScriptTokens}-token safety limit`);
+  }
+  const spokenWords = script.tokens.filter((token) => token.spoken).length;
+  const { heard, units: heardUnits } = heardFromSegments(input.segments, durationSec);
+  if (script.tokens.length === 0 || durationSec === 0) {
+    return { words: [], blocks: [], detectedSyllables: 0, cost: 0, matchedWords: 0, spokenWords };
+  }
+  const units = scriptUnits(script);
+  const matched = new Array(script.tokens.length);
+  for (const [s, t] of matchUnits(units, heardUnits)) {
+    const token = units[s].index;
+    matched[token] ?? (matched[token] = heardUnits[t].index);
+  }
+  const matchedWords = matched.filter((heardIndex) => heardIndex !== void 0).length;
+  const lastSpeechEnd = heard.reduce((end, word) => Math.max(end, word.endSec), 0);
+  const words = placeWords(
+    script,
+    matched,
+    heard,
+    lastSpeechEnd || durationSec,
+    durationSec,
+    c.gapMinSec
+  );
+  const gaps = [];
+  for (let i = 1; i < heard.length; i++) {
+    const startSec = heard[i - 1].endSec;
+    const endSec = heard[i].startSec;
+    if (endSec - startSec >= c.gapMinSec) {
+      gaps.push({ kind: "gap", tSec: (startSec + endSec) / 2, startSec, endSec });
+    }
+  }
+  const blocks = deriveBlockRanges(script, words, gaps, durationSec, lastSpeechEnd, c);
+  return {
+    words,
+    blocks,
+    detectedSyllables: heard.length,
+    cost: 0,
+    matchedWords,
+    spokenWords
+  };
+}
+
 // src/narration/advanceTiming.ts
 var EMPTY_ADVANCE_LOG = Object.freeze([]);
 function recordSlideShown(log, blockId, atMs) {
@@ -963,6 +1291,8 @@ export {
   traceWordPosAt,
   downsampleTrace,
   alignNarration,
+  transcriptWordKeys,
+  alignTranscript,
   EMPTY_ADVANCE_LOG,
   recordSlideShown,
   buildAdvanceTimingJson,

package/dist/{chunk-D3JQMZUT.js → chunk-CPD3MFX7.js}

@@ -11,7 +11,7 @@ import {
   sanitizeUrl,
   splitKeyValueToken,
   tokenizeAttrTokens
-} from "./chunk-6NWVLLMI.js";
+} from "./chunk-KVEOD57Z.js";
 import {
   resolveIcon
 } from "./chunk-CZ7AUSLI.js";

package/dist/{chunk-POZCKPCO.js → chunk-CSR6VCSJ.js}

@@ -16,7 +16,7 @@ import {
   splitKeyValueToken,
   tokenizeAttrTokens,
   walkMarkdownTree
-} from "./chunk-6NWVLLMI.js";
+} from "./chunk-KVEOD57Z.js";
 
 // src/doc/asciiDiagram/chars.ts
 function toCells(s) {
@@ -3977,6 +3977,7 @@ export {
   parseAnnotationInner,
   parseStandaloneAnnotation,
   isMediaAnnotationName,
+  isStandaloneHtmlVideo,
   extractMediaFromContents,
   toCells,
   cellWidth,