@beyondwork/docx-react-component 1.0.103 → 1.0.104

package/src/model/canonical-layout-inputs.ts

@@ -0,0 +1,979 @@
+import type {
+  AnchorGeometry,
+  BlockNode,
+  CanonicalDocument,
+  DrawingFrameNode,
+  FieldFamily,
+  FieldRefreshStatus,
+  HeaderFooterReference,
+  HeaderFooterVariant,
+  ImageNode,
+  InlineNode,
+  SectionProperties,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+  TocRegion,
+} from "./canonical-document.ts";
+
+export const MAIN_STORY_KEY = "main";
+
+export type CanonicalStoryKind =
+  | "main"
+  | "header"
+  | "footer"
+  | "footnote"
+  | "endnote";
+
+export interface CanonicalStoryIdentity {
+  readonly storyKey: string;
+  readonly kind: CanonicalStoryKind;
+  readonly blockCount: number;
+  readonly sectionIndex?: number;
+  readonly boundSectionIndexes?: readonly number[];
+  readonly explicitSectionIndexes?: readonly number[];
+  readonly inheritedSectionIndexes?: readonly number[];
+  readonly variant?: HeaderFooterVariant;
+  readonly relationshipId?: string;
+  readonly partPath?: string;
+  readonly noteId?: string;
+}
+
+export type CanonicalFieldRegionKind = "field" | "toc-region";
+
+export interface CanonicalFieldRegionIdentity {
+  readonly regionId: string;
+  readonly kind: CanonicalFieldRegionKind;
+  readonly storyKey: string;
+  readonly fieldIndex: number;
+  readonly fieldFamily: FieldFamily;
+  readonly refreshStatus: FieldRefreshStatus;
+  readonly paragraphIndex: number;
+  readonly tocId?: string;
+  readonly sourcePath?: string;
+  readonly parentKind?: TocRegion["parentKind"];
+  readonly resultRange?: TocRegion["resultRange"];
+  readonly status?: TocRegion["status"];
+  readonly cachedEntryCount?: number;
+  readonly generatedEntryCount?: number;
+}
+
+export interface CanonicalLayoutInputs {
+  readonly stories: readonly CanonicalStoryIdentity[];
+  readonly fieldRegions: readonly CanonicalFieldRegionIdentity[];
+  readonly tables: readonly CanonicalTableLayoutInput[];
+  readonly anchors: readonly CanonicalAnchorLayoutInput[];
+  readonly scopes: readonly CanonicalScopeLayoutInput[];
+}
+
+export interface CanonicalTableLayoutInput {
+  readonly tableKey: string;
+  readonly storyKey: string;
+  readonly blockPath: string;
+  readonly rowCount: number;
+  readonly columnCount: number;
+  readonly gridColumns: readonly number[];
+  readonly width?: TableNode["width"];
+  readonly alignment?: TableNode["alignment"];
+  readonly borders?: TableNode["borders"];
+  readonly cellMargins?: TableNode["cellMargins"];
+  readonly tblLook?: TableNode["tblLook"];
+  readonly indent?: TableNode["indent"];
+  readonly layoutMode?: TableNode["layoutMode"];
+  readonly cellSpacing?: TableNode["cellSpacing"];
+  readonly bidiVisual?: boolean;
+  readonly floating?: TableNode["floating"];
+  readonly rows: readonly CanonicalTableRowLayoutInput[];
+}
+
+export interface CanonicalTableRowLayoutInput {
+  readonly rowKey: string;
+  readonly rowIndex: number;
+  readonly cellCount: number;
+  readonly gridBefore?: number;
+  readonly widthBefore?: TableRowNode["widthBefore"];
+  readonly gridAfter?: number;
+  readonly widthAfter?: TableRowNode["widthAfter"];
+  readonly height?: number;
+  readonly heightRule?: TableRowNode["heightRule"];
+  readonly isHeader?: boolean;
+  readonly cantSplit?: boolean;
+  readonly horizontalAlignment?: TableRowNode["horizontalAlignment"];
+  readonly cnfStyle?: string;
+  readonly cells: readonly CanonicalTableCellLayoutInput[];
+}
+
+export interface CanonicalTableCellLayoutInput {
+  readonly cellKey: string;
+  readonly rowIndex: number;
+  readonly cellIndex: number;
+  readonly gridColumnStart: number;
+  readonly gridSpan: number;
+  readonly verticalMerge?: TableCellNode["verticalMerge"];
+  readonly width?: TableCellNode["width"];
+  readonly borders?: TableCellNode["borders"];
+  readonly shading?: TableCellNode["shading"];
+  readonly verticalAlign?: TableCellNode["verticalAlign"];
+  readonly textDirection?: TableCellNode["textDirection"];
+  readonly noWrap?: boolean;
+  readonly fitText?: boolean;
+  readonly margins?: TableCellNode["margins"];
+  readonly cnfStyle?: string;
+  readonly blockCount: number;
+}
+
+export type CanonicalAnchorObjectKind =
+  | "legacy-image"
+  | "picture"
+  | "shape"
+  | "textbox"
+  | "chart"
+  | "smartart"
+  | "opaque";
+
+export type CanonicalAnchorEditPosture =
+  | "editable"
+  | "read-only-preview"
+  | "preserve-only";
+
+export interface CanonicalAnchorLayoutInput {
+  readonly objectKey: string;
+  readonly storyKey: string;
+  readonly blockPath: string;
+  readonly inlinePath: string;
+  readonly objectKind: CanonicalAnchorObjectKind;
+  readonly editPosture: CanonicalAnchorEditPosture;
+  readonly display?: "inline" | "floating";
+  readonly extent?: AnchorGeometry["extent"];
+  readonly wrapMode?: AnchorGeometry["wrapMode"];
+  readonly wrapPolygonPointCount?: number;
+  readonly positionH?: AnchorGeometry["positionH"];
+  readonly positionV?: AnchorGeometry["positionV"];
+  readonly distMargins?: AnchorGeometry["distMargins"];
+  readonly relativeHeight?: number;
+  readonly zOrder?: "behind-document" | "in-front-of-text";
+  readonly layoutInCell?: boolean;
+  readonly allowOverlap?: boolean;
+  readonly simplePos?: boolean;
+  readonly docPrId?: string;
+  readonly docPrName?: string;
+  readonly docPrDescription?: string;
+  readonly hidden?: boolean;
+  readonly frameLocks?: AnchorGeometry["frameLocks"];
+  readonly mediaId?: string;
+  readonly packagePartName?: string;
+  readonly relationshipId?: string;
+  readonly isLinked?: boolean;
+  readonly hasTextBoxBlocks?: boolean;
+  readonly textBoxBlockCount?: number;
+  readonly rawXmlPreserved?: boolean;
+}
+
+export type CanonicalScopeLayoutStatus = "paired" | "start-only" | "end-only";
+
+export interface CanonicalScopeMarkerReference {
+  readonly markerKey: string;
+  readonly blockPath: string;
+  readonly inlinePath: string;
+  readonly markerIndex: number;
+}
+
+export interface CanonicalScopeLayoutInput {
+  readonly scopeKey: string;
+  readonly scopeId: string;
+  readonly storyKey: string;
+  readonly status: CanonicalScopeLayoutStatus;
+  readonly source: "canonical-marker";
+  readonly start?: CanonicalScopeMarkerReference;
+  readonly end?: CanonicalScopeMarkerReference;
+}
+
+export interface CanonicalStoryBlockContext {
+  readonly storyKey: string;
+  readonly blocks: readonly BlockNode[];
+  readonly basePath: string;
+}
+
+export function createHeaderFooterStoryKey(input: {
+  kind: "header" | "footer";
+  relationshipId: string;
+  variant: HeaderFooterVariant;
+  sectionIndex?: number;
+}): string {
+  const section = input.sectionIndex === undefined ? "unscoped" : String(input.sectionIndex);
+  return `${input.kind}:${section}:${input.variant}:${input.relationshipId}`;
+}
+
+export function createNoteStoryKey(
+  kind: "footnote" | "endnote",
+  noteId: string,
+): string {
+  return `${kind}:${noteId}`;
+}
+
+export function collectCanonicalLayoutInputs(
+  doc: CanonicalDocument,
+): CanonicalLayoutInputs {
+  const blockContexts = collectStoryBlockContexts(doc);
+  return {
+    stories: collectCanonicalStoryIdentities(doc),
+    fieldRegions: collectCanonicalFieldRegionIdentities(doc),
+    tables: collectCanonicalTableLayoutInputs(blockContexts),
+    anchors: collectCanonicalAnchorLayoutInputs(doc, blockContexts),
+    scopes: collectCanonicalScopeLayoutInputs(blockContexts),
+  };
+}
+
+export function collectCanonicalStoryIdentities(
+  doc: CanonicalDocument,
+): CanonicalStoryIdentity[] {
+  const stories: CanonicalStoryIdentity[] = [
+    {
+      storyKey: MAIN_STORY_KEY,
+      kind: "main",
+      blockCount: doc.content.children.length,
+    },
+  ];
+
+  const sectionCount = countSections(doc);
+  for (const header of doc.subParts?.headers ?? []) {
+    const bindings = collectHeaderFooterBindings(
+      doc,
+      "header",
+      header.relationshipId,
+      header.variant,
+      header.sectionIndex,
+      sectionCount,
+    );
+    stories.push({
+      storyKey: createHeaderFooterStoryKey({
+        kind: "header",
+        relationshipId: header.relationshipId,
+        variant: header.variant,
+        ...(header.sectionIndex !== undefined
+          ? { sectionIndex: header.sectionIndex }
+          : {}),
+      }),
+      kind: "header",
+      blockCount: header.blocks.length,
+      variant: header.variant,
+      relationshipId: header.relationshipId,
+      partPath: header.partPath,
+      ...(header.sectionIndex !== undefined ? { sectionIndex: header.sectionIndex } : {}),
+      boundSectionIndexes: bindings.boundSectionIndexes,
+      explicitSectionIndexes: bindings.explicitSectionIndexes,
+      inheritedSectionIndexes: bindings.inheritedSectionIndexes,
+    });
+  }
+
+  for (const footer of doc.subParts?.footers ?? []) {
+    const bindings = collectHeaderFooterBindings(
+      doc,
+      "footer",
+      footer.relationshipId,
+      footer.variant,
+      footer.sectionIndex,
+      sectionCount,
+    );
+    stories.push({
+      storyKey: createHeaderFooterStoryKey({
+        kind: "footer",
+        relationshipId: footer.relationshipId,
+        variant: footer.variant,
+        ...(footer.sectionIndex !== undefined
+          ? { sectionIndex: footer.sectionIndex }
+          : {}),
+      }),
+      kind: "footer",
+      blockCount: footer.blocks.length,
+      variant: footer.variant,
+      relationshipId: footer.relationshipId,
+      partPath: footer.partPath,
+      ...(footer.sectionIndex !== undefined ? { sectionIndex: footer.sectionIndex } : {}),
+      boundSectionIndexes: bindings.boundSectionIndexes,
+      explicitSectionIndexes: bindings.explicitSectionIndexes,
+      inheritedSectionIndexes: bindings.inheritedSectionIndexes,
+    });
+  }
+
+  const notes = doc.subParts?.footnoteCollection;
+  if (notes) {
+    for (const note of Object.values(notes.footnotes)) {
+      stories.push({
+        storyKey: createNoteStoryKey("footnote", note.noteId),
+        kind: "footnote",
+        noteId: note.noteId,
+        blockCount: note.blocks.length,
+      });
+    }
+    for (const note of Object.values(notes.endnotes)) {
+      stories.push({
+        storyKey: createNoteStoryKey("endnote", note.noteId),
+        kind: "endnote",
+        noteId: note.noteId,
+        blockCount: note.blocks.length,
+      });
+    }
+  }
+
+  return stories;
+}
+
+export function collectCanonicalFieldRegionIdentities(
+  doc: CanonicalDocument,
+): CanonicalFieldRegionIdentity[] {
+  const registry = doc.fieldRegistry;
+  if (!registry) return [];
+
+  const byFieldIndex = new Map(
+    [...registry.supported, ...registry.preserveOnly].map((entry) => [
+      entry.fieldIndex,
+      entry,
+    ]),
+  );
+  const regions: CanonicalFieldRegionIdentity[] = [];
+
+  for (const entry of byFieldIndex.values()) {
+    regions.push({
+      regionId: `field:${entry.fieldIndex}`,
+      kind: "field",
+      storyKey: entry.storyKey ?? MAIN_STORY_KEY,
+      fieldIndex: entry.fieldIndex,
+      fieldFamily: entry.fieldFamily,
+      refreshStatus: entry.refreshStatus,
+      paragraphIndex: entry.paragraphIndex,
+    });
+  }
+
+  for (const toc of registry.tocRegions ?? []) {
+    const field = byFieldIndex.get(toc.sourceFieldIndex);
+    regions.push({
+      regionId: `toc:${toc.tocId}`,
+      kind: "toc-region",
+      storyKey: field?.storyKey ?? MAIN_STORY_KEY,
+      fieldIndex: toc.sourceFieldIndex,
+      fieldFamily: field?.fieldFamily ?? "TOC",
+      refreshStatus: field?.refreshStatus ?? "stale",
+      paragraphIndex: toc.resultRange.fromParagraphIndex,
+      tocId: toc.tocId,
+      sourcePath: toc.sourcePath,
+      parentKind: toc.parentKind,
+      resultRange: toc.resultRange,
+      status: toc.status,
+      cachedEntryCount: toc.cachedEntries.length,
+      generatedEntryCount: toc.generatedEntries.length,
+    });
+  }
+
+  return regions;
+}
+
+export function collectCanonicalTableLayoutInputs(
+  contexts: readonly CanonicalStoryBlockContext[],
+): CanonicalTableLayoutInput[] {
+  const tables: CanonicalTableLayoutInput[] = [];
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      table(table, blockPath) {
+        tables.push(projectTableLayoutInput(table, context.storyKey, blockPath));
+      },
+    });
+  }
+  return tables;
+}
+
+export function collectCanonicalAnchorLayoutInputs(
+  doc: CanonicalDocument,
+  contexts: readonly CanonicalStoryBlockContext[] = collectStoryBlockContexts(doc),
+): CanonicalAnchorLayoutInput[] {
+  const anchors: CanonicalAnchorLayoutInput[] = [];
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      inline(inline, blockPath, inlinePath) {
+        const anchor = projectAnchorLayoutInput(
+          doc,
+          inline,
+          context.storyKey,
+          blockPath,
+          inlinePath,
+        );
+        if (anchor) anchors.push(anchor);
+      },
+    });
+  }
+  return anchors;
+}
+
+export function collectCanonicalScopeLayoutInputs(
+  contexts: readonly CanonicalStoryBlockContext[],
+): CanonicalScopeLayoutInput[] {
+  const scopes: CanonicalScopeLayoutInput[] = [];
+  for (const context of contexts) {
+    scopes.push(...collectScopeLayoutInputsForStory(context));
+  }
+  return scopes.sort((left, right) => left.scopeKey.localeCompare(right.scopeKey));
+}
+
+export function collectStoryBlockContexts(
+  doc: CanonicalDocument,
+): CanonicalStoryBlockContext[] {
+  const contexts: CanonicalStoryBlockContext[] = [
+    { storyKey: MAIN_STORY_KEY, blocks: doc.content.children, basePath: "main" },
+  ];
+
+  for (const header of doc.subParts?.headers ?? []) {
+    contexts.push({
+      storyKey: createHeaderFooterStoryKey({
+        kind: "header",
+        relationshipId: header.relationshipId,
+        variant: header.variant,
+        ...(header.sectionIndex !== undefined
+          ? { sectionIndex: header.sectionIndex }
+          : {}),
+      }),
+      blocks: header.blocks,
+      basePath: `header:${header.partPath}`,
+    });
+  }
+
+  for (const footer of doc.subParts?.footers ?? []) {
+    contexts.push({
+      storyKey: createHeaderFooterStoryKey({
+        kind: "footer",
+        relationshipId: footer.relationshipId,
+        variant: footer.variant,
+        ...(footer.sectionIndex !== undefined
+          ? { sectionIndex: footer.sectionIndex }
+          : {}),
+      }),
+      blocks: footer.blocks,
+      basePath: `footer:${footer.partPath}`,
+    });
+  }
+
+  const notes = doc.subParts?.footnoteCollection;
+  if (notes) {
+    for (const note of Object.values(notes.footnotes)) {
+      contexts.push({
+        storyKey: createNoteStoryKey("footnote", note.noteId),
+        blocks: note.blocks,
+        basePath: `footnote:${note.noteId}`,
+      });
+    }
+    for (const note of Object.values(notes.endnotes)) {
+      contexts.push({
+        storyKey: createNoteStoryKey("endnote", note.noteId),
+        blocks: note.blocks,
+        basePath: `endnote:${note.noteId}`,
+      });
+    }
+  }
+
+  return contexts;
+}
+
+interface BlockWalkVisitor {
+  readonly table?: (table: TableNode, blockPath: string) => void;
+  readonly inline?: (
+    inline: InlineNode,
+    blockPath: string,
+    inlinePath: string,
+  ) => void;
+}
+
+function walkBlocks(
+  blocks: readonly BlockNode[],
+  storyKey: string,
+  basePath: string,
+  visitor: BlockWalkVisitor,
+): void {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
+
+    if (block.type === "table") {
+      visitor.table?.(block, blockPath);
+      for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+        const row = block.rows[rowIndex];
+        if (!row) continue;
+        for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+          const cell = row.cells[cellIndex];
+          if (!cell) continue;
+          walkBlocks(
+            cell.children,
+            storyKey,
+            `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
+            visitor,
+          );
+        }
+      }
+      continue;
+    }
+
+    if (block.type === "paragraph") {
+      walkInlines(block.children, storyKey, blockPath, `${blockPath}/inline`, visitor);
+      continue;
+    }
+
+    if (block.type === "sdt" || block.type === "custom_xml") {
+      walkBlocks(block.children, storyKey, blockPath, visitor);
+    }
+  }
+}
+
+function walkInlines(
+  inlines: readonly InlineNode[],
+  storyKey: string,
+  blockPath: string,
+  basePath: string,
+  visitor: BlockWalkVisitor,
+): void {
+  for (let inlineIndex = 0; inlineIndex < inlines.length; inlineIndex += 1) {
+    const inline = inlines[inlineIndex];
+    if (!inline) continue;
+    const inlinePath = `${basePath}[${inlineIndex}]`;
+    visitor.inline?.(inline, blockPath, inlinePath);
+
+    if (inline.type === "hyperlink") {
+      walkInlines(inline.children, storyKey, blockPath, `${inlinePath}/child`, visitor);
+      continue;
+    }
+
+    if (inline.type === "shape" && inline.txbxBlocks) {
+      walkBlocks(inline.txbxBlocks, storyKey, `${inlinePath}/txbx`, visitor);
+      continue;
+    }
+
+    if (
+      inline.type === "drawing_frame" &&
+      inline.content.type === "shape" &&
+      inline.content.txbxBlocks
+    ) {
+      walkBlocks(inline.content.txbxBlocks, storyKey, `${inlinePath}/txbx`, visitor);
+    }
+  }
+}
+
+function projectTableLayoutInput(
+  table: TableNode,
+  storyKey: string,
+  blockPath: string,
+): CanonicalTableLayoutInput {
+  const tableKey = `${storyKey}:${blockPath}`;
+  const rows = table.rows.map((row, rowIndex) =>
+    projectTableRowLayoutInput(row, tableKey, rowIndex),
+  );
+  return {
+    tableKey,
+    storyKey,
+    blockPath,
+    rowCount: table.rows.length,
+    columnCount: table.gridColumns.length,
+    gridColumns: [...table.gridColumns],
+    ...(table.width !== undefined ? { width: table.width } : {}),
+    ...(table.alignment !== undefined ? { alignment: table.alignment } : {}),
+    ...(table.borders !== undefined ? { borders: table.borders } : {}),
+    ...(table.cellMargins !== undefined ? { cellMargins: table.cellMargins } : {}),
+    ...(table.tblLook !== undefined ? { tblLook: table.tblLook } : {}),
+    ...(table.indent !== undefined ? { indent: table.indent } : {}),
+    ...(table.layoutMode !== undefined ? { layoutMode: table.layoutMode } : {}),
+    ...(table.cellSpacing !== undefined ? { cellSpacing: table.cellSpacing } : {}),
+    ...(table.bidiVisual !== undefined ? { bidiVisual: table.bidiVisual } : {}),
+    ...(table.floating !== undefined ? { floating: table.floating } : {}),
+    rows,
+  };
+}
+
+function projectTableRowLayoutInput(
+  row: TableRowNode,
+  tableKey: string,
+  rowIndex: number,
+): CanonicalTableRowLayoutInput {
+  const rowKey = `${tableKey}:row[${rowIndex}]`;
+  let gridColumn = row.gridBefore ?? 0;
+  const cells = row.cells.map((cell, cellIndex) => {
+    const input = projectTableCellLayoutInput(cell, rowKey, rowIndex, cellIndex, gridColumn);
+    gridColumn += input.gridSpan;
+    return input;
+  });
+  return {
+    rowKey,
+    rowIndex,
+    cellCount: row.cells.length,
+    ...(row.gridBefore !== undefined ? { gridBefore: row.gridBefore } : {}),
+    ...(row.widthBefore !== undefined ? { widthBefore: row.widthBefore } : {}),
+    ...(row.gridAfter !== undefined ? { gridAfter: row.gridAfter } : {}),
+    ...(row.widthAfter !== undefined ? { widthAfter: row.widthAfter } : {}),
+    ...(row.height !== undefined ? { height: row.height } : {}),
+    ...(row.heightRule !== undefined ? { heightRule: row.heightRule } : {}),
+    ...(row.isHeader !== undefined ? { isHeader: row.isHeader } : {}),
+    ...(row.cantSplit !== undefined ? { cantSplit: row.cantSplit } : {}),
+    ...(row.horizontalAlignment !== undefined
+      ? { horizontalAlignment: row.horizontalAlignment }
+      : {}),
+    ...(row.cnfStyle !== undefined ? { cnfStyle: row.cnfStyle } : {}),
+    cells,
+  };
+}
+
+function projectTableCellLayoutInput(
+  cell: TableCellNode,
+  rowKey: string,
+  rowIndex: number,
+  cellIndex: number,
+  gridColumnStart: number,
+): CanonicalTableCellLayoutInput {
+  const gridSpan = cell.gridSpan ?? 1;
+  return {
+    cellKey: `${rowKey}:cell[${cellIndex}]`,
+    rowIndex,
+    cellIndex,
+    gridColumnStart,
+    gridSpan,
+    ...(cell.verticalMerge !== undefined ? { verticalMerge: cell.verticalMerge } : {}),
+    ...(cell.width !== undefined ? { width: cell.width } : {}),
+    ...(cell.borders !== undefined ? { borders: cell.borders } : {}),
+    ...(cell.shading !== undefined ? { shading: cell.shading } : {}),
+    ...(cell.verticalAlign !== undefined ? { verticalAlign: cell.verticalAlign } : {}),
+    ...(cell.textDirection !== undefined ? { textDirection: cell.textDirection } : {}),
+    ...(cell.noWrap !== undefined ? { noWrap: cell.noWrap } : {}),
+    ...(cell.fitText !== undefined ? { fitText: cell.fitText } : {}),
+    ...(cell.margins !== undefined ? { margins: cell.margins } : {}),
+    ...(cell.cnfStyle !== undefined ? { cnfStyle: cell.cnfStyle } : {}),
+    blockCount: cell.children.length,
+  };
+}
+
+function projectAnchorLayoutInput(
+  doc: CanonicalDocument,
+  inline: InlineNode,
+  storyKey: string,
+  blockPath: string,
+  inlinePath: string,
+): CanonicalAnchorLayoutInput | null {
+  if (inline.type === "drawing_frame") {
+    return projectDrawingFrameAnchor(inline, storyKey, blockPath, inlinePath);
+  }
+
+  if (inline.type === "image") {
+    return projectLegacyImageAnchor(doc, inline, storyKey, blockPath, inlinePath);
+  }
+
+  return null;
+}
+
+function projectDrawingFrameAnchor(
+  node: DrawingFrameNode,
+  storyKey: string,
+  blockPath: string,
+  inlinePath: string,
+): CanonicalAnchorLayoutInput {
+  const anchor = node.anchor;
+  const content = node.content;
+  const shapeBlocks = content.type === "shape" ? content.txbxBlocks : undefined;
+  const objectKind = drawingContentKind(content);
+  return {
+    objectKey: `${storyKey}:${inlinePath}`,
+    storyKey,
+    blockPath,
+    inlinePath,
+    objectKind,
+    editPosture: drawingEditPosture(node),
+    display: anchor.display,
+    extent: anchor.extent,
+    wrapMode: anchor.wrapMode,
+    ...(anchor.wrapPolygon !== undefined
+      ? { wrapPolygonPointCount: anchor.wrapPolygon.length }
+      : {}),
+    ...(anchor.positionH !== undefined ? { positionH: anchor.positionH } : {}),
+    ...(anchor.positionV !== undefined ? { positionV: anchor.positionV } : {}),
+    ...(anchor.distMargins !== undefined ? { distMargins: anchor.distMargins } : {}),
+    ...(anchor.relativeHeight !== undefined ? { relativeHeight: anchor.relativeHeight } : {}),
+    ...(anchor.behindDoc !== undefined
+      ? { zOrder: anchor.behindDoc ? "behind-document" : "in-front-of-text" }
+      : {}),
+    ...(anchor.layoutInCell !== undefined ? { layoutInCell: anchor.layoutInCell } : {}),
+    ...(anchor.allowOverlap !== undefined ? { allowOverlap: anchor.allowOverlap } : {}),
+    ...(anchor.simplePos !== undefined ? { simplePos: anchor.simplePos } : {}),
+    ...(anchor.docPr?.id !== undefined ? { docPrId: anchor.docPr.id } : {}),
+    ...(anchor.docPr?.name !== undefined ? { docPrName: anchor.docPr.name } : {}),
+    ...(anchor.docPr?.descr !== undefined ? { docPrDescription: anchor.docPr.descr } : {}),
+    ...(anchor.docPr?.hidden !== undefined ? { hidden: anchor.docPr.hidden } : {}),
+    ...(anchor.frameLocks !== undefined ? { frameLocks: anchor.frameLocks } : {}),
+    ...(content.type === "picture" && content.mediaId !== undefined
+      ? { mediaId: content.mediaId }
+      : {}),
+    ...(content.type === "picture" && content.packagePartName !== undefined
+      ? { packagePartName: content.packagePartName }
+      : {}),
+    ...(content.type === "picture" ? { relationshipId: content.blipRef } : {}),
+    ...(content.type === "picture" && content.isLinked !== undefined
+      ? { isLinked: content.isLinked }
+      : {}),
+    ...(shapeBlocks !== undefined ? { hasTextBoxBlocks: true } : {}),
+    ...(shapeBlocks !== undefined ? { textBoxBlockCount: shapeBlocks.length } : {}),
+    rawXmlPreserved: content.type !== "picture" || content.rawXml !== undefined,
+  };
+}
+
+function projectLegacyImageAnchor(
+  doc: CanonicalDocument,
+  node: ImageNode,
+  storyKey: string,
+  blockPath: string,
+  inlinePath: string,
+): CanonicalAnchorLayoutInput {
+  const media = doc.media.items[node.mediaId];
+  return {
+    objectKey: `${storyKey}:${inlinePath}`,
+    storyKey,
+    blockPath,
+    inlinePath,
+    objectKind: "legacy-image",
+    editPosture: "editable",
+    ...(node.display !== undefined ? { display: node.display } : {}),
+    ...(media?.widthEmu !== undefined && media.heightEmu !== undefined
+      ? { extent: { widthEmu: media.widthEmu, heightEmu: media.heightEmu } }
+      : {}),
+    ...(node.floating?.wrap !== undefined ? { wrapMode: node.floating.wrap } : {}),
+    ...(node.floating?.horizontalPosition !== undefined
+      ? { positionH: normalizeFloatingAxis(node.floating.horizontalPosition) }
+      : {}),
+    ...(node.floating?.verticalPosition !== undefined
+      ? { positionV: normalizeFloatingAxis(node.floating.verticalPosition) }
+      : {}),
+    ...(node.floating?.behindDoc !== undefined
+      ? { zOrder: node.floating.behindDoc ? "behind-document" : "in-front-of-text" }
+      : {}),
+    ...(node.floating?.layoutInCell !== undefined
+      ? { layoutInCell: node.floating.layoutInCell }
+      : {}),
+    ...(node.floating?.allowOverlap !== undefined
+      ? { allowOverlap: node.floating.allowOverlap }
+      : {}),
+    mediaId: node.mediaId,
+    ...(media?.packagePartName !== undefined ? { packagePartName: media.packagePartName } : {}),
+    ...(media?.relationshipId !== undefined ? { relationshipId: media.relationshipId } : {}),
+    ...(node.placementXml !== undefined ? { rawXmlPreserved: true } : {}),
+  };
+}
+
+function normalizeFloatingAxis(
+  axis: NonNullable<ImageNode["floating"]>["horizontalPosition"],
+): AnchorGeometry["positionH"] {
+  return {
+    relativeFrom: axis?.relativeFrom ?? "",
+    ...(axis?.align !== undefined ? { align: axis.align } : {}),
+    ...(axis?.offset !== undefined ? { offset: axis.offset } : {}),
+  };
+}
+
+function drawingContentKind(
+  content: DrawingFrameNode["content"],
+): CanonicalAnchorObjectKind {
+  if (content.type === "picture") return "picture";
+  if (content.type === "shape") {
+    return content.isTextBox || content.txbxBlocks || content.txbxContentXml
+      ? "textbox"
+      : "shape";
+  }
+  if (content.type === "chart_preview") return "chart";
+  if (content.type === "smartart_preview") return "smartart";
+  return "opaque";
+}
+
+function drawingEditPosture(
+  node: DrawingFrameNode,
+): CanonicalAnchorEditPosture {
+  if (node.content.type === "picture" && !node.content.isLinked) return "editable";
+  if (node.content.type === "opaque") return "preserve-only";
+  return "read-only-preview";
+}
+
+interface ScopeMarkerOccurrence {
+  readonly scopeId: string;
+  readonly markerType: "start" | "end";
+  readonly markerIndex: number;
+  readonly blockPath: string;
+  readonly inlinePath: string;
+}
+
+function collectScopeLayoutInputsForStory(
+  context: CanonicalStoryBlockContext,
+): CanonicalScopeLayoutInput[] {
+  const occurrences: ScopeMarkerOccurrence[] = [];
+  walkBlocks(context.blocks, context.storyKey, context.basePath, {
+    inline(inline, blockPath, inlinePath) {
+      if (inline.type !== "scope_marker_start" && inline.type !== "scope_marker_end") {
+        return;
+      }
+      occurrences.push({
+        scopeId: inline.scopeId,
+        markerType: inline.type === "scope_marker_start" ? "start" : "end",
+        markerIndex: occurrences.length,
+        blockPath,
+        inlinePath,
+      });
+    },
+  });
+
+  const open = new Map<string, ScopeMarkerOccurrence[]>();
+  const scopes: CanonicalScopeLayoutInput[] = [];
+
+  for (const marker of occurrences) {
+    if (marker.markerType === "start") {
+      const stack = open.get(marker.scopeId) ?? [];
+      stack.push(marker);
+      open.set(marker.scopeId, stack);
+      continue;
+    }
+
+    const stack = open.get(marker.scopeId);
+    const opener = stack?.pop();
+    if (stack && stack.length === 0) {
+      open.delete(marker.scopeId);
+    }
+
+    if (opener) {
+      scopes.push(createScopeLayoutInput(context.storyKey, "paired", opener, marker));
+      continue;
+    }
+
+    scopes.push(createScopeLayoutInput(context.storyKey, "end-only", undefined, marker));
+  }
+
+  for (const stack of open.values()) {
+    for (const opener of stack) {
+      scopes.push(createScopeLayoutInput(context.storyKey, "start-only", opener, undefined));
+    }
+  }
+
+  return scopes.sort(
+    (left, right) =>
+      (left.start?.markerIndex ?? left.end?.markerIndex ?? Number.MAX_SAFE_INTEGER) -
+        (right.start?.markerIndex ?? right.end?.markerIndex ?? Number.MAX_SAFE_INTEGER) ||
+      left.scopeId.localeCompare(right.scopeId),
+  );
+}
+
+function createScopeLayoutInput(
+  storyKey: string,
+  status: CanonicalScopeLayoutStatus,
+  start: ScopeMarkerOccurrence | undefined,
+  end: ScopeMarkerOccurrence | undefined,
+): CanonicalScopeLayoutInput {
+  const scopeId = start?.scopeId ?? end?.scopeId ?? "";
+  const keyIndex = start?.markerIndex ?? end?.markerIndex ?? 0;
+  return {
+    scopeKey: `${storyKey}:scope:${scopeId}:${keyIndex}`,
+    scopeId,
+    storyKey,
+    status,
+    source: "canonical-marker",
+    ...(start !== undefined ? { start: createScopeMarkerReference(storyKey, start) } : {}),
+    ...(end !== undefined ? { end: createScopeMarkerReference(storyKey, end) } : {}),
+  };
+}
+
+function createScopeMarkerReference(
+  storyKey: string,
+  marker: ScopeMarkerOccurrence,
+): CanonicalScopeMarkerReference {
+  return {
+    markerKey: `${storyKey}:scope-marker:${marker.scopeId}:${marker.markerIndex}`,
+    blockPath: marker.blockPath,
+    inlinePath: marker.inlinePath,
+    markerIndex: marker.markerIndex,
+  };
+}
+
+function countSections(doc: CanonicalDocument): number {
+  let explicitBreaks = 0;
+  for (const block of doc.content.children) {
+    if (block.type === "section_break") explicitBreaks += 1;
+  }
+  return explicitBreaks + 1;
+}
+
+interface HeaderFooterBindings {
+  readonly boundSectionIndexes: readonly number[];
+  readonly explicitSectionIndexes: readonly number[];
+  readonly inheritedSectionIndexes: readonly number[];
+}
+
+function collectHeaderFooterBindings(
+  doc: CanonicalDocument,
+  kind: "header" | "footer",
+  relationshipId: string,
+  variant: HeaderFooterVariant,
+  fallbackSectionIndex: number | undefined,
+  sectionCount: number,
+): HeaderFooterBindings {
+  const bound = new Set<number>();
+  const explicit = new Set<number>();
+  const inherited = new Set<number>();
+  const effectiveByVariant = new Map<HeaderFooterVariant, string>();
+  const sectionProperties = collectSectionProperties(doc);
+
+  for (let sectionIndex = 0; sectionIndex < sectionCount; sectionIndex += 1) {
+    const properties = sectionProperties[sectionIndex];
+    const refs = getHeaderFooterReferences(properties, kind);
+    const hasRequestedVariant = refs.some((ref) => ref.variant === variant);
+    if (!hasRequestedVariant && effectiveByVariant.get(variant) === relationshipId) {
+      inherited.add(sectionIndex);
+      bound.add(sectionIndex);
+    }
+
+    if (
+      refs.some(
+        (ref) =>
+          ref.relationshipId === relationshipId && ref.variant === variant,
+      )
+    ) {
+      explicit.add(sectionIndex);
+      bound.add(sectionIndex);
+    }
+
+    for (const ref of refs) {
+      effectiveByVariant.set(ref.variant, ref.relationshipId);
+    }
+  }
+
+  if (fallbackSectionIndex !== undefined) {
+    bound.add(fallbackSectionIndex);
+  } else if (bound.size === 0) {
+    for (let sectionIndex = 0; sectionIndex < sectionCount; sectionIndex += 1) {
+      bound.add(sectionIndex);
+    }
+  }
+
+  return {
+    boundSectionIndexes: sortIndexes(bound),
+    explicitSectionIndexes: sortIndexes(explicit),
+    inheritedSectionIndexes: sortIndexes(inherited),
+  };
+}
+
+function collectSectionProperties(
+  doc: CanonicalDocument,
+): Array<SectionProperties | undefined> {
+  const sectionProperties = doc.content.children
+    .filter((block) => block.type === "section_break")
+    .map((block) => block.sectionProperties);
+  sectionProperties.push(doc.subParts?.finalSectionProperties);
+  return sectionProperties;
+}
+
+function getHeaderFooterReferences(
+  properties: SectionProperties | undefined,
+  kind: "header" | "footer",
+): readonly HeaderFooterReference[] {
+  return (kind === "header"
+    ? properties?.headerReferences
+    : properties?.footerReferences) ?? [];
+}
+
+function sortIndexes(indexes: ReadonlySet<number>): readonly number[] {
+  return [...indexes].sort((left, right) => left - right);
+}