@hypit/hypit 0.0.1 → 0.1.0

package/packages/script/src/format.ts

@@ -0,0 +1,83 @@
+import { canonicalStringify } from "@hypit/protocol";
+
+import { ScriptSyntaxError } from "./error.js";
+import { narrativeValue } from "./narrative.js";
+import { parseScript } from "./parser.js";
+
+const ROLE = /^[\p{L}\p{M}\p{N}_](?:[\p{L}\p{M}\p{N}_. -]{0,30}[\p{L}\p{M}\p{N}_.-])?$/u;
+
+function compact(value: string): string {
+  return value.replace(/\s+/gu, " ").trim();
+}
+
+function formatSegment(raw: string, id: string, selfClosing: boolean): string[] {
+  if (selfClosing) return [`<${id}/>`];
+  const openEnd = raw.indexOf(">") + 1;
+  const closeStart = raw.lastIndexOf(`</${id}>`);
+  const body = raw.slice(openEnd, closeStart);
+  const lines: string[] = [`<${id}>`];
+  const turns: string[] = [];
+  let chunkStart = 0;
+  let cursor = 0;
+  while (cursor < body.length) {
+    if (body[cursor] !== "<" || body.startsWith("<!--", cursor)) {
+      cursor += 1;
+      continue;
+    }
+    const end = body.indexOf(">", cursor + 1);
+    if (end < 0) break;
+    const inside = body.slice(cursor + 1, end);
+    if (!inside.includes("|") && ROLE.test(inside)) {
+      const before = compact(body.slice(chunkStart, cursor));
+      if (before) turns.push(before);
+      chunkStart = cursor;
+    }
+    cursor = end + 1;
+  }
+  const tail = compact(body.slice(chunkStart));
+  if (tail) turns.push(tail);
+  lines.push(...turns.map((turn) => `  ${turn}`));
+  lines.push(`</${id}>`);
+  return lines;
+}
+
+function formatOutside(raw: string): string[] {
+  return raw
+    .replace(/\r\n?/gu, "\n")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+/** Formats a Script body, not the outer `<script>` element. */
+export function formatScript(sourceName: string, source: string): string {
+  const parsed = parseScript(sourceName, source);
+  const output: string[] = [];
+  let cursor = 0;
+  for (const segment of parsed.segments) {
+    const start = segment.range.start;
+    const end = segment.range.end;
+    const outside = formatOutside(source.slice(cursor, start));
+    if (outside.length) {
+      if (output.length) output.push("");
+      output.push(...outside, "");
+    } else if (output.length) {
+      output.push("");
+    }
+    output.push(...formatSegment(source.slice(start, end), segment.id, segment.selfClosing));
+    cursor = end;
+  }
+  const tail = formatOutside(source.slice(cursor));
+  if (tail.length) output.push("", ...tail);
+  while (output.at(-1) === "") output.pop();
+  const formatted = `${output.join("\n")}\n`;
+  const reparsed = parseScript(sourceName, formatted);
+  if (canonicalStringify(narrativeValue(parsed, "comparison")) !== canonicalStringify(narrativeValue(reparsed, "comparison"))) {
+    throw new ScriptSyntaxError(
+      "SCRIPT_FORMAT_SEMANTICS",
+      "Formatter refused to change Script semantics.",
+      sourceName,
+    );
+  }
+  return formatted;
+}

package/packages/script/src/index.ts

@@ -0,0 +1,20 @@
+export { ScriptSyntaxError } from "./error.js";
+export { adjustScriptMoment, adjustScriptSelection, scriptAnchorEditSites } from "./edit.js";
+export { formatScript } from "./format.js";
+export { captionDocumentType, narrativeExcerptType, narrativeMomentType, narrativeSelectionType, narrativeSchema, narrativeType, scriptManifest, scriptMarkupSurfaces, scriptModuleRef } from "./manifest.js";
+export {
+  captionDocument,
+  captionDocumentValue,
+  narrativeDialogueTextValue,
+  narrativeSegmentExcerptValue,
+  narrativeMomentValue,
+  narrativeSelectionValue,
+  narrativeSpeechTextValue,
+  narrativeValue,
+  serializeCaption,
+  serializeDialogue,
+  serializeSpeech,
+} from "./narrative.js";
+export { parseScript } from "./parser.js";
+export { decodeScriptSurface } from "./surface.js";
+export type * from "./types.js";

package/packages/script/src/lexical.ts

@@ -0,0 +1,133 @@
+export type LexicalUnit = {
+  readonly text: string;
+  readonly index: number;
+};
+
+const CHARACTER_UNIT = String.raw`[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]`;
+// A Latin name beside Han prose ends at the script boundary, even without an authored space.
+const WORD_CHARACTER = String.raw`(?:(?!${CHARACTER_UNIT})[\p{L}\p{M}\p{N}])`;
+const LEXICAL_UNIT = new RegExp([
+  String.raw`(?:\p{N}{1,3}(?:[,，]\p{N}{3})+|\p{N}+)(?:[.．]\p{N}+)?(?:-\p{N}+(?:[.．]\p{N}+)?)*(?!\p{N}|-[\p{L}\p{M}])`,
+  String.raw`${CHARACTER_UNIT}\p{M}*`,
+  String.raw`${WORD_CHARACTER}+(?:['’.-]${WORD_CHARACTER}+)*`,
+].join("|"), "gu");
+
+const OPENING_PUNCTUATION = new Set([
+  "(", "[", "{", "（", "【", "《", "「", "『", "〔", "〈", "“", "‘",
+  "$", "¥", "￥", "€", "£",
+]);
+
+const QUOTE_PUNCTUATION = new Set(["\"", "'", "`", "’", "ʼ"]);
+const UNICODE_OPENING_PUNCTUATION = /[\p{Ps}\p{Pi}]/u;
+
+/**
+ * ASCII quotation marks have no Unicode opening/closing category. In a gap between
+ * lexical units, whitespace before the mark is the useful authoring signal:
+ * `said "hello` opens a quote, while `hello" world` closes one. A quote before the
+ * first unit is opening by definition; contractions stay inside one lexical unit.
+ */
+function isOpeningPunctuation(
+  character: string,
+  gap: string,
+  position: number,
+  hasPreviousSurface: boolean,
+): boolean {
+  if (OPENING_PUNCTUATION.has(character) || UNICODE_OPENING_PUNCTUATION.test(character)) return true;
+  if (!QUOTE_PUNCTUATION.has(character)) return false;
+  if (!hasPreviousSurface) return true;
+  const before = [...gap.slice(0, position)].at(-1);
+  return before !== undefined && /\s/u.test(before);
+}
+
+export function lexicalUnits(value: string): readonly LexicalUnit[] {
+  return [...value.matchAll(LEXICAL_UNIT)].map((match) => ({
+    text: match[0],
+    index: match.index,
+  }));
+}
+
+export function lexicalCount(value: string): number {
+  return lexicalUnits(value).length;
+}
+
+/** Canonical prose spacing; punctuation remains display/speech information, never a timing token. */
+export function cleanProjection(value: string): string {
+  return value
+    .replace(/\s+/gu, " ")
+    .replace(/\s+([,.;:!?%…，。！？；：、％‰）】》」』〕〉}\]])/gu, "$1")
+    .replace(/([([{（【《「『〔〈“‘])\s+/gu, "$1")
+    // Do not erase a cross-script space: `here 你好` must remain two semantic regions.
+    // Only collapse explicit spaces inside one CJK run; the lexical tokenizer already keeps
+    // adjacent Latin and CJK runs separate when no space was authored.
+    .replace(/([\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])\s+(?=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])/gu, "$1")
+    .trim();
+}
+
+/** Structural markers split atoms but must not invent prose whitespace when those atoms rejoin. */
+export function joinProjection(parts: readonly string[]): string {
+  return cleanProjection(parts.join(""));
+}
+
+/**
+ * Display units follow the same lexical boundaries as semantic speech tokens. Punctuation is kept
+ * for rendering: opening punctuation belongs to the next unit; all other inter-token punctuation
+ * belongs to the previous unit. Whitespace is layout, not a display word of its own.
+ */
+export function displayWordSurfaces(value: string): readonly string[] {
+  const prose = cleanProjection(value);
+  const units = lexicalUnits(prose);
+  if (units.length === 0) return [];
+
+  const surfaces: string[] = [];
+  let cursor = 0;
+  let prefix = "";
+  for (const unit of units) {
+    const gap = prose.slice(cursor, unit.index);
+    const punctuation = [...gap]
+      .map((character, position) => ({ character, position }))
+      .filter(({ character }) => !/\s/u.test(character));
+    if (surfaces.length === 0) {
+      prefix += punctuation.map(({ character }) => character).join("");
+    } else {
+      const suffix = punctuation
+        .filter(({ character, position }) => !isOpeningPunctuation(character, gap, position, true))
+        .map(({ character }) => character)
+        .join("");
+      const opening = punctuation
+        .filter(({ character, position }) => isOpeningPunctuation(character, gap, position, true))
+        .map(({ character }) => character)
+        .join("");
+      if (suffix) surfaces[surfaces.length - 1] += suffix;
+      prefix += opening;
+    }
+    surfaces.push(`${prefix}${unit.text}`);
+    prefix = "";
+    cursor = unit.index + unit.text.length;
+  }
+  const trailing = prose.slice(cursor).replace(/\s+/gu, "");
+  if (trailing) surfaces[surfaces.length - 1] += trailing;
+  return surfaces;
+}
+
+/** Closing punctuation before a lexical unit belongs to the previous display unit when one exists. */
+export function splitLeadingClosingPunctuation(value: string): {
+  readonly previous: string;
+  readonly current: string;
+} {
+  const prose = cleanProjection(value);
+  const first = lexicalUnits(prose)[0];
+  if (first === undefined) return { previous: prose.replace(/\s+/gu, ""), current: "" };
+  const leading = prose.slice(0, first.index);
+  const punctuation = [...leading]
+    .map((character, position) => ({ character, position }))
+    .filter(({ character }) => !/\s/u.test(character));
+  const previous = punctuation
+    .filter(({ character, position }) => !isOpeningPunctuation(character, leading, position, false))
+    .map(({ character }) => character)
+    .join("");
+  const opening = punctuation
+    .filter(({ character, position }) => isOpeningPunctuation(character, leading, position, false))
+    .map(({ character }) => character)
+    .join("");
+  return { previous, current: `${opening}${prose.slice(first.index)}` };
+}

package/packages/script/src/manifest.ts

@@ -0,0 +1,95 @@
+import { narrativeDependency, narrativeSchema, narrativeTypes } from "@hypit/narrative";
+import { textDependency, textTypes } from "@hypit/text";
+import type { ModuleManifest, TypeRef } from "@hypit/protocol";
+
+export const scriptModuleRef = { name: "@hypit/script", version: "1" } as const;
+export const narrativeType: TypeRef = narrativeTypes.narrative;
+export const narrativeExcerptType: TypeRef = narrativeTypes.excerpt;
+export const narrativeSelectionType: TypeRef = narrativeTypes.selection;
+export const narrativeMomentType: TypeRef = narrativeTypes.moment;
+export const captionDocumentType: TypeRef = narrativeTypes.captionDocument;
+export { narrativeSchema };
+
+export const scriptMarkupSurfaces = [
+  {
+    name: "script",
+    tag: "script",
+    mode: "raw",
+    outputs: [
+      narrativeType,
+      narrativeExcerptType,
+      textTypes.text,
+      narrativeSelectionType,
+      narrativeMomentType,
+      captionDocumentType,
+    ],
+    vocabulary: {
+      summary: "Holds every spoken word as prose-first Segments and publishes the authored Narrative with the Selections, Moments and text projections the rest of the source reads.",
+      attributes: [
+        { name: "id", kind: "identifier", required: false,
+          summary: "Names the Narrative Record and prefixes every view this element publishes." },
+      ],
+      text: "The element's own content is the Script body: named Segments holding prose, Role Cues, Dual Text, flat token attributes, and zero-width Selection and Moment markers. It carries no timecode, no media reference and no generation parameter.",
+      ports: [
+        { name: "", type: narrativeType,
+          summary: "The whole authored Narrative, addressed by the element's own id." },
+        { name: "segment.<id>", type: narrativeExcerptType,
+          summary: "One Segment as a narrow Excerpt, used to associate a generated Take with that Segment." },
+        { name: "segment.<id>.dialogue", type: textTypes.text,
+          summary: "One Segment as display-independent dialogue, keeping Role Cue labels and the spoken side of Dual Text." },
+        { name: "segment.<id>.speech", type: textTypes.text,
+          summary: "One Segment as pronunciation only, with Role Cue labels dropped." },
+        { name: "caption", type: captionDocumentType,
+          summary: "The complete Script-owned CaptionDocument: display Words, N:M Alignment Units, Cue breaks and speech correspondence." },
+        { name: "selection.<id>", type: narrativeSelectionType,
+          summary: "One named range over the Narrative, reusable wherever a Selection is read." },
+        { name: "moment.<id>", type: narrativeMomentType,
+          summary: "One named point in the Narrative, reusable wherever a Moment is read." },
+      ],
+      example: [
+        '<script id="story">',
+        "  @whole",
+        "  <hook>",
+        "    <HOST> @problem Never let anyone take credit for your work. @/problem",
+        "  </hook>",
+        "",
+        "  <meeting>",
+        "    <HOST> I started sending <BCC | B C C> recaps. @ranking! Everything changed.",
+        "  </meeting>",
+        "  @/whole~",
+        "</script>",
+      ].join("\n"),
+      notes: [
+        "`id` defaults to `script` and must be a canonical lower-case identifier of up to 64 characters.",
+        "A Script requires at least one Segment, and natural-language text is refused outside a Segment.",
+        "A Segment is opened by its own lower-case name and closed by that exact name, or written self-closing as `<pause/>`; the name is the Segment id, must be unique within the Script, and `script` is reserved. Segments do not nest.",
+        "A Role Cue such as `<HOST>` is a bare tag inside a Segment with no close; its turn runs until the next Cue or the end of the Segment, and a Cue may not follow unowned speech in the same Segment. Role state resets when the Segment closes.",
+        "Dual Text is written `<display | speech>`: the left side reaches the caption projection and the right side reaches dialogue and speech. The spoken side must not be empty; the displayed side may be, which speaks a word that is never displayed.",
+        "A flat token attribute follows a complete display token as `{name}` or `{name=value}`; multiple attributes use one comma-separated block. Attributes do not nest, do not carry timing, and never split a Dual Alignment Unit.",
+        "Selection and Moment markers are zero-width, share one name namespace, and may not split a speech token:",
+        [
+          "| Marker | Meaning |",
+          "|---|---|",
+          "| `@id` | Opens a Selection at the next word's start |",
+          "| `~@id` | Opens a Selection at the previous word's end |",
+          "| `@/id` | Closes a Selection at the previous word's end |",
+          "| `@/id~` | Closes a Selection at the next word's start |",
+          "| `@id!` | A Moment at the next word's start |",
+          "| `~@id!` | A Moment at the previous word's end |",
+        ].join("\n"),
+        "Each Selection name has one opening and one closing marker; use distinct names for distinct semantic ranges.",
+        "`<!-- -->` comments never enter any projection, and `\\@`, `\\<`, `\\\\`, `\\{` and `\\}` write those characters literally; inside Dual Text `\\|` and `\\>` do the same.",
+      ],
+    },
+  },
+] as const;
+
+export const scriptManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: scriptModuleRef.name,
+  version: scriptModuleRef.version,
+  dependencies: [narrativeDependency, textDependency],
+  types: [],
+  capabilities: [],
+  producers: [],
+};

