@beyondwork/docx-react-component 1.0.120 → 1.0.121

package/dist/api/public-types.cjs

@@ -1185,7 +1185,7 @@ function parseTextStory(content) {
 function countLogicalPositions(units) {
   let size = 0;
   for (const unit of units) {
-    if (unit.kind !== "scope_marker") size += 1;
+    size += unitLogicalSize(unit);
   }
   return size;
 }
@@ -1245,7 +1245,29 @@ function flattenInlineNodes(nodes, hyperlinkHref) {
         });
         break;
       case "hyperlink":
-        units.push(...flattenInlineNodes(node.children, node.href));
+        units.push({
+          kind: "protected_inline",
+          node: structuredClone(node),
+          logicalSize: inlineLogicalLength(node),
+          reason: "hyperlink"
+        });
+        break;
+      case "field":
+        units.push({
+          kind: "protected_inline",
+          node: structuredClone(node),
+          logicalSize: inlineLogicalLength(node),
+          reason: "field"
+        });
+        break;
+      case "bookmark_start":
+      case "bookmark_end":
+        units.push({
+          kind: "protected_inline",
+          node: structuredClone(node),
+          logicalSize: 0,
+          reason: "bookmark"
+        });
         break;
       case "image":
         units.push({
@@ -1279,6 +1301,32 @@ function flattenInlineNodes(nodes, hyperlinkHref) {
   }
   return units;
 }
+function unitLogicalSize(unit) {
+  switch (unit.kind) {
+    case "scope_marker":
+      return 0;
+    case "protected_inline":
+      return unit.logicalSize;
+    default:
+      return 1;
+  }
+}
+function inlineLogicalLength(node) {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "hyperlink":
+    case "field":
+      return node.children.reduce((total, child) => total + inlineLogicalLength(child), 0);
+    case "bookmark_start":
+    case "bookmark_end":
+    case "scope_marker_start":
+    case "scope_marker_end":
+      return 0;
+    default:
+      return 1;
+  }
+}
 function extractParagraphProperties(paragraph) {
   return {
     ...paragraph.styleId ? { styleId: paragraph.styleId } : {},
@@ -2473,7 +2521,19 @@ function createHeaderFooterStoryKey(input) {
 function createNoteStoryKey(kind, noteId) {
   return `${kind}:${noteId}`;
 }
-function collectEditableTargetRefs(doc) {
+function collectCanonicalLayoutInputs(doc) {
+  const blockContexts = collectStoryBlockContexts(doc);
+  return {
+    stories: collectCanonicalStoryIdentities(doc),
+    fieldRegions: collectCanonicalFieldRegionIdentities(doc),
+    numbering: collectCanonicalNumberingLayoutInputs(doc, blockContexts),
+    tables: collectCanonicalTableLayoutInputs(blockContexts),
+    anchors: collectCanonicalAnchorLayoutInputs(doc, blockContexts),
+    scopes: collectCanonicalScopeLayoutInputs(blockContexts),
+    editableTargets: collectEditableTargetRefs(doc)
+  };
+}
+function collectEditableTargetRefs(doc, cache) {
   const targets = [];
   for (const context of collectStoryBlockContexts(doc)) {
     collectEditableTargetsInBlocks(
@@ -2485,17 +2545,53 @@ function collectEditableTargetRefs(doc) {
         insideTextBox: false,
         tableDepth: 0
       },
-      targets
+      targets,
+      cache
     );
   }
+  collectFieldRegionRefreshTargets(doc, targets);
+  collectBookmarkContentRangeTargets(doc, targets);
   collectReviewEditableTargets(doc, targets);
   return targets;
 }
-function collectEditableTargetsInBlocks(blocks, context, targets) {
+function buildBlockCacheSignature(context, blockIndex) {
+  const cc = context.contentControl;
+  const tt = context.tableTarget;
+  const owner = tt?.editableOwnersByChildIndex?.get(blockIndex);
+  return [
+    context.storyKey,
+    context.insideSdt ? "1" : "0",
+    context.insideTextBox ? "1" : "0",
+    String(context.tableDepth),
+    cc?.sdtId ?? "",
+    cc?.tag ?? "",
+    cc?.alias ?? "",
+    cc?.sdtType ?? "",
+    cc?.lock ?? "",
+    tt?.tablePath ?? "",
+    tt?.tableDepth ?? "",
+    tt?.rowIndex ?? "",
+    tt?.cellIndex ?? "",
+    tt?.gridColumnStart ?? "",
+    tt?.cell?.verticalMerge ?? "",
+    tt?.cell?.gridSpan ?? "",
+    owner?.targetKey ?? ""
+  ].join("|");
+}
+function collectEditableTargetsInBlocks(blocks, context, targets, cache) {
   for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
     const block = blocks[blockIndex];
     if (!block) continue;
     const blockPath = `${context.basePath}/block[${blockIndex}]`;
+    const signature = cache !== void 0 ? buildBlockCacheSignature(context, blockIndex) : "";
+    if (cache !== void 0) {
+      const cached = cache.get(block);
+      if (cached !== void 0 && cached.blockPath === blockPath && cached.signature === signature) {
+        for (const target of cached.targets) targets.push(target);
+        continue;
+      }
+    }
+    const blockStart = targets.length;
     if (block.type === "paragraph") {
       const targetKind = editableParagraphTargetKind(context);
       if (targetKind !== null) {
@@ -2507,14 +2603,13 @@ function collectEditableTargetsInBlocks(blocks, context, targets) {
             blockPath,
             editableParagraphTargetPosture(targetKind),
             context.contentControl,
-            context.tableTarget
+            context.tableTarget,
+            context.tableTarget?.editableOwnersByChildIndex?.get(blockIndex)
           )
         );
       }
       collectEditableTargetsInInlines(block.children ?? [], `${blockPath}/inline`, context, targets);
-      continue;
-    }
-    if (block.type === "sdt") {
+    } else if (block.type === "sdt") {
       const contentControl = contentControlIdentityForSdt(block, context.contentControl);
       collectEditableTargetsInBlocks(
         block.children,
@@ -2524,11 +2619,10 @@ function collectEditableTargetsInBlocks(blocks, context, targets) {
           insideSdt: true,
           contentControl
         },
-        targets
+        targets,
+        cache
       );
-      continue;
-    }
-    if (block.type === "custom_xml") {
+    } else if (block.type === "custom_xml") {
       targets.push(createCustomXmlEditableTarget(block, context.storyKey, blockPath));
       collectEditableTargetsInBlocks(
         block.children,
@@ -2536,25 +2630,29 @@ function collectEditableTargetsInBlocks(blocks, context, targets) {
           ...context,
           basePath: blockPath
         },
-        targets
+        targets,
+        cache
       );
-      continue;
-    }
-    if (block.type === "opaque_block") {
+    } else if (block.type === "opaque_block") {
       targets.push(createOpaqueBlockEditableTarget(block, context.storyKey, blockPath));
-      continue;
-    }
-    if (block.type === "alt_chunk") {
+    } else if (block.type === "alt_chunk") {
       targets.push(createAltChunkEditableTarget(block.relationshipId, context.storyKey, blockPath));
-      continue;
-    }
-    if (block.type === "table") {
-      collectEditableTargetsInTable(block, blockPath, context, targets);
+    } else if (block.type === "table") {
+      collectEditableTargetsInTable(block, blockPath, context, targets, cache);
+    }
+    if (cache !== void 0) {
+      const blockTargets = targets.slice(blockStart);
+      cache.set(block, {
+        blockPath,
+        signature,
+        targets: blockTargets
+      });
     }
   }
 }
-function collectEditableTargetsInTable(table, tablePath, context, targets) {
+function collectEditableTargetsInTable(table, tablePath, context, targets, cache) {
   const tableDepth = context.tableDepth + 1;
+  const verticalMergeOwners = [];
   targets.push(createTableStructureTarget({
     scope: "table",
     kind: "table-structure-table",
@@ -2593,6 +2691,10 @@ function collectEditableTargetsInTable(table, tablePath, context, targets) {
       const cell = row.cells[cellIndex];
       if (!cell) continue;
       const gridSpan = cell.gridSpan ?? 1;
+      const continuationOwner = cell.verticalMerge === "continue" ? findVerticalMergeOwner(verticalMergeOwners, gridColumnStart, gridSpan) : null;
+      if (cell.verticalMerge !== "continue") {
+        clearVerticalMergeOwners(verticalMergeOwners, gridColumnStart, gridSpan);
+      }
       targets.push(createTableStructureTarget({
         scope: "cell",
         kind: "table-structure-cell",
@@ -2635,15 +2737,136 @@ function collectEditableTargetsInTable(table, tablePath, context, targets) {
             row,
             cellIndex,
             cell,
-            gridColumnStart
+            gridColumnStart,
+            ...continuationOwner ? {
+              editableOwnersByChildIndex: continuationOwnerTargetsByChildIndex(
+                continuationOwner,
+                cell.children.length
+              )
+            } : {}
           }
         },
-        targets
+        targets,
+        cache
       );
+      if (cell.verticalMerge === "restart") {
+        verticalMergeOwners.push(createVerticalMergeOwnerState({
+          context,
+          table,
+          tablePath,
+          tableDepth,
+          rowIndex,
+          row,
+          cellIndex,
+          cell,
+          gridColumnStart,
+          gridSpan
+        }));
+      }
       gridColumnStart += gridSpan;
     }
   }
 }
+function findVerticalMergeOwner(owners, gridColumnStart, gridSpan) {
+  return owners.find(
+    (owner) => owner.gridColumnStart === gridColumnStart && owner.gridSpan === gridSpan
+  ) ?? null;
+}
+function clearVerticalMergeOwners(owners, gridColumnStart, gridSpan) {
+  const gridColumnEnd = gridColumnStart + gridSpan;
+  for (let index = owners.length - 1; index >= 0; index -= 1) {
+    const owner = owners[index];
+    if (!owner) continue;
+    const ownerEnd = owner.gridColumnStart + owner.gridSpan;
+    if (gridColumnStart < ownerEnd && owner.gridColumnStart < gridColumnEnd) {
+      owners.splice(index, 1);
+    }
+  }
+}
+function continuationOwnerTargetsByChildIndex(owner, childCount) {
+  if (!owner.fallbackOwnerTarget) return void 0;
+  const targets = /* @__PURE__ */ new Map();
+  for (let childIndex = 0; childIndex < childCount; childIndex += 1) {
+    targets.set(
+      childIndex,
+      owner.ownerTargetsByChildIndex.get(childIndex) ?? owner.fallbackOwnerTarget
+    );
+  }
+  return targets;
+}
+function createVerticalMergeOwnerState(input) {
+  const ownerTargetsByChildIndex = /* @__PURE__ */ new Map();
+  for (let childIndex = 0; childIndex < input.cell.children.length; childIndex += 1) {
+    const owner = createVerticalMergeEditableOwner({ ...input, childIndex });
+    if (owner) ownerTargetsByChildIndex.set(childIndex, owner);
+  }
+  return {
+    gridColumnStart: input.gridColumnStart,
+    gridSpan: input.gridSpan,
+    ownerTargetsByChildIndex,
+    ...ownerTargetsByChildIndex.size > 0 ? { fallbackOwnerTarget: ownerTargetsByChildIndex.values().next().value } : {}
+  };
+}
+function createVerticalMergeEditableOwner(input) {
+  const child = input.cell.children[input.childIndex];
+  if (child?.type !== "paragraph") return null;
+  const ownerTableTarget = {
+    table: input.table,
+    tablePath: input.tablePath,
+    tableDepth: input.tableDepth,
+    rowIndex: input.rowIndex,
+    row: input.row,
+    cellIndex: input.cellIndex,
+    cell: input.cell,
+    gridColumnStart: input.gridColumnStart
+  };
+  const kind = editableParagraphTargetKind({
+    ...input.context,
+    basePath: `${input.tablePath}/row[${input.rowIndex}]/cell[${input.cellIndex}]`,
+    tableDepth: input.tableDepth,
+    tableTarget: ownerTableTarget
+  });
+  if (!kind) return null;
+  const blockPath = `${input.tablePath}/row[${input.rowIndex}]/cell[${input.cellIndex}]/block[${input.childIndex}]`;
+  const paragraphTextHash = hashText(collectParagraphText(child));
+  const table = createTableIdentity({
+    scope: "text",
+    context: {
+      storyKey: input.context.storyKey,
+      insideSdt: input.context.contentControl !== void 0
+    },
+    ...ownerTableTarget
+  });
+  return {
+    targetKey: `${input.context.storyKey}:${blockPath}:text`,
+    kind,
+    storyKey: input.context.storyKey,
+    blockPath,
+    leafPath: `${blockPath}/inline`,
+    commandFamily: "text-leaf",
+    reason: "vertical-merge-restart-cell",
+    canonicalAddress: ownerRoutingFromAddress(
+      createTableTargetCanonicalAddress(
+        table,
+        "paragraph",
+        paragraphTextHash,
+        { rangeBoundary: { boundaryKind: "cell-fragment" } }
+      )
+    ),
+    table: {
+      tableKey: table.tableKey,
+      tablePath: table.tablePath,
+      ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
+      ...table.rowSourceRef !== void 0 ? { rowSourceRef: table.rowSourceRef } : {},
+      ...table.cellSourceRef !== void 0 ? { cellSourceRef: table.cellSourceRef } : {},
+      ...table.rowIndex !== void 0 ? { rowIndex: table.rowIndex } : {},
+      ...table.cellIndex !== void 0 ? { cellIndex: table.cellIndex } : {},
+      ...table.gridColumnStart !== void 0 ? { gridColumnStart: table.gridColumnStart } : {},
+      ...table.gridSpan !== void 0 ? { gridSpan: table.gridSpan } : {},
+      ...table.verticalMerge !== void 0 ? { verticalMerge: table.verticalMerge } : {}
+    }
+  };
+}
 function computeTableStructureColumnCount(table) {
   let columnCount = table.gridColumns.length;
   for (const row of table.rows) {
@@ -2663,6 +2886,7 @@ function createTableStructureTarget(input) {
   const columnPath = input.columnIndex !== void 0 ? `${input.tablePath}/column[${input.columnIndex}]` : void 0;
   const blockPath = cellPath ?? rowPath ?? columnPath ?? input.tablePath;
   const tableIdentity = createTableIdentity(input);
+  const targetHash = hashTableStructureTarget(input);
   return {
     targetKey: `${tableKey}:structure:${tableIdentity.operationScope}${tableTargetSuffix(tableIdentity)}`,
     kind: input.kind,
@@ -2674,8 +2898,14 @@ function createTableStructureTarget(input) {
     ...input.table.sourceRef !== void 0 ? { sourceRef: input.table.sourceRef } : {},
     ...input.context.contentControl !== void 0 ? { contentControl: input.context.contentControl } : {},
     table: tableIdentity,
+    canonicalAddress: createTableTargetCanonicalAddress(
+      tableIdentity,
+      tableStructureBlockType(input.scope),
+      targetHash,
+      { rangeBoundary: { boundaryKind: "table-grid" } }
+    ),
     staleCheck: {
-      targetHash: hashTableStructureTarget(input),
+      targetHash,
       childCount: input.scope === "table" ? input.table.rows.length : input.scope === "row" ? input.row?.cells.length ?? 0 : input.scope === "cell" || input.scope === "span" ? input.cell?.children.length ?? 0 : computeTableStructureColumnCount(input.table),
       blockType: tableStructureBlockType(input.scope),
       ...input.table.sourceRef !== void 0 ? { sourceRef: input.table.sourceRef } : {}
@@ -2686,10 +2916,15 @@ function createTableStructureTarget(input) {
 function createTableIdentity(input) {
   const tableKey = `${input.context.storyKey}:${input.tablePath}`;
   const columnCount = computeTableStructureColumnCount(input.table);
+  const rowRange = tableFragmentRowRange(input).rowRange;
+  const columnRange = tableFragmentColumnRange(input, columnCount).columnRange;
   const base = {
     operationScope: input.scope,
     tableKey,
     tablePath: input.tablePath,
+    ...input.table.sourceRef !== void 0 ? { sourceRef: input.table.sourceRef } : {},
+    ...input.row?.sourceRef !== void 0 ? { rowSourceRef: input.row.sourceRef } : {},
+    ...input.cell?.sourceRef !== void 0 ? { cellSourceRef: input.cell.sourceRef } : {},
     ...tablePathIndexes(input.tablePath),
     tableDepth: input.tableDepth,
     ...input.tableDepth >= 2 ? { nestedTable: true } : {},
@@ -2697,7 +2932,10 @@ function createTableIdentity(input) {
     ...input.context.storyKey !== MAIN_STORY_KEY ? { secondaryStory: true } : {},
     rowCount: input.table.rows.length,
     columnCount,
-    fragment: createTableFragmentIdentity(input, tableKey, columnCount)
+    fragment: createTableFragmentIdentity(input, tableKey, columnCount),
+    ...input.cell !== void 0 ? {
+      cellFragment: createTableCellFragmentIdentity(input, tableKey, rowRange, columnRange)
+    } : {}
   };
   return {
     ...base,
@@ -2711,6 +2949,25 @@ function createTableIdentity(input) {
     ...input.cell !== void 0 ? { blockCount: input.cell.children.length } : {}
   };
 }
+function createTableCellFragmentIdentity(input, tableKey, rowRange, columnRange) {
+  const text = (input.cell?.children ?? []).map(blockTextForTargetHash).join("");
+  return {
+    fragmentKey: hashText(JSON.stringify({
+      tableKey,
+      rowIndex: input.rowIndex ?? null,
+      cellIndex: input.cellIndex ?? null,
+      gridColumnStart: input.gridColumnStart ?? null,
+      gridSpan: input.cell?.gridSpan ?? 1,
+      verticalMerge: input.cell?.verticalMerge ?? null,
+      sourceId: input.cell?.sourceRef?.sourceId ?? null
+    })),
+    textHash: hashText(text),
+    blockCount: input.cell?.children.length ?? 0,
+    ...rowRange !== void 0 ? { rowRange } : {},
+    ...columnRange !== void 0 ? { columnRange } : {},
+    ...sourceJoinHashForRefs(input.table.sourceRef, input.row?.sourceRef, input.cell?.sourceRef)
+  };
+}
 function tablePathIndexes(tablePath) {
   const blockIndexes = [...tablePath.matchAll(/\/block\[(\d+)\]/gu)].map((match) => Number(match[1]));
   const storyBlockIndex = blockIndexes[0];
@@ -2876,13 +3133,39 @@ function collectEditableTargetsInInlines(inlines, basePath, context, targets) {
     }
   }
 }
-function createParagraphEditableTarget(paragraph, kind, storyKey, blockPath, targetPosture = { editability: "editable", posture: { blockers: [] } }, contentControl, tableTarget) {
+function createParagraphEditableTarget(paragraph, kind, storyKey, blockPath, targetPosture = { editability: "editable", posture: { blockers: [] } }, contentControl, tableTarget, editableOwner) {
   const paragraphText = collectParagraphText(paragraph);
+  const paragraphTextHash = hashText(paragraphText);
   const sourceRef = paragraph.sourceRef;
   const lockedContentControl = contentControlLocksContent(contentControl);
-  const posture = lockedContentControl ? mergeTargetPosture(targetPosture.posture, ["locked-content-control"], {
+  const syntheticLayoutCell = tableTarget?.cell?.verticalMerge === "continue";
+  const tableIdentity = tableTarget !== void 0 ? createTableIdentity({
+    scope: "text",
+    context: { storyKey, insideSdt: contentControl !== void 0 },
+    ...tableTarget
+  }) : void 0;
+  const listAddress = tableIdentity === void 0 && paragraph.numbering !== void 0 ? createCanonicalAddress({
+    addressKind: "list-item-text",
+    storyKey,
+    staleCheckKind: "paragraph",
+    operationScope: "list-text",
+    sourceRefs: [sourceRef],
+    staleHash: paragraphTextHash,
+    rangeBoundary: { boundaryKind: "list-item-text" },
+    discriminator: {
+      blockPath,
+      numberingInstanceId: paragraph.numbering.numberingInstanceId,
+      level: paragraph.numbering.level,
+      sourceId: sourceRef?.sourceId ?? null,
+      paraId: paragraph.wordExtensionIds?.paraId ?? null,
+      textId: paragraph.wordExtensionIds?.textId ?? null
+    }
+  }) : void 0;
+  const tableAwarePosture = syntheticLayoutCell ? mergeTargetPosture(targetPosture.posture, ["synthetic-layout-cell"]) : targetPosture.posture;
+  const posture = lockedContentControl ? mergeTargetPosture(tableAwarePosture, ["locked-content-control"], {
     lockedContentControl: true
-  }) : targetPosture.posture;
+  }) : tableAwarePosture;
+  const editability = lockedContentControl || syntheticLayoutCell ? "non-editable" : targetPosture.editability;
   return {
     targetKey: `${storyKey}:${blockPath}:text`,
     kind,
@@ -2890,12 +3173,24 @@ function createParagraphEditableTarget(paragraph, kind, storyKey, blockPath, tar
     blockPath,
     leafPath: `${blockPath}/inline`,
     commandFamily: "text-leaf",
-    editability: lockedContentControl ? "non-editable" : targetPosture.editability,
+    editability,
     ...sourceRef !== void 0 ? { sourceRef } : {},
     ...contentControl !== void 0 ? { contentControl } : {},
-    ...tableTarget !== void 0 ? { table: createTableIdentity({ scope: "text", context: { storyKey, insideSdt: contentControl !== void 0 }, ...tableTarget }) } : {},
+    ...tableIdentity !== void 0 ? { table: tableIdentity } : {},
+    ...editableOwner !== void 0 ? { editableOwner } : {},
+    ...tableIdentity !== void 0 ? {
+      canonicalAddress: createTableTargetCanonicalAddress(
+        tableIdentity,
+        "paragraph",
+        paragraphTextHash,
+        {
+          rangeBoundary: { boundaryKind: "cell-fragment" },
+          owner: editableOwner?.canonicalAddress
+        }
+      )
+    } : listAddress !== void 0 ? { canonicalAddress: listAddress } : {},
     staleCheck: {
-      paragraphTextHash: hashText(paragraphText),
+      paragraphTextHash,
       paragraphTextLength: Array.from(paragraphText).length,
       inlineCount: paragraph.children?.length ?? 0,
       blockType: "paragraph",
@@ -2926,12 +3221,27 @@ function collectInlineTarget(inline, storyKey, inlinePath, targets) {
       return;
     case "hyperlink":
       targets.push(createHyperlinkEditableTarget(inline, storyKey, inlinePath));
+      targets.push(createHyperlinkDestinationEditableTarget(inline, storyKey, inlinePath));
       return;
     case "bookmark_start":
-      targets.push(createBookmarkEditableTarget(inline.bookmarkId, inline.name, storyKey, inlinePath, "start"));
+      targets.push(createBookmarkEditableTarget(
+        inline.bookmarkId,
+        inline.name,
+        storyKey,
+        inlinePath,
+        "start",
+        inline.sourceRef
+      ));
       return;
     case "bookmark_end":
-      targets.push(createBookmarkEditableTarget(inline.bookmarkId, void 0, storyKey, inlinePath, "end"));
+      targets.push(createBookmarkEditableTarget(
+        inline.bookmarkId,
+        void 0,
+        storyKey,
+        inlinePath,
+        "end",
+        inline.sourceRef
+      ));
       return;
     case "image":
       targets.push(createImageEditableTarget(inline, storyKey, inlinePath));
@@ -2955,6 +3265,7 @@ function collectInlineTarget(inline, storyKey, inlinePath, targets) {
 function createFieldEditableTarget(field, storyKey, inlinePath) {
   const resultText = field.children.map(inlineTextForTargetHash).join("");
   const sourceRef = field.sourceRef;
+  const targetHash = hashText(`${field.instruction}\0${resultText}`);
   const preserveOnly = field.refreshStatus === "preserve-only" || field.fieldFamily === "UNKNOWN";
   const blockers = preserveOnly ? ["field-generated-text", "preserve-only"] : ["field-generated-text", "unmodeled-target"];
   return {
@@ -2974,9 +3285,28 @@ function createFieldEditableTarget(field, storyKey, inlinePath) {
       ...field.locked !== void 0 ? { locked: field.locked } : {},
       ...field.dirty !== void 0 ? { dirty: field.dirty } : {}
     },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: "field-result",
+      storyKey,
+      staleCheckKind: "field",
+      operationScope: "field-refresh",
+      sourceRefs: [sourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "field-result",
+        from: 0,
+        to: Array.from(resultText).length
+      },
+      discriminator: {
+        canonicalFieldId: field.canonicalFieldId ?? null,
+        fieldFamily: field.fieldFamily ?? null,
+        fieldTarget: field.fieldTarget ?? null,
+        sourceId: sourceRef?.sourceId ?? null
+      }
+    }),
     staleCheck: {
       blockType: "field",
-      targetHash: hashText(`${field.instruction}\0${resultText}`),
+      targetHash,
       targetTextLength: Array.from(resultText).length,
       childCount: field.children.length,
       ...sourceRef !== void 0 ? { sourceRef } : {}
@@ -2990,6 +3320,7 @@ function createFieldEditableTarget(field, storyKey, inlinePath) {
 function createHyperlinkEditableTarget(hyperlink, storyKey, inlinePath) {
   const text = hyperlink.children.map(inlineTextForTargetHash).join("");
   const sourceRef = hyperlink.sourceRef ?? hyperlink.fieldCarrier?.sourceRef;
+  const targetHash = hashText(`${hyperlink.href}\0${text}`);
   return {
     targetKey: `${storyKey}:${inlinePath}:hyperlink`,
     kind: "hyperlink-text",
@@ -3000,9 +3331,25 @@ function createHyperlinkEditableTarget(hyperlink, storyKey, inlinePath) {
     editability: "editable",
     ...sourceRef !== void 0 ? { sourceRef } : {},
     link: { href: hyperlink.href },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: "hyperlink-display-text",
+      storyKey,
+      staleCheckKind: "hyperlink",
+      sourceRefs: [sourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "hyperlink-display",
+        from: 0,
+        to: Array.from(text).length
+      },
+      discriminator: {
+        href: hyperlink.href,
+        sourceId: sourceRef?.sourceId ?? null
+      }
+    }),
     staleCheck: {
       blockType: "hyperlink",
-      targetHash: hashText(`${hyperlink.href}\0${text}`),
+      targetHash,
       targetTextLength: Array.from(text).length,
       childCount: hyperlink.children.length,
       ...sourceRef !== void 0 ? { sourceRef } : {}
@@ -3010,7 +3357,52 @@ function createHyperlinkEditableTarget(hyperlink, storyKey, inlinePath) {
     posture: { blockers: [] }
   };
 }
-function createBookmarkEditableTarget(bookmarkId, bookmarkName, storyKey, inlinePath, edge) {
+function createHyperlinkDestinationEditableTarget(hyperlink, storyKey, inlinePath) {
+  const sourceRef = hyperlink.sourceRef ?? hyperlink.fieldCarrier?.sourceRef;
+  const destinationKind = hyperlink.href.startsWith("#") ? "internal-anchor" : "external";
+  const targetHash = hashText(`destination\0${hyperlink.href}`);
+  return {
+    targetKey: `${storyKey}:${inlinePath}:hyperlink-destination`,
+    kind: "hyperlink-destination",
+    storyKey,
+    blockPath: inlinePath,
+    leafPath: `${inlinePath}/destination`,
+    commandFamily: "link-bookmark",
+    editability: "non-editable",
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    link: {
+      href: hyperlink.href,
+      destinationKind
+    },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: "hyperlink-destination",
+      storyKey,
+      staleCheckKind: "hyperlink",
+      operationScope: "link-destination",
+      sourceRefs: [sourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "hyperlink-destination",
+        ...sourceRef !== void 0 ? { startSourceJoinHash: sourceJoinHash([sourceRef]) } : {},
+        ...sourceRef !== void 0 ? { endSourceJoinHash: sourceJoinHash([sourceRef]) } : {}
+      },
+      discriminator: {
+        href: hyperlink.href,
+        destinationKind,
+        sourceId: sourceRef?.sourceId ?? null
+      }
+    }),
+    staleCheck: {
+      blockType: "hyperlink",
+      targetHash,
+      childCount: hyperlink.children.length,
+      ...sourceRef !== void 0 ? { sourceRef } : {}
+    },
+    posture: { blockers: ["unmodeled-target"] }
+  };
+}
+function createBookmarkEditableTarget(bookmarkId, bookmarkName, storyKey, inlinePath, edge, sourceRef) {
+  const targetHash = hashText(`${edge}\0${bookmarkId}\0${bookmarkName ?? ""}`);
   return {
     targetKey: `${storyKey}:${inlinePath}:bookmark:${edge}:${bookmarkId}`,
     kind: "bookmark-anchor",
@@ -3019,14 +3411,34 @@ function createBookmarkEditableTarget(bookmarkId, bookmarkName, storyKey, inline
     leafPath: inlinePath,
     commandFamily: "link-bookmark",
     editability: "non-editable",
+    ...sourceRef !== void 0 ? { sourceRef } : {},
     link: {
       bookmarkId,
       ...bookmarkName !== void 0 ? { bookmarkName } : {}
     },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: "bookmark-anchor",
+      storyKey,
+      staleCheckKind: "bookmark",
+      sourceRefs: [sourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "bookmark-anchor",
+        ...sourceRef !== void 0 ? { startSourceJoinHash: sourceJoinHash([sourceRef]) } : {},
+        ...sourceRef !== void 0 ? { endSourceJoinHash: sourceJoinHash([sourceRef]) } : {}
+      },
+      discriminator: {
+        bookmarkId,
+        bookmarkName: bookmarkName ?? null,
+        edge,
+        sourceId: sourceRef?.sourceId ?? null
+      }
+    }),
     staleCheck: {
       blockType: "bookmark",
-      targetHash: hashText(`${edge}\0${bookmarkId}\0${bookmarkName ?? ""}`),
-      childCount: 0
+      targetHash,
+      childCount: 0,
+      ...sourceRef !== void 0 ? { sourceRef } : {}
     },
     posture: { blockers: ["unmodeled-target"] }
   };
@@ -3074,6 +3486,7 @@ function createObjectEditableTarget(inline, storyKey, inlinePath) {
       storyKey,
       inlinePath,
       objectKind: "ole",
+      sourceRef: inline.sourceRef,
       targetHash: `${inline.id}\0${inline.relationshipId}`,
       object: {
         objectKind: "ole",
@@ -3195,6 +3608,167 @@ function createOpaqueEditableTarget(input) {
     }
   };
 }
+function collectFieldRegionRefreshTargets(doc, targets) {
+  for (const region of collectCanonicalFieldRegionIdentities(doc)) {
+    targets.push(createFieldRegionRefreshEditableTarget(region));
+  }
+}
+function createFieldRegionRefreshEditableTarget(region) {
+  const isToc = region.kind === "toc-region" || region.fieldFamily === "TOC";
+  const sourceRef = region.sourceRef;
+  const targetHash = hashText(JSON.stringify({
+    regionId: region.regionId,
+    canonicalFieldId: region.canonicalFieldId,
+    fieldFamily: region.fieldFamily,
+    refreshStatus: region.refreshStatus,
+    tocId: region.tocId ?? null,
+    resultRange: region.resultRange ?? null,
+    status: region.status ?? null
+  }));
+  return {
+    targetKey: `${region.storyKey}:field-region:${region.regionId}:refresh`,
+    kind: isToc ? "toc-region-refresh" : "field-region-refresh",
+    storyKey: region.storyKey,
+    blockPath: `${region.storyKey}/field-region[${region.regionId}]`,
+    leafPath: `${region.storyKey}/field-region[${region.regionId}]/refresh`,
+    commandFamily: "field",
+    editability: "non-editable",
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    field: {
+      canonicalFieldId: region.canonicalFieldId,
+      regionId: region.regionId,
+      fieldFamily: region.fieldFamily,
+      refreshStatus: region.refreshStatus,
+      ...region.sourcePath !== void 0 ? { sourcePath: region.sourcePath } : {},
+      ...region.tocId !== void 0 ? { tocId: region.tocId } : {},
+      ...region.resultRange !== void 0 ? {
+        resultRangeFromParagraphIndex: region.resultRange.fromParagraphIndex,
+        resultRangeToParagraphIndex: region.resultRange.toParagraphIndex
+      } : {},
+      ...region.status !== void 0 ? { status: region.status } : {},
+      ...region.cachedEntryCount !== void 0 ? { cachedEntryCount: region.cachedEntryCount } : {},
+      ...region.generatedEntryCount !== void 0 ? { generatedEntryCount: region.generatedEntryCount } : {}
+    },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: isToc ? "toc-region-refresh" : "field-region-refresh",
+      storyKey: region.storyKey,
+      staleCheckKind: "field",
+      operationScope: isToc ? "toc-refresh" : "field-refresh",
+      sourceRefs: [sourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "field-region",
+        ...region.resultRange !== void 0 ? {
+          from: region.resultRange.fromParagraphIndex,
+          to: region.resultRange.toParagraphIndex
+        } : { from: region.paragraphIndex, to: region.paragraphIndex }
+      },
+      discriminator: {
+        regionId: region.regionId,
+        canonicalFieldId: region.canonicalFieldId,
+        fieldIndex: region.fieldIndex,
+        fieldFamily: region.fieldFamily,
+        tocId: region.tocId ?? null
+      }
+    }),
+    staleCheck: {
+      blockType: "field",
+      targetHash,
+      childCount: region.cachedEntryCount ?? 0,
+      ...sourceRef !== void 0 ? { sourceRef } : {}
+    },
+    posture: {
+      blockers: ["field-generated-text", "unmodeled-target"]
+    }
+  };
+}
+function collectBookmarkContentRangeTargets(doc, targets) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const context of collectStoryBlockContexts(doc)) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      inline(inline, _blockPath, inlinePath) {
+        if (inline.type !== "bookmark_start" && inline.type !== "bookmark_end") return;
+        const key = `${context.storyKey}:${inline.bookmarkId}`;
+        const previous = candidates.get(key);
+        if (inline.type === "bookmark_start") {
+          candidates.set(key, {
+            ...previous ?? { storyKey: context.storyKey, bookmarkId: inline.bookmarkId },
+            bookmarkName: inline.name,
+            startPath: inlinePath,
+            startSourceRef: inline.sourceRef
+          });
+          return;
+        }
+        candidates.set(key, {
+          ...previous ?? { storyKey: context.storyKey, bookmarkId: inline.bookmarkId },
+          endPath: inlinePath,
+          endSourceRef: inline.sourceRef
+        });
+      }
+    });
+  }
+  for (const candidate of candidates.values()) {
+    if (candidate.startPath === void 0 || candidate.endPath === void 0) continue;
+    targets.push(createBookmarkContentRangeEditableTarget({
+      ...candidate,
+      startPath: candidate.startPath,
+      endPath: candidate.endPath
+    }));
+  }
+}
+function createBookmarkContentRangeEditableTarget(candidate) {
+  const startSourceJoinHash = sourceJoinHash([candidate.startSourceRef]);
+  const endSourceJoinHash = sourceJoinHash([candidate.endSourceRef]);
+  const rangeKey = hashText(JSON.stringify({
+    storyKey: candidate.storyKey,
+    bookmarkId: candidate.bookmarkId,
+    bookmarkName: candidate.bookmarkName ?? null,
+    startSourceId: candidate.startSourceRef?.sourceId ?? null,
+    endSourceId: candidate.endSourceRef?.sourceId ?? null
+  }));
+  const targetHash = hashText(`range\0${candidate.bookmarkId}\0${candidate.bookmarkName ?? ""}\0${candidate.startPath}\0${candidate.endPath}`);
+  return {
+    targetKey: `${candidate.storyKey}:bookmark:${candidate.bookmarkId}:content-range`,
+    kind: "bookmark-content-range",
+    storyKey: candidate.storyKey,
+    blockPath: `${candidate.storyKey}/bookmark[${candidate.bookmarkId}]`,
+    leafPath: `${candidate.storyKey}/bookmark[${candidate.bookmarkId}]/content-range`,
+    commandFamily: "link-bookmark",
+    editability: "non-editable",
+    ...candidate.startSourceRef !== void 0 ? { sourceRef: candidate.startSourceRef } : {},
+    link: {
+      bookmarkId: candidate.bookmarkId,
+      ...candidate.bookmarkName !== void 0 ? { bookmarkName: candidate.bookmarkName } : {},
+      rangeKey
+    },
+    canonicalAddress: createCanonicalAddress({
+      addressKind: "bookmark-content-range",
+      storyKey: candidate.storyKey,
+      staleCheckKind: "bookmark",
+      operationScope: "bookmark-range",
+      sourceRefs: [candidate.startSourceRef, candidate.endSourceRef],
+      staleHash: targetHash,
+      rangeBoundary: {
+        boundaryKind: "bookmark-content",
+        ...startSourceJoinHash !== void 0 ? { startSourceJoinHash } : {},
+        ...endSourceJoinHash !== void 0 ? { endSourceJoinHash } : {}
+      },
+      discriminator: {
+        bookmarkId: candidate.bookmarkId,
+        bookmarkName: candidate.bookmarkName ?? null,
+        startSourceId: candidate.startSourceRef?.sourceId ?? null,
+        endSourceId: candidate.endSourceRef?.sourceId ?? null
+      }
+    }),
+    staleCheck: {
+      blockType: "bookmark",
+      targetHash,
+      childCount: 2,
+      ...candidate.startSourceRef !== void 0 ? { sourceRef: candidate.startSourceRef } : {}
+    },
+    posture: { blockers: ["unmodeled-target"] }
+  };
+}
 function inlineObjectKind(inline) {
   switch (inline.type) {
     case "chart_preview":
@@ -3317,6 +3891,16 @@ function collectParagraphText(paragraph) {
   }
   return text;
 }
+function blockTextForTargetHash(block) {
+  if (block.type === "paragraph") return collectParagraphText(block);
+  if (block.type === "sdt" || block.type === "custom_xml") {
+    return block.children.map(blockTextForTargetHash).join("");
+  }
+  if (block.type === "table") {
+    return block.rows.flatMap((row) => row.cells).flatMap((cell) => cell.children).map(blockTextForTargetHash).join("");
+  }
+  return "";
+}
 function inlineTextForTargetHash(inline) {
   if (inline.type === "text") return inline.text;
   if (inline.type === "symbol") return inline.char;
@@ -3332,6 +3916,225 @@ function inlineTextForTargetHash(inline) {
   }
   return "";
 }
+function createTableTargetCanonicalAddress(table, staleCheckKind, staleHash, resolver = {}) {
+  return createCanonicalAddress({
+    addressKind: "table-target",
+    storyKey: tableStoryKey(table),
+    staleCheckKind,
+    operationScope: table.operationScope,
+    rowRange: table.fragment?.rowRange,
+    columnRange: table.fragment?.columnRange,
+    sourceRefs: [table.sourceRef, table.rowSourceRef, table.cellSourceRef],
+    staleHash,
+    ...resolver,
+    discriminator: {
+      operationScope: table.operationScope,
+      tableDepth: table.tableDepth,
+      rowIndex: table.rowIndex ?? null,
+      columnIndex: table.columnIndex ?? null,
+      cellIndex: table.cellIndex ?? null,
+      gridColumnStart: table.gridColumnStart ?? null,
+      gridSpan: table.gridSpan ?? null,
+      verticalMerge: table.verticalMerge ?? null,
+      sourceId: table.sourceRef?.sourceId ?? null,
+      rowSourceId: table.rowSourceRef?.sourceId ?? null,
+      cellSourceId: table.cellSourceRef?.sourceId ?? null
+    },
+    secondaryStory: table.secondaryStory,
+    nestedTable: table.nestedTable,
+    insideSdt: table.insideSdt
+  });
+}
+function tableStoryKey(table) {
+  const suffix = `:${table.tablePath}`;
+  return table.tableKey.endsWith(suffix) ? table.tableKey.slice(0, -suffix.length) : MAIN_STORY_KEY;
+}
+function createCanonicalAddress(input) {
+  const sourceHash = sourceJoinHash(input.sourceRefs ?? []);
+  const payload = {
+    addressKind: input.addressKind,
+    storyKey: input.storyKey,
+    operationScope: input.operationScope ?? null,
+    rowRange: input.rowRange ?? null,
+    columnRange: input.columnRange ?? null,
+    sourceHash: sourceHash ?? null,
+    discriminator: input.discriminator
+  };
+  return {
+    addressKey: `editable-address:${hashText(JSON.stringify(payload))}`,
+    addressKind: input.addressKind,
+    storyKey: input.storyKey,
+    staleCheckKind: input.staleCheckKind,
+    ...input.operationScope !== void 0 ? { operationScope: input.operationScope } : {},
+    ...input.rowRange !== void 0 ? { rowRange: input.rowRange } : {},
+    ...input.columnRange !== void 0 ? { columnRange: input.columnRange } : {},
+    ...sourceHash !== void 0 ? { sourceJoinHash: sourceHash } : {},
+    ...input.secondaryStory === true ? { secondaryStory: true } : {},
+    ...input.nestedTable === true ? { nestedTable: true } : {},
+    ...input.insideSdt === true ? { insideSdt: true } : {},
+    resolver: {
+      staleHash: input.staleHash,
+      ...sourceHash !== void 0 ? { sourceJoinHash: sourceHash } : {},
+      ...input.rowRange !== void 0 ? { rowRange: input.rowRange } : {},
+      ...input.columnRange !== void 0 ? { columnRange: input.columnRange } : {},
+      ...input.rangeBoundary !== void 0 ? { rangeBoundary: input.rangeBoundary } : {},
+      ...input.owner !== void 0 ? { owner: input.owner } : {}
+    }
+  };
+}
+function ownerRoutingFromAddress(address) {
+  return {
+    addressKey: address.addressKey,
+    addressKind: address.addressKind,
+    storyKey: address.storyKey,
+    ...address.operationScope !== void 0 ? { operationScope: address.operationScope } : {},
+    ...address.sourceJoinHash !== void 0 ? { sourceJoinHash: address.sourceJoinHash } : {},
+    staleHash: address.resolver?.staleHash ?? "",
+    ...address.rowRange !== void 0 ? { rowRange: address.rowRange } : {},
+    ...address.columnRange !== void 0 ? { columnRange: address.columnRange } : {}
+  };
+}
+function sourceJoinHashForRefs(...refs) {
+  const sourceHash = sourceJoinHash(refs);
+  return sourceHash === void 0 ? {} : { sourceJoinHash: sourceHash };
+}
+function sourceJoinHash(refs) {
+  const sourceIds = refs.map((ref) => ref?.sourceId).filter((sourceId) => sourceId !== void 0);
+  if (sourceIds.length === 0) return void 0;
+  return hashText(sourceIds.join("\0"));
+}
+function collectCanonicalStoryIdentities(doc) {
+  const stories = [
+    {
+      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 !== void 0 ? { sectionIndex: header.sectionIndex } : {}
+      }),
+      kind: "header",
+      blockCount: header.blocks.length,
+      variant: header.variant,
+      relationshipId: header.relationshipId,
+      partPath: header.partPath,
+      ...header.sectionIndex !== void 0 ? { 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 !== void 0 ? { sectionIndex: footer.sectionIndex } : {}
+      }),
+      kind: "footer",
+      blockCount: footer.blocks.length,
+      variant: footer.variant,
+      relationshipId: footer.relationshipId,
+      partPath: footer.partPath,
+      ...footer.sectionIndex !== void 0 ? { 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;
+}
+function collectCanonicalNumberingLayoutInputs(doc, contexts = collectStoryBlockContexts(doc)) {
+  const inputs = [];
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      paragraph(paragraph, blockPath) {
+        const styleNumbering = paragraph.numbering === void 0 && paragraph.styleId !== void 0 ? resolveParagraphStyleNumbering(doc, paragraph.styleId) : void 0;
+        const numbering = paragraph.numbering ?? styleNumbering;
+        if (numbering === void 0) {
+          return;
+        }
+        const instance = doc.numbering.instances[numbering.numberingInstanceId];
+        const abstractDefinition = instance?.abstractNumberingId === void 0 ? void 0 : doc.numbering.abstractDefinitions[instance.abstractNumberingId];
+        inputs.push({
+          numberingKey: `${context.storyKey}:${blockPath}:numbering`,
+          storyKey: context.storyKey,
+          blockPath,
+          paragraphIndex: blockIndexFromPath(blockPath),
+          ...paragraph.sourceRef !== void 0 ? { sourceRef: paragraph.sourceRef } : {},
+          ...paragraph.numbering?.sourceRef !== void 0 ? { numberingSourceRef: paragraph.numbering.sourceRef } : {},
+          numberingOrigin: paragraph.numbering === void 0 ? "paragraph-style" : "paragraph",
+          ...paragraph.numbering === void 0 && paragraph.styleId !== void 0 ? { paragraphStyleId: paragraph.styleId } : {},
+          numberingInstanceId: numbering.numberingInstanceId,
+          ...instance?.sourceRef !== void 0 ? { numberingInstanceSourceRef: instance.sourceRef } : {},
+          ...instance?.abstractNumberingId !== void 0 ? { abstractNumberingId: instance.abstractNumberingId } : {},
+          ...abstractDefinition?.sourceRef !== void 0 ? { abstractNumberingSourceRef: abstractDefinition.sourceRef } : {},
+          level: numbering.level ?? 0
+        });
+      }
+    });
+  }
+  return inputs;
+}
+function resolveParagraphStyleNumbering(doc, styleId) {
+  const visited = /* @__PURE__ */ new Set();
+  let currentStyleId = styleId;
+  while (currentStyleId !== void 0 && !visited.has(currentStyleId)) {
+    visited.add(currentStyleId);
+    const style = doc.styles.paragraphs[currentStyleId];
+    if (style === void 0) {
+      return void 0;
+    }
+    if (style.numbering !== void 0) {
+      return style.numbering;
+    }
+    currentStyleId = style.basedOn;
+  }
+  return void 0;
+}
 function collectCanonicalFieldRegionIdentities(doc) {
   const registry = doc.fieldRegistry;
   const byFieldIndex = new Map(
@@ -3457,6 +4260,42 @@ function blockIndexFromPath(blockPath) {
   const last = matches.at(-1);
   return last ? Number.parseInt(last[1], 10) : 0;
 }
+function collectCanonicalTableLayoutInputs(contexts) {
+  const tables = [];
+  for (const context of contexts) {
+    walkBlocks(context.blocks, context.storyKey, context.basePath, {
+      table(table, blockPath) {
+        tables.push(projectTableLayoutInput(table, context.storyKey, blockPath));
+      }
+    });
+  }
+  return tables;
+}
+function collectCanonicalAnchorLayoutInputs(doc, contexts = collectStoryBlockContexts(doc)) {
+  const anchors = [];
+  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;
+}
+function collectCanonicalScopeLayoutInputs(contexts) {
+  const scopes = [];
+  for (const context of contexts) {
+    scopes.push(...collectScopeLayoutInputsForStory(context));
+  }
+  return scopes.sort((left, right) => left.scopeKey.localeCompare(right.scopeKey));
+}
 function collectStoryBlockContexts(doc) {
   const contexts = [
     { storyKey: MAIN_STORY_KEY, blocks: doc.content.children, basePath: "main" }
@@ -3529,7 +4368,7 @@ function walkBlocks(blocks, storyKey, basePath, visitor) {
     }
     if (block.type === "paragraph") {
       visitor.paragraph?.(block, blockPath);
-      walkInlines(block.children, storyKey, blockPath, `${blockPath}/inline`, visitor);
+      walkInlines(block.children ?? [], storyKey, blockPath, `${blockPath}/inline`, visitor);
       continue;
     }
     if (block.type === "sdt" || block.type === "custom_xml") {
@@ -3556,6 +4395,393 @@ function walkInlines(inlines, storyKey, blockPath, basePath, visitor) {
     }
   }
 }
+function projectTableLayoutInput(table, storyKey, blockPath) {
+  const tableKey = `${storyKey}:${blockPath}`;
+  const rows = table.rows.map(
+    (row, rowIndex) => projectTableRowLayoutInput(row, tableKey, rowIndex)
+  );
+  return {
+    tableKey,
+    storyKey,
+    blockPath,
+    ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
+    ...table.styleId !== void 0 ? { styleId: table.styleId } : {},
+    rowCount: table.rows.length,
+    columnCount: table.gridColumns.length,
+    gridColumns: [...table.gridColumns],
+    ...table.width !== void 0 ? { width: table.width } : {},
+    ...table.alignment !== void 0 ? { alignment: table.alignment } : {},
+    ...table.borders !== void 0 ? { borders: table.borders } : {},
+    ...table.cellMargins !== void 0 ? { cellMargins: table.cellMargins } : {},
+    ...table.tblLook !== void 0 ? { tblLook: table.tblLook } : {},
+    ...table.indent !== void 0 ? { indent: table.indent } : {},
+    ...table.layoutMode !== void 0 ? { layoutMode: table.layoutMode } : {},
+    ...table.cellSpacing !== void 0 ? { cellSpacing: table.cellSpacing } : {},
+    ...table.bidiVisual !== void 0 ? { bidiVisual: table.bidiVisual } : {},
+    ...table.floating !== void 0 ? { floating: table.floating } : {},
+    rows
+  };
+}
+function projectTableRowLayoutInput(row, tableKey, rowIndex) {
+  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,
+    ...row.sourceRef !== void 0 ? { sourceRef: row.sourceRef } : {},
+    rowIndex,
+    cellCount: row.cells.length,
+    ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
+    ...row.widthBefore !== void 0 ? { widthBefore: row.widthBefore } : {},
+    ...row.gridAfter !== void 0 ? { gridAfter: row.gridAfter } : {},
+    ...row.widthAfter !== void 0 ? { widthAfter: row.widthAfter } : {},
+    ...row.height !== void 0 ? { height: row.height } : {},
+    ...row.heightRule !== void 0 ? { heightRule: row.heightRule } : {},
+    ...row.isHeader !== void 0 ? { isHeader: row.isHeader } : {},
+    ...row.cantSplit !== void 0 ? { cantSplit: row.cantSplit } : {},
+    ...row.horizontalAlignment !== void 0 ? { horizontalAlignment: row.horizontalAlignment } : {},
+    ...row.cnfStyle !== void 0 ? { cnfStyle: row.cnfStyle } : {},
+    cells
+  };
+}
+function projectTableCellLayoutInput(cell, rowKey, rowIndex, cellIndex, gridColumnStart) {
+  const gridSpan = cell.gridSpan ?? 1;
+  return {
+    cellKey: `${rowKey}:cell[${cellIndex}]`,
+    ...cell.sourceRef !== void 0 ? { sourceRef: cell.sourceRef } : {},
+    rowIndex,
+    cellIndex,
+    gridColumnStart,
+    gridSpan,
+    ...cell.verticalMerge !== void 0 ? { verticalMerge: cell.verticalMerge } : {},
+    ...cell.width !== void 0 ? { width: cell.width } : {},
+    ...cell.borders !== void 0 ? { borders: cell.borders } : {},
+    ...cell.shading !== void 0 ? { shading: cell.shading } : {},
+    ...cell.verticalAlign !== void 0 ? { verticalAlign: cell.verticalAlign } : {},
+    ...cell.textDirection !== void 0 ? { textDirection: cell.textDirection } : {},
+    ...cell.noWrap !== void 0 ? { noWrap: cell.noWrap } : {},
+    ...cell.fitText !== void 0 ? { fitText: cell.fitText } : {},
+    ...cell.margins !== void 0 ? { margins: cell.margins } : {},
+    ...cell.cnfStyle !== void 0 ? { cnfStyle: cell.cnfStyle } : {},
+    blockCount: cell.children.length
+  };
+}
+function projectAnchorLayoutInput(doc, inline, storyKey, blockPath, inlinePath) {
+  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, storyKey, blockPath, inlinePath) {
+  const anchor = node.anchor;
+  const content = node.content;
+  const shapeBlocks = content.type === "shape" ? content.txbxBlocks : void 0;
+  const objectKind = drawingContentKind(content);
+  const sourceRef = node.sourceRef ?? drawingContentSourceRef(content);
+  const objectKey = `${storyKey}:${inlinePath}`;
+  const textBoxBody = projectTextBoxBodyLayoutInput(content, objectKey, sourceRef, `${inlinePath}/txbx`);
+  return {
+    objectKey,
+    storyKey,
+    blockPath,
+    inlinePath,
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    objectKind,
+    editPosture: drawingEditPosture(node),
+    display: anchor.display,
+    extent: anchor.extent,
+    wrapMode: anchor.wrapMode,
+    ...anchor.wrapPolygon !== void 0 ? { wrapPolygonPointCount: anchor.wrapPolygon.length } : {},
+    ...anchor.positionH !== void 0 ? { positionH: anchor.positionH } : {},
+    ...anchor.positionV !== void 0 ? { positionV: anchor.positionV } : {},
+    ...anchor.distMargins !== void 0 ? { distMargins: anchor.distMargins } : {},
+    ...anchor.relativeHeight !== void 0 ? { relativeHeight: anchor.relativeHeight } : {},
+    ...anchor.behindDoc !== void 0 ? { zOrder: anchor.behindDoc ? "behind-document" : "in-front-of-text" } : {},
+    ...anchor.layoutInCell !== void 0 ? { layoutInCell: anchor.layoutInCell } : {},
+    ...anchor.allowOverlap !== void 0 ? { allowOverlap: anchor.allowOverlap } : {},
+    ...anchor.simplePos !== void 0 ? { simplePos: anchor.simplePos } : {},
+    ...anchor.docPr?.id !== void 0 ? { docPrId: anchor.docPr.id } : {},
+    ...anchor.docPr?.name !== void 0 ? { docPrName: anchor.docPr.name } : {},
+    ...anchor.docPr?.descr !== void 0 ? { docPrDescription: anchor.docPr.descr } : {},
+    ...anchor.docPr?.hidden !== void 0 ? { hidden: anchor.docPr.hidden } : {},
+    ...anchor.frameLocks !== void 0 ? { frameLocks: anchor.frameLocks } : {},
+    ...content.type === "picture" && content.mediaId !== void 0 ? { mediaId: content.mediaId } : {},
+    ...content.type === "picture" && content.packagePartName !== void 0 ? { packagePartName: content.packagePartName } : {},
+    ...content.type === "picture" ? { relationshipId: content.blipRef } : {},
+    ...content.type === "picture" && content.isLinked !== void 0 ? { isLinked: content.isLinked } : {},
+    ...shapeBlocks !== void 0 ? { hasTextBoxBlocks: true } : {},
+    ...shapeBlocks !== void 0 ? { textBoxBlockCount: shapeBlocks.length } : {},
+    ...textBoxBody !== void 0 ? { textBoxBody } : {},
+    rawXmlPreserved: content.type !== "picture" || content.rawXml !== void 0
+  };
+}
+function projectTextBoxBodyLayoutInput(content, objectKey, sourceRef, basePath) {
+  if (content.type !== "shape") return void 0;
+  if (!content.isTextBox && content.txbxContentXml === void 0 && content.txbxBlocks === void 0) {
+    return void 0;
+  }
+  const bodyKey = `${objectKey}:txbx`;
+  const blockCount = content.txbxBlocks?.length ?? 0;
+  if (content.txbxBlocks === void 0) {
+    return {
+      bodyKey,
+      ...sourceRef !== void 0 ? { sourceRef } : {},
+      status: content.txbxContentXml !== void 0 ? "preserve-only" : "unavailable",
+      unavailableReason: "txbx-blocks-unavailable",
+      ...content.textBoxBody !== void 0 ? { bodyProperties: content.textBoxBody } : {},
+      blockCount,
+      paragraphCount: 0,
+      unsupportedBlockCount: 0,
+      paragraphs: []
+    };
+  }
+  const paragraphs = content.txbxBlocks.flatMap(
+    (block, index) => block.type === "paragraph" ? [projectTextBoxParagraphLayoutInput(block, bodyKey, `${basePath}/block[${index}]`, index)] : []
+  );
+  const unsupportedBlockCount = content.txbxBlocks.length - paragraphs.length;
+  const unavailableReason = content.txbxBlocks.length === 0 ? "empty-body" : paragraphs.length === 0 ? "unsupported-content" : void 0;
+  return {
+    bodyKey,
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    status: unavailableReason === void 0 ? "modeled" : "unavailable",
+    ...unavailableReason !== void 0 ? { unavailableReason } : {},
+    ...content.textBoxBody !== void 0 ? { bodyProperties: content.textBoxBody } : {},
+    blockCount,
+    paragraphCount: paragraphs.length,
+    unsupportedBlockCount,
+    paragraphs
+  };
+}
+function projectTextBoxParagraphLayoutInput(paragraph, bodyKey, blockPath, blockIndex) {
+  const runs = paragraph.children.map(
+    (inline, inlineIndex) => projectTextBoxRunLayoutInput(inline, `${bodyKey}:block[${blockIndex}]`, inlineIndex)
+  );
+  const text = runs.map((run) => run.text ?? "").join("");
+  return {
+    paragraphKey: `${bodyKey}:block[${blockIndex}]`,
+    blockPath,
+    blockIndex,
+    ...paragraph.sourceRef !== void 0 ? { sourceRef: paragraph.sourceRef } : {},
+    ...paragraph.styleId !== void 0 ? { styleId: paragraph.styleId } : {},
+    ...paragraph.alignment !== void 0 ? { alignment: paragraph.alignment } : {},
+    ...paragraph.borders !== void 0 ? { borders: paragraph.borders } : {},
+    text,
+    textLength: Array.from(text).length,
+    runCount: runs.length,
+    runs
+  };
+}
+function projectTextBoxRunLayoutInput(inline, paragraphKey, inlineIndex) {
+  const runKey = `${paragraphKey}:inline[${inlineIndex}]`;
+  if (inline.type === "text") {
+    return {
+      runKey,
+      inlineIndex,
+      kind: "text",
+      text: inline.text,
+      textLength: Array.from(inline.text).length,
+      ...inline.marks !== void 0 ? { marks: inline.marks } : {}
+    };
+  }
+  if (inline.type === "tab") {
+    return { runKey, inlineIndex, kind: "tab", text: "	", textLength: 1 };
+  }
+  if (inline.type === "hard_break") {
+    return { runKey, inlineIndex, kind: "hard-break", text: "\n", textLength: 1 };
+  }
+  if (inline.type === "symbol") {
+    return {
+      runKey,
+      inlineIndex,
+      kind: "symbol",
+      text: inline.char,
+      textLength: Array.from(inline.char).length
+    };
+  }
+  return { runKey, inlineIndex, kind: "unsupported" };
+}
+function projectLegacyImageAnchor(doc, node, storyKey, blockPath, inlinePath) {
+  const media = doc.media.items[node.mediaId];
+  return {
+    objectKey: `${storyKey}:${inlinePath}`,
+    storyKey,
+    blockPath,
+    inlinePath,
+    objectKind: "legacy-image",
+    editPosture: "editable",
+    ...node.display !== void 0 ? { display: node.display } : {},
+    ...media?.widthEmu !== void 0 && media.heightEmu !== void 0 ? { extent: { widthEmu: media.widthEmu, heightEmu: media.heightEmu } } : {},
+    ...node.floating?.wrap !== void 0 ? { wrapMode: node.floating.wrap } : {},
+    ...node.floating?.horizontalPosition !== void 0 ? { positionH: normalizeFloatingAxis(node.floating.horizontalPosition) } : {},
+    ...node.floating?.verticalPosition !== void 0 ? { positionV: normalizeFloatingAxis(node.floating.verticalPosition) } : {},
+    ...node.floating?.behindDoc !== void 0 ? { zOrder: node.floating.behindDoc ? "behind-document" : "in-front-of-text" } : {},
+    ...node.floating?.layoutInCell !== void 0 ? { layoutInCell: node.floating.layoutInCell } : {},
+    ...node.floating?.allowOverlap !== void 0 ? { allowOverlap: node.floating.allowOverlap } : {},
+    mediaId: node.mediaId,
+    ...node.sourceRef !== void 0 ? { sourceRef: node.sourceRef } : {},
+    ...media?.packagePartName !== void 0 ? { packagePartName: media.packagePartName } : {},
+    ...media?.relationshipId !== void 0 ? { relationshipId: media.relationshipId } : {},
+    ...node.placementXml !== void 0 ? { rawXmlPreserved: true } : {}
+  };
+}
+function preserveOnlySourceRef(sourceId) {
+  return sourceId === void 0 ? void 0 : { sourceId };
+}
+function drawingContentSourceRef(content) {
+  if ("preserveOnlyObject" in content) {
+    return preserveOnlySourceRef(content.preserveOnlyObject?.sourceId);
+  }
+  return void 0;
+}
+function normalizeFloatingAxis(axis) {
+  return {
+    relativeFrom: axis?.relativeFrom ?? "",
+    ...axis?.align !== void 0 ? { align: axis.align } : {},
+    ...axis?.offset !== void 0 ? { offset: axis.offset } : {}
+  };
+}
+function drawingContentKind(content) {
+  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) {
+  if (node.content.type === "picture" && !node.content.isLinked) return "editable";
+  if (node.content.type === "opaque") return "preserve-only";
+  return "read-only-preview";
+}
+function collectScopeLayoutInputsForStory(context) {
+  const occurrences = [];
+  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 = /* @__PURE__ */ new Map();
+  const scopes = [];
+  for (const marker of occurrences) {
+    if (marker.markerType === "start") {
+      const stack2 = open.get(marker.scopeId) ?? [];
+      stack2.push(marker);
+      open.set(marker.scopeId, stack2);
+      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", void 0, marker));
+  }
+  for (const stack of open.values()) {
+    for (const opener of stack) {
+      scopes.push(createScopeLayoutInput(context.storyKey, "start-only", opener, void 0));
+    }
+  }
+  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, status, start, end) {
+  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 !== void 0 ? { start: createScopeMarkerReference(storyKey, start) } : {},
+    ...end !== void 0 ? { end: createScopeMarkerReference(storyKey, end) } : {}
+  };
+}
+function createScopeMarkerReference(storyKey, marker) {
+  return {
+    markerKey: `${storyKey}:scope-marker:${marker.scopeId}:${marker.markerIndex}`,
+    blockPath: marker.blockPath,
+    inlinePath: marker.inlinePath,
+    markerIndex: marker.markerIndex
+  };
+}
+function countSections(doc) {
+  let explicitBreaks = 0;
+  for (const block of doc.content.children) {
+    if (block.type === "section_break") explicitBreaks += 1;
+  }
+  return explicitBreaks + 1;
+}
+function collectHeaderFooterBindings(doc, kind, relationshipId, variant, fallbackSectionIndex, sectionCount) {
+  const bound = /* @__PURE__ */ new Set();
+  const explicit = /* @__PURE__ */ new Set();
+  const inherited = /* @__PURE__ */ new Set();
+  const effectiveByVariant = /* @__PURE__ */ new Map();
+  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 !== void 0) {
+    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) {
+  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, kind) {
+  return (kind === "header" ? properties?.headerReferences : properties?.footerReferences) ?? [];
+}
+function sortIndexes(indexes) {
+  return [...indexes].sort((left, right) => left - right);
+}
 
 // src/preservation/store.ts
 var BLOCKED_IMPORT_FEATURE_KEYS = /* @__PURE__ */ new Set([
@@ -5979,7 +7205,7 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
     ...options.getEffectiveMarkupMode ? { getEffectiveMarkupMode: options.getEffectiveMarkupMode } : {},
     ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
   });
-  const editableTargetsByBlockPath = indexEditableTargetsByBlockPath(document2);
+  const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document2);
   const activeStoryBlockPathBase = getActiveStoryBlockPathBase(document2, activeStory);
   chartModelStore.beginBuildPass(document2);
   const unsupportedNumberingFormatsSeen = options.emitFormattingTelemetry ? /* @__PURE__ */ new Set() : null;
@@ -6260,6 +7486,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
         from: cursor,
         to: innerCursor,
         styleId: table.styleId,
+        ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
         gridColumns: table.gridColumns,
         rows: []
       },
@@ -6329,6 +7556,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
         resolvedTable.table?.cellMargins
       );
       cells.push({
+        ...cell.sourceRef !== void 0 ? { sourceRef: cell.sourceRef } : {},
         gridSpan: cell.gridSpan ?? 1,
         verticalMerge: cell.verticalMerge ?? null,
         colspan: cell.gridSpan ?? 1,
@@ -6352,6 +7580,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
     }
     const headerLike = row.isHeader === true || resolvedRow?.style.isHeader === true;
     rows.push({
+      ...row.sourceRef !== void 0 ? { sourceRef: row.sourceRef } : {},
       cells,
       ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
       ...row.gridAfter !== void 0 ? { gridAfter: row.gridAfter } : {},
@@ -6382,6 +7611,7 @@ function createTableBlock(tableIndex, table, document2, cursor, counters, format
       from: cursor,
       to: innerCursor,
       styleId: table.styleId,
+      ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
       gridColumns: table.gridColumns,
       ...gridColumnsRelative ? { gridColumnsRelative } : {},
       ...resolvedTable.table?.alignment ? { alignment: resolvedTable.table.alignment } : {},
@@ -6926,6 +8156,7 @@ function appendInlineSegments(paragraph, node, document2, start, promoteSecondar
         const anchor = surfaceAnchorFromGeometry(node.anchor);
         const txbxTextSegment = c.isTextBox ? extractTxbxFirstTextSegment(c.txbxBlocks) : void 0;
         const txbxText = txbxTextSegment?.text ?? (c.isTextBox ? c.text : void 0);
+        const txbxBody = c.isTextBox ? surfaceTextBoxBodyFromShape(c, node.sourceRef) : void 0;
         const surfaceFill = c.fill;
         paragraph.segments.push({
           segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
@@ -6942,6 +8173,7 @@ function appendInlineSegments(paragraph, node, document2, start, promoteSecondar
           ...c.textBoxBody ? { textBoxBody: c.textBoxBody } : {},
           ...c.preserveOnlyObject ? { preserveOnlyObject: surfacePreserveOnlyObject(c.preserveOnlyObject) } : {},
           ...txbxText ? { txbxText } : {},
+          ...txbxBody ? { txbxBody } : {},
           ...txbxTextSegment?.marks && txbxTextSegment.marks.length > 0 ? { txbxMarks: txbxTextSegment.marks } : {},
           ...txbxTextSegment?.markAttrs ? { txbxMarkAttrs: txbxTextSegment.markAttrs } : {}
         });
@@ -7354,6 +8586,97 @@ function extractTxbxFirstTextSegment(blocks) {
   }
   return void 0;
 }
+function surfaceTextBoxBodyFromShape(shape, sourceRef) {
+  if (!shape.isTextBox && shape.txbxContentXml === void 0 && shape.txbxBlocks === void 0) {
+    return void 0;
+  }
+  if (shape.txbxBlocks === void 0) {
+    return {
+      ...sourceRef !== void 0 ? { sourceRef } : {},
+      status: shape.txbxContentXml !== void 0 ? "preserve-only" : "unavailable",
+      unavailableReason: "txbx-blocks-unavailable",
+      ...shape.textBoxBody !== void 0 ? { bodyProperties: shape.textBoxBody } : {},
+      blockCount: 0,
+      paragraphCount: 0,
+      unsupportedBlockCount: 0,
+      paragraphs: []
+    };
+  }
+  const paragraphs = shape.txbxBlocks.flatMap((block, blockIndex) => {
+    if (block.type !== "paragraph") return [];
+    const children = block.children;
+    const legacyRuns = block.runs;
+    const runs = children !== void 0 ? children.map(
+      (inline, inlineIndex) => surfaceTextBoxRunFromInline(inline, inlineIndex)
+    ) : legacyRuns?.map(
+      (run, inlineIndex) => surfaceTextBoxRunFromLegacyRun(run, inlineIndex)
+    ) ?? [];
+    const text = runs.map((run) => run.text ?? "").join("");
+    return [{
+      ...block.sourceRef !== void 0 ? { sourceRef: block.sourceRef } : {},
+      blockIndex,
+      text,
+      textLength: Array.from(text).length,
+      ...block.borders !== void 0 ? { borders: block.borders } : {},
+      runs
+    }];
+  });
+  const unsupportedBlockCount = shape.txbxBlocks.length - paragraphs.length;
+  const unavailableReason = shape.txbxBlocks.length === 0 ? "empty-body" : paragraphs.length === 0 ? "unsupported-content" : void 0;
+  return {
+    ...sourceRef !== void 0 ? { sourceRef } : {},
+    status: unavailableReason === void 0 ? "modeled" : "unavailable",
+    ...unavailableReason !== void 0 ? { unavailableReason } : {},
+    ...shape.textBoxBody !== void 0 ? { bodyProperties: shape.textBoxBody } : {},
+    blockCount: shape.txbxBlocks.length,
+    paragraphCount: paragraphs.length,
+    unsupportedBlockCount,
+    paragraphs
+  };
+}
+function surfaceTextBoxRunFromLegacyRun(run, inlineIndex) {
+  const text = run.text ?? "";
+  const cloned = run.marks ? cloneMarks2(run.marks) : void 0;
+  return {
+    inlineIndex,
+    kind: "text",
+    text,
+    textLength: Array.from(text).length,
+    ...cloned?.marks && cloned.marks.length > 0 ? { marks: cloned.marks } : {},
+    ...cloned?.markAttrs ? { markAttrs: cloned.markAttrs } : {}
+  };
+}
+function surfaceTextBoxRunFromInline(inline, inlineIndex) {
+  if (inline.type === "text") {
+    const cloned = inline.marks ? cloneMarks2(inline.marks) : void 0;
+    return {
+      inlineIndex,
+      kind: "text",
+      text: inline.text,
+      textLength: Array.from(inline.text).length,
+      ...cloned?.marks && cloned.marks.length > 0 ? { marks: cloned.marks } : {},
+      ...cloned?.markAttrs ? { markAttrs: cloned.markAttrs } : {}
+    };
+  }
+  if (inline.type === "tab") {
+    return { inlineIndex, kind: "tab", text: "	", textLength: 1 };
+  }
+  if (inline.type === "hard_break") {
+    return { inlineIndex, kind: "hard-break", text: "\n", textLength: 1 };
+  }
+  if (inline.type === "symbol") {
+    const cloned = inline.marks ? cloneMarks2(inline.marks) : void 0;
+    return {
+      inlineIndex,
+      kind: "symbol",
+      text: inline.char,
+      textLength: Array.from(inline.char).length,
+      ...cloned?.marks && cloned.marks.length > 0 ? { marks: cloned.marks } : {},
+      ...cloned?.markAttrs ? { markAttrs: cloned.markAttrs } : {}
+    };
+  }
+  return { inlineIndex, kind: "unsupported" };
+}
 function appendComplexPreviewSegment(paragraph, node, start, label, detail, extras = {}) {
   const preserveOnlyObject = node.preserveOnlyObject ? surfacePreserveOnlyObject(node.preserveOnlyObject) : void 0;
   paragraph.segments.push({
@@ -10485,6 +11808,7 @@ var PAGE_INSTANCE_FIELD_FAMILIES = /* @__PURE__ */ new Set([
   "NUMPAGES",
   "SECTIONPAGES"
 ]);
+var MAX_PAGE_LOCAL_STORY_PREVIEW_CHARS = 140;
 var EMUS_PER_TWIP = 635;
 function buildPageGraph(inputOrPages, sectionsArg, storiesArg) {
   const input = Array.isArray(inputOrPages) ? {
@@ -10797,6 +12121,8 @@ function buildPageLocalStoryInstance(frameId, pageId, pageIndex, sectionIndex, d
     layout,
     pageFieldCounts
   }) : [];
+  const previewParts = source ? collectPageLocalStoryPreviewParts(source.blocks, storyKey) : [];
+  const previewText = renderPageLocalStoryPreviewText(previewParts, resolvedFields);
   const objectLedger = source ? collectStoryAnchoredObjects(source.blocks, {
     frameId,
     storyKey,
@@ -10811,6 +12137,7 @@ function buildPageLocalStoryInstance(frameId, pageId, pageIndex, sectionIndex, d
     relationshipId: target.relationshipId,
     sectionPart,
     measuredFrameHeightTwips,
+    previewText,
     resolvedFields,
     anchoredObjects: objectLedger.objects
   });
@@ -10824,6 +12151,8 @@ function buildPageLocalStoryInstance(frameId, pageId, pageIndex, sectionIndex, d
       relationshipId: target.relationshipId,
       ...target.sectionIndex === void 0 ? {} : { sectionIndex: target.sectionIndex },
       resolvedFields,
+      previewText,
+      previewParts,
       anchoredObjects: objectLedger.objects,
       measuredFrameHeightTwips,
       signature
@@ -10839,6 +12168,7 @@ function buildPageLocalStorySignature(input) {
     input.relationshipId,
     input.sectionPart,
     input.measuredFrameHeightTwips,
+    input.previewText,
     ...input.resolvedFields.map(
       (field) => [field.fieldId, field.family, field.displayText].join(":")
     ),
@@ -10929,6 +12259,74 @@ function collectResolvedStoryFields(blocks, context) {
   for (const block of blocks) visitBlock(block);
   return fields;
 }
+function collectPageLocalStoryPreviewParts(blocks, storyKey) {
+  const parts = [];
+  let pageFieldOrdinal = 0;
+  const visitBlock = (block) => {
+    switch (block.type) {
+      case "paragraph":
+        for (const child of block.children) visitInline(child);
+        parts.push({ kind: "text", text: " " });
+        break;
+      case "table":
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            for (const childBlock of cell.children) visitBlock(childBlock);
+          }
+        }
+        break;
+      case "sdt":
+        for (const child of block.children) visitBlock(child);
+        break;
+      default:
+        break;
+    }
+  };
+  const visitInline = (inline) => {
+    switch (inline.type) {
+      case "text":
+        parts.push({ kind: "text", text: inline.text });
+        break;
+      case "tab":
+      case "hard_break":
+        parts.push({ kind: "text", text: " " });
+        break;
+      case "field": {
+        const family = inline.fieldFamily ?? classifyFieldInstructionLocal2(inline.instruction);
+        const fallbackText = flattenInline2(inline.children);
+        if (PAGE_INSTANCE_FIELD_FAMILIES.has(family)) {
+          parts.push({
+            kind: "field",
+            fieldId: `${storyKey}:field-${pageFieldOrdinal}:${family}`,
+            fallbackText
+          });
+          pageFieldOrdinal += 1;
+        } else {
+          parts.push({ kind: "text", text: fallbackText });
+        }
+        break;
+      }
+      case "hyperlink":
+        for (const child of inline.children) visitInline(child);
+        break;
+      default:
+        break;
+    }
+  };
+  for (const block of blocks) visitBlock(block);
+  return parts;
+}
+function renderPageLocalStoryPreviewText(parts, resolvedFields) {
+  const fieldsById = new Map(resolvedFields.map((field) => [field.fieldId, field]));
+  const text = parts.map(
+    (part) => part.kind === "field" ? fieldsById.get(part.fieldId)?.displayText ?? part.fallbackText : part.text
+  ).join("").replace(/\s+/g, " ").trim();
+  return truncatePageLocalStoryPreview(text);
+}
+function truncatePageLocalStoryPreview(text) {
+  if (text.length <= MAX_PAGE_LOCAL_STORY_PREVIEW_CHARS) return text;
+  return `${text.slice(0, MAX_PAGE_LOCAL_STORY_PREVIEW_CHARS - 1).trimEnd()}\u2026`;
+}
 function collectStoryAnchoredObjects(blocks, context) {
   const objects = [];
   const divergences = [];
@@ -11329,6 +12727,7 @@ function freezeRuntimePageGraph(graph) {
   for (const page of graph.pages) {
     freezePageNode(page);
   }
+  for (const fragment of graph.fragments) freezeBlockFragment(fragment);
   Object.freeze(graph.pages);
   Object.freeze(graph.fragments);
   Object.freeze(graph.anchors);
@@ -11343,6 +12742,64 @@ function freezePageNode(page) {
   Object.freeze(page.noteAllocations);
   Object.freeze(page);
 }
+function freezeBlockFragment(fragment) {
+  if (fragment.layoutObject) {
+    Object.freeze(fragment.layoutObject.measuredExtentTwips);
+    if (fragment.layoutObject.fieldFamilies) Object.freeze(fragment.layoutObject.fieldFamilies);
+    if (fragment.layoutObject.fieldRegions) {
+      for (const region of fragment.layoutObject.fieldRegions) {
+        if (region.resultRange) Object.freeze(region.resultRange);
+        if (region.sourceRef) Object.freeze(region.sourceRef);
+        if (region.fieldEvidence?.sourceRef) Object.freeze(region.fieldEvidence.sourceRef);
+        if (region.fieldEvidence) Object.freeze(region.fieldEvidence);
+        Object.freeze(region);
+      }
+      Object.freeze(fragment.layoutObject.fieldRegions);
+    }
+    if (fragment.layoutObject.bookmarkRanges) {
+      for (const range of fragment.layoutObject.bookmarkRanges) {
+        if (range.sourceRef) Object.freeze(range.sourceRef);
+        if (range.startSourceRef) Object.freeze(range.startSourceRef);
+        if (range.endSourceRef) Object.freeze(range.endSourceRef);
+        Object.freeze(range);
+      }
+      Object.freeze(fragment.layoutObject.bookmarkRanges);
+    }
+    if (fragment.layoutObject.hyperlinks) {
+      for (const hyperlink of fragment.layoutObject.hyperlinks) {
+        if (hyperlink.sourceRef) Object.freeze(hyperlink.sourceRef);
+        Object.freeze(hyperlink);
+      }
+      Object.freeze(fragment.layoutObject.hyperlinks);
+    }
+    if (fragment.layoutObject.numbering) freezeNumberingLayoutFacts(fragment.layoutObject.numbering);
+    if (fragment.layoutObject.numberingRows) {
+      for (const numbering of fragment.layoutObject.numberingRows) {
+        freezeNumberingLayoutFacts(numbering);
+      }
+      Object.freeze(fragment.layoutObject.numberingRows);
+    }
+    Object.freeze(fragment.layoutObject);
+  }
+  if (fragment.paragraphLineRange) Object.freeze(fragment.paragraphLineRange);
+  if (fragment.tableRowRange) Object.freeze(fragment.tableRowRange);
+  if (fragment.continuation) Object.freeze(fragment.continuation);
+  Object.freeze(fragment);
+}
+function freezeNumberingLayoutFacts(numbering) {
+  if (!numbering) return;
+  if (numbering.sourceRef) Object.freeze(numbering.sourceRef);
+  if (numbering.numberingSourceRef) Object.freeze(numbering.numberingSourceRef);
+  if (numbering.numberingInstanceSourceRef) Object.freeze(numbering.numberingInstanceSourceRef);
+  if (numbering.abstractNumberingSourceRef) Object.freeze(numbering.abstractNumberingSourceRef);
+  if (numbering.markerLane) Object.freeze(numbering.markerLane);
+  if (numbering.textColumn) Object.freeze(numbering.textColumn);
+  if (numbering.tabStops) {
+    for (const tab of numbering.tabStops) Object.freeze(tab);
+    Object.freeze(numbering.tabStops);
+  }
+  Object.freeze(numbering);
+}
 function freezePageRegions(regions) {
   freezePageRegion(regions.body);
   if (regions.header) freezePageRegion(regions.header);
@@ -11365,6 +12822,12 @@ function freezePageRegion(region) {
 function freezePageFrame(frame) {
   Object.freeze(frame.physicalBoundsTwips);
   Object.freeze(frame.divergenceIds);
+  for (const story of frame.pageLocalStories) {
+    Object.freeze(story.resolvedFields);
+    Object.freeze(story.previewParts);
+    Object.freeze(story.anchoredObjects);
+    Object.freeze(story);
+  }
   Object.freeze(frame.pageLocalStories);
   Object.freeze(frame);
 }
@@ -11398,16 +12861,22 @@ function normalizePageLocalStoryFieldsForPages(pages) {
         return { ...field, displayText };
       });
       if (!storyChanged) return story;
+      const previewText = renderPageLocalStoryPreviewText(
+        story.previewParts,
+        resolvedFields
+      );
       const sectionPart = story.sectionIndex === void 0 ? "section-unknown" : `section-${story.sectionIndex}`;
       return {
         ...story,
         resolvedFields,
+        previewText,
         signature: buildPageLocalStorySignature({
           kind: story.kind,
           variant: story.variant,
           relationshipId: story.relationshipId,
           sectionPart,
           measuredFrameHeightTwips: story.measuredFrameHeightTwips,
+          previewText,
           resolvedFields,
           anchoredObjects: story.anchoredObjects
         })
@@ -11514,10 +12983,13 @@ function collectSplitRowCarryForPage(ranges, pageRangeIndex) {
 }
 
 // src/runtime/layout/project-block-fragments.ts
-function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlockIdByPageIndex, fragmentMeasurementsByPageIndex, fieldRegions = []) {
+function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlockIdByPageIndex, fragmentMeasurementsByPageIndex, fieldRegions = [], editableTargets = [], numberingInputs = []) {
   const byPage = /* @__PURE__ */ new Map();
   const perPageCounter = /* @__PURE__ */ new Map();
   const fieldRegionsByParagraphIndex = buildFieldRegionsByParagraphIndex(fieldRegions);
+  const generatedTargets = buildGeneratedTargets(editableTargets);
+  const bookmarkRanges = buildBookmarkRanges(editableTargets);
+  const numberingByParagraphIndex = buildNumberingByParagraphIndex(numberingInputs);
   const pushFragment = (pageIndex, fragment) => {
     const existing = byPage.get(pageIndex);
     if (existing) {
@@ -11552,6 +13024,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
             });
           },
           fieldRegionsByParagraphIndex,
+          generatedTargets,
+          bookmarkRanges,
+          numberingByParagraphIndex,
           blockPath
         );
         continue;
@@ -11571,6 +13046,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
           });
         },
         fieldRegionsByParagraphIndex,
+        generatedTargets,
+        bookmarkRanges,
+        numberingByParagraphIndex,
         blockPath
       );
       continue;
@@ -11601,6 +13079,9 @@ function projectSurfaceBlocksToPageFragments(surface, pages, splits, columnByBlo
         widthTwips,
         paginationRole: "whole",
         fieldRegionsByParagraphIndex,
+        generatedTargets,
+        bookmarkRanges,
+        numberingByParagraphIndex,
         blockPath
       }),
       ...columnIndex !== void 0 ? { columnIndex } : {}
@@ -11747,7 +13228,7 @@ function buildRunAnchorsForLine(input) {
   }
   return anchors;
 }
-function emitSlicedParagraph(block, slices, emit, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
+function emitSlicedParagraph(block, slices, emit, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], bookmarkRanges = [], numberingByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i];
     const heightTwips = slice.heightTwips ?? estimateSliceHeightFromLines(slice.lineRange);
@@ -11771,6 +13252,9 @@ function emitSlicedParagraph(block, slices, emit, fieldRegionsByParagraphIndex =
         widthTwips: slice.widthTwips,
         paginationRole: slice.lineRange.from > 0 ? "continuation" : "slice",
         fieldRegionsByParagraphIndex,
+        generatedTargets,
+        bookmarkRanges,
+        numberingByParagraphIndex,
         blockPath
       })
     };
@@ -11791,7 +13275,7 @@ function estimateSliceHeightFromLines(lineRange) {
   const lines = Math.max(0, lineRange.to - lineRange.from);
   return lines * 240;
 }
-function emitSlicedTable(block, slices, emit, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
+function emitSlicedTable(block, slices, emit, fieldRegionsByParagraphIndex = /* @__PURE__ */ new Map(), generatedTargets = [], bookmarkRanges = [], numberingByParagraphIndex = /* @__PURE__ */ new Map(), blockPath) {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i];
     const heightTwips = slice.heightTwips ?? estimateSliceHeightFromRows(slice.rowRange);
@@ -11814,6 +13298,9 @@ function emitSlicedTable(block, slices, emit, fieldRegionsByParagraphIndex = /*
         heightTwips,
         paginationRole: slice.rowRange.from > 0 ? "continuation" : "slice",
         fieldRegionsByParagraphIndex,
+        generatedTargets,
+        bookmarkRanges,
+        numberingByParagraphIndex,
         blockPath
       }),
       ...slice.columnIndex !== void 0 ? { columnIndex: slice.columnIndex } : {}
@@ -11884,13 +13371,27 @@ function estimateSliceHeightFromRows(rowRange) {
 function buildFragmentLayoutObject(input) {
   const fieldFamilies = collectFieldFamilies(input.block);
   const kind = resolveFragmentLayoutObjectKind(input.block, fieldFamilies);
-  const numberingRows = collectNumberingLayoutFactsForBlock(input.block, input.blockPath);
+  const numberingRows = collectNumberingLayoutFactsForBlock(
+    input.block,
+    input.blockPath,
+    input.numberingByParagraphIndex
+  );
   const numbering = input.block.kind === "paragraph" ? numberingRows[0] : void 0;
   const fieldRegions = collectFieldRegionLayoutFacts(
     input.block,
     input.fragmentId,
     input.fieldRegionsByParagraphIndex
   );
+  const bookmarkRanges = collectBookmarkRangeLayoutFacts(
+    input.fragmentId,
+    input.blockPath,
+    input.bookmarkRanges
+  );
+  const hyperlinks = collectHyperlinkLayoutFacts(
+    input.fragmentId,
+    input.blockPath,
+    input.generatedTargets
+  );
   return {
     objectId: `${kind}:${input.fragmentId}`,
     kind,
@@ -11902,6 +13403,8 @@ function buildFragmentLayoutObject(input) {
     },
     ...fieldFamilies.length > 0 ? { fieldFamilies } : {},
     ...fieldRegions.length > 0 ? { fieldRegions } : {},
+    ...bookmarkRanges.length > 0 ? { bookmarkRanges } : {},
+    ...hyperlinks.length > 0 ? { hyperlinks } : {},
     ...numbering ? { numbering } : {},
     ...numberingRows.length > 0 ? { numberingRows } : {}
   };
@@ -12016,6 +13519,18 @@ function toRuntimeFieldRegionLayoutFacts(region, fieldRegionId) {
     paragraphIndex: region.paragraphIndex,
     fieldFamily: region.fieldFamily,
     refreshStatus: region.refreshStatus,
+    ...region.tocId !== void 0 ? { tocId: region.tocId } : {},
+    ...region.sourcePath !== void 0 ? { sourcePath: region.sourcePath } : {},
+    ...region.parentKind !== void 0 ? { parentKind: region.parentKind } : {},
+    ...region.resultRange !== void 0 ? {
+      resultRange: {
+        fromParagraphIndex: region.resultRange.fromParagraphIndex,
+        toParagraphIndex: region.resultRange.toParagraphIndex
+      }
+    } : {},
+    ...region.status !== void 0 ? { status: region.status } : {},
+    ...region.cachedEntryCount !== void 0 ? { cachedEntryCount: region.cachedEntryCount } : {},
+    ...region.generatedEntryCount !== void 0 ? { generatedEntryCount: region.generatedEntryCount } : {},
     ...region.sourceRef !== void 0 ? { sourceRef: { ...region.sourceRef } } : {},
     ...region.fieldEvidence !== void 0 ? {
       fieldEvidence: {
@@ -12025,6 +13540,134 @@ function toRuntimeFieldRegionLayoutFacts(region, fieldRegionId) {
     } : {}
   };
 }
+function buildGeneratedTargets(targets) {
+  return targets.filter(
+    (target) => target.kind === "field-result-text" || target.kind === "hyperlink-text" || target.kind === "hyperlink-destination" || target.kind === "bookmark-anchor" || target.kind === "bookmark-content-range"
+  );
+}
+function buildBookmarkRanges(targets) {
+  const anchors = /* @__PURE__ */ new Map();
+  const contentRanges = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const bookmarkId = target.link?.bookmarkId;
+    if (!bookmarkId) continue;
+    const key = `${target.storyKey}:${bookmarkId}`;
+    if (target.kind === "bookmark-content-range") {
+      contentRanges.set(key, target);
+      continue;
+    }
+    if (target.kind !== "bookmark-anchor") continue;
+    const entry = anchors.get(key) ?? {};
+    if (target.targetKey.includes(":bookmark:start:")) entry.start = target;
+    else if (target.targetKey.includes(":bookmark:end:")) entry.end = target;
+    anchors.set(key, entry);
+  }
+  const ranges = [];
+  for (const [key, pair] of anchors) {
+    if (!pair.start || !pair.end) continue;
+    const startBlockPath = topLevelBlockPath(pair.start.blockPath);
+    const endBlockPath = topLevelBlockPath(pair.end.blockPath);
+    const startBlockIndex = parseTopLevelBlockIndex(startBlockPath);
+    const endBlockIndex = parseTopLevelBlockIndex(endBlockPath);
+    if (startBlockPath === void 0 || endBlockPath === void 0 || startBlockIndex === void 0 || endBlockIndex === void 0) {
+      continue;
+    }
+    const contentRange = contentRanges.get(key);
+    ranges.push({
+      bookmarkId: pair.start.link?.bookmarkId ?? pair.end.link?.bookmarkId ?? key,
+      ...pair.start.link?.bookmarkName !== void 0 ? { bookmarkName: pair.start.link.bookmarkName } : {},
+      storyKey: pair.start.storyKey,
+      ...contentRange?.link?.rangeKey !== void 0 ? { rangeKey: contentRange.link.rangeKey } : {},
+      ...contentRange?.targetKey !== void 0 ? { contentRangeTargetKey: contentRange.targetKey } : {},
+      startTargetKey: pair.start.targetKey,
+      endTargetKey: pair.end.targetKey,
+      startBlockPath,
+      endBlockPath,
+      startBlockIndex,
+      endBlockIndex,
+      ...cloneRuntimeSourceRef(contentRange?.sourceRef ?? pair.start.sourceRef) !== void 0 ? { sourceRef: cloneRuntimeSourceRef(contentRange?.sourceRef ?? pair.start.sourceRef) } : {},
+      ...cloneRuntimeSourceRef(pair.start.sourceRef) !== void 0 ? { startSourceRef: cloneRuntimeSourceRef(pair.start.sourceRef) } : {},
+      ...cloneRuntimeSourceRef(pair.end.sourceRef) !== void 0 ? { endSourceRef: cloneRuntimeSourceRef(pair.end.sourceRef) } : {}
+    });
+  }
+  return ranges;
+}
+function buildNumberingByParagraphIndex(numberingInputs) {
+  const byParagraph = /* @__PURE__ */ new Map();
+  for (const input of numberingInputs) {
+    if (!byParagraph.has(input.paragraphIndex)) {
+      byParagraph.set(input.paragraphIndex, input);
+    }
+  }
+  return byParagraph;
+}
+function collectBookmarkRangeLayoutFacts(fragmentId, blockPath, bookmarkRanges) {
+  if (!blockPath || !bookmarkRanges || bookmarkRanges.length === 0) return [];
+  const blockIndex = parseTopLevelBlockIndex(blockPath);
+  if (blockIndex === void 0) return [];
+  const facts = [];
+  for (const range of bookmarkRanges) {
+    const from = Math.min(range.startBlockIndex, range.endBlockIndex);
+    const to = Math.max(range.startBlockIndex, range.endBlockIndex);
+    if (blockIndex < from || blockIndex > to) continue;
+    const startsHere = blockIndex === range.startBlockIndex;
+    const endsHere = blockIndex === range.endBlockIndex;
+    facts.push({
+      bookmarkRangeId: `bookmark-range:${range.storyKey}:${range.bookmarkId}:${fragmentId}`,
+      bookmarkId: range.bookmarkId,
+      ...range.bookmarkName !== void 0 ? { bookmarkName: range.bookmarkName } : {},
+      storyKey: range.storyKey,
+      rangeRole: startsHere && endsHere ? "whole" : startsHere ? "start" : endsHere ? "end" : "inside",
+      startBlockPath: range.startBlockPath,
+      endBlockPath: range.endBlockPath,
+      ...range.rangeKey !== void 0 ? { rangeKey: range.rangeKey } : {},
+      ...range.contentRangeTargetKey !== void 0 ? { contentRangeTargetKey: range.contentRangeTargetKey } : {},
+      ...range.startTargetKey !== void 0 ? { startTargetKey: range.startTargetKey } : {},
+      ...range.endTargetKey !== void 0 ? { endTargetKey: range.endTargetKey } : {},
+      ...range.sourceRef !== void 0 ? { sourceRef: { ...range.sourceRef } } : {},
+      ...range.startSourceRef !== void 0 ? { startSourceRef: { ...range.startSourceRef } } : {},
+      ...range.endSourceRef !== void 0 ? { endSourceRef: { ...range.endSourceRef } } : {}
+    });
+  }
+  return facts;
+}
+function collectHyperlinkLayoutFacts(fragmentId, blockPath, targets) {
+  if (!blockPath || !targets || targets.length === 0) return [];
+  const facts = [];
+  for (const target of targets) {
+    if (target.kind !== "hyperlink-text" && target.kind !== "hyperlink-destination") continue;
+    if (!pathParticipatesInBlock(target.blockPath, blockPath)) continue;
+    const href = target.link?.href;
+    facts.push({
+      hyperlinkLayoutId: `hyperlink:${target.targetKey}:${fragmentId}`,
+      targetKey: target.targetKey,
+      storyKey: target.storyKey,
+      blockPath: target.blockPath,
+      leafPath: target.leafPath,
+      role: target.kind === "hyperlink-text" ? "display-text" : "destination",
+      ...href !== void 0 ? { href } : {},
+      ...target.link?.destinationKind !== void 0 ? { destinationKind: target.link.destinationKind } : href?.startsWith("#") ? { destinationKind: "internal-anchor" } : href !== void 0 ? { destinationKind: "external" } : {},
+      ...target.link?.bookmarkName !== void 0 ? { targetBookmarkName: target.link.bookmarkName } : href?.startsWith("#") && href.length > 1 ? { targetBookmarkName: href.slice(1) } : {},
+      ...cloneRuntimeSourceRef(target.sourceRef) !== void 0 ? { sourceRef: cloneRuntimeSourceRef(target.sourceRef) } : {}
+    });
+  }
+  return facts;
+}
+function pathParticipatesInBlock(targetPath, blockPath) {
+  return targetPath === blockPath || targetPath.startsWith(`${blockPath}/`);
+}
+function topLevelBlockPath(path) {
+  const match = /^(main\/block\[\d+\])(?:\/|$)/u.exec(path);
+  return match?.[1];
+}
+function parseTopLevelBlockIndex(path) {
+  if (!path) return void 0;
+  const match = /^main\/block\[(\d+)\]$/u.exec(path);
+  return match ? Number(match[1]) : void 0;
+}
+function cloneRuntimeSourceRef(sourceRef) {
+  return sourceRef !== void 0 ? { ...sourceRef } : void 0;
+}
 function collectNumberingLayoutFacts(block) {
   if (block.kind !== "paragraph") return void 0;
   if (!block.numbering && !block.resolvedNumbering && block.numberingPrefix === void 0) {
@@ -12064,13 +13707,14 @@ function collectNumberingLayoutFacts(block) {
     } : {}
   };
 }
-function collectNumberingLayoutFactsForBlock(block, blockPath) {
+function collectNumberingLayoutFactsForBlock(block, blockPath, numberingByParagraphIndex) {
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
   visitParagraphBlocks(block, (paragraph, context) => {
     const numbering = collectNumberingLayoutFacts(paragraph);
     if (!numbering) return;
     const paragraphIndex = parseParagraphBlockIndex(paragraph.blockId);
+    const canonical = paragraphIndex !== void 0 ? numberingByParagraphIndex?.get(paragraphIndex) : void 0;
     const numberingKey = context.path !== void 0 ? `main:${context.path}:numbering` : void 0;
     const numberingLayoutId = numberingKey ?? [
       "numbering",
@@ -12083,9 +13727,17 @@ function collectNumberingLayoutFactsForBlock(block, blockPath) {
     rows.push({
       numberingLayoutId,
       ...numberingKey !== void 0 ? { numberingKey } : {},
-      ...context.path !== void 0 ? { sourceBlockPath: context.path } : {},
+      ...canonical?.storyKey !== void 0 ? { storyKey: canonical.storyKey } : {},
+      ...canonical?.blockPath !== void 0 ? { sourceBlockPath: canonical.blockPath } : context.path !== void 0 ? { sourceBlockPath: context.path } : {},
       sourceBlockId: paragraph.blockId,
       ...paragraphIndex !== void 0 ? { paragraphIndex } : {},
+      ...canonical?.sourceRef !== void 0 ? { sourceRef: { ...canonical.sourceRef } } : {},
+      ...canonical?.numberingSourceRef !== void 0 ? { numberingSourceRef: { ...canonical.numberingSourceRef } } : {},
+      ...canonical?.numberingOrigin !== void 0 ? { numberingOrigin: canonical.numberingOrigin } : {},
+      ...canonical?.paragraphStyleId !== void 0 ? { paragraphStyleId: canonical.paragraphStyleId } : {},
+      ...canonical?.numberingInstanceSourceRef !== void 0 ? { numberingInstanceSourceRef: { ...canonical.numberingInstanceSourceRef } } : {},
+      ...canonical?.abstractNumberingId !== void 0 ? { abstractNumberingId: canonical.abstractNumberingId } : {},
+      ...canonical?.abstractNumberingSourceRef !== void 0 ? { abstractNumberingSourceRef: { ...canonical.abstractNumberingSourceRef } } : {},
       ...numbering
     });
   }, blockPath);
@@ -12467,7 +14119,7 @@ function createEmpiricalProvider() {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 96;
+var LAYOUT_ENGINE_VERSION = 87;
 
 // src/runtime/layout/layout-engine-instance.ts
 var FULL_VIEWPORT_WINDOW_KEY = "full";
@@ -12774,7 +14426,8 @@ function createLayoutEngine(options = {}) {
       MAIN_STORY_TARGET
     );
     const sections = buildResolvedSections(document2);
-    const fieldRegions = collectCanonicalFieldRegionIdentities(document2);
+    const layoutInputs = collectCanonicalLayoutInputs(document2);
+    const fieldRegions = layoutInputs.fieldRegions;
     const pageStack = buildPageStackWithSplits(
       document2,
       sections,
@@ -12790,7 +14443,9 @@ function createLayoutEngine(options = {}) {
       pageStack.splits,
       pageStack.columnByBlockIdByPageIndex,
       pageStack.fragmentMeasurementsByPageIndex,
-      fieldRegions
+      fieldRegions,
+      layoutInputs.editableTargets,
+      layoutInputs.numbering
     );
     const lineBoxesByPageIndex = projectLineBoxesForPageFragments(
       pages,
@@ -12914,14 +14569,17 @@ function createLayoutEngine(options = {}) {
     const freshSnapshotsToRebuild = freshSnapshots.slice(0, convergenceIndex);
     const convergedTailStart = convergenceIndex < freshSnapshots.length ? firstDirty + convergenceIndex : void 0;
     const freshStories = resolvePageStories(freshSnapshotsToRebuild);
-    const fieldRegions = collectCanonicalFieldRegionIdentities(document2);
+    const layoutInputs = collectCanonicalLayoutInputs(document2);
+    const fieldRegions = layoutInputs.fieldRegions;
     const freshBodyFragmentsByPageIndex = projectSurfaceBlocksToPageFragments(
       mainSurface,
       freshSnapshotsToRebuild,
       freshResult.splits,
       freshResult.columnByBlockIdByPageIndex,
       freshResult.fragmentMeasurementsByPageIndex,
-      fieldRegions
+      fieldRegions,
+      layoutInputs.editableTargets,
+      layoutInputs.numbering
     );
     const freshLineBoxesByPageIndex = projectLineBoxesForPageFragments(
       freshSnapshotsToRebuild,