@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/io/ooxml/parse-tables.ts

@@ -69,6 +69,25 @@ export interface ParsedTableLook {
   noVBand?: boolean;
 }
 
+export interface ParsedTableIndent {
+  value: number;
+  type: "dxa" | "auto" | "pct" | "nil";
+}
+
+export interface ParsedTableFloating {
+  horizontalAnchor?: "margin" | "page" | "text";
+  verticalAnchor?: "margin" | "page" | "text";
+  horizontalAlign?: "left" | "center" | "right" | "inside" | "outside";
+  horizontalOffset?: number;
+  verticalAlign?: "top" | "center" | "bottom" | "inside" | "outside";
+  verticalOffset?: number;
+  leftFromText?: number;
+  rightFromText?: number;
+  topFromText?: number;
+  bottomFromText?: number;
+  overlap?: boolean;
+}
+
 export interface ParsedTableDocument {
   tables: ParsedTable[];
 }
@@ -85,6 +104,13 @@ export interface ParsedTable {
   borders?: ParsedTableBorders;
   cellMargins?: ParsedCellMargins;
   tblLook?: ParsedTableLook;
+  indent?: ParsedTableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: ParsedTableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: ParsedTableFloating;
 }
 
 export interface ParsedTableRow {
@@ -94,6 +120,9 @@ export interface ParsedTableRow {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
 }
 
 export interface ParsedTableCell {
@@ -106,6 +135,11 @@ export interface ParsedTableCell {
   borders?: ParsedTableCellBorders;
   shading?: ParsedCellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: ParsedCellMargins;
+  cnfStyle?: string;
 }
 
 export function parseTablesFromDocumentXml(xml: string): ParsedTableDocument {
@@ -133,6 +167,13 @@ function parseTable(node: XmlElementNode, sourceXml: string): ParsedTable {
   const borders = propertiesNode ? readTableBorders(propertiesNode) : undefined;
   const cellMargins = propertiesNode ? readTableCellMargins(propertiesNode) : undefined;
   const tblLook = propertiesNode ? readTableLook(propertiesNode) : undefined;
+  const indent = propertiesNode ? readTableIndent(propertiesNode) : undefined;
+  const layoutMode = propertiesNode ? readTableLayoutMode(propertiesNode) : undefined;
+  const cellSpacing = propertiesNode ? readTableCellSpacing(propertiesNode) : undefined;
+  const caption = propertiesNode ? readTableCaption(propertiesNode) : undefined;
+  const description = propertiesNode ? readTableDescription(propertiesNode) : undefined;
+  const bidiVisual = propertiesNode ? readTableBidiVisual(propertiesNode) : undefined;
+  const floating = propertiesNode ? readTableFloating(propertiesNode) : undefined;
 
   return {
     type: "table",
@@ -146,6 +187,13 @@ function parseTable(node: XmlElementNode, sourceXml: string): ParsedTable {
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
     ...(tblLook ? { tblLook } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
   };
 }
 
@@ -154,6 +202,9 @@ function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
   const height = propertiesNode ? readRowHeight(propertiesNode) : undefined;
   const heightRule = propertiesNode ? readRowHeightRule(propertiesNode) : undefined;
   const isHeader = propertiesNode ? readRowIsHeader(propertiesNode) : undefined;
+  const cantSplit = propertiesNode ? readRowCantSplit(propertiesNode) : undefined;
+  const horizontalAlignment = propertiesNode ? readRowHorizontalAlignment(propertiesNode) : undefined;
+  const cnfStyle = propertiesNode ? readRowCnfStyle(propertiesNode) : undefined;
 
   return {
     ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
@@ -164,6 +215,9 @@ function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
   };
 }
 
@@ -179,6 +233,11 @@ function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
   const borders = propertiesNode ? readCellBorders(propertiesNode) : undefined;
   const shading = propertiesNode ? readCellShading(propertiesNode) : undefined;
   const verticalAlign = propertiesNode ? readCellVerticalAlign(propertiesNode) : undefined;
+  const textDirection = propertiesNode ? readCellTextDirection(propertiesNode) : undefined;
+  const noWrap = propertiesNode ? readCellNoWrap(propertiesNode) : undefined;
+  const fitText = propertiesNode ? readCellFitText(propertiesNode) : undefined;
+  const margins = propertiesNode ? readCellMargins(propertiesNode) : undefined;
+  const cnfStyle = propertiesNode ? readCellCnfStyle(propertiesNode) : undefined;
 
   return {
     ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
@@ -190,6 +249,11 @@ function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
   };
 }
 
@@ -606,6 +670,191 @@ export function readRowIsHeader(propertiesNode: XmlElementNode): boolean | undef
   return val !== "false" && val !== "0";
 }
 
+export function readTableIndent(propertiesNode: XmlElementNode): ParsedTableIndent | undefined {
+  const indentNode = findFirstChild(propertiesNode, "tblInd");
+  if (!indentNode) return undefined;
+  const valueRaw = indentNode.attributes["w:w"] ?? indentNode.attributes.w;
+  const value = valueRaw !== undefined ? Number.parseInt(valueRaw, 10) : 0;
+  if (!Number.isFinite(value)) return undefined;
+  const rawType = (indentNode.attributes["w:type"] ?? indentNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableIndent["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+export function readTableLayoutMode(propertiesNode: XmlElementNode): "fixed" | "autofit" | undefined {
+  const layoutNode = findFirstChild(propertiesNode, "tblLayout");
+  if (!layoutNode) return undefined;
+  const raw = (layoutNode.attributes["w:type"] ?? layoutNode.attributes.type ?? "").toLowerCase();
+  if (raw === "fixed") return "fixed";
+  if (raw === "autofit") return "autofit";
+  return undefined;
+}
+
+export function readTableCellSpacing(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
+  const spacingNode = findFirstChild(propertiesNode, "tblCellSpacing");
+  if (!spacingNode) return undefined;
+  const valueRaw = spacingNode.attributes["w:w"] ?? spacingNode.attributes.w;
+  const value = valueRaw !== undefined ? Number.parseInt(valueRaw, 10) : 0;
+  if (!Number.isFinite(value)) return undefined;
+  const rawType = (spacingNode.attributes["w:type"] ?? spacingNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableWidth["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+export function readTableCaption(propertiesNode: XmlElementNode): string | undefined {
+  const captionNode = findFirstChild(propertiesNode, "tblCaption");
+  if (!captionNode) return undefined;
+  return captionNode.attributes["w:val"] ?? captionNode.attributes.val;
+}
+
+export function readTableDescription(propertiesNode: XmlElementNode): string | undefined {
+  const descriptionNode = findFirstChild(propertiesNode, "tblDescription");
+  if (!descriptionNode) return undefined;
+  return descriptionNode.attributes["w:val"] ?? descriptionNode.attributes.val;
+}
+
+export function readTableBidiVisual(propertiesNode: XmlElementNode): boolean | undefined {
+  const bidiNode = findFirstChild(propertiesNode, "bidiVisual");
+  if (!bidiNode) return undefined;
+  const val = bidiNode.attributes["w:val"] ?? bidiNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readTableFloating(propertiesNode: XmlElementNode): ParsedTableFloating | undefined {
+  const tblpPrNode = findFirstChild(propertiesNode, "tblpPr");
+  const overlapNode = findFirstChild(propertiesNode, "tblOverlap");
+  if (!tblpPrNode && !overlapNode) return undefined;
+
+  const floating: ParsedTableFloating = {};
+
+  if (tblpPrNode) {
+    const attr = (name: string): string | undefined =>
+      tblpPrNode.attributes[`w:${name}`] ?? tblpPrNode.attributes[name];
+    const num = (raw: string | undefined): number | undefined => {
+      if (raw === undefined) return undefined;
+      const parsed = Number.parseInt(raw, 10);
+      return Number.isFinite(parsed) ? parsed : undefined;
+    };
+    const anchor = (raw: string | undefined): ParsedTableFloating["horizontalAnchor"] | undefined => {
+      if (raw === "margin" || raw === "page" || raw === "text") return raw;
+      return undefined;
+    };
+    const hAlign = (raw: string | undefined): ParsedTableFloating["horizontalAlign"] | undefined => {
+      if (raw === "left" || raw === "center" || raw === "right" || raw === "inside" || raw === "outside") return raw;
+      return undefined;
+    };
+    const vAlign = (raw: string | undefined): ParsedTableFloating["verticalAlign"] | undefined => {
+      if (raw === "top" || raw === "center" || raw === "bottom" || raw === "inside" || raw === "outside") return raw;
+      return undefined;
+    };
+
+    const hAnc = anchor(attr("horzAnchor"));
+    if (hAnc) floating.horizontalAnchor = hAnc;
+    const vAnc = anchor(attr("vertAnchor"));
+    if (vAnc) floating.verticalAnchor = vAnc;
+    const hA = hAlign(attr("tblpXSpec"));
+    if (hA) floating.horizontalAlign = hA;
+    const hOff = num(attr("tblpX"));
+    if (hOff !== undefined) floating.horizontalOffset = hOff;
+    const vA = vAlign(attr("tblpYSpec"));
+    if (vA) floating.verticalAlign = vA;
+    const vOff = num(attr("tblpY"));
+    if (vOff !== undefined) floating.verticalOffset = vOff;
+    const left = num(attr("leftFromText"));
+    if (left !== undefined) floating.leftFromText = left;
+    const right = num(attr("rightFromText"));
+    if (right !== undefined) floating.rightFromText = right;
+    const top = num(attr("topFromText"));
+    if (top !== undefined) floating.topFromText = top;
+    const bottom = num(attr("bottomFromText"));
+    if (bottom !== undefined) floating.bottomFromText = bottom;
+  }
+
+  if (overlapNode) {
+    const val = (overlapNode.attributes["w:val"] ?? overlapNode.attributes.val ?? "overlap").toLowerCase();
+    floating.overlap = val === "overlap";
+  }
+
+  return Object.keys(floating).length > 0 ? floating : undefined;
+}
+
+export function readRowCantSplit(propertiesNode: XmlElementNode): boolean | undefined {
+  const cantSplitNode = findFirstChild(propertiesNode, "cantSplit");
+  if (!cantSplitNode) return undefined;
+  const val = cantSplitNode.attributes["w:val"] ?? cantSplitNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readRowHorizontalAlignment(propertiesNode: XmlElementNode): "left" | "center" | "right" | undefined {
+  const jcNode = findFirstChild(propertiesNode, "jc");
+  if (!jcNode) return undefined;
+  const val = jcNode.attributes["w:val"] ?? jcNode.attributes.val;
+  if (val === "left" || val === "center" || val === "right") return val;
+  return undefined;
+}
+
+export function readRowCnfStyle(propertiesNode: XmlElementNode): string | undefined {
+  const cnfNode = findFirstChild(propertiesNode, "cnfStyle");
+  if (!cnfNode) return undefined;
+  return cnfNode.attributes["w:val"] ?? cnfNode.attributes.val;
+}
+
+export function readCellTextDirection(propertiesNode: XmlElementNode): "lrTb" | "tbRl" | "btLr" | undefined {
+  const dirNode = findFirstChild(propertiesNode, "textDirection");
+  if (!dirNode) return undefined;
+  const val = dirNode.attributes["w:val"] ?? dirNode.attributes.val;
+  if (val === "lrTb" || val === "tbRl" || val === "btLr") return val;
+  return undefined;
+}
+
+export function readCellNoWrap(propertiesNode: XmlElementNode): boolean | undefined {
+  const noWrapNode = findFirstChild(propertiesNode, "noWrap");
+  if (!noWrapNode) return undefined;
+  const val = noWrapNode.attributes["w:val"] ?? noWrapNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readCellFitText(propertiesNode: XmlElementNode): boolean | undefined {
+  const fitNode = findFirstChild(propertiesNode, "tcFitText");
+  if (!fitNode) return undefined;
+  const val = fitNode.attributes["w:val"] ?? fitNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readCellMargins(propertiesNode: XmlElementNode): ParsedCellMargins | undefined {
+  const marginsNode = findFirstChild(propertiesNode, "tcMar");
+  if (!marginsNode) return undefined;
+  const readSide = (name: string): number | undefined => {
+    const sideNode = findFirstChild(marginsNode, name);
+    if (!sideNode) return undefined;
+    const raw = sideNode.attributes["w:w"] ?? sideNode.attributes.w;
+    if (raw === undefined) return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  };
+  const top = readSide("top");
+  const bottom = readSide("bottom");
+  const left = readSide("start") ?? readSide("left");
+  const right = readSide("end") ?? readSide("right");
+  if (top === undefined && bottom === undefined && left === undefined && right === undefined) {
+    return undefined;
+  }
+  return {
+    ...(top !== undefined ? { top } : {}),
+    ...(bottom !== undefined ? { bottom } : {}),
+    ...(left !== undefined ? { left } : {}),
+    ...(right !== undefined ? { right } : {}),
+  };
+}
+
+export function readCellCnfStyle(propertiesNode: XmlElementNode): string | undefined {
+  const cnfNode = findFirstChild(propertiesNode, "cnfStyle");
+  if (!cnfNode) return undefined;
+  return cnfNode.attributes["w:val"] ?? cnfNode.attributes.val;
+}
+
 function parseBorderSpec(child: XmlElementNode): ParsedBorderSpec | undefined {
   const value = child.attributes["w:val"] ?? child.attributes.val;
   const sizeRaw = child.attributes["w:sz"] ?? child.attributes.sz;

package/src/legal/bookmarks.ts

@@ -254,6 +254,84 @@ export function resolveBookmarkFieldDependencies(
   return deps;
 }
 
+/**
+ * A.4 — detect duplicate bookmark ids in the canonical document.
+ *
+ * Walks the document in order and records every bookmarkStart. The first
+ * occurrence of each id keeps its original value; later occurrences are
+ * scheduled for re-keying to a fresh monotonically-increasing id above
+ * `max(existing numeric ids)` so newly-allocated ids never collide with
+ * any surviving original.
+ *
+ * Returns a plan the caller can use to mutate both bookmark nodes and
+ * every reference to them (PAGEREF / REF field instructions, hyperlink
+ * w:anchor, TOC entries). Each assignment is keyed by the start node's
+ * ordinal position so callers can walk the document a second time and
+ * apply the new id deterministically.
+ */
+export interface BookmarkRekeyAssignment {
+  /** Ordinal position of the bookmark_start within the pre-order walk. */
+  ordinal: number;
+  /** Original bookmark id as emitted by the source. */
+  oldId: string;
+  /** New id when a re-key was scheduled; undefined when the id is kept. */
+  newId?: string;
+}
+
+export interface BookmarkRekeyPlan {
+  assignments: readonly BookmarkRekeyAssignment[];
+  /** All ids that had ≥2 occurrences in the source. */
+  duplicatedIds: readonly string[];
+  /** New max id allocated by the plan (advisory for allocators). */
+  nextId: number;
+}
+
+export function detectDuplicateBookmarkIds(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): BookmarkRekeyPlan {
+  const root = "content" in document ? document.content : document;
+  const seenStarts = new Set<string>();
+  const duplicatedIds = new Set<string>();
+  let maxNumericId = 0;
+
+  const bookmarkStarts: Array<BookmarkStartNode> = [];
+
+  walkDocument(root, (node) => {
+    if (node.type === "bookmark_start") {
+      bookmarkStarts.push(node);
+      const parsed = Number.parseInt(node.bookmarkId, 10);
+      if (Number.isFinite(parsed)) {
+        maxNumericId = Math.max(maxNumericId, parsed);
+      }
+    }
+  });
+
+  const assignments: BookmarkRekeyAssignment[] = [];
+  let nextId = maxNumericId + 1;
+  for (let ordinal = 0; ordinal < bookmarkStarts.length; ordinal += 1) {
+    const start = bookmarkStarts[ordinal]!;
+    if (!seenStarts.has(start.bookmarkId)) {
+      seenStarts.add(start.bookmarkId);
+      assignments.push({ ordinal, oldId: start.bookmarkId });
+      continue;
+    }
+    duplicatedIds.add(start.bookmarkId);
+    const fresh = String(nextId);
+    nextId += 1;
+    assignments.push({
+      ordinal,
+      oldId: start.bookmarkId,
+      newId: fresh,
+    });
+  }
+
+  return {
+    assignments,
+    duplicatedIds: [...duplicatedIds].sort(),
+    nextId,
+  };
+}
+
 function walkDocument(node: DocumentNode, visit: (node: DocumentNode) => void): void {
   visit(node);
 

package/src/model/canonical-document.ts

@@ -372,6 +372,17 @@ export interface ParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  /**
+   * Preserved w14 extension identifiers for this paragraph.
+   * Round-trip (§2 A.7) requires these to survive import → export so the
+   * `w14:paraId` / `w14:textId` attributes that Word places on paragraph
+   * and run boundaries are re-emitted with the same values. Both ids are
+   * 8-hex uppercase strings per ECMA-376 Part 1 Appendix A.
+   */
+  wordExtensionIds?: {
+    paraId?: string;
+    textId?: string;
+  };
   children: InlineNode[];
 }
 
@@ -405,6 +416,25 @@ export interface TableWidth {
   type: "dxa" | "auto" | "pct" | "nil";
 }
 
+export interface TableIndent {
+  value: number;
+  type: "dxa" | "auto" | "pct" | "nil";
+}
+
+export interface TableFloatingProperties {
+  horizontalAnchor?: "margin" | "page" | "text";
+  verticalAnchor?: "margin" | "page" | "text";
+  horizontalAlign?: "left" | "center" | "right" | "inside" | "outside";
+  horizontalOffset?: number;
+  verticalAlign?: "top" | "center" | "bottom" | "inside" | "outside";
+  verticalOffset?: number;
+  leftFromText?: number;
+  rightFromText?: number;
+  topFromText?: number;
+  bottomFromText?: number;
+  overlap?: boolean;
+}
+
 export interface CellShading {
   fill?: string;
   color?: string;
@@ -470,6 +500,13 @@ export interface TableNode {
   borders?: TableBorders;
   cellMargins?: TableCellMargins;
   tblLook?: TableLook;
+  indent?: TableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: TableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: TableFloatingProperties;
 }
 
 export interface TableRowNode {
@@ -483,6 +520,9 @@ export interface TableRowNode {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
 }
 
 export interface TableCellNode {
@@ -495,6 +535,11 @@ export interface TableCellNode {
   borders?: TableCellBorders;
   shading?: CellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: TableCellMargins;
+  cnfStyle?: string;
 }
 
 export interface SdtCheckboxState {

package/src/review/store/scope-tag-diff.ts

@@ -0,0 +1,130 @@
+import type { ScopeTagTouch } from "../../api/public-types.ts";
+import type {
+  CanonicalAnchor,
+  CommentThread,
+  RevisionRecord,
+} from "../../model/canonical-document.ts";
+
+/**
+ * Diff prior vs next review state and emit one `ScopeTagTouch` per changed
+ * comment or revision anchor. The predicted-text lane consumes these touches
+ * to classify a text command's ack as `equivalent` (no touches), `adjusted`
+ * (anchors shifted), or to feed decoration redraws without a PM rebuild.
+ *
+ * Notes
+ *  - Newly created annotations show up as "extended" (revisions) or "split"
+ *    (comments) so the lane knows to redraw them.
+ *  - Detached annotations show up as "detached".
+ *  - Anchors whose range is byte-identical across the diff are omitted.
+ */
+export function collectScopeTagTouches(
+  priorComments: Readonly<Record<string, CommentThread>>,
+  nextComments: Readonly<Record<string, CommentThread>>,
+  priorRevisions: Readonly<Record<string, RevisionRecord>>,
+  nextRevisions: Readonly<Record<string, RevisionRecord>>,
+): ScopeTagTouch[] {
+  const touches: ScopeTagTouch[] = [];
+
+  for (const [id, prior] of Object.entries(priorComments)) {
+    const next = nextComments[id];
+    if (!next) {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior: "detached",
+        range: anchorRange(prior.anchor),
+      });
+      continue;
+    }
+    const behavior = classifyAnchorChange(prior.anchor, next.anchor);
+    if (behavior !== "unchanged") {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior,
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, next] of Object.entries(nextComments)) {
+    if (!priorComments[id]) {
+      touches.push({
+        tagType: "comment",
+        tagId: id,
+        behavior: "split",
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, prior] of Object.entries(priorRevisions)) {
+    const next = nextRevisions[id];
+    if (!next) {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior: "detached",
+        range: anchorRange(prior.anchor),
+      });
+      continue;
+    }
+    const behavior = classifyAnchorChange(prior.anchor, next.anchor);
+    if (behavior !== "unchanged") {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior,
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  for (const [id, next] of Object.entries(nextRevisions)) {
+    if (!priorRevisions[id]) {
+      touches.push({
+        tagType: "revision",
+        tagId: id,
+        behavior: "extended",
+        range: anchorRange(next.anchor),
+      });
+    }
+  }
+
+  return touches;
+}
+
+function anchorRange(anchor: CanonicalAnchor): { from: number; to: number } {
+  if (anchor.kind === "range") {
+    return { from: anchor.range.from, to: anchor.range.to };
+  }
+  if (anchor.kind === "node") {
+    return { from: anchor.at, to: anchor.at };
+  }
+  return { from: anchor.lastKnownRange.from, to: anchor.lastKnownRange.to };
+}
+
+function classifyAnchorChange(
+  prior: CanonicalAnchor,
+  next: CanonicalAnchor,
+): "unchanged" | "extended" | "trimmed" | "split" | "detached" {
+  if (prior.kind === "detached" && next.kind === "detached") {
+    const pr = prior.lastKnownRange;
+    const nr = next.lastKnownRange;
+    return pr.from === nr.from && pr.to === nr.to ? "unchanged" : "detached";
+  }
+  if (prior.kind !== "detached" && next.kind === "detached") {
+    return "detached";
+  }
+  if (prior.kind === "detached" && next.kind !== "detached") {
+    return "extended";
+  }
+  const priorR = anchorRange(prior);
+  const nextR = anchorRange(next);
+  if (priorR.from === nextR.from && priorR.to === nextR.to) return "unchanged";
+  const priorLen = priorR.to - priorR.from;
+  const nextLen = nextR.to - nextR.from;
+  if (nextLen > priorLen) return "extended";
+  if (nextLen < priorLen) return "trimmed";
+  return "split";
+}

package/src/runtime/document-layout.ts

@@ -15,6 +15,7 @@ import type {
   SubPartsCatalog,
 } from "../model/canonical-document.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+import { resolveDefaultPageSizeTwips } from "./layout/default-page-format.ts";
 import {
   resolveSectionVariants,
   sectionSupportsStoryTarget,
@@ -88,9 +89,10 @@ export function buildPageLayoutSnapshot(
   properties: SectionProperties | undefined,
   subParts: SubPartsCatalog | undefined,
 ): PageLayoutSnapshot {
+  const defaultSize = resolveDefaultPageSizeTwips();
   const pageSize = properties?.pageSize ?? {
-    width: 12240,
-    height: 15840,
+    width: defaultSize.widthTwips,
+    height: defaultSize.heightTwips,
     orientation: "portrait" as const,
   };
   const margins = properties?.pageMargins ?? {