@stll/folio-core 0.7.0 → 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,63 +46,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 +57,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 +74,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) => {
@@ -243,6 +190,7 @@ 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 } : {}
@@ -257,23 +205,28 @@ 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 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) naturalPageAdvanceSinceRenderedBreak = "reflowBoundary";
+			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) renderedBreakState = recordReflowBoundary(renderedBreakState, true);
 		}
 		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
@@ -329,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 = "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 {
@@ -387,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",
@@ -406,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();
@@ -534,7 +491,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);
@@ -543,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];
@@ -929,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/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[];
 };
 /**

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

@@ -1,9 +1,12 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.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 +28,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;
@@ -82,9 +85,6 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	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 +101,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,7 +142,7 @@ 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];
@@ -178,14 +157,14 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			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 +179,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 +202,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 +238,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 +282,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 +306,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 +318,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 +334,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 +470,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 +499,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 +542,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;

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

@@ -22,8 +22,9 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
-const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .025;
+const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .02;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
 const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
@@ -245,6 +246,7 @@ function isEmptyTextRun(run) {
 * preceding a floating image.
 */
 function isBlockLayoutImageRun(run) {
+	if (isFloatingImageRun(run)) return false;
 	return run.wrapType === "topAndBottom" || run.displayMode === "block";
 }
 function measureInlineWidthAfterTab(runs, tabIndex, fieldValues) {
@@ -339,7 +341,7 @@ function justifyShrinkToleranceRatio(block, isFirstLine, regularSpaceCount, nonB
 		const hanging = block.attrs.indent?.hanging ?? 0;
 		if (isFirstLine) return hanging <= DEFAULT_LIST_HANGING_INDENT_PX ? JUSTIFY_SHRINK_TOLERANCE_RATIO : JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO;
 		const left = block.attrs.indent?.left ?? 0;
-		if (hanging > 0 && left > hanging) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
+		if (hanging > 0 && left > hanging) return JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO;
 		return fixedSpaceAdjustedShrinkTolerance({
 			tolerance: JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO,
 			regularSpaceCount,
@@ -552,7 +554,14 @@ function measureParagraph(block, maxWidth, options) {
 		...firstLineFloatingMargins.segments?.length ? { segmentZones: firstLineFloatingMargins.segments } : {}
 	};
 	const calculateLineTypography = (line) => {
-		const finalTypography = { ...calculateTypographyMetrics(line.maxFontSize, spacing, line.maxFontMetrics) };
+		const paragraphFontSize = attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
+		const paragraphFontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+		const fontSize = line.maxFontMetrics ? line.maxFontSize : paragraphFontSize;
+		const metrics = line.maxFontMetrics ?? getFontMetrics({
+			fontSize: paragraphFontSize,
+			fontFamily: paragraphFontFamily
+		});
+		const finalTypography = { ...calculateTypographyMetrics(fontSize, spacing, metrics) };
 		const inlineObjectHeight = Math.max(line.maxImageHeightPx, line.maxMathHeightPx);
 		if (inlineObjectHeight > finalTypography.lineHeight) {
 			const objectHeight = inlineObjectHeight;
@@ -682,7 +691,7 @@ function measureParagraph(block, maxWidth, options) {
 		}
 		if (isImageRun(run)) {
 			const wrapType = run.wrapType;
-			if (run.displayMode === "float" || wrapType === "square" || wrapType === "tight" || wrapType === "through" || wrapType === "behind" || wrapType === "inFront") {
+			if (isFloatingImageRun(run)) {
 				currentLine.toRun = runIndex;
 				currentLine.toChar = 1;
 				continue;