@beyondwork/docx-react-component 1.0.37 → 1.0.39

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

@@ -61,6 +61,8 @@ import {
   resolveTextWidth,
 } from "./resolved-formatting-state.ts";
 import { analyzeInvalidation as analyzeInvalidationFn } from "./layout-invalidation.ts";
+import type { LayoutMeasurementProvider } from "./layout-measurement-provider.ts";
+import { paginateParagraphLines } from "./paginate-paragraph-lines.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -80,6 +82,58 @@ export interface PageStackResult {
   sections: ResolvedDocumentSection[];
 }
 
+/**
+ * One slice of a paragraph split across a page boundary.
+ *
+ * Emitted when intra-paragraph line-box pagination produces a block that
+ * renders on multiple pages. The offset range on the page snapshot still
+ * spans the whole paragraph (pages are contiguous, non-overlapping); the
+ * slice tells consumers which lines of the paragraph render on which page.
+ */
+export interface ParagraphLineSlice {
+  /** Global (whole-document) pageIndex this slice renders on. */
+  pageIndex: number;
+  /** Inclusive-exclusive line range rendered by this slice. */
+  lineRange: { from: number; to: number; totalLines: number };
+}
+
+/**
+ * R3: one slice of a table split at a row boundary across a page break.
+ *
+ * Emitted when a table's total measured height exceeds the remaining page
+ * space and pagination commits to row-level splitting. Consumers render
+ * the rows in `rowRange` on the indicated `pageIndex`; when `rowRange.from > 0`
+ * and the source table has rows with `isHeader: true`, consumers are
+ * expected to prepend those header rows visually so the table header
+ * repeats on every continuation page.
+ */
+export interface TableRowSlice {
+  /** Global (whole-document) pageIndex this slice renders on. */
+  pageIndex: number;
+  /** Inclusive-exclusive row range rendered by this slice. */
+  rowRange: { from: number; to: number; totalRows: number };
+}
+
+/**
+ * Per-block slice information produced by pagination.  `byBlockId` is keyed
+ * by `SurfaceBlockSnapshot.blockId`. Absence of a key means the block is
+ * unsplit and renders as a single fragment on exactly one page.
+ *
+ * Paragraph-slice and table-slice keys are disjoint (a block is either a
+ * paragraph or a table, never both).  Consumers read the appropriate map
+ * for the block kind they're projecting.
+ */
+export interface BlockSplits {
+  byBlockId: Map<string, ParagraphLineSlice[]>;
+  /** R3: table blocks split at row boundaries. */
+  tablesByBlockId: Map<string, TableRowSlice[]>;
+}
+
+export interface PageStackResultWithSplits {
+  pages: DocumentPageSnapshot[];
+  splits: BlockSplits;
+}
+
 // ---------------------------------------------------------------------------
 // Facade
 // ---------------------------------------------------------------------------
@@ -90,13 +144,38 @@ export interface PageStackResult {
  * This is the single entry point for page composition.  All consumers
  * (document-navigation, view-state, page mode) should call this instead
  * of directly using the estimation helpers.
+ *
+ * `measurementProvider` is optional.  When supplied, paragraph line counts
+ * and block heights consult the provider's `measureLineFragments` so the
+ * canvas backend can participate.  When omitted, measurement falls through
+ * to the empirical path baked into this module — which matches the
+ * provider's empirical backend numerically, keeping pagination stable.
  */
 export function buildPageStack(
   document: CanonicalDocumentEnvelope,
   sections: ResolvedDocumentSection[],
   mainSurface: EditorSurfaceSnapshot,
+  measurementProvider?: LayoutMeasurementProvider,
 ): DocumentPageSnapshot[] {
+  return buildPageStackWithSplits(document, sections, mainSurface, measurementProvider).pages;
+}
+
+/**
+ * Full page-stack computation that also reports per-block slice metadata
+ * produced by intra-paragraph line-box pagination.
+ *
+ * Consumers that need to project blocks into per-page render targets
+ * (see `project-block-fragments.ts`) use the `splits` map to emit one
+ * `RuntimeBlockFragment` per slice.
+ */
+export function buildPageStackWithSplits(
+  document: CanonicalDocumentEnvelope,
+  sections: ResolvedDocumentSection[],
+  mainSurface: EditorSurfaceSnapshot,
+  measurementProvider?: LayoutMeasurementProvider,
+): PageStackResultWithSplits {
   const pages: DocumentPageSnapshot[] = [];
+  const splitsByBlock = new Map<string, ParagraphLineSlice[]>();
   let globalPageIndex = 0;
 
   for (let sectionIdx = 0; sectionIdx < sections.length; sectionIdx++) {
@@ -149,18 +228,21 @@ export function buildPageStack(
       }
     }
 
-    const paginated = paginateSectionBlocks(
+    const paginatedResult = paginateSectionBlocksWithSplits(
       section,
       sectionBlocks,
       layout,
       document.subParts?.footnoteCollection,
+      measurementProvider,
     );
+    const paginated = paginatedResult.pages;
 
     // continuous / nextColumn: merge the first page of this section into the
     // previous section's last page (same visual sheet of paper, different
     // semantic section).  The merged page keeps the PREVIOUS section's
     // layout because page geometry cannot change mid-page in OOXML.
     let firstPageHandled = false;
+    let mergedIntoGlobalPageIndex: number | null = null;
     if (
       isContinuous &&
       pages.length > 0 &&
@@ -177,17 +259,40 @@ export function buildPageStack(
         firstNewPage.endOffset,
       );
       firstPageHandled = true;
+      mergedIntoGlobalPageIndex = previousPage.pageIndex;
     }
 
+    // Map pageInSection → global pageIndex so we can resolve slice metadata.
+    const pageInSectionToGlobal = new Map<number, number>();
     for (let i = 0; i < paginated.length; i += 1) {
-      if (firstPageHandled && i === 0) continue;
       const page = paginated[i]!;
+      if (firstPageHandled && i === 0) {
+        if (mergedIntoGlobalPageIndex !== null) {
+          pageInSectionToGlobal.set(page.pageInSection, mergedIntoGlobalPageIndex);
+        }
+        continue;
+      }
+      pageInSectionToGlobal.set(page.pageInSection, globalPageIndex);
       pages.push({
         ...page,
         pageIndex: globalPageIndex,
       });
       globalPageIndex += 1;
     }
+
+    // Resolve per-section splits to global pageIndex and merge into splitsByBlock.
+    for (const [blockId, localSlices] of paginatedResult.splits.byBlockId) {
+      const existing = splitsByBlock.get(blockId) ?? [];
+      for (const localSlice of localSlices) {
+        const globalPageIdx = pageInSectionToGlobal.get(localSlice.pageInSection);
+        if (globalPageIdx === undefined) continue; // defensive — paginated might include filler
+        existing.push({
+          pageIndex: globalPageIdx,
+          lineRange: localSlice.lineRange,
+        });
+      }
+      if (existing.length > 0) splitsByBlock.set(blockId, existing);
+    }
   }
 
   // Guarantee at least one page
@@ -207,7 +312,11 @@ export function buildPageStack(
   }
 
   applyWidowControlPass(pages, mainSurface);
-  return pages;
+  const tableSplitsByBlock = collectTableRowSlices(mainSurface.blocks, pages);
+  return {
+    pages,
+    splits: { byBlockId: splitsByBlock, tablesByBlockId: tableSplitsByBlock },
+  };
 }
 
 /**
@@ -228,18 +337,130 @@ export function buildPageStackFrom(
   sections: readonly ResolvedDocumentSection[],
   mainSurface: EditorSurfaceSnapshot,
   resumeAt: { startPageIndex: number; startOffset: number },
+  measurementProvider?: LayoutMeasurementProvider,
 ): DocumentPageSnapshot[] {
-  // Correctness-first: run the full pipeline and return pages from the
-  // requested start.  `startOffset` is accepted for forward compatibility
-  // with a future true-resume but is not required by this implementation.
+  return buildPageStackFromWithSplits(
+    document,
+    sections,
+    mainSurface,
+    resumeAt,
+    measurementProvider,
+  ).pages;
+}
+
+/**
+ * Resumable variant that also reports per-block slices (filtered to pages at
+ * or after `resumeAt.startPageIndex`).
+ */
+export function buildPageStackFromWithSplits(
+  document: CanonicalDocumentEnvelope,
+  sections: readonly ResolvedDocumentSection[],
+  mainSurface: EditorSurfaceSnapshot,
+  resumeAt: { startPageIndex: number; startOffset: number },
+  measurementProvider?: LayoutMeasurementProvider,
+): PageStackResultWithSplits {
   void resumeAt.startOffset;
-  const full = buildPageStack(
+  const full = buildPageStackWithSplits(
     document,
     sections as ResolvedDocumentSection[],
     mainSurface,
+    measurementProvider,
   );
   const startIndex = Math.max(0, resumeAt.startPageIndex);
-  return full.slice(startIndex);
+  const tailPages = full.pages.slice(startIndex);
+  const tailSplits = new Map<string, ParagraphLineSlice[]>();
+  for (const [blockId, slices] of full.splits.byBlockId) {
+    const tail = slices.filter((s) => s.pageIndex >= startIndex);
+    if (tail.length > 0) tailSplits.set(blockId, tail);
+  }
+  const tailTableSplits = new Map<string, TableRowSlice[]>();
+  for (const [blockId, slices] of full.splits.tablesByBlockId) {
+    const tail = slices.filter((s) => s.pageIndex >= startIndex);
+    if (tail.length > 0) tailTableSplits.set(blockId, tail);
+  }
+  return {
+    pages: tailPages,
+    splits: { byBlockId: tailSplits, tablesByBlockId: tailTableSplits },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// R3: table row-slice collection
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute `TableRowSlice[]` entries for table blocks that span multiple pages.
+ *
+ * Tables are currently placed atomically by `paginateSectionBlocks` — the
+ * engine never splits a table mid-row.  As a consequence the offset range of
+ * every table block falls inside exactly one page's `[startOffset, endOffset)`,
+ * and this function returns an empty map.
+ *
+ * The function is wired so that when row-level table pagination lands (the
+ * engine emits `pushPage` mid-table, making `pages[]` contain a page whose
+ * `startOffset` lands between two rows of a table), the same walk
+ * automatically groups rows by page and emits `TableRowSlice` entries
+ * without any further schema change.
+ *
+ * Row offsets are derived from `row.cells[0].content[0].from` — the first
+ * cell's first inner block.  Rows whose first cell has no paragraph fall
+ * back to the table's own `from` so they group with the table's origin page.
+ */
+function collectTableRowSlices(
+  blocks: readonly SurfaceBlockSnapshot[],
+  pages: readonly DocumentPageSnapshot[],
+): Map<string, TableRowSlice[]> {
+  const result = new Map<string, TableRowSlice[]>();
+  if (pages.length === 0) return result;
+
+  const findPageIndex = (offset: number): number | null => {
+    for (const page of pages) {
+      if (offset >= page.startOffset && offset < page.endOffset) {
+        return page.pageIndex;
+      }
+    }
+    const last = pages[pages.length - 1];
+    if (last && offset >= last.startOffset && offset <= last.endOffset) {
+      return last.pageIndex;
+    }
+    return null;
+  };
+
+  for (const block of blocks) {
+    if (block.kind !== "table") continue;
+    const totalRows = block.rows.length;
+    if (totalRows === 0) continue;
+
+    // Walk rows and assign each to the page containing its start offset.
+    const perPageRange = new Map<number, { from: number; to: number }>();
+    for (let rowIndex = 0; rowIndex < totalRows; rowIndex += 1) {
+      const row = block.rows[rowIndex]!;
+      const rowStart = row.cells[0]?.content[0]?.from ?? block.from;
+      const pageIndex = findPageIndex(rowStart);
+      if (pageIndex === null) continue;
+      const existing = perPageRange.get(pageIndex);
+      if (existing) {
+        existing.to = rowIndex + 1;
+      } else {
+        perPageRange.set(pageIndex, { from: rowIndex, to: rowIndex + 1 });
+      }
+    }
+
+    // Single-page tables produce no slices.
+    if (perPageRange.size <= 1) continue;
+
+    const slices: TableRowSlice[] = [];
+    for (const [pageIndex, range] of perPageRange) {
+      slices.push({
+        pageIndex,
+        rowRange: { from: range.from, to: range.to, totalRows },
+      });
+    }
+    slices.sort((a, b) => a.pageIndex - b.pageIndex);
+    result.set(block.blockId, slices);
+  }
+
+  return result;
 }
 
 // ---------------------------------------------------------------------------
@@ -342,10 +563,15 @@ const FOOTNOTE_REFERENCE_RESERVATION_TWIPS = 180;
 /**
  * Compute block height using resolved formatting when available.
  * Uses improved table measurement for legal contracts.
+ *
+ * When `measurementProvider` is supplied, paragraph line counts are produced
+ * by `provider.measureLineFragments(...)`; otherwise the inline empirical
+ * path runs (which matches the empirical backend numerically).
  */
 function measureBlockHeight(
   block: SurfaceBlockSnapshot | undefined,
   columnWidth: number,
+  measurementProvider?: LayoutMeasurementProvider,
 ): number {
   if (!block) return 0;
 
@@ -353,17 +579,26 @@ function measureBlockHeight(
     case "paragraph": {
       const formatting = resolveBlockFormatting(block);
       if (formatting) {
-        const lineCount = measureParagraphLineCount(block, formatting, columnWidth);
+        const lineCount = measureParagraphLineCount(
+          block,
+          formatting,
+          columnWidth,
+          measurementProvider,
+        );
         return calculateParagraphHeight(formatting, lineCount);
       }
       return estimateBlockHeight(block, columnWidth);
     }
     case "table":
-      return measureTableHeight(block, columnWidth);
+      return measureTableHeight(block, columnWidth, measurementProvider);
     case "sdt_block":
       return Math.max(
         MIN_BLOCK_HEIGHT_TWIPS,
-        block.children.reduce((total, child) => total + measureBlockHeight(child, columnWidth), 0),
+        block.children.reduce(
+          (total, child) =>
+            total + measureBlockHeight(child, columnWidth, measurementProvider),
+          0,
+        ),
       );
     case "opaque_block":
       return block.label === "Section break" ? 0 : MIN_BLOCK_HEIGHT_TWIPS;
@@ -372,33 +607,76 @@ function measureBlockHeight(
 
 /**
  * Improved table height estimation.
+ *
  * Uses resolved formatting for cell content paragraphs and respects
  * explicit row heights and height rules.
+ *
+ * Per-cell width is derived from the table's `gridColumns` and each
+ * cell's `colspan` (honoring `gridBefore`/`gridAfter` row padding).
+ * This replaces the prior `columnWidth / cellCount` approximation,
+ * which was wrong whenever columns carried non-uniform widths or any
+ * cell had `colspan > 1`.
  */
 function measureTableHeight(
   block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   columnWidth: number,
+  measurementProvider?: LayoutMeasurementProvider,
 ): number {
   const TABLE_ROW_PADDING_TWIPS = 120;
   let totalHeight = 0;
 
+  const gridColumnCount = block.gridColumns.length;
+  const totalGridTwips = block.gridColumns.reduce((sum, w) => sum + w, 0);
+  // Scale the canonical gridColumns to the available column width so that
+  // a table defined in 9000-twip grid on a 12240-twip canvas measures
+  // against the actual canvas width, not the OOXML-declared width.
+  const gridScale =
+    totalGridTwips > 0 && columnWidth > 0 ? columnWidth / totalGridTwips : 1;
+
   for (const row of block.rows) {
     const explicitHeight = row.height ?? 0;
     const heightRule = row.heightRule ?? "auto";
+    const gridBefore = row.gridBefore ?? 0;
 
-    // Calculate content-driven height
+    // Calculate content-driven height using real per-cell widths.
     let contentHeight = MIN_BLOCK_HEIGHT_TWIPS;
-    const cellCount = Math.max(1, row.cells.length);
-    const cellWidth = Math.max(720, Math.floor(columnWidth / cellCount));
+    let columnCursor = gridBefore;
 
     for (const cell of row.cells) {
+      const span = Math.max(1, cell.colspan ?? 1);
+      const cellWidth = resolveCellWidth(
+        block.gridColumns,
+        columnCursor,
+        span,
+        columnWidth,
+        gridScale,
+      );
+      columnCursor += span;
+
+      if (cell.verticalMerge === "continue") {
+        // Continuation cells don't contribute their own content height —
+        // the origin cell's height covers the whole span.
+        continue;
+      }
+
       let cellContentHeight = 0;
       for (const child of cell.content) {
-        cellContentHeight += measureBlockHeight(child, cellWidth);
+        cellContentHeight += measureBlockHeight(
+          child,
+          cellWidth,
+          measurementProvider,
+        );
       }
       contentHeight = Math.max(contentHeight, cellContentHeight + TABLE_ROW_PADDING_TWIPS);
     }
 
+    // Sanity fallback if the row declared more columns than the grid
+    // (malformed input) — clamp the cursor back so subsequent rows
+    // continue to measure without throwing.
+    if (gridColumnCount > 0 && columnCursor > gridColumnCount) {
+      // no-op; kept for documentation — width resolution handles overflow.
+    }
+
     if (heightRule === "exact" && explicitHeight > 0) {
       totalHeight += explicitHeight;
     } else if (heightRule === "atLeast" && explicitHeight > 0) {
@@ -413,15 +691,78 @@ function measureTableHeight(
   return Math.max(MIN_BLOCK_HEIGHT_TWIPS, totalHeight);
 }
 
+/**
+ * Sum the widths of `columnSpan` columns starting at `startColumn` from
+ * the table's `gridColumns`, scaled to the available column width.
+ *
+ * Falls back to an even split of `fallbackColumnWidth` when the grid has
+ * no entries (no `gridColumns` declared).
+ *
+ * Exported via `__resolveCellWidth` for unit tests; not part of the
+ * stable surface.
+ */
+export function __resolveCellWidth(
+  gridColumns: readonly number[],
+  startColumn: number,
+  columnSpan: number,
+  fallbackColumnWidth: number,
+  gridScale: number,
+): number {
+  return resolveCellWidth(gridColumns, startColumn, columnSpan, fallbackColumnWidth, gridScale);
+}
+
+function resolveCellWidth(
+  gridColumns: readonly number[],
+  startColumn: number,
+  columnSpan: number,
+  fallbackColumnWidth: number,
+  gridScale: number,
+): number {
+  if (gridColumns.length === 0) {
+    // No grid declared — best-effort even split of the canvas.
+    return Math.max(240, Math.floor(fallbackColumnWidth));
+  }
+  let gridWidth = 0;
+  for (let i = 0; i < columnSpan; i += 1) {
+    const column = startColumn + i;
+    if (column < 0 || column >= gridColumns.length) continue;
+    gridWidth += gridColumns[column] ?? 0;
+  }
+  const scaled = Math.floor(gridWidth * gridScale);
+  return Math.max(240, scaled);
+}
+
 /**
  * Count lines in a paragraph using resolved formatting.
  * Accounts for proper indentation, font metrics, and numbering geometry.
+ *
+ * When a measurement provider is supplied, delegates line counting to the
+ * provider's `measureLineFragments`.  The provider's empirical backend
+ * returns the same numerical result as the inline path, so switching does
+ * not change pagination behavior; the canvas backend returns canvas-
+ * measured line counts once fonts resolve.
  */
 function measureParagraphLineCount(
   block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
   formatting: import("./resolved-formatting-state.ts").ResolvedParagraphFormatting,
   columnWidth: number,
+  measurementProvider?: LayoutMeasurementProvider,
 ): number {
+  if (measurementProvider) {
+    const measured = measurementProvider.measureLineFragments({
+      block,
+      formatting,
+      // The paginated pipeline currently resolves formatting at the
+      // paragraph level only; per-run formatting is not yet threaded
+      // through.  Pass an empty map; the provider's empirical backend
+      // does not consult per-run metrics and the canvas backend falls
+      // back to the paragraph defaults when a run is missing.
+      runs: new Map(),
+      columnWidth,
+    });
+    return Math.max(1, measured.lineCount);
+  }
+
   const firstLineWidth = resolveTextWidth(formatting, columnWidth, true);
   const subsequentLineWidth = resolveTextWidth(formatting, columnWidth, false);
   const firstLineCapacity = resolveCharsPerLine(firstLineWidth, formatting.averageCharWidthTwips);
@@ -529,25 +870,66 @@ function collectSectionBlocks(
   return blocks.filter((block) => block.to > start && block.from < end);
 }
 
+/**
+ * Per-section slice key: paragraphs carry `pageInSection` scoped to this
+ * section's pagination. The outer `buildPageStackWithSplits` resolves these
+ * to global page indices.
+ */
+interface SectionLocalSlice {
+  pageInSection: number;
+  lineRange: { from: number; to: number; totalLines: number };
+}
+
+interface SectionPaginationResult {
+  pages: Omit<DocumentPageSnapshot, "pageIndex">[];
+  splits: { byBlockId: Map<string, SectionLocalSlice[]> };
+}
+
+/**
+ * Backwards-compatible wrapper that returns only the pages. Internal to the
+ * module; kept to avoid threading the extra map through ancient call sites
+ * that don't need it.
+ */
 function paginateSectionBlocks(
   section: ResolvedDocumentSection,
   blocks: readonly SurfaceBlockSnapshot[],
   layout: DocumentPageSnapshot["layout"],
   footnotes: FootnoteCollection | undefined,
+  measurementProvider?: LayoutMeasurementProvider,
 ): Omit<DocumentPageSnapshot, "pageIndex">[] {
+  return paginateSectionBlocksWithSplits(
+    section,
+    blocks,
+    layout,
+    footnotes,
+    measurementProvider,
+  ).pages;
+}
+
+function paginateSectionBlocksWithSplits(
+  section: ResolvedDocumentSection,
+  blocks: readonly SurfaceBlockSnapshot[],
+  layout: DocumentPageSnapshot["layout"],
+  footnotes: FootnoteCollection | undefined,
+  measurementProvider?: LayoutMeasurementProvider,
+): SectionPaginationResult {
   if (blocks.length === 0) {
-    return [
-      {
-        sectionIndex: section.index,
-        pageInSection: 0,
-        startOffset: section.start,
-        endOffset: section.end,
-        layout,
-      },
-    ];
+    return {
+      pages: [
+        {
+          sectionIndex: section.index,
+          pageInSection: 0,
+          startOffset: section.start,
+          endOffset: section.end,
+          layout,
+        },
+      ],
+      splits: { byBlockId: new Map() }, // section-local; global map includes tablesByBlockId via collectTableRowSlices
+    };
   }
 
   const pages: Omit<DocumentPageSnapshot, "pageIndex">[] = [];
+  const splitsByBlock = new Map<string, SectionLocalSlice[]>();
   const usableHeight = getUsablePageHeight(layout);
   const columnMetrics = getUsableColumnMetrics(layout);
   const maxColumns = Math.max(1, columnMetrics.length);
@@ -585,12 +967,13 @@ function paginateSectionBlocks(
       const columnWidth =
         columnMetrics[Math.min(columnIndex, columnMetrics.length - 1)]?.width ??
         getUsableColumnWidth(layout);
-      const baseHeight = measureBlockHeight(block, columnWidth);
+      const baseHeight = measureBlockHeight(block, columnWidth, measurementProvider);
 
       // keepNext: this paragraph must stay with the next one on the same page
       const keepWithNextHeight =
         block.kind === "paragraph" && block.keepNext
-          ? baseHeight + measureBlockHeight(blocks[index + 1], columnWidth)
+          ? baseHeight +
+            measureBlockHeight(blocks[index + 1], columnWidth, measurementProvider)
           : baseHeight;
 
       // keepLines: the entire paragraph must fit on one page.
@@ -616,6 +999,66 @@ function paginateSectionBlocks(
           reservedNotes.clear();
           continue;
         }
+
+        // Intra-paragraph line-box split attempt. When the overflowing block
+        // is a paragraph with enough lines to split, we record a split
+        // metadata entry so renderers can bleed the first `linesOnCurrent`
+        // lines up onto the prior page's body.  Offset-wise the paragraph
+        // still lives entirely on the new page — the splits map is the
+        // contract that tells fragment projection to emit a bleed-up slice.
+        //
+        // This keeps page offset ranges contiguous and non-overlapping
+        // (preserving `findPageNodeForOffset` invariants), while still
+        // letting the UI render the paragraph across the boundary.
+        if (
+          block.kind === "paragraph" &&
+          formatting &&
+          !keepLinesActive &&
+          !block.keepNext
+        ) {
+          const availableHeight = usableHeight - columnHeight - reservedNoteHeight;
+          const totalLines = measureParagraphLineCount(
+            block,
+            formatting,
+            columnWidth,
+            measurementProvider,
+          );
+          const availableLines =
+            formatting.lineHeight > 0
+              ? Math.max(0, Math.floor(availableHeight / formatting.lineHeight))
+              : 0;
+          const splitRule = paginateParagraphLines({
+            totalLines,
+            availableLines,
+            keepLines: keepLinesActive,
+            widowControl: formatting.widowControl,
+            keepNext: Boolean(block.keepNext),
+            isLastBlockOnPage: index === blocks.length - 1,
+          });
+          if (splitRule) {
+            const bleedUpPageInSection = pageInSection;
+            const anchorPageInSection = pageInSection + 1;
+            splitsByBlock.set(block.blockId, [
+              {
+                pageInSection: bleedUpPageInSection,
+                lineRange: {
+                  from: 0,
+                  to: splitRule.linesOnCurrent,
+                  totalLines,
+                },
+              },
+              {
+                pageInSection: anchorPageInSection,
+                lineRange: {
+                  from: splitRule.linesOnCurrent,
+                  to: totalLines,
+                  totalLines,
+                },
+              },
+            ]);
+          }
+        }
+
         pushPage(block.from);
         continue;
       }
@@ -664,17 +1107,21 @@ function paginateSectionBlocks(
     }
   }
 
-  return pages.length > 0
-    ? pages
-    : [
-        {
-          sectionIndex: section.index,
-          pageInSection: 0,
-          startOffset: section.start,
-          endOffset: section.end,
-          layout,
-        },
-      ];
+  return {
+    pages:
+      pages.length > 0
+        ? pages
+        : [
+            {
+              sectionIndex: section.index,
+              pageInSection: 0,
+              startOffset: section.start,
+              endOffset: section.end,
+              layout,
+            },
+          ],
+    splits: { byBlockId: splitsByBlock },
+  };
 }
 
 function estimateFootnoteReservation(