package/packages/script/src/narrative.ts

@@ -0,0 +1,232 @@
+import { canonicalize } from "@hypit/protocol";
+import type { CanonicalValue } from "@hypit/protocol";
+import type { CaptionAlignmentUnit, CaptionDocument, CaptionDisplayWord } from "@hypit/narrative";
+import { sealText } from "@hypit/text";
+
+import type { ParsedCaptionRegion, ParsedNarrative } from "./types.js";
+import { cleanProjection, displayWordSurfaces, joinProjection, lexicalCount } from "./lexical.js";
+
+function turnForRegion(parsed: ParsedNarrative, region: ParsedCaptionRegion): ParsedNarrative["turns"][number] {
+  const turn = parsed.turns.find((candidate) =>
+    candidate.segmentId === region.segmentId
+    && candidate.tokenStart < region.endTokenExclusive
+    && candidate.tokenEndExclusive > region.startToken);
+  if (turn === undefined) throw new Error(`Caption region ${region.id} is not owned by a Narrative Turn`);
+  return turn;
+}
+
+function projectCaption(parsed: ParsedNarrative, id: string, narrativeId: string): CaptionDocument {
+  const units: CaptionAlignmentUnit[] = [];
+  const words: CaptionDisplayWord[] = [];
+  for (const region of parsed.captionProjection.regions) {
+    if (region.kind === "hidden") continue;
+    const turn = turnForRegion(parsed, region);
+    const surfaces = displayWordSurfaces(region.display);
+    if (surfaces.length === 0) throw new Error(`Caption region ${region.id} contains no visible display surface`);
+    // A Dual Text alias is one indivisible N:M correspondence unit. Ordinary prose gives one
+    // unit per display surface so the author can place cue/style boundaries between words.
+    const groups = region.kind === "alias"
+      ? [{ surfaces, indices: surfaces.map((_, index) => index) }]
+      : surfaces.map((surface, index) => ({ surfaces: [surface], indices: [index] }));
+    for (const mark of region.marks) {
+      if (!Number.isSafeInteger(mark.displayIndex) || mark.displayIndex < 0 || mark.displayIndex >= surfaces.length) {
+        throw new Error(`Caption region ${region.id} contains an attribute outside its display words`);
+      }
+    }
+    let sourceCursor = region.startToken;
+    for (const group of groups) {
+      const unitId = `${id}:unit:${units.length + 1}`;
+      const unitWordIds = group.surfaces.map((surface, groupIndex) => {
+        const wordId = `${unitId}:word:${groupIndex + 1}`;
+        const attributes = region.marks.find((mark) => mark.displayIndex === group.indices[groupIndex])?.attributes ?? [];
+        words.push({
+          id: wordId,
+          unitId,
+          segmentId: region.segmentId,
+          turnId: turn.id,
+          ...(turn.role === undefined ? {} : { role: turn.role }),
+          text: surface,
+          attributes,
+        });
+        return wordId;
+      });
+      const sourceEnd = region.kind === "alias"
+        ? region.endTokenExclusive
+        : sourceCursor + group.surfaces.reduce((count, surface) => count + lexicalCount(surface), 0);
+      const sourceTokenIds = parsed.tokens.slice(sourceCursor, sourceEnd).map((token) => token.id);
+      if (sourceTokenIds.length === 0) throw new Error(`Caption Unit ${unitId} has no authored speech correspondence`);
+      units.push({
+        id: unitId,
+        segmentId: region.segmentId,
+        turnId: turn.id,
+        ...(turn.role === undefined ? {} : { role: turn.role }),
+        wordIds: unitWordIds,
+        sourceTokenIds,
+      });
+      sourceCursor = sourceEnd;
+    }
+    if (sourceCursor !== region.endTokenExclusive) {
+      throw new Error(`Caption identity region ${region.id} does not structurally partition its authored speech`);
+    }
+  }
+
+  const tokenIndex = new Map(parsed.tokens.map((token) => [token.id, token.index]));
+  const cueBreaks = parsed.captionProjection.breaks.map((breakPoint) => {
+    const next = units.findIndex((unit) => {
+      const indexes = unit.sourceTokenIds.map((tokenId) => tokenIndex.get(tokenId));
+      return indexes.every((index): index is number => index !== undefined)
+        && Math.min(...indexes) >= breakPoint.tokenIndex;
+    });
+    if (next <= 0 || next === -1) {
+      throw new Error("Caption Cue break must lie between two complete Alignment Units");
+    }
+    const previous = units[next - 1]!;
+    const previousIndexes = previous.sourceTokenIds.map((tokenId) => tokenIndex.get(tokenId));
+    if (previousIndexes.some((index) => index === undefined)
+      || Math.max(...previousIndexes as number[]) + 1 !== breakPoint.tokenIndex) {
+      throw new Error("Caption Cue break cannot split an Alignment Unit");
+    }
+    return { afterUnitId: previous.id };
+  });
+  // Segment close is a hard cue boundary.  A cue cannot carry words across two
+  // independent speech takes even when the author omitted an explicit `||`.
+  // Keep explicit breaks, but de-duplicate the boundary when `||` was placed
+  // immediately before `</segment>`.
+  const breaks = new Set(cueBreaks.map((item) => item.afterUnitId));
+  for (let index = 0; index < units.length - 1; index += 1) {
+    if (units[index]!.segmentId === units[index + 1]!.segmentId) continue;
+    breaks.add(units[index]!.id);
+  }
+  return {
+    narrativeId,
+    id,
+    units,
+    words,
+    cueBreaks: units.filter((unit) => breaks.has(unit.id)).map((unit) => ({ afterUnitId: unit.id })),
+  };
+}
+
+export function captionDocument(parsed: ParsedNarrative, id: string, narrativeId: string): CaptionDocument {
+  return projectCaption(parsed, id, narrativeId);
+}
+
+export function captionDocumentValue(parsed: ParsedNarrative, id: string, narrativeId: string): CanonicalValue {
+  return canonicalize(captionDocument(parsed, id, narrativeId));
+}
+
+function segmentSerializations(segment: ParsedNarrative["segments"][number]): {
+  readonly dialogue: string;
+  readonly speech: string;
+} {
+  const speechTurns: string[] = [];
+  const dialogue: string[] = [];
+  let role: string | undefined;
+  let turn: string[] = [];
+  const flush = (): void => {
+    const body = joinProjection(turn);
+    if (body) {
+      dialogue.push(role === undefined ? body : `${role}: ${body}`);
+      speechTurns.push(body);
+    }
+    turn = [];
+  };
+  for (const atom of segment.atoms) {
+    if (atom.kind === "role") {
+      flush();
+      role = atom.label;
+      continue;
+    }
+    turn.push(atom.speech);
+  }
+  flush();
+  return { dialogue: dialogue.join("\n"), speech: cleanProjection(speechTurns.join(" ")) };
+}
+
+export function narrativeSegmentExcerptValue(
+  parsed: ParsedNarrative,
+  segment: ParsedNarrative["segments"][number],
+  narrativeId: string,
+): CanonicalValue {
+  return canonicalize({
+    kind: "segment",
+    narrativeId,
+    id: segment.id,
+    tokenStart: segment.tokenStart,
+    tokenEndExclusive: segment.tokenEndExclusive,
+  });
+}
+
+export function narrativeDialogueTextValue(segment: ParsedNarrative["segments"][number]): CanonicalValue {
+  return sealText(segmentSerializations(segment).dialogue) as unknown as CanonicalValue;
+}
+
+export function narrativeSpeechTextValue(segment: ParsedNarrative["segments"][number]): CanonicalValue {
+  return sealText(segmentSerializations(segment).speech) as unknown as CanonicalValue;
+}
+
+export function narrativeSelectionValue(selection: ParsedNarrative["selections"][number], narrativeId: string): CanonicalValue {
+  return canonicalize({
+    narrativeId,
+    id: selection.id,
+    startAnchorId: selection.open.boundary.anchorId,
+    endAnchorId: selection.close.boundary.anchorId,
+  });
+}
+
+export function narrativeMomentValue(moment: ParsedNarrative["moments"][number], narrativeId: string): CanonicalValue {
+  return canonicalize({ narrativeId, id: moment.id, anchorId: moment.boundary.anchorId });
+}
+
+export function narrativeValue(parsed: ParsedNarrative, id: string): CanonicalValue {
+  return canonicalize({
+    id,
+    segments: parsed.segments.map((segment) => ({
+      id: segment.id,
+      startAnchorId: segment.startAnchorId,
+      endAnchorId: segment.endAnchorId,
+      tokenStart: segment.tokenStart,
+      tokenEndExclusive: segment.tokenEndExclusive,
+    })),
+    tokens: parsed.tokens.map((token) => ({
+      id: token.id,
+      segmentId: token.segmentId,
+      startAnchorId: token.startAnchorId,
+      endAnchorId: token.endAnchorId,
+      text: token.text,
+      normalized: token.normalized,
+    })),
+    turns: parsed.turns.map((turn) => ({
+      id: turn.id,
+      segmentId: turn.segmentId,
+      ...(turn.role === undefined ? {} : { role: turn.role }),
+      tokenStart: turn.tokenStart,
+      tokenEndExclusive: turn.tokenEndExclusive,
+    })),
+    selections: parsed.selections.map((selection) => ({
+      id: selection.id,
+      startAnchorId: selection.open.boundary.anchorId,
+      endAnchorId: selection.close.boundary.anchorId,
+    })),
+    moments: parsed.moments.map((moment) => ({ id: moment.id, anchorId: moment.boundary.anchorId })),
+    semanticIndex: {
+      anchors: parsed.semanticIndex.anchors.map((anchor) => ({
+        id: anchor.id,
+        kind: anchor.kind,
+        ...("segmentId" in anchor ? { segmentId: anchor.segmentId } : {}),
+        ...("tokenId" in anchor && anchor.tokenId !== undefined ? { tokenId: anchor.tokenId } : {}),
+      })),
+    },
+  });
+}
+
+export function serializeSpeech(parsed: ParsedNarrative): string {
+  return parsed.serializations.speech;
+}
+
+export function serializeDialogue(parsed: ParsedNarrative): string {
+  return parsed.serializations.dialogue;
+}
+
+export function serializeCaption(parsed: ParsedNarrative): string {
+  return parsed.captionProjection.text;
+}