@beyondwork/docx-react-component 1.0.120 → 1.0.121

package/dist/{chunk-AQA7OZ2R.js → chunk-TFSXOIAI.js}

@@ -255,7 +255,7 @@ function collectCanonicalLayoutInputs(doc) {
     editableTargets: collectEditableTargetRefs(doc)
   };
 }
-function collectEditableTargetRefs(doc) {
+function collectEditableTargetRefs(doc, cache) {
   const targets = [];
   for (const context of collectStoryBlockContexts(doc)) {
     collectEditableTargetsInBlocks(
@@ -267,17 +267,64 @@ 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 createEditableTargetBlockCache() {
+  const map = /* @__PURE__ */ new WeakMap();
+  return {
+    get(block) {
+      return map.get(block);
+    },
+    set(block, entry) {
+      map.set(block, entry);
+    }
+  };
+}
+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) {
@@ -289,14 +336,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,
@@ -306,11 +352,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,
@@ -318,25 +363,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;
+    } else if (block.type === "table") {
+      collectEditableTargetsInTable(block, blockPath, context, targets, cache);
     }
-    if (block.type === "table") {
-      collectEditableTargetsInTable(block, blockPath, context, targets);
+    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",
@@ -375,6 +424,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",
@@ -417,15 +470,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) {
@@ -445,6 +619,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,
@@ -456,8 +631,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 } : {}
@@ -468,10 +649,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 } : {},
@@ -479,7 +665,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,
@@ -493,6 +682,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];
@@ -658,13 +866,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,
@@ -672,12 +906,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",
@@ -708,12 +954,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));
@@ -737,6 +998,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 {
@@ -756,9 +1018,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 } : {}
@@ -772,6 +1053,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",
@@ -782,9 +1064,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 } : {}
@@ -792,7 +1090,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",
@@ -801,14 +1144,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"] }
   };
@@ -856,6 +1219,7 @@ function createObjectEditableTarget(inline, storyKey, inlinePath) {
       storyKey,
       inlinePath,
       objectKind: "ole",
+      sourceRef: inline.sourceRef,
       targetHash: `${inline.id}\0${inline.relationshipId}`,
       object: {
         objectKind: "ole",
@@ -977,6 +1341,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":
@@ -1099,6 +1624,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;
@@ -1114,6 +1649,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 validateEditableTargetRef(value, path = "$") {
   const issues = [];
   const record = asPlainObject(value, path, issues);
@@ -1146,6 +1768,12 @@ function validateEditableTargetRef(value, path = "$") {
   if (record.table !== void 0) {
     validateTargetTable(record.table, `${path}.table`, issues);
   }
+  if (record.editableOwner !== void 0) {
+    validateTargetEditableOwner(record.editableOwner, `${path}.editableOwner`, issues);
+  }
+  if (record.canonicalAddress !== void 0) {
+    validateTargetCanonicalAddress(record.canonicalAddress, `${path}.canonicalAddress`, issues);
+  }
   const staleCheck = asPlainObject(record.staleCheck, `${path}.staleCheck`, issues);
   if (staleCheck) {
     if (staleCheck.paragraphTextHash !== void 0) {
@@ -1288,6 +1916,11 @@ function validateTargetTable(value, path, issues) {
   validateEnum(record.operationScope, EDITABLE_TARGET_TABLE_OPERATION_SCOPES, `${path}.operationScope`, issues);
   expectString(record.tableKey, `${path}.tableKey`, issues);
   expectString(record.tablePath, `${path}.tablePath`, issues);
+  for (const key of ["sourceRef", "rowSourceRef", "cellSourceRef"]) {
+    if (record[key] !== void 0) {
+      validateTargetSourceRef(record[key], `${path}.${key}`, issues);
+    }
+  }
   for (const key of [
     "tableDepth",
     "storyBlockIndex",
@@ -1318,6 +1951,46 @@ function validateTargetTable(value, path, issues) {
   if (record.fragment !== void 0) {
     validateTargetTableFragment(record.fragment, `${path}.fragment`, issues);
   }
+  if (record.cellFragment !== void 0) {
+    validateTargetCellFragment(record.cellFragment, `${path}.cellFragment`, issues);
+  }
+}
+function validateTargetEditableOwner(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  expectString(record.targetKey, `${path}.targetKey`, issues);
+  validateEnum(record.kind, EDITABLE_TARGET_KINDS, `${path}.kind`, issues);
+  expectString(record.storyKey, `${path}.storyKey`, issues);
+  expectString(record.blockPath, `${path}.blockPath`, issues);
+  expectString(record.leafPath, `${path}.leafPath`, issues);
+  validateEnum(record.commandFamily, /* @__PURE__ */ new Set(["text-leaf"]), `${path}.commandFamily`, issues);
+  validateEnum(record.reason, /* @__PURE__ */ new Set(["vertical-merge-restart-cell"]), `${path}.reason`, issues);
+  if (record.canonicalAddress !== void 0) {
+    validateTargetOwnerAddressRouting(record.canonicalAddress, `${path}.canonicalAddress`, issues);
+  }
+  if (record.table !== void 0) {
+    validateTargetEditableOwnerTable(record.table, `${path}.table`, issues);
+  }
+}
+function validateTargetEditableOwnerTable(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  expectString(record.tableKey, `${path}.tableKey`, issues);
+  expectString(record.tablePath, `${path}.tablePath`, issues);
+  for (const key of ["sourceRef", "rowSourceRef", "cellSourceRef"]) {
+    if (record[key] !== void 0) {
+      validateTargetSourceRef(record[key], `${path}.${key}`, issues);
+    }
+  }
+  for (const key of ["rowIndex", "cellIndex", "gridColumnStart", "gridSpan"]) {
+    const valueForKey = record[key];
+    if (valueForKey !== void 0 && (typeof valueForKey !== "number" || !Number.isInteger(valueForKey) || valueForKey < 0)) {
+      issues.push({ path: `${path}.${key}`, message: "must be a non-negative integer when present." });
+    }
+  }
+  if (record.verticalMerge !== void 0) {
+    validateEnum(record.verticalMerge, /* @__PURE__ */ new Set(["restart", "continue"]), `${path}.verticalMerge`, issues);
+  }
 }
 function validateTargetTableFragment(value, path, issues) {
   const record = asPlainObject(value, path, issues);
@@ -1335,6 +2008,118 @@ function validateTargetTableFragment(value, path, issues) {
     }
   }
 }
+function validateTargetCellFragment(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  validateSha256(record.fragmentKey, `${path}.fragmentKey`, issues);
+  validateSha256(record.textHash, `${path}.textHash`, issues);
+  const blockCount = record.blockCount;
+  if (typeof blockCount !== "number" || !Number.isInteger(blockCount) || blockCount < 0) {
+    issues.push({ path: `${path}.blockCount`, message: "blockCount must be a non-negative integer." });
+  }
+  if (record.rowRange !== void 0) {
+    validateTargetTableRange(record.rowRange, `${path}.rowRange`, issues);
+  }
+  if (record.columnRange !== void 0) {
+    validateTargetTableRange(record.columnRange, `${path}.columnRange`, issues);
+  }
+  if (record.sourceJoinHash !== void 0) {
+    validateSha256(record.sourceJoinHash, `${path}.sourceJoinHash`, issues);
+  }
+}
+function validateTargetCanonicalAddress(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  const addressKey = expectString(record.addressKey, `${path}.addressKey`, issues);
+  if (addressKey && !/^editable-address:[A-Fa-f0-9]{64}$/u.test(addressKey)) {
+    issues.push({ path: `${path}.addressKey`, message: "must be an editable-address SHA-256 key." });
+  }
+  validateEnum(record.addressKind, EDITABLE_TARGET_CANONICAL_ADDRESS_KINDS, `${path}.addressKind`, issues);
+  expectString(record.storyKey, `${path}.storyKey`, issues);
+  validateEnum(record.staleCheckKind, EDITABLE_TARGET_STALE_BLOCK_TYPES, `${path}.staleCheckKind`, issues);
+  if (record.operationScope !== void 0) {
+    validateEnum(record.operationScope, EDITABLE_TARGET_CANONICAL_ADDRESS_OPERATION_SCOPES, `${path}.operationScope`, issues);
+  }
+  if (record.rowRange !== void 0) {
+    validateTargetTableRange(record.rowRange, `${path}.rowRange`, issues);
+  }
+  if (record.columnRange !== void 0) {
+    validateTargetTableRange(record.columnRange, `${path}.columnRange`, issues);
+  }
+  if (record.sourceJoinHash !== void 0) {
+    validateSha256(record.sourceJoinHash, `${path}.sourceJoinHash`, issues);
+  }
+  if (record.resolver !== void 0) {
+    validateTargetCanonicalAddressResolver(record.resolver, `${path}.resolver`, issues);
+  }
+  for (const key of ["secondaryStory", "nestedTable", "insideSdt"]) {
+    if (record[key] !== void 0 && typeof record[key] !== "boolean") {
+      issues.push({ path: `${path}.${key}`, message: "must be a boolean when present." });
+    }
+  }
+}
+function validateTargetCanonicalAddressResolver(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  validateSha256(record.staleHash, `${path}.staleHash`, issues);
+  if (record.sourceJoinHash !== void 0) {
+    validateSha256(record.sourceJoinHash, `${path}.sourceJoinHash`, issues);
+  }
+  if (record.rowRange !== void 0) {
+    validateTargetTableRange(record.rowRange, `${path}.rowRange`, issues);
+  }
+  if (record.columnRange !== void 0) {
+    validateTargetTableRange(record.columnRange, `${path}.columnRange`, issues);
+  }
+  if (record.rangeBoundary !== void 0) {
+    validateTargetAddressRangeBoundary(record.rangeBoundary, `${path}.rangeBoundary`, issues);
+  }
+  if (record.owner !== void 0) {
+    validateTargetOwnerAddressRouting(record.owner, `${path}.owner`, issues);
+  }
+}
+function validateTargetAddressRangeBoundary(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  validateEnum(record.boundaryKind, EDITABLE_TARGET_ADDRESS_BOUNDARY_KINDS, `${path}.boundaryKind`, issues);
+  for (const key of ["from", "to"]) {
+    const valueForKey = record[key];
+    if (valueForKey !== void 0 && (typeof valueForKey !== "number" || !Number.isInteger(valueForKey) || valueForKey < 0)) {
+      issues.push({ path: `${path}.${key}`, message: "must be a non-negative integer when present." });
+    }
+  }
+  if (typeof record.from === "number" && typeof record.to === "number" && Number.isInteger(record.from) && Number.isInteger(record.to) && record.to < record.from) {
+    issues.push({ path: `${path}.to`, message: "must be greater than or equal to from." });
+  }
+  for (const key of ["startSourceJoinHash", "endSourceJoinHash"]) {
+    if (record[key] !== void 0) {
+      validateSha256(record[key], `${path}.${key}`, issues);
+    }
+  }
+}
+function validateTargetOwnerAddressRouting(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) return;
+  const addressKey = expectString(record.addressKey, `${path}.addressKey`, issues);
+  if (addressKey && !/^editable-address:[A-Fa-f0-9]{64}$/u.test(addressKey)) {
+    issues.push({ path: `${path}.addressKey`, message: "must be an editable-address SHA-256 key." });
+  }
+  validateEnum(record.addressKind, EDITABLE_TARGET_CANONICAL_ADDRESS_KINDS, `${path}.addressKind`, issues);
+  expectString(record.storyKey, `${path}.storyKey`, issues);
+  if (record.operationScope !== void 0) {
+    validateEnum(record.operationScope, EDITABLE_TARGET_CANONICAL_ADDRESS_OPERATION_SCOPES, `${path}.operationScope`, issues);
+  }
+  if (record.sourceJoinHash !== void 0) {
+    validateSha256(record.sourceJoinHash, `${path}.sourceJoinHash`, issues);
+  }
+  validateSha256(record.staleHash, `${path}.staleHash`, issues);
+  if (record.rowRange !== void 0) {
+    validateTargetTableRange(record.rowRange, `${path}.rowRange`, issues);
+  }
+  if (record.columnRange !== void 0) {
+    validateTargetTableRange(record.columnRange, `${path}.columnRange`, issues);
+  }
+}
 function validateTargetTableRange(value, path, issues) {
   const record = asPlainObject(value, path, issues);
   if (!record) return;
@@ -1361,12 +2146,12 @@ function validateTargetSourceRef(value, path, issues) {
   const record = asPlainObject(value, path, issues);
   if (!record) return;
   expectString(record.sourceId, `${path}.sourceId`, issues);
-  for (const key of ["partPath", "storyKind", "element"]) {
+  for (const key of ["partPath", "storyKind", "element", "xmlPath", "tableCellPath"]) {
     if (record[key] !== void 0) {
       expectString(record[key], `${path}.${key}`, issues);
     }
   }
-  for (const key of ["ordinal", "startOffset", "endOffset"]) {
+  for (const key of ["ordinal", "startOffset", "endOffset", "tableDepth"]) {
     const numberValue = record[key];
     if (numberValue !== void 0 && (typeof numberValue !== "number" || !Number.isInteger(numberValue) || numberValue < 0)) {
       issues.push({ path: `${path}.${key}`, message: `${key} must be a non-negative integer when present.` });
@@ -1387,8 +2172,12 @@ var EDITABLE_TARGET_KINDS = /* @__PURE__ */ new Set([
   "secondary-story-paragraph-text",
   "textbox-paragraph-text",
   "field-result-text",
+  "field-region-refresh",
+  "toc-region-refresh",
   "hyperlink-text",
+  "hyperlink-destination",
   "bookmark-anchor",
+  "bookmark-content-range",
   "comment-anchor",
   "revision-anchor",
   "object-anchor",
@@ -1439,6 +2228,41 @@ var EDITABLE_TARGET_TABLE_OPERATION_SCOPES = /* @__PURE__ */ new Set([
   "cell",
   "span"
 ]);
+var EDITABLE_TARGET_CANONICAL_ADDRESS_KINDS = /* @__PURE__ */ new Set([
+  "table-target",
+  "list-item-text",
+  "field-result",
+  "field-region-refresh",
+  "toc-region-refresh",
+  "hyperlink-display-text",
+  "hyperlink-destination",
+  "bookmark-anchor",
+  "bookmark-content-range"
+]);
+var EDITABLE_TARGET_CANONICAL_ADDRESS_OPERATION_SCOPES = /* @__PURE__ */ new Set([
+  "text",
+  "table",
+  "row",
+  "column",
+  "cell",
+  "span",
+  "list-text",
+  "field-refresh",
+  "toc-refresh",
+  "link-destination",
+  "bookmark-range"
+]);
+var EDITABLE_TARGET_ADDRESS_BOUNDARY_KINDS = /* @__PURE__ */ new Set([
+  "table-grid",
+  "cell-fragment",
+  "list-item-text",
+  "field-result",
+  "field-region",
+  "hyperlink-display",
+  "bookmark-content",
+  "hyperlink-destination",
+  "bookmark-anchor"
+]);
 function collectCanonicalStoryIdentities(doc) {
   const stories = [
     {
@@ -1804,7 +2628,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") {
@@ -1841,6 +2665,7 @@ function projectTableLayoutInput(table, storyKey, blockPath) {
     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],
@@ -1867,6 +2692,7 @@ function projectTableRowLayoutInput(row, tableKey, rowIndex) {
   });
   return {
     rowKey,
+    ...row.sourceRef !== void 0 ? { sourceRef: row.sourceRef } : {},
     rowIndex,
     cellCount: row.cells.length,
     ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
@@ -1886,6 +2712,7 @@ function projectTableCellLayoutInput(cell, rowKey, rowIndex, cellIndex, gridColu
   const gridSpan = cell.gridSpan ?? 1;
   return {
     cellKey: `${rowKey}:cell[${cellIndex}]`,
+    ...cell.sourceRef !== void 0 ? { sourceRef: cell.sourceRef } : {},
     rowIndex,
     cellIndex,
     gridColumnStart,
@@ -1918,8 +2745,10 @@ function projectDrawingFrameAnchor(node, storyKey, blockPath, inlinePath) {
   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}:${inlinePath}`,
+    objectKey,
     storyKey,
     blockPath,
     inlinePath,
@@ -1949,9 +2778,95 @@ function projectDrawingFrameAnchor(node, storyKey, blockPath, inlinePath) {
     ...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 {
@@ -2142,6 +3057,7 @@ export {
   createNoteStoryKey,
   collectCanonicalLayoutInputs,
   collectEditableTargetRefs,
+  createEditableTargetBlockCache,
   validateEditableTargetRef,
   collectCanonicalFieldRegionIdentities,
   createCanonicalFieldId,