@beyondwork/docx-react-component 1.0.86 → 1.0.87

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

@@ -120,6 +120,12 @@ export interface ParagraphLineSlice {
   pageIndex: number;
   /** Inclusive-exclusive line range rendered by this slice. */
   lineRange: { from: number; to: number; totalLines: number };
+  /** Height consumed by this visible slice, when measured by pagination. */
+  heightTwips?: number;
+  /** Resolved line height used for this paragraph slice. */
+  lineHeightTwips?: number;
+  /** Available inline width for this slice. */
+  widthTwips?: number;
 }
 
 /**
@@ -137,6 +143,10 @@ export interface TableRowSlice {
   pageIndex: number;
   /** Inclusive-exclusive row range rendered by this slice. */
   rowRange: { from: number; to: number; totalRows: number };
+  /** Height consumed by this row slice, including repeated headers. */
+  heightTwips?: number;
+  /** Column occupied by this slice when the table flows across columns. */
+  columnIndex?: number;
 }
 
 /**
@@ -154,6 +164,17 @@ export interface BlockSplits {
   tablesByBlockId: Map<string, TableRowSlice[]>;
 }
 
+export interface FragmentMeasurement {
+  /** Height consumed by this block fragment on the page. */
+  heightTwips: number;
+  /** Paragraph line count for this fragment, when known. */
+  lineCount?: number;
+  /** Resolved paragraph line height for generated body line boxes. */
+  lineHeightTwips?: number;
+  /** Available inline width used during measurement. */
+  widthTwips?: number;
+}
+
 export interface PageStackResultWithSplits {
   pages: DocumentPageSnapshot[];
   splits: BlockSplits;
@@ -178,6 +199,13 @@ export interface PageStackResultWithSplits {
    * `RuntimePageRegions.columns[i].fragmentIds`.
    */
   columnByBlockIdByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, number>>;
+  /**
+   * Measured whole-fragment geometry keyed by global page index and blockId.
+   * Split paragraph/table slices carry their own height on the slice object;
+   * this map covers unsplit/whole fragments and keeps projection from
+   * recomputing geometry with heuristic span math.
+   */
+  fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>;
 }
 
 // ---------------------------------------------------------------------------
@@ -234,6 +262,7 @@ export function buildPageStackWithSplits(
     : undefined;
   const pages: DocumentPageSnapshot[] = [];
   const splitsByBlock = new Map<string, ParagraphLineSlice[]>();
+  const tableSplitsByBlock = new Map<string, TableRowSlice[]>();
   // P8.1b — aggregate note allocations and fragments across all sections,
   // keyed by global page index.
   const globalNoteAllocationsByPageIndex = new Map<number, RuntimeNoteAllocation[]>();
@@ -245,6 +274,7 @@ export function buildPageStackWithSplits(
   // sections, keyed by global page index. Populated only for blocks that
   // paginated under a multi-column layout; absent entries mean single-column.
   const globalColumnByBlockIdByPageIndex = new Map<number, Map<string, number>>();
+  const globalFragmentMeasurementsByPageIndex = new Map<number, Map<string, FragmentMeasurement>>();
   // Refactor/04 post-Slice-4 — end-column per global page, used by the
   // next section's `nextColumn` handling to decide whether to seed
   // section N at `prevEnd + 1` or start fresh on a new page.
@@ -407,10 +437,27 @@ export function buildPageStackWithSplits(
         existing.push({
           pageIndex: globalPageIdx,
           lineRange: localSlice.lineRange,
+          ...(localSlice.heightTwips !== undefined ? { heightTwips: localSlice.heightTwips } : {}),
+          ...(localSlice.lineHeightTwips !== undefined ? { lineHeightTwips: localSlice.lineHeightTwips } : {}),
+          ...(localSlice.widthTwips !== undefined ? { widthTwips: localSlice.widthTwips } : {}),
         });
       }
       if (existing.length > 0) splitsByBlock.set(blockId, existing);
     }
+    for (const [blockId, localSlices] of paginatedResult.splits.tablesByBlockId) {
+      const existing = tableSplitsByBlock.get(blockId) ?? [];
+      for (const localSlice of localSlices) {
+        const globalPageIdx = pageInSectionToGlobal.get(localSlice.pageInSection);
+        if (globalPageIdx === undefined) continue;
+        existing.push({
+          pageIndex: globalPageIdx,
+          rowRange: localSlice.rowRange,
+          ...(localSlice.heightTwips !== undefined ? { heightTwips: localSlice.heightTwips } : {}),
+          ...(localSlice.columnIndex !== undefined ? { columnIndex: localSlice.columnIndex } : {}),
+        });
+      }
+      if (existing.length > 0) tableSplitsByBlock.set(blockId, existing);
+    }
 
     // P8.1b — resolve per-section note allocations + fragments to global
     // page index and merge into the global maps.
@@ -451,6 +498,31 @@ export function buildPageStackWithSplits(
       }
       endColumnByGlobalPageIndex.set(globalPageIdx, maxCol);
     }
+    for (const [pageInSec, sectionMeasurements] of paginatedResult.fragmentMeasurementsByPageInSection) {
+      const globalPageIdx = pageInSectionToGlobal.get(pageInSec);
+      if (globalPageIdx === undefined) continue;
+      let forPage = globalFragmentMeasurementsByPageIndex.get(globalPageIdx);
+      if (!forPage) {
+        forPage = new Map<string, FragmentMeasurement>();
+        globalFragmentMeasurementsByPageIndex.set(globalPageIdx, forPage);
+      }
+      for (const [blockId, measurement] of sectionMeasurements) {
+        const existing = forPage.get(blockId);
+        if (!existing) {
+          forPage.set(blockId, measurement);
+          continue;
+        }
+        forPage.set(blockId, {
+          heightTwips: existing.heightTwips + measurement.heightTwips,
+          lineCount:
+            existing.lineCount !== undefined || measurement.lineCount !== undefined
+              ? (existing.lineCount ?? 0) + (measurement.lineCount ?? 0)
+              : undefined,
+          lineHeightTwips: measurement.lineHeightTwips ?? existing.lineHeightTwips,
+          widthTwips: measurement.widthTwips ?? existing.widthTwips,
+        });
+      }
+    }
   }
 
   // Guarantee at least one page
@@ -470,7 +542,7 @@ export function buildPageStackWithSplits(
   }
 
   applyWidowControlPass(pages, mainSurface);
-  const tableSplitsByBlock = collectTableRowSlices(mainSurface.blocks, pages);
+  applyChapterPageNumbering(pages, mainSurface);
   return {
     pages,
     splits: { byBlockId: splitsByBlock, tablesByBlockId: tableSplitsByBlock },
@@ -483,9 +555,133 @@ export function buildPageStackWithSplits(
     columnByBlockIdByPageIndex: globalColumnByBlockIdByPageIndex.size > 0
       ? globalColumnByBlockIdByPageIndex
       : undefined,
+    fragmentMeasurementsByPageIndex: globalFragmentMeasurementsByPageIndex.size > 0
+      ? globalFragmentMeasurementsByPageIndex
+      : undefined,
   };
 }
 
+function applyChapterPageNumbering(
+  pages: DocumentPageSnapshot[],
+  mainSurface: EditorSurfaceSnapshot,
+): void {
+  const pagesNeedingChapterNumber = pages.filter(
+    (page) => page.layout.pageNumbering?.chapterStyle,
+  );
+  if (pagesNeedingChapterNumber.length === 0) {
+    return;
+  }
+
+  for (const page of pagesNeedingChapterNumber) {
+    const pageNumbering = page.layout.pageNumbering;
+    if (!pageNumbering?.chapterStyle) {
+      continue;
+    }
+    const chapterNumber = resolveChapterNumberForPage(
+      mainSurface.blocks,
+      page,
+      pageNumbering.chapterStyle,
+    );
+    if (!chapterNumber) {
+      continue;
+    }
+    page.layout = {
+      ...page.layout,
+      pageNumbering: {
+        ...pageNumbering,
+        chapterNumber,
+      },
+    };
+  }
+}
+
+function resolveChapterNumberForPage(
+  blocks: readonly SurfaceBlockSnapshot[],
+  page: DocumentPageSnapshot,
+  chapterStyle: string,
+): string | undefined {
+  let current: string | undefined;
+  let firstOnPage: string | undefined;
+  for (const block of blocks) {
+    if (block.kind !== "paragraph") {
+      continue;
+    }
+    if (block.from >= page.endOffset) {
+      break;
+    }
+    if (!paragraphMatchesChapterStyle(block, chapterStyle)) {
+      continue;
+    }
+    const chapterNumber = normalizeChapterNumberMarker(
+      block.numberingPrefix ?? block.resolvedNumbering?.text,
+    );
+    if (!chapterNumber) {
+      continue;
+    }
+    if (block.from >= page.startOffset && firstOnPage === undefined) {
+      firstOnPage = chapterNumber;
+    }
+    if (block.from <= page.startOffset) {
+      current = chapterNumber;
+    }
+  }
+  return current ?? firstOnPage;
+}
+
+function paragraphMatchesChapterStyle(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  chapterStyle: string,
+): boolean {
+  const normalizedChapterStyle = normalizeStyleToken(chapterStyle);
+  if (!normalizedChapterStyle) {
+    return false;
+  }
+  const normalizedStyleId = normalizeStyleToken(block.styleId);
+  if (normalizedStyleId && normalizedStyleId === normalizedChapterStyle) {
+    return true;
+  }
+
+  const chapterLevel = chapterStyleToHeadingLevel(chapterStyle);
+  if (chapterLevel === undefined) {
+    return false;
+  }
+  if (block.outlineLevel === chapterLevel - 1) {
+    return true;
+  }
+  const headingLevel = styleIdToHeadingLevel(block.styleId);
+  return headingLevel === chapterLevel;
+}
+
+function chapterStyleToHeadingLevel(value: string): number | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (/^[1-9]$/u.test(trimmed)) {
+    return Number(trimmed);
+  }
+  return styleIdToHeadingLevel(trimmed);
+}
+
+function styleIdToHeadingLevel(value: string | undefined): number | undefined {
+  const normalized = normalizeStyleToken(value);
+  const match = /^heading([1-9])$/u.exec(normalized);
+  return match ? Number(match[1]) : undefined;
+}
+
+function normalizeStyleToken(value: string | undefined): string {
+  return (value ?? "").trim().replace(/[\s_-]+/gu, "").toLowerCase();
+}
+
+function normalizeChapterNumberMarker(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const normalized = trimmed.replace(/[\s.):-]+$/u, "");
+  return normalized.length > 0 ? normalized : trimmed;
+}
+
 /**
  * Resumable variant of `buildPageStack` — returns page snapshots starting at
  * `resumeAt.startPageIndex`, suitable for splicing into a prior page graph.
@@ -582,6 +778,14 @@ export function buildPageStackFromWithSplits(
       const tail = slices.filter((s) => s.pageIndex >= dirtyPageNumberOffset);
       if (tail.length > 0) tailTableSplits.set(blockId, tail);
     }
+    const tailFragmentMeasurements =
+      full.fragmentMeasurementsByPageIndex && full.fragmentMeasurementsByPageIndex.size > 0
+        ? new Map(
+            Array.from(full.fragmentMeasurementsByPageIndex.entries()).filter(
+              ([pi]) => pi >= dirtyPageNumberOffset,
+            ),
+          )
+        : undefined;
     return {
       pages: tailPages,
       splits: { byBlockId: tailSplits, tablesByBlockId: tailTableSplits },
@@ -594,6 +798,9 @@ export function buildPageStackFromWithSplits(
             ),
           }
         : {}),
+      ...(tailFragmentMeasurements !== undefined
+        ? { fragmentMeasurementsByPageIndex: tailFragmentMeasurements }
+        : {}),
     };
   }
 
@@ -616,6 +823,7 @@ export function buildPageStackFromWithSplits(
     dirtySurface,
     measurementProvider,
   );
+  applyChapterPageNumbering(tailResult.pages, mainSurface);
 
   // Shift global page indices on all returned pages and splits so they align
   // with the global page graph (the caller's spliceGraph prepends the head).
@@ -666,6 +874,15 @@ export function buildPageStackFromWithSplits(
           ]),
         )
       : undefined;
+  const shiftedFragmentMeasurements =
+    tailResult.fragmentMeasurementsByPageIndex && tailResult.fragmentMeasurementsByPageIndex.size > 0
+      ? new Map<number, ReadonlyMap<string, FragmentMeasurement>>(
+          Array.from(tailResult.fragmentMeasurementsByPageIndex.entries()).map(([pi, measurements]) => [
+            pi + dirtyPageNumberOffset,
+            measurements,
+          ]),
+        )
+      : undefined;
 
   return {
     pages: shiftedPages,
@@ -679,88 +896,12 @@ export function buildPageStackFromWithSplits(
     ...(shiftedColumnByBlockId !== undefined
       ? { columnByBlockIdByPageIndex: shiftedColumnByBlockId }
       : {}),
+    ...(shiftedFragmentMeasurements !== undefined
+      ? { fragmentMeasurementsByPageIndex: shiftedFragmentMeasurements }
+      : {}),
   };
 }
 
-// ---------------------------------------------------------------------------
-// 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;
-}
-
 // ---------------------------------------------------------------------------
 // Widow control pass
 // ---------------------------------------------------------------------------
@@ -1273,6 +1414,10 @@ function measureParagraphLineCount(
         currentLineCapacity = subsequentLineCapacity;
         break;
       case "image":
+        // Keep the heuristic paginator calibrated to the historical CCEP
+        // page-count locks. Intrinsic object extent is preserved by the
+        // measurement backends; true object placement belongs to the frame
+        // layout path, not paragraph line-count inflation.
         lineCount += Math.max(1, Math.round(segment.display === "floating" ? 2 : 1));
         currentLineChars = 0;
         currentLineCapacity = subsequentLineCapacity;
@@ -1351,11 +1496,24 @@ function collectSectionBlocks(
 interface SectionLocalSlice {
   pageInSection: number;
   lineRange: { from: number; to: number; totalLines: number };
+  heightTwips?: number;
+  lineHeightTwips?: number;
+  widthTwips?: number;
+}
+
+interface SectionLocalTableSlice {
+  pageInSection: number;
+  rowRange: { from: number; to: number; totalRows: number };
+  heightTwips?: number;
+  columnIndex?: number;
 }
 
 interface SectionPaginationResult {
   pages: Omit<DocumentPageSnapshot, "pageIndex">[];
-  splits: { byBlockId: Map<string, SectionLocalSlice[]> };
+  splits: {
+    byBlockId: Map<string, SectionLocalSlice[]>;
+    tablesByBlockId: Map<string, SectionLocalTableSlice[]>;
+  };
   /** P8.1b — per-page note allocations keyed by pageInSection index. */
   noteAllocationsByPageInSection: Map<number, RuntimeNoteAllocation[]>;
   /** P8.1b — per-page note body fragments keyed by pageInSection index. */
@@ -1366,6 +1524,7 @@ interface SectionPaginationResult {
    * single-column sections; absent for note/footnote blocks.
    */
   columnByBlockIdByPageInSection: Map<number, Map<string, number>>;
+  fragmentMeasurementsByPageInSection: Map<number, Map<string, FragmentMeasurement>>;
 }
 
 /**
@@ -1431,15 +1590,18 @@ export function paginateSectionBlocksWithSplits(
           layout,
         },
       ],
-      splits: { byBlockId: new Map() }, // section-local; global map includes tablesByBlockId via collectTableRowSlices
+      splits: { byBlockId: new Map(), tablesByBlockId: new Map() },
       noteAllocationsByPageInSection: new Map(),
       noteFragmentsByPageInSection: new Map(),
       columnByBlockIdByPageInSection: new Map(),
+      fragmentMeasurementsByPageInSection: new Map(),
     };
   }
 
   const pages: Omit<DocumentPageSnapshot, "pageIndex">[] = [];
   const splitsByBlock = new Map<string, SectionLocalSlice[]>();
+  const tableSplitsByBlock = new Map<string, SectionLocalTableSlice[]>();
+  const fragmentMeasurementsByPageInSection = new Map<number, Map<string, FragmentMeasurement>>();
   const usableHeight = getUsablePageHeight(layout);
   const columnMetrics = getUsableColumnMetrics(layout);
   const maxColumns = Math.max(1, columnMetrics.length);
@@ -1476,6 +1638,38 @@ export function paginateSectionBlocksWithSplits(
       forPage.set(blockId, columnIndex);
     }
   };
+  const recordFragmentMeasurement = (
+    blockId: string,
+    measurement: FragmentMeasurement,
+  ): void => {
+    let forPage = fragmentMeasurementsByPageInSection.get(pageInSection);
+    if (!forPage) {
+      forPage = new Map<string, FragmentMeasurement>();
+      fragmentMeasurementsByPageInSection.set(pageInSection, forPage);
+    }
+    const existing = forPage.get(blockId);
+    if (existing) {
+      forPage.set(blockId, {
+        heightTwips: existing.heightTwips + measurement.heightTwips,
+        lineCount:
+          existing.lineCount !== undefined || measurement.lineCount !== undefined
+            ? (existing.lineCount ?? 0) + (measurement.lineCount ?? 0)
+            : undefined,
+        lineHeightTwips: measurement.lineHeightTwips ?? existing.lineHeightTwips,
+        widthTwips: measurement.widthTwips ?? existing.widthTwips,
+      });
+      return;
+    }
+    forPage.set(blockId, measurement);
+  };
+  const appendTableSlice = (
+    blockId: string,
+    slice: SectionLocalTableSlice,
+  ): void => {
+    const list = tableSplitsByBlock.get(blockId) ?? [];
+    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.
@@ -1501,6 +1695,30 @@ export function paginateSectionBlocksWithSplits(
     if (delta === 0) return baseHeight;
     return Math.max(MIN_BLOCK_HEIGHT_TWIPS, baseHeight - delta);
   };
+  const measureParagraphFragment = (
+    block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+    formatting: import("./resolved-formatting-state.ts").ResolvedParagraphFormatting | null,
+    columnWidth: number,
+    heightTwips: number,
+    lineRange?: { from: number; to: number; totalLines: number },
+  ): FragmentMeasurement => {
+    if (!formatting) return { heightTwips, widthTwips: columnWidth };
+    const lineCount = lineRange
+      ? Math.max(0, lineRange.to - lineRange.from)
+      : (
+          cache?.getLineCount(block, columnWidth) ??
+          measureParagraphLineCount(block, formatting, columnWidth, measurementProvider)
+        );
+    if (!lineRange && cache?.getLineCount(block, columnWidth) === undefined) {
+      cache?.setLineCount(block, columnWidth, lineCount);
+    }
+    return {
+      heightTwips,
+      lineCount: Math.max(1, lineCount),
+      lineHeightTwips: formatting.lineHeight,
+      widthTwips: columnWidth,
+    };
+  };
 
   // P8.1b — per-page note tracking.
   // `pendingNoteKeys` parallels `reservedNotes` but is only snapshotted on
@@ -1700,6 +1918,8 @@ export function paginateSectionBlocksWithSplits(
           block,
           columnWidth,
           measurementProvider,
+          defaultTabInterval,
+          themeFonts,
         });
         const { cantSplitFlags, isHeaderFlags } = extractRowFlags(block);
         const repeatedHeaderHeightTwips = computeRepeatedHeaderHeight(
@@ -1720,10 +1940,29 @@ export function paginateSectionBlocksWithSplits(
           const firstChild = row?.cells[0]?.content[0];
           return firstChild?.from ?? block.from;
         };
+        const sliceHeight = (fromRow: number, toRow: number): number => {
+          let height = fromRow > 0 ? repeatedHeaderHeightTwips : 0;
+          for (let r = fromRow; r < toRow; r += 1) {
+            height += rowHeights[r] ?? 0;
+          }
+          return height;
+        };
 
         // Case 1: remainder fits — place and break.
         if (remainderHeight <= remainingForTable) {
           recordColumnPlacement(block.blockId);
+          if (startRow > 0) {
+            appendTableSlice(block.blockId, {
+              pageInSection,
+              rowRange: { from: startRow, to: rowHeights.length, totalRows: rowHeights.length },
+              heightTwips: remainderHeight,
+              ...(isMultiColumn ? { columnIndex } : {}),
+            });
+          }
+          recordFragmentMeasurement(block.blockId, {
+            heightTwips: startRow > 0 ? remainderHeight : baseHeight,
+            widthTwips: columnWidth,
+          });
           columnHeight += startRow > 0 ? remainderHeight : baseHeight;
           if (startRow > 0) tableProgress.delete(block.blockId);
           if (index === blocks.length - 1) pushPage(section.end);
@@ -1740,16 +1979,83 @@ export function paginateSectionBlocksWithSplits(
           startRow,
         });
         if (decision.rowsOnCurrentPage > 0) {
+          const splitHeight = sliceHeight(startRow, decision.splitRowIndex);
           recordColumnPlacement(block.blockId);
+          appendTableSlice(block.blockId, {
+            pageInSection,
+            rowRange: {
+              from: startRow,
+              to: decision.splitRowIndex,
+              totalRows: rowHeights.length,
+            },
+            heightTwips: splitHeight,
+            ...(isMultiColumn ? { columnIndex } : {}),
+          });
+          recordFragmentMeasurement(block.blockId, {
+            heightTwips: splitHeight,
+            widthTwips: columnWidth,
+          });
+          columnHeight += splitHeight;
           tableProgress.set(block.blockId, decision.splitRowIndex);
+          if (columnIndex < maxColumns - 1) {
+            columnIndex += 1;
+            columnHeight = 0;
+            continue;
+          }
           pushPage(rowOffset(decision.splitRowIndex));
           continue;
         }
 
+        // Degraded row-boundary placement for an oversized continuation row.
+        // If no row fits on a fresh continuation page, pushing at startRow's
+        // offset would re-open the same page forever. Keep the row intact,
+        // mark it as visually overflowing this page/column, and advance to the
+        // next row boundary.
+        if (startRow > 0 && columnHeight === 0) {
+          const forcedEndRow = Math.min(rowHeights.length, startRow + 1);
+          const forcedHeight = sliceHeight(startRow, forcedEndRow);
+          recordColumnPlacement(block.blockId);
+          appendTableSlice(block.blockId, {
+            pageInSection,
+            rowRange: {
+              from: startRow,
+              to: forcedEndRow,
+              totalRows: rowHeights.length,
+            },
+            heightTwips: forcedHeight,
+            ...(isMultiColumn ? { columnIndex } : {}),
+          });
+          recordFragmentMeasurement(block.blockId, {
+            heightTwips: forcedHeight,
+            widthTwips: columnWidth,
+          });
+          columnHeight += forcedHeight;
+          if (forcedEndRow >= rowHeights.length) {
+            tableProgress.delete(block.blockId);
+            if (index === blocks.length - 1) pushPage(section.end);
+            break;
+          }
+          tableProgress.set(block.blockId, forcedEndRow);
+          if (columnIndex < maxColumns - 1) {
+            columnIndex += 1;
+            columnHeight = 0;
+            continue;
+          }
+          const nextRowOffset = rowOffset(forcedEndRow);
+          const fallbackOffset = Math.min(section.end, pageStart + 1);
+          pushPage(nextRowOffset > pageStart ? nextRowOffset : fallbackOffset);
+          continue;
+        }
+
         // Case 3: can't split here.  If there's content above (or we're
         // resuming), push everything from the resume point to the next
         // page so the next iteration starts fresh.
         if (columnHeight > 0 || startRow > 0) {
+          if (columnIndex < maxColumns - 1) {
+            columnIndex += 1;
+            columnHeight = 0;
+            continue;
+          }
           pushPage(startRow > 0 ? rowOffset(startRow) : block.from);
           continue;
         }
@@ -1758,23 +2064,22 @@ export function paginateSectionBlocksWithSplits(
         // it doesn't fit on, AND the first row alone exceeds page
         // height).  Preserve pre-P6.c semantics so offsets stay clean.
         recordColumnPlacement(block.blockId);
+        recordFragmentMeasurement(block.blockId, {
+          heightTwips: baseHeight,
+          widthTwips: columnWidth,
+        });
         columnHeight += baseHeight;
         if (index === blocks.length - 1) pushPage(section.end);
         break;
       }
 
-      // Overflow check — paragraph doesn't fit on current page
+      // Overflow check — block doesn't fit on current page/column.
       if (projectedHeight > usableHeight && pageStart < block.from) {
         if (columnIndex < maxColumns - 1) {
-          // Advance to next column without a page break — do NOT snapshot.
+          // Advance to next column without a page break. Footnotes are
+          // page-scoped, so keep pending note state alive until pushPage().
           columnIndex += 1;
           columnHeight = 0;
-          reservedNoteHeight = 0;
-          reservedNotes.clear();
-          // P8.1b: clear pending note state WITHOUT snapshotting.
-          pendingNoteKeys.clear();
-          pendingNoteBlockFroms.clear();
-          pendingNoteColumnWidths.clear();
           continue;
         }
 
@@ -1822,24 +2127,42 @@ export function paginateSectionBlocksWithSplits(
           if (splitRule) {
             const bleedUpPageInSection = pageInSection;
             const anchorPageInSection = pageInSection + 1;
+            const currentLineRange = {
+              from: 0,
+              to: splitRule.linesOnCurrent,
+              totalLines,
+            };
+            const nextLineRange = {
+              from: splitRule.linesOnCurrent,
+              to: totalLines,
+              totalLines,
+            };
             splitsByBlock.set(block.blockId, [
               {
                 pageInSection: bleedUpPageInSection,
-                lineRange: {
-                  from: 0,
-                  to: splitRule.linesOnCurrent,
-                  totalLines,
-                },
+                lineRange: currentLineRange,
+                heightTwips: splitRule.linesOnCurrent * formatting.lineHeight,
+                lineHeightTwips: formatting.lineHeight,
+                widthTwips: columnWidth,
               },
               {
                 pageInSection: anchorPageInSection,
-                lineRange: {
-                  from: splitRule.linesOnCurrent,
-                  to: totalLines,
-                  totalLines,
-                },
+                lineRange: nextLineRange,
+                heightTwips: Math.max(0, totalLines - splitRule.linesOnCurrent) * formatting.lineHeight,
+                lineHeightTwips: formatting.lineHeight,
+                widthTwips: columnWidth,
               },
             ]);
+            recordFragmentMeasurement(
+              block.blockId,
+              measureParagraphFragment(
+                block,
+                formatting,
+                columnWidth,
+                splitRule.linesOnCurrent * formatting.lineHeight,
+                currentLineRange,
+              ),
+            );
           }
         }
 
@@ -1852,15 +2175,10 @@ export function paginateSectionBlocksWithSplits(
       // span the full page if it's truly larger than a page).
       if (keepLinesActive && columnHeight > 0 && baseHeight > usableHeight - columnHeight && pageStart < block.from) {
         if (columnIndex < maxColumns - 1) {
-          // Column advance without page break — do NOT snapshot.
+          // Column advance without page break. Keep page-scoped footnote
+          // reservations/pending allocations until the page closes.
           columnIndex += 1;
           columnHeight = 0;
-          reservedNoteHeight = 0;
-          reservedNotes.clear();
-          // P8.1b: clear pending note state WITHOUT snapshotting.
-          pendingNoteKeys.clear();
-          pendingNoteBlockFroms.clear();
-          pendingNoteColumnWidths.clear();
           continue;
         }
         pushPage(block.from);
@@ -1877,6 +2195,17 @@ export function paginateSectionBlocksWithSplits(
       // branch below advances `columnIndex`; the block itself lives in the
       // PRE-advance column.
       recordColumnPlacement(block.blockId);
+      if (block.kind === "paragraph") {
+        recordFragmentMeasurement(
+          block.blockId,
+          measureParagraphFragment(block, formatting, columnWidth, baseHeight),
+        );
+      } else {
+        recordFragmentMeasurement(block.blockId, {
+          heightTwips: baseHeight,
+          widthTwips: columnWidth,
+        });
+      }
       columnHeight += baseHeight;
       reservedNoteHeight += effectiveNoteHeight;
       currentPageNoteIds(block).forEach((noteKey) => {
@@ -1904,17 +2233,10 @@ export function paginateSectionBlocksWithSplits(
       if (hasColumnBreak(block)) {
         if (columnIndex < maxColumns - 1) {
           // Column break within a multi-column layout: advance to next column.
-          // DO NOT snapshot note allocations — only page-push triggers snapshotting.
-          // Clear pending note state alongside reservedNotes so notes that only
-          // appeared before the column break don't get double-counted.
+          // Do not snapshot note allocations here; they remain attached to
+          // the physical page and are emitted when pushPage() closes it.
           columnIndex += 1;
           columnHeight = 0;
-          reservedNoteHeight = 0;
-          reservedNotes.clear();
-          // P8.1b: clear pending note state WITHOUT snapshotting.
-          pendingNoteKeys.clear();
-          pendingNoteBlockFroms.clear();
-          pendingNoteColumnWidths.clear();
         } else {
           pushPage(nextBoundary);
         }
@@ -1941,10 +2263,11 @@ export function paginateSectionBlocksWithSplits(
               layout,
             },
           ],
-    splits: { byBlockId: splitsByBlock },
+    splits: { byBlockId: splitsByBlock, tablesByBlockId: tableSplitsByBlock },
     noteAllocationsByPageInSection,
     noteFragmentsByPageInSection,
     columnByBlockIdByPageInSection,
+    fragmentMeasurementsByPageInSection,
   };
 }