@stll/folio-core 0.6.1 → 0.8.0

package/dist/layout-engine/index.js

@@ -1,11 +1,15 @@
 import { emuToPixels } from "../utils/units.js";
 import { measuredLineAdvance } from "./lineFlow.js";
-import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "./types.js";
+import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "./types.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "./paragraphSpacing.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
+import { continuesNumberedSequence } from "./paragraphSequence.js";
 import { createPaginator } from "./paginator.js";
 import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
+import { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
 import { buildTableRowBreakInfo, snapRowBreak } from "./tableRowBreak.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
+import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
 import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
 import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
 import { panic } from "better-result";
@@ -42,53 +46,55 @@ function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 		breakIndices
 	};
 }
-/**
-* Whether a paragraph block has no visible content (no runs, or a single
-* empty text run). Word collapses style-inherited spacing on empty
-* paragraphs (only direct `<w:pPr><w:spacing>` formatting survives) — see
-* eigenpal #402.
-*/
-function isEmptyParagraph(block) {
-	if (block.runs.length === 0) return true;
-	if (block.runs.length !== 1) return false;
-	const r = block.runs[0];
-	return r?.kind === "text" && r.text === "";
-}
-function isPaginationEmptyParagraph(block) {
-	return block.runs.every((run) => {
-		if (run.kind === "text") return run.text.trim().length === 0;
-		return run.kind === "tab" || run.kind === "lineBreak";
-	});
-}
-function pageHasVisibleBodyContent(page, blocksById) {
-	for (const fragment of page.fragments) {
-		if (fragment.kind !== "paragraph") return true;
-		const block = blocksById.get(String(fragment.blockId));
-		if (block?.kind !== "paragraph" || !isPaginationEmptyParagraph(block)) return true;
+function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }) {
+	if (columnCount <= 1 || startIndex >= endIndex || availableHeight <= 0) return;
+	const lineUnits = [];
+	let totalHeight = 0;
+	let tallestUnit = 0;
+	let trailingSpacing = incomingSpacing;
+	for (let index = startIndex; index < endIndex; index++) {
+		const block = blocks[index];
+		const measure = measures[index];
+		if (block?.kind !== "paragraph" || measure?.kind !== "paragraph") return;
+		if (block.attrs?.keepNext === true || block.attrs?.keepLines === true || block.runs.some((run) => run.kind === "text" && run.footnoteRefId !== void 0)) return;
+		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		if (measure.lines.length === 0) {
+			if (leadingSpacing > 0) {
+				lineUnits.push(leadingSpacing);
+				totalHeight += leadingSpacing;
+				tallestUnit = Math.max(tallestUnit, leadingSpacing);
+			}
+		}
+		for (let lineIndex = 0; lineIndex < measure.lines.length; lineIndex++) {
+			const line = measure.lines[lineIndex];
+			if (!line) continue;
+			const unitHeight = measuredLineAdvance(line) + (lineIndex === 0 ? leadingSpacing : 0);
+			lineUnits.push(unitHeight);
+			totalHeight += unitHeight;
+			tallestUnit = Math.max(tallestUnit, unitHeight);
+		}
+		if (tallestUnit > availableHeight || totalHeight > availableHeight * columnCount) return;
+		trailingSpacing = getParagraphSpacingAfter(block);
 	}
-	return false;
-}
-/**
-* Get spacing before a paragraph block. Empty paragraphs whose
-* `before` came only from the implicit default paragraph style collapse to
-* zero. An explicit `w:pStyle` selection is authored paragraph formatting,
-* so Word keeps the selected style's spacing even when the paragraph is empty.
-*/
-function getSpacingBefore(block) {
-	const value = block.attrs?.spacing?.before ?? 0;
-	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.before) return 0;
-	return value;
-}
-/**
-* Get spacing after a paragraph block. Same implicit-default-style collapse
-* rule as `getSpacingBefore`.
-*/
-function getSpacingAfter(block) {
-	const value = block.attrs?.spacing?.after ?? 0;
-	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.after) return 0;
-	return value;
+	if (totalHeight <= 0) return;
+	const columnsNeeded = (targetHeight) => {
+		let usedHeight = 0;
+		let usedColumns = 1;
+		for (const unitHeight of lineUnits) if (usedHeight > 0 && usedHeight + unitHeight > targetHeight) {
+			usedColumns += 1;
+			usedHeight = unitHeight;
+		} else usedHeight += unitHeight;
+		return usedColumns;
+	};
+	let lower = Math.max(tallestUnit, totalHeight / columnCount);
+	let upper = Math.min(totalHeight, availableHeight);
+	if (columnsNeeded(upper) > columnCount) return;
+	for (let iteration = 0; iteration < 32; iteration++) {
+		const middle = (lower + upper) / 2;
+		if (columnsNeeded(middle) <= columnCount) upper = middle;
+		else lower = middle;
+	}
+	return Math.ceil(upper * 1e3) / 1e3;
 }
 function hasWidowControl(block) {
 	return block.attrs?.widowControl !== false;
@@ -123,6 +129,24 @@ function applyContextualSpacing(blocks) {
 	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyContextualSpacing(cell.blocks);
 	else if (block.kind === "textBox") applyContextualSpacing(block.content);
 }
+/** Suppress automatic inter-item spacing within one numbered sequence. */
+const applyAutomaticListSpacing = (blocks) => {
+	for (let index = 1; index < blocks.length; index++) {
+		const previous = blocks[index - 1];
+		const current = blocks[index];
+		if (previous?.kind !== "paragraph" || current?.kind !== "paragraph" || !continuesNumberedSequence(previous, current)) continue;
+		if (previous.attrs?.automaticSpacing?.after && previous.attrs.spacing) previous.attrs.spacing = {
+			...previous.attrs.spacing,
+			after: 0
+		};
+		if (current.attrs?.automaticSpacing?.before && current.attrs.spacing) current.attrs.spacing = {
+			...current.attrs.spacing,
+			before: 0
+		};
+	}
+	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyAutomaticListSpacing(cell.blocks);
+	else if (block.kind === "textBox") applyAutomaticListSpacing(block.content);
+};
 /**
 * Layout a document: convert blocks + measures into pages with positioned fragments.
 *
@@ -166,11 +190,13 @@ function layoutDocument(blocks, measures, options) {
 		margins: initialConfig.margins,
 		...options.mirrorMargins === true ? { mirrorMargins: true } : {},
 		...options.firstPageMargins !== void 0 ? { firstPageMargins: options.firstPageMargins } : {},
+		...options.sectionEvenPageMargins !== void 0 ? { sectionEvenPageMargins: options.sectionEvenPageMargins } : {},
 		columns: initialConfig.columns ?? DEFAULT_COLUMNS,
 		...options.footnoteReservedHeights !== void 0 ? { footnoteReservedHeights: options.footnoteReservedHeights } : {},
 		...options.sectionHeaderFooterRefs !== void 0 ? { sectionHeaderFooterRefs: options.sectionHeaderFooterRefs } : {}
 	});
 	applyContextualSpacing(blocks);
+	applyAutomaticListSpacing(blocks);
 	const keepNextChains = computeKeepNextChains(blocks);
 	const midChainIndices = getMidChainIndices(keepNextChains);
 	const blocksById = /* @__PURE__ */ new Map();
@@ -179,21 +205,28 @@ function layoutDocument(blocks, measures, options) {
 	let activeSectionMarginTop = initialConfig.margins.top;
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
-	let naturalPageAdvanceSinceRenderedBreak = false;
+	let renderedBreakState = INITIAL_RENDERED_BREAK_STATE;
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
-		const hasRenderedPageBreak = block.kind === "paragraph" && block.attrs?.renderedPageBreakBefore === true;
-		if (hasPageBreakBefore(block)) paginator.forcePageBreak();
-		else if (hasRenderedPageBreak) {
-			const state = paginator.getCurrentState();
-			if (!(block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
-		}
-		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = false;
+		const renderedBreakNeedsSnap = measure.kind === "paragraph" && !paginator.fits(measure.totalHeight);
+		const breakDecision = reconcileBreakBeforeBlock({
+			state: renderedBreakState,
+			block,
+			previousBlock: blocks[i - 1],
+			page: paginator.getCurrentState().page,
+			blocksById,
+			hasExplicitPageBreak: hasPageBreakBefore(block),
+			renderedBreakNeedsSnap
+		});
+		if (breakDecision.forcePageBreak) paginator.forcePageBreak();
+		renderedBreakState = breakDecision.state;
 		const chain = keepNextChains.get(i);
 		if (chain && !midChainIndices.has(i)) {
 			const chainHeight = calculateChainHeight(chain, blocks, measures);
+			const pageBeforeChainLayout = paginator.getCurrentState().page.number;
 			paginator.ensureFits(chainHeight);
+			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) renderedBreakState = recordReflowBoundary(renderedBreakState, true);
 		}
 		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
@@ -224,6 +257,23 @@ function layoutDocument(blocks, measures, options) {
 			case "sectionBreak": {
 				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
 				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx], sectionIdx + 1);
+				const nextColumns = nextSectionConfig.columns;
+				const nextBreakIndex = breakIndices[sectionIdx + 1] ?? blocks.length;
+				const nextBreak = blocks[nextBreakIndex];
+				const sectionEndsContinuously = nextBreakIndex === blocks.length || nextBreak?.kind === "sectionBreak" && nextBreak.type === "continuous";
+				if (nextColumns && sectionEndsContinuously) {
+					const state = paginator.getCurrentState();
+					const balancedHeight = balancedParagraphSectionHeight({
+						blocks,
+						measures,
+						startIndex: i + 1,
+						endIndex: nextBreakIndex,
+						incomingSpacing: state.trailingSpacing,
+						columnCount: nextColumns.count,
+						availableHeight: paginator.getAvailableHeight()
+					});
+					if (balancedHeight !== void 0) state.contentBottom = Math.min(state.contentBottom, state.cursorY + balancedHeight);
+				}
 				activeSectionMarginTop = nextSectionConfig.margins.top;
 				activeSectionPageHeight = nextSectionConfig.pageSize.h;
 				activeSectionMarginBottom = nextSectionConfig.margins.bottom;
@@ -232,9 +282,13 @@ function layoutDocument(blocks, measures, options) {
 			}
 			default: break;
 		}
-		const isVisibleBodyBlock = block.kind === "paragraph" ? !isEmptyParagraph(block) : block.kind !== "pageBreak" && block.kind !== "columnBreak" && block.kind !== "sectionBreak";
-		if (block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak") naturalPageAdvanceSinceRenderedBreak = false;
-		else if (isVisibleBodyBlock && paginator.getCurrentState().page.number > pageBeforeBlockLayout) naturalPageAdvanceSinceRenderedBreak = true;
+		renderedBreakState = reconcileAfterBlock({
+			state: renderedBreakState,
+			block,
+			pageNumberBefore: pageBeforeBlockLayout,
+			pageNumberAfter: paginator.getCurrentState().page.number,
+			previousPage: paginator.pages[pageBeforeBlockLayout - 1]
+		});
 	}
 	if (paginator.pages.length === 0) paginator.getCurrentState();
 	return {
@@ -290,8 +344,8 @@ function getLineFootnoteRefs(block, fromRun, toRun, fnHeights) {
 function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeightById) {
 	const lines = measure.lines;
 	if (lines.length === 0) {
-		const spaceBefore = getSpacingBefore(block);
-		const spaceAfter = getSpacingAfter(block);
+		const spaceBefore = getParagraphSpacingBefore(block);
+		const spaceAfter = getParagraphSpacingAfter(block);
 		const state = paginator.getCurrentState();
 		const fragment = {
 			kind: "paragraph",
@@ -309,8 +363,8 @@ function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeight
 		paginator.addFragment(fragment, 0, spaceBefore, spaceAfter);
 		return;
 	}
-	const spaceBefore = getSpacingBefore(block);
-	const spaceAfter = getSpacingAfter(block);
+	const spaceBefore = getParagraphSpacingBefore(block);
+	const spaceAfter = getParagraphSpacingAfter(block);
 	let currentLineIndex = 0;
 	while (currentLineIndex < lines.length) {
 		const state = paginator.getCurrentState();
@@ -429,14 +483,14 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		let x = paginator.getColumnX(columnIndex);
 		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
 		else if (block.justification === "right") x = x + paginator.columnWidth - measure.totalWidth;
+		else if (block.indent !== void 0) x += block.indent;
 		else {
 			const leadingCellMargin = block.rows.at(0)?.cells.at(0)?.padding?.left ?? 0;
-			x += (block.indent ?? 0) - leadingCellMargin;
+			x -= leadingCellMargin;
 		}
 		return x;
 	};
 	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
-	const getCurrentAvailableHeight = (state = paginator.getCurrentState()) => state.contentBottom - state.cursorY;
 	const hasAdjacentPriorTableRows = (rowIndex, state = paginator.getCurrentState()) => {
 		const previous = state.page.fragments.at(-1);
 		return previous?.kind === "table" && previous.blockId === block.id && previous.toRow === rowIndex && previous.y + previous.height === state.cursorY && previous.x === computeTableX(state.columnIndex);
@@ -445,11 +499,9 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
 		const row = rows[rowIndex];
 		if (!row) return false;
-		const repeatedHeaderOverhead = shouldRepeatHeaderRows(rowIndex, 0, state) ? headerRowsHeight : 0;
 		if ((breakInfo.breakOffsets[rowIndex]?.length ?? 0) <= 1) return false;
-		const requiredHeight = row.height + repeatedHeaderOverhead;
-		if (requiredHeight > getCurrentRowCapacity(state)) return true;
-		return hasAdjacentPriorTableRows(rowIndex, state) && requiredHeight > getCurrentAvailableHeight(state) - state.trailingSpacing;
+		const freshHeaderOverhead = headerRowCount > 0 && rowIndex >= headerRowCount ? headerRowsHeight : 0;
+		return row.height + freshHeaderOverhead > getCurrentRowCapacity(state);
 	};
 	while (currentRowIndex < rows.length) {
 		const oversizedRow = rows[currentRowIndex];
@@ -638,9 +690,10 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 		else if (spec === "center") y = baseY + (contentHeight - tableHeight) / 2;
 	}
 	if (!usedExplicitY) y = paginator.ensureFits(tableHeight).cursorY;
-	const pageAnchored = floating?.horzAnchor === "page";
-	const minX = pageAnchored ? 0 : margins.left;
-	const maxX = pageAnchored ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
+	const usesNumericOffset = floating?.tblpX !== void 0;
+	const clampToPage = floating?.horzAnchor === "page" || usesNumericOffset;
+	const minX = clampToPage ? 0 : margins.left;
+	const maxX = clampToPage ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
 	if (Number.isFinite(maxX)) x = Math.max(minX, Math.min(x, maxX));
 	const fragment = {
 		kind: "table",
@@ -830,4 +883,4 @@ function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionTyp
 	paginator.updateColumns(nextSectionConfig.columns ?? DEFAULT_COLUMNS);
 }
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak, tableColumnsArePinned };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, getTableRowLeadingWidth, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, resolveSectionHeaderFooterRefs, scheduleSectionBreak, tableColumnsArePinned };

package/dist/layout-engine/keep-together.d.ts

@@ -2,8 +2,9 @@ import { FlowBlock, Measure } from "./types.js";
 
 //#region src/layout-engine/keep-together.d.ts
 /**
- * A chain of keepNext-linked paragraphs, including empty separators Word
- * carries through to the next paragraph with visible content.
+ * A chain of paragraphs that Word keeps with following content. This includes
+ * explicit keepNext links and a trailing table separator that would otherwise
+ * be stranded at the bottom of a page.
  */
 type KeepNextChain = {
   /** Index of the first paragraph in the chain. */startIndex: number; /** Index of the last keepNext or pass-through empty member. */
@@ -14,9 +15,10 @@ type KeepNextChain = {
 /**
  * Pre-scan blocks to find all keepNext chains.
  *
- * A keepNext chain starts with a paragraph whose keepNext=true and continues
- * through further keepNext paragraphs and structural empty separators. The
- * first visible non-keepNext paragraph is its anchor.
+ * A chain starts with a paragraph whose keepNext=true or with an empty
+ * separator immediately following a table. It continues through further
+ * keepNext paragraphs and structural empty separators. The first visible
+ * non-keepNext paragraph is its anchor.
  *
  * Returns a map from chain start index to chain info.
  */

package/dist/layout-engine/keep-together.js

@@ -5,12 +5,23 @@ function isVisuallyEmptyParagraph(block) {
 	const run = block.runs.at(0);
 	return run?.kind === "text" && run.text === "";
 }
+function startsTrailingTableSeparatorChain(blocks, index) {
+	const block = blocks[index];
+	if (block?.kind !== "paragraph" || !isVisuallyEmptyParagraph(block) || blocks[index - 1]?.kind !== "table") return false;
+	for (let nextIndex = index + 1; nextIndex < blocks.length; nextIndex++) {
+		const nextBlock = blocks[nextIndex];
+		if (nextBlock?.kind !== "paragraph") return false;
+		if (!isVisuallyEmptyParagraph(nextBlock)) return true;
+	}
+	return false;
+}
 /**
 * Pre-scan blocks to find all keepNext chains.
 *
-* A keepNext chain starts with a paragraph whose keepNext=true and continues
-* through further keepNext paragraphs and structural empty separators. The
-* first visible non-keepNext paragraph is its anchor.
+* A chain starts with a paragraph whose keepNext=true or with an empty
+* separator immediately following a table. It continues through further
+* keepNext paragraphs and structural empty separators. The first visible
+* non-keepNext paragraph is its anchor.
 *
 * Returns a map from chain start index to chain info.
 */
@@ -21,7 +32,7 @@ function computeKeepNextChains(blocks) {
 		if (processed.has(i)) continue;
 		const block = blocks[i];
 		if (block.kind !== "paragraph") continue;
-		if (!block.attrs?.keepNext) continue;
+		if (!block.attrs?.keepNext && !startsTrailingTableSeparatorChain(blocks, i)) continue;
 		const memberIndices = [i];
 		let endIndex = i;
 		for (let j = i + 1; j < blocks.length; j++) {
@@ -67,6 +78,7 @@ function calculateChainHeight(chain, blocks, measures) {
 	if (firstBlock?.kind !== "paragraph" || firstMeasure?.kind !== "paragraph") return 0;
 	let totalHeight = (firstBlock.attrs?.spacing?.before ?? 0) + firstMeasure.totalHeight;
 	let trailingSpacing = firstBlock.attrs?.spacing?.after ?? 0;
+	const startsWithTrailingTableSeparator = blocks[firstMemberIndex - 1]?.kind === "table" && isVisuallyEmptyParagraph(firstBlock) && !firstBlock.attrs?.keepNext;
 	const successorIndices = [...chain.memberIndices.slice(1)];
 	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
 	for (let index = 0; index < successorIndices.length; index++) {
@@ -80,6 +92,10 @@ function calculateChainHeight(chain, blocks, measures) {
 		if (!firstLine) return totalHeight;
 		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;
 		const isSplittable = successorMeasure.lines.length > 1 && !successorBlock.attrs?.keepLines;
+		if (isAnchor && startsWithTrailingTableSeparator && successorBlock.attrs?.widowControl !== false && successorMeasure.lines.length > 1) {
+			const secondLine = successorMeasure.lines.at(1);
+			return totalHeight + firstLine.lineHeight + (secondLine?.lineHeight ?? 0);
+		}
 		if (isAnchor || isSplittable) return totalHeight + firstLine.lineHeight;
 		totalHeight += successorMeasure.totalHeight;
 		trailingSpacing = successorBlock.attrs?.spacing?.after ?? 0;

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

@@ -160,11 +160,13 @@ function hashParagraphBlock(block) {
 	const attrs = block.attrs;
 	if (attrs) {
 		if (attrs.alignment) parts.push(`align:${attrs.alignment}`);
+		if (attrs.outlineLevel !== void 0) parts.push(`outline:${attrs.outlineLevel}`);
 		if (attrs.indent) parts.push(`indent:${attrs.indent.left}|${attrs.indent.right}|${attrs.indent.firstLine}|${attrs.indent.hanging}`);
 		if (attrs.spacing) parts.push(`spacing:${attrs.spacing.before}|${attrs.spacing.after}|${attrs.spacing.line}|${attrs.spacing.lineRule}`);
 		if (attrs.defaultFontSize != null) parts.push(`dfs:${attrs.defaultFontSize}`);
 		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
 		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
+		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
 		const borders = attrs.borders;
 		if (borders) {
 			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";

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

@@ -36,5 +36,7 @@ declare function resolveListMarkerFont(block: ParagraphBlock): {
  * grid is not erased by custom tabs, just augmented).
  */
 declare function getListMarkerInlineWidth(block: ParagraphBlock): number;
+/** Paint-only offset that places the marker around its authored list anchor. */
+declare function getListMarkerVisualOffset(block: ParagraphBlock): number;
 //#endregion
-export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont };

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

@@ -51,15 +51,16 @@ function getListMarkerInlineWidth(block) {
 		fontSize
 	};
 	const naturalWidth = measureTextWidth(attrs.listMarker, style);
+	const markerEndOffset = getMarkerEndOffset(naturalWidth, attrs.listMarkerAlignment);
 	const suffix = attrs.listMarkerSuffix ?? "tab";
-	if (suffix === "nothing") return naturalWidth;
-	if (suffix === "space") return naturalWidth + measureTextWidth(" ", style);
+	if (suffix === "nothing") return markerEndOffset;
+	if (suffix === "space") return markerEndOffset + measureTextWidth(" ", style);
 	const indent = attrs.indent;
 	const indentLeft = indent?.left ?? 0;
 	const firstLine = indent?.firstLine ?? 0;
 	const hanging = indent?.hanging ?? 0;
 	const markerStartPx = hanging > 0 ? indentLeft - hanging : indentLeft + firstLine;
-	const minBodyStart = markerStartPx + naturalWidth;
+	const minBodyStart = markerStartPx + markerEndOffset;
 	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX);
 	if (hanging > 0) customTabs.push(indentLeft);
 	const searchStart = hanging > 0 ? Math.max(minBodyStart, indentLeft) : minBodyStart;
@@ -72,5 +73,23 @@ function getListMarkerInlineWidth(block) {
 	if (bodyStart === void 0) return naturalWidth + ptToPx(fontSize) * .5;
 	return bodyStart - markerStartPx;
 }
+/** Paint-only offset that places the marker around its authored list anchor. */
+function getListMarkerVisualOffset(block) {
+	const attrs = block.attrs;
+	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
+	const { fontFamily, fontSize } = resolveListMarkerFont(block);
+	const naturalWidth = measureTextWidth(attrs.listMarker, {
+		fontFamily,
+		fontSize
+	});
+	if (attrs.listMarkerAlignment === "right") return -naturalWidth;
+	if (attrs.listMarkerAlignment === "center") return -naturalWidth / 2;
+	return 0;
+}
+const getMarkerEndOffset = (naturalWidth, alignment) => {
+	if (alignment === "right") return 0;
+	if (alignment === "center") return naturalWidth / 2;
+	return naturalWidth;
+};
 //#endregion
-export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont };

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

@@ -4,7 +4,10 @@ import { FloatingImageZone } from "./floatingZones.js";
 declare function measureTableCellBlockVisualHeight(block: FlowBlock, blockMeasure: Measure): number;
 declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
 type BandPageGeometry = {
+  pageWidth?: number | number[];
   pageHeight: number | number[];
+  marginLeft?: number | number[];
+  marginRight?: number | number[];
   marginBottom: number | number[];
 };
 /**