@stll/folio-core 0.6.0 → 0.7.0

package/dist/docx/server/extractDocxText.js

@@ -0,0 +1,154 @@
+import { findAllDeep, findChild, findDeep, getAttributeAnyPrefix, getLocalName, getTextContent, parseXml } from "../xmlParser.js";
+import { loadDocxArchive } from "./boundedArchive.js";
+//#region src/docx/server/extractDocxText.ts
+const HEADER_FOOTER_PATH = /^word\/(?:header|footer)\d+\.xml$/u;
+const childElements = (element) => element.elements?.filter((child) => child.type === "element") ?? [];
+const collectText = (element) => {
+	let text = "";
+	const walk = (node) => {
+		const localName = getLocalName(node.name ?? "");
+		if (localName === "t") {
+			text += getTextContent(node);
+			return;
+		}
+		if (localName === "br") {
+			text += "\n";
+			return;
+		}
+		if (localName === "tab") {
+			text += "	";
+			return;
+		}
+		if (localName === "del" || localName === "delText" || localName === "moveFrom") return;
+		for (const child of childElements(node)) walk(child);
+	};
+	walk(element);
+	return text;
+};
+const readParagraphProperties = (paragraph) => {
+	const properties = findChild(paragraph, "w", "pPr");
+	if (!properties) return {};
+	const result = {};
+	const styleValue = getAttributeAnyPrefix(findChild(properties, "w", "pStyle"), "val");
+	if (styleValue !== null) result.style = styleValue;
+	const alignment = getAttributeAnyPrefix(findChild(properties, "w", "jc"), "val");
+	if (alignment === "left" || alignment === "center" || alignment === "right" || alignment === "both") result.alignment = alignment;
+	return result;
+};
+const readRunMetrics = (paragraph) => {
+	const metrics = [];
+	for (const run of childElements(paragraph)) {
+		if (getLocalName(run.name ?? "") !== "r") continue;
+		const properties = findChild(run, "w", "rPr");
+		const boldProperty = findChild(properties, "w", "b");
+		const boldValue = getAttributeAnyPrefix(boldProperty, "val");
+		const bold = boldProperty !== null && boldValue !== "0" && boldValue !== "false";
+		const sizeValue = getAttributeAnyPrefix(findChild(properties, "w", "sz"), "val");
+		const parsedSize = sizeValue === null ? NaN : Number.parseInt(sizeValue, 10);
+		const fontSize = Number.isFinite(parsedSize) && parsedSize > 0 ? parsedSize : void 0;
+		let chars = 0;
+		for (const textNode of findAllDeep(run, "w", "t")) chars += getTextContent(textNode).length;
+		if (chars === 0) continue;
+		const entry = {
+			bold,
+			chars
+		};
+		if (fontSize !== void 0) entry.fontSize = fontSize;
+		metrics.push(entry);
+	}
+	return metrics;
+};
+const extractContainer = ({ container, source, startIndex }) => {
+	const paragraphs = [];
+	let charCount = 0;
+	for (const [offset, paragraph] of findAllDeep(container, "w", "p").entries()) {
+		const text = collectText(paragraph);
+		const entry = {
+			index: startIndex + offset,
+			text,
+			source
+		};
+		const { style, alignment } = readParagraphProperties(paragraph);
+		if (style !== void 0) entry.style = style;
+		if (alignment !== void 0) entry.alignment = alignment;
+		const runs = readRunMetrics(paragraph);
+		if (runs.length > 0) {
+			const totalChars = runs.reduce((sum, run) => sum + run.chars, 0);
+			if (runs.reduce((sum, run) => sum + (run.bold ? run.chars : 0), 0) > totalChars / 2) entry.bold = true;
+			const firstFontSize = runs.find((run) => run.fontSize !== void 0)?.fontSize;
+			if (firstFontSize !== void 0) entry.fontSize = firstFontSize;
+		}
+		paragraphs.push(entry);
+		charCount += text.length;
+	}
+	return {
+		paragraphs,
+		charCount
+	};
+};
+const extractParts = async ({ archive, source, rootName, startIndex }) => {
+	const paragraphs = [];
+	let charCount = 0;
+	let nextIndex = startIndex;
+	const prefix = `word/${source}`;
+	const paths = archive.entries.filter((path) => HEADER_FOOTER_PATH.test(path) && path.startsWith(prefix)).toSorted();
+	for (const path of paths) {
+		const xml = await archive.readEntryString(path);
+		if (xml === null) continue;
+		const container = findDeep(parseXml(xml), "w", rootName);
+		if (!container) continue;
+		const result = extractContainer({
+			container,
+			source,
+			startIndex: nextIndex
+		});
+		paragraphs.push(...result.paragraphs);
+		charCount += result.charCount;
+		nextIndex += result.paragraphs.length;
+	}
+	return {
+		paragraphs,
+		charCount
+	};
+};
+const createEmptyResult = () => ({
+	paragraphs: [],
+	charCount: 0,
+	view: "accepted"
+});
+/** Extract paragraph text and formatting metadata from a DOCX archive. */
+const extractDocxText = async (bytes) => {
+	const archive = await loadDocxArchive(bytes);
+	const documentXml = await archive.readEntryString("word/document.xml");
+	if (documentXml === null) return createEmptyResult();
+	const body = findDeep(parseXml(documentXml), "w", "body");
+	if (!body) return createEmptyResult();
+	const headers = await extractParts({
+		archive,
+		source: "header",
+		rootName: "hdr",
+		startIndex: 0
+	});
+	const bodyResult = extractContainer({
+		container: body,
+		source: "body",
+		startIndex: headers.paragraphs.length
+	});
+	const footers = await extractParts({
+		archive,
+		source: "footer",
+		rootName: "ftr",
+		startIndex: headers.paragraphs.length + bodyResult.paragraphs.length
+	});
+	return {
+		paragraphs: [
+			...headers.paragraphs,
+			...bodyResult.paragraphs,
+			...footers.paragraphs
+		],
+		charCount: headers.charCount + bodyResult.charCount + footers.charCount,
+		view: "accepted"
+	};
+};
+//#endregion
+export { extractDocxText };

package/dist/docx/tableParser.js

@@ -3,6 +3,7 @@ import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
 import { BorderStyleSchema, FloatingTableXSpecSchema, FloatingTableYSpecSchema, ShadingPatternSchema, TableCellTextDirectionSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, appendBookmarkMarkerToLastParagraphInCells, prependBookmarkMarkersToFirstParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInCell } from "./bookmarkPlacement.js";
+import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
 //#region src/docx/tableParser.ts
 /**
 * Parse a table measurement (width, height, etc.)
@@ -489,6 +490,7 @@ function parseCellContent(tcElement, styles, theme, numbering, rels, media, opti
 		const localName = getLocalName(child.name);
 		if (localName === "p") {
 			const para = parseParagraph(child, styles, theme, numbering, rels, media, options);
+			enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media);
 			prependPendingBookmarkMarkers(para, pendingBookmarkMarkers);
 			content.push(para);
 		} else if (localName === "tbl") {

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -1,13 +1,14 @@
 import { NUMBER_FORMAT_VALUES } from "../../types/documentEnumValues.js";
-import { halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
+import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
 import { padDecimal } from "../../docx/numberingParser.js";
 import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
 import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
 import { resolveShadingFill } from "../../utils/formatToStyle.js";
 import { convertBulletToUnicode } from "../../docx/bulletMarkers.js";
 import { setTextBoxGroupId } from "../../layout-engine/textBoxGroup.js";
+import { getColumns } from "../sectionColumns.js";
 import { directionIsRtl } from "../../prosemirror/paragraphDirection.js";
-import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
 import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
 import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
 import { assertValidProseMirrorDocument } from "../../prosemirror/validation.js";
@@ -672,6 +673,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 		else if (align === "center") attrs.alignment = "center";
 		else if (align === "right") attrs.alignment = "right";
 	}
+	if (typeof pmAttrs.outlineLevel === "number") attrs.outlineLevel = pmAttrs.outlineLevel;
 	const spaceBefore = pmAttrs.spaceBefore;
 	const spaceAfter = pmAttrs.spaceAfter;
 	const lineSpacing = pmAttrs.lineSpacing;
@@ -679,10 +681,14 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	const autoAfter = autospacingMatchesBase(pmAttrs._autospacingBase, "after", spaceAfter);
 	if (autoBefore || autoAfter || typeof spaceBefore === "number" || typeof spaceAfter === "number" || typeof lineSpacing === "number") {
 		attrs.spacing = {};
-		if (autoBefore) attrs.spacing.before = 14;
+		if (autoBefore) attrs.spacing.before = AUTO_PARAGRAPH_SPACING_PX;
 		else if (typeof spaceBefore === "number") attrs.spacing.before = twipsToPixels(spaceBefore);
-		if (autoAfter) attrs.spacing.after = 14;
+		if (autoAfter) attrs.spacing.after = AUTO_PARAGRAPH_SPACING_PX;
 		else if (typeof spaceAfter === "number") attrs.spacing.after = twipsToPixels(spaceAfter);
+		if (autoBefore || autoAfter) attrs.automaticSpacing = {
+			...autoBefore ? { before: true } : {},
+			...autoAfter ? { after: true } : {}
+		};
 		const pmSpacingExplicit = pmAttrs.spacingExplicit;
 		const spacingFromDocDefaults = pmAttrs.spacingFromDocDefaults;
 		const explicit = {};
@@ -702,7 +708,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	let indentLeft = typeof pmAttrs.indentLeft === "number" ? pmAttrs.indentLeft : void 0;
 	let indentFirstLine = typeof pmAttrs.indentFirstLine === "number" ? pmAttrs.indentFirstLine : void 0;
 	let hangingIndent = pmAttrs.hangingIndent;
-	if (pmAttrs.numPr?.numId && indentLeft === void 0) {
+	if (pmAttrs.numPr?.numId && indentLeft === void 0 && indentFirstLine === void 0) {
 		indentLeft = ((pmAttrs.numPr.ilvl ?? 0) + 1) * 720;
 		if (indentFirstLine === void 0) {
 			indentFirstLine = -360;
@@ -828,6 +834,7 @@ function convertParagraph(node, startPos, options) {
 	const attrs = convertParagraphAttrs(pmAttrs, options.theme, options.listCounters, options.listAbstractCounters, options.listSeenNumIds, options.defaultTabStopTwips, options.originalListCounters, options.originalListAbstractCounters, options.originalListSeenNumIds);
 	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
 	if (runs.length === 0) {
+		if (pmAttrs._originalFormatting && Object.entries(pmAttrs._originalFormatting).some(([key, value]) => key !== "runProperties" && value !== void 0 && value !== null)) attrs.hasDirectParagraphFormatting = true;
 		const paragraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
 		if (paragraphMarkFormatting?.fontSize !== void 0) attrs.defaultFontSize = paragraphMarkFormatting.fontSize / 2;
 		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily?.ascii ?? paragraphMarkFormatting?.fontFamily?.hAnsi;
@@ -850,6 +857,37 @@ function convertParagraph(node, startPos, options) {
 	};
 }
 /**
+* Word keeps terminal empty body paragraphs after a final table as editable
+* anchors, but they do not create a page of their own. Preserve every block
+* and PM range while collapsing only the contiguous, run-free suffix; empty
+* paragraphs elsewhere still retain their normal line height.
+*/
+function isPaintlessTerminalParagraph(block) {
+	if (block?.kind !== "paragraph" || block.runs.length !== 0) return false;
+	const attrs = block.attrs;
+	return !(attrs?.listMarker !== void 0 && !attrs.listMarkerHidden || attrs?.borders?.top || attrs?.borders?.bottom || attrs?.borders?.left || attrs?.borders?.right || attrs?.borders?.between || attrs?.borders?.bar || attrs?.shading || attrs?.spacingExplicit?.before || attrs?.spacingExplicit?.after || attrs?.pageBreakBefore || attrs?.renderedPageBreakBefore);
+}
+function suppressTerminalEmptyParagraphsAfterTable(blocks) {
+	let suffixStart = blocks.length;
+	while (suffixStart > 0 && isPaintlessTerminalParagraph(blocks[suffixStart - 1])) suffixStart -= 1;
+	if (suffixStart === blocks.length || suffixStart === 0 || blocks[suffixStart - 1]?.kind !== "table") return;
+	for (let index = suffixStart; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		if (isPaintlessTerminalParagraph(block)) block.attrs = {
+			...block.attrs,
+			suppressEmptyParagraphHeight: true
+		};
+	}
+}
+function reserveLeadingEmptyOutlineHeight(blocks) {
+	const firstBlock = blocks.at(0);
+	if (firstBlock?.kind !== "paragraph" || firstBlock.runs.length !== 0 || firstBlock.attrs?.outlineLevel !== 0) return;
+	firstBlock.attrs = {
+		...firstBlock.attrs,
+		reserveEmptyOutlineHeight: true
+	};
+}
+/**
 * Convert border width from eighths of a point to pixels.
 * OOXML stores border widths in eighths of a point.
 */
@@ -919,6 +957,7 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 			const block = convertParagraph(child, offset, options);
 			blocks.push(block);
 		} else if (child.type.name === "table") blocks.push(convertTable(child, offset, options));
+		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, offset, options));
 		offset += child.nodeSize;
 	});
 	const trailingBlock = blocks.at(-1);
@@ -999,7 +1038,8 @@ function convertTable(node, startPos, options) {
 	}
 	const justification = attrs.justification;
 	const originalFormatting = attrs._originalFormatting;
-	const indentPx = originalFormatting?.indent?.value && originalFormatting.indent.type === "dxa" ? twipsToPixels(originalFormatting.indent.value) : void 0;
+	const effectiveIndent = attrs._resolvedIndent ?? originalFormatting?.indent;
+	const indentPx = effectiveIndent?.value !== void 0 && effectiveIndent?.type === "dxa" ? twipsToPixels(effectiveIndent.value) : void 0;
 	const floating = attrs.floating;
 	let floatingPx;
 	if (floating) {
@@ -1213,11 +1253,33 @@ function toFlowBlocks(doc, options = {}) {
 		}
 		switch (node.type.name) {
 			case "paragraph": {
-				const block = convertParagraph(node, pos, opts);
 				const pmAttrs = expectParagraphAttrs(node);
-				trackedPush(block);
 				const secProps = pmAttrs._sectionProperties;
-				if (secProps || pmAttrs.sectionBreakType) {
+				const hasSectionBreak = secProps !== void 0 || pmAttrs.sectionBreakType !== null && pmAttrs.sectionBreakType !== void 0;
+				const hasListFormatting = pmAttrs.numPr !== null && pmAttrs.numPr !== void 0 || pmAttrs.listMarker !== null && pmAttrs.listMarker !== void 0;
+				const firstChild = node.firstChild;
+				const startsWithColumnBreak = firstChild?.type.name === "hardBreak" && expectHardBreakAttrs(firstChild).breakType === "column";
+				if (node.childCount === 1 && startsWithColumnBreak) {
+					const columnBreak = {
+						kind: "columnBreak",
+						id: nextBlockId(),
+						pmStart: pos,
+						pmEnd: pos + node.nodeSize
+					};
+					trackedPush(columnBreak);
+				} else if (startsWithColumnBreak && firstChild) {
+					const columnBreak = {
+						kind: "columnBreak",
+						id: nextBlockId(),
+						pmStart: pos + 1,
+						pmEnd: pos + 1 + firstChild.nodeSize
+					};
+					trackedPush(columnBreak);
+					const paragraph = convertParagraph(node, pos, opts);
+					if (paragraph.runs.at(0)?.kind === "lineBreak") paragraph.runs.shift();
+					trackedPush(paragraph);
+				} else if (node.content.size > 0 || hasListFormatting || !hasSectionBreak) trackedPush(convertParagraph(node, pos, opts));
+				if (hasSectionBreak) {
 					const sectionBreak = {
 						kind: "sectionBreak",
 						id: nextBlockId()
@@ -1245,16 +1307,8 @@ function toFlowBlocks(doc, options = {}) {
 							if (secProps.headerDistance !== void 0) sectionBreak.margins.header = twipsToPixels(secProps.headerDistance);
 							if (secProps.footerDistance !== void 0) sectionBreak.margins.footer = twipsToPixels(secProps.footerDistance);
 						}
-						const colCount = secProps.columnCount ?? 1;
-						if (colCount > 1) {
-							const cols = {
-								count: colCount,
-								gap: twipsToPixels(secProps.columnSpace ?? 720),
-								equalWidth: secProps.equalWidth ?? true
-							};
-							if (secProps.separator !== void 0) cols.separator = secProps.separator;
-							sectionBreak.columns = cols;
-						}
+						const columns = getColumns(secProps);
+						if (columns) sectionBreak.columns = columns;
 					}
 					trackedPush(sectionBreak);
 				}
@@ -1286,6 +1340,8 @@ function toFlowBlocks(doc, options = {}) {
 	doc.forEach((node, nodeOffset) => {
 		visit(node, offset + nodeOffset);
 	});
+	reserveLeadingEmptyOutlineHeight(blocks);
+	suppressTerminalEmptyParagraphsAfterTable(blocks);
 	return mergeRunInParagraphs(blocks);
 }
 /**

package/dist/layout-bridge/sectionColumns.js

@@ -7,13 +7,18 @@ const DEFAULT_COLUMN_SPACE_TWIPS = 720;
 * Returns undefined for single-column (default) to avoid unnecessary paginator overhead.
 */
 function getColumns(sectionProps) {
-	const count = sectionProps?.columnCount ?? 1;
+	const authoredColumns = sectionProps?.columns;
+	const count = sectionProps?.columnCount ?? authoredColumns?.length ?? 1;
 	if (count <= 1) return void 0;
 	const columns = {
 		count,
 		gap: twipsToPixels(sectionProps?.columnSpace ?? DEFAULT_COLUMN_SPACE_TWIPS),
 		equalWidth: sectionProps?.equalWidth ?? true
 	};
+	if (sectionProps?.equalWidth === false && authoredColumns?.length === count && authoredColumns.every(({ width }) => width !== void 0)) {
+		columns.widths = authoredColumns.map(({ width }) => twipsToPixels(width ?? 0));
+		columns.gaps = authoredColumns.slice(0, -1).map(({ space }) => twipsToPixels(space ?? sectionProps.columnSpace ?? DEFAULT_COLUMN_SPACE_TWIPS));
+	}
 	if (sectionProps?.separator !== void 0) columns.separator = sectionProps.separator;
 	return columns;
 }

package/dist/layout-engine/index.js

@@ -44,9 +44,7 @@ function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 }
 /**
 * Whether a paragraph block has no visible content (no runs, or a single
-* empty text run). Word collapses style-inherited spacing on empty
-* paragraphs (only direct `<w:pPr><w:spacing>` formatting survives) — see
-* eigenpal #402.
+* empty text run).
 */
 function isEmptyParagraph(block) {
 	if (block.runs.length === 0) return true;
@@ -68,16 +66,27 @@ function pageHasVisibleBodyContent(page, blocksById) {
 	}
 	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. An explicit `w:pStyle` selection is authored paragraph formatting,
-* so Word keeps the selected style's spacing even when the paragraph is empty.
+* 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?.spacingExplicit?.before) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.spacingExplicit?.before) return 0;
 	return value;
 }
 /**
@@ -87,9 +96,59 @@ function getSpacingBefore(block) {
 function getSpacingAfter(block) {
 	const value = block.attrs?.spacing?.after ?? 0;
 	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.after) return 0;
+	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 = [];
+	let totalHeight = 0;
+	let tallestUnit = 0;
+	let trailingSpacing = incomingSpacing;
+	for (let index = startIndex; index < endIndex; index++) {
+		const block = blocks[index];
+		const measure = measures[index];
+		if (block?.kind !== "paragraph" || measure?.kind !== "paragraph") return;
+		if (block.attrs?.keepNext === true || block.attrs?.keepLines === true || block.runs.some((run) => run.kind === "text" && run.footnoteRefId !== void 0)) return;
+		const leadingSpacing = Math.max(getSpacingBefore(block), trailingSpacing);
+		if (measure.lines.length === 0) {
+			if (leadingSpacing > 0) {
+				lineUnits.push(leadingSpacing);
+				totalHeight += leadingSpacing;
+				tallestUnit = Math.max(tallestUnit, leadingSpacing);
+			}
+		}
+		for (let lineIndex = 0; lineIndex < measure.lines.length; lineIndex++) {
+			const line = measure.lines[lineIndex];
+			if (!line) continue;
+			const unitHeight = measuredLineAdvance(line) + (lineIndex === 0 ? leadingSpacing : 0);
+			lineUnits.push(unitHeight);
+			totalHeight += unitHeight;
+			tallestUnit = Math.max(tallestUnit, unitHeight);
+		}
+		if (tallestUnit > availableHeight || totalHeight > availableHeight * columnCount) return;
+		trailingSpacing = getSpacingAfter(block);
+	}
+	if (totalHeight <= 0) return;
+	const columnsNeeded = (targetHeight) => {
+		let usedHeight = 0;
+		let usedColumns = 1;
+		for (const unitHeight of lineUnits) if (usedHeight > 0 && usedHeight + unitHeight > targetHeight) {
+			usedColumns += 1;
+			usedHeight = unitHeight;
+		} else usedHeight += unitHeight;
+		return usedColumns;
+	};
+	let lower = Math.max(tallestUnit, totalHeight / columnCount);
+	let upper = Math.min(totalHeight, availableHeight);
+	if (columnsNeeded(upper) > columnCount) return;
+	for (let iteration = 0; iteration < 32; iteration++) {
+		const middle = (lower + upper) / 2;
+		if (columnsNeeded(middle) <= columnCount) upper = middle;
+		else lower = middle;
+	}
+	return Math.ceil(upper * 1e3) / 1e3;
+}
 function hasWidowControl(block) {
 	return block.attrs?.widowControl !== false;
 }
@@ -123,6 +182,24 @@ function applyContextualSpacing(blocks) {
 	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyContextualSpacing(cell.blocks);
 	else if (block.kind === "textBox") applyContextualSpacing(block.content);
 }
+/** Suppress automatic inter-item spacing within one numbered sequence. */
+const applyAutomaticListSpacing = (blocks) => {
+	for (let index = 1; index < blocks.length; index++) {
+		const previous = blocks[index - 1];
+		const current = blocks[index];
+		if (previous?.kind !== "paragraph" || current?.kind !== "paragraph" || !continuesNumberedSequence(previous, current)) continue;
+		if (previous.attrs?.automaticSpacing?.after && previous.attrs.spacing) previous.attrs.spacing = {
+			...previous.attrs.spacing,
+			after: 0
+		};
+		if (current.attrs?.automaticSpacing?.before && current.attrs.spacing) current.attrs.spacing = {
+			...current.attrs.spacing,
+			before: 0
+		};
+	}
+	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyAutomaticListSpacing(cell.blocks);
+	else if (block.kind === "textBox") applyAutomaticListSpacing(block.content);
+};
 /**
 * Layout a document: convert blocks + measures into pages with positioned fragments.
 *
@@ -156,7 +233,8 @@ function layoutDocument(blocks, measures, options) {
 		pageSize: finalPageSize,
 		margins: finalMargins
 	};
-	if (options.columns !== void 0) finalConfig.columns = options.columns;
+	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 initialConfig = sectionConfigs.at(0) ?? bodyConfig;
@@ -170,6 +248,7 @@ function layoutDocument(blocks, measures, options) {
 		...options.sectionHeaderFooterRefs !== void 0 ? { sectionHeaderFooterRefs: options.sectionHeaderFooterRefs } : {}
 	});
 	applyContextualSpacing(blocks);
+	applyAutomaticListSpacing(blocks);
 	const keepNextChains = computeKeepNextChains(blocks);
 	const midChainIndices = getMidChainIndices(keepNextChains);
 	const blocksById = /* @__PURE__ */ new Map();
@@ -178,7 +257,7 @@ function layoutDocument(blocks, measures, options) {
 	let activeSectionMarginTop = initialConfig.margins.top;
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
-	let naturalPageAdvanceSinceRenderedBreak = false;
+	let naturalPageAdvanceSinceRenderedBreak = "none";
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
@@ -186,18 +265,20 @@ function layoutDocument(blocks, measures, options) {
 		if (hasPageBreakBefore(block)) paginator.forcePageBreak();
 		else if (hasRenderedPageBreak) {
 			const state = paginator.getCurrentState();
-			if (!(block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
+			if (!(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 = false;
+		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = "none";
 		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";
 		}
 		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
 			case "paragraph":
-				layoutParagraph(block, measure, paginator, paginator.getContentWidth(), options.footnoteHeightById);
+				layoutParagraph(block, measure, paginator, paginator.columnWidth, options.footnoteHeightById);
 				break;
 			case "table":
 				if (block.floating) layoutFloatingTable(block, measure, paginator, paginator.getContentWidth());
@@ -223,6 +304,23 @@ function layoutDocument(blocks, measures, options) {
 			case "sectionBreak": {
 				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
 				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx], sectionIdx + 1);
+				const nextColumns = nextSectionConfig.columns;
+				const nextBreakIndex = breakIndices[sectionIdx + 1] ?? blocks.length;
+				const nextBreak = blocks[nextBreakIndex];
+				const sectionEndsContinuously = nextBreakIndex === blocks.length || nextBreak?.kind === "sectionBreak" && nextBreak.type === "continuous";
+				if (nextColumns && sectionEndsContinuously) {
+					const state = paginator.getCurrentState();
+					const balancedHeight = balancedParagraphSectionHeight({
+						blocks,
+						measures,
+						startIndex: i + 1,
+						endIndex: nextBreakIndex,
+						incomingSpacing: state.trailingSpacing,
+						columnCount: nextColumns.count,
+						availableHeight: paginator.getAvailableHeight()
+					});
+					if (balancedHeight !== void 0) state.contentBottom = Math.min(state.contentBottom, state.cursorY + balancedHeight);
+				}
 				activeSectionMarginTop = nextSectionConfig.margins.top;
 				activeSectionPageHeight = nextSectionConfig.pageSize.h;
 				activeSectionMarginBottom = nextSectionConfig.margins.bottom;
@@ -232,8 +330,8 @@ function layoutDocument(blocks, measures, options) {
 			default: break;
 		}
 		const isVisibleBodyBlock = block.kind === "paragraph" ? !isEmptyParagraph(block) : block.kind !== "pageBreak" && block.kind !== "columnBreak" && block.kind !== "sectionBreak";
-		if (block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak") naturalPageAdvanceSinceRenderedBreak = false;
-		else if (isVisibleBodyBlock && paginator.getCurrentState().page.number > pageBeforeBlockLayout) naturalPageAdvanceSinceRenderedBreak = true;
+		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";
 	}
 	if (paginator.pages.length === 0) paginator.getCurrentState();
 	return {
@@ -428,9 +526,10 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		let x = paginator.getColumnX(columnIndex);
 		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
 		else if (block.justification === "right") x = x + paginator.columnWidth - measure.totalWidth;
-		else if (block.indent !== void 0) {
-			const leadingCellMargin = block.rows[0]?.cells[0]?.padding?.left ?? 0;
-			x += block.indent - leadingCellMargin;
+		else if (block.indent !== void 0) x += block.indent;
+		else {
+			const leadingCellMargin = block.rows.at(0)?.cells.at(0)?.padding?.left ?? 0;
+			x -= leadingCellMargin;
 		}
 		return x;
 	};
@@ -637,8 +736,10 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 		else if (spec === "center") y = baseY + (contentHeight - tableHeight) / 2;
 	}
 	if (!usedExplicitY) y = paginator.ensureFits(tableHeight).cursorY;
-	const minX = margins.left;
-	const maxX = margins.left + contentWidth - tableWidth;
+	const usesNumericOffset = floating?.tblpX !== void 0;
+	const clampToPage = floating?.horzAnchor === "page" || usesNumericOffset;
+	const minX = clampToPage ? 0 : margins.left;
+	const maxX = clampToPage ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
 	if (Number.isFinite(maxX)) x = Math.max(minX, Math.min(x, maxX));
 	const fragment = {
 		kind: "table",

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

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