@beyondwork/docx-react-component 1.0.122 → 1.0.124

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

@@ -11,7 +11,7 @@ import {
 } from "./chunk-M6XR534O.js";
 import {
   buildBookmarkNameMap
-} from "./chunk-OBCP6VTG.js";
+} from "./chunk-NAMAWCXN.js";
 import {
   deleteSelectionOrBackward,
   deleteSelectionOrForward,
@@ -22,7 +22,7 @@ import {
   insertText,
   outdentParagraphAtSelection,
   splitParagraph
-} from "./chunk-3OFSP2IX.js";
+} from "./chunk-BOHHIVQ2.js";
 import {
   applyFormattingOperationToDocument,
   applyTextMarkOperationToDocumentRange,
@@ -32,18 +32,18 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-37SEJQ3G.js";
+} from "./chunk-RSYN6FTS.js";
 import {
   applyTextTransaction
-} from "./chunk-3OHVK2D6.js";
+} from "./chunk-IR7QV2BX.js";
 import {
   applyTableStructureOperationForEditableTarget,
   removeCellFromRow,
   removeTableRowPure
-} from "./chunk-XVFENXLK.js";
+} from "./chunk-LGWNN3L2.js";
 import {
   resolveParagraphScope
-} from "./chunk-ZKSDVHGH.js";
+} from "./chunk-KOHQFZMM.js";
 import {
   buildGeometryDebugEntry,
   collectLineBoxesForRegion,
@@ -51,7 +51,7 @@ import {
   createRenderKernel,
   incrementInvalidationCounter,
   recordPerfSample
-} from "./chunk-GZW2ERUO.js";
+} from "./chunk-N4VIXI2Z.js";
 import {
   AI_ACTION_POLICIES,
   buildFormattingDebugEntry,
@@ -74,7 +74,7 @@ import {
   resolveHeadingPath,
   resolveScope,
   serializeFragmentToWordML
-} from "./chunk-PCXTMEGY.js";
+} from "./chunk-Q76XPPTA.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -109,7 +109,7 @@ import {
   setWorkspaceMode,
   setZoomLevel,
   snapCommentAnchorAwayFromTable
-} from "./chunk-G3B2OBCZ.js";
+} from "./chunk-ZRHLLPSJ.js";
 import {
   countLogicalPositions,
   createPlainText,
@@ -128,7 +128,7 @@ import {
   replaceStoryBlocks,
   resolvePageFieldDisplayText,
   storyTargetKey
-} from "./chunk-3TUQCHYT.js";
+} from "./chunk-H6IL5ABU.js";
 import {
   createCommentSidebarProjection,
   createCommentStoreFromRuntimeComments
@@ -152,18 +152,20 @@ import {
   persistedSnapshotFromEditorSessionState,
   remapRevisionStore,
   setRevisionStatus
-} from "./chunk-UWDWGQH5.js";
+} from "./chunk-TY4DIJO3.js";
 import {
   isSupportedFieldFamily,
   parseTocLevelRange,
   resolveRefFieldText
-} from "./chunk-TMU7JMXX.js";
+} from "./chunk-A74Y5NE4.js";
 import {
   collectEditableTargetRefs,
+  collectEditableTargetRefsForStoryBlockRanges,
   collectStoryBlockContexts,
   createEditableTargetBlockCache,
-  createHeaderFooterStoryKey
-} from "./chunk-TFSXOIAI.js";
+  createHeaderFooterStoryKey,
+  sha256TextHex
+} from "./chunk-FNWKE74J.js";
 import {
   setActiveSerializeTelemetryBus
 } from "./chunk-EB6M3GE6.js";
@@ -1581,8 +1583,8 @@ function isNodeSelectableSegment(segment) {
 }
 
 // src/runtime/edit-ops/index.ts
-function validateResult(result) {
-  const maxOffset = result.storyText.length;
+function validateResult(result, context) {
+  const maxOffset = getPostMutationMaxOffset(result, context);
   const options = result.selection.activeRange.kind === "node" ? {
     isValidNodeTarget: createSurfaceNodeSelectionProbe(
       createEditorSurfaceSnapshot(result.document, result.selection)
@@ -1599,24 +1601,34 @@ function validateResult(result) {
   }
   return { ...result, selection: validated };
 }
+function getPostMutationMaxOffset(result, context) {
+  if (typeof context.activeStorySize !== "number" || context.textTarget?.kind === "text-leaf") {
+    return result.storyText.length;
+  }
+  let storySize = context.activeStorySize;
+  for (const step of result.mapping.steps) {
+    storySize += step.insertSize - Math.max(0, step.to - step.from);
+  }
+  return Math.max(result.storyText.length, storySize);
+}
 var editLayer = {
   applyTextInsert(doc, selection, text, context, formatting) {
-    return validateResult(insertText(doc, selection, text, context, formatting));
+    return validateResult(insertText(doc, selection, text, context, formatting), context);
   },
   applyDeleteBackward(doc, selection, context) {
-    return validateResult(deleteSelectionOrBackward(doc, selection, context));
+    return validateResult(deleteSelectionOrBackward(doc, selection, context), context);
   },
   applyDeleteForward(doc, selection, context) {
-    return validateResult(deleteSelectionOrForward(doc, selection, context));
+    return validateResult(deleteSelectionOrForward(doc, selection, context), context);
   },
   applyInsertTab(doc, selection, context) {
-    return validateResult(insertTab(doc, selection, context));
+    return validateResult(insertTab(doc, selection, context), context);
   },
   applyInsertHardBreak(doc, selection, context) {
-    return validateResult(insertHardBreak(doc, selection, context));
+    return validateResult(insertHardBreak(doc, selection, context), context);
   },
   applySplitParagraph(doc, selection, context) {
-    return validateResult(splitParagraph(doc, selection, context));
+    return validateResult(splitParagraph(doc, selection, context), context);
   }
 };
 
@@ -9356,12 +9368,37 @@ function toPublicStoryAnchoredObject(object) {
       }
     } : {},
     ...object.anchorRectTwips ? { anchorRectTwips: toPublicTwipsRect(object.anchorRectTwips) } : {},
+    ...object.textBoxBody ? { textBoxBody: toPublicTextBoxBodyFacts(object.textBoxBody) } : {},
     ...object.relationshipIds ? { relationshipIds: [...object.relationshipIds] } : {},
     ...object.mediaIds ? { mediaIds: [...object.mediaIds] } : {},
     preserveOnly: object.preserveOnly,
     divergenceIds: [...object.divergenceIds]
   };
 }
+function toPublicTextBoxBodyFacts(textBoxBody) {
+  return {
+    bodyKey: textBoxBody.bodyKey,
+    status: textBoxBody.status,
+    ...textBoxBody.unavailableReason !== void 0 ? { unavailableReason: textBoxBody.unavailableReason } : {},
+    ...textBoxBody.bodyProperties ? { bodyProperties: { ...textBoxBody.bodyProperties } } : {},
+    ...textBoxBody.bodyInsetsTwips ? { bodyInsetsTwips: { ...textBoxBody.bodyInsetsTwips } } : {},
+    ...textBoxBody.contentRectTwips ? { contentRectTwips: toPublicTwipsRect(textBoxBody.contentRectTwips) } : {},
+    blockCount: textBoxBody.blockCount,
+    paragraphCount: textBoxBody.paragraphCount,
+    unsupportedBlockCount: textBoxBody.unsupportedBlockCount,
+    paragraphs: textBoxBody.paragraphs.map((paragraph) => ({
+      paragraphKey: paragraph.paragraphKey,
+      blockPath: paragraph.blockPath,
+      blockIndex: paragraph.blockIndex,
+      ...paragraph.rectTwips ? { rectTwips: toPublicTwipsRect(paragraph.rectTwips) } : {},
+      ...paragraph.unavailableReason !== void 0 ? { unavailableReason: paragraph.unavailableReason } : {},
+      ...paragraph.styleId !== void 0 ? { styleId: paragraph.styleId } : {},
+      ...paragraph.alignment !== void 0 ? { alignment: paragraph.alignment } : {},
+      textLength: paragraph.textLength,
+      runCount: paragraph.runCount
+    }))
+  };
+}
 function toPublicLayoutDivergence(divergence) {
   return {
     divergenceId: divergence.divergenceId,
@@ -11933,6 +11970,26 @@ function mapLocalSelectionOnRemoteReplay(selection, mapping) {
 }
 
 // src/runtime/document-runtime.ts
+var CANONICAL_BLOCK_REFS_SYMBOL = /* @__PURE__ */ Symbol.for("wre.canonical-block-refs");
+function getLocalTextPatchMetadata(mapping) {
+  const metadata = mapping.metadata?.localTextPatch;
+  if (!metadata || typeof metadata !== "object") {
+    return null;
+  }
+  const insertedText = metadata.insertedText;
+  return typeof insertedText === "string" ? { insertedText } : null;
+}
+function getSurfaceCanonicalBlockRefs(snapshot) {
+  return snapshot[CANONICAL_BLOCK_REFS_SYMBOL];
+}
+function attachSurfaceCanonicalBlockRefs(snapshot, refs) {
+  Object.defineProperty(snapshot, CANONICAL_BLOCK_REFS_SYMBOL, {
+    value: refs,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
 function normalizeViewportRanges(ranges) {
   const cleaned = ranges.filter((r) => Number.isFinite(r.start) && Number.isFinite(r.end) && r.end > r.start).map((r) => ({ start: r.start, end: r.end }));
   if (cleaned.length === 0) return Object.freeze([]);
@@ -12296,6 +12353,22 @@ function createDocumentRuntime(options) {
     cachedEditableTargetMap = { document, map: byBlockPath };
     return byBlockPath;
   }
+  function getEditableTargetsByBlockPathForRanges(document, storyKey, ranges) {
+    if (ranges === null) return getEditableTargetsByBlockPath(document);
+    perfCounters.increment("runtime.editableTargets.boundedBuilds");
+    const targets = collectEditableTargetRefsForStoryBlockRanges(
+      document,
+      storyKey,
+      ranges,
+      editableTargetBlockCache
+    );
+    if (targets.length === 0) return /* @__PURE__ */ new Map();
+    const byBlockPath = /* @__PURE__ */ new Map();
+    for (const target of targets) {
+      byBlockPath.set(target.blockPath, target);
+    }
+    return byBlockPath;
+  }
   function invalidateEditableTargetMap() {
     cachedEditableTargetMap = null;
   }
@@ -12346,7 +12419,7 @@ function createDocumentRuntime(options) {
     }
     const snapshot = createEditorSurfaceSnapshot(document, state.selection, nextActiveStory, {
       viewportBlockRanges: surfaceViewportRanges,
-      editableTargetsByBlockPath: getEditableTargetsByBlockPath(document),
+      editableTargetsByBlockPath: options2.editableTargetsByBlockPathOverride ?? getEditableTargetsByBlockPath(document),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -12409,6 +12482,180 @@ function createDocumentRuntime(options) {
     }
     return -1;
   }
+  function cachePatchedLocalTextSurface(surface) {
+    const activeStoryKey = storyTargetKey(activeStory);
+    const rangesKey = serializeViewportRanges(surface.viewportBlockRanges);
+    cachedSurface = {
+      content: state.document.content,
+      subParts: state.document.subParts,
+      styles: state.document.styles,
+      numbering: state.document.numbering,
+      media: state.document.media,
+      preservation: state.document.preservation,
+      review: state.document.review,
+      effectiveMarkupModeProvider,
+      activeStoryKey,
+      viewportRangesKey: rangesKey,
+      snapshot: surface
+    };
+    if (surface.viewportBlockRanges === null) {
+      cachedFullSurface = {
+        content: state.document.content,
+        subParts: state.document.subParts,
+        styles: state.document.styles,
+        numbering: state.document.numbering,
+        media: state.document.media,
+        preservation: state.document.preservation,
+        review: state.document.review,
+        effectiveMarkupModeProvider,
+        activeStoryKey,
+        snapshot: surface
+      };
+    }
+    cachedSurfaceFingerprint = `${activeStoryKey}|${rangesKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
+  }
+  function tryPatchLocalTextSurface(previousSurface, mapping) {
+    const tTotal0 = performance.now();
+    try {
+      if (!previousSurface || activeStory.kind !== "main") {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const patch = getLocalTextPatchMetadata(mapping);
+      if (!patch || mapping.steps.length !== 1) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const step = mapping.steps[0];
+      if (patch.insertedText.length !== step.insertSize) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const editFrom = step.from;
+      const editTo = step.to;
+      if (editTo < editFrom || editFrom < 0) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const blockIndex = previousSurface.blocks.findIndex(
+        (block2) => block2.kind === "paragraph" && editFrom >= block2.from && editTo <= block2.to
+      );
+      if (blockIndex < 0) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const block = previousSurface.blocks[blockIndex];
+      if (block.kind !== "paragraph") {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const segmentIndex = block.segments.findIndex(
+        (segment2) => segment2.kind === "text" && editFrom >= segment2.from && editTo <= segment2.to
+      );
+      if (segmentIndex < 0) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const segment = block.segments[segmentIndex];
+      if (segment.kind !== "text") {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      if (segment.text.length !== segment.to - segment.from) {
+        perfCounters.increment("surface.localText.patchMiss");
+        return null;
+      }
+      const localFrom = editFrom - segment.from;
+      const localTo = editTo - segment.from;
+      const delta = patch.insertedText.length - (editTo - editFrom);
+      const nextText = segment.text.slice(0, localFrom) + patch.insertedText + segment.text.slice(localTo);
+      const nextSegments = block.segments.map((candidate, index) => {
+        if (index < segmentIndex) return candidate;
+        if (index === segmentIndex) {
+          return {
+            ...segment,
+            text: nextText,
+            to: segment.to + delta
+          };
+        }
+        return shiftSurfaceInlineSegment(candidate, delta);
+      });
+      const nextBlock = {
+        ...block,
+        to: block.to + delta,
+        segments: nextSegments
+      };
+      const nextBlocks = previousSurface.blocks.map((candidate, index) => {
+        if (index < blockIndex) return candidate;
+        if (index === blockIndex) return nextBlock;
+        return shiftSurfaceBlock(candidate, delta);
+      });
+      const nextPlainText = previousSurface.plainText.slice(0, editFrom) + patch.insertedText + previousSurface.plainText.slice(editTo);
+      const nextSurface = {
+        ...previousSurface,
+        storySize: previousSurface.storySize + delta,
+        plainText: nextPlainText,
+        blocks: nextBlocks
+      };
+      const refs = getSurfaceCanonicalBlockRefs(previousSurface);
+      if (refs) {
+        const nextRefs = [...refs];
+        nextRefs[blockIndex] = state.document.content.children[blockIndex] ?? null;
+        attachSurfaceCanonicalBlockRefs(nextSurface, nextRefs);
+      }
+      perfCounters.increment("surface.localText.patchHit");
+      perfCounters.increment("surface.localText.patchDelta", delta);
+      return nextSurface;
+    } finally {
+      perfCounters.increment("surface.localText.total.us", Math.round((performance.now() - tTotal0) * 1e3));
+    }
+  }
+  function shiftSurfaceInlineSegment(segment, delta) {
+    if (delta === 0) return segment;
+    return {
+      ...segment,
+      from: segment.from + delta,
+      to: segment.to + delta
+    };
+  }
+  function shiftSurfaceBlock(block, delta) {
+    if (delta === 0) return block;
+    switch (block.kind) {
+      case "paragraph":
+        return {
+          ...block,
+          from: block.from + delta,
+          to: block.to + delta,
+          segments: block.segments.map((segment) => shiftSurfaceInlineSegment(segment, delta))
+        };
+      case "table":
+        return {
+          ...block,
+          from: block.from + delta,
+          to: block.to + delta,
+          rows: block.rows.map((row2) => ({
+            ...row2,
+            cells: row2.cells.map((cell) => ({
+              ...cell,
+              content: cell.content.map((child) => shiftSurfaceBlock(child, delta))
+            }))
+          }))
+        };
+      case "sdt_block":
+        return {
+          ...block,
+          from: block.from + delta,
+          to: block.to + delta,
+          children: block.children.map((child) => shiftSurfaceBlock(child, delta))
+        };
+      case "opaque_block":
+        return {
+          ...block,
+          from: block.from + delta,
+          to: block.to + delta
+        };
+    }
+  }
   function enrichCulledPlaceholdersWithHeights(snapshot) {
     let heights;
     try {
@@ -13294,7 +13541,8 @@ function createDocumentRuntime(options) {
       document,
       target: command.editableTarget,
       activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
-      selectionDescriptor: command.selectionDescriptor
+      selectionDescriptor: command.selectionDescriptor,
+      editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
       emit({
@@ -13357,7 +13605,8 @@ function createDocumentRuntime(options) {
       document,
       surface,
       target,
-      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+      editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
       emit({
@@ -13387,7 +13636,8 @@ function createDocumentRuntime(options) {
       document,
       surface,
       target: command.editableTarget,
-      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+      activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+      editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
       emit({
@@ -13415,7 +13665,8 @@ function createDocumentRuntime(options) {
       activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
       commandFamilies: command.type === "field.refresh" || command.type === "toc.refresh" ? ["field"] : ["link-bookmark"],
       targetKinds: targetKindsForModeledCommand(command.type),
-      allowGeneratedPosture: true
+      allowGeneratedPosture: true,
+      editableTargetCache: editableTargetBlockCache
     });
     if (resolution.kind === "rejected") {
       emit({
@@ -13457,7 +13708,8 @@ function createDocumentRuntime(options) {
         baseState.selection.head,
         storyTarget,
         getFullPageGraph(),
-        command.options
+        command.options,
+        command.editableTarget
       );
       if (!refreshed2.changed) return null;
       cachedFieldSnapshotEntry = null;
@@ -13499,6 +13751,9 @@ function createDocumentRuntime(options) {
     );
   }
   const runtime = {
+    getEditableTargetCache() {
+      return editableTargetBlockCache;
+    },
     subscribe(listener) {
       listeners.add(listener);
       return () => {
@@ -15702,6 +15957,12 @@ function createDocumentRuntime(options) {
     }
     return !effects.commentAdded && !effects.commentResolved && !effects.commentReopened && !effects.commentReplyAdded && !effects.commentBodyEdited && !effects.changeAccepted && !effects.changeRejected && !effects.revisionAuthored && !effects.commandBlocked;
   }
+  function canSkipOverlaySyncForLocalText(transaction) {
+    if (transaction.mapping.steps.length !== 1) return false;
+    if (transaction.mapping.metadata?.invalidatesStructures) return false;
+    if (transaction.mapping.metadata?.scopeTagTouches) return false;
+    return getLocalTextPatchMetadata(transaction.mapping) !== null;
+  }
   function applyTransactionToState(transaction, options2 = {}) {
     const effects = transaction.effects;
     const selectionUnchanged = transaction.nextState.selection === state.selection;
@@ -15723,9 +15984,28 @@ function createDocumentRuntime(options) {
     state = finalizeState(transaction.nextState, transaction.markDirty, clock());
     perfCounters.increment("commit.finalizeState.us", Math.round((performance.now() - tFinalize0) * 1e3));
     storySelections.set(storyTargetKey(activeStory), state.selection);
+    const tClassify0 = performance.now();
+    const useLocalTextCommitSnapshot = options2.allowLocalTextFastPath === true && shouldUseLocalTextCommitSnapshot(
+      previous,
+      state,
+      transaction,
+      transaction.effects
+    );
+    perfCounters.increment("commit.refreshClassify.us", Math.round((performance.now() - tClassify0) * 1e3));
     const tOverlay0 = performance.now();
-    overlayStore.replaceOverlay(overlayStore.getOverlay(), state.document);
-    const detachedWorkflowScopeWarnings = syncDetachedWorkflowScopeWarningsInState();
+    const skipOverlaySync = useLocalTextCommitSnapshot && canSkipOverlaySyncForLocalText(transaction);
+    const detachedWorkflowScopeWarnings = skipOverlaySync ? { added: [], cleared: [] } : (() => {
+      const tReplace0 = performance.now();
+      overlayStore.replaceOverlay(overlayStore.getOverlay(), state.document);
+      perfCounters.increment("commit.overlaySync.replaceOverlay.us", Math.round((performance.now() - tReplace0) * 1e3));
+      const tWarnings0 = performance.now();
+      const result = syncDetachedWorkflowScopeWarningsInState();
+      perfCounters.increment("commit.overlaySync.detachedWarnings.us", Math.round((performance.now() - tWarnings0) * 1e3));
+      return result;
+    })();
+    if (skipOverlaySync) {
+      perfCounters.increment("commit.overlaySync.skipped");
+    }
     perfCounters.increment("commit.overlaySync.us", Math.round((performance.now() - tOverlay0) * 1e3));
     const tInvalidate0 = performance.now();
     if (transaction.markDirty && transaction.mapping.steps.length > 0) {
@@ -15759,22 +16039,34 @@ function createDocumentRuntime(options) {
         ...detachedWorkflowScopeWarnings.cleared
       ]
     };
-    const tClassify0 = performance.now();
-    const useLocalTextCommitSnapshot = options2.allowLocalTextFastPath === true && shouldUseLocalTextCommitSnapshot(
-      previous,
-      state,
-      transaction,
-      notifyEffects
-    );
-    perfCounters.increment("commit.refreshClassify.us", Math.round((performance.now() - tClassify0) * 1e3));
     if (!useLocalTextCommitSnapshot && transaction.markDirty && previous.document !== state.document) {
       applyViewportRanges(getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface));
     }
     const tValidation0 = performance.now();
-    const surfaceForValidation = useLocalTextCommitSnapshot ? getCachedSurface(state.document, activeStory, {
-      viewportBlockRangesOverride: getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface),
-      enrichCulledPlaceholders: false
-    }) : getCachedSurface(state.document, activeStory);
+    const patchedLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(cachedRenderSnapshot.surface, transaction.mapping) : null;
+    if (patchedLocalTextSurface) {
+      cachePatchedLocalTextSurface(patchedLocalTextSurface);
+      perfCounters.increment("commit.localTextValidation.storySizeOnly");
+    }
+    const localTextViewportRanges = useLocalTextCommitSnapshot && !patchedLocalTextSurface ? getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface) : void 0;
+    const localTextEditableTargetsByBlockPath = useLocalTextCommitSnapshot && !patchedLocalTextSurface ? getEditableTargetsByBlockPathForRanges(
+      state.document,
+      storyTargetKey(activeStory),
+      localTextViewportRanges ?? null
+    ) : void 0;
+    const surfaceForValidation = patchedLocalTextSurface ? patchedLocalTextSurface : useLocalTextCommitSnapshot ? (() => {
+      const tSurface0 = performance.now();
+      try {
+        perfCounters.increment("surface.localText.fullProjectionFallback");
+        return getCachedSurface(state.document, activeStory, {
+          viewportBlockRangesOverride: localTextViewportRanges,
+          enrichCulledPlaceholders: false,
+          editableTargetsByBlockPathOverride: localTextEditableTargetsByBlockPath
+        });
+      } finally {
+        perfCounters.increment("surface.localText.fullProjection.us", Math.round((performance.now() - tSurface0) * 1e3));
+      }
+    })() : getCachedSurface(state.document, activeStory);
     const validationOptions = state.selection.activeRange.kind === "node" ? {
       isValidNodeTarget: createSurfaceNodeSelectionProbe(surfaceForValidation)
     } : void 0;
@@ -16041,7 +16333,8 @@ function createDocumentRuntime(options) {
       selection,
       surface: cachedRenderSnapshot.surface?.blocks ?? [],
       target: editableTarget,
-      activeStoryKey: canonicalEditableTargetStoryKey(activeStory)
+      activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+      editableTargetCache: editableTargetBlockCache
     }) : null;
     if (targetResolution?.kind === "rejected") {
       const blockedReason = targetResolution.blockedReason;
@@ -16093,6 +16386,7 @@ function createDocumentRuntime(options) {
       documentMode: textOptions.documentModeOverride ?? workflowCoordinator.getEffectiveDocumentMode(selection),
       defaultAuthorId: defaultAuthorId ?? void 0,
       renderSnapshot: cachedRenderSnapshot,
+      activeStorySize: cachedRenderSnapshot.surface?.storySize,
       textTarget,
       rejectTargetlessTableStructureInsert: true
     };
@@ -17507,15 +17801,12 @@ function flattenInlineDisplayText(children) {
     }
   }).join("");
 }
-function refreshDocumentFields(document, selectionHead, activeStory, pageGraph, options) {
+function refreshDocumentFields(document, selectionHead, activeStory, pageGraph, options, target) {
   const supportedOnly = options?.supportedOnly ?? true;
   const bookmarkMap = buildBookmarkNameMap(document);
   const paragraphs = collectParagraphContexts(document.content.children);
-  const activePageIndex = resolveActivePageIndexFromPageGraph(
-    pageGraph,
-    selectionHead,
-    activeStory
-  );
+  void selectionHead;
+  void activeStory;
   let updatedCount = 0;
   let changed = false;
   let changedFrom;
@@ -17525,19 +17816,27 @@ function refreshDocumentFields(document, selectionHead, activeStory, pageGraph,
     let storyChangedFrom;
     let storyChangedTo;
     const refreshed = refreshBlocksWithCursor(blocks, (field, range) => {
+      if (target !== void 0 && !fieldMatchesRefreshTarget(field, target)) {
+        return field;
+      }
       if (!field.fieldFamily || !isSupportedFieldFamily(field.fieldFamily)) {
         return field;
       }
       if (supportedOnly && field.fieldFamily === "TOC") {
         return field;
       }
+      const fieldPageIndex = resolveActivePageIndexFromPageGraph(
+        pageGraph,
+        range.from,
+        storyTarget
+      );
       const display = resolveSupportedFieldDisplay(
         field,
         document,
         bookmarkMap,
         paragraphs,
         pageGraph,
-        activePageIndex,
+        fieldPageIndex,
         storyTarget
       );
       if (!display) {
@@ -17687,6 +17986,34 @@ function refreshDocumentFields(document, selectionHead, activeStory, pageGraph,
     ...protectionSelection ? { protectionSelection } : {}
   };
 }
+function fieldMatchesRefreshTarget(field, target) {
+  if (target.kind !== "field-result-text" && target.kind !== "field-region-refresh") {
+    return false;
+  }
+  const targetField = target.field;
+  if (targetField?.canonicalFieldId !== void 0) {
+    return field.canonicalFieldId === targetField.canonicalFieldId;
+  }
+  const resultText = flattenInlineDisplayText(field.children);
+  const fieldResultHash = sha256TextHex(`${field.instruction}\0${resultText}`);
+  if (target.kind === "field-result-text" && target.staleCheck.targetHash !== void 0) {
+    return target.staleCheck.targetHash === fieldResultHash;
+  }
+  if (targetField?.fieldFamily !== void 0 && targetField.fieldFamily !== field.fieldFamily) {
+    return false;
+  }
+  if (targetField?.fieldTarget !== void 0 && targetField.fieldTarget !== field.fieldTarget) {
+    return false;
+  }
+  if (target.staleCheck.sourceRef !== void 0 || target.sourceRef !== void 0) {
+    return sourceRefsEqual(target.staleCheck.sourceRef ?? target.sourceRef, field.sourceRef);
+  }
+  return false;
+}
+function sourceRefsEqual(left, right) {
+  if (left === void 0 || right === void 0) return false;
+  return left.sourceId === right.sourceId && left.partPath === right.partPath && left.storyKind === right.storyKind && left.element === right.element && left.xmlPath === right.xmlPath && left.tableCellPath === right.tableCellPath && left.tableDepth === right.tableDepth && left.ordinal === right.ordinal && left.startOffset === right.startOffset && left.endOffset === right.endOffset;
+}
 function refreshDocumentTableOfContents(document, selectionHead, activeStory, options, resolveDisplayPageNumber, navigationSnapshot) {
   const selectedRegion = selectTocRegion(document.fieldRegistry?.tocRegions, options?.tocId);
   const refreshMode = options?.mode ?? "regenerate";