@beyondwork/docx-react-component 1.0.120 → 1.0.121

package/dist/core/commands/image-commands.cjs

@@ -69,7 +69,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;
 }
@@ -201,6 +201,9 @@ function serializeTextStory(story) {
           warningId: unit.warningId
         });
         break;
+      case "protected_inline":
+        pushInlineNode(structuredClone(unit.node));
+        break;
       case "scope_marker":
         pushInlineNode({
           type: unit.boundary === "start" ? "scope_marker_start" : "scope_marker_end",
@@ -249,6 +252,13 @@ function cloneStoryUnit(unit) {
         fragmentId: unit.fragmentId,
         warningId: unit.warningId
       };
+    case "protected_inline":
+      return {
+        kind: "protected_inline",
+        node: structuredClone(unit.node),
+        logicalSize: unit.logicalSize,
+        reason: unit.reason
+      };
     case "opaque_block":
       return {
         kind: "opaque_block",
@@ -331,7 +341,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({
@@ -365,6 +397,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 } : {},
@@ -795,7 +853,7 @@ function createHeaderFooterStoryKey(input) {
 function createNoteStoryKey(kind, noteId) {
   return `${kind}:${noteId}`;
 }
-function collectEditableTargetRefs(doc) {
+function collectEditableTargetRefs(doc, cache) {
   const targets = [];
   for (const context of collectStoryBlockContexts(doc)) {
     collectEditableTargetsInBlocks(
@@ -807,17 +865,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) {
@@ -829,14 +923,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,
@@ -846,11 +939,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,
@@ -858,25 +950,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",
@@ -915,6 +1011,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",
@@ -957,15 +1057,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) {
@@ -985,6 +1206,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,
@@ -996,8 +1218,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 } : {}
@@ -1008,10 +1236,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 } : {},
@@ -1019,7 +1252,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,
@@ -1033,6 +1269,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];
@@ -1198,13 +1453,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,
@@ -1212,12 +1493,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",
@@ -1248,12 +1541,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));
@@ -1277,6 +1585,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 {
@@ -1296,9 +1605,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 } : {}
@@ -1312,6 +1640,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",
@@ -1322,9 +1651,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 } : {}
@@ -1332,7 +1677,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",
@@ -1341,14 +1731,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"] }
   };
@@ -1396,6 +1806,7 @@ function createObjectEditableTarget(inline, storyKey, inlinePath) {
       storyKey,
       inlinePath,
       objectKind: "ole",
+      sourceRef: inline.sourceRef,
       targetHash: `${inline.id}\0${inline.relationshipId}`,
       object: {
         objectKind: "ole",
@@ -1517,6 +1928,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":
@@ -1639,6 +2211,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;
@@ -1654,6 +2236,93 @@ 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 collectCanonicalFieldRegionIdentities(doc) {
   const registry = doc.fieldRegistry;
   const byFieldIndex = new Map(
@@ -1851,7 +2520,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") {
@@ -4601,6 +5270,7 @@ var PICTURE_EFFECT_SCHEME_ALIASES = {
   bg2: "lt2"
 };
 var EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH = /* @__PURE__ */ new Map();
+var NO_EDITABLE_TARGETS_INDEX = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH;
 function indexEditableTargetsByBlockPath(document) {
   const targets = collectEditableTargetRefs(document);
   if (targets.length === 0) return EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH;
@@ -4652,7 +5322,7 @@ function createEditorSurfaceSnapshot(document, _selection, activeStory = { kind:
     ...options.getEffectiveMarkupMode ? { getEffectiveMarkupMode: options.getEffectiveMarkupMode } : {},
     ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
   });
-  const editableTargetsByBlockPath = indexEditableTargetsByBlockPath(document);
+  const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document);
   const activeStoryBlockPathBase = getActiveStoryBlockPathBase(document, activeStory);
   chartModelStore.beginBuildPass(document);
   const unsupportedNumberingFormatsSeen = options.emitFormattingTelemetry ? /* @__PURE__ */ new Set() : null;
@@ -4933,6 +5603,7 @@ function createTableBlock(tableIndex, table, document, cursor, counters, formatt
         from: cursor,
         to: innerCursor,
         styleId: table.styleId,
+        ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
         gridColumns: table.gridColumns,
         rows: []
       },
@@ -5002,6 +5673,7 @@ function createTableBlock(tableIndex, table, document, cursor, counters, formatt
         resolvedTable.table?.cellMargins
       );
       cells.push({
+        ...cell.sourceRef !== void 0 ? { sourceRef: cell.sourceRef } : {},
         gridSpan: cell.gridSpan ?? 1,
         verticalMerge: cell.verticalMerge ?? null,
         colspan: cell.gridSpan ?? 1,
@@ -5025,6 +5697,7 @@ function createTableBlock(tableIndex, table, document, cursor, counters, formatt
     }
     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 } : {},
@@ -5055,6 +5728,7 @@ function createTableBlock(tableIndex, table, document, cursor, counters, formatt
       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 } : {},
@@ -5599,6 +6273,7 @@ function appendInlineSegments(paragraph, node, document, start, promoteSecondary
         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}`,
@@ -5615,6 +6290,7 @@ function appendInlineSegments(paragraph, node, document, start, promoteSecondary
           ...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 } : {}
         });
@@ -6027,6 +6703,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({
@@ -6543,7 +7310,9 @@ function resolveParagraphScope(document, selection) {
   if (!root) {
     return null;
   }
-  const surface = createEditorSurfaceSnapshot(document, selection);
+  const surface = createEditorSurfaceSnapshot(document, selection, void 0, {
+    editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX
+  });
   const selectionFrom = Math.min(selection.anchor, selection.head);
   const selectionTo = Math.max(selection.anchor, selection.head);
   for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {