@stll/folio-core 0.62.0 → 0.63.0

package/dist/layout-engine/paragraphLayout.js

@@ -100,7 +100,10 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 			});
 			const columnCapacity = state.contentBottom - state.topMargin;
 			if (collapsedLead + firstLineHeight > availableHeight && spaceBefore + firstLineHeight <= columnCapacity) {
-				paginator.ensureFits(collapsedLead + firstLineHeight);
+				paginator.ensureFits({
+					requiredHeight: collapsedLead + firstLineHeight,
+					freshColumnHeight: firstLineHeight
+				});
 				continue;
 			}
 		}
@@ -113,7 +116,10 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 			const columnCapacity = state.contentBottom - state.topMargin;
 			if (collapsedLead + wholeHeight > availableHeight && spaceBefore + wholeHeight <= columnCapacity) {
 				keepLinesMoveAttempted = true;
-				paginator.ensureFits(collapsedLead + wholeHeight);
+				paginator.ensureFits({
+					requiredHeight: collapsedLead + wholeHeight,
+					freshColumnHeight: wholeHeight
+				});
 				continue;
 			}
 		}
@@ -122,10 +128,11 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 		const linesFnIds = [];
 		let fittingLines = 0;
 		let forcePageBreakAfterFragment = false;
-		const firstFragmentSpaceBefore = currentLineIndex === 0 ? collapseParagraphSpacing({
+		let firstFragmentSpaceBefore = 0;
+		if (currentLineIndex === 0 && !paginator.isAtFreshColumnRegion()) firstFragmentSpaceBefore = collapseParagraphSpacing({
 			before: spaceBefore,
 			after: state.trailingSpacing
-		}) : 0;
+		});
 		for (let j = currentLineIndex; j < lines.length; j++) {
 			const line = lines[j];
 			const lineAdvance = measuredLineAdvance(line);
@@ -188,16 +195,28 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 		};
 		if (linesFnHeight > 0) {
 			const stateBefore = paginator.getCurrentState();
-			paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateBefore, linesFnHeight));
+			const firstPassFootnoteGrowth = projectedFootnoteReserveGrowth(stateBefore, linesFnHeight);
+			paginator.ensureFits({
+				requiredHeight: effectiveSpaceBefore + linesHeight + firstPassFootnoteGrowth,
+				freshColumnHeight: linesHeight + firstPassFootnoteGrowth
+			});
 			const stateAfter = paginator.getCurrentState();
-			if (stateAfter.footnoteDemandHeight === 0) paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateAfter, linesFnHeight + 12));
+			if (stateAfter.footnoteDemandHeight === 0) {
+				const freshColumnFootnoteGrowth = projectedFootnoteReserveGrowth(stateAfter, linesFnHeight + 12);
+				paginator.ensureFits({
+					requiredHeight: effectiveSpaceBefore + linesHeight + freshColumnFootnoteGrowth,
+					freshColumnHeight: linesHeight + freshColumnFootnoteGrowth
+				});
+			}
 		}
 		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
 		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
 		currentLineIndex += fittingLines;
-		if (currentLineIndex < lines.length) if (forcePageBreakAfterFragment) paginator.forcePageBreak();
-		else if (forceBreakAfterFragment) paginator.forceColumnBreak();
-		else paginator.ensureFits(measuredLineAdvance(lines[currentLineIndex]));
+		if (currentLineIndex < lines.length) {
+			if (forcePageBreakAfterFragment) paginator.forcePageBreak();
+			else if (forceBreakAfterFragment) paginator.forceColumnBreak();
+			else paginator.ensureFits({ requiredHeight: measuredLineAdvance(lines[currentLineIndex]) });
+		}
 	}
 }
 //#endregion

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

@@ -1,6 +1,5 @@
 import { FlowBlock } from "./types.js";
 //#region src/layout-engine/paragraphSequence.d.ts
-declare const continuesNumberedSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
-declare const continuesTabbedParagraphSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
-//#endregion
-export { continuesNumberedSequence, continuesTabbedParagraphSequence };
+export declare const continuesNumberedSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+export declare const continuesTabbedParagraphSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+//#endregion

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

@@ -9,23 +9,23 @@ type CollapseParagraphSpacingOptions = {
   after: number;
 };
 /** Collapse adjacent paragraph spacing to the larger authored side. */
-declare const collapseParagraphSpacing: ({ before, after }: CollapseParagraphSpacingOptions) => number;
+export declare const collapseParagraphSpacing: ({ before, after }: CollapseParagraphSpacingOptions) => number;
 /** Whether a paragraph has no visible run content. */
-declare function isEmptyParagraph(block: ParagraphBlock): boolean;
+export declare function isEmptyParagraph(block: ParagraphBlock): boolean;
 /** Whether a visually empty paragraph carries authored formatting semantics. */
-declare const isAuthoredEmptyParagraph: (block: ParagraphBlock) => boolean;
+export declare const isAuthoredEmptyParagraph: (block: ParagraphBlock) => boolean;
 /**
  * Resolve leading paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare const getParagraphSpacingBefore: (block: ParagraphBlock) => number;
+export declare const getParagraphSpacingBefore: (block: ParagraphBlock) => number;
 /**
  * Resolve trailing paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare const getParagraphSpacingAfter: (block: ParagraphBlock) => number;
+export declare const getParagraphSpacingAfter: (block: ParagraphBlock) => number;
 /** Resolve empty-paragraph spacing without modifying the authored block. */
-declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => EffectiveParagraphSpacing;
+export declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => EffectiveParagraphSpacing;
 /**
  * Derive sequence-level spacing suppression with structural sharing.
  *
@@ -33,9 +33,9 @@ declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => Effec
  * OOXML formatting. Only changed branches are cloned; the input tree remains
  * untouched and repeated resolution is idempotent.
  */
-declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
-declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
+export declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
+export 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;
+export declare const resolveTableSpacing: (block: TableBlock) => TableBlock;
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree, resolveTableSpacing };
+export {};

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

@@ -7,7 +7,7 @@ import { Layout } from "./types.js";
  * names the calling site so runtime failures (e.g. an old adapter
  * compiled against a newer core) point future debuggers at the contract.
  */
-declare function assertExhaustiveFlowBlock(block: never, site: string): never;
+export declare function assertExhaustiveFlowBlock(block: never, site: string): never;
 /**
  * Page index (0-based) whose layout fragments cover `pmPos`, or null if none.
  * Used when the painted DOM may not yet have `[data-pm-start]` for this position (virtualization).
@@ -18,6 +18,5 @@ declare function assertExhaustiveFlowBlock(block: never, site: string): never;
  * fragment wins (avoids returning the previous page for the start of the
  * next paragraph).
  */
-declare function findPageIndexContainingPmPos(layout: Layout, pmPos: number): number | null;
-//#endregion
-export { assertExhaustiveFlowBlock, findPageIndexContainingPmPos };
+export declare function findPageIndexContainingPmPos(layout: Layout, pmPos: number): number | null;
+//#endregion

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

@@ -1,6 +1,6 @@
 import { FlowBlock, Page } from "./types.js";
 //#region src/layout-engine/renderedBreakReconciliation.d.ts
