@beyondwork/docx-react-component 1.0.131 → 1.0.132

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   createSearchPlugin,
   performSearch,
   searchPluginKey
-} from "./chunk-6TBLDBCL.js";
+} from "./chunk-CDEZGLQ3.js";
 import {
   CODE_METADATA_TABLE,
   KNOWN_DIAGNOSTIC_CODES,
@@ -26,7 +26,7 @@ import {
   splitListParagraph,
   toggleBulletedList,
   toggleNumberedList
-} from "./chunk-YLL7MF5C.js";
+} from "./chunk-43JAPM2F.js";
 import {
   applyParagraphStyleToDocument
 } from "./chunk-6EXNNAO6.js";
@@ -37,7 +37,7 @@ import {
   setSectionPageNumberingAtSectionIndex,
   updateSectionLayoutAtSectionIndex
 } from "./chunk-M6XR534O.js";
-import "./chunk-ZVC23LKV.js";
+import "./chunk-ZDYGRO2Z.js";
 import {
   createRuntimeCollabSync,
   createRuntimeCommandAppliedBridge
@@ -45,7 +45,7 @@ import {
 import {
   insertPageBreak,
   insertTable
-} from "./chunk-QXKQPUOM.js";
+} from "./chunk-SZ6BJA4Q.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-UFPBYJMA.js";
+import "./chunk-N5FTU4HZ.js";
 import {
   getTableStructureContext,
   tableStructureActionHandleForTarget
-} from "./chunk-Q7Y57KOK.js";
-import "./chunk-PHMWH23E.js";
+} from "./chunk-6TLZ6CMP.js";
+import "./chunk-C5LXKR54.js";
 import {
   MOUNTED_SURFACE_VIEWPORT_BLOCK_THRESHOLD,
   OverlayAnchorBridgeProvider,
@@ -85,16 +85,12 @@ import {
   resolveSelectionToolRegistry,
   shouldRenderAbsoluteFloatingImageInPageOverlay,
   shouldRenderSelectionToolKind,
-  shouldUseMountedSurfaceViewportCulling
-} from "./chunk-3YCQM2RV.js";
+  shouldUseMountedSurfaceViewportCulling,
+  useLayoutFacetRenderSignal
+} from "./chunk-QUTVR72L.js";
 import {
-  PREDICTED_LANE_COUNTERS,
-  createInertGeometryFacet,
-  finishPerfProbe,
-  incrementInvalidationCounter,
-  recordPerfSample,
-  startPerfProbe
-} from "./chunk-35RHOE6I.js";
+  createInertGeometryFacet
+} from "./chunk-UP2KDOYE.js";
 import {
   composeSeriesColor,
   computeStructuralHash,
@@ -108,12 +104,12 @@ import {
   resolveColor,
   tryReadLaycacheEnvelope,
   writeEnvelopeToOpcPackage
-} from "./chunk-WZDKNF37.js";
+} from "./chunk-YUHNDEV5.js";
 import {
   findTextMatches,
   parseCanonicalFragmentFromWordML,
   searchDocument
-} from "./chunk-7G5GR3VV.js";
+} from "./chunk-XYTWOJII.js";
 import {
   clearLocalCursorState,
   getCursorColorForUser,
@@ -123,23 +119,29 @@ import {
 import {
   resolveChromePreset,
   resolveChromeVisibilityForPreset
-} from "./chunk-CI2TD3T4.js";
+} from "./chunk-W2I47J2Q.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-LPLJZJT2.js";
 import "./chunk-OVLZQ6FZ.js";
 import "./chunk-QIO6V46H.js";
 import {
@@ -147,7 +149,7 @@ import {
   getStoryBlocks,
   replaceStoryBlocks,
   stableChartId
-} from "./chunk-A3GSNB4G.js";
+} from "./chunk-U3UMKA7B.js";
 import "./chunk-SYQWQ6FE.js";
 import {
   createDefaultCanonicalDocument,
@@ -158,14 +160,14 @@ import {
   SessionNotOpenError,
   SessionNotWiredError,
   isReopenBarrier
-} from "./chunk-DGA7M77X.js";
+} from "./chunk-ALWXYGXP.js";
 import {
   createHmacSigner,
   createHmacVerifier,
   loadDocxSessionSync,
   signWorkflowPayloadXml,
   verifyWorkflowPayloadXml
-} from "./chunk-VRKK2CSZ.js";
+} from "./chunk-JVTDBX67.js";
 import {
   EDITOR_SESSION_STATE_VERSION,
   assertEditorSessionState,
@@ -174,8 +176,8 @@ import {
   editorSessionStateFromPersistedSnapshot,
   persistedSnapshotFromEditorSessionState,
   validateEditorSessionState
-} from "./chunk-4YCWECLZ.js";
-import "./chunk-M7YRJX6V.js";
+} from "./chunk-4HGFJ6Z2.js";
+import "./chunk-RBWJHRNP.js";
 import {
   decodePersistedSourcePackageBytes,
   hasValidPersistedSourcePackageDigest
@@ -187,7 +189,7 @@ import {
   collectEditableTargetRefs,
   createHeaderFooterStoryKey,
   createNoteStoryKey
-} from "./chunk-A66ZVUAT.js";
+} from "./chunk-RYMMKOFI.js";
 import {
   readOpcPackage
 } from "./chunk-WUDSNHWF.js";
@@ -6937,6 +6939,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 +7127,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);
@@ -9674,6 +9706,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 +9719,292 @@ function createSurfaceDecorationKey(input) {
   });
 }
 
+// src/ui-tailwind/editor-surface/pm-page-body-patch.ts
+function resolvePmPageBodyPatchPlan(input) {
+  if (input.patchPlan.addedPages.length > 0 || input.patchPlan.removedPages.length > 0) {
+    return {
+      status: "fallback",
+      reason: "page-membership-change",
+      pageIds: [...input.patchPlan.addedPages, ...input.patchPlan.removedPages]
+    };
+  }
+  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]
+      };
+    }
+    rawSpans.push(
+      nestedSpan.status === "nested" ? nestedSpan.span : {
+        pageIds: [pageId],
+        fromBlockIndex: previousRange.first,
+        toBlockIndex: previousRange.last + 1,
+        nextFromBlockIndex: nextRange.first,
+        nextToBlockIndex: nextRange.last + 1
+      }
+    );
+  }
+  if (rawSpans.length === 0) {
+    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((span) => span?.insideVerticalMergeContinuation) || nextLocated.some((span) => span?.insideVerticalMergeContinuation)) {
+    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 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 +13454,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 +13514,53 @@ 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 || !input.previousFrame || !input.nextFrame || input.previousPlugins !== input.plugins) {
+    return { status: "fallback" };
+  }
+  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 +13680,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;
@@ -13358,6 +13778,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 +13800,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       props.activeWorkflowWorkItemId,
       props.activeWorkflowScopeIds,
       props.workflowScopes,
+      props.pageBreakRevision,
       showTrackedChanges,
       suggestionsEnabled,
       snapshot.comments.activeCommentId
@@ -13527,6 +13949,7 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       props.workflowMetadata,
       props.workflowCandidates,
       props.workflowScopes,
+      props.pageBreakRevision,
       revisionDisplayByOffset,
       revisionModel,
       showTrackedChanges,
@@ -13654,6 +14077,9 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
       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 +14118,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 +14180,8 @@ var TwProseMirrorSurface = forwardRef(function TwProseMirrorSurface2(props, ref)
     surface,
     snapshot.selection,
     plugins,
-    props.mediaPreviews
+    props.mediaPreviews,
+    props.geometryFacet
   ]);
   useEffect4(() => {
     const view = viewRef.current;
@@ -15448,6 +15901,7 @@ var WordReviewEditor = forwardRef3(
       lastSavedRevisionTokenRef,
       runtimeViewStateSeedRef
     } = useEditorRuntimeBoundary(props);
+    const pageBreakRevision = useLayoutFacetRenderSignal(activeRuntime.layout);
     const shellUiStateRef = useRef7({
       hostPosture: {},
       chromePresetInput: { chromePreset: "advanced" }
@@ -17931,6 +18385,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) => {