@stll/folio-core 0.7.0 → 0.9.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 { buildTableRowBreakInfo, snapRowBreak } from "./tableRowBreak.js";
+import { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
+import { buildTableRowBreakInfo, getRowContinuationSkip, 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";
@@ -19,6 +23,7 @@ const DEFAULT_COLUMNS = {
 	count: 1,
 	gap: 0
 };
+const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
 function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 	const configs = [];
 	const breakIndices = [];
@@ -42,63 +47,6 @@ function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 		breakIndices
 	};
 }
-/**
-* Whether a paragraph block has no visible content (no runs, or a single
-* empty text run).
-*/
-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;
-	}
-	return false;
-}
-function continuesNumberedSequence(previous, current) {
-	if (previous?.kind !== "paragraph" || current.kind !== "paragraph") return false;
-	const previousNumPr = previous.attrs?.numPr;
-	const currentNumPr = current.attrs?.numPr;
-	if (previousNumPr?.numId === void 0 || currentNumPr?.numId === void 0) return false;
-	return previousNumPr.numId === currentNumPr.numId && previousNumPr.ilvl === currentNumPr.ilvl;
-}
-function pageStartsWithPreviousParagraphContinuation(page, previousBlock) {
-	if (previousBlock?.kind !== "paragraph") return false;
-	return page.fragments.some((fragment) => fragment.kind === "paragraph" && String(fragment.blockId) === String(previousBlock.id) && fragment.continuesFromPrev === true);
-}
-/**
-* Get spacing before a paragraph block. Empty paragraphs whose
-* `before` came only from the implicit default paragraph style collapse to
-* zero. Reference layout keeps inherited spacing when the empty paragraph itself is
-* authored through direct `w:pPr` formatting or an explicit `w:pStyle`.
-*/
-function getSpacingBefore(block) {
-	const value = block.attrs?.spacing?.before ?? 0;
-	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !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?.hasDirectParagraphFormatting && !block.attrs?.spacingExplicit?.after) return 0;
-	return value;
-}
 function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }) {
 	if (columnCount <= 1 || startIndex >= endIndex || availableHeight <= 0) return;
 	const lineUnits = [];
@@ -110,7 +58,7 @@ function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex
 		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(getSpacingBefore(block), trailingSpacing);
+		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
 		if (measure.lines.length === 0) {
 			if (leadingSpacing > 0) {
 				lineUnits.push(leadingSpacing);
@@ -127,7 +75,7 @@ function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex
 			tallestUnit = Math.max(tallestUnit, unitHeight);
 		}
 		if (tallestUnit > availableHeight || totalHeight > availableHeight * columnCount) return;
-		trailingSpacing = getSpacingAfter(block);
+		trailingSpacing = getParagraphSpacingAfter(block);
 	}
 	if (totalHeight <= 0) return;
 	const columnsNeeded = (targetHeight) => {
@@ -236,13 +184,14 @@ function layoutDocument(blocks, measures, options) {
 	const finalColumns = options.finalColumns ?? options.columns;
 	if (finalColumns !== void 0) finalConfig.columns = finalColumns;
 	const { configs: sectionConfigs, breakIndices } = collectSectionConfigs(blocks, bodyConfig, finalConfig);
-	const sectionBreakTypes = [...breakIndices.map((index) => blocks[index].type), options.bodyBreakType];
+	const sectionBreakTypes = breakIndices.map((index) => blocks[index].type);
 	const initialConfig = sectionConfigs.at(0) ?? bodyConfig;
 	const paginator = createPaginator({
 		pageSize: initialConfig.pageSize,
 		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 } : {}
@@ -257,28 +206,41 @@ function layoutDocument(blocks, measures, options) {
 	let activeSectionMarginTop = initialConfig.margins.top;
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
-	let naturalPageAdvanceSinceRenderedBreak = "none";
+	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 (!(pageStartsWithPreviousParagraphContinuation(state.page, blocks[i - 1]) || naturalPageAdvanceSinceRenderedBreak === "reflowBoundary" || block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak !== "none" || naturalPageAdvanceSinceRenderedBreak !== "none" && continuesNumberedSequence(blocks[i - 1], block)) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
-		}
-		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = "none";
+		const renderedBreakNeedsSnap = measure.kind === "paragraph" && !paginator.fits(measure.totalHeight);
+		const hasExplicitPageBreak = hasPageBreakBefore(block);
+		const breakDecision = reconcileBreakBeforeBlock({
+			state: renderedBreakState,
+			block,
+			previousBlock: blocks[i - 1],
+			page: paginator.getCurrentState().page,
+			blocksById,
+			hasExplicitPageBreak,
+			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) naturalPageAdvanceSinceRenderedBreak = "reflowBoundary";
+			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) renderedBreakState = recordReflowBoundary(renderedBreakState, true);
 		}
 		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
 			case "paragraph":
-				layoutParagraph(block, measure, paginator, paginator.columnWidth, options.footnoteHeightById);
+				layoutParagraph({
+					block,
+					measure,
+					paginator,
+					contentWidth: paginator.columnWidth,
+					footnoteHeightById: options.footnoteHeightById,
+					suppressSpaceBefore: breakDecision.suppressSpaceBefore
+				});
 				break;
 			case "table":
 				if (block.floating) layoutFloatingTable(block, measure, paginator, paginator.getContentWidth());
@@ -303,7 +265,9 @@ function layoutDocument(blocks, measures, options) {
 				break;
 			case "sectionBreak": {
 				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
-				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx], sectionIdx + 1);
+				let nextType = options.bodyBreakType ?? sectionBreakTypes[sectionIdx] ?? DEFAULT_SECTION_BREAK_TYPE;
+				if (sectionIdx + 1 < sectionBreakTypes.length) nextType = sectionBreakTypes[sectionIdx + 1] ?? DEFAULT_SECTION_BREAK_TYPE;
+				handleSectionBreak(block, paginator, nextSectionConfig, nextType, sectionIdx + 1);
 				const nextColumns = nextSectionConfig.columns;
 				const nextBreakIndex = breakIndices[sectionIdx + 1] ?? blocks.length;
 				const nextBreak = blocks[nextBreakIndex];
@@ -329,9 +293,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 = "none";
-		else if (isVisibleBodyBlock && paginator.getCurrentState().page.number > pageBeforeBlockLayout) naturalPageAdvanceSinceRenderedBreak = paginator.pages[pageBeforeBlockLayout - 1]?.fragments.some(({ blockId }) => blockId === block.id) ? "reflowBoundary" : "ordinary";
+		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 {
@@ -374,21 +342,11 @@ function getLineFootnoteRefs(block, fromRun, toRun, fnHeights) {
 		height
 	};
 }
-/**
-* Layout a paragraph block onto pages.
-*
-* When `footnoteHeightById` is provided, each line carrying a footnote
-* ref additionally reserves space on its host page for the fn's
-* content. Pagination decisions look at the line's effective height
-* (`lineHeight + lineFnHeight`) so a line cannot land on a page that
-* lacks room for both — preventing footnote overflow without the
-* static-reservation iteration loop.
-*/
-function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeightById) {
+function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeightById, suppressSpaceBefore }) {
 	const lines = measure.lines;
 	if (lines.length === 0) {
-		const spaceBefore = getSpacingBefore(block);
-		const spaceAfter = getSpacingAfter(block);
+		const spaceBefore = suppressSpaceBefore ? 0 : getParagraphSpacingBefore(block);
+		const spaceAfter = getParagraphSpacingAfter(block);
 		const state = paginator.getCurrentState();
 		const fragment = {
 			kind: "paragraph",
@@ -406,8 +364,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 = suppressSpaceBefore ? 0 : getParagraphSpacingBefore(block);
+	const spaceAfter = getParagraphSpacingAfter(block);
 	let currentLineIndex = 0;
 	while (currentLineIndex < lines.length) {
 		const state = paginator.getCurrentState();
@@ -522,6 +480,7 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	const headerRowsHeight = getHeaderRowsHeight(measure, headerRowCount);
 	let currentRowIndex = 0;
 	const breakInfo = buildTableRowBreakInfo(block, measure);
+	const hasVerticalMerges = block.rows.some((row) => row.cells.some((cell) => (cell.rowSpan ?? 1) > 1));
 	const computeTableX = (columnIndex) => {
 		let x = paginator.getColumnX(columnIndex);
 		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
@@ -534,7 +493,6 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		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);
@@ -542,18 +500,21 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 	const shouldRepeatHeaderRows = (rowIndex, consumed, state = paginator.getCurrentState()) => headerRowCount > 0 && rowIndex >= headerRowCount && !(consumed === 0 && hasAdjacentPriorTableRows(rowIndex, state));
 	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
 		const row = rows[rowIndex];
-		if (!row) return false;
-		const repeatedHeaderOverhead = shouldRepeatHeaderRows(rowIndex, 0, state) ? headerRowsHeight : 0;
+		const sourceRow = block.rows[rowIndex];
+		if (!row || !sourceRow || sourceRow.cantSplit || sourceRow.isHeader || hasVerticalMerges) return false;
 		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;
+		const oversized = row.height + freshHeaderOverhead > getCurrentRowCapacity(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;
+		return oversized || row.height > currentAvailableHeight;
 	};
 	while (currentRowIndex < rows.length) {
-		const oversizedRow = rows[currentRowIndex];
+		const splittableRow = rows[currentRowIndex];
 		if (canSplitRow(currentRowIndex)) {
 			let consumed = 0;
-			while (consumed < oversizedRow.height) {
+			while (consumed < splittableRow.height) {
 				const sliceState = paginator.getCurrentState();
 				const repeatHeaderRows = shouldRepeatHeaderRows(currentRowIndex, consumed, sliceState);
 				const headerOverhead = repeatHeaderRows ? headerRowsHeight : 0;
@@ -565,11 +526,12 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 						continue;
 					}
 					const from = consumed;
-					slice = (breakInfo.breakOffsets[currentRowIndex]?.find((o) => o > from) ?? oversizedRow.height) - consumed;
+					slice = (breakInfo.breakOffsets[currentRowIndex]?.find((o) => o > from) ?? splittableRow.height) - consumed;
 				}
 				const sliceBottom = consumed + slice;
-				const reachesRowEnd = sliceBottom >= oversizedRow.height;
-				const moreAfter = !reachesRowEnd || currentRowIndex + 1 < rows.length;
+				const continuationSkip = sliceBottom < splittableRow.height ? getRowContinuationSkip(breakInfo, currentRowIndex, sliceBottom) : 0;
+				const nextConsumed = Math.min(splittableRow.height, sliceBottom + continuationSkip);
+				const moreAfter = !(nextConsumed >= splittableRow.height) || currentRowIndex + 1 < rows.length;
 				const fragmentHeight = headerOverhead + slice;
 				const sliceFragment = {
 					kind: "table",
@@ -586,14 +548,14 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 					...moreAfter ? { continuesOnNext: true } : {},
 					...repeatHeaderRows ? { headerRowCount } : {},
 					...consumed > 0 ? { topClip: consumed } : {},
-					...reachesRowEnd ? {} : { bottomClip: sliceBottom },
+					...sliceBottom >= splittableRow.height ? {} : { bottomClip: sliceBottom },
 					...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
 				};
 				const sliceResult = paginator.addFragment(sliceFragment, fragmentHeight, 0, 0);
 				sliceFragment.y = sliceResult.y;
 				sliceFragment.x = computeTableX(sliceResult.state.columnIndex);
-				consumed = sliceBottom;
-				if (consumed < oversizedRow.height) paginator.forceColumnBreak();
+				consumed = nextConsumed;
+				if (consumed < splittableRow.height) paginator.forceColumnBreak();
 			}
 			currentRowIndex += 1;
 			continue;
@@ -929,4 +891,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/measure/cache.js

@@ -1,3 +1,4 @@
+import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
 //#region src/layout-engine/measure/cache.ts
 /**
 * Current max size for text width cache
@@ -152,10 +153,10 @@ const paragraphMeasureCache = /* @__PURE__ */ new Map();
 * Used as cache key to identify identical content
 */
 function hashParagraphBlock(block) {
-	const parts = [];
-	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.fontSize}|${run.bold}|${run.italic}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}`);
+	const parts = [`lbp:${getLineBreakProviderGeneration()}`];
+	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.fontSize}|${run.bold}|${run.italic}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}|${run.language?.val}|${run.language?.eastAsia}|${run.language?.bidi}`);
 	else if (run.kind === "tab") parts.push(`tab:${run.width}`);
-	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}`);
+	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}:${run.exactLineHeight === true ? "exact" : "text"}`);
 	else if (run.kind === "lineBreak") parts.push("br");
 	const attrs = block.attrs;
 	if (attrs) {
@@ -167,6 +168,13 @@ function hashParagraphBlock(block) {
 		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
 		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
 		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
+		if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
+		if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
+		if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);
+		const automaticHyphenation = attrs.automaticHyphenation;
+		if (automaticHyphenation) parts.push(`auto-hyphens:${automaticHyphenation.doNotHyphenateCaps}|${automaticHyphenation.consecutiveLineLimit}`);
+		const lineBreakRules = attrs.lineBreakRules;
+		if (lineBreakRules) parts.push(`line-break-rules:${lineBreakRules.noLineBreaksBefore?.language}|${lineBreakRules.noLineBreaksBefore?.characters}|${lineBreakRules.noLineBreaksAfter?.language}|${lineBreakRules.noLineBreaksAfter?.characters}|${lineBreakRules.useLegacyEthiopicAmharicRules}`);
 		const borders = attrs.borders;
 		if (borders) {
 			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";

package/dist/layout-engine/measure/font-metrics.worker.js

@@ -44,6 +44,7 @@ function isFontFingerprintMatch(context, expectedWidth) {
 function measureEntry(entry) {
 	const context = getCtx();
 	context.font = entry.font;
+	context.fontKerning = entry.fontKerning;
 	if (!isFontFingerprintMatch(context, entry.fontFingerprintWidth)) return null;
 	let width = context.measureText(entry.text).width;
 	const codePoints = countCodePoints(entry.text);

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

@@ -1,9 +1,10 @@
 import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "./measureTypes.js";
 import { MeasureProvider, getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { LineBreakPolicy, LineBreakProvider, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider } from "./lineBreakProvider.js";
 import { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { MeasureParagraphOptions, getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
 import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
 import { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
-export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, type MeasureParagraphOptions, type MeasureProvider, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };
+export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, type LineBreakPolicy, type LineBreakProvider, type MeasureParagraphOptions, type MeasureProvider, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, defaultLineBreakProvider, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getLineBreakProvider, getLineBreakProviderGeneration, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetLineBreakProvider, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setLineBreakProvider, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -1,8 +1,9 @@
 import { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider } from "./lineBreakProvider.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
 import { getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
 import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
 import { isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
-export { buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };
+export { buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, defaultLineBreakProvider, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getLineBreakProvider, getLineBreakProviderGeneration, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetLineBreakProvider, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setLineBreakProvider, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -0,0 +1,33 @@
+//#region src/layout-engine/measure/lineBreakProvider.d.ts
+/**
+ * Replaceable line-break policy for the layout engine.
+ *
+ * Providers return UTF-16 offsets so their output composes directly with the
+ * run and ProseMirror positions used by the rest of the layout pipeline. The
+ * default provider uses the platform's Unicode segmenter, then applies the
+ * OOXML line-edge restrictions that are available in the flow model.
+ */
+type LineBreakPolicy = {
+  /** BCP-47 language tag resolved from `w:lang` for this run. */locale?: string; /** Apply East Asian first/last-character restrictions (`w:kinsoku`). */
+  kinsoku?: boolean; /** Document replacement list: characters that may not begin a line. */
+  noLineBreaksBefore?: string; /** Document replacement list: characters that may not end a line. */
+  noLineBreaksAfter?: string; /** Use the legacy Ethiopic/Amharic compatibility behavior. */
+  useLegacyEthiopicAmharicRules?: boolean; /** Keep words made entirely of capital letters unhyphenated. */
+  doNotHyphenateCaps?: boolean; /** The run renders with the DOCX all-caps transform. */
+  renderedAllCaps?: boolean;
+};
+type LineBreakProvider = {
+  /** Legal soft-wrap offsets, in ascending UTF-16 order. */findBreaks: (text: string, policy?: LineBreakPolicy) => number[]; /** Grapheme-safe emergency-wrap offsets, in ascending UTF-16 order. */
+  findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[]; /** Dictionary-based discretionary hyphen offsets, in ascending UTF-16 order. */
+  findHyphenationBreaks?: (text: string, policy?: LineBreakPolicy) => number[]; /** Whether a trailing grapheme may overhang the line edge. */
+  isHangingPunctuation?: (text: string, policy?: LineBreakPolicy) => boolean;
+};
+declare const MAX_HYPHENATION_WORD_LENGTH = 256;
+declare const defaultLineBreakProvider: LineBreakProvider;
+declare const getLineBreakProvider: () => LineBreakProvider;
+/** Changes whenever the active provider changes, so layout caches cannot go stale. */
+declare const getLineBreakProviderGeneration: () => number;
+declare const setLineBreakProvider: (provider: LineBreakProvider) => void;
+declare const resetLineBreakProvider: () => void;
+//#endregion
+export { LineBreakPolicy, LineBreakProvider, MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider };