@stll/folio-core 0.47.7 → 0.49.0

package/dist/layout-engine/measure/tableCellFloating.js

@@ -53,6 +53,7 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 			const distLeft = run.distLeft ?? 12;
 			const distRight = run.distRight ?? 12;
 			const verticalOriginY = run.position?.vertical?.relativeTo === "paragraph" ? placement.top : placement.contentTop;
+			if (run.layoutInCell === false && !resolvePosition) continue;
 			const resolved = run.layoutInCell === false && resolvePosition ? resolvePosition(run, verticalOriginY) : resolveCellScopedPosition({
 				run,
 				paragraphY: verticalOriginY,
@@ -82,6 +83,7 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 				distLeft,
 				distRight,
 				wrapText,
+				...run.wrapType !== void 0 ? { wrapType: run.wrapType } : {},
 				...run.pmStart !== void 0 ? { pmStart: run.pmStart } : {},
 				...run.pmEnd !== void 0 ? { pmEnd: run.pmEnd } : {}
 			});
@@ -89,26 +91,56 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 	}
 	return result;
 }
+/**
+* The text exclusion one cell-scoped picture casts, in cell content
+* coordinates, or `undefined` when text ignores it.
+*
+* - `wp:wrapNone` (`behind` / `inFront`): text paints over or under the
+*   picture, so nothing is excluded.
+* - `wp:wrapTopAndBottom`: no text beside the picture; lines it overlaps move
+*   below it.
+* - `wp:wrapSquare` and the contour modes: text runs on the picture's open
+*   side. When the picture and its wrap distances cover the cell's content
+*   width there is no open side, and the text moves below the picture as for
+*   `wrapTopAndBottom`.
+*/
+function tableCellFloatingZone(img, contentWidth) {
+	if (img.wrapType === "behind" || img.wrapType === "inFront") return;
+	const rectLeft = img.x - img.distLeft;
+	const rectRight = img.x + img.width + img.distRight;
+	const topY = img.y - img.distTop;
+	const bottomY = img.y + img.height + img.distBottom;
+	const belowPicture = {
+		leftMargin: 0,
+		rightMargin: 0,
+		topY,
+		bottomY,
+		fullWidthBlock: true
+	};
+	if (img.wrapType === "topAndBottom") return belowPicture;
+	let leftMargin = 0;
+	let rightMargin = 0;
+	const wrapText = img.wrapText ?? "bothSides";
+	if (wrapText === "right") leftMargin = rectRight;
+	else if (wrapText === "left") rightMargin = contentWidth - rectLeft;
+	else if (img.side === "left") leftMargin = rectRight;
+	else rightMargin = contentWidth - rectLeft;
+	if (rectRight > 0 && rectLeft < contentWidth && Math.max(leftMargin, rightMargin) >= contentWidth) return belowPicture;
+	const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
+	return {
+		leftMargin: clamped.leftMargin,
+		rightMargin: clamped.rightMargin,
+		topY,
+		bottomY
+	};
+}
 function buildTableCellFloatingZones(floatingImages, contentWidth) {
-	return floatingImages.map((img) => {
-		const rectRight = img.x + img.width + img.distRight;
-		const rectTop = img.y - img.distTop;
-		const rectBottom = img.y + img.height + img.distBottom;
-		let leftMargin = 0;
-		let rightMargin = 0;
-		const wrapText = img.wrapText ?? "bothSides";
-		if (wrapText === "right") leftMargin = rectRight;
-		else if (wrapText === "left") rightMargin = contentWidth - (img.x - img.distLeft);
-		else if (img.side === "left") leftMargin = rectRight;
-		else rightMargin = contentWidth - (img.x - img.distLeft);
-		const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
-		return {
-			leftMargin: clamped.leftMargin,
-			rightMargin: clamped.rightMargin,
-			topY: rectTop,
-			bottomY: rectBottom
-		};
-	});
+	const zones = [];
+	for (const img of floatingImages) {
+		const zone = tableCellFloatingZone(img, contentWidth);
+		if (zone !== void 0) zones.push(zone);
+	}
+	return zones;
 }
 //#endregion
 export { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };

package/dist/layout-engine/measure/tableCellGrid.d.ts

@@ -16,13 +16,38 @@ type BuildTableCellPlacementsOptions = {
   grid: TableCellGrid;
   columnWidths: readonly number[];
   bidi: boolean;
+  /** `w:tblCellSpacing` in pixels; see {@link getTableCellSpacingInsetsX}. */
+  cellSpacing?: number | undefined;
 };
+type TableCellSpacingInsets = {
+  readonly start: number;
+  readonly end: number;
+};
+type TableCellSpacingInsetsY = {
+  readonly top: number;
+  readonly bottom: number;
+};
+/**
+ * Logical inline insets of a cell box inside its grid slot under
+ * `w:tblCellSpacing` (§17.4.43). The spacing separates every cell from its
+ * neighbours and from the table edge: each cell keeps one unit on each side of
+ * its slot, and a slot at the table's leading or trailing grid edge keeps one
+ * more for the edge itself.
+ */
+declare const getTableCellSpacingInsetsX: (cellSpacing: number | undefined, sourceColumn: number, columnSpan: number, columnCount: number) => TableCellSpacingInsets;
+/**
+ * Block-direction insets of a cell box inside the rows it spans, the
+ * `w:tblCellSpacing` counterpart of {@link getTableCellSpacingInsetsX}: one
+ * unit above and below every cell, plus one more at the table's first and
+ * last rows.
+ */
+declare const getTableCellSpacingInsetsY: (cellSpacing: number | undefined, rowIndex: number, rowSpan: number, rowCount: number) => TableCellSpacingInsetsY;
 declare const buildTableCellGrid: (rows: readonly TableRow[], columnCount: number) => TableCellGrid;
 declare const getFirstAvailableColumn: (grid: TableCellGrid, rowIndex: number, startingColumn: number) => number;
 declare const getSourceCellAt: (grid: TableCellGrid, rowIndex: number, columnIndex: number) => TableCell | undefined;
 declare const getSourceCellColumn: (grid: TableCellGrid, cell: TableCell) => number | undefined;
 /** Resolve all source cells to canonical logical columns and physical boxes. */
-declare const buildTableCellPlacements: ({ grid, columnWidths, bidi }: BuildTableCellPlacementsOptions) => TableCellPlacements;
-declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number) => number;
+declare const buildTableCellPlacements: ({ grid, columnWidths, bidi, cellSpacing }: BuildTableCellPlacementsOptions) => TableCellPlacements;
+declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number, separated?: boolean) => number;
 //#endregion
-export { TableCellGrid, TableCellPlacement, TableCellPlacements, buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { TableCellGrid, TableCellPlacement, TableCellPlacements, TableCellSpacingInsets, TableCellSpacingInsetsY, buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight };

package/dist/layout-engine/measure/tableCellGrid.js

@@ -1,5 +1,41 @@
 import { paintsCssBorder } from "../../utils/borderCss.js";
 //#region src/layout-engine/measure/tableCellGrid.ts
+const spacingUnit = (cellSpacing) => cellSpacing !== void 0 && Number.isFinite(cellSpacing) && cellSpacing > 0 ? cellSpacing : 0;
+/**
+* Logical inline insets of a cell box inside its grid slot under
+* `w:tblCellSpacing` (§17.4.43). The spacing separates every cell from its
+* neighbours and from the table edge: each cell keeps one unit on each side of
+* its slot, and a slot at the table's leading or trailing grid edge keeps one
+* more for the edge itself.
+*/
+const getTableCellSpacingInsetsX = (cellSpacing, sourceColumn, columnSpan, columnCount) => {
+	const unit = spacingUnit(cellSpacing);
+	if (unit === 0) return {
+		start: 0,
+		end: 0
+	};
+	return {
+		start: sourceColumn <= 0 ? unit * 2 : unit,
+		end: sourceColumn + columnSpan >= columnCount ? unit * 2 : unit
+	};
+};
+/**
+* Block-direction insets of a cell box inside the rows it spans, the
+* `w:tblCellSpacing` counterpart of {@link getTableCellSpacingInsetsX}: one
+* unit above and below every cell, plus one more at the table's first and
+* last rows.
+*/
+const getTableCellSpacingInsetsY = (cellSpacing, rowIndex, rowSpan, rowCount) => {
+	const unit = spacingUnit(cellSpacing);
+	if (unit === 0) return {
+		top: 0,
+		bottom: 0
+	};
+	return {
+		top: rowIndex <= 0 ? unit * 2 : unit,
+		bottom: rowIndex + Math.max(1, rowSpan) >= rowCount ? unit * 2 : unit
+	};
+};
 const buildTableCellGrid = (rows, columnCount) => {
 	const occupiedColumnsByRow = /* @__PURE__ */ new Map();
 	const sourceCellsByRow = /* @__PURE__ */ new Map();
@@ -36,7 +72,7 @@ const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailab
 const getSourceCellAt = (grid, rowIndex, columnIndex) => grid.sourceCellsByRow.get(rowIndex)?.get(columnIndex);
 const getSourceCellColumn = (grid, cell) => grid.sourceColumnsByCell.get(cell);
 /** Resolve all source cells to canonical logical columns and physical boxes. */
-const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
+const buildTableCellPlacements = ({ grid, columnWidths, bidi, cellSpacing }) => {
 	const columnOffsets = [0];
 	for (const columnWidth of columnWidths) columnOffsets.push((columnOffsets.at(-1) ?? 0) + columnWidth);
 	const tableWidth = columnOffsets.at(-1) ?? 0;
@@ -45,8 +81,11 @@ const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
 		if (sourceColumn < 0 || sourceColumn >= columnWidths.length) continue;
 		const declaredColumnSpan = Math.max(1, Math.trunc(cell.colSpan ?? 1));
 		const columnSpan = Math.min(declaredColumnSpan, columnWidths.length - sourceColumn);
-		const logicalLeft = columnOffsets.at(sourceColumn) ?? 0;
-		const logicalRight = columnOffsets.at(sourceColumn + columnSpan) ?? logicalLeft;
+		const slotLeft = columnOffsets.at(sourceColumn) ?? 0;
+		const slotRight = columnOffsets.at(sourceColumn + columnSpan) ?? slotLeft;
+		const insets = getTableCellSpacingInsetsX(cellSpacing, sourceColumn, columnSpan, columnWidths.length);
+		const logicalLeft = Math.min(slotRight, slotLeft + insets.start);
+		const logicalRight = Math.max(logicalLeft, slotRight - insets.end);
 		const width = logicalRight - logicalLeft;
 		placements.set(cell, {
 			sourceColumn,
@@ -57,7 +96,8 @@ const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
 	}
 	return placements;
 };
-const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
+const getTableCellVerticalBorderHeight = (grid, cell, rowIndex, separated = false) => {
+	if (separated) return (cell?.borders?.top?.width ?? 0) + (cell?.borders?.bottom?.width ?? 0);
 	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
 	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
 	const aboveOwnsEdge = aboveBottom !== void 0 && paintsCssBorder(aboveBottom.style);
@@ -83,4 +123,4 @@ const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
 	return occupiedColumns;
 };
 //#endregion
-export { buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight };

package/dist/layout-engine/measure/tableFragmentBorderGeometry.js

@@ -9,7 +9,8 @@ const tableFragmentBottomBorders = ({ fragment, block, measure, placements: supp
 	const placements = suppliedPlacements ?? buildTableCellPlacements({
 		grid: buildTableCellGrid(block.rows, measure.columnWidths.length),
 		columnWidths: measure.columnWidths,
-		bidi: block.bidi === true
+		bidi: block.bidi === true,
+		cellSpacing: block.cellSpacing
 	});
 	return splitRow.cells.flatMap((cell) => {
 		const placement = placements.get(cell);

package/dist/layout-engine/noteAreaFlow.d.ts

@@ -0,0 +1,19 @@
+import { FlowBlock, Layout, Measure, NoteAreaLayout } from "./types.js";
+import { PageTopContinuation, Paginator } from "./paginator.js";
+//#region src/layout-engine/noteAreaFlow.d.ts
+/**
+ * The continuation separator a page opens with while a note area continues
+ * onto it. Its space after collapses with the next note paragraph's space
+ * before, as between any two paragraphs.
+ */
+declare function createNoteAreaContinuation(noteAreas: NoteAreaLayout | undefined, paginator: Paginator): PageTopContinuation | undefined;
+/** Whether laying out `block` continues a note area onto any page it opens. */
+declare function continuesNoteArea(noteAreas: NoteAreaLayout | undefined, block: FlowBlock): boolean;
+/**
+ * Record where each separator mark landed. A rule is centred on the first line
+ * of the separator paragraph: a `w:separator` spans part of the column and a
+ * `w:continuationSeparator` all of it.
+ */
+declare function annotateNoteSeparators(layout: Layout, blocks: readonly FlowBlock[], measures: readonly Measure[], noteAreas: NoteAreaLayout | undefined): Layout;
+//#endregion
+export { annotateNoteSeparators, continuesNoteArea, createNoteAreaContinuation };

package/dist/layout-engine/noteAreaFlow.js

@@ -0,0 +1,83 @@
+import { measuredLineRangeHeight } from "./lineFlow.js";
+import { getParagraphSpacingAfter } from "./paragraphSpacing.js";
+import { NOTE_SEPARATOR_RULE_THICKNESS, NOTE_SEPARATOR_WIDTH_FRACTION } from "./types.js";
+//#region src/layout-engine/noteAreaFlow.ts
+/**
+* Note areas that flow with the body (ECMA-376 §17.11).
+*
+* Endnotes are collected after the last body block of the document, or of a
+* section, and paginate exactly as body content does. Two things set them
+* apart from the body: the area opens with its `w:separator` story, and every
+* page the area continues onto opens with its `w:continuationSeparator` story.
+* Both stories draw their separator mark as a horizontal rule.
+*/
+/**
+* The continuation separator a page opens with while a note area continues
+* onto it. Its space after collapses with the next note paragraph's space
+* before, as between any two paragraphs.
+*/
+function createNoteAreaContinuation(noteAreas, paginator) {
+	const continuation = noteAreas?.continuationSeparator;
+	if (continuation === void 0) return;
+	const { block, measure } = continuation;
+	const height = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+	return (state, x, width) => {
+		const fragment = {
+			kind: "paragraph",
+			blockId: block.id,
+			x,
+			y: state.cursorY,
+			width,
+			height,
+			fromLine: 0,
+			toLine: measure.lines.length
+		};
+		paginator.addUnflowedFragment(fragment);
+		state.trailingSpacing = getParagraphSpacingAfter(block);
+		return height;
+	};
+}
+/** Whether laying out `block` continues a note area onto any page it opens. */
+function continuesNoteArea(noteAreas, block) {
+	return noteAreas?.contentBlockIds.has(String(block.id)) === true;
+}
+/**
+* Record where each separator mark landed. A rule is centred on the first line
+* of the separator paragraph: a `w:separator` spans part of the column and a
+* `w:continuationSeparator` all of it.
+*/
+function annotateNoteSeparators(layout, blocks, measures, noteAreas) {
+	if (noteAreas === void 0 || noteAreas.separatorBlockIds.size === 0) return layout;
+	const measureById = /* @__PURE__ */ new Map();
+	for (const [index, block] of blocks.entries()) {
+		const measure = measures[index];
+		if (noteAreas.separatorBlockIds.has(String(block.id)) && measure?.kind === "paragraph") measureById.set(String(block.id), measure);
+	}
+	const continuation = noteAreas.continuationSeparator;
+	if (continuation !== void 0) measureById.set(String(continuation.block.id), continuation.measure);
+	for (const page of layout.pages) {
+		const rules = [];
+		for (const fragment of page.fragments) {
+			if (fragment.kind !== "paragraph" || fragment.fromLine !== 0) continue;
+			const kind = noteAreas.separatorBlockIds.get(String(fragment.blockId));
+			const firstLine = measureById.get(String(fragment.blockId))?.lines.at(0);
+			if (kind === void 0 || firstLine === void 0) continue;
+			rules.push({
+				x: fragment.x,
+				y: fragment.y + (firstLine.lineHeight - NOTE_SEPARATOR_RULE_THICKNESS) / 2,
+				width: fragment.width * separatorWidthFraction(kind)
+			});
+		}
+		if (rules.length > 0) page.noteSeparators = rules;
+	}
+	return layout;
+}
+function separatorWidthFraction(kind) {
+	switch (kind) {
+		case "separator": return NOTE_SEPARATOR_WIDTH_FRACTION;
+		case "continuationSeparator": return 1;
+		default: return kind;
+	}
+}
+//#endregion
+export { annotateNoteSeparators, continuesNoteArea, createNoteAreaContinuation };

package/dist/layout-engine/paginator.d.ts

@@ -51,6 +51,8 @@ type PaginatorOptions = {
   firstPageMargins?: PageMargins;
   /** Per-section body margins used on even authored page numbers. */
   sectionEvenPageMargins?: (PageMargins | undefined)[];
+  /** Per-section body margins used on the first page of a `w:titlePg` section. */
+  sectionFirstPageMargins?: (PageMargins | undefined)[];
   /** Page-number policy for the initial section. */
   pageNumbering?: SectionPageNumbering;
   /** Column configuration (optional). */
@@ -65,6 +67,13 @@ type PaginatorOptions = {
 type ForcePageBreakOptions = {
   coalesceBlankPage?: boolean;
 };
+/**
+ * Content that opens every page created while a flow continues from an
+ * earlier page (a note area's continuation separator). Called with the new
+ * page's state and the first column's box; returns the height it placed,
+ * which the page's flow then starts below.
+ */
+type PageTopContinuation = (state: PageState, x: number, width: number) => number;
 declare const SECTION_START_PLACEMENT: {
   readonly CONTINUOUS: "continuous";
   readonly NEXT_PAGE: "nextPage";
@@ -147,7 +156,9 @@ declare function createPaginator(options: PaginatorOptions): {
   }, newMargins?: PageMargins, applyImmediately?: boolean) => void;
   /** Mark the next created page as the first page of a new section. */
   startSection: ({ sectionIndex, pageNumbering, placement }: StartSectionOptions) => void;
+  /** Set (or clear) the content that opens each page a flow continues onto. */
+  setPageTopContinuation: (continuation: PageTopContinuation | undefined) => void;
 };
 type Paginator = ReturnType<typeof createPaginator>;
 //#endregion
-export { FOOTNOTE_SEPARATOR_HEIGHT, PageState, Paginator, PaginatorOptions, SECTION_START_PLACEMENT, calculateColumnLefts, calculateColumnWidths, createPaginator, resolveColumnLeft };
+export { FOOTNOTE_SEPARATOR_HEIGHT, PageState, PageTopContinuation, Paginator, PaginatorOptions, SECTION_START_PLACEMENT, calculateColumnLefts, calculateColumnWidths, createPaginator, resolveColumnLeft };

package/dist/layout-engine/paginator.js

@@ -62,6 +62,7 @@ function createPaginator(options) {
 		type: "pending",
 		placement: "nextPage"
 	};
+	let pageTopContinuation;
 	const pages = [];
 	const states = [];
 	const paginationStateByPage = /* @__PURE__ */ new WeakMap();
@@ -93,7 +94,11 @@ function createPaginator(options) {
 	}
 	function getPageMargins(pageNumber, logicalPageNumber) {
 		const evenMargins = logicalPageNumber % 2 === 0 ? options.sectionEvenPageMargins?.[currentSectionIndex] : void 0;
-		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...evenMargins ?? margins };
+		const titlePageMargins = currentSectionPageNumber === 1 ? options.sectionFirstPageMargins?.[currentSectionIndex] : void 0;
+		let pageMargins;
+		if (titlePageMargins) pageMargins = { ...titlePageMargins };
+		else if (pageNumber === 1 && options.firstPageMargins) pageMargins = { ...options.firstPageMargins };
+		else pageMargins = { ...evenMargins ?? margins };
 		if (options.mirrorMargins === true && pageNumber % 2 === 0) return {
 			...pageMargins,
 			left: pageMargins.right,
@@ -180,6 +185,13 @@ function createPaginator(options) {
 		states.push(state);
 		columnRegionTop = topMargin;
 		columnRegionMaxBottom = topMargin;
+		const continuationHeight = pageTopContinuation?.(state, getColumnX(0), columnWidths[0] ?? getContentWidth()) ?? 0;
+		if (continuationHeight > 0) {
+			state.cursorY += continuationHeight;
+			state.topMargin += continuationHeight;
+			columnRegionTop = state.topMargin;
+			columnRegionMaxBottom = state.topMargin;
+		}
 		if (options.onNewPage) options.onNewPage(state);
 		return state;
 	}
@@ -503,7 +515,11 @@ function createPaginator(options) {
 		/** Update page size/margins for subsequent pages. */
 		updatePageLayout,
 		/** Mark the next created page as the first page of a new section. */
-		startSection
+		startSection,
+		/** Set (or clear) the content that opens each page a flow continues onto. */
+		setPageTopContinuation: (continuation) => {
+			pageTopContinuation = continuation;
+		}
 	};
 }
 //#endregion

package/dist/layout-engine/paragraphSpacing.d.ts

@@ -1,4 +1,4 @@
-import { FlowBlock, ParagraphBlock } from "./types.js";
+import { FlowBlock, ParagraphBlock, TableBlock } from "./types.js";
 //#region src/layout-engine/paragraphSpacing.d.ts
 type EffectiveParagraphSpacing = Readonly<{
   before: number;
@@ -35,5 +35,7 @@ declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => Effec
  */
 declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
 declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
+/** Derive the effective paragraph spacing of every cell story in a table. */
+declare const resolveTableSpacing: (block: TableBlock) => TableBlock;
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree, resolveTableSpacing };

package/dist/layout-engine/paragraphSpacing.js

@@ -88,6 +88,7 @@ const resolveTextBoxContentSpacing = (blocks) => {
 	});
 	return changed ? resolved : blocks;
 };
+/** Derive the effective paragraph spacing of every cell story in a table. */
 const resolveTableSpacing = (block) => {
 	let changed = false;
 	const rows = block.rows.map((row) => {
@@ -122,4 +123,4 @@ const resolveTextBoxSpacing = (block) => {
 	};
 };
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree, resolveTableSpacing };

package/dist/layout-engine/tableRowBreak.d.ts

@@ -19,6 +19,13 @@ type TableRowBreakInfo = {
   /** Suppressible leading paragraph whitespace after each matching break offset. */
   continuationSkips: number[][];
 };
+/**
+ * Height of the start of a table that a preceding `w:keepNext` paragraph
+ * (§17.3.1.15) must share a page with: the leading header rows (§17.4.49) and
+ * the first body row. A row that may break across pages (no `w:cantSplit`,
+ * §17.4.6) needs only its first line there; an unbreakable row needs all of it.
+ */
+declare function tableKeepNextOpeningHeight(block: TableBlock, measure: TableMeasure): number;
 /** Build break geometry for a table from its block + measure. */
 declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure): TableRowBreakInfo;
 /** Leading empty-paragraph whitespace to consume when a row resumes after `offset`. */
@@ -30,4 +37,4 @@ declare function getRowContinuationSkip(info: TableRowBreakInfo, rowIndex: numbe
  */
 declare function snapRowBreak(info: TableRowBreakInfo, rowIndex: number, fromOffset: number, maxSlice: number): number;
 //#endregion
-export { TableRowBreakInfo, buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak };
+export { TableRowBreakInfo, buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak, tableKeepNextOpeningHeight };

package/dist/layout-engine/tableRowBreak.js

@@ -2,6 +2,7 @@ import { measuredLineAdvance } from "./lineFlow.js";
 import { measureParagraph } from "./measure/measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "./measure/tableCellFloating.js";
 import { createTableCellFlowState, placeTableCellBlock } from "./measure/tableCellFlow.js";
+import { getTableCellSpacingInsetsY } from "./measure/tableCellGrid.js";
 import { isEmptyParagraph } from "./paragraphSpacing.js";
 import { resolveTableCellPadding } from "./types.js";
 //#region src/layout-engine/tableRowBreak.ts
@@ -140,6 +141,27 @@ const continuationSkipAfter = (geometries, offset) => {
 	if (skips.length === 0 || skips.some((skip) => skip <= BREAK_OFFSET_EPSILON)) return 0;
 	return Math.min(...skips);
 };
+/**
+* Height of the start of a table that a preceding `w:keepNext` paragraph
+* (§17.3.1.15) must share a page with: the leading header rows (§17.4.49) and
+* the first body row. A row that may break across pages (no `w:cantSplit`,
+* §17.4.6) needs only its first line there; an unbreakable row needs all of it.
+*/
+function tableKeepNextOpeningHeight(block, measure) {
+	let height = 0;
+	let rowIndex = 0;
+	while (rowIndex < measure.rows.length && block.rows[rowIndex]?.isHeader === true) {
+		height += measure.rows[rowIndex]?.height ?? 0;
+		rowIndex += 1;
+	}
+	const row = measure.rows[rowIndex];
+	const sourceRow = block.rows[rowIndex];
+	if (!row || !sourceRow) return height;
+	const breakOffsets = buildTableRowBreakInfo(block, measure).breakOffsets[rowIndex] ?? [];
+	const firstBreak = breakOffsets.at(0);
+	const rowMayBreak = sourceRow.cantSplit !== true && breakOffsets.length > 1;
+	return height + (rowMayBreak && firstBreak !== void 0 ? firstBreak : row.height);
+}
 /** Build break geometry for a table from its block + measure. */
 function buildTableRowBreakInfo(block, measure) {
 	const rowCount = measure.rows.length;
@@ -164,7 +186,8 @@ function buildTableRowBreakInfo(block, measure) {
 			const measuredCell = measuredCells[c];
 			if (!measuredCell) continue;
 			const sourceCell = sourceCells[c];
-			const geometry = shiftCellGeometry(cellBreakGeometry(sourceCell, measuredCell), getVerticalAlignmentOffset(sourceCell, measuredCell, rowHeight));
+			const spacing = getTableCellSpacingInsetsY(block.cellSpacing, r, sourceCell?.rowSpan ?? 1, block.rows.length);
+			const geometry = shiftCellGeometry(cellBreakGeometry(sourceCell, measuredCell), spacing.top + getVerticalAlignmentOffset(sourceCell, measuredCell, Math.max(0, rowHeight - spacing.top - spacing.bottom)));
 			cellGeometries.push(geometry);
 			for (const b of geometry.bottoms) if (b > 0 && b < rowHeight) offsets.add(b);
 		}
@@ -206,4 +229,4 @@ function snapRowBreak(info, rowIndex, fromOffset, maxSlice) {
 	return best;
 }
 //#endregion
-export { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak };
+export { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak, tableKeepNextOpeningHeight };