@beyondwork/docx-react-component 1.0.120 → 1.0.121

package/dist/{chunk-KD5K5XIA.js → chunk-UHQOUTAX.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-M6XR534O.js";
 import {
   buildBookmarkNameMap
-} from "./chunk-2ZWFQ74R.js";
+} from "./chunk-OBCP6VTG.js";
 import {
   deleteSelectionOrBackward,
   deleteSelectionOrForward,
@@ -22,7 +22,7 @@ import {
   insertText,
   outdentParagraphAtSelection,
   splitParagraph
-} from "./chunk-FXGQM2JB.js";
+} from "./chunk-3OFSP2IX.js";
 import {
   applyFormattingOperationToDocument,
   applyTextMarkOperationToDocumentRange,
@@ -32,19 +32,18 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-5RNMPLXU.js";
+} from "./chunk-37SEJQ3G.js";
 import {
   applyTextTransaction
-} from "./chunk-U5BSQXF4.js";
+} from "./chunk-3OHVK2D6.js";
 import {
-  applyTableStructureOperation,
   applyTableStructureOperationForEditableTarget,
   removeCellFromRow,
   removeTableRowPure
-} from "./chunk-BBB4GSDB.js";
+} from "./chunk-XVFENXLK.js";
 import {
   resolveParagraphScope
-} from "./chunk-MUEN2WOG.js";
+} from "./chunk-ZKSDVHGH.js";
 import {
   buildGeometryDebugEntry,
   collectLineBoxesForRegion,
@@ -52,7 +51,7 @@ import {
   createRenderKernel,
   incrementInvalidationCounter,
   recordPerfSample
-} from "./chunk-WVZX4NYG.js";
+} from "./chunk-GZW2ERUO.js";
 import {
   AI_ACTION_POLICIES,
   buildFormattingDebugEntry,
@@ -69,12 +68,13 @@ import {
   findTextMatches,
   findTextWithStyleMatches,
   rebuildFieldRegistry,
+  resolveEditableCommandTarget,
   resolveEditableTableStructureTarget,
   resolveEditableTextTarget,
   resolveHeadingPath,
   resolveScope,
   serializeFragmentToWordML
-} from "./chunk-MPYYBRVN.js";
+} from "./chunk-PCXTMEGY.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -109,14 +109,14 @@ import {
   setWorkspaceMode,
   setZoomLevel,
   snapCommentAnchorAwayFromTable
-} from "./chunk-TMQGWF7R.js";
+} from "./chunk-G3B2OBCZ.js";
 import {
   countLogicalPositions,
   createPlainText,
   logicalPositionToUnitIndex,
   parseTextStory,
   serializeTextStory
-} from "./chunk-4ZNQFWFM.js";
+} from "./chunk-QIO6V46H.js";
 import {
   ThemeColorResolver,
   createEditorSurfaceSnapshot,
@@ -128,18 +128,18 @@ import {
   replaceStoryBlocks,
   resolvePageFieldDisplayText,
   storyTargetKey
-} from "./chunk-AUQDC5BD.js";
+} from "./chunk-3TUQCHYT.js";
 import {
   createCommentSidebarProjection,
   createCommentStoreFromRuntimeComments
-} from "./chunk-VDIUVT46.js";
+} from "./chunk-CX42VC67.js";
 import {
   createEditorState,
   createPersistedEditorSnapshot,
   createSelectionSnapshot,
   deriveDocumentStats,
   normalizeCommentThreadRecord
-} from "./chunk-FLNQY74K.js";
+} from "./chunk-OYGMRRR7.js";
 import {
   buildCompatibilityReport,
   createDiagnostics,
@@ -152,12 +152,18 @@ import {
   persistedSnapshotFromEditorSessionState,
   remapRevisionStore,
   setRevisionStatus
-} from "./chunk-327AIUXL.js";
+} from "./chunk-UWDWGQH5.js";
 import {
   isSupportedFieldFamily,
   parseTocLevelRange,
   resolveRefFieldText
-} from "./chunk-NQZUGMLW.js";
+} from "./chunk-TMU7JMXX.js";
+import {
+  collectEditableTargetRefs,
+  collectStoryBlockContexts,
+  createEditableTargetBlockCache,
+  createHeaderFooterStoryKey
+} from "./chunk-TFSXOIAI.js";
 import {
   setActiveSerializeTelemetryBus
 } from "./chunk-EB6M3GE6.js";
@@ -170,7 +176,7 @@ import {
   createPublicRangeAnchor,
   toInternalAnchorProjection,
   toPublicAnchorProjection
-} from "./chunk-4JNUMMM7.js";
+} from "./chunk-PGGPPZ65.js";
 import {
   DEFAULT_BOUNDARY_ASSOC,
   MAIN_STORY_TARGET,
@@ -1686,27 +1692,10 @@ function applyFragmentInsert(document, selection, fragment, context) {
     };
   }
   if (scope.kind === "table-cell") {
-    const spliced = insertFragmentBlocksAfterTableCellScope(
-      splitRoot,
-      scope,
-      fragment.blocks
-    );
-    if (!spliced) {
-      return {
-        changed: false,
-        document,
-        selection
-      };
-    }
     return {
-      changed: true,
-      document: {
-        ...splitResult.document,
-        updatedAt: context.timestamp,
-        content: spliced
-      },
-      selection: createSelectionSnapshot(0, 0),
-      mapping: createEmptyMapping()
+      changed: false,
+      document,
+      selection
     };
   }
   const rightHalfIndex = scope.blockIndex + 1;
@@ -1814,35 +1803,6 @@ function insertBlocksAfterPathInBlocks(blocks, tokens, tokenIndex, fragmentBlock
     };
   });
 }
-function insertFragmentBlocksAfterTableCellScope(root, scope, fragmentBlocks) {
-  return {
-    ...root,
-    children: root.children.map((block, blockIndex) => {
-      if (blockIndex !== scope.tableBlockIndex || block.type !== "table") {
-        return block;
-      }
-      return {
-        ...block,
-        rows: block.rows.map((row2, rowIndex) => {
-          if (rowIndex !== scope.rowIndex) return row2;
-          return {
-            ...row2,
-            cells: row2.cells.map(
-              (cell, cellIndex) => cellIndex === scope.cellIndex ? {
-                ...cell,
-                children: [
-                  ...cell.children.slice(0, scope.childIndex + 1),
-                  ...fragmentBlocks.map((candidate) => cloneBlock(candidate)),
-                  ...cell.children.slice(scope.childIndex + 1)
-                ]
-              } : cell
-            )
-          };
-        })
-      };
-    })
-  };
-}
 function parseCanonicalBlockPath(path) {
   const blockStart = path.indexOf("/block[");
   if (blockStart < 0) return null;
@@ -2006,6 +1966,9 @@ function executeEditorCommand(state, command, context) {
       );
     }
     case "table.apply-text": {
+      if (!command.editableTarget || context.textTarget?.kind !== "table-paragraph") {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
       const textContext = context;
       const formatting = command.formatting ?? { mode: "match-replaced-range" };
       const suggestingResult = context.documentMode === "suggesting" ? applySuggestingInsert(state, command.operation.text, textContext) : void 0;
@@ -2588,20 +2551,15 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "table.apply-structure": {
-      if (!context.renderSnapshot) {
+      if (!context.renderSnapshot || !command.editableTarget) {
         return createTransaction(state, { historyBoundary: "skip", markDirty: false });
       }
-      const result = command.editableTarget ? applyTableStructureOperationForEditableTarget(
+      const result = applyTableStructureOperationForEditableTarget(
         state.document,
         context.renderSnapshot,
         command.selectionDescriptor,
         command.operation,
         command.editableTarget
-      ) : applyTableStructureOperation(
-        state.document,
-        context.renderSnapshot,
-        command.selectionDescriptor,
-        command.operation
       );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.changed,
@@ -2610,6 +2568,35 @@ function executeEditorCommand(state, command, context) {
         mapping: result.mapping
       });
     }
+    case "field.refresh":
+    case "toc.refresh":
+      return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+    case "bookmark.edit-content": {
+      const result = editBookmarkRangeContent(
+        state.document,
+        command.editableTarget,
+        command.text,
+        context.timestamp
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection
+      });
+    }
+    case "hyperlink.update-destination": {
+      const result = updateHyperlinkDestination(
+        state.document,
+        command.editableTarget,
+        command.href,
+        context.timestamp
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection
+      });
+    }
     case "image.insert": {
       const dataBytes = decodeBase64ToBytes(command.data);
       const result = insertImage(
@@ -2800,6 +2787,230 @@ function resolvePatchedContent(base, patch, contentChildren) {
     children: nextChildren
   };
 }
+function editBookmarkRangeContent(document, target, text, timestamp) {
+  if (target.kind !== "bookmark-content-range" || target.commandFamily !== "link-bookmark") {
+    return { changed: false, document };
+  }
+  const bookmarkId = target.link?.bookmarkId;
+  if (!bookmarkId) return { changed: false, document };
+  const replaced = replaceBlocksForEditableStory(document, target.storyKey, (blocks) => {
+    const next = rewriteBookmarkRangeInBlocks(blocks, bookmarkId, text);
+    return next === blocks ? null : next;
+  });
+  return replaced ? { changed: true, document: { ...replaced, updatedAt: timestamp } } : { changed: false, document };
+}
+function updateHyperlinkDestination(document, target, href, timestamp) {
+  if (target.kind !== "hyperlink-destination" || target.commandFamily !== "link-bookmark") {
+    return { changed: false, document };
+  }
+  const storyContext = collectStoryBlockContexts(document).find(
+    (context) => context.storyKey === target.storyKey
+  );
+  if (!storyContext) return { changed: false, document };
+  const relative = pathRelativeToStoryBase(target.blockPath, storyContext.basePath);
+  if (!relative) return { changed: false, document };
+  const nextBlocks = rewriteHyperlinkAtPath(storyContext.blocks, relative, href);
+  if (!nextBlocks) return { changed: false, document };
+  const replaced = replaceBlocksForEditableStory(document, target.storyKey, () => nextBlocks);
+  return replaced ? { changed: true, document: { ...replaced, updatedAt: timestamp } } : { changed: false, document };
+}
+function rewriteBookmarkRangeInBlocks(blocks, bookmarkId, text) {
+  let changed = false;
+  const next = blocks.map((block) => {
+    const rewritten = rewriteBookmarkRangeInBlock(block, bookmarkId, text);
+    if (rewritten !== block) changed = true;
+    return rewritten;
+  });
+  return changed ? next : blocks;
+}
+function rewriteBookmarkRangeInBlock(block, bookmarkId, text) {
+  if (block.type === "paragraph") {
+    const startIndex = block.children.findIndex(
+      (child) => child.type === "bookmark_start" && child.bookmarkId === bookmarkId
+    );
+    const endIndex = block.children.findIndex(
+      (child, index) => index > startIndex && child.type === "bookmark_end" && child.bookmarkId === bookmarkId
+    );
+    if (startIndex >= 0 && endIndex > startIndex) {
+      const replacement = text.length > 0 ? [{ type: "text", text }] : [];
+      return {
+        ...block,
+        children: [
+          ...block.children.slice(0, startIndex + 1),
+          ...replacement,
+          ...block.children.slice(endIndex)
+        ]
+      };
+    }
+    return block;
+  }
+  if (block.type === "table") {
+    let changed = false;
+    const rows = block.rows.map((row2) => {
+      let rowChanged = false;
+      const cells = row2.cells.map((cell) => {
+        const children = rewriteBookmarkRangeInBlocks(cell.children, bookmarkId, text);
+        if (children !== cell.children) rowChanged = true;
+        return children === cell.children ? cell : { ...cell, children: [...children] };
+      });
+      if (rowChanged) changed = true;
+      return rowChanged ? { ...row2, cells } : row2;
+    });
+    return changed ? { ...block, rows } : block;
+  }
+  if (block.type === "sdt" || block.type === "custom_xml") {
+    const children = rewriteBookmarkRangeInBlocks(block.children, bookmarkId, text);
+    return children === block.children ? block : { ...block, children: [...children] };
+  }
+  return block;
+}
+function rewriteHyperlinkAtPath(blocks, relativePath, href) {
+  const parts = relativePath.split("/");
+  const rewritten = rewriteInlineAtPathInBlocks(blocks, parts, 0, (inline) => {
+    if (inline.type !== "hyperlink") return inline;
+    const hyperlink = inline;
+    return hyperlink.href === href ? hyperlink : { ...hyperlink, href };
+  });
+  return rewritten === blocks ? null : [...rewritten];
+}
+function rewriteInlineAtPathInBlocks(blocks, parts, offset, update) {
+  const blockIndex = parseIndexedPathPart(parts[offset], "block");
+  if (blockIndex === null) return blocks;
+  const block = blocks[blockIndex];
+  if (!block) return blocks;
+  const nextBlock = rewriteInlineAtPathInBlock(block, parts, offset + 1, update);
+  if (nextBlock === block) return blocks;
+  return blocks.map((candidate, index) => index === blockIndex ? nextBlock : candidate);
+}
+function rewriteInlineAtPathInBlock(block, parts, offset, update) {
+  const inlineIndex = parseIndexedPathPart(parts[offset], "inline");
+  if (inlineIndex !== null && block.type === "paragraph") {
+    const inline = block.children[inlineIndex];
+    if (!inline) return block;
+    const nextInline = update(inline);
+    if (nextInline === inline) return block;
+    return {
+      ...block,
+      children: block.children.map((candidate, index) => index === inlineIndex ? nextInline : candidate)
+    };
+  }
+  if (block.type === "sdt" || block.type === "custom_xml") {
+    const children2 = rewriteInlineAtPathInBlocks(block.children, parts, offset, update);
+    return children2 === block.children ? block : { ...block, children: [...children2] };
+  }
+  if (block.type !== "table") return block;
+  const rowIndex = parseIndexedPathPart(parts[offset], "row");
+  const cellIndex = parseIndexedPathPart(parts[offset + 1], "cell");
+  if (rowIndex === null || cellIndex === null) return block;
+  const row2 = block.rows[rowIndex];
+  const cell = row2?.cells[cellIndex];
+  if (!row2 || !cell) return block;
+  const children = rewriteInlineAtPathInBlocks(cell.children, parts, offset + 2, update);
+  if (children === cell.children) return block;
+  return {
+    ...block,
+    rows: block.rows.map(
+      (candidateRow, candidateRowIndex) => candidateRowIndex === rowIndex ? {
+        ...candidateRow,
+        cells: candidateRow.cells.map(
+          (candidateCell, candidateCellIndex) => candidateCellIndex === cellIndex ? { ...candidateCell, children: [...children] } : candidateCell
+        )
+      } : candidateRow
+    )
+  };
+}
+function parseIndexedPathPart(part, kind) {
+  if (!part) return null;
+  const match = new RegExp(`^${kind}\\[(\\d+)\\]$`, "u").exec(part);
+  if (!match) return null;
+  const index = Number(match[1]);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}
+function pathRelativeToStoryBase(path, basePath) {
+  if (path === basePath) return "";
+  return path.startsWith(`${basePath}/`) ? path.slice(basePath.length + 1) : null;
+}
+function replaceBlocksForEditableStory(document, storyKey, replace) {
+  if (storyKey === "main") {
+    const children = replace(document.content.children);
+    return children ? { ...document, content: { ...document.content, children: [...children] } } : null;
+  }
+  const headers = document.subParts?.headers ?? [];
+  for (const header of headers) {
+    if (createHeaderFooterStoryKey({
+      kind: "header",
+      relationshipId: header.relationshipId,
+      variant: header.variant,
+      ...header.sectionIndex !== void 0 ? { sectionIndex: header.sectionIndex } : {}
+    }) === storyKey) {
+      const blocks = replace(header.blocks);
+      return blocks ? {
+        ...document,
+        subParts: {
+          ...document.subParts,
+          headers: headers.map((entry) => entry === header ? { ...entry, blocks: [...blocks] } : entry)
+        }
+      } : null;
+    }
+  }
+  const footers = document.subParts?.footers ?? [];
+  for (const footer of footers) {
+    if (createHeaderFooterStoryKey({
+      kind: "footer",
+      relationshipId: footer.relationshipId,
+      variant: footer.variant,
+      ...footer.sectionIndex !== void 0 ? { sectionIndex: footer.sectionIndex } : {}
+    }) === storyKey) {
+      const blocks = replace(footer.blocks);
+      return blocks ? {
+        ...document,
+        subParts: {
+          ...document.subParts,
+          footers: footers.map((entry) => entry === footer ? { ...entry, blocks: [...blocks] } : entry)
+        }
+      } : null;
+    }
+  }
+  const footnoteMatch = /^footnote:(.+)$/u.exec(storyKey);
+  const footnotes = document.subParts?.footnoteCollection?.footnotes;
+  if (footnoteMatch && footnotes?.[footnoteMatch[1]]) {
+    const note = footnotes[footnoteMatch[1]];
+    const blocks = replace(note.blocks);
+    return blocks ? {
+      ...document,
+      subParts: {
+        ...document.subParts,
+        footnoteCollection: {
+          ...document.subParts.footnoteCollection,
+          footnotes: {
+            ...footnotes,
+            [footnoteMatch[1]]: { ...note, blocks: [...blocks] }
+          }
+        }
+      }
+    } : null;
+  }
+  const endnoteMatch = /^endnote:(.+)$/u.exec(storyKey);
+  const endnotes = document.subParts?.footnoteCollection?.endnotes;
+  if (endnoteMatch && endnotes?.[endnoteMatch[1]]) {
+    const note = endnotes[endnoteMatch[1]];
+    const blocks = replace(note.blocks);
+    return blocks ? {
+      ...document,
+      subParts: {
+        ...document.subParts,
+        footnoteCollection: {
+          ...document.subParts.footnoteCollection,
+          endnotes: {
+            ...endnotes,
+            [endnoteMatch[1]]: { ...note, blocks: [...blocks] }
+          }
+        }
+      }
+    } : null;
+  }
+  return null;
+}
 function buildDocumentReplaceTransaction(state, context, result) {
   if (!result.changed) {
     return createTransaction(state, { historyBoundary: "skip", markDirty: false });
@@ -9118,6 +9329,7 @@ function toPublicPageLocalStory(story) {
     variant: story.variant,
     relationshipId: story.relationshipId,
     ...story.sectionIndex !== void 0 ? { sectionIndex: story.sectionIndex } : {},
+    previewText: story.previewText,
     resolvedFields: story.resolvedFields.map(toPublicResolvedStoryField),
     anchoredObjects: story.anchoredObjects.map(toPublicStoryAnchoredObject),
     measuredFrameHeightTwips: story.measuredFrameHeightTwips,
@@ -9251,6 +9463,7 @@ function toPublicTableFrameContexts(graph, tableRecords) {
       const columnContexts = buildTableFrameColumnContexts(tableBlock, tableFamily);
       const rowContexts = buildTableFrameRowContexts({
         tableFamily,
+        tableBlock,
         rowRange,
         repeatedHeaderRowIndexes: repeatedHeaderRowIndexes2,
         splitRowCarry,
@@ -9269,6 +9482,8 @@ function toPublicTableFrameContexts(graph, tableRecords) {
           pageId: page.pageId,
           pageIndex: page.pageIndex,
           pageNumber: page.pageIndex + 1,
+          pageStartOffset: page.startOffset,
+          pageEndOffset: page.endOffset,
           fragmentId: fragment.fragmentId,
           rowRange,
           ...continuation !== void 0 ? {
@@ -9371,6 +9586,7 @@ function buildTableFrameRowContexts(input) {
     return {
       tableFamily: input.tableFamily,
       rowIndex,
+      ...input.tableBlock?.rows[rowIndex]?.sourceRef !== void 0 ? { rowSourceRef: cloneSourceRef(input.tableBlock.rows[rowIndex].sourceRef) } : {},
       visualIndex,
       isRepeatedHeader: repeatedHeaderRows.has(rowIndex) && (rowIndex < input.rowRange.from || rowIndex >= input.rowRange.to),
       isInRowRange: rowIndex >= input.rowRange.from && rowIndex < input.rowRange.to,
@@ -9418,8 +9634,10 @@ function buildTableFrameCellContexts(input) {
       cells.push({
         tableFamily: rowContext.tableFamily,
         rowIndex: rowContext.rowIndex,
+        ...row2.sourceRef !== void 0 ? { rowSourceRef: cloneSourceRef(row2.sourceRef) } : {},
         visualRowIndex: rowContext.visualIndex,
         columnIndex,
+        ...cell.sourceRef !== void 0 ? { cellSourceRef: cloneSourceRef(cell.sourceRef) } : {},
         columnSpan,
         startTwips,
         widthTwips,
@@ -9548,6 +9766,12 @@ function cloneFragmentLayoutObject(layoutObject) {
     ...layoutObject.fieldRegions !== void 0 ? {
       fieldRegions: layoutObject.fieldRegions.map((region) => ({
         ...region,
+        ...region.resultRange !== void 0 ? {
+          resultRange: {
+            fromParagraphIndex: region.resultRange.fromParagraphIndex,
+            toParagraphIndex: region.resultRange.toParagraphIndex
+          }
+        } : {},
         ...region.sourceRef !== void 0 ? { sourceRef: { ...region.sourceRef } } : {},
         ...region.fieldEvidence !== void 0 ? {
           fieldEvidence: {
@@ -9557,6 +9781,20 @@ function cloneFragmentLayoutObject(layoutObject) {
         } : {}
       }))
     } : {},
+    ...layoutObject.bookmarkRanges !== void 0 ? {
+      bookmarkRanges: layoutObject.bookmarkRanges.map((range) => ({
+        ...range,
+        ...range.sourceRef !== void 0 ? { sourceRef: { ...range.sourceRef } } : {},
+        ...range.startSourceRef !== void 0 ? { startSourceRef: { ...range.startSourceRef } } : {},
+        ...range.endSourceRef !== void 0 ? { endSourceRef: { ...range.endSourceRef } } : {}
+      }))
+    } : {},
+    ...layoutObject.hyperlinks !== void 0 ? {
+      hyperlinks: layoutObject.hyperlinks.map((hyperlink) => ({
+        ...hyperlink,
+        ...hyperlink.sourceRef !== void 0 ? { sourceRef: { ...hyperlink.sourceRef } } : {}
+      }))
+    } : {},
     ...layoutObject.numbering !== void 0 ? { numbering: cloneNumberingLayoutFacts(layoutObject.numbering) } : {},
     ...layoutObject.numberingRows !== void 0 ? { numberingRows: layoutObject.numberingRows.map(cloneNumberingLayoutFacts) } : {}
   };
@@ -9564,6 +9802,10 @@ function cloneFragmentLayoutObject(layoutObject) {
 function cloneNumberingLayoutFacts(numbering) {
   return {
     ...numbering,
+    ...numbering.sourceRef !== void 0 ? { sourceRef: { ...numbering.sourceRef } } : {},
+    ...numbering.numberingSourceRef !== void 0 ? { numberingSourceRef: { ...numbering.numberingSourceRef } } : {},
+    ...numbering.numberingInstanceSourceRef !== void 0 ? { numberingInstanceSourceRef: { ...numbering.numberingInstanceSourceRef } } : {},
+    ...numbering.abstractNumberingSourceRef !== void 0 ? { abstractNumberingSourceRef: { ...numbering.abstractNumberingSourceRef } } : {},
     ...numbering.markerLane !== void 0 ? { markerLane: { ...numbering.markerLane } } : {},
     ...numbering.textColumn !== void 0 ? { textColumn: { ...numbering.textColumn } } : {},
     ...numbering.tabStops !== void 0 ? { tabStops: numbering.tabStops.map((tab) => ({ ...tab })) } : {}
@@ -9798,7 +10040,8 @@ function collectSurfaceTables(blocks, options = {}) {
         tablePath: blockPath,
         tableDepth: tableDepth + 1,
         insideSdt: options.insideSdt === true,
-        secondaryStory: options.secondaryStory === true
+        secondaryStory: options.secondaryStory === true,
+        ...block.sourceRef !== void 0 ? { sourceRef: block.sourceRef } : {}
       });
       tables.push({ table: block, tableFamily });
       for (const [rowIndex, row2] of block.rows.entries()) {
@@ -9837,6 +10080,7 @@ function tableFamilyIdentityForPath(input) {
     storyKey: input.storyKey,
     tableKey,
     tablePath: input.tablePath,
+    ...input.sourceRef !== void 0 ? { sourceRef: cloneSourceRef(input.sourceRef) } : {},
     fragmentJoinKey: tableKey,
     tableDepth: input.tableDepth,
     ...indexes,
@@ -9845,6 +10089,9 @@ function tableFamilyIdentityForPath(input) {
     ...input.secondaryStory ? { secondaryStory: true } : {}
   };
 }
+function cloneSourceRef(sourceRef) {
+  return { ...sourceRef };
+}
 function tablePathIndexes(tablePath) {
   const blockIndexes = [...tablePath.matchAll(/\/block\[(\d+)\]/gu)].map((match) => Number(match[1]));
   const storyBlockIndex = blockIndexes[0];
@@ -11843,7 +12090,6 @@ function createDocumentRuntime(options) {
   let viewportRangesKey = serializeViewportRanges(null);
   let viewportBlocksPerPageEstimate = null;
   const EDITING_CORRIDOR_BLOCK_RADIUS = 8;
-  const EDITING_CORRIDOR_MIN_BLOCKS = 24;
   const getRuntimeForLayoutFacet = () => {
     if (!runtimeRef) {
       throw new Error("Document runtime viewport methods are not initialized");
@@ -12035,6 +12281,24 @@ function createDocumentRuntime(options) {
   }
   let cachedSurface;
   let cachedFullSurface;
+  const editableTargetBlockCache = createEditableTargetBlockCache();
+  let cachedEditableTargetMap = null;
+  function getEditableTargetsByBlockPath(document) {
+    if (cachedEditableTargetMap !== null && cachedEditableTargetMap.document === document) {
+      return cachedEditableTargetMap.map;
+    }
+    perfCounters.increment("runtime.editableTargets.builds");
+    const targets = collectEditableTargetRefs(document, editableTargetBlockCache);
+    const byBlockPath = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      byBlockPath.set(target.blockPath, target);
+    }
+    cachedEditableTargetMap = { document, map: byBlockPath };
+    return byBlockPath;
+  }
+  function invalidateEditableTargetMap() {
+    cachedEditableTargetMap = null;
+  }
   let cachedCompatibility;
   let cachedComments;
   let cachedTrackedChanges;
@@ -12053,6 +12317,7 @@ function createDocumentRuntime(options) {
     }
     const snapshot = createEditorSurfaceSnapshot(document, state.selection, nextActiveStory, {
       viewportBlockRanges: null,
+      editableTargetsByBlockPath: getEditableTargetsByBlockPath(document),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -12081,6 +12346,7 @@ function createDocumentRuntime(options) {
     }
     const snapshot = createEditorSurfaceSnapshot(document, state.selection, nextActiveStory, {
       viewportBlockRanges: surfaceViewportRanges,
+      editableTargetsByBlockPath: getEditableTargetsByBlockPath(document),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -12117,7 +12383,7 @@ function createDocumentRuntime(options) {
     return enrichedSnapshot;
   }
   function getSelectionCorridorViewportRanges(previousSurface) {
-    if (!previousSurface || previousSurface.blocks.length < EDITING_CORRIDOR_MIN_BLOCKS) {
+    if (!previousSurface) {
       return viewportBlockRanges;
     }
     const caretBlockIndex = findSurfaceBlockIndexForSelection(previousSurface, state.selection);
@@ -12847,6 +13113,7 @@ function createDocumentRuntime(options) {
       activeStory,
       {
         viewportBlockRanges,
+        editableTargetsByBlockPath: getEditableTargetsByBlockPath(state.document),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
@@ -12902,6 +13169,7 @@ function createDocumentRuntime(options) {
   function invalidateDerivedRuntimeCaches() {
     cachedSurface = void 0;
     cachedFullSurface = void 0;
+    invalidateEditableTargetMap();
     cachedSurfaceFingerprint = null;
     cachedCompatibility = void 0;
     cachedComments = void 0;
@@ -13107,9 +13375,129 @@ function createDocumentRuntime(options) {
     return {
       kind: "accepted",
       command,
-      selection: createSelectionSnapshot(resolution.range.from, resolution.range.to)
+      selection: createSelectionSnapshot(resolution.range.from, resolution.range.to),
+      ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
     };
   }
+  function prepareFragmentInsertCommandForExecution(command, document, surface, storyTarget) {
+    if (!command.editableTarget) {
+      return { kind: "accepted", selection: state.selection };
+    }
+    const resolution = resolveEditableTextTarget({
+      document,
+      surface,
+      target: command.editableTarget,
+      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+    });
+    if (resolution.kind === "rejected") {
+      emit({
+        type: "command_blocked",
+        documentId: state.documentId,
+        command: command.type,
+        reasons: [{
+          code: "unsupported_surface",
+          message: resolution.blockedReason.message,
+          detail: resolution.blockedReason.code
+        }]
+      });
+      return resolution;
+    }
+    return {
+      kind: "accepted",
+      selection: createSelectionSnapshot(resolution.range.from, resolution.range.to),
+      ...resolution.textTarget ? { textTarget: resolution.textTarget } : {}
+    };
+  }
+  function prepareModeledTargetCommandForExecution(command, document, storyTarget) {
+    const resolution = resolveEditableCommandTarget({
+      document,
+      target: command.editableTarget,
+      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+      commandFamilies: command.type === "field.refresh" || command.type === "toc.refresh" ? ["field"] : ["link-bookmark"],
+      targetKinds: targetKindsForModeledCommand(command.type),
+      allowGeneratedPosture: true
+    });
+    if (resolution.kind === "rejected") {
+      emit({
+        type: "command_blocked",
+        documentId: state.documentId,
+        command: command.type,
+        reasons: [{
+          code: "unsupported_surface",
+          message: resolution.blockedReason.message,
+          detail: resolution.blockedReason.code
+        }]
+      });
+      return resolution;
+    }
+    return {
+      kind: "accepted",
+      command: {
+        ...command,
+        editableTarget: resolution.target
+      }
+    };
+  }
+  function targetKindsForModeledCommand(commandType) {
+    switch (commandType) {
+      case "field.refresh":
+        return ["field-result-text", "field-region-refresh"];
+      case "toc.refresh":
+        return ["toc-region-refresh", "field-result-text"];
+      case "bookmark.edit-content":
+        return ["bookmark-content-range"];
+      case "hyperlink.update-destination":
+        return ["hyperlink-destination"];
+    }
+  }
+  function executeRefreshCommand(command, baseState, context, storyTarget) {
+    if (command.type === "field.refresh") {
+      const refreshed2 = refreshDocumentFields(
+        baseState.document,
+        baseState.selection.head,
+        storyTarget,
+        getFullPageGraph(),
+        command.options
+      );
+      if (!refreshed2.changed) return null;
+      cachedFieldSnapshotEntry = null;
+      return executeEditorCommand(
+        baseState,
+        {
+          type: "document.replace",
+          document: refreshed2.document,
+          mapping: createEmptyMapping(),
+          protectionSelection: refreshed2.protectionSelection,
+          origin: command.origin
+        },
+        context
+      );
+    }
+    const tocId = command.options?.tocId ?? command.editableTarget.field?.tocId;
+    const refreshed = refreshDocumentTableOfContents(
+      baseState.document,
+      baseState.selection.head,
+      storyTarget,
+      {
+        ...command.options,
+        ...tocId !== void 0 ? { tocId } : {}
+      },
+      getFullDisplayPageNumber,
+      getCachedDocumentNavigationSnapshot(baseState, storyTarget)
+    );
+    if (!refreshed.changed) return null;
+    return executeEditorCommand(
+      baseState,
+      {
+        type: "document.replace",
+        document: refreshed.document,
+        mapping: createEmptyMapping(),
+        protectionSelection: refreshed.protectionSelection,
+        origin: command.origin
+      },
+      context
+    );
+  }
   const runtime = {
     subscribe(listener) {
       listeners.add(listener);
@@ -13175,7 +13563,33 @@ function createDocumentRuntime(options) {
         });
         return;
       }
-      const commandSelection = getCommandSelection(command, state.selection);
+      let executableCommand = command;
+      let commandSelection = getCommandSelection(command, state.selection);
+      let resolvedFragmentTextTarget;
+      if (command.type === "fragment.insert" && command.editableTarget) {
+        const prepared = prepareFragmentInsertCommandForExecution(
+          command,
+          state.document,
+          cachedRenderSnapshot.surface?.blocks ?? [],
+          activeStory
+        );
+        if (prepared.kind === "rejected") {
+          return;
+        }
+        commandSelection = prepared.selection;
+        resolvedFragmentTextTarget = prepared.textTarget;
+      }
+      if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
+        const prepared = prepareModeledTargetCommandForExecution(
+          command,
+          state.document,
+          activeStory
+        );
+        if (prepared.kind === "rejected") {
+          return;
+        }
+        executableCommand = prepared.command;
+      }
       if (isMutationCommand(command)) {
         const blockedReasons = workflowCoordinator.evaluateBlockedReasons(
           commandSelection,
@@ -13223,7 +13637,6 @@ function createDocumentRuntime(options) {
         return;
       }
       try {
-        let executableCommand = command;
         if (command.type === "table.apply-structure") {
           const prepared = prepareTableStructureCommandForExecution(
             command,
@@ -13239,12 +13652,17 @@ function createDocumentRuntime(options) {
           timestamp: normalizeCommandTimestamp(executableCommand.origin?.timestamp) ?? clock(),
           documentMode: workflowCoordinator.getEffectiveDocumentMode(commandSelection),
           defaultAuthorId: defaultAuthorId ?? void 0,
-          renderSnapshot: cachedRenderSnapshot
+          renderSnapshot: cachedRenderSnapshot,
+          ...resolvedFragmentTextTarget ? { textTarget: resolvedFragmentTextTarget } : {}
         };
         const preSelection = commandSelection;
         const preActiveStory = activeStory;
         const priorDocument = state.document;
-        const transaction = executeEditorCommand(state, executableCommand, context);
+        const baseState = commandSelection === state.selection ? state : { ...state, selection: commandSelection };
+        const transaction = executableCommand.type === "field.refresh" || executableCommand.type === "toc.refresh" ? executeRefreshCommand(executableCommand, baseState, context, activeStory) : executeEditorCommand(baseState, executableCommand, context);
+        if (!transaction) {
+          return;
+        }
         commit(transaction);
         options.onCommandApplied?.(executableCommand, transaction, context, {
           preSelection,
@@ -13282,6 +13700,7 @@ function createDocumentRuntime(options) {
           replaySnapshot = cachedRenderSnapshot;
         }
         let executableCommand = command;
+        let resolvedReplayTextTarget;
         if (command.type === "table.apply-structure") {
           const prepared = prepareTableStructureCommandForExecution(
             command,
@@ -13307,12 +13726,42 @@ function createDocumentRuntime(options) {
             selection: prepared.selection
           };
           executableCommand = prepared.command;
+          resolvedReplayTextTarget = prepared.textTarget;
+        } else if (command.type === "fragment.insert" && command.editableTarget) {
+          const prepared = prepareFragmentInsertCommandForExecution(
+            command,
+            replayState.document,
+            replaySnapshot.surface?.blocks ?? [],
+            replayStory
+          );
+          if (prepared.kind === "rejected") {
+            return;
+          }
+          replayState = {
+            ...replayState,
+            selection: prepared.selection
+          };
+          resolvedReplayTextTarget = prepared.textTarget;
+        } else if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
+          const prepared = prepareModeledTargetCommandForExecution(
+            command,
+            replayState.document,
+            replayStory
+          );
+          if (prepared.kind === "rejected") {
+            return;
+          }
+          executableCommand = prepared.command;
         }
         const replayContext = {
           ...context,
-          renderSnapshot: replaySnapshot
+          renderSnapshot: replaySnapshot,
+          ...resolvedReplayTextTarget ? { textTarget: resolvedReplayTextTarget } : {}
         };
-        const transaction = executeEditorCommand(replayState, executableCommand, replayContext);
+        const transaction = executableCommand.type === "field.refresh" || executableCommand.type === "toc.refresh" ? executeRefreshCommand(executableCommand, replayState, replayContext, replayStory) : executeEditorCommand(replayState, executableCommand, replayContext);
+        if (!transaction) {
+          return;
+        }
         if (crossStoryReplay) {
           commitRemote({
             ...transaction,
@@ -13394,6 +13843,7 @@ function createDocumentRuntime(options) {
             snapshotForCommand = cachedRenderSnapshot;
           }
           let executableCommand = command;
+          let resolvedReplayTextTarget;
           if (command.type === "table.apply-structure") {
             const prepared = prepareTableStructureCommandForExecution(
               command,
@@ -13419,12 +13869,42 @@ function createDocumentRuntime(options) {
               selection: prepared.selection
             };
             executableCommand = prepared.command;
+            resolvedReplayTextTarget = prepared.textTarget;
+          } else if (command.type === "fragment.insert" && command.editableTarget) {
+            const prepared = prepareFragmentInsertCommandForExecution(
+              command,
+              stateForCommand.document,
+              snapshotForCommand.surface?.blocks ?? [],
+              replayStory
+            );
+            if (prepared.kind === "rejected") {
+              continue;
+            }
+            stateForCommand = {
+              ...stateForCommand,
+              selection: prepared.selection
+            };
+            resolvedReplayTextTarget = prepared.textTarget;
+          } else if (command.type === "field.refresh" || command.type === "toc.refresh" || command.type === "bookmark.edit-content" || command.type === "hyperlink.update-destination") {
+            const prepared = prepareModeledTargetCommandForExecution(
+              command,
+              stateForCommand.document,
+              replayStory
+            );
+            if (prepared.kind === "rejected") {
+              continue;
+            }
+            executableCommand = prepared.command;
           }
           const replayContext = {
             ...context,
-            renderSnapshot: snapshotForCommand
+            renderSnapshot: snapshotForCommand,
+            ...resolvedReplayTextTarget ? { textTarget: resolvedReplayTextTarget } : {}
           };
-          const transaction = executeEditorCommand(stateForCommand, executableCommand, replayContext);
+          const transaction = executableCommand.type === "field.refresh" || executableCommand.type === "toc.refresh" ? executeRefreshCommand(executableCommand, stateForCommand, replayContext, replayStory) : executeEditorCommand(stateForCommand, executableCommand, replayContext);
+          if (!transaction) {
+            continue;
+          }
           replayState = transaction.nextState;
           stepsAccumulator.push(...transaction.mapping.steps);
           anyDirty = anyDirty || transaction.markDirty;
@@ -13837,13 +14317,13 @@ function createDocumentRuntime(options) {
       }
       return changed;
     },
-    insertFragment(fragment, target) {
+    insertFragment(fragment, target, editContext) {
       actionDepth += 1;
       actionStack.push("insertFragment");
       try {
         const timestamp = clock();
         const selection = target ? createSelectionFromPublicAnchor(target) : state.selection;
-        const editableTarget = inferEditableTargetForFragmentInsert(
+        const editableTarget = editContext?.editableTarget && isTableParagraphEditableTarget(editContext.editableTarget) ? editContext.editableTarget : inferEditableTargetForFragmentInsert(
           cachedRenderSnapshot.surface?.blocks ?? [],
           selection
         );
@@ -16463,7 +16943,7 @@ function findEditableTargetInSurfaceCell(cell, position) {
   return findEditableTargetAtSurfacePosition(cell.content, position);
 }
 function isTableParagraphEditableTarget(target) {
-  return target.commandFamily === "text-leaf" && (target.kind === "table-cell-paragraph-text" || target.kind === "nested-table-cell-paragraph-text" || target.kind === "sdt-table-cell-paragraph-text");
+  return target.editability === "editable" && target.posture.blockers.length === 0 && target.commandFamily === "text-leaf" && (target.kind === "table-cell-paragraph-text" || target.kind === "nested-table-cell-paragraph-text" || target.kind === "sdt-table-cell-paragraph-text");
 }
 function extractSelectionFragment(document, selection, activeStory) {
   const from = Math.min(selection.anchor, selection.head);