@stll/folio-core 0.7.0 → 0.9.0

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

@@ -1,9 +1,13 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
+import { layoutTextBoxParagraphs } from "./textBoxParagraphLayout.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
+import { isParagraphFrameTextBox } from "../paragraphFrame.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
-import { bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
+import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
+import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
 //#region src/layout-engine/measure/measureBlocks.ts
 /**
 * Pseudo-infinite measurement width (px) used for `w:noWrap` table cells so
@@ -25,7 +29,7 @@ const NO_WRAP_MEASURE_WIDTH = 1e6;
 * around a background letterhead or a foreground overlay (Codex
 * PR #258 review).
 */
-function isFloatingImageRun(run) {
+function isSideWrappingImageRun(run) {
 	const wrapType = run.wrapType;
 	const displayMode = run.displayMode;
 	if (wrapType === "behind" || wrapType === "inFront") return false;
@@ -49,42 +53,6 @@ function resolveTableWidthPx(width, widthType, contentWidth) {
 	if (widthType === "pct") return contentWidth * width / 5e3;
 	if (widthType === "dxa" || !widthType || widthType === "auto") return Math.round(width / 20 * 1.333);
 }
-function isInlineFlowImageRun(run) {
-	if (run.displayMode === "float") return false;
-	if (run.wrapType === "square" || run.wrapType === "tight" || run.wrapType === "through" || run.wrapType === "behind" || run.wrapType === "inFront") return false;
-	if (run.displayMode === "block" || run.wrapType === "topAndBottom") return false;
-	return true;
-}
-function measureTableCellBlockVisualHeight(block, blockMeasure) {
-	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return 0;
-	if (block.kind !== "paragraph" || blockMeasure.kind !== "paragraph") {
-		if ("totalHeight" in blockMeasure) return blockMeasure.totalHeight;
-		if ("height" in blockMeasure) return blockMeasure.height;
-		return 0;
-	}
-	const paragraphBlock = block;
-	const paragraphMeasure = blockMeasure;
-	const nonEmptyRuns = paragraphBlock.runs.filter((run) => run.kind !== "text" || run.text.replace(/\u00a0/gu, " ").trim().length > 0);
-	if (paragraphMeasure.lines.length !== 1 || nonEmptyRuns.length === 0) return paragraphMeasure.totalHeight;
-	const inlineImageRuns = [];
-	for (const run of nonEmptyRuns) {
-		if (run.kind !== "image" || !isInlineFlowImageRun(run)) return paragraphMeasure.totalHeight;
-		inlineImageRuns.push(run);
-	}
-	let maxImageHeight = 0;
-	for (const run of inlineImageRuns) maxImageHeight = Math.max(maxImageHeight, run.height);
-	if (inlineImageRuns.length === 1) {
-		const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
-		const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
-		return spacingBefore + maxImageHeight + spacingAfter;
-	}
-	const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
-	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
-	return spacingBefore + maxImageHeight + spacingAfter;
-}
-function getTableCellVerticalBorderHeight(cell, isFirstRow) {
-	return (isFirstRow ? cell?.borders?.top?.width ?? 0 : 0) + (cell?.borders?.bottom?.width ?? 0);
-}
 function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	const DEFAULT_CELL_PADDING_X = 7;
 	const DEFAULT_CELL_PADDING_Y = 0;
@@ -101,38 +69,17 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			columnWidths = columnWidths.map((w) => w * scale);
 		}
 	}
-	const occupiedColumnsPerRow = /* @__PURE__ */ new Map();
-	for (let rowIdx = 0; rowIdx < tableBlock.rows.length; rowIdx++) {
-		const row = tableBlock.rows[rowIdx];
-		if (!row) continue;
-		let colIdx = 0;
-		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
-		while (occupied.has(colIdx)) colIdx++;
-		for (const cell of row.cells) {
-			const colSpan = cell.colSpan ?? 1;
-			const rowSpan = cell.rowSpan ?? 1;
-			if (rowSpan > 1) for (let r = rowIdx + 1; r < rowIdx + rowSpan; r++) {
-				if (!occupiedColumnsPerRow.has(r)) occupiedColumnsPerRow.set(r, /* @__PURE__ */ new Set());
-				const occSet = occupiedColumnsPerRow.get(r);
-				for (let c = 0; c < colSpan; c++) occSet.add(colIdx + c);
-			}
-			colIdx += colSpan;
-			while (occupied.has(colIdx)) colIdx++;
-		}
-	}
+	const cellGrid = buildTableCellGrid(tableBlock.rows, columnWidths.length);
 	const columnsPinned = tableColumnsArePinned(tableBlock);
 	const rows = tableBlock.rows.map((row, rowIdx) => {
-		let columnIndex = 0;
-		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
-		while (occupied.has(columnIndex)) columnIndex++;
+		let columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, row.gridBefore ?? 0);
 		return {
 			cells: row.cells.map((cell) => {
 				const colSpan = cell.colSpan ?? 1;
 				let cellWidth = 0;
 				for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
 				if (cellWidth === 0) cellWidth = cell.width ?? 100;
-				columnIndex += colSpan;
-				while (occupied.has(columnIndex)) columnIndex++;
+				columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, columnIndex + colSpan);
 				const padLeft = cell.padding?.left ?? DEFAULT_CELL_PADDING_X;
 				const padRight = cell.padding?.right ?? DEFAULT_CELL_PADDING_X;
 				const cellContentWidth = Math.max(1, cellWidth - padLeft - padRight);
@@ -163,29 +110,31 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
-		let maxBorderHeight = 0;
+		let maxCellInsets = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
 			const cell = row.cells[cellIdx];
 			const sourceCell = sourceRowCells?.[cellIdx];
 			cell.height = 0;
+			const flowState = createTableCellFlowState();
 			for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
 				const sourceBlock = sourceCell?.blocks[blockIdx];
 				const blockMeasure = cell.blocks[blockIdx];
 				if (!sourceBlock || !blockMeasure) continue;
-				cell.height += measureTableCellBlockVisualHeight(sourceBlock, blockMeasure);
+				placeTableCellBlock(flowState, sourceBlock, blockMeasure);
 			}
+			cell.height = finishTableCellFlow(flowState);
 			const padTop = sourceCell?.padding?.top ?? DEFAULT_CELL_PADDING_Y;
 			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
 			cell.height += padTop + padBottom;
 			if ((sourceCell?.rowSpan ?? 1) > 1) continue;
-			const borderHeight = getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0);
+			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx);
 			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
-			maxBorderHeight = Math.max(maxBorderHeight, borderHeight);
+			maxCellInsets = Math.max(maxCellInsets, padTop + padBottom + borderHeight);
 		}
 		const explicitHeight = sourceRow?.height;
 		const heightRule = sourceRow?.heightRule;
 		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;
-		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxBorderHeight);
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets);
 		else row.height = maxCellHeightWithBorders;
 	}
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
@@ -200,7 +149,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const spanEnd = Math.min(rows.length, rowIdx + rowSpan);
 			let combinedHeight = 0;
 			for (let spannedRowIdx = rowIdx; spannedRowIdx < spanEnd; spannedRowIdx++) combinedHeight += rows[spannedRowIdx]?.height ?? 0;
-			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0) - combinedHeight;
+			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx) - combinedHeight;
 			if (deficit <= 0) continue;
 			for (let spannedRowIdx = spanEnd - 1; spannedRowIdx >= rowIdx; spannedRowIdx--) {
 				if (tableBlock.rows[spannedRowIdx]?.heightRule === "exact") continue;
@@ -223,13 +172,34 @@ function perBlockNumberValue(value, blockIndex, fallback) {
 	if (Array.isArray(value)) return value[blockIndex] ?? fallback;
 	return value;
 }
+function textBoxWrapSide({ box, contentX, boxWidth, contentWidth }) {
+	if (box.wrapText === "left") return "left";
+	if (box.wrapText === "right") return "right";
+	const leftSpace = contentX;
+	const rightSpace = contentWidth - contentX - boxWidth;
+	if (box.wrapText === "largest") return leftSpace >= rightSpace ? "left" : "right";
+	return contentX + boxWidth / 2 < contentWidth / 2 ? "right" : "left";
+}
 function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
 	const zones = [];
+	const defaultContentWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
 	const textBoxGroupAnchors = /* @__PURE__ */ new Map();
+	const paragraphFrameGroupSizes = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		if (block.kind !== "textBox" || !isParagraphFrameTextBox(block)) continue;
+		const groupId = getTextBoxGroupId(block);
+		if (groupId !== void 0) paragraphFrameGroupSizes.set(groupId, (paragraphFrameGroupSizes.get(groupId) ?? 0) + 1);
+	}
 	const defaultMarginTop = Array.isArray(marginTop) ? marginTop[0] ?? 0 : marginTop;
+	const pageWidthInput = pageGeometry?.pageWidth ?? defaultContentWidth;
 	const pageHeightInput = pageGeometry?.pageHeight ?? 0;
+	const marginLeftInput = pageGeometry?.marginLeft ?? 0;
+	const marginRightInput = pageGeometry?.marginRight ?? 0;
 	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
+	const defaultPageWidth = Array.isArray(pageWidthInput) ? pageWidthInput[0] ?? defaultContentWidth : pageWidthInput;
 	const defaultPageHeight = Array.isArray(pageHeightInput) ? pageHeightInput[0] ?? 0 : pageHeightInput;
+	const defaultMarginLeft = Array.isArray(marginLeftInput) ? marginLeftInput[0] ?? 0 : marginLeftInput;
+	const defaultMarginRight = Array.isArray(marginRightInput) ? marginRightInput[0] ?? 0 : marginRightInput;
 	const defaultMarginBottom = Array.isArray(marginBottomInput) ? marginBottomInput[0] ?? 0 : marginBottomInput;
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		const block = blocks[blockIndex];
@@ -238,13 +208,36 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		for (const run of paragraphBlock.runs) {
 			if (run.kind !== "image") continue;
 			const imgRun = run;
-			if (!isFloatingImageRun(imgRun)) continue;
+			const positionedBand = imgRun.wrapType === "topAndBottom" && imgRun.position !== void 0;
+			if (!isSideWrappingImageRun(imgRun) && !positionedBand) continue;
 			let topY = 0;
 			const position = imgRun.position;
 			const distTop = imgRun.distTop ?? 0;
 			const distBottom = imgRun.distBottom ?? 0;
 			const distLeft = imgRun.distLeft ?? 12;
 			const distRight = imgRun.distRight ?? 12;
+			if (positionedBand && position !== void 0) {
+				const vertical = position.vertical;
+				const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
+				const pageFrameRelative = isPageFrameRelativeAnchor(vertical?.relativeTo);
+				const rawTop = pageFrameRelative ? bandTopContentY(vertical, {
+					pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
+					marginTop: blockMarginTop,
+					marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
+					boxHeight: imgRun.height
+				}) : emuToPixels(vertical?.posOffset ?? 0);
+				const bottomY = rawTop + imgRun.height + distBottom;
+				if (bottomY > 0) zones.push({
+					leftMargin: 0,
+					rightMargin: 0,
+					topY: Math.max(0, rawTop - distTop),
+					bottomY,
+					anchorBlockIndex: blockIndex,
+					...pageFrameRelative ? { isMarginRelative: true } : {},
+					fullWidthBlock: true
+				});
+				continue;
+			}
 			if (position?.vertical) {
 				const v = position.vertical;
 				if (v.align === "top" && v.relativeTo === "margin") topY = 0;
@@ -259,8 +252,8 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 				else if (h.align === "right") rightMargin = imgRun.width + distLeft;
 				else if (h.posOffset !== void 0) {
 					const x = emuToPixels(h.posOffset);
-					if (x < contentWidth / 2) leftMargin = x + imgRun.width + distRight;
-					else rightMargin = contentWidth - x + distLeft;
+					if (x < defaultContentWidth / 2) leftMargin = x + imgRun.width + distRight;
+					else rightMargin = defaultContentWidth - x + distLeft;
 				}
 			} else if (imgRun.cssFloat === "left") leftMargin = imgRun.width + distRight;
 			else if (imgRun.cssFloat === "right") rightMargin = imgRun.width + distLeft;
@@ -283,7 +276,7 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		const tableBlock = block;
 		const floating = tableBlock.floating;
 		if (!floating) continue;
-		const tableMeasure = measureTableBlock(tableBlock, contentWidth);
+		const tableMeasure = measureTableBlock(tableBlock, defaultContentWidth);
 		const tableWidth = tableMeasure.totalWidth;
 		const tableHeight = tableMeasure.totalHeight;
 		const distLeft = floating.leftFromText ?? 12;
@@ -295,12 +288,12 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		let x = 0;
 		if (floating.tblpX !== void 0) x = floating.tblpX;
 		else if (floating.tblpXSpec) if (floating.tblpXSpec === "left" || floating.tblpXSpec === "inside") x = 0;
-		else if (floating.tblpXSpec === "right" || floating.tblpXSpec === "outside") x = contentWidth - tableWidth;
-		else x = (contentWidth - tableWidth) / 2;
-		else if (tableBlock.justification === "center") x = (contentWidth - tableWidth) / 2;
-		else if (tableBlock.justification === "right") x = contentWidth - tableWidth;
-		if (x < contentWidth / 2) leftMargin = x + tableWidth + distRight;
-		else rightMargin = contentWidth - x + distLeft;
+		else if (floating.tblpXSpec === "right" || floating.tblpXSpec === "outside") x = defaultContentWidth - tableWidth;
+		else x = (defaultContentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "center") x = (defaultContentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "right") x = defaultContentWidth - tableWidth;
+		if (x < defaultContentWidth / 2) leftMargin = x + tableWidth + distRight;
+		else rightMargin = defaultContentWidth - x + distLeft;
 		const topY = floating.tblpY ?? 0;
 		const bottomY = topY + tableHeight;
 		zones.push({
@@ -311,6 +304,64 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 			anchorBlockIndex: blockIndex
 		});
 	}
+	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+		const block = blocks[blockIndex];
+		if (block.kind !== "textBox") continue;
+		const tb = block;
+		if (!floatingTextBoxWrapsText(tb) || tb.position === void 0) continue;
+		const measure = measureTextBoxBlock(tb);
+		const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
+		const blockMarginLeft = perBlockNumberValue(marginLeftInput, blockIndex, defaultMarginLeft);
+		const blockMarginRight = perBlockNumberValue(marginRightInput, blockIndex, defaultMarginRight);
+		const blockPageWidth = perBlockNumberValue(pageWidthInput, blockIndex, defaultPageWidth);
+		const blockContentWidth = perBlockNumberValue(contentWidth, blockIndex, defaultContentWidth);
+		const vertical = tb.position.vertical;
+		const pageFrameRelative = isPageFrameRelativeAnchor(vertical?.relativeTo);
+		const topY = pageFrameRelative ? bandTopContentY(vertical, {
+			pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
+			marginTop: blockMarginTop,
+			marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
+			boxHeight: measure.height
+		}) : emuToPixels(vertical?.posOffset ?? 0);
+		const groupId = getTextBoxGroupId(tb);
+		const anchorBlockIndex = groupId ? textBoxGroupAnchors.get(groupId) ?? blockIndex : blockIndex;
+		if (groupId && !textBoxGroupAnchors.has(groupId)) textBoxGroupAnchors.set(groupId, blockIndex);
+		if (isParagraphFrameTextBox(tb) && groupId !== void 0 && (paragraphFrameGroupSizes.get(groupId) ?? 0) > 1) {
+			zones.push({
+				leftMargin: 0,
+				rightMargin: 0,
+				topY: 0,
+				bottomY: topY + measure.height + (tb.distBottom ?? 0),
+				anchorBlockIndex,
+				...pageFrameRelative ? { isMarginRelative: true } : {},
+				fullWidthBlock: true
+			});
+			continue;
+		}
+		const horizontal = tb.position.horizontal;
+		const contentX = (horizontal ? bandFragmentX(horizontal, {
+			pageWidth: blockPageWidth,
+			marginLeft: blockMarginLeft,
+			marginRight: blockMarginRight,
+			boxWidth: measure.width
+		}) : blockMarginLeft) - blockMarginLeft;
+		const wrapSide = textBoxWrapSide({
+			box: tb,
+			contentX,
+			boxWidth: measure.width,
+			contentWidth: blockContentWidth
+		});
+		const leftMargin = wrapSide === "right" ? contentX + measure.width + (tb.distRight ?? 12) : 0;
+		const rightMargin = wrapSide === "left" ? blockContentWidth - contentX + (tb.distLeft ?? 12) : 0;
+		zones.push({
+			leftMargin: Math.max(0, leftMargin),
+			rightMargin: Math.max(0, rightMargin),
+			topY: topY - (tb.distTop ?? 0),
+			bottomY: topY + measure.height + (tb.distBottom ?? 0),
+			anchorBlockIndex,
+			...pageFrameRelative ? { isMarginRelative: true } : {}
+		});
+	}
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		const block = blocks[blockIndex];
 		if (block.kind !== "textBox") continue;
@@ -389,8 +440,8 @@ function measureTextBoxBlock(tb, fieldValues) {
 	const margins = tb.margins ?? DEFAULT_TEXTBOX_MARGINS;
 	const innerWidth = tb.width - margins.left - margins.right;
 	const innerMeasures = tb.content.map((p) => measureParagraph(p, innerWidth, fieldValues ? { fieldValues } : void 0));
-	const contentHeight = innerMeasures.reduce((sum, m) => sum + m.totalHeight, 0);
-	const totalHeight = tb.height ?? contentHeight + margins.top + margins.bottom;
+	const contentBoxHeight = layoutTextBoxParagraphs(tb.content, innerMeasures).totalHeight + margins.top + margins.bottom;
+	const totalHeight = tb.autoFit === "shape" ? Math.max(tb.height ?? 0, contentBoxHeight) : tb.height ?? contentBoxHeight;
 	return {
 		kind: "textBox",
 		width: tb.width,
@@ -418,7 +469,7 @@ function isNextPageSectionBreak(block) {
 */
 function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldValues) {
 	const defaultWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
-	const floatingZonesWithAnchors = extractFloatingZones(blocks, defaultWidth, marginTop, pageGeometry);
+	const floatingZonesWithAnchors = extractFloatingZones(blocks, contentWidth, marginTop, pageGeometry);
 	const marginRelative = floatingZonesWithAnchors.filter((z) => z.isMarginRelative && !z.fullWidthBlock);
 	const ownAnchorZones = floatingZonesWithAnchors.filter((z) => !z.isMarginRelative || z.fullWidthBlock);
 	const marginByTopY = /* @__PURE__ */ new Map();
@@ -461,10 +512,11 @@ function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldV
 		try {
 			const blockWidth = Array.isArray(contentWidth) ? contentWidth[blockIndex] ?? defaultWidth : contentWidth;
 			const measure = measureBlock(block, blockWidth, zones, cumulativeY, fieldValues);
-			const bandZones = zones?.filter((zone) => zone.fullWidthBlock);
-			if (bandZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
+			const clearingZones = measure.kind === "table" ? zones : zones?.filter((zone) => zone.fullWidthBlock);
+			if (clearingZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
 				const blockHeight = measure.kind === "image" ? measure.height : measure.totalHeight;
-				const skip = findClearLineY(cumulativeY, blockHeight, bandZones, blockWidth, 24) - cumulativeY;
+				const requiredWidth = measure.kind === "table" ? Math.min(blockWidth, measure.totalWidth) : 24;
+				const skip = findClearLineY(cumulativeY, blockHeight, clearingZones, blockWidth, Math.max(24, requiredWidth)) - cumulativeY;
 				if (skip > 0) {
 					measure.bandSkipBefore = skip;
 					cumulativeY += skip;
@@ -494,4 +546,4 @@ function measureSingleBlockWithoutFloatingZones(block, blockWidth, blockIndex) {
 	return measureBlock(block, blockWidth);
 }
 //#endregion
-export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTextBoxBlock };

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

@@ -1,4 +1,5 @@
 import { setMeasureProvider } from "./measureProvider.js";
+import { getFontKerningMode } from "./textMeasurementPolicy.js";
 import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
 import { hasCjk, isCjkCodePoint, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
@@ -46,13 +47,14 @@ function getCanvasContext() {
 function resetCanvasContext() {
 	canvasContext = null;
 }
-function getWorkerFontFingerprintWidth(ctx, font) {
+function getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning) {
 	const generation = getTextWidthCacheGeneration();
-	const cached = workerFontFingerprintCache.get(font);
+	const cached = workerFontFingerprintCache.get(fontCacheKey);
 	if (cached?.generation === generation) return cached.width;
 	ctx.font = font;
+	ctx.fontKerning = fontKerning;
 	const width = ctx.measureText(WORKER_FONT_FINGERPRINT_TEXT).width;
-	workerFontFingerprintCache.set(font, {
+	workerFontFingerprintCache.set(fontCacheKey, {
 		generation,
 		width
 	});
@@ -86,6 +88,7 @@ function canvasGetFontMetrics(style) {
 	try {
 		const ctx = getCanvasContext();
 		ctx.font = buildFontString(style);
+		ctx.fontKerning = getFontKerningMode(style);
 		const metrics = ctx.measureText("Hg");
 		if (typeof metrics.actualBoundingBoxAscent === "number" && typeof metrics.actualBoundingBoxDescent === "number") {
 			ascent = metrics.actualBoundingBoxAscent;
@@ -120,10 +123,12 @@ function canvasMeasureTextWidth(text, style) {
 	const font = buildFontString(style);
 	const letterSpacing = style.letterSpacing ?? 0;
 	const horizontalScale = getHorizontalScaleFactor(style);
-	const fontCacheKey = `${font}|scale:${horizontalScale}`;
+	const fontKerning = getFontKerningMode(style);
+	const fontCacheKey = style.kerning ? `${font}|kerning:normal|scale:${horizontalScale}` : `${font}|scale:${horizontalScale}`;
 	const cached = getCachedTextWidth(measuredText, fontCacheKey, letterSpacing);
 	if (cached !== void 0) return cached;
 	ctx.font = font;
+	ctx.fontKerning = fontKerning;
 	let width = ctx.measureText(measuredText).width;
 	if (letterSpacing) {
 		const codePoints = countCodePoints(measuredText);
@@ -132,9 +137,17 @@ function canvasMeasureTextWidth(text, style) {
 	const scaledWidth = width * horizontalScale;
 	setCachedTextWidth(measuredText, fontCacheKey, letterSpacing, scaledWidth);
 	if (!canPrefetchMeasurement()) return scaledWidth;
-	const fontFingerprintWidth = getWorkerFontFingerprintWidth(ctx, font);
-	prefetchMeasurement(measuredText, font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth);
-	prefetchBinarySearchProbes(measuredText, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale);
+	const fontFingerprintWidth = getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning);
+	prefetchMeasurement({
+		text: measuredText,
+		font,
+		letterSpacing,
+		horizontalScale,
+		fontCacheKey,
+		fontFingerprintWidth,
+		fontKerning
+	});
+	prefetchBinarySearchProbes(measuredText, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale, fontKerning);
 	return scaledWidth;
 }
 /**
@@ -150,6 +163,7 @@ function glyphAdvanceStyle(style, fontFamily) {
 	if (style.bold !== void 0) result.bold = style.bold;
 	if (style.italic !== void 0) result.italic = style.italic;
 	if (style.fontVariant !== void 0) result.fontVariant = style.fontVariant;
+	if (style.kerning !== void 0) result.kerning = style.kerning;
 	return result;
 }
 /**
@@ -186,12 +200,20 @@ function measureMixedScriptWidth(measuredText, style) {
 * pays the main-thread cost as usual. When the worker wins, that probe
 * lands on a hit.
 */
-function prefetchBinarySearchProbes(text, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale) {
+function prefetchBinarySearchProbes(text, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale, fontKerning) {
 	if (text.length < 4) return;
 	for (let denom = 2; denom <= 8; denom *= 2) {
 		const len = Math.floor(text.length / denom);
 		if (len < 2) break;
-		prefetchMeasurement(text.slice(0, len), font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth);
+		prefetchMeasurement({
+			text: text.slice(0, len),
+			font,
+			letterSpacing,
+			horizontalScale,
+			fontCacheKey,
+			fontFingerprintWidth,
+			fontKerning
+		});
 	}
 }
 /**
@@ -224,6 +246,7 @@ function canvasMeasureRun(text, style) {
 	const ctx = getCanvasContext();
 	const baseFont = buildFontString(style);
 	ctx.font = baseFont;
+	ctx.fontKerning = style.kerning ? "normal" : "none";
 	const eastAsiaFont = style.eastAsiaFontFamily !== void 0 && !style.letterSpacing ? buildFontString({
 		...style,
 		fontFamily: style.eastAsiaFontFamily

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

@@ -1,5 +1,6 @@
 import { resolveFontFamily } from "../../utils/fontResolver.js";
 import "../../utils/fontWeights.js";
+import { FONT_KERNING_MODE, getRunFontKerningMode } from "./textMeasurementPolicy.js";
 //#region src/layout-engine/measure/measureHelpers.ts
 /**
 * Pure measurement helpers — no canvas, no DOM, no worker.
@@ -23,16 +24,18 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 * and size fallbacks for runs that declare neither.
 */
 function buildRunFontStyle(run, fallbackFontFamily, fallbackFontSize) {
+	const fontSize = run.fontSize ?? fallbackFontSize;
 	return {
 		fontFamily: run.fontFamily ?? fallbackFontFamily,
 		...run.eastAsiaFontFamily !== void 0 ? { eastAsiaFontFamily: run.eastAsiaFontFamily } : {},
-		fontSize: run.fontSize ?? fallbackFontSize,
+		fontSize,
 		...run.bold !== void 0 ? { bold: run.bold } : {},
 		...run.italic !== void 0 ? { italic: run.italic } : {},
 		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
 		...run.allCaps ? { textTransform: "uppercase" } : {},
 		...run.smallCaps ? { fontVariant: "small-caps" } : {},
-		...run.horizontalScale !== void 0 ? { horizontalScale: run.horizontalScale } : {}
+		...run.horizontalScale !== void 0 ? { horizontalScale: run.horizontalScale } : {},
+		kerning: getRunFontKerningMode(run, fallbackFontSize) === FONT_KERNING_MODE.enabled
 	};
 }
 /** Cache for resolved font data */