@stll/folio-core 0.4.0 → 0.5.0

package/dist/layout-engine/index.js

@@ -1,5 +1,6 @@
+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 } from "./types.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 { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { createPaginator } from "./paginator.js";
 import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
@@ -51,25 +52,42 @@ 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 ?? "") === "";
+	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;
 }
 /**
 * Get spacing before a paragraph block. Empty paragraphs whose
-* `before` was inherited from a paragraph style (not set inline) collapse
-* to zero — Word fidelity for incidental empty separators.
+* `before` came only from the implicit default paragraph style collapse to
+* zero. An explicit `w:pStyle` selection is authored paragraph formatting,
+* so Word keeps the selected style's spacing even when the paragraph is empty.
 */
 function getSpacingBefore(block) {
 	const value = block.attrs?.spacing?.before ?? 0;
-	if (isEmptyParagraph(block) && !block.attrs?.spacingExplicit?.before) return 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.before) return 0;
 	return value;
 }
 /**
-* Get spacing after a paragraph block. Same empty-paragraph collapse rule
-* as `getSpacingBefore`.
+* 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 (isEmptyParagraph(block) && !block.attrs?.spacingExplicit?.after) return 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.after) return 0;
 	return value;
 }
 function hasWidowControl(block) {
@@ -78,9 +96,10 @@ function hasWidowControl(block) {
 /**
 * Apply contextual spacing suppression (OOXML §17.3.1.9).
 *
-* When two consecutive paragraph blocks both have `contextualSpacing: true`
-* and share the same `styleId`, the spaceAfter of the first paragraph and
-* the spaceBefore of the second paragraph are suppressed (set to 0).
+* Contextual spacing applies independently to each paragraph: suppress the
+* current paragraph's spaceAfter when it opts in, and the next paragraph's
+* spaceBefore when it opts in, provided both paragraphs share a style. Two
+* absent style ids both refer to the document's default paragraph style.
 *
 * This mutates the block attrs in-place before layout runs.
 */
@@ -91,16 +110,15 @@ function applyContextualSpacing(blocks) {
 		if (curr.kind !== "paragraph" || next.kind !== "paragraph") continue;
 		const currAttrs = curr.attrs;
 		const nextAttrs = next.attrs;
-		if (currAttrs?.contextualSpacing && nextAttrs?.contextualSpacing && currAttrs.styleId && currAttrs.styleId === nextAttrs.styleId) {
-			if (currAttrs.spacing) currAttrs.spacing = {
-				...currAttrs.spacing,
-				after: 0
-			};
-			if (nextAttrs.spacing) nextAttrs.spacing = {
-				...nextAttrs.spacing,
-				before: 0
-			};
-		}
+		if (currAttrs?.styleId !== nextAttrs?.styleId) continue;
+		if (currAttrs?.contextualSpacing && currAttrs.spacing) currAttrs.spacing = {
+			...currAttrs.spacing,
+			after: 0
+		};
+		if (nextAttrs?.contextualSpacing && nextAttrs.spacing) nextAttrs.spacing = {
+			...nextAttrs.spacing,
+			before: 0
+		};
 	}
 	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);
@@ -145,6 +163,7 @@ function layoutDocument(blocks, measures, options) {
 	const paginator = createPaginator({
 		pageSize: initialConfig.pageSize,
 		margins: initialConfig.margins,
+		...options.mirrorMargins === true ? { mirrorMargins: true } : {},
 		...options.firstPageMargins !== void 0 ? { firstPageMargins: options.firstPageMargins } : {},
 		columns: initialConfig.columns ?? DEFAULT_COLUMNS,
 		...options.footnoteReservedHeights !== void 0 ? { footnoteReservedHeights: options.footnoteReservedHeights } : {},
@@ -153,21 +172,29 @@ function layoutDocument(blocks, measures, options) {
 	applyContextualSpacing(blocks);
 	const keepNextChains = computeKeepNextChains(blocks);
 	const midChainIndices = getMidChainIndices(keepNextChains);
+	const blocksById = /* @__PURE__ */ new Map();
+	for (const block of blocks) blocksById.set(String(block.id), block);
 	let sectionIdx = 0;
 	let activeSectionMarginTop = initialConfig.margins.top;
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
+	let naturalPageAdvanceSinceRenderedBreak = false;
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
+		const hasRenderedPageBreak = block.kind === "paragraph" && block.attrs?.renderedPageBreakBefore === true;
 		if (hasPageBreakBefore(block)) paginator.forcePageBreak();
+		else if (hasRenderedPageBreak) {
+			const state = paginator.getCurrentState();
+			if (!(block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
+		}
+		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = false;
 		const chain = keepNextChains.get(i);
 		if (chain && !midChainIndices.has(i)) {
 			const chainHeight = calculateChainHeight(chain, blocks, measures);
-			const state = paginator.getCurrentState();
-			const availableHeight = paginator.getAvailableHeight();
-			if (chainHeight <= state.contentBottom - state.topMargin && chainHeight > availableHeight && state.page.fragments.length > 0) paginator.forcePageBreak();
+			paginator.ensureFits(chainHeight);
 		}
+		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
 			case "paragraph":
 				layoutParagraph(block, measure, paginator, paginator.getContentWidth(), options.footnoteHeightById);
@@ -204,6 +231,9 @@ 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 (paginator.pages.length === 0) paginator.getCurrentState();
 	return {
@@ -397,7 +427,10 @@ function layoutTable(block, measure, paginator) {
 		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) x += block.indent;
+		else if (block.indent !== void 0) {
+			const leadingCellMargin = block.rows[0]?.cells[0]?.padding?.left ?? 0;
+			x += block.indent - leadingCellMargin;
+		}
 		return x;
 	};
 	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
@@ -531,6 +564,7 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 	let baseY = margins.top;
 	if (floating?.horzAnchor === "page") baseX = 0;
 	if (floating?.vertAnchor === "page") baseY = 0;
+	else if (floating?.vertAnchor === "text") baseY = state.cursorY;
 	let x = paginator.getColumnX(state.columnIndex);
 	if (floating?.tblpX !== void 0) x = baseX + floating.tblpX;
 	else if (floating?.tblpXSpec) {
@@ -649,6 +683,35 @@ function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPag
 		state.page.fragments.push(fragment);
 		return;
 	}
+	if (block.position !== void 0) {
+		const state = paginator.getCurrentState();
+		const horizontal = block.position.horizontal;
+		const x = horizontal ? bandFragmentX(horizontal, {
+			pageWidth: state.page.size.w,
+			marginLeft: state.page.margins.left,
+			marginRight: state.page.margins.right,
+			boxWidth: measure.width
+		}) : paginator.getColumnX(state.columnIndex);
+		const vertical = block.position.vertical;
+		const y = isPageFrameRelativeAnchor(vertical?.relativeTo) ? state.topMargin + bandTopContentY(vertical, {
+			pageHeight: sectionPageHeight,
+			marginTop: sectionMarginTop,
+			marginBottom: sectionMarginBottom,
+			boxHeight: measure.height
+		}) : state.cursorY + emuToPixels(vertical?.posOffset ?? 0);
+		const fragment = {
+			kind: "textBox",
+			blockId: block.id,
+			x,
+			y,
+			width: measure.width,
+			height: measure.height,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+		};
+		state.page.fragments.push(fragment);
+		return;
+	}
 	const state = paginator.ensureFits(measure.height);
 	const fragment = {
 		kind: "textBox",
@@ -715,4 +778,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 };
+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 };

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

@@ -2,28 +2,33 @@ import { FlowBlock, Measure } from "./types.js";
 
 //#region src/layout-engine/keep-together.d.ts
 /**
- * A chain of consecutive keepNext paragraphs.
+ * A chain of keepNext-linked paragraphs, including empty separators Word
+ * carries through to the next paragraph with visible content.
  */
 type KeepNextChain = {
-  /** Index of the first paragraph in the chain. */startIndex: number; /** Index of the last paragraph in the chain. */
-  endIndex: number; /** All paragraph indices in the chain. */
+  /** Index of the first paragraph in the chain. */startIndex: number; /** Index of the last keepNext or pass-through empty member. */
+  endIndex: number; /** All keepNext and pass-through empty paragraph indices in the chain. */
   memberIndices: number[]; /** Index of the anchor paragraph (first non-keepNext after chain), or -1 if none. */
   anchorIndex: number;
 };
 /**
  * Pre-scan blocks to find all keepNext chains.
  *
- * A keepNext chain is a sequence of consecutive paragraphs with keepNext=true,
- * followed by an anchor paragraph (the first non-keepNext paragraph).
- * The entire chain must stay on the same page as the anchor's first line.
+ * 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.
  *
  * Returns a map from chain start index to chain info.
  */
 declare function computeKeepNextChains(blocks: FlowBlock[]): Map<number, KeepNextChain>;
 /**
- * Calculate the total height needed to keep a chain together.
+ * Calculate the height needed to keep consecutive paragraph boundaries from
+ * breaking across pages.
  *
- * Includes all chain members plus the first line of the anchor paragraph.
+ * Single-line and `keepLines` members are indivisible, so the reservation must
+ * continue through them to the anchor's first line. A multi-line member without
+ * `keepLines` may itself split; only its first line is needed to satisfy the
+ * preceding member's `keepNext`, and the chain can stop there.
  */
 declare function calculateChainHeight(chain: KeepNextChain, blocks: FlowBlock[], measures: Measure[]): number;
 /**

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

@@ -1,10 +1,16 @@
 //#region src/layout-engine/keep-together.ts
+function isVisuallyEmptyParagraph(block) {
+	if (block.runs.length === 0) return true;
+	if (block.runs.length !== 1) return false;
+	const run = block.runs.at(0);
+	return run?.kind === "text" && run.text === "";
+}
 /**
 * Pre-scan blocks to find all keepNext chains.
 *
-* A keepNext chain is a sequence of consecutive paragraphs with keepNext=true,
-* followed by an anchor paragraph (the first non-keepNext paragraph).
-* The entire chain must stay on the same page as the anchor's first line.
+* 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.
 *
 * Returns a map from chain start index to chain info.
 */
@@ -22,7 +28,8 @@ function computeKeepNextChains(blocks) {
 			const nextBlock = blocks[j];
 			if (nextBlock.kind === "sectionBreak" || nextBlock.kind === "pageBreak" || nextBlock.kind === "columnBreak") break;
 			if (nextBlock.kind !== "paragraph") break;
-			if (nextBlock.attrs?.keepNext) {
+			const nextPara = nextBlock;
+			if (nextPara.attrs?.keepNext || isVisuallyEmptyParagraph(nextPara)) {
 				memberIndices.push(j);
 				endIndex = j;
 				processed.add(j);
@@ -44,30 +51,38 @@ function computeKeepNextChains(blocks) {
 	return chains;
 }
 /**
-* Calculate the total height needed to keep a chain together.
+* Calculate the height needed to keep consecutive paragraph boundaries from
+* breaking across pages.
 *
-* Includes all chain members plus the first line of the anchor paragraph.
+* Single-line and `keepLines` members are indivisible, so the reservation must
+* continue through them to the anchor's first line. A multi-line member without
+* `keepLines` may itself split; only its first line is needed to satisfy the
+* preceding member's `keepNext`, and the chain can stop there.
 */
 function calculateChainHeight(chain, blocks, measures) {
-	let totalHeight = 0;
-	for (const memberIndex of chain.memberIndices) {
-		const block = blocks[memberIndex];
-		const measure = measures[memberIndex];
-		if (!block || !measure || block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
-		const para = block;
-		const paraMeasure = measure;
-		const spacingBefore = para.attrs?.spacing?.before ?? 0;
-		totalHeight += spacingBefore;
-		totalHeight += paraMeasure.totalHeight;
-		const spacingAfter = para.attrs?.spacing?.after ?? 0;
-		totalHeight += spacingAfter;
-	}
-	if (chain.anchorIndex !== -1) {
-		const anchorMeasure = measures[chain.anchorIndex];
-		if (anchorMeasure?.kind === "paragraph") {
-			const anchorPara = anchorMeasure;
-			if (anchorPara.lines.length > 0) totalHeight += anchorPara.lines[0].lineHeight;
-		}
+	const firstMemberIndex = chain.memberIndices.at(0);
+	if (firstMemberIndex === void 0) return 0;
+	const firstBlock = blocks[firstMemberIndex];
+	const firstMeasure = measures[firstMemberIndex];
+	if (firstBlock?.kind !== "paragraph" || firstMeasure?.kind !== "paragraph") return 0;
+	let totalHeight = (firstBlock.attrs?.spacing?.before ?? 0) + firstMeasure.totalHeight;
+	let trailingSpacing = firstBlock.attrs?.spacing?.after ?? 0;
+	const successorIndices = [...chain.memberIndices.slice(1)];
+	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
+	for (let index = 0; index < successorIndices.length; index++) {
+		const successorIndex = successorIndices[index];
+		if (successorIndex === void 0) continue;
+		const successorBlock = blocks[successorIndex];
+		const successorMeasure = measures[successorIndex];
+		if (successorBlock?.kind !== "paragraph" || successorMeasure?.kind !== "paragraph") return totalHeight;
+		totalHeight += Math.max(trailingSpacing, successorBlock.attrs?.spacing?.before ?? 0);
+		const firstLine = successorMeasure.lines.at(0);
+		if (!firstLine) return totalHeight;
+		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;
+		const isSplittable = successorMeasure.lines.length > 1 && !successorBlock.attrs?.keepLines;
+		if (isAnchor || isSplittable) return totalHeight + firstLine.lineHeight;
+		totalHeight += successorMeasure.totalHeight;
+		trailingSpacing = successorBlock.attrs?.spacing?.after ?? 0;
 	}
 	return totalHeight;
 }

package/dist/layout-engine/layoutInstrumentation.d.ts

@@ -5,7 +5,12 @@ type LayoutRunReason = "font-ready" | "initial" | "layout-input" | "manual" | "t
 type LayoutPhase = "flow-blocks" | "header-footer" | "initial-fonts" | "layout-document" | "measure-blocks" | "render-pages";
 type HiddenEditorStateReason = "external-document" | "mount";
 type HiddenEditorPhase = "editor-state" | "editor-view" | "to-prose-doc" | "update-state";
+type DocumentLoadPhase = "docx-parse";
 type LayoutInstrumentation = {
+  onDocumentLoadPhase?: (event: {
+    durationMs: number;
+    phase: DocumentLoadPhase;
+  }) => void;
   onHiddenEditorPhase?: (event: {
     durationMs: number;
     phase: HiddenEditorPhase;
@@ -21,6 +26,9 @@ type LayoutInstrumentation = {
     message: string;
     reason: LayoutRunReason;
   }) => void;
+  onLayoutStart?: (event: {
+    reason: LayoutRunReason;
+  }) => void;
   onLayoutPhase?: (event: {
     durationMs: number;
     phase: LayoutPhase;
@@ -42,9 +50,11 @@ declare global {
 declare function recordMeasureBlock(blockIndex: number, block: FlowBlock): void;
 declare function recordMeasureBlockError(blockIndex: number, block: FlowBlock, error: unknown): void;
 declare function recordLayoutComplete(reason?: LayoutRunReason): void;
+declare function recordLayoutStart(reason: LayoutRunReason): void;
 declare function recordLayoutError(reason: LayoutRunReason, error: unknown): void;
 declare function recordLayoutPhase(reason: LayoutRunReason, phase: LayoutPhase, durationMs: number): void;
 declare function recordHiddenEditorStateCreate(reason: HiddenEditorStateReason): void;
 declare function recordHiddenEditorPhase(reason: HiddenEditorStateReason, phase: HiddenEditorPhase, durationMs: number): void;
+declare function recordDocumentLoadPhase(phase: DocumentLoadPhase, durationMs: number): void;
 //#endregion
-export { HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };
+export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/layoutInstrumentation.js

@@ -15,6 +15,9 @@ function recordMeasureBlockError(blockIndex, block, error) {
 function recordLayoutComplete(reason = "manual") {
 	globalThis.__folioLayoutInstrumentation?.onLayoutComplete?.({ reason });
 }
+function recordLayoutStart(reason) {
+	globalThis.__folioLayoutInstrumentation?.onLayoutStart?.({ reason });
+}
 function recordLayoutError(reason, error) {
 	const message = error instanceof Error ? error.message : String(error);
 	globalThis.__folioLayoutInstrumentation?.onLayoutError?.({
@@ -39,5 +42,11 @@ function recordHiddenEditorPhase(reason, phase, durationMs) {
 		reason
 	});
 }
+function recordDocumentLoadPhase(phase, durationMs) {
+	globalThis.__folioLayoutInstrumentation?.onDocumentLoadPhase?.({
+		durationMs,
+		phase
+	});
+}
 //#endregion
-export { recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };
+export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

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

@@ -1,6 +1,7 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
 import { bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
 //#region src/layout-engine/measure/measureBlocks.ts
@@ -80,8 +81,8 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
 	return spacingBefore + maxImageHeight + spacingAfter;
 }
-function getTableCellVerticalBorderHeight(cell) {
-	return (cell?.borders?.top?.width ?? 0) + (cell?.borders?.bottom?.width ?? 0);
+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;
@@ -118,6 +119,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			while (occupied.has(colIdx)) colIdx++;
 		}
 	}
+	const columnsPinned = tableColumnsArePinned(tableBlock);
 	const rows = tableBlock.rows.map((row, rowIdx) => {
 		let columnIndex = 0;
 		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
@@ -133,7 +135,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 				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);
-				const measureWidth = cell.noWrap ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
+				const measureWidth = cell.noWrap === true && !columnsPinned ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
 				const cellMeasure = {
 					blocks: cell.blocks.map((b) => measureBlock(b, measureWidth, void 0, void 0, fieldValues)),
 					width: cellWidth,
@@ -160,6 +162,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
+		let maxBorderHeight = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
 			const cell = row.cells[cellIdx];
 			const sourceCell = sourceRowCells?.[cellIdx];
@@ -173,12 +176,14 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const padTop = sourceCell?.padding?.top ?? DEFAULT_CELL_PADDING_Y;
 			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
 			cell.height += padTop + padBottom;
-			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + getTableCellVerticalBorderHeight(sourceCell));
+			const borderHeight = getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0);
+			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
+			maxBorderHeight = Math.max(maxBorderHeight, 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);
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxBorderHeight);
 		else row.height = maxCellHeightWithBorders;
 	}
 	const totalHeight = rows.reduce((h, r) => h + r.height, 0);
@@ -197,6 +202,7 @@ function perBlockNumberValue(value, blockIndex, fallback) {
 }
 function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
 	const zones = [];
+	const textBoxGroupAnchors = /* @__PURE__ */ new Map();
 	const defaultMarginTop = Array.isArray(marginTop) ? marginTop[0] ?? 0 : marginTop;
 	const pageHeightInput = pageGeometry?.pageHeight ?? 0;
 	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
@@ -286,28 +292,31 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		const block = blocks[blockIndex];
 		if (block.kind !== "textBox") continue;
 		const tb = block;
-		if (!floatingTextBoxReservesBand(tb)) continue;
+		if (!floatingTextBoxReservesBand(tb) || tb.position === void 0) continue;
 		const v = tb.position?.vertical;
-		if (!isPageFrameRelativeAnchor(v?.relativeTo)) continue;
 		const height = measureTextBoxBlock(tb).height;
 		const distTop = tb.distTop ?? 0;
 		const distBottom = tb.distBottom ?? 0;
 		const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
-		const rawTop = bandTopContentY(v, {
+		const pageFrameRelative = isPageFrameRelativeAnchor(v?.relativeTo);
+		const rawTop = pageFrameRelative ? bandTopContentY(v, {
 			pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
 			marginTop: blockMarginTop,
 			marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
 			boxHeight: height
-		});
+		}) : emuToPixels(v?.posOffset ?? 0);
 		const bottomY = rawTop + height + distBottom;
 		if (bottomY <= 0) continue;
+		const groupId = getTextBoxGroupId(tb);
+		const anchorBlockIndex = groupId ? textBoxGroupAnchors.get(groupId) ?? blockIndex : blockIndex;
+		if (groupId && !textBoxGroupAnchors.has(groupId)) textBoxGroupAnchors.set(groupId, blockIndex);
 		zones.push({
 			leftMargin: 0,
 			rightMargin: 0,
 			topY: Math.max(0, rawTop - distTop),
 			bottomY,
-			anchorBlockIndex: blockIndex,
-			isMarginRelative: true,
+			anchorBlockIndex,
+			...pageFrameRelative ? { isMarginRelative: true } : {},
 			fullWidthBlock: true
 		});
 	}
@@ -367,14 +376,15 @@ function measureTextBoxBlock(tb, fieldValues) {
 	};
 }
 /**
-* `true` for a section break that starts a new page (`nextPage`/`evenPage`/
-* `oddPage`, or an unspecified type, which the layout treats as `nextPage`).
-* A `continuous` break stays on the current page, so it does not open a fresh
-* page frame. Used by `measureBlocks` to reset the running Y for a page-pinned
-* band that lands right after the break. eigenpal #694.
+* `true` for a section break that explicitly starts a new page
+* (`nextPage`/`evenPage`/`oddPage`). An absent type follows
+* `scheduleSectionBreak` and stays continuous, so measurement must retain any
+* active exclusion zones across it. Used by `measureBlocks` to reset the
+* running Y for a page-pinned band that lands right after the break.
+* eigenpal #694.
 */
 function isNextPageSectionBreak(block) {
-	return block.kind === "sectionBreak" && block.type !== "continuous";
+	return block.kind === "sectionBreak" && block.type !== void 0 && block.type !== "continuous";
 }
 /**
 * Measure all blocks with floating image support.