-type RenderedBreakState = {
+export type RenderedBreakState = {
   type: "noPageAdvance";
 } | {
   type: "pageAdvance";
@@ -15,7 +15,7 @@ type RenderedBreakState = {
   boundary: "sectionBreak";
   nextHardBreak: "coalesce" | "advance";
 };
-declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
+export declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
 type ReconcileBeforeBlockOptions = {
   state: RenderedBreakState;
   block: FlowBlock;
@@ -25,7 +25,7 @@ type ReconcileBeforeBlockOptions = {
   hasExplicitPageBreak: boolean;
   renderedBreakNeedsSnap: boolean;
 };
-declare const PAGE_ADVANCE: {
+export declare const PAGE_ADVANCE: {
   readonly COALESCED: "coalesced";
   readonly NONE: "none";
   readonly PHYSICAL: "physical";
@@ -44,8 +44,8 @@ type BreakDecision = {
  * Every marker consumes the accumulated advance state so later markers make
  * independent decisions.
  */
-declare const reconcileBreakBeforeBlock: ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }: ReconcileBeforeBlockOptions) => BreakDecision;
-declare const recordReflowBoundary: (state: RenderedBreakState, crossedPageBoundary: boolean) => RenderedBreakState;
+export declare const reconcileBreakBeforeBlock: ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }: ReconcileBeforeBlockOptions) => BreakDecision;
+export declare const recordReflowBoundary: (state: RenderedBreakState, crossedPageBoundary: boolean) => RenderedBreakState;
 type ReconcileAfterBlockOptions = {
   state: RenderedBreakState;
   block: FlowBlock;
@@ -54,6 +54,6 @@ type ReconcileAfterBlockOptions = {
   previousPage: Page | undefined;
 };
 /** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
-declare const reconcileAfterBlock: ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }: ReconcileAfterBlockOptions) => RenderedBreakState;
+export declare const reconcileAfterBlock: ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }: ReconcileAfterBlockOptions) => RenderedBreakState;
 //#endregion
-export { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, RenderedBreakState, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };
+export {};

package/dist/layout-engine/section-breaks.d.ts

@@ -5,7 +5,7 @@ import { SectionStart } from "@stll/docx-core/model";
  * State tracking for sections during layout.
  * Uses active/pending pattern to schedule changes at page boundaries.
  */
-type SectionState = {
+export type SectionState = {
   /** Currently active top margin. */
   activeTopMargin: number;
   /** Currently active bottom margin. */
@@ -46,7 +46,7 @@ type SectionState = {
 /**
  * Decision about what happens at a section break.
  */
-type BreakDecision = {
+export type BreakDecision = {
   /** Force a page break. */
   forcePageBreak: boolean;
   /** Force a mid-page region change (for column layout changes). */
@@ -55,7 +55,7 @@ type BreakDecision = {
   requiredParity?: "even" | "odd";
 };
 /** `w:sectPr` may omit `w:type`; §17.6.22's omitted value is `nextPage`. */
-declare const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
+export declare const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
 /**
  * The section start a boundary states, with the omitted value resolved.
  *
@@ -63,7 +63,7 @@ declare const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
  * `ST_SectionMark` is not, so it panics rather than resolving to the same
  * default and hiding whichever producer invented it.
  */
-declare function normalizeSectionBreakType(sectionStart: SectionBreakBlock["type"]): SectionStart;
+export declare function normalizeSectionBreakType(sectionStart: SectionBreakBlock["type"]): SectionStart;
 /**
  * What a section start does to the page it begins on.
  *
@@ -80,15 +80,15 @@ declare const SECTION_START_ADVANCE: {
   readonly nextColumn: "column";
   readonly continuous: "region";
 };
-type SectionStartAdvance = (typeof SECTION_START_ADVANCE)[SectionStart];
+export type SectionStartAdvance = (typeof SECTION_START_ADVANCE)[SectionStart];
 /** The disposition of the section starting at a boundary. Total over `ST_SectionMark`. */
-declare const sectionStartAdvanceOf: (sectionStart: SectionBreakBlock["type"]) => SectionStartAdvance;
+export declare const sectionStartAdvanceOf: (sectionStart: SectionBreakBlock["type"]) => SectionStartAdvance;
 /**
  * Whether a section start can continue into the column region the outgoing
  * section occupies: it needs a further column, and the incoming section has to
  * repeat the geometry rather than redefine it.
  */
-declare const columnRegionIsShared: (active: ColumnLayout, next: ColumnLayout | undefined) => boolean;
+export declare const columnRegionIsShared: (active: ColumnLayout, next: ColumnLayout | undefined) => boolean;
 type PhysicalColumnRegion = {
   pageSize: {
     w: number;
@@ -101,11 +101,11 @@ type CandidatePhysicalColumnRegion = Omit<PhysicalColumnRegion, "columns"> & {
   columns?: ColumnLayout;
 };
 /** Whether two sections describe the same physical column region on a sheet. */
-declare const physicalColumnRegionIsShared: (active: PhysicalColumnRegion, next: CandidatePhysicalColumnRegion) => boolean;
+export declare const physicalColumnRegionIsShared: (active: PhysicalColumnRegion, next: CandidatePhysicalColumnRegion) => boolean;
 /**
  * Create initial section state from default options.
  */
-declare function createInitialSectionState(margins: PageMargins, pageSize: {
+export declare function createInitialSectionState(margins: PageMargins, pageSize: {
   w: number;
   h: number;
 }, columns?: ColumnLayout): SectionState;
@@ -115,7 +115,7 @@ declare function createInitialSectionState(margins: PageMargins, pageSize: {
  * This determines what layout changes should occur (page break, column changes)
  * and schedules the new section properties to be applied at the appropriate boundary.
  */
-declare function scheduleSectionBreak(block: SectionBreakBlock, state: SectionState, _baseMargins: PageMargins): {
+export declare function scheduleSectionBreak(block: SectionBreakBlock, state: SectionState, _baseMargins: PageMargins): {
   decision: BreakDecision;
   state: SectionState;
 };
@@ -123,22 +123,22 @@ declare function scheduleSectionBreak(block: SectionBreakBlock, state: SectionSt
  * Apply pending section state to active state at a page boundary.
  * Transfers all pending values to active and clears pending.
  */
-declare function applyPendingToActive(state: SectionState): SectionState;
+export declare function applyPendingToActive(state: SectionState): SectionState;
 /**
  * Get the effective margins for the current section state.
  * Returns active margins, or pending if scheduled.
  */
-declare function getEffectiveMargins(state: SectionState): PageMargins;
+export declare function getEffectiveMargins(state: SectionState): PageMargins;
 /**
  * Get the effective page size for the current section state.
  */
-declare function getEffectivePageSize(state: SectionState): {
+export declare function getEffectivePageSize(state: SectionState): {
   w: number;
   h: number;
 };
 /**
  * Get the effective columns for the current section state.
  */
-declare function getEffectiveColumns(state: SectionState): ColumnLayout;
+export declare function getEffectiveColumns(state: SectionState): ColumnLayout;
 //#endregion
-export { BreakDecision, DEFAULT_SECTION_BREAK_TYPE, SectionStartAdvance, SectionState, applyPendingToActive, columnRegionIsShared, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, physicalColumnRegionIsShared, scheduleSectionBreak, sectionStartAdvanceOf };
+export {};

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

@@ -2,7 +2,7 @@ import { ColumnLayout, FlowBlock, Measure, PageMargins, SectionBreakBlock, Secti
 import { createPaginator } from "./paginator.js";
 import { SectionStart } from "@stll/docx-core/model";
 //#region src/layout-engine/sectionLayout.d.ts
-type SectionLayoutConfig = {
+export type SectionLayoutConfig = {
   pageSize: {
     w: number;
     h: number;
@@ -11,9 +11,9 @@ type SectionLayoutConfig = {
   pageNumbering: SectionPageNumbering;
   columns?: ColumnLayout;
 };
-declare const DEFAULT_COLUMNS: ColumnLayout;
-declare const CONTINUE_PAGE_NUMBERING: SectionPageNumbering;
-declare function collectSectionConfigs(blocks: FlowBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig): {
+export declare const DEFAULT_COLUMNS: ColumnLayout;
+export declare const CONTINUE_PAGE_NUMBERING: SectionPageNumbering;
+export declare function collectSectionConfigs(blocks: FlowBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig): {
   configs: SectionLayoutConfig[];
   breakIndices: number[];
 };
@@ -32,7 +32,7 @@ type BalancedParagraphSectionHeightOptions = {
   columnCount: number;
   availableHeight: number;
 };
-declare function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }: BalancedParagraphSectionHeightOptions): number | undefined;
+export declare function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }: BalancedParagraphSectionHeightOptions): number | undefined;
 /**
  * Handle a section break block.
  * @param block - The section break block (current section's properties)
@@ -40,6 +40,6 @@ declare function balancedParagraphSectionHeight({ blocks, measures, startIndex,
  * @param nextSectionConfig - Page layout for the NEXT section
  * @param nextSectionType - Break type of the NEXT section (how it starts relative to current)
  */
-declare function handleSectionBreak(_block: SectionBreakBlock, paginator: ReturnType<typeof createPaginator>, nextSectionConfig: SectionLayoutConfig, nextSectionType: SectionStart, nextSectionIndex?: number): void;
+export declare function handleSectionBreak(_block: SectionBreakBlock, paginator: ReturnType<typeof createPaginator>, nextSectionConfig: SectionLayoutConfig, nextSectionType: SectionStart, nextSectionIndex?: number): void;
 //#endregion
-export { CONTINUE_PAGE_NUMBERING, DEFAULT_COLUMNS, SectionLayoutConfig, balancedParagraphSectionHeight, collectSectionConfigs, handleSectionBreak };
+export {};

package/dist/layout-engine/sectionLayout.js

@@ -205,10 +205,7 @@ function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionTyp
 			paginator.forceColumnBreak();
 			return;
 		}
-		case "continuous":
-			startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex);
-			break;
-		default:
+		case "continuous": startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex);
 	}
 	paginator.updateColumns(nextSectionConfig.columns ?? DEFAULT_COLUMNS);
 }

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

@@ -2,6 +2,5 @@ import { Layout } from "./types.js";
 import { VerticalAlign } from "@stll/docx-core/model";
 //#region src/layout-engine/sectionVerticalAlignment.d.ts
 /** Align each page's body inside the authored section content frame. */
-declare const applySectionVerticalAlignment: (layout: Layout, alignments: readonly (VerticalAlign | undefined)[] | undefined) => Layout;
-//#endregion
-export { applySectionVerticalAlignment };
+export declare const applySectionVerticalAlignment: (layout: Layout, alignments: readonly (VerticalAlign | undefined)[] | undefined) => Layout;
+//#endregion

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

@@ -1,5 +1,4 @@
 import { TableBlock } from "./types.js";
 //#region src/layout-engine/tableIndentCompatibility.d.ts
-declare const resolveTableIndentCompatibility: (compatibilityMode: number | undefined) => NonNullable<TableBlock["indentCompatibility"]> | undefined;
-//#endregion
-export { resolveTableIndentCompatibility };
+export declare const resolveTableIndentCompatibility: (compatibilityMode: number | undefined) => NonNullable<TableBlock["indentCompatibility"]> | undefined;
+//#endregion

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

@@ -4,14 +4,13 @@ import { createPaginator } from "./paginator.js";
 /**
  * Calculate total height of header rows from their measures.
  */
-declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
+export declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
 /**
  * Layout a table block onto pages.
  */
-declare function layoutTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, footnoteHeightById?: Map<number, number>): void;
+export declare function layoutTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, footnoteHeightById?: Map<number, number>): void;
 /**
  * Layout a floating table (anchored) without advancing the cursor.
  */
-declare function layoutFloatingTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, contentWidth: number): void;
-//#endregion
-export { getHeaderRowsHeight, layoutFloatingTable, layoutTable };
+export declare function layoutFloatingTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, contentWidth: number): void;
+//#endregion

package/dist/layout-engine/tableLayout.js

@@ -96,11 +96,11 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
 		const row = rows[rowIndex];
 		const sourceRow = block.rows[rowIndex];
-		if (!row || !sourceRow || sourceRow.isHeader || verticallyMergedRows.has(rowIndex)) return false;
+		if (!row || !sourceRow || sourceRow.heightRule === "exact" || sourceRow.isHeader || verticallyMergedRows.has(rowIndex)) return false;
 		if ((breakInfo.breakOffsets[rowIndex]?.length ?? 0) <= 1) return false;
 		const freshHeaderOverhead = headerRowCount > 0 && rowIndex >= headerRowCount ? headerRowsHeight : 0;
 		const oversized = row.height + freshHeaderOverhead > getCurrentRowCapacity(state);
-		if (sourceRow.cantSplit) return oversized && sourceRow.heightRule !== "exact" && rowOpensFlowRegion(rowIndex, state);
+		if (sourceRow.cantSplit) return oversized && rowOpensFlowRegion(rowIndex, state);
 		if (!oversized && (state.footnoteHeight > 0 || (rowFootnoteIds[rowIndex]?.length ?? 0) > 0)) return false;
 		const currentHeaderOverhead = shouldRepeatHeaderRows(rowIndex, 0, state) ? headerRowsHeight : 0;
 		const currentAvailableHeight = paginator.getAvailableHeight() - currentHeaderOverhead - state.trailingSpacing;
@@ -188,11 +188,13 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 					rowIndex: currentRowIndex
 				});
 				consumed = nextConsumed;
-				if (consumed < splittableRow.height) if (forceRenderedPageBreak) paginator.forcePageBreak();
-				else {
-					const previousPageNumber = paginator.getCurrentState().page.number;
-					paginator.forceColumnBreak();
-					advanceAfterNaturalFlowBreak(previousPageNumber);
+				if (consumed < splittableRow.height) {
+					if (forceRenderedPageBreak) paginator.forcePageBreak();
+					else {
+						const previousPageNumber = paginator.getCurrentState().page.number;
+						paginator.forceColumnBreak();
+						advanceAfterNaturalFlowBreak(previousPageNumber);
+					}
 				}
 			}
 			currentRowIndex += 1;
@@ -207,6 +209,7 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		const normalHeaderOverhead = repeatHeaderRowsForNormalFragment ? headerRowsHeight : 0;
 		let rowsHeight = 0;
 		let fittingRows = 0;
+		let exactRowBottomClip;
 		const pageFootnoteIds = new Set(state.page.footnoteIds ?? []);
 		const fragmentFootnoteIds = [];
 		let fragmentFootnoteHeight = 0;
@@ -231,14 +234,18 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 				rowFootnoteHeight += footnoteHeightById?.get(id) ?? 0;
 			}
 			const candidateFootnoteHeight = fragmentFootnoteHeight + rowFootnoteHeight;
-			const footnoteGrowth = projectedFootnoteReserveGrowth(state, candidateFootnoteHeight + (state.footnoteDemandHeight === 0 && candidateFootnoteHeight > 0 ? 12 : 0));
+			const separatorHeight = state.footnoteDemandHeight === 0 && candidateFootnoteHeight > 0 ? 12 : 0;
+			const footnoteGrowth = projectedFootnoteReserveGrowth(state, candidateFootnoteHeight + separatorHeight);
 			if (rowsHeight + rowHeight + normalHeaderOverhead + footnoteGrowth <= availableHeight) {
 				rowsHeight += rowHeight;
 				fragmentFootnoteHeight += rowFootnoteHeight;
 				fittingRows++;
 			} else if (fittingRows === 0) {
 				if (state.cursorY === state.topMargin && state.page.fragments.length === 0) {
-					rowsHeight += rowHeight;
+					const exactRowClip = block.rows[j]?.heightRule === "exact" && rowHeight + normalHeaderOverhead + footnoteGrowth > availableHeight;
+					const rowBand = exactRowClip ? Math.max(0, availableHeight - normalHeaderOverhead - footnoteGrowth) : rowHeight;
+					rowsHeight += rowBand;
+					if (exactRowClip) exactRowBottomClip = rowBand;
 					fragmentFootnoteHeight += rowFootnoteHeight;
 					fittingRows++;
 					break;
@@ -270,6 +277,7 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 			...!isFirstFragment ? { continuesFromPrev: true } : {},
 			...!isLastFragment ? { continuesOnNext: true } : {},
 			...repeatHeaderRowsForNormalFragment ? { headerRowCount } : {},
+			...exactRowBottomClip !== void 0 ? { bottomClip: exactRowBottomClip } : {},
 			...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
 		};
 		if (fragmentFootnoteHeight > 0) paginator.addFootnoteHeight(fragmentFootnoteHeight, fragmentFootnoteIds);

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

@@ -5,7 +5,7 @@ type RenderedRowBreakHint = {
   lineAdvance: number;
 };
 /** Precomputed break geometry for a table. */
-type TableRowBreakInfo = {
+export type TableRowBreakInfo = {
   /** Cumulative y of the top of each row; `rowTops[rows.length]` is the table height. */
   rowTops: number[];
   /**
@@ -25,16 +25,16 @@ type TableRowBreakInfo = {
  * 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;
+export 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;
+export declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure): TableRowBreakInfo;
 /** Leading empty-paragraph whitespace to consume when a row resumes after `offset`. */
-declare function getRowContinuationSkip(info: TableRowBreakInfo, rowIndex: number, offset: number): number;
+export declare function getRowContinuationSkip(info: TableRowBreakInfo, rowIndex: number, offset: number): number;
 /**
  * Given a row and how much of it has already been placed (`fromOffset`), return
  * how many more px can be placed ending on a whole line, without exceeding
  * `maxSlice`. Returns 0 when not even the first line fits.
  */
-declare function snapRowBreak(info: TableRowBreakInfo, rowIndex: number, fromOffset: number, maxSlice: number): number;
+export declare function snapRowBreak(info: TableRowBreakInfo, rowIndex: number, fromOffset: number, maxSlice: number): number;
 //#endregion
-export { TableRowBreakInfo, buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak, tableKeepNextOpeningHeight };
+export {};

package/dist/layout-engine/tableRowBreak.js

@@ -58,17 +58,22 @@ function cellBreakGeometry(cell, measure) {
 	const blockMeasures = measure.blocks;
 	const { top: padTop } = resolveTableCellPadding(cell);
 	const contentWidth = getTableCellContentWidth(cell, measure);
-	const floatingZones = buildTableCellFloatingZones(cell !== void 0 ? getTableCellFloatingImages(cell, measure, contentWidth) : [], contentWidth);
+	const floatingImages = cell !== void 0 ? getTableCellFloatingImages(cell, measure, contentWidth) : [];
+	const floatingZones = buildTableCellFloatingZones(floatingImages, contentWidth);
 	const flowState = createTableCellFlowState();
 	for (let i = 0; i < blockMeasures.length; i++) {
 		let blockMeasure = blockMeasures[i];
 		if (blockMeasure?.kind === "paragraph") {
 			const block = cellBlocks?.[i];
 			if (block?.kind !== "paragraph") continue;
-			if (floatingZones.length > 0) blockMeasure = measureParagraph(block, contentWidth, {
-				floatingZones,
-				paragraphYOffset: placeTableCellBlock({ ...flowState }, block, blockMeasure).contentTop
-			});
+			if (floatingZones.length > 0) {
+				const previewState = { ...flowState };
+				const preview = placeTableCellBlock(previewState, block, blockMeasure);
+				blockMeasure = measureParagraph(block, contentWidth, {
+					floatingZones,
+					paragraphYOffset: preview.contentTop
+				});
+			}
 			const placement = placeTableCellBlock(flowState, block, blockMeasure);
 			if (placement.leadingSpacing > 0 && isEmptyParagraph(block)) suppressibleLeadingRanges.push({
 				top: padTop + placement.top,

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

@@ -9,9 +9,9 @@ type VerticalRelativeTo = NonNullable<ImageRunPosition["vertical"]>["relativeTo"
  * over the OOXML `ST_RelFromV` set so a new relativeFrom value forces a decision
  * here instead of silently falling through. eigenpal #694.
  */
-declare function isPageFrameRelativeAnchor(relativeTo: VerticalRelativeTo): boolean;
+export declare function isPageFrameRelativeAnchor(relativeTo: VerticalRelativeTo): boolean;
 /** Page geometry needed to resolve a band box's vertical anchor. */
-type BandVerticalGeometry = {
+export type BandVerticalGeometry = {
   pageHeight: number;
   marginTop: number;
   marginBottom: number;
@@ -27,9 +27,9 @@ type BandVerticalGeometry = {
  * (0 = content top), so a page/margin-strip frame is converted by subtracting
  * the top margin. Ported from eigenpal #694.
  */
-declare function bandTopContentY(vertical: ImageRunPosition["vertical"], geometry: BandVerticalGeometry): number;
+export declare function bandTopContentY(vertical: ImageRunPosition["vertical"], geometry: BandVerticalGeometry): number;
 /** Page geometry needed to resolve a band box's horizontal anchor. */
-type BandHorizontalGeometry = {
+export type BandHorizontalGeometry = {
   pageWidth: number;
   marginLeft: number;
   marginRight: number;
@@ -46,6 +46,6 @@ type BandHorizontalGeometry = {
  * where the box paints, not the reserved vertical space. Ported from eigenpal
  * #694.
  */
-declare function bandFragmentX(horizontal: ImageRunPosition["horizontal"], geometry: BandHorizontalGeometry): number;
+export declare function bandFragmentX(horizontal: ImageRunPosition["horizontal"], geometry: BandHorizontalGeometry): number;
 //#endregion
-export { BandHorizontalGeometry, BandVerticalGeometry, bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor };
+export {};

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

@@ -1,6 +1,5 @@
 import { TextBoxBlock } from "./types.js";
 //#region src/layout-engine/textBoxGroup.d.ts
-declare const setTextBoxGroupId: (textBox: TextBoxBlock, groupId: string) => void;
-declare const getTextBoxGroupId: (textBox: TextBoxBlock) => string | undefined;
-//#endregion
-export { getTextBoxGroupId, setTextBoxGroupId };
+export declare const setTextBoxGroupId: (textBox: TextBoxBlock, groupId: string) => void;
+export declare const getTextBoxGroupId: (textBox: TextBoxBlock) => string | undefined;
+//#endregion

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

@@ -10,6 +10,6 @@ type LayoutTextBoxOptions = {
 /**
  * Layout a text box block onto pages.
  */
-declare function layoutTextBox(block: TextBoxBlock, measure: TextBoxMeasure, { paginator, sectionMarginTop, sectionPageHeight, sectionMarginBottom }: LayoutTextBoxOptions): void;
+export declare function layoutTextBox(block: TextBoxBlock, measure: TextBoxMeasure, { paginator, sectionMarginTop, sectionPageHeight, sectionMarginBottom }: LayoutTextBoxOptions): void;
 //#endregion
-export { layoutTextBox };
+export {};