@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/runtime/layout/layout-engine-version.ts

@@ -1,18 +1,20 @@
 /**
- * Layout engine version marker — bump when **any** file under
- * `src/runtime/layout/**` or `src/runtime/render/**` changes, or when
- * the page-break widget DOM shape under `src/ui-tailwind/editor-surface/`
- * changes in a way that affects cached render-frame diffs or persisted
- * layout caches.
+ * Layout engine version markers — co-touch this file when **any** file under
+ * `src/runtime/layout/**` or `src/runtime/render/**` changes, or when the
+ * page-break widget DOM shape under `src/ui-tailwind/editor-surface/` changes
+ * in a way that affects render-frame diffs or persisted layout caches.
  *
  * Enforcement: `scripts/ci-check-layout-engine-version.mjs` inspects the
- * PR diff; if any file in the watched trees is touched without this
- * constant being co-touched, CI fails.  See CLAUDE.md → *Performance
+ * PR diff; if any file in the watched trees is touched without this file
+ * being co-touched, CI fails.  See CLAUDE.md → *Performance
  * Invariants* for the full contract.
  *
- * Persisted caches should key their stored snapshots on this version so a
- * bump automatically invalidates stale entries — no corruption path
- * exists because the version is the cache's top-level discriminator.
+ * `LAYOUT_ENGINE_VERSION` is the layout-output correctness discriminator used
+ * by persisted laycache envelopes, projection, telemetry, debug, and public
+ * layout readers. Bump it when the same canonical input can produce different
+ * pagination, graph semantics, measurement/page geometry, render-frame output,
+ * or cache-key semantics. When only the laycache envelope or cached payload
+ * shape grows, leave this value alone and bump `LAYCACHE_SCHEMA_VERSION`.
  *
  * History:
  *   1 — initial materialization (L8 Phase B).
@@ -1074,14 +1076,172 @@
  *   table header rows, and vertical-merge carry metadata. Cache envelopes
  *   from v67 invalidate because fragment payloads can now include
  *   continuation state. Shipped via pe2 commit `33fbf45ac`.
+ *
+ *  69 — PE2 Slice 3 measured layout-object descriptors (Layer 04). Body
+ *   fragments and footnote-area fragments now carry a twips/plain
+ *   `layoutObject` row with stable object id, source block id, object kind,
+ *   pagination role, measured extent, and field-family hints where applicable.
+ *   Cache envelopes from v68 invalidate because fragment payloads can now
+ *   include layout-object descriptors. Shipped via pe2 commit `9c4417418`.
+ *
+ *  70 — PE2 review follow-up: page-local header/footer anchored-object
+ *   ledgers now mint instance-stable object ids for reused image/drawing
+ *   relationships and keep media/blip references as metadata. Cache
+ *   envelopes from v69 invalidate because page-frame object ids, signatures,
+ *   and divergence ids can change when a story reuses the same image
+ *   relationship. Shipped via pe2 commit `788bebef3`.
+ *
+ *  71 — PE2 Slice 1 cleanup: the standalone document navigation snapshot
+ *   adapter now delegates page stack and active-page derivation to the L04
+ *   layout engine graph instead of running its own `buildPageStack` path.
+ *   Cache envelopes from v70 invalidate because public navigation snapshots
+ *   are now sourced from graph-derived page truth. Shipped via pe2 commit
+ *   `cfd568942`.
+ *
+ *  72 — PE2 Slice 2 public graph surface: `PublicPageLocalStoryInstance`
+ *   now publishes the graph-owned `resolvedFields` ledger for page-local
+ *   header/footer PAGE / NUMPAGES / SECTIONPAGES fields. Cache envelopes
+ *   from v71 invalidate so public page-frame consumers cannot observe the
+ *   old story projection shape. Shipped via pe2 commit `e887a042d`.
+ *
+ *  73 — PE2 Slice 4 public divergence handles: `PublicLayoutDivergence`
+ *   now publishes graph-owned `objectIds` for object-scoped divergences
+ *   such as unsupported wrap and preserve-only placeholders. Cache envelopes
+ *   from v72 invalidate so public consumers can join divergence rows back
+ *   to page-local anchored-object ledgers without reconstructing ids.
+ *   Shipped via pe2 commit `e39766d6b`.
+ *
+ *  74 — Ship-side rollup: pe2 commits b58c0d45c (collapsed-selection
+ *   caret rect now carries an explicit `precision: "exact"` tag) and
+ *   de9b32423 (page-overlay rect projection requires complete frame
+ *   geometry) changed geometry projections without bumping the engine
+ *   version on pe2. Cache envelopes from v73 invalidate so persisted
+ *   selection-rect / page-overlay payloads cannot leak the older
+ *   precision-tag and overlay shapes through.
+ *
+ *  75 — Ship-side rollup: pe2 commit d4ac70a06 ("fix(05): tag anchor
+ *   hit target rects") added precision tagging to anchor hit-target
+ *   rects in `geometry-index.ts` + `hit-test.ts` without bumping the
+ *   engine version on pe2. Cache envelopes from v74 invalidate so
+ *   persisted hit-target payloads cannot leak the older untagged
+ *   shape through.
+ *
+ *  76 — KI-005 precision-geometry prerequisite: fragment layout-object rows
+ *   for numbered paragraphs now carry resolved numbering source facts
+ *   (marker text/suffix, list instance + level, marker lane, text column, tab
+ *   stops, and marker justification) as twips/plain graph truth. Cache
+ *   envelopes from v75 invalidate because fragment payloads can now include
+ *   numbering facts consumed by geometry/debug projections. Shipped via pe2
+ *   commit `8ff418fed`.
+ *
+ *  77 — PE2 L07 blocker service: public page-frame records now carry an
+ *   explicit `completeness` discriminator (`complete` / `partial` / `absent`)
+ *   derived from the L04 twips region ledger. Cache envelopes from v76
+ *   invalidate so runtime/API consumers can distinguish realized empty
+ *   page-local story ledgers from missing frame substrate. Shipped via pe2
+ *   commits `96b89b221` + `da704503b`.
+ *
+ *  78 — Ship-side rollup: pe2 commit 2b2cd7c2f ("feat(04): expose page-local
+ *   object wrap evidence") added a `wrapMode` field to page-local
+ *   anchored-object rows in the runtime graph and public page-frame surface,
+ *   plus pe2 commits 8d94bb10e and 246b2d299 (event telemetry / export safety)
+ *   that brushed `src/runtime/layout/page-graph.ts` and `public-facet.ts`,
+ *   without bumping the engine version on pe2. Cache envelopes from v77
+ *   invalidate so persisted page-frame story signatures and anchored-object
+ *   payloads cannot leak the older shape through.
+ *
+ *  79 — Ship-side rollup: pe2 commit 6389423bb ("perf(05): avoid duplicate
+ *   marker projection") changed how geometry coverage summaries read
+ *   numbering-marker precision/status metadata without rebuilding the marker
+ *   rect projection solely for counts; pe2 also brushed
+ *   `src/runtime/layout/public-facet.ts` via 6fcf11477 ("Route L04 oracle
+ *   unlock evidence work") without bumping on pe2. Pixel geometry is
+ *   unchanged, but geometry is a watched runtime projection surface, so the
+ *   version advances with the implementation slice. Cache envelopes from v78
+ *   invalidate.
+ *
+ *  80 — Ship-side rollup: pe2 commit b76c9a026 ("test(05): harden geometry
+ *   cleanup slice") brushed `src/runtime/layout/public-facet.ts` and the
+ *   layout-guard diagnostics helper as part of the L05 guard-warning
+ *   dependency cleanup. The pe2 history-block bumped to v76 in isolation, but
+ *   ship-preview is already at v79, so this rollup advances to v80 to keep
+ *   persisted laycache envelopes from leaking the older facet shape through.
+ *   Pixel geometry is unchanged.
+ *
+ *  81 — Ship-side rollup: pe2 commit 118171efd ("feat(10): add object drag
+ *   lifecycle") added a UI API drag session for mounted object handles
+ *   (update/commit/cancel) and commits image resize/reposition through the
+ *   existing runtime mutation path. Layout geometry is invalidated by those
+ *   committed mutations; the pe2 history-block bumped to v77 in isolation, so
+ *   ship-preview's rollup advances to v81. Cache envelopes from v80
+ *   invalidate so object-handle chrome cannot replay against a pre-lifecycle
+ *   surface.
+ *
+ *  82 — Ship-side rollup: pe2 commit 348fcaf66 ("feat(05): clip table geometry
+ *   to continuation rows") brushed `src/runtime/geometry/geometry-index.ts`
+ *   to clip table geometry to continuation rows, without bumping on pe2.
+ *   `src/runtime/geometry/**` is in the CI guard's watched-prefixes set; cache
+ *   envelopes from v81 invalidate so persisted geometry projections cannot
+ *   replay against the pre-clipping shape.
+ *
+ *  83 — Ship-side rollup: pe2 commits cf6f54878 ("Add L04 D-8 table split-row
+ *   contract") + b704efa82 ("Implement L04 split-row carry slices") added L04
+ *   D-8 table split-row carry: table pagination can now include a splittable
+ *   overflowing row on both adjacent row slices, with typed `splitRowCarry`
+ *   continuation metadata and runtime projection overlap readbacks. The pe2
+ *   history-block bumped to v78 in isolation; ship-preview's rollup advances
+ *   to v83. Cache envelopes from v82 invalidate because table fragment row
+ *   ranges and continuation cursor payloads can change for splittable
+ *   cross-page rows.
+ *
+ *  84 — Ship-side rollup: pe2 commit 763047797 ("Calibrate L04 auto-height
+ *   table splits") landed L04 D-8 auto-height table calibration: table row
+ *   pagination now uses resolved cell-content height only for materially
+ *   taller auto-height rows in non-repeated-header tables, and uses that
+ *   calibrated height to emit bounded split-row carry on CCEP D-8 targets.
+ *   The pe2 history-block bumped to v79 in isolation; ship-preview's rollup
+ *   advances to v84. Cache envelopes from v83 invalidate because auto-height
+ *   table row ranges and continuation cursor payloads can change.
+ *
+ *  85 — Ship-side rollup: pe2 commit a1b4a2e10 ("Carry default table rows
+ *   across pages") landed L04 D-8 default table-row carry: default
+ *   non-`cantSplit` / non-`exact` rows can now emit split-row carry, matching
+ *   Word's default row-break posture for newly unlocked clean D-8 table data
+ *   without broadening the resolved-height calibration gate. The pe2
+ *   history-block bumped to v80 in isolation; ship-preview's rollup advances
+ *   to v85. Cache envelopes from v84 invalidate because table row ranges and
+ *   continuation cursor payloads can change.
+ *
+ *  86 — Ship-side rollup: pe2 commits 3458b8c53 ("feat(05): expose table
+ *   split row carry geometry") + 68e9e8528 ("feat(05): ingest word layout
+ *   line geometry") + 089536b59 ("perf(05): cache geometry index
+ *   projection") + 805b42af5 ("fix(l11): relocate perf probe telemetry")
+ *   brushed `src/runtime/geometry/**` and `src/runtime/render/**` without
+ *   bumping on pe2. The pe2 history-block stayed at v80; ship-preview's
+ *   rollup advances to v86. Cache envelopes from v85 invalidate because
+ *   geometry projections (split-row carry geometry, word layout line
+ *   geometry, cached geometry index) and render-side perf probe telemetry
+ *   shapes can change.
+ *
+ *  87 — Ship-side rollup: pe2 commit a4dc6f6a3 ("Close L04 final-gap D8
+ *   table behavior") landed L04 final-gap D-8 table behavior — long
+ *   non-header auto tables now get a bounded per-row soft content-height
+ *   allowance, and long compact authored-height tables cap dense auto rows
+ *   while suppressing synthetic header reservation for split math. This
+ *   moves the repaired clean D-8 table candidates toward Word row ranges
+ *   without applying broad resolved heights to every long table. The pe2
+ *   history-block bumped to v81 in isolation; ship-preview's rollup advances
+ *   to v87. Cache envelopes from v86 invalidate because table row ranges and
+ *   continuation cursor payloads can change.
  */
-export const LAYOUT_ENGINE_VERSION = 68 as const;
+export const LAYOUT_ENGINE_VERSION = 87 as const;
 
 /**
- * Serialization schema version for the LayCache payload (the cache envelope
- * stored in IndexedDB, and — post Plan B — the customXml editor-state
- * namespace). Bump independently of LAYOUT_ENGINE_VERSION when the
- * envelope shape changes but the layout engine itself has not.
+ * Serialization schema version for the LayCache envelope and cached payload
+ * shape. This is the cache-shape discriminator for IndexedDB and customXml
+ * laycache entries. Bump independently of `LAYOUT_ENGINE_VERSION` when the
+ * envelope shape or cached graph/surface payload grows, but the same canonical
+ * input would still produce layout-compatible pagination output.
  *
  * History:
  *   1 — initial envelope shape: { schemaVersion, engineVersion,
@@ -1103,5 +1263,17 @@ export const LAYOUT_ENGINE_VERSION = 68 as const;
  *       written without the report are still valid; readers fall through
  *       to the live `buildCompatibilityReport` call. v2 envelopes are
  *       rejected cleanly on v3 readers (schemaVersion mismatch).
+ *   4 — Pass-8 versioning discipline: graph/surface payload-shape changes now
+ *       route here instead of a separate cache-engine discriminator. The
+ *       envelope still stores `engineVersion`, but that field is the
+ *       `LAYOUT_ENGINE_VERSION` correctness tag for layout-output changes.
+ *       Additive cached-payload fields route to this schema discriminator.
+ *   5 — L04 field-region runtime readback: fragment layout objects can now
+ *       carry source/canonical field-region identities for Debug/L05 joins.
+ *       Pagination output is unchanged, but cached graph payload shape grows.
+ *   6 — L04 numbering runtime readback: fragment layout objects can now carry
+ *       `numberingRows[]` for all numbered paragraphs represented by the
+ *       fragment, including table/SDT-nested paragraphs. Pagination output is
+ *       unchanged, but cached graph payload shape grows.
  */
-export const LAYCACHE_SCHEMA_VERSION = 3 as const;
+export const LAYCACHE_SCHEMA_VERSION = 6 as const;

package/src/runtime/layout/layout-facet-types.ts

@@ -44,14 +44,20 @@ export type {
   PublicLineBox,
   PublicNoteAllocation,
   PublicPageAnchor,
+  PublicPageFrame,
+  PublicPageLocalStoryInstance,
   PublicPageSpan,
   PublicSectionNode,
   PublicResolvedPageStories,
+  PublicResolvedStoryField,
   PublicResolvedParagraphFormatting,
   PublicResolvedRunFormatting,
+  PublicStoryAnchoredObject,
+  PublicTwipsRect,
   PublicBlockMeasurement,
   PublicMeasurementFidelity,
   PublicFieldDirtinessReport,
+  PublicLayoutDivergence,
 
   // Events + invalidation ----------------------------------------------
   LayoutFacetEvent,

package/src/runtime/layout/page-graph.ts

@@ -65,6 +65,7 @@ export type {
   RuntimeLayoutDivergenceKind,
   RuntimeLayoutDivergence,
   RuntimePageFrame,
+  RuntimePageFrameCompleteness,
   RuntimePageLocalStoryInstance,
   RuntimeResolvedStoryField,
   RuntimeStoryAnchoredObject,
@@ -72,6 +73,8 @@ export type {
   RuntimeParagraphContinuationCursor,
   RuntimeTableContinuationCursor,
   RuntimeTableVerticalMergeCarry,
+  RuntimeFragmentLayoutObjectKind,
+  RuntimeFragmentLayoutObject,
   RuntimeBlockFragment,
   RuntimeLineBox,
   RuntimeNoteAllocation,
@@ -451,6 +454,7 @@ function buildPageFrame(input: {
   const divergences = [...input.divergences, ...pageLocalStoryResult.divergences];
   const pageLocalStories = pageLocalStoryResult.instances;
   const divergenceIds = divergences.map((d) => d.divergenceId);
+  const completeness = resolvePageFrameCompleteness(regions);
   return {
     frame: {
       frameId: input.frameId,
@@ -458,6 +462,7 @@ function buildPageFrame(input: {
       pageIndex: input.pageIndex,
       sectionIndex: input.sectionIndex,
       displayPageNumber: input.displayPageNumber,
+      completeness,
       physicalBoundsTwips: rect(0, 0, input.layout.pageWidth, input.layout.pageHeight),
       regions,
       pageLocalStories,
@@ -613,6 +618,8 @@ function buildPageLocalStorySignature(input: {
         object.extentTwips?.widthTwips ?? "",
         object.extentTwips?.heightTwips ?? "",
         object.relationshipIds?.join(",") ?? "",
+        object.mediaIds?.join(",") ?? "",
+        object.wrapMode ?? "",
         object.preserveOnly ? "preserve-only" : "renderable",
         object.divergenceIds.join(","),
       ].join(":"),
@@ -738,7 +745,6 @@ function collectStoryAnchoredObjects(
     object: Omit<RuntimeStoryAnchoredObject, "objectId" | "divergenceIds"> & {
       objectId?: string;
       preserveHint?: PreserveOnlyObjectSizing;
-      wrapMode?: string;
     },
   ): void => {
     const objectId =
@@ -780,7 +786,7 @@ function collectStoryAnchoredObjects(
       });
     }
 
-    const { preserveHint: _preserveHint, wrapMode: _wrapMode, ...ledger } = object;
+    const { preserveHint: _preserveHint, ...ledger } = object;
     objects.push({
       ...ledger,
       objectId,
@@ -813,9 +819,10 @@ function collectStoryAnchoredObjects(
     switch (inline.type) {
       case "image": {
         pushObject({
-          objectId: inline.mediaId,
+          objectId: `${context.storyKey}:image-${ordinal}`,
           sourceType: "image",
           display: inline.display === "floating" ? "floating" : "inline",
+          mediaIds: [inline.mediaId],
           preserveOnly: false,
           wrapMode: inline.floating?.wrap,
         });
@@ -834,6 +841,9 @@ function collectStoryAnchoredObjects(
             inline.anchor.extent.heightEmu,
           ),
           ...(relationshipIds.length > 0 ? { relationshipIds } : {}),
+          ...(inline.content.type === "picture" && inline.content.mediaId
+            ? { mediaIds: [inline.content.mediaId] }
+            : {}),
           preserveOnly: Boolean(preserveHint),
           ...(preserveHint ? { preserveHint } : {}),
           wrapMode: inline.anchor.wrapMode,
@@ -927,7 +937,7 @@ function getDrawingFrameObjectId(
   ordinal: number,
 ): string {
   if (inline.anchor.docPr?.id) return `${storyKey}:drawing-${inline.anchor.docPr.id}`;
-  if (inline.content.type === "picture") return `${storyKey}:picture-${inline.content.blipRef}`;
+  if (inline.content.type === "picture") return `${storyKey}:picture-${ordinal}:${inline.content.blipRef}`;
   return `${storyKey}:drawing-${ordinal}`;
 }
 
@@ -1051,6 +1061,7 @@ function buildPageFrameSignature(
   });
   return [
     "page-frame",
+    resolvePageFrameCompleteness(input.regions),
     input.pageIndex,
     input.sectionIndex,
     input.displayPageNumber,
@@ -1062,6 +1073,14 @@ function buildPageFrameSignature(
   ].join("|");
 }
 
+function resolvePageFrameCompleteness(
+  regions: RuntimePageRegions,
+): RuntimePageFrame["completeness"] {
+  return collectRegions(regions).every((region) => region.rectTwips !== undefined)
+    ? "complete"
+    : "partial";
+}
+
 function detectFrameDivergences(
   frameId: string,
   regions: RuntimePageRegions,

package/src/runtime/layout/paginated-layout-engine.ts

@@ -86,6 +86,7 @@ import {
   computeRepeatedHeaderHeight,
   extractRowFlags,
   findTableRowSplit,
+  measureTableRowHeightProfile,
   measureTableRowHeights,
 } from "./table-row-split.ts";
 
@@ -998,6 +999,9 @@ export function requiresFullRecompute(reason: LayoutInvalidationReason): boolean
 
 const MIN_BLOCK_HEIGHT_TWIPS = 240;
 const FOOTNOTE_REFERENCE_RESERVATION_TWIPS = 180;
+const MIN_SPLIT_ROW_FRAGMENT_TWIPS = 720;
+const LONG_TABLE_SOFT_AUTO_ROW_DELTA_TWIPS = 60;
+const COMPACT_AUTHORED_ROW_HEIGHT_TWIPS = 1500;
 
 /**
  * Per-invocation measurement cache keyed by `(block, columnWidth)`.
@@ -1508,6 +1512,36 @@ interface SectionLocalTableSlice {
   columnIndex?: number;
 }
 
+interface TablePaginationProgress {
+  startRow: number;
+  carriedRowIndex?: number;
+  carriedRowUsesCalibratedHeight?: boolean;
+}
+
+function hasOnlyCompactAuthoredAutoRows(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+): boolean {
+  return (
+    block.rows.length > 10 &&
+    block.rows.every((row) => {
+      const heightRule = row.heightRule ?? "auto";
+      return heightRule !== "exact" && (row.height ?? 0) > 0 && (row.height ?? 0) <= 60;
+    })
+  );
+}
+
+function shouldUseSoftLongTableAutoHeight(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  hasRepeatedHeaderRows: boolean,
+): boolean {
+  return (
+    block.rows.length > 10 &&
+    !hasRepeatedHeaderRows &&
+    block.rows.every((row) => (row.height ?? 0) <= 1440) &&
+    block.rows.every((row) => (row.heightRule ?? "auto") !== "exact")
+  );
+}
+
 interface SectionPaginationResult {
   pages: Omit<DocumentPageSnapshot, "pageIndex">[];
   splits: {
@@ -1670,10 +1704,11 @@ export function paginateSectionBlocksWithSplits(
     list.push(slice);
     tableSplitsByBlock.set(blockId, list);
   };
-  // P6.c: per-table progress when a table is being split row-by-row
-  // across pages.  Map<blockId, nextRowIndexToPlace>.  Cleared once a
-  // table is fully placed.
-  const tableProgress = new Map<string, number>();
+  // P6.c/D-8: per-table progress when a table is being split row-by-row
+  // across pages. `startRow` is the next row to place. `carriedRowIndex`
+  // marks a row that already began on the prior page, so the next page must
+  // not immediately re-split that same row and loop forever.
+  const tableProgress = new Map<string, TablePaginationProgress>();
 
   // Contextual-spacing pair mask — precomputed once so the inner pagination
   // loop can fold suppression in O(1) per block without re-scanning neighbors.
@@ -1791,6 +1826,16 @@ export function paginateSectionBlocksWithSplits(
         to: refRange.blockTo,
         heightTwips: heightTwips + FOOTNOTE_REFERENCE_RESERVATION_TWIPS,
         kind: "whole",
+        layoutObject: {
+          objectId: `footnote-body:${fragmentId}`,
+          kind: "footnote-body",
+          sourceBlockId: `note-body-${noteKind}-${noteId}`,
+          paginationRole: "whole",
+          measuredExtentTwips: {
+            heightTwips: heightTwips + FOOTNOTE_REFERENCE_RESERVATION_TWIPS,
+            widthTwips: effectiveColumnWidth,
+          },
+        },
       };
 
       allocations.push(allocation);
@@ -1911,20 +1956,77 @@ export function paginateSectionBlocksWithSplits(
       //      degrade to atomic placement (visual overflow, but offset
       //      ranges stay clean — same as pre-P6.c behavior).
       if (block.kind === "table") {
-        const startRow = tableProgress.get(block.blockId) ?? 0;
+        const progress = tableProgress.get(block.blockId);
+        const startRow = progress?.startRow ?? 0;
+        const carriedRowIndex = progress?.carriedRowIndex;
         const remainingForTable =
           usableHeight - columnHeight - reservedNoteHeight;
-        const rowHeights = measureTableRowHeights({
+        const { cantSplitFlags, isHeaderFlags } = extractRowFlags(block);
+        const hasRepeatedHeaderRows = isHeaderFlags.some(Boolean);
+        const hasCompactAuthoredAutoRows = hasOnlyCompactAuthoredAutoRows(block);
+        const canUseAutoHeightCalibration =
+          !hasRepeatedHeaderRows && block.rows.length <= 10;
+        const rowHeightProfile = measureTableRowHeightProfile({
           block,
           columnWidth,
           measurementProvider,
           defaultTabInterval,
           themeFonts,
+          contentMode: canUseAutoHeightCalibration
+            ? "auto-height-calibrated"
+            : "legacy-min",
         });
-        const { cantSplitFlags, isHeaderFlags } = extractRowFlags(block);
+        const shouldUseSoftLongTableHeights =
+          shouldUseSoftLongTableAutoHeight(block, hasRepeatedHeaderRows);
+        const resolvedRowHeights =
+          hasCompactAuthoredAutoRows || shouldUseSoftLongTableHeights
+            ? measureTableRowHeights({
+                block,
+                columnWidth,
+                measurementProvider,
+                defaultTabInterval,
+                themeFonts,
+                contentMode: "resolved",
+              })
+            : null;
+        const legacyRowHeights = progress?.carriedRowUsesCalibratedHeight === true
+          ? measureTableRowHeights({
+              block,
+              columnWidth,
+              measurementProvider,
+              defaultTabInterval,
+              themeFonts,
+            })
+          : null;
+        const rowHeights = [...rowHeightProfile.heights];
+        if (resolvedRowHeights) {
+          for (let rowIndex = 0; rowIndex < rowHeights.length; rowIndex += 1) {
+            const resolvedHeight = resolvedRowHeights[rowIndex] ?? rowHeights[rowIndex] ?? 0;
+            if (hasCompactAuthoredAutoRows) {
+              rowHeights[rowIndex] = Math.min(
+                Math.max(rowHeights[rowIndex] ?? 0, resolvedHeight),
+                COMPACT_AUTHORED_ROW_HEIGHT_TWIPS,
+              );
+            } else if (resolvedHeight > (rowHeights[rowIndex] ?? 0)) {
+              rowHeights[rowIndex] = (rowHeights[rowIndex] ?? 0) + LONG_TABLE_SOFT_AUTO_ROW_DELTA_TWIPS;
+            }
+          }
+        }
+        const calibratedAutoRowIndexes = new Set(rowHeightProfile.calibratedAutoRowIndexes);
+        if (
+          carriedRowIndex !== undefined &&
+          progress?.carriedRowUsesCalibratedHeight === true &&
+          carriedRowIndex === startRow &&
+          calibratedAutoRowIndexes.has(carriedRowIndex)
+        ) {
+          rowHeights[carriedRowIndex] = Math.min(
+            rowHeights[carriedRowIndex] ?? 0,
+            legacyRowHeights?.[carriedRowIndex] ?? rowHeights[carriedRowIndex] ?? 0,
+          );
+        }
         const repeatedHeaderHeightTwips = computeRepeatedHeaderHeight(
           rowHeights,
-          isHeaderFlags,
+          hasCompactAuthoredAutoRows ? rowHeights.map(() => false) : isHeaderFlags,
         );
         const headerReservation =
           startRow > 0 ? repeatedHeaderHeightTwips : 0;
@@ -1947,6 +2049,13 @@ export function paginateSectionBlocksWithSplits(
           }
           return height;
         };
+        const isRowSplittableAcrossPages = (rowIndex: number): boolean => {
+          const row = block.rows[rowIndex];
+          if (!row) return false;
+          if (cantSplitFlags[rowIndex] === true) return false;
+          if (row.heightRule === "exact") return false;
+          return true;
+        };
 
         // Case 1: remainder fits — place and break.
         if (remainderHeight <= remainingForTable) {
@@ -1980,29 +2089,54 @@ export function paginateSectionBlocksWithSplits(
         });
         if (decision.rowsOnCurrentPage > 0) {
           const splitHeight = sliceHeight(startRow, decision.splitRowIndex);
+          const splitRowIndex = decision.splitRowIndex;
+          const splitRowVisibleHeight = remainingForTable - splitHeight;
+          const canCarrySplitRow =
+            decision.continuationRequired &&
+            splitRowIndex < rowHeights.length &&
+            splitRowIndex !== carriedRowIndex &&
+            isRowSplittableAcrossPages(splitRowIndex) &&
+            splitRowVisibleHeight >= MIN_SPLIT_ROW_FRAGMENT_TWIPS;
+          const currentSliceEndRow = canCarrySplitRow
+            ? Math.min(rowHeights.length, splitRowIndex + 1)
+            : splitRowIndex;
+          const currentSliceHeight = canCarrySplitRow
+            ? splitHeight + splitRowVisibleHeight
+            : splitHeight;
           recordColumnPlacement(block.blockId);
           appendTableSlice(block.blockId, {
             pageInSection,
             rowRange: {
               from: startRow,
-              to: decision.splitRowIndex,
+              to: currentSliceEndRow,
               totalRows: rowHeights.length,
             },
-            heightTwips: splitHeight,
+            heightTwips: currentSliceHeight,
             ...(isMultiColumn ? { columnIndex } : {}),
           });
           recordFragmentMeasurement(block.blockId, {
-            heightTwips: splitHeight,
+            heightTwips: currentSliceHeight,
             widthTwips: columnWidth,
           });
-          columnHeight += splitHeight;
-          tableProgress.set(block.blockId, decision.splitRowIndex);
+          columnHeight += currentSliceHeight;
+          tableProgress.set(
+            block.blockId,
+            canCarrySplitRow
+              ? {
+                  startRow: splitRowIndex,
+                  carriedRowIndex: splitRowIndex,
+                  ...(calibratedAutoRowIndexes.has(splitRowIndex)
+                    ? { carriedRowUsesCalibratedHeight: true }
+                    : {}),
+                }
+              : { startRow: splitRowIndex },
+          );
           if (columnIndex < maxColumns - 1) {
             columnIndex += 1;
             columnHeight = 0;
             continue;
           }
-          pushPage(rowOffset(decision.splitRowIndex));
+          pushPage(rowOffset(splitRowIndex));
           continue;
         }
 
@@ -2035,7 +2169,7 @@ export function paginateSectionBlocksWithSplits(
             if (index === blocks.length - 1) pushPage(section.end);
             break;
           }
-          tableProgress.set(block.blockId, forcedEndRow);
+          tableProgress.set(block.blockId, { startRow: forcedEndRow });
           if (columnIndex < maxColumns - 1) {
             columnIndex += 1;
             columnHeight = 0;