@beyondwork/docx-react-component 1.0.38 → 1.0.39

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

@@ -62,6 +62,7 @@ import {
 } 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
@@ -81,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
 // ---------------------------------------------------------------------------
@@ -104,7 +157,25 @@ export function buildPageStack(
   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++) {
@@ -157,19 +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 &&
@@ -186,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
@@ -216,7 +312,11 @@ export function buildPageStack(
   }
 
   applyWidowControlPass(pages, mainSurface);
-  return pages;
+  const tableSplitsByBlock = collectTableRowSlices(mainSurface.blocks, pages);
+  return {
+    pages,
+    splits: { byBlockId: splitsByBlock, tablesByBlockId: tableSplitsByBlock },
+  };
 }
 
 /**
@@ -239,18 +339,128 @@ export function buildPageStackFrom(
   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;
 }
 
 // ---------------------------------------------------------------------------
@@ -660,6 +870,26 @@ 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[],
@@ -667,19 +897,39 @@ function paginateSectionBlocks(
   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);
@@ -749,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;
       }
@@ -797,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(

package/src/runtime/layout/project-block-fragments.ts

@@ -1,17 +1,22 @@
 /**
- * Project surface blocks → per-page RuntimeBlockFragments (P4).
+ * Project surface blocks → per-page RuntimeBlockFragments (P4 + R3).
  *
  * The pagination engine produces `DocumentPageSnapshot[]` keyed by offset
  * ranges, but for render-kernel consumers to get per-block geometry (and
  * for the chrome to anchor tables, images, etc.) we need one block
- * fragment per top-level surface block, assigned to the page that contains
- * its offset range.
+ * fragment per top-level surface block, assigned to the page that
+ * contains its offset range.
  *
- * Today the engine does not split tables across pages, so this emission
- * pass treats each top-level SurfaceBlockSnapshot as an atomic fragment
- * with `pageIndex` resolved from `pages[i].startOffset..endOffset`. Row-
- * level splitting (for header-row repeat + per-row cantSplit) will refine
- * this to multiple fragments per block.
+ * The engine also reports **split metadata** (see `BlockSplits` in
+ * `paginated-layout-engine.ts`):
+ *   - paragraph-slice: one fragment per slice, keyed by `paragraphLineRange`
+ *   - table-slice: one fragment per row-range slice, keyed by `tableRowRange`
+ *   - otherwise: one atomic fragment per top-level block (the original P4
+ *     behavior).
+ *
+ * Consumers read `fragment.kind` to choose between whole-block rendering
+ * and slice-aware rendering (line-range clipping for paragraphs, row-range
+ * rendering + repeated header row for tables).
  */
 
 import type {
@@ -20,46 +25,175 @@ import type {
   SurfaceBlockSnapshot,
 } from "../../api/public-types";
 import type { RuntimeBlockFragment } from "./page-graph.ts";
+import type {
+  BlockSplits,
+  ParagraphLineSlice,
+  TableRowSlice,
+} from "./paginated-layout-engine.ts";
 
 type FragmentWithoutPageId = Omit<RuntimeBlockFragment, "pageId">;
 
 export function projectSurfaceBlocksToPageFragments(
   surface: EditorSurfaceSnapshot,
   pages: readonly DocumentPageSnapshot[],
+  splits?: BlockSplits,
 ): Map<number, FragmentWithoutPageId[]> {
   const byPage = new Map<number, FragmentWithoutPageId[]>();
   const perPageCounter = new Map<number, number>();
 
+  const pushFragment = (
+    pageIndex: number,
+    fragment: FragmentWithoutPageId,
+  ): void => {
+    const existing = byPage.get(pageIndex);
+    if (existing) {
+      existing.push(fragment);
+    } else {
+      byPage.set(pageIndex, [fragment]);
+    }
+  };
+
+  const nextOrder = (pageIndex: number): number => {
+    const n = perPageCounter.get(pageIndex) ?? 0;
+    perPageCounter.set(pageIndex, n + 1);
+    return n;
+  };
+
   for (const block of surface.blocks) {
+    // R3: table split across pages — emit one fragment per row slice.
+    // Consumers read `tableRowRange` and prepend header rows when from > 0.
+    if (block.kind === "table") {
+      const tableSliceList = splits?.tablesByBlockId.get(block.blockId);
+      if (tableSliceList && tableSliceList.length > 1) {
+        emitSlicedTable(
+          block,
+          tableSliceList,
+          (pageIndex, fragment) => {
+            pushFragment(pageIndex, {
+              ...fragment,
+              orderInRegion: nextOrder(pageIndex),
+            });
+          },
+        );
+        continue;
+      }
+    }
+
+    // Paragraph split across pages (bleed-up slice metadata): emit one
+    // fragment per slice with `paragraphLineRange` set.
+    const sliceList = splits?.byBlockId.get(block.blockId);
+    if (sliceList && sliceList.length > 1) {
+      emitSlicedParagraph(
+        block,
+        sliceList,
+        (pageIndex, fragment) => {
+          pushFragment(pageIndex, {
+            ...fragment,
+            orderInRegion: nextOrder(pageIndex),
+          });
+        },
+      );
+      continue;
+    }
+
+    // Unsplit block: single atomic fragment on the page containing its
+    // start offset.
     const pageIndex = findPageIndexForOffset(pages, block.from);
     if (pageIndex === null) continue;
-    const orderInRegion = perPageCounter.get(pageIndex) ?? 0;
-    perPageCounter.set(pageIndex, orderInRegion + 1);
 
     const fragment: FragmentWithoutPageId = {
       fragmentId: `fragment-${block.blockId}`,
       blockId: block.blockId,
-      orderInRegion,
+      orderInRegion: nextOrder(pageIndex),
       regionKind: "body",
       from: block.from,
       to: block.to,
-      // Height is not recomputed here — the pagination engine already
-      // measured the block to assign it to this page. Chrome surfaces
-      // that need precise heights can consult layout facet measurements.
       heightTwips: estimateBlockHeightFromSpan(block),
+      kind: "whole",
     };
 
-    const existing = byPage.get(pageIndex);
-    if (existing) {
-      existing.push(fragment);
-    } else {
-      byPage.set(pageIndex, [fragment]);
-    }
+    pushFragment(pageIndex, fragment);
   }
 
   return byPage;
 }
 
+/**
+ * Emit one fragment per slice for a paragraph that pagination split across
+ * pages. The source `block` offset range stays intact on every slice; the
+ * `paragraphLineRange` identifies which lines the slice renders.
+ */
+function emitSlicedParagraph(
+  block: SurfaceBlockSnapshot,
+  slices: readonly ParagraphLineSlice[],
+  emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
+): void {
+  for (let i = 0; i < slices.length; i += 1) {
+    const slice = slices[i]!;
+    const fragment: FragmentWithoutPageId = {
+      fragmentId: `fragment-${block.blockId}-slice-${i}`,
+      blockId: block.blockId,
+      orderInRegion: 0, // re-assigned by caller via nextOrder(pageIndex).
+      regionKind: "body",
+      from: block.from,
+      to: block.to,
+      heightTwips: estimateSliceHeightFromLines(slice.lineRange),
+      kind: "paragraph-slice",
+      paragraphLineRange: slice.lineRange,
+    };
+    emit(slice.pageIndex, fragment);
+  }
+}
+
+function estimateSliceHeightFromLines(lineRange: {
+  from: number;
+  to: number;
+  totalLines: number;
+}): number {
+  const lines = Math.max(0, lineRange.to - lineRange.from);
+  return lines * 240;
+}
+
+/**
+ * R3: emit one fragment per row-slice when a table spans multiple pages.
+ * The source `block` offset range stays intact on every slice (so selection
+ * math and incremental relayout see a single logical block); `tableRowRange`
+ * tells downstream consumers which rows to render on this page. When
+ * `rowRange.from > 0` and the owning table has `isHeader` rows, consumers
+ * prepend those header rows visually so the table's header repeats on
+ * every continuation page.
+ */
+function emitSlicedTable(
+  block: SurfaceBlockSnapshot,
+  slices: readonly TableRowSlice[],
+  emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
+): void {
+  for (let i = 0; i < slices.length; i += 1) {
+    const slice = slices[i]!;
+    const fragment: FragmentWithoutPageId = {
+      fragmentId: `fragment-${block.blockId}-rowslice-${i}`,
+      blockId: block.blockId,
+      orderInRegion: 0, // re-assigned by caller via nextOrder(pageIndex).
+      regionKind: "body",
+      from: block.from,
+      to: block.to,
+      heightTwips: estimateSliceHeightFromRows(slice.rowRange),
+      kind: "table-slice",
+      tableRowRange: slice.rowRange,
+    };
+    emit(slice.pageIndex, fragment);
+  }
+}
+
+function estimateSliceHeightFromRows(rowRange: {
+  from: number;
+  to: number;
+  totalRows: number;
+}): number {
+  const rows = Math.max(0, rowRange.to - rowRange.from);
+  return rows * 360; // ~1 line + padding per row, approximate
+}
+
 function findPageIndexForOffset(
   pages: readonly DocumentPageSnapshot[],
   offset: number,