@beyondwork/docx-react-component 1.0.131 → 1.0.133

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   createSearchPlugin,
   performSearch,
   searchPluginKey
-} from "./chunk-6TBLDBCL.js";
+} from "./chunk-ZFCZ7XXH.js";
 import {
   CODE_METADATA_TABLE,
   KNOWN_DIAGNOSTIC_CODES,
@@ -26,7 +26,7 @@ import {
   splitListParagraph,
   toggleBulletedList,
   toggleNumberedList
-} from "./chunk-YLL7MF5C.js";
+} from "./chunk-3JEE5RJU.js";
 import {
   applyParagraphStyleToDocument
 } from "./chunk-6EXNNAO6.js";
@@ -37,7 +37,7 @@ import {
   setSectionPageNumberingAtSectionIndex,
   updateSectionLayoutAtSectionIndex
 } from "./chunk-M6XR534O.js";
-import "./chunk-ZVC23LKV.js";
+import "./chunk-RP76USJE.js";
 import {
   createRuntimeCollabSync,
   createRuntimeCommandAppliedBridge
@@ -45,7 +45,7 @@ import {
 import {
   insertPageBreak,
   insertTable
-} from "./chunk-QXKQPUOM.js";
+} from "./chunk-REFHJ2FN.js";
 import {
   getFormattingStateFromRenderSnapshot
 } from "./chunk-Y4XZCMCS.js";
@@ -53,13 +53,13 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-KNHMXKC6.js";
-import "./chunk-T5YYFDZB.js";
+} from "./chunk-INLRCC4N.js";
+import "./chunk-MQ5GAJ54.js";
 import {
   getTableStructureContext,
   tableStructureActionHandleForTarget
-} from "./chunk-Q7Y57KOK.js";
-import "./chunk-PHMWH23E.js";
+} from "./chunk-WDDFU2N2.js";
+import "./chunk-QTRJLKR2.js";
 import {
   MOUNTED_SURFACE_VIEWPORT_BLOCK_THRESHOLD,
   OverlayAnchorBridgeProvider,
@@ -83,18 +83,15 @@ import {
   resolveScopedChromePolicy,
   resolveScrollTopForAnchor,
   resolveSelectionToolRegistry,
+  sanitizeNumberingPictureBulletSrc,
   shouldRenderAbsoluteFloatingImageInPageOverlay,
   shouldRenderSelectionToolKind,
-  shouldUseMountedSurfaceViewportCulling
-} from "./chunk-3YCQM2RV.js";
+  shouldUseMountedSurfaceViewportCulling,
+  useLayoutFacetRenderSignal
+} from "./chunk-S3PEKX6H.js";
 import {
-  PREDICTED_LANE_COUNTERS,
-  createInertGeometryFacet,
-  finishPerfProbe,
-  incrementInvalidationCounter,
-  recordPerfSample,
-  startPerfProbe
-} from "./chunk-35RHOE6I.js";
+  createInertGeometryFacet
+} from "./chunk-57HTKX3P.js";
 import {
   composeSeriesColor,
   computeStructuralHash,
@@ -108,12 +105,12 @@ import {
   resolveColor,
   tryReadLaycacheEnvelope,
   writeEnvelopeToOpcPackage
-} from "./chunk-WZDKNF37.js";
+} from "./chunk-OTRVGNZQ.js";
 import {
   findTextMatches,
   parseCanonicalFragmentFromWordML,
   searchDocument
-} from "./chunk-7G5GR3VV.js";
+} from "./chunk-224TSMEB.js";
 import {
   clearLocalCursorState,
   getCursorColorForUser,
@@ -123,23 +120,29 @@ import {
 import {
   resolveChromePreset,
   resolveChromeVisibilityForPreset
-} from "./chunk-CI2TD3T4.js";
+} from "./chunk-NJFKPDNG.js";
 import {
   CAPABILITY_BY_ID,
   ISSUE_METADATA_ID,
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   MetadataResolverMissingError,
+  PREDICTED_LANE_COUNTERS,
   REVIEW_ACTION_METADATA_ID,
   buildPagePreviewMaps,
   createEditorViewStateSnapshot,
   createLayoutEngine,
+  createPagePatchPlan,
   createScopeTagRegistry,
   createViewState,
   deriveCapabilities,
+  finishPerfProbe,
+  incrementInvalidationCounter,
+  recordPerfSample,
   sanitizeMarkdown,
-  sha256Hex
-} from "./chunk-THVM6EP5.js";
+  sha256Hex,
+  startPerfProbe
+} from "./chunk-CVSD3UNK.js";
 import "./chunk-OVLZQ6FZ.js";
 import "./chunk-QIO6V46H.js";
 import {
@@ -147,7 +150,7 @@ import {
   getStoryBlocks,
   replaceStoryBlocks,
   stableChartId
-} from "./chunk-A3GSNB4G.js";
+} from "./chunk-XBQFDBXE.js";
 import "./chunk-SYQWQ6FE.js";
 import {
   createDefaultCanonicalDocument,
@@ -158,14 +161,14 @@ import {
   SessionNotOpenError,
   SessionNotWiredError,
   isReopenBarrier
-} from "./chunk-DGA7M77X.js";
+} from "./chunk-V2JF42SI.js";
 import {
   createHmacSigner,
   createHmacVerifier,
   loadDocxSessionSync,
   signWorkflowPayloadXml,
   verifyWorkflowPayloadXml
-} from "./chunk-VRKK2CSZ.js";
+} from "./chunk-EFEW7BTT.js";
 import {
   EDITOR_SESSION_STATE_VERSION,
   assertEditorSessionState,
@@ -174,8 +177,8 @@ import {
   editorSessionStateFromPersistedSnapshot,
   persistedSnapshotFromEditorSessionState,
   validateEditorSessionState
-} from "./chunk-4YCWECLZ.js";
-import "./chunk-M7YRJX6V.js";
+} from "./chunk-PZIEOEJZ.js";
+import "./chunk-T66OS7MN.js";
 import {
   decodePersistedSourcePackageBytes,
   hasValidPersistedSourcePackageDigest
@@ -187,7 +190,7 @@ import {
   collectEditableTargetRefs,
   createHeaderFooterStoryKey,
   createNoteStoryKey
-} from "./chunk-A66ZVUAT.js";
+} from "./chunk-5KTJKTNE.js";
 import {
   readOpcPackage
 } from "./chunk-WUDSNHWF.js";
@@ -325,6 +328,9 @@ function applyListAwareTextCommand(context, command, deps) {
       if (!paragraphContext.atParagraphStart || !context.localSnapshot.selection.isCollapsed) {
         return null;
       }
+      if (shouldRouteListBoundaryJoinThroughTextCommand(context, paragraphContext)) {
+        return null;
+      }
       const result = backspaceAtListStart(
         context.localDocument,
         paragraphContext.paragraphIndex,
@@ -365,6 +371,39 @@ function listCommandTargetOptions(context, paragraphContext) {
   }
   return { editableTargets: [paragraphContext.paragraph.editableTarget] };
 }
+function shouldRouteListBoundaryJoinThroughTextCommand(context, paragraphContext) {
+  const currentNumbering = paragraphContext.paragraph.numbering;
+  const currentTarget = paragraphContext.paragraph.editableTarget;
+  if (context.activeStory.kind !== "main" || !currentNumbering || currentNumbering.level > 0 || currentTarget?.listAddress?.operationScope !== "list-text") {
+    return false;
+  }
+  const paragraphs = collectSurfaceParagraphs(context.localSnapshot.surface?.blocks ?? []);
+  const previous = paragraphs[paragraphContext.paragraphIndex - 1];
+  const previousNumbering = previous?.numbering;
+  return Boolean(
+    previousNumbering && previousNumbering.numberingInstanceId === currentNumbering.numberingInstanceId && previousNumbering.level === currentNumbering.level
+  );
+}
+function collectSurfaceParagraphs(blocks, output = []) {
+  for (const block of blocks) {
+    if (block.kind === "paragraph") {
+      output.push(block);
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectSurfaceParagraphs(cell.content, output);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectSurfaceParagraphs(block.children, output);
+    }
+  }
+  return output;
+}
 function createListMutationResult(result, selection, deps) {
   return {
     changed: result.affectedParagraphIndexes.length > 0,
@@ -401,13 +440,23 @@ function dispatchTextCommand(runtime, command, deps) {
   }
   switch (command.type) {
     case "insert-text":
-      runtime.applyActiveStoryTextCommand({ type: "text.insert", text: command.text });
+      runtime.applyActiveStoryTextCommand({
+        type: "text.insert",
+        text: command.text,
+        ...mountedListTextTarget(context, deps)
+      });
       return;
     case "delete-backward":
-      runtime.applyActiveStoryTextCommand({ type: "text.delete-backward" });
+      runtime.applyActiveStoryTextCommand({
+        type: "text.delete-backward",
+        ...mountedListTextTarget(context, deps)
+      });
       return;
     case "delete-forward":
-      runtime.applyActiveStoryTextCommand({ type: "text.delete-forward" });
+      runtime.applyActiveStoryTextCommand({
+        type: "text.delete-forward",
+        ...mountedListTextTarget(context, deps)
+      });
       return;
     case "insert-tab":
       runtime.applyActiveStoryTextCommand({ type: "text.insert-tab" });
@@ -416,13 +465,30 @@ function dispatchTextCommand(runtime, command, deps) {
       runtime.applyActiveStoryTextCommand({ type: "text.outdent-tab" });
       return;
     case "insert-hard-break":
-      runtime.applyActiveStoryTextCommand({ type: "text.insert-hard-break" });
+      runtime.applyActiveStoryTextCommand({
+        type: "text.insert-hard-break",
+        ...mountedListTextTarget(context, deps)
+      });
       return;
     case "split-paragraph":
-      runtime.applyActiveStoryTextCommand({ type: "paragraph.split" });
+      runtime.applyActiveStoryTextCommand({
+        type: "paragraph.split",
+        ...mountedListTextTarget(context, deps)
+      });
       return;
   }
 }
+function mountedListTextTarget(context, deps) {
+  const selectionTarget = context.localSnapshot.selection.editableTarget;
+  if (selectionTarget?.listAddress?.operationScope === "list-text") {
+    return { editableTarget: selectionTarget };
+  }
+  const paragraphTarget = deps.resolveActiveParagraphContext(context.localSnapshot)?.paragraph.editableTarget;
+  if (paragraphTarget?.listAddress?.operationScope === "list-text") {
+    return { editableTarget: paragraphTarget };
+  }
+  return {};
+}
 function getMountedTextCommandName(command) {
   switch (command.type) {
     case "insert-text":
@@ -5331,7 +5397,7 @@ var editorSchema = new Schema({
         if (typeof numberingMarkerStartTwips === "number") {
           attrs["data-numbering-marker-start-twips"] = String(numberingMarkerStartTwips);
         }
-        const _numberingMarkerWidthTwips = node.attrs.numberingMarkerWidth;
+        const _numberingMarkerWidthTwips = node.attrs.numberingMarkerWidth ?? node.attrs.indentHanging;
         if (typeof _numberingMarkerWidthTwips === "number" && _numberingMarkerWidthTwips > 0) {
           attrs["data-numbering-marker-width-twips"] = String(
             _numberingMarkerWidthTwips
@@ -5347,7 +5413,9 @@ var editorSchema = new Schema({
         const numberingMarkerWidth = node.attrs.numberingMarkerWidth;
         const numberingMarkerStart = node.attrs.numberingMarkerStart;
         const numberingMarkerJustification = node.attrs.numberingMarkerJustification;
-        const numberingPicBulletSrc = node.attrs.numberingPicBulletSrc;
+        const numberingPicBulletSrc = sanitizeNumberingPictureBulletSrc(
+          node.attrs.numberingPicBulletSrc
+        );
         const children = [];
         if (pageBreak) {
           attrs["data-page-break-before"] = "true";
@@ -5403,6 +5471,7 @@ var editorSchema = new Schema({
             {
               class: baseClasses.join(" "),
               contenteditable: "false",
+              "data-numbering-marker": "true",
               "data-numbering-prefix": numberingPicBulletSrc ? "" : numberingPrefix ?? "",
               ...typeof numberingLevel === "number" ? { "data-numbering-level": String(numberingLevel) } : {},
               ...numberingSuffix ? { "data-numbering-suffix": numberingSuffix } : {},
@@ -5774,13 +5843,17 @@ var editorSchema = new Schema({
       },
       toDOM(node) {
         const refreshStatus = node.attrs.refreshStatus;
+        const fieldTarget = node.attrs.fieldTarget;
         const statusClass = refreshStatus === "current" ? "text-blue-700 bg-blue-50 border-blue-200" : refreshStatus === "unresolvable" ? "text-amber-800 bg-amber-50 border-amber-200" : "text-slate-700 bg-slate-50 border-slate-200";
         return [
           "span",
           {
             class: `inline-flex items-center gap-1 mx-0.5 px-1.5 py-0.5 rounded text-xs border ${statusClass}`,
             "data-node-type": "field_ref_atom",
+            "data-generated-field": "true",
             "data-field-family": node.attrs.fieldFamily,
+            ...fieldTarget ? { "data-field-target": fieldTarget } : {},
+            "data-field-refresh-status": refreshStatus,
             title: node.attrs.instruction
           },
           node.attrs.label || "Field"
@@ -6937,6 +7010,28 @@ function paragraphNeighborDigest(p) {
 function paragraphExternalKey(prev, next, mediaPreviewsId, showUnsupportedObjectPreviews, renderAbsoluteFloatingObjectsInPageOverlay) {
   return `p|${paragraphNeighborDigest(prev)}|${paragraphNeighborDigest(next)}|m${mediaPreviewsId}|${showUnsupportedObjectPreviews ? 1 : 0}|${renderAbsoluteFloatingObjectsInPageOverlay ? 1 : 0}`;
 }
+function topLevelBlockExternalKey(input) {
+  const common = `m${input.mediaPreviewsId}|${input.showUnsupportedObjectPreviews ? 1 : 0}|${input.renderAbsoluteFloatingObjectsInPageOverlay ? 1 : 0}`;
+  if (input.block.kind === "paragraph") {
+    return paragraphExternalKey(
+      input.previousParagraph,
+      input.nextParagraph,
+      input.mediaPreviewsId,
+      input.showUnsupportedObjectPreviews,
+      input.renderAbsoluteFloatingObjectsInPageOverlay
+    );
+  }
+  if (input.block.kind === "table") {
+    return `t|${common}`;
+  }
+  if (input.block.kind === "sdt_block") {
+    return `sdt|${common}`;
+  }
+  if (input.block.kind === "opaque_block") {
+    return `opaque|${input.showUnsupportedObjectPreviews ? 1 : 0}`;
+  }
+  return null;
+}
 function cacheLookup(blockRef, externalKey) {
   const bucket = pmNodeCache.get(blockRef);
   if (!bucket) return null;
@@ -7103,69 +7198,77 @@ function buildPMBlocks(blocks, mediaPreviews, showUnsupportedObjectPreviews, ren
     const nextBlock = blocks[index + 1];
     const previousParagraph = previousBlock?.kind === "paragraph" ? previousBlock : null;
     const nextParagraph = nextBlock?.kind === "paragraph" ? nextBlock : null;
-    if (block.kind === "paragraph") {
-      const ref = blockRefs?.[index] ?? null;
-      if (ref !== null) {
-        const extKey = paragraphExternalKey(
-          previousParagraph,
-          nextParagraph,
-          mediaId,
-          showUnsupportedObjectPreviews,
-          renderAbsoluteFloatingObjectsInPageOverlay
-        );
-        const cached = cacheLookup(ref, extKey);
-        if (cached) {
-          identityCacheHits += 1;
-          nodes.push(cached);
-          continue;
-        }
-        identityCacheMisses += 1;
-        const built = buildParagraph(
-          block,
-          previousParagraph,
-          nextParagraph,
-          mediaPreviews,
-          showUnsupportedObjectPreviews,
-          renderAbsoluteFloatingObjectsInPageOverlay
-        );
-        cacheStore(ref, extKey, built);
-        nodes.push(built);
+    const ref = blockRefs?.[index] ?? null;
+    const externalKey = ref === null ? null : topLevelBlockExternalKey({
+      block,
+      previousParagraph,
+      nextParagraph,
+      mediaPreviewsId: mediaId,
+      showUnsupportedObjectPreviews,
+      renderAbsoluteFloatingObjectsInPageOverlay
+    });
+    if (ref !== null && externalKey !== null) {
+      const cached = cacheLookup(ref, externalKey);
+      if (cached) {
+        identityCacheHits += 1;
+        nodes.push(cached);
         continue;
       }
-      nodes.push(
-        buildParagraph(
-          block,
-          previousParagraph,
-          nextParagraph,
-          mediaPreviews,
-          showUnsupportedObjectPreviews,
-          renderAbsoluteFloatingObjectsInPageOverlay
-        )
-      );
-    } else if (block.kind === "table") {
-      nodes.push(
-        buildTable(
-          block,
-          mediaPreviews,
-          showUnsupportedObjectPreviews,
-          renderAbsoluteFloatingObjectsInPageOverlay
-        )
-      );
-    } else if (block.kind === "sdt_block") {
-      nodes.push(
-        buildSdtBlock(
-          block,
-          mediaPreviews,
-          showUnsupportedObjectPreviews,
-          renderAbsoluteFloatingObjectsInPageOverlay
-        )
+      identityCacheMisses += 1;
+      const built = buildPMBlock(
+        block,
+        previousParagraph,
+        nextParagraph,
+        mediaPreviews,
+        showUnsupportedObjectPreviews,
+        renderAbsoluteFloatingObjectsInPageOverlay
       );
-    } else {
-      nodes.push(buildOpaqueBlock(block, showUnsupportedObjectPreviews));
+      cacheStore(ref, externalKey, built);
+      nodes.push(built);
+      continue;
     }
+    nodes.push(
+      buildPMBlock(
+        block,
+        previousParagraph,
+        nextParagraph,
+        mediaPreviews,
+        showUnsupportedObjectPreviews,
+        renderAbsoluteFloatingObjectsInPageOverlay
+      )
+    );
   }
   return nodes;
 }
+function buildPMBlock(block, previousParagraph, nextParagraph, mediaPreviews, showUnsupportedObjectPreviews, renderAbsoluteFloatingObjectsInPageOverlay) {
+  if (block.kind === "paragraph") {
+    return buildParagraph(
+      block,
+      previousParagraph,
+      nextParagraph,
+      mediaPreviews,
+      showUnsupportedObjectPreviews,
+      renderAbsoluteFloatingObjectsInPageOverlay
+    );
+  }
+  if (block.kind === "table") {
+    return buildTable(
+      block,
+      mediaPreviews,
+      showUnsupportedObjectPreviews,
+      renderAbsoluteFloatingObjectsInPageOverlay
+    );
+  }
+  if (block.kind === "sdt_block") {
+    return buildSdtBlock(
+      block,
+      mediaPreviews,
+      showUnsupportedObjectPreviews,
+      renderAbsoluteFloatingObjectsInPageOverlay
+    );
+  }
+  return buildOpaqueBlock(block, showUnsupportedObjectPreviews);
+}
 function buildParagraph(block, previousParagraph, nextParagraph, mediaPreviews, showUnsupportedObjectPreviews, renderAbsoluteFloatingObjectsInPageOverlay) {
   const content = [];
   const paragraphLayout = resolveParagraphLayout(block);
@@ -7242,7 +7345,7 @@ function buildParagraph(block, previousParagraph, nextParagraph, mediaPreviews,
       numberingPicBulletSrc: (() => {
         const mediaId = block.resolvedNumbering?.picBulletMediaId;
         if (!mediaId) return null;
-        return mediaPreviews[mediaId]?.src ?? null;
+        return sanitizeNumberingPictureBulletSrc(mediaPreviews[mediaId]?.src);
       })(),
       shadingFill: block.shading?.fill ?? cascade?.shading?.fill ?? null,
       borderTop: block.borders?.top ?? cascadeBorders?.top ?? null,
@@ -7792,9 +7895,9 @@ function resolveDropSelectionFromCoordinates(view, event) {
   if (selection.eq(view.state.selection)) return;
   view.dispatch(view.state.tr.setSelection(selection));
 }
-function applyPasteSegmentsToCallbacks(segments, callbacks) {
+function applyPasteSegmentsToCallbacks(segments, callbacks, context) {
   if (callbacks.onPastePlainTextFragment && callbacks.shouldPastePlainTextAsFragment?.() !== false && segments.some((seg) => seg.kind === "split") && segments.some((seg) => seg.kind === "text" && seg.value.length > 0)) {
-    callbacks.onPastePlainTextFragment(createPlainTextFragmentFromSegments(segments));
+    callbacks.onPastePlainTextFragment(createPlainTextFragmentFromSegments(segments), context);
     return;
   }
   for (const seg of segments) {
@@ -7864,6 +7967,34 @@ function applyContextMenuEvent(callbacks, event) {
     return false;
   }
 }
+function elementFromEventTarget(target) {
+  if (!target) return null;
+  const maybeElement = target;
+  if (typeof maybeElement.closest === "function") return maybeElement;
+  const maybeNode = target;
+  return maybeNode.parentElement ?? null;
+}
+function applyNumberingMarkerClick(view, event) {
+  const targetElement = elementFromEventTarget(event.target);
+  const marker = targetElement?.closest('[data-numbering-marker="true"]');
+  if (!marker) return false;
+  const paragraph = marker.closest('p[data-numbered="true"]');
+  if (!paragraph) return false;
+  const content = paragraph.querySelector(".pm-paragraph-content");
+  if (!content) return false;
+  let contentStart;
+  try {
+    contentStart = view.posAtDOM(content, 0);
+  } catch {
+    return false;
+  }
+  const docSize = view.state.doc.content.size;
+  const boundedStart = Math.max(0, Math.min(contentStart, docSize));
+  const selection = TextSelection2.near(view.state.doc.resolve(boundedStart), 1);
+  event.preventDefault();
+  view.dispatch(view.state.tr.setSelection(selection).scrollIntoView());
+  return true;
+}
 var bridgeKey = new PluginKey("command-bridge");
 function createSelectionSyncPlugin(callbacks) {
   return new Plugin({
@@ -8001,6 +8132,9 @@ function createCommandBridgePlugins(callbacks, options) {
         // behavior (back-compat).
         contextmenu(_view, event) {
           return applyContextMenuEvent(callbacks, event);
+        },
+        click(view, event) {
+          return applyNumberingMarkerClick(view, event);
         }
       },
       handleTextInput(_view, _from, _to, text) {
@@ -8027,10 +8161,12 @@ function createCommandBridgePlugins(callbacks, options) {
       // through to Tier A so the user isn't left with a silent no-op.
       handlePaste(_view, event) {
         if (isComposing) return true;
-        if (!isPmEditTargetEditable(_view.state, callbacks.getPositionMap())) {
+        const positionMap = callbacks.getPositionMap();
+        if (!isPmEditTargetEditable(_view.state, positionMap)) {
           callbacks.onBlockedInput?.("paste", NON_EDITABLE_INPUT_MESSAGE);
           return true;
         }
+        const editableTarget = resolveCurrentEditableTarget(_view.state, positionMap);
         const clipboard = event.clipboardData;
         if (!clipboard) {
           callbacks.onBlockedInput?.("paste", "Clipboard data was not available.");
@@ -8052,7 +8188,11 @@ function createCommandBridgePlugins(callbacks, options) {
           if (wordml) {
             const parsed = options.pasteFragmentParser.parseWordML(wordml);
             if (parsed.ok && parsed.fragment.blocks.length > 0) {
-              callbacks.onPasteFragment({ fragment: parsed.fragment, source: "wordml" });
+              callbacks.onPasteFragment({
+                fragment: parsed.fragment,
+                source: "wordml",
+                ...editableTarget ? { editableTarget } : {}
+              });
               return true;
             }
           }
@@ -8062,7 +8202,11 @@ function createCommandBridgePlugins(callbacks, options) {
           if (htmlPayload && htmlPayload.trim().length > 0) {
             const parsed = options.pasteFragmentParser.parseHtml(htmlPayload);
             if (parsed.ok && parsed.fragment.blocks.length > 0) {
-              callbacks.onPasteFragment({ fragment: parsed.fragment, source: "html" });
+              callbacks.onPasteFragment({
+                fragment: parsed.fragment,
+                source: "html",
+                ...editableTarget ? { editableTarget } : {}
+              });
               return true;
             }
           }
@@ -8076,7 +8220,11 @@ function createCommandBridgePlugins(callbacks, options) {
           return true;
         }
         const segments = extractPlainTextSegments(plain);
-        applyPasteSegmentsToCallbacks(segments, callbacks);
+        applyPasteSegmentsToCallbacks(
+          segments,
+          callbacks,
+          editableTarget ? { editableTarget } : void 0
+        );
         callbacks.onPasteApplied?.({
           segmentCount: segments.length,
           charCount: totalTextCharCount(segments),
@@ -8137,7 +8285,11 @@ function createCommandBridgePlugins(callbacks, options) {
           return true;
         }
         const segments = extractPlainTextSegments(plain);
-        applyPasteSegmentsToCallbacks(segments, callbacks);
+        applyPasteSegmentsToCallbacks(
+          segments,
+          callbacks,
+          editableTarget ? { editableTarget } : void 0
+        );
         callbacks.onPasteApplied?.({
           segmentCount: segments.length,
           charCount: totalTextCharCount(segments),
@@ -9674,6 +9826,7 @@ function createSurfaceDecorationKey(input) {
     showTrackedChanges: input.showTrackedChanges,
     suggestionsEnabled: input.suggestionsEnabled ?? false,
     canEdit: input.canEdit,
+    pageBreakRevision: input.pageBreakRevision ?? 0,
     activeCommentId: input.activeCommentId ?? null,
     activeRevisionId: input.activeRevisionId ?? null,
     workflowScopeSignature: input.workflowScopeSignature ?? null,
@@ -9686,6 +9839,375 @@ function createSurfaceDecorationKey(input) {
   });
 }
 
+// src/ui-tailwind/editor-surface/pm-page-body-patch.ts
+function resolvePmPageBodyPatchPlan(input) {
+  const membershipChangedPageIds = [
+    ...input.patchPlan.addedPages,
+    ...input.patchPlan.removedPages
+  ];
+  if (membershipChangedPageIds.length > 0 && input.currentDoc.childCount !== input.nextDoc.childCount) {
+    return {
+      status: "fallback",
+      reason: "page-membership-change",
+      pageIds: membershipChangedPageIds
+    };
+  }
+  if (input.currentDoc.childCount !== input.previousSurface.blocks.length || input.nextDoc.childCount !== input.nextSurface.blocks.length) {
+    return {
+      status: "fallback",
+      reason: "doc-child-count-mismatch",
+      pageIds: input.realization.patchPageIds
+    };
+  }
+  const changedEntriesByPageId = new Map(
+    input.patchPlan.changedPages.map((entry) => [entry.pageId, entry])
+  );
+  const rawSpans = [];
+  const skippedPageIds = [];
+  for (const pageId of input.realization.patchPageIds) {
+    const entry = changedEntriesByPageId.get(pageId);
+    if (!entry || !entry.regionChanges.includes("body") || entry.fragmentChanges.length === 0) {
+      skippedPageIds.push(pageId);
+      continue;
+    }
+    const previousPage = input.previousFrame.pages.find((page) => page.page.pageId === pageId);
+    const nextPage = input.nextFrame.pages.find((page) => page.page.pageId === pageId);
+    if (!previousPage || !nextPage) {
+      return { status: "fallback", reason: "page-not-found", pageIds: [pageId] };
+    }
+    const previousRange = findBlockIndexRangeForPage(
+      input.previousSurface.blocks,
+      previousPage.page
+    );
+    const nextRange = findBlockIndexRangeForPage(input.nextSurface.blocks, nextPage.page);
+    if (!previousRange || !nextRange) {
+      return {
+        status: "fallback",
+        reason: "page-has-no-block-range",
+        pageIds: [pageId]
+      };
+    }
+    const nestedSpan = resolveNestedPatchSpan({
+      pageId,
+      changedFragmentIds: entry.fragmentChanges,
+      previousSurface: input.previousSurface,
+      nextSurface: input.nextSurface,
+      currentDoc: input.currentDoc,
+      nextDoc: input.nextDoc,
+      previousRange,
+      nextRange
+    });
+    if (nestedSpan.status === "fallback") {
+      return {
+        status: "fallback",
+        reason: nestedSpan.reason,
+        pageIds: [pageId]
+      };
+    }
+    if (nestedSpan.status === "nested") {
+      rawSpans.push(nestedSpan.span);
+      continue;
+    }
+    const topLevelSpans = resolveTopLevelFragmentPatchSpans({
+      pageId,
+      changedFragmentIds: entry.fragmentChanges,
+      previousSurface: input.previousSurface,
+      nextSurface: input.nextSurface,
+      previousRange,
+      nextRange
+    });
+    rawSpans.push(
+      ...topLevelSpans ?? [
+        {
+          pageIds: [pageId],
+          fromBlockIndex: previousRange.first,
+          toBlockIndex: previousRange.last + 1,
+          nextFromBlockIndex: nextRange.first,
+          nextToBlockIndex: nextRange.last + 1
+        }
+      ]
+    );
+  }
+  if (rawSpans.length === 0) {
+    if (membershipChangedPageIds.length > 0 && !input.currentDoc.eq(input.nextDoc)) {
+      return {
+        status: "fallback",
+        reason: "page-membership-change",
+        pageIds: membershipChangedPageIds
+      };
+    }
+    return {
+      status: "fallback",
+      reason: "no-body-fragment-changes",
+      pageIds: skippedPageIds
+    };
+  }
+  const spans = mergePatchSpans(rawSpans).map((span) => ({
+    ...span,
+    fromPm: span.fromPm ?? topLevelPositionForBlockIndex(input.currentDoc, span.fromBlockIndex),
+    toPm: span.toPm ?? topLevelPositionForBlockIndex(input.currentDoc, span.toBlockIndex),
+    nextFromPm: span.nextFromPm ?? topLevelPositionForBlockIndex(input.nextDoc, span.nextFromBlockIndex),
+    nextToPm: span.nextToPm ?? topLevelPositionForBlockIndex(input.nextDoc, span.nextToBlockIndex)
+  }));
+  const selection = input.currentSelection;
+  if (selection) {
+    const intersecting = spans.find(
+      (span) => selectionIntersectsSpan(selection, span.fromPm, span.toPm)
+    );
+    if (intersecting) {
+      return {
+        status: "fallback",
+        reason: "selection-intersects-replacement",
+        pageIds: intersecting.pageIds
+      };
+    }
+  }
+  return {
+    status: "patch",
+    spans,
+    skippedPageIds,
+    replacedBlockCount: spans.reduce(
+      (total, span) => total + (span.replacedBlockCount ?? span.toBlockIndex - span.fromBlockIndex),
+      0
+    )
+  };
+}
+function resolveNestedPatchSpan(input) {
+  if (input.previousRange.first !== input.previousRange.last || input.nextRange.first !== input.nextRange.last || input.previousRange.first !== input.nextRange.first) {
+    return { status: "top-level" };
+  }
+  const topIndex = input.previousRange.first;
+  const previousTop = input.previousSurface.blocks[topIndex];
+  const nextTop = input.nextSurface.blocks[topIndex];
+  if (!previousTop || !nextTop || previousTop.kind !== nextTop.kind) {
+    return { status: "top-level" };
+  }
+  if (previousTop.kind !== "table" && previousTop.kind !== "sdt_block") {
+    return { status: "top-level" };
+  }
+  const changedIds = input.changedFragmentIds.filter(
+    (id) => id !== "<added>" && id !== "<removed>"
+  );
+  if (changedIds.length !== input.changedFragmentIds.length) {
+    return { status: "top-level" };
+  }
+  if (changedIds.includes(previousTop.blockId) || changedIds.includes(nextTop.blockId)) {
+    return { status: "top-level" };
+  }
+  if (changedIds.length === 0) {
+    return { status: "top-level" };
+  }
+  const previousLocated = changedIds.map(
+    (id) => findNestedBlockSpanById(input.previousSurface.blocks, input.currentDoc, id)
+  );
+  const nextLocated = changedIds.map(
+    (id) => findNestedBlockSpanById(input.nextSurface.blocks, input.nextDoc, id)
+  );
+  if (previousLocated.some((span) => !span) || nextLocated.some((span) => !span)) {
+    return { status: "fallback", reason: "nested-span-unavailable" };
+  }
+  if (previousLocated.some(isUnpatchableVerticalMergeContinuationSpan) || nextLocated.some(isUnpatchableVerticalMergeContinuationSpan)) {
+    return { status: "fallback", reason: "split-row-continuation" };
+  }
+  const previousSpans = previousLocated;
+  const nextSpans = nextLocated;
+  const previousKinds = new Set(previousSpans.map((span) => span.block.kind));
+  const nextKinds = new Set(nextSpans.map((span) => span.block.kind));
+  if (previousKinds.size !== nextKinds.size || [...previousKinds].some((kind) => !nextKinds.has(kind))) {
+    return { status: "fallback", reason: "nested-span-unavailable" };
+  }
+  return {
+    status: "nested",
+    span: {
+      pageIds: [input.pageId],
+      fromBlockIndex: topIndex,
+      toBlockIndex: topIndex + 1,
+      nextFromBlockIndex: topIndex,
+      nextToBlockIndex: topIndex + 1,
+      fromPm: Math.min(...previousSpans.map((span) => span.fromPm)),
+      toPm: Math.max(...previousSpans.map((span) => span.toPm)),
+      nextFromPm: Math.min(...nextSpans.map((span) => span.fromPm)),
+      nextToPm: Math.max(...nextSpans.map((span) => span.toPm)),
+      replacedBlockCount: previousSpans.length
+    }
+  };
+}
+function isUnpatchableVerticalMergeContinuationSpan(span) {
+  return Boolean(
+    span?.insideVerticalMergeContinuation && span.fromPm >= span.toPm
+  );
+}
+function resolveTopLevelFragmentPatchSpans(input) {
+  const changedIds = uniqueStableFragmentIds(input.changedFragmentIds);
+  if (changedIds.length !== input.changedFragmentIds.length || changedIds.length === 0) {
+    return null;
+  }
+  const spans = [];
+  for (const blockId of changedIds) {
+    const previousIndex = findTopLevelBlockIndexById(
+      input.previousSurface.blocks,
+      input.previousRange,
+      blockId
+    );
+    const nextIndex = findTopLevelBlockIndexById(
+      input.nextSurface.blocks,
+      input.nextRange,
+      blockId
+    );
+    if (previousIndex === null || nextIndex === null) {
+      return null;
+    }
+    const previousBlock = input.previousSurface.blocks[previousIndex];
+    const nextBlock = input.nextSurface.blocks[nextIndex];
+    if (!previousBlock || !nextBlock || previousBlock.kind !== nextBlock.kind) {
+      return null;
+    }
+    spans.push({
+      pageIds: [input.pageId],
+      fromBlockIndex: previousIndex,
+      toBlockIndex: previousIndex + 1,
+      nextFromBlockIndex: nextIndex,
+      nextToBlockIndex: nextIndex + 1,
+      replacedBlockCount: 1
+    });
+  }
+  return spans;
+}
+function uniqueStableFragmentIds(ids) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (id === "<added>" || id === "<removed>") continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    result.push(id);
+  }
+  return result;
+}
+function findTopLevelBlockIndexById(blocks, range, blockId) {
+  for (let index = range.first; index <= range.last; index += 1) {
+    if (blocks[index]?.blockId === blockId) return index;
+  }
+  return null;
+}
+function findNestedBlockSpanById(blocks, doc, blockId) {
+  return findBlockSpanByIdInContainer({
+    blocks,
+    containerNode: doc,
+    contentStartPm: 1,
+    blockId,
+    allowCurrentLevelMatch: false,
+    insideVerticalMergeContinuation: false
+  });
+}
+function findBlockSpanByIdInContainer(input) {
+  let cursor = input.contentStartPm;
+  for (let blockIndex = 0; blockIndex < input.blocks.length; blockIndex += 1) {
+    const block = input.blocks[blockIndex];
+    const childNode = input.containerNode.child(blockIndex);
+    const fromPm = cursor;
+    const toPm = fromPm + childNode.nodeSize;
+    if (input.allowCurrentLevelMatch && block.blockId === input.blockId) {
+      return {
+        fromPm,
+        toPm,
+        blockIndex,
+        block,
+        insideVerticalMergeContinuation: input.insideVerticalMergeContinuation
+      };
+    }
+    if (block.kind === "sdt_block") {
+      const found = findBlockSpanByIdInContainer({
+        blocks: block.children,
+        containerNode: childNode,
+        contentStartPm: fromPm + 1,
+        blockId: input.blockId,
+        allowCurrentLevelMatch: true,
+        insideVerticalMergeContinuation: input.insideVerticalMergeContinuation
+      });
+      if (found) return found;
+    } else if (block.kind === "table") {
+      const found = findBlockSpanByIdInTable({
+        table: block,
+        tableNode: childNode,
+        tableStartPm: fromPm,
+        blockId: input.blockId
+      });
+      if (found) return found;
+    }
+    cursor = toPm;
+  }
+  return null;
+}
+function findBlockSpanByIdInTable(input) {
+  let rowCursor = input.tableStartPm + 1;
+  for (let rowIndex = 0; rowIndex < input.table.rows.length; rowIndex += 1) {
+    const row = input.table.rows[rowIndex];
+    const rowNode = input.tableNode.child(rowIndex);
+    let cellCursor = rowCursor + 1;
+    for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+      const cell = row.cells[cellIndex];
+      const cellNode = rowNode.child(cellIndex);
+      const found = findBlockSpanByIdInContainer({
+        blocks: cell.content,
+        containerNode: cellNode,
+        contentStartPm: cellCursor + 1,
+        blockId: input.blockId,
+        allowCurrentLevelMatch: true,
+        insideVerticalMergeContinuation: cell.verticalMerge === "continue"
+      });
+      if (found) return found;
+      cellCursor += cellNode.nodeSize;
+    }
+    rowCursor += rowNode.nodeSize;
+  }
+  return null;
+}
+function mergePatchSpans(spans) {
+  const sorted = [...spans].sort((a, b) => a.fromBlockIndex - b.fromBlockIndex);
+  const merged = [];
+  for (const span of sorted) {
+    const previous = merged[merged.length - 1];
+    if (previous && span.fromBlockIndex <= previous.toBlockIndex && span.nextFromBlockIndex <= previous.nextToBlockIndex) {
+      previous.toBlockIndex = Math.max(previous.toBlockIndex, span.toBlockIndex);
+      previous.nextToBlockIndex = Math.max(
+        previous.nextToBlockIndex,
+        span.nextToBlockIndex
+      );
+      previous.fromPm = minDefined(previous.fromPm, span.fromPm);
+      previous.toPm = maxDefined(previous.toPm, span.toPm);
+      previous.nextFromPm = minDefined(previous.nextFromPm, span.nextFromPm);
+      previous.nextToPm = maxDefined(previous.nextToPm, span.nextToPm);
+      previous.replacedBlockCount = (previous.replacedBlockCount ?? previous.toBlockIndex - previous.fromBlockIndex) + (span.replacedBlockCount ?? span.toBlockIndex - span.fromBlockIndex);
+      previous.pageIds = [...previous.pageIds, ...span.pageIds];
+      continue;
+    }
+    merged.push({ ...span });
+  }
+  return merged;
+}
+function minDefined(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.min(left, right);
+}
+function maxDefined(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function topLevelPositionForBlockIndex(doc, blockIndex) {
+  const clamped = Math.max(0, Math.min(blockIndex, doc.childCount));
+  let pos = 1;
+  for (let index = 0; index < clamped; index += 1) {
+    pos += doc.child(index).nodeSize;
+  }
+  return pos;
+}
+function selectionIntersectsSpan(selection, from, to) {
+  return selection.to > from && selection.from < to;
+}
+
 // src/ui-tailwind/editor-surface/tw-table-node-view.tsx
 var TABLE_LAYOUT_SYNC_EVENT = "pm-table-layout-sync";
 function readRowPadding(node, side) {
@@ -13135,6 +13657,57 @@ var chartNodeViews = {
   chart_atom: (node) => new ChartNodeViewInstance(node)
 };
 
+// src/ui-tailwind/page-stack/page-patch-realization.ts
+function resolvePagePatchRealization(input) {
+  const { patchPlan, mountedPageIds, desiredMountedPageIds } = input;
+  const mounted = new Set(mountedPageIds);
+  const desiredPageIds = desiredMountedPageIds ?? null;
+  const desired = desiredPageIds ? new Set(desiredPageIds) : null;
+  const planMounts = desiredPageIds ? desiredPageIds.filter((pageId) => !mounted.has(pageId)) : patchPlan.mountChanges.mountPageIds;
+  const planUnmounts = desired ? mountedPageIds.filter((pageId) => !desired.has(pageId)) : patchPlan.mountChanges.unmountPageIds;
+  const mountPageIds = uniquePageIds(planMounts);
+  const unmountPageIds = uniquePageIds(planUnmounts);
+  const finalMounted = resolveFinalMountedPageIds({
+    mountedPageIds,
+    mountPageIds,
+    unmountPageIds
+  });
+  const changedFragmentIdsByPageId = {};
+  for (const entry of patchPlan.changedPages) {
+    changedFragmentIdsByPageId[entry.pageId] = entry.fragmentChanges;
+  }
+  const patchPageIds = patchPlan.changedPages.map((entry) => entry.pageId).filter((pageId) => finalMounted.has(pageId));
+  const preservePageIds = patchPlan.unchangedPages.filter(
+    (pageId) => mounted.has(pageId) && finalMounted.has(pageId)
+  );
+  const skippedUnchangedPageIds = patchPlan.unchangedPages.filter(
+    (pageId) => !finalMounted.has(pageId)
+  );
+  return {
+    layoutRevision: patchPlan.layoutRevision,
+    geometryRevision: patchPlan.geometryRevision,
+    preservePageIds: uniquePageIds(preservePageIds),
+    patchPageIds: uniquePageIds(patchPageIds),
+    mountPageIds,
+    unmountPageIds,
+    skippedUnchangedPageIds: uniquePageIds(skippedUnchangedPageIds),
+    changedFragmentIdsByPageId
+  };
+}
+function resolveFinalMountedPageIds(input) {
+  const finalMounted = new Set(input.mountedPageIds);
+  for (const pageId of input.unmountPageIds) {
+    finalMounted.delete(pageId);
+  }
+  for (const pageId of input.mountPageIds) {
+    finalMounted.add(pageId);
+  }
+  return finalMounted;
+}
+function uniquePageIds(pageIds) {
+  return [...new Set(pageIds)];
+}
+
 // src/ui-tailwind/editor-surface/tw-prosemirror-surface.tsx
 import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 var BOUNDED_TYPING_SCROLL_RESTORE_MAX_DELTA_PX = 256;
@@ -13144,6 +13717,62 @@ function shouldPreserveScrollAnchorForRebuild(options) {
   if (!options.previousStory) return false;
   return storyTargetsEqual(options.previousStory, options.nextStory);
 }
+function pageIdsFromRenderFrame(frame) {
+  return frame.pages.map((page) => page.page.pageId);
+}
+function resolvePageBodyPatchForMountedState(input) {
+  if (!input.previousSurface) {
+    return { status: "fallback", reason: "previous-surface-missing" };
+  }
+  if (!input.previousFrame) {
+    return { status: "fallback", reason: "previous-frame-missing" };
+  }
+  if (!input.nextFrame) {
+    return { status: "fallback", reason: "next-frame-missing" };
+  }
+  if (input.previousPlugins !== input.plugins) {
+    return { status: "fallback", reason: "plugin-set-changed" };
+  }
+  const patchPlan = createPagePatchPlan(input.previousFrame, input.nextFrame, void 0, {
+    mountedPageIds: pageIdsFromRenderFrame(input.previousFrame),
+    requestedMountPageIds: pageIdsFromRenderFrame(input.nextFrame)
+  });
+  const realization = resolvePagePatchRealization({
+    patchPlan,
+    mountedPageIds: pageIdsFromRenderFrame(input.previousFrame),
+    desiredMountedPageIds: pageIdsFromRenderFrame(input.nextFrame)
+  });
+  const bodyPatch = resolvePmPageBodyPatchPlan({
+    patchPlan,
+    realization,
+    previousFrame: input.previousFrame,
+    nextFrame: input.nextFrame,
+    previousSurface: input.previousSurface,
+    nextSurface: input.nextSurface,
+    currentDoc: input.view.state.doc,
+    nextDoc: input.nextState.doc,
+    currentSelection: input.view.state.selection
+  });
+  if (bodyPatch.status !== "patch") {
+    if (bodyPatch.reason === "no-body-fragment-changes") {
+      return { status: "skip", reason: bodyPatch.reason };
+    }
+    return { status: "fallback", reason: bodyPatch.reason };
+  }
+  return { status: "patch", plan: bodyPatch };
+}
+function applyPageBodyPatchToState(view, nextDoc, plan) {
+  let tr = view.state.tr;
+  const spans = [...plan.spans].sort((a, b) => b.fromPm - a.fromPm);
+  for (const span of spans) {
+    tr = tr.replace(
+      span.fromPm,
+      span.toPm,
+      nextDoc.slice(span.nextFromPm, span.nextToPm)
+    );
+  }
+  return view.state.apply(tr);
+}
 function buildPageBreakDecorationsFromProps(geometryFacet, isMainStory, positionMap, posture, canonicalDocument, dimensions = {}, surfaceBlocks) {
   if (!geometryFacet || !isMainStory) return [];
   const frame = geometryFacet.getRenderFrame();
@@ -13263,6 +13892,9 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
   const localEquivalentOpsRef = useRef5([]);
   const pendingRebuildScrollAnchorRef = useRef5(null);
   const lastBuiltStoryRef = useRef5(null);
+  const lastBuiltSurfaceRef = useRef5(null);
+  const lastRenderFrameRef = useRef5(null);
+  const lastPluginsRef = useRef5(null);
   const snapshotRef = useRef5(snapshot);
   snapshotRef.current = snapshot;
   const scopeTagRegistryFactoryProp = props.scopeTagRegistryFactory;
@@ -13300,8 +13932,12 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
     onPasteFragment: (meta) => {
       props.onPasteFragment?.(meta);
     },
-    onPastePlainTextFragment: (fragment) => {
-      props.onPasteFragment?.({ fragment, source: "plain-text" });
+    onPastePlainTextFragment: (fragment, context) => {
+      props.onPasteFragment?.({
+        fragment,
+        source: "plain-text",
+        ...context?.editableTarget ? { editableTarget: context.editableTarget } : {}
+      });
     },
     shouldPastePlainTextAsFragment: () => snapshotRef.current.documentMode !== "suggesting",
     onPasteImage: (meta) => {
@@ -13358,6 +13994,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       showTrackedChanges,
       suggestionsEnabled,
       canEdit,
+      pageBreakRevision: props.pageBreakRevision,
       activeCommentId: snapshot.comments.activeCommentId,
       activeRevisionId: props.activeRevisionId,
       workflowScopeSignature: createWorkflowScopeSignature(props.workflowScopes),
@@ -13379,6 +14016,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       props.activeWorkflowWorkItemId,
       props.activeWorkflowScopeIds,
       props.workflowScopes,
+      props.pageBreakRevision,
       showTrackedChanges,
       suggestionsEnabled,
       snapshot.comments.activeCommentId
@@ -13441,7 +14079,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       onBlockedInput: (command, message) => callbacksRef.current?.onBlockedInput?.(command, message),
       onPasteApplied: (meta) => callbacksRef.current?.onPasteApplied?.(meta),
       onPasteFragment: (meta) => callbacksRef.current?.onPasteFragment?.(meta),
-      onPastePlainTextFragment: (fragment) => callbacksRef.current?.onPastePlainTextFragment?.(fragment),
+      onPastePlainTextFragment: (fragment, context) => callbacksRef.current?.onPastePlainTextFragment?.(fragment, context),
       shouldPastePlainTextAsFragment: () => callbacksRef.current?.shouldPastePlainTextAsFragment?.() ?? true,
       onPasteImage: (meta) => callbacksRef.current?.onPasteImage?.(meta),
       onDropFragment: (meta) => callbacksRef.current?.onDropFragment?.(meta),
@@ -13527,6 +14165,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       props.workflowMetadata,
       props.workflowCandidates,
       props.workflowScopes,
+      props.pageBreakRevision,
       revisionDisplayByOffset,
       revisionModel,
       showTrackedChanges,
@@ -13642,6 +14281,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
   useEffect4(() => {
     if (!mountRef.current || !surface) return;
     if (viewRef.current && documentBuildKeyRef.current === documentBuildKey) {
+      incrementInvalidationCounter("pm.rebuild.skip.documentBuildKey");
       pendingRebuildScrollAnchorRef.current = null;
       return;
     }
@@ -13650,10 +14290,14 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       positionMapRef.current = buildPositionMap(surface);
       documentBuildKeyRef.current = documentBuildKey;
       applyDecorationProps(viewRef.current, positionMapRef.current);
+      incrementInvalidationCounter("pm.rebuild.skip.equivalentAck");
       equivalentAckLedgerRef.current.delete(snapshot.revisionToken);
       localEquivalentOpsRef.current = [];
       pendingRebuildScrollAnchorRef.current = null;
       lastBuiltStoryRef.current = snapshot.activeStory;
+      lastBuiltSurfaceRef.current = surface;
+      lastRenderFrameRef.current = snapshot.activeStory.kind === "main" ? props.geometryFacet?.getRenderFrame() ?? null : null;
+      lastPluginsRef.current = plugins;
       if (pendingTypingProbeRef.current) {
         finishPerfProbe(pendingTypingProbeRef.current);
         pendingTypingProbeRef.current = null;
@@ -13692,23 +14336,49 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
         previousStory: lastBuiltStoryRef.current,
         nextStory: snapshot.activeStory
       });
-      replaceStatePreservingPosition(
-        {
-          view,
-          geometryFacet: props.geometryFacet,
-          suppressionRef: suppressSelectionEchoRef,
-          preserveScrollAnchor,
-          maxScrollDeltaPx: BOUNDED_TYPING_SCROLL_RESTORE_MAX_DELTA_PX,
-          afterUpdateState: () => {
-            applyDecorationProps(view, positionMap);
-            appliedDecorationProps = true;
-          }
-        },
-        state
-      );
+      const pageBodyPatch = resolvePageBodyPatchForMountedState({
+        view,
+        nextState: state,
+        previousSurface: lastBuiltSurfaceRef.current,
+        nextSurface: surface,
+        previousFrame: lastRenderFrameRef.current,
+        nextFrame: snapshot.activeStory.kind === "main" ? props.geometryFacet?.getRenderFrame() ?? null : null,
+        plugins,
+        previousPlugins: lastPluginsRef.current
+      });
+      const replacementState = pageBodyPatch.status === "patch" ? applyPageBodyPatchToState(view, state.doc, pageBodyPatch.plan) : state;
+      if (pageBodyPatch.status === "skip") {
+        applyDecorationProps(view, positionMap);
+        appliedDecorationProps = true;
+      } else {
+        replaceStatePreservingPosition(
+          {
+            view,
+            geometryFacet: props.geometryFacet,
+            suppressionRef: suppressSelectionEchoRef,
+            preserveScrollAnchor,
+            maxScrollDeltaPx: BOUNDED_TYPING_SCROLL_RESTORE_MAX_DELTA_PX,
+            afterUpdateState: () => {
+              applyDecorationProps(view, positionMap);
+              appliedDecorationProps = true;
+            }
+          },
+          replacementState
+        );
+      }
+      if (pageBodyPatch.status === "patch") {
+        incrementInvalidationCounter("pm.pagePatch.body");
+      } else if (pageBodyPatch.status === "skip") {
+        incrementInvalidationCounter(`pm.pagePatch.skip.${pageBodyPatch.reason}`);
+      } else if (pageBodyPatch.reason) {
+        incrementInvalidationCounter(`pm.pagePatch.fallback.${pageBodyPatch.reason}`);
+      }
     }
     documentBuildKeyRef.current = documentBuildKey;
     lastBuiltStoryRef.current = snapshot.activeStory;
+    lastBuiltSurfaceRef.current = surface;
+    lastRenderFrameRef.current = snapshot.activeStory.kind === "main" ? props.geometryFacet?.getRenderFrame() ?? null : null;
+    lastPluginsRef.current = plugins;
     if (!appliedDecorationProps) {
       applyDecorationProps(viewRef.current, positionMap);
     }
@@ -13728,7 +14398,8 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
     surface,
     snapshot.selection,
     plugins,
-    props.mediaPreviews
+    props.mediaPreviews,
+    props.geometryFacet
   ]);
   useEffect4(() => {
     const view = viewRef.current;
@@ -15186,6 +15857,15 @@ function deriveShellPinnedSurfaces(chromePreset, chromeOptions) {
 import { Fragment as Fragment4, jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
 var EMU_PER_CSS_PX = 9525;
 var nextObjectDragSessionId = 0;
+function preferListTextEditableTarget(primary, fallback) {
+  if (primary?.listAddress?.operationScope === "list-text") {
+    return primary;
+  }
+  if (fallback?.listAddress?.operationScope === "list-text") {
+    return fallback;
+  }
+  return primary ?? fallback;
+}
 function createMountedObjectDragSession(runtime, input) {
   nextObjectDragSessionId += 1;
   const sessionId = `object-drag-${nextObjectDragSessionId}`;
@@ -15448,6 +16128,7 @@ var WordReviewEditor = forwardRef3(
       lastSavedRevisionTokenRef,
       runtimeViewStateSeedRef
     } = useEditorRuntimeBoundary(props);
+    const pageBreakRevision = useLayoutFacetRenderSignal(activeRuntime.layout);
     const shellUiStateRef = useRef7({
       hostPosture: {},
       chromePresetInput: { chromePreset: "advanced" }
@@ -17457,7 +18138,10 @@ var WordReviewEditor = forwardRef3(
       // auto-bracketing in insertFragment + our explicit startAction around
       // the delete, so the undo history sees a single atomic action.
       onDropFragment: (meta) => {
-        const dropEditableTarget = meta.editableTarget ?? activeRuntime.getRenderSnapshot().selection.editableTarget;
+        const dropEditableTarget = preferListTextEditableTarget(
+          meta.editableTarget,
+          activeRuntime.getRenderSnapshot().selection.editableTarget
+        );
         if (meta.effect === "move" && meta.sourceRange) {
           activeRuntime.startAction("drag-move");
           try {
@@ -17468,7 +18152,10 @@ var WordReviewEditor = forwardRef3(
               assoc: { start: -1, end: 1 }
             });
             const currentEditableTarget = activeRuntime.getRenderSnapshot().selection.editableTarget;
-            const editableTarget = currentEditableTarget?.targetKey === dropEditableTarget?.targetKey ? currentEditableTarget : dropEditableTarget;
+            const editableTarget = preferListTextEditableTarget(
+              currentEditableTarget?.targetKey === dropEditableTarget?.targetKey ? currentEditableTarget : void 0,
+              dropEditableTarget
+            );
             activeRuntime.insertFragment(
               meta.fragment,
               void 0,
@@ -17507,7 +18194,10 @@ var WordReviewEditor = forwardRef3(
       // insertFragment auto-bracket (R.5.a Phase 2) makes the paste a
       // single-undo action.
       onPasteFragment: (meta) => {
-        const editableTarget = activeRuntime.getRenderSnapshot().selection.editableTarget;
+        const editableTarget = preferListTextEditableTarget(
+          meta.editableTarget,
+          activeRuntime.getRenderSnapshot().selection.editableTarget
+        );
         activeRuntime.insertFragment(
           meta.fragment,
           void 0,
@@ -17860,6 +18550,9 @@ var WordReviewEditor = forwardRef3(
         onDeleteTable: commands.onDeleteTable,
         onMergeCells: commands.onMergeCells,
         onSplitCell: commands.onSplitCell,
+        onUpdateFields: () => {
+          activeRuntime.updateFields();
+        },
         onAskAgentForSelection: () => {
           const { selection } = snapshot;
           onEventRef.current?.({
@@ -17931,6 +18624,7 @@ var WordReviewEditor = forwardRef3(
         pageChromeHeaderBandPx: isPageWorkspace ? 32 : 0,
         pageChromeFooterBandPx: isPageWorkspace ? 32 : 0,
         pageChromeInterGapPx: PAGE_CHROME_DEFAULTS.interGapPx,
+        pageBreakRevision,
         onOpenHeaderStoryForPage: (pageIndex) => openStoryForPage(activeRuntime, pageIndex, "header"),
         onOpenFooterStoryForPage: (pageIndex) => openStoryForPage(activeRuntime, pageIndex, "footer"),
         onCommentActivated: (commentId) => {