@stll/folio-core 0.7.0 → 0.8.0

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

@@ -0,0 +1,15 @@
+import { TableCell, TableRow } from "../types.js";
+
+//#region src/layout-engine/measure/tableCellGrid.d.ts
+type TableCellGrid = {
+  occupiedColumnsByRow: ReadonlyMap<number, ReadonlySet<number>>;
+  sourceCellsByRow: ReadonlyMap<number, ReadonlyMap<number, TableCell>>;
+  sourceColumnsByCell: ReadonlyMap<TableCell, number>;
+};
+declare const buildTableCellGrid: (rows: readonly TableRow[], columnCount: number) => TableCellGrid;
+declare const getFirstAvailableColumn: (grid: TableCellGrid, rowIndex: number, startingColumn: number) => number;
+declare const getSourceCellAt: (grid: TableCellGrid, rowIndex: number, columnIndex: number) => TableCell | undefined;
+declare const getSourceCellColumn: (grid: TableCellGrid, cell: TableCell) => number | undefined;
+declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number) => number;
+//#endregion
+export { TableCellGrid, buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,62 @@
+//#region src/layout-engine/measure/tableCellGrid.ts
+const buildTableCellGrid = (rows, columnCount) => {
+	const occupiedColumnsByRow = /* @__PURE__ */ new Map();
+	const sourceCellsByRow = /* @__PURE__ */ new Map();
+	const sourceColumnsByCell = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), row.gridBefore ?? 0);
+		for (const cell of row.cells) {
+			const columnSpan = cell.colSpan ?? 1;
+			const rowSpan = cell.rowSpan ?? 1;
+			sourceColumnsByCell.set(cell, columnIndex);
+			const rowEnd = Math.min(rows.length, rowIndex + rowSpan);
+			const columnEnd = Math.min(columnCount, columnIndex + columnSpan);
+			for (let gridRowIndex = rowIndex; gridRowIndex < rowEnd; gridRowIndex++) {
+				const cellsByColumn = getOrCreateCellRow(sourceCellsByRow, gridRowIndex);
+				for (let gridColumnIndex = columnIndex; gridColumnIndex < columnEnd; gridColumnIndex++) cellsByColumn.set(gridColumnIndex, cell);
+			}
+			if (rowSpan > 1) for (let spannedRowIndex = rowIndex + 1; spannedRowIndex < rowIndex + rowSpan; spannedRowIndex++) {
+				const occupied = getOrCreateOccupiedRow(occupiedColumnsByRow, spannedRowIndex);
+				for (let columnOffset = 0; columnOffset < columnSpan; columnOffset++) occupied.add(columnIndex + columnOffset);
+			}
+			columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), columnIndex + columnSpan);
+		}
+	}
+	return {
+		occupiedColumnsByRow,
+		sourceCellsByRow,
+		sourceColumnsByCell
+	};
+};
+const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailableColumn(grid.occupiedColumnsByRow.get(rowIndex), startingColumn);
+const getSourceCellAt = (grid, rowIndex, columnIndex) => grid.sourceCellsByRow.get(rowIndex)?.get(columnIndex);
+const getSourceCellColumn = (grid, cell) => grid.sourceColumnsByCell.get(cell);
+const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
+	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
+	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
+	const aboveOwnsEdge = aboveBottom !== void 0 && aboveBottom.width !== 0 && aboveBottom.style !== "none" && aboveBottom.style !== "nil";
+	return (rowIndex === 0 || !aboveOwnsEdge ? cell?.borders?.top?.width ?? 0 : 0) + (cell?.borders?.bottom?.width ?? 0);
+};
+const firstAvailableColumn = (occupiedColumns, startingColumn) => {
+	let columnIndex = startingColumn;
+	while (occupiedColumns?.has(columnIndex)) columnIndex++;
+	return columnIndex;
+};
+const getOrCreateCellRow = (sourceCellsByRow, rowIndex) => {
+	const existing = sourceCellsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const cellsByColumn = /* @__PURE__ */ new Map();
+	sourceCellsByRow.set(rowIndex, cellsByColumn);
+	return cellsByColumn;
+};
+const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
+	const existing = occupiedColumnsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const occupiedColumns = /* @__PURE__ */ new Set();
+	occupiedColumnsByRow.set(rowIndex, occupiedColumns);
+	return occupiedColumns;
+};
+//#endregion
+export { buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,18 @@
+import { ParagraphBlock, ParagraphMeasure } from "../types.js";
+
+//#region src/layout-engine/measure/textBoxParagraphLayout.d.ts
+type TextBoxParagraphPlacement = {
+  leadingSpacing: number;
+  contentHeight: number;
+};
+type TextBoxParagraphLayout = {
+  placements: TextBoxParagraphPlacement[];
+  totalHeight: number;
+};
+/**
+ * Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+ * before/after spacing collapses to the larger value, matching body flow.
+ */
+declare function layoutTextBoxParagraphs(blocks: readonly ParagraphBlock[], measures: readonly ParagraphMeasure[]): TextBoxParagraphLayout;
+//#endregion
+export { TextBoxParagraphLayout, TextBoxParagraphPlacement, layoutTextBoxParagraphs };

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

@@ -0,0 +1,32 @@
+import { measuredLineRangeHeight } from "../lineFlow.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
+import { panic } from "better-result";
+//#region src/layout-engine/measure/textBoxParagraphLayout.ts
+/**
+* Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+* before/after spacing collapses to the larger value, matching body flow.
+*/
+function layoutTextBoxParagraphs(blocks, measures) {
+	if (blocks.length !== measures.length) panic("layoutTextBoxParagraphs: block and measure counts must match");
+	const placements = [];
+	let totalHeight = 0;
+	let trailingSpacing = 0;
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const measure = measures[index];
+		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		const contentHeight = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+		placements.push({
+			leadingSpacing,
+			contentHeight
+		});
+		totalHeight += leadingSpacing + contentHeight;
+		trailingSpacing = getParagraphSpacingAfter(block);
+	}
+	return {
+		placements,
+		totalHeight: totalHeight + trailingSpacing
+	};
+}
+//#endregion
+export { layoutTextBoxParagraphs };

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

@@ -35,7 +35,8 @@ type PaginatorOptions = {
    * its title page (typically extended top margin to clear an overflowing
    * first-page header) vs. its body pages. Pages 2+ use `margins`.
    */
-  firstPageMargins?: PageMargins; /** Column configuration (optional). */
+  firstPageMargins?: PageMargins; /** Per-section body margins used on even section pages. */
+  sectionEvenPageMargins?: (PageMargins | undefined)[]; /** Column configuration (optional). */
   columns?: ColumnLayout; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
   footnoteReservedHeights?: Map<number, number>; /** Header/footer refs by section index. */
   sectionHeaderFooterRefs?: PageHeaderFooterRefs[]; /** Callback when a new page is created. */

package/dist/layout-engine/paginator.js

@@ -47,7 +47,7 @@ function createPaginator(options) {
 	}
 	function currentPageUsesActiveLayout(state) {
 		if (pendingPageSize || pendingMargins) return false;
-		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number));
+		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number, state.page.sectionPageNumber ?? currentSectionPageNumber));
 	}
 	if (getContentHeight() <= 0) panic("Paginator: page size and margins yield no content area");
 	let columnWidths = calculateColumnWidths(pageSize.w, margins.left, margins.right, columns);
@@ -62,8 +62,9 @@ function createPaginator(options) {
 		if (getContentHeight() <= 0) panic("Paginator: section page size and margins yield no content area");
 		recalculateColumnWidths();
 	}
-	function getPageMargins(pageNumber) {
-		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+	function getPageMargins(pageNumber, sectionPageNumber) {
+		const evenMargins = sectionPageNumber % 2 === 0 ? options.sectionEvenPageMargins?.[currentSectionIndex] : void 0;
+		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...evenMargins ?? margins };
 		if (options.mirrorMargins === true && pageNumber % 2 === 0) return {
 			...pageMargins,
 			left: pageMargins.right,
@@ -77,7 +78,7 @@ function createPaginator(options) {
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1).left;
+		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1, 1).left;
 		for (let index = 0; index < columnIndex; index++) x += (columnWidths[index] ?? columnWidths[0] ?? 0) + gapAfterColumn(columns, index);
 		return x;
 	}
@@ -88,7 +89,7 @@ function createPaginator(options) {
 		if (pendingPageSize || pendingMargins) applyPendingLayout();
 		const pageNumber = pages.length + 1;
 		currentSectionPageNumber += 1;
-		const pageMargins = getPageMargins(pageNumber);
+		const pageMargins = getPageMargins(pageNumber, currentSectionPageNumber);
 		const topMargin = pageMargins.top;
 		const contentBottom = pageSize.h - pageMargins.bottom;
 		const footnoteHeight = options.footnoteReservedHeights?.get(pageNumber) ?? 0;
@@ -244,7 +245,7 @@ function createPaginator(options) {
 		const current = states.at(-1);
 		if (!current || current.page.fragments.length > 0 || current.cursorY !== current.topMargin) return false;
 		if (pendingPageSize || pendingMargins) applyPendingLayout();
-		const pageMargins = getPageMargins(current.page.number);
+		const pageMargins = getPageMargins(current.page.number, 1);
 		const topMargin = pageMargins.top;
 		const rawContentBottom = pageSize.h - pageMargins.bottom;
 		const footnoteHeight = options.footnoteReservedHeights?.get(current.page.number) ?? 0;

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

@@ -0,0 +1,22 @@
+import { ParagraphBlock, TextBoxBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphFrame.d.ts
+type ParagraphFrame = {
+  width?: number;
+  height?: number;
+  hSpace?: number;
+  vSpace?: number;
+  hAnchor?: "text" | "margin" | "page";
+  vAnchor?: "text" | "margin" | "page";
+  x?: number;
+  y?: number;
+  xAlign?: "left" | "center" | "right" | "inside" | "outside";
+  yAlign?: "top" | "center" | "bottom" | "inside" | "outside" | "inline";
+  wrap?: "around" | "auto" | "none" | "notBeside" | "through" | "tight";
+};
+declare function setParagraphFrame(block: ParagraphBlock, frame: ParagraphFrame): void;
+declare function getParagraphFrame(block: ParagraphBlock): ParagraphFrame | undefined;
+declare function markParagraphFrameTextBox(block: TextBoxBlock): void;
+declare function isParagraphFrameTextBox(block: TextBoxBlock): boolean;
+//#endregion
+export { ParagraphFrame, getParagraphFrame, isParagraphFrameTextBox, markParagraphFrameTextBox, setParagraphFrame };

package/dist/layout-engine/paragraphFrame.js

@@ -0,0 +1,17 @@
+//#region src/layout-engine/paragraphFrame.ts
+const paragraphFrames = /* @__PURE__ */ new WeakMap();
+const paragraphFrameTextBoxes = /* @__PURE__ */ new WeakSet();
+function setParagraphFrame(block, frame) {
+	paragraphFrames.set(block, frame);
+}
+function getParagraphFrame(block) {
+	return paragraphFrames.get(block);
+}
+function markParagraphFrameTextBox(block) {
+	paragraphFrameTextBoxes.add(block);
+}
+function isParagraphFrameTextBox(block) {
+	return paragraphFrameTextBoxes.has(block);
+}
+//#endregion
+export { getParagraphFrame, isParagraphFrameTextBox, markParagraphFrameTextBox, setParagraphFrame };

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

@@ -0,0 +1,7 @@
+import { FlowBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphSequence.d.ts
+declare const continuesNumberedSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+declare const continuesTabbedParagraphSequence: (previous: FlowBlock | undefined, current: FlowBlock) => boolean;
+//#endregion
+export { continuesNumberedSequence, continuesTabbedParagraphSequence };

package/dist/layout-engine/paragraphSequence.js

@@ -0,0 +1,25 @@
+//#region src/layout-engine/paragraphSequence.ts
+const 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;
+};
+const continuesTabbedParagraphSequence = (previous, current) => {
+	if (previous?.kind !== "paragraph" || current.kind !== "paragraph") return false;
+	if (!previous.attrs?.styleId || previous.attrs.styleId !== current.attrs?.styleId) return false;
+	if (!previous.runs.some((run) => run.kind === "tab") || !current.runs.some((run) => run.kind === "tab")) return false;
+	const previousIndent = previous.attrs.indent;
+	const currentIndent = current.attrs.indent;
+	if (previousIndent?.left !== currentIndent?.left || previousIndent?.right !== currentIndent?.right || previousIndent?.firstLine !== currentIndent?.firstLine || previousIndent?.hanging !== currentIndent?.hanging) return false;
+	const previousTabs = previous.attrs.tabs ?? [];
+	const currentTabs = current.attrs.tabs ?? [];
+	return previousTabs.length === currentTabs.length && previousTabs.every((tab, index) => {
+		const currentTab = currentTabs[index];
+		if (!currentTab) return false;
+		return tab.val === currentTab.val && tab.pos === currentTab.pos && tab.leader === currentTab.leader;
+	});
+};
+//#endregion
+export { continuesNumberedSequence, continuesTabbedParagraphSequence };

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

@@ -0,0 +1,17 @@
+import { ParagraphBlock } from "./types.js";
+
+//#region src/layout-engine/paragraphSpacing.d.ts
+/** Whether a paragraph has no visible run content. */
+declare function isEmptyParagraph(block: ParagraphBlock): boolean;
+/**
+ * Resolve leading paragraph spacing after applying the empty-paragraph
+ * inherited-spacing collapse rule.
+ */
+declare function getParagraphSpacingBefore(block: ParagraphBlock): number;
+/**
+ * Resolve trailing paragraph spacing after applying the empty-paragraph
+ * inherited-spacing collapse rule.
+ */
+declare function getParagraphSpacingAfter(block: ParagraphBlock): number;
+//#endregion
+export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };

package/dist/layout-engine/paragraphSpacing.js

@@ -0,0 +1,30 @@
+//#region src/layout-engine/paragraphSpacing.ts
+/** Whether a paragraph has no visible run content. */
+function isEmptyParagraph(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 === "";
+}
+/**
+* Resolve leading paragraph spacing after applying the empty-paragraph
+* inherited-spacing collapse rule.
+*/
+function getParagraphSpacingBefore(block) {
+	const value = block.attrs?.spacing?.before ?? 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.before) return 0;
+	return value;
+}
+/**
+* Resolve trailing paragraph spacing after applying the empty-paragraph
+* inherited-spacing collapse rule.
+*/
+function getParagraphSpacingAfter(block) {
+	const value = block.attrs?.spacing?.after ?? 0;
+	if (value === 0) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.hasDirectParagraphMarkFormatting && !block.attrs?.spacingExplicit?.after) return 0;
+	return value;
+}
+//#endregion
+export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };

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

@@ -0,0 +1,58 @@
+import { FlowBlock, Page } from "./types.js";
+
+//#region src/layout-engine/renderedBreakReconciliation.d.ts
+type RenderedBreakState = {
+  type: "noPageAdvance";
+} | {
+  type: "pageAdvance";
+  reason: "ordinary" | "reflowBoundary";
+};
+declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
+type ReconcileBeforeBlockOptions = {
+  state: RenderedBreakState;
+  block: FlowBlock;
+  previousBlock: FlowBlock | undefined;
+  page: Page;
+  blocksById: ReadonlyMap<string, FlowBlock>;
+  hasExplicitPageBreak: boolean;
+  renderedBreakNeedsSnap: boolean;
+};
+type BreakDecision = {
+  forcePageBreak: boolean;
+  state: RenderedBreakState;
+};
+/**
+ * Reconcile an authored or cached break before laying out one block.
+ *
+ * Cached markers describe a boundary at a paragraph, not an ordinal page.
+ * Natural reflow may therefore satisfy the marker before layout reaches it.
+ * Every marker consumes the accumulated advance state so later markers make
+ * independent decisions.
+ */
+declare const reconcileBreakBeforeBlock: ({
+  state,
+  block,
+  previousBlock,
+  page,
+  blocksById,
+  hasExplicitPageBreak,
+  renderedBreakNeedsSnap
+}: ReconcileBeforeBlockOptions) => BreakDecision;
+declare const recordReflowBoundary: (state: RenderedBreakState, crossedPageBoundary: boolean) => RenderedBreakState;
+type ReconcileAfterBlockOptions = {
+  state: RenderedBreakState;
+  block: FlowBlock;
+  pageNumberBefore: number;
+  pageNumberAfter: number;
+  previousPage: Page | undefined;
+};
+/** Record page movement caused by laying out a block, or reset at a structural break. */
+declare const reconcileAfterBlock: ({
+  state,
+  block,
+  pageNumberBefore,
+  pageNumberAfter,
+  previousPage
+}: ReconcileAfterBlockOptions) => RenderedBreakState;
+//#endregion
+export { INITIAL_RENDERED_BREAK_STATE, RenderedBreakState, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

package/dist/layout-engine/renderedBreakReconciliation.js

@@ -0,0 +1,63 @@
+import { isEmptyParagraph } from "./paragraphSpacing.js";
+import { continuesNumberedSequence, continuesTabbedParagraphSequence } from "./paragraphSequence.js";
+//#region src/layout-engine/renderedBreakReconciliation.ts
+const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
+/**
+* Reconcile an authored or cached break before laying out one block.
+*
+* Cached markers describe a boundary at a paragraph, not an ordinal page.
+* Natural reflow may therefore satisfy the marker before layout reaches it.
+* Every marker consumes the accumulated advance state so later markers make
+* independent decisions.
+*/
+const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }) => {
+	if (hasExplicitPageBreak) return {
+		forcePageBreak: true,
+		state: INITIAL_RENDERED_BREAK_STATE
+	};
+	if (block.kind !== "paragraph" || block.attrs?.renderedPageBreakBefore !== true) return {
+		forcePageBreak: false,
+		state
+	};
+	const markerAlreadySatisfied = pageStartsWithPreviousParagraphContinuation(page, previousBlock) || state.type === "pageAdvance" && state.reason === "reflowBoundary" || state.type === "pageAdvance" && isPaginationEmptyParagraph(block) || state.type === "pageAdvance" && (continuesNumberedSequence(previousBlock, block) || continuesTabbedParagraphSequence(previousBlock, block));
+	return {
+		forcePageBreak: renderedBreakNeedsSnap && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById),
+		state: INITIAL_RENDERED_BREAK_STATE
+	};
+};
+const recordReflowBoundary = (state, crossedPageBoundary) => crossedPageBoundary ? {
+	type: "pageAdvance",
+	reason: "reflowBoundary"
+} : state;
+/** Record page movement caused by laying out a block, or reset at a structural break. */
+const reconcileAfterBlock = ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }) => {
+	if (isStructuralBreak(block)) return INITIAL_RENDERED_BREAK_STATE;
+	if (!isVisibleBodyBlock(block) || pageNumberAfter <= pageNumberBefore) return state;
+	return {
+		type: "pageAdvance",
+		reason: previousPage?.fragments.some(({ blockId }) => blockId === block.id) ? "reflowBoundary" : "ordinary"
+	};
+};
+const isPaginationEmptyParagraph = (block) => block.runs.every((run) => {
+	if (run.kind === "text") return run.text.trim().length === 0;
+	return run.kind === "tab" || run.kind === "lineBreak";
+});
+const 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;
+};
+const 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);
+};
+const isStructuralBreak = (block) => block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak";
+const isVisibleBodyBlock = (block) => {
+	if (block.kind === "paragraph") return !isEmptyParagraph(block);
+	return !isStructuralBreak(block);
+};
+//#endregion
+export { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

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

@@ -1,9 +1,9 @@
 import { OutlineStyleAttr } from "../types/documentEnumValues.js";
-import { ImagePosition, ImageWrap, SdtProperties, SdtType, TableWidthType } from "@stll/docx-core/model";
+import { ImagePosition, ImageWrap, SdtProperties, SdtType, ShapeTextBody, TableWidthType } from "@stll/docx-core/model";
 
 //#region src/layout-engine/types.d.ts
 declare namespace types_d_exports {
-  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
+  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
 }
 /**
  * Unique identifier for a block in the document.
@@ -310,7 +310,8 @@ type ParagraphAttrs = {
    * source `w:pPr`. Word treats such a blank as authored and keeps its
    * inherited spacing; a bare empty paragraph still collapses that spacing.
    */
-  hasDirectParagraphFormatting?: boolean;
+  hasDirectParagraphFormatting?: boolean; /** Whether an empty paragraph carries direct formatting on its paragraph mark. */
+  hasDirectParagraphMarkFormatting?: boolean;
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
@@ -337,7 +338,8 @@ type ParagraphAttrs = {
   listIsBullet?: boolean;
   listMarkerHidden?: boolean;
   listMarkerFontFamily?: string;
-  listMarkerFontSize?: number;
+  listMarkerFontSize?: number; /** Horizontal alignment of the marker around the paragraph's list anchor. */
+  listMarkerAlignment?: "left" | "center" | "right";
   /**
    * `w:suff` (§17.9.25) — what follows the marker before body text.
    * `tab` (default) grows the marker to the next tab stop; `space` adds
@@ -443,6 +445,8 @@ type TableCell = {
 type TableRow = {
   id: BlockId;
   cells: TableCell[];
+  gridBefore?: number;
+  gridAfter?: number;
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
@@ -582,7 +586,8 @@ type TextBoxBlock = {
   kind: "textBox";
   id: BlockId; /** Width in pixels */
   width: number; /** Height in pixels (may be auto-calculated) */
-  height?: number; /** Fill/background color */
+  height?: number; /** Text fitting behavior */
+  autoFit?: ShapeTextBody["autoFit"]; /** Fill/background color */
   fillColor?: string; /** Border width in pixels */
   outlineWidth?: number; /** Border color */
   outlineColor?: string; /** Outline dash style, or `"none"` for an explicit no-outline. */
@@ -913,7 +918,8 @@ type LayoutOptions = {
    * overflowing first-page header without forcing pages 2+ to inherit the
    * same extension.
    */
-  firstPageMargins?: PageMargins; /** Body-level final section page size. */
+  firstPageMargins?: PageMargins; /** Per-section body margins used on even section pages. */
+  sectionEvenPageMargins?: (PageMargins | undefined)[]; /** Body-level final section page size. */
   finalPageSize?: {
     w: number;
     h: number;
@@ -1016,7 +1022,8 @@ type HeaderFooterContent = {
 /**
  * `true` when the image run is anchored at page-level coordinates instead of
  * participating in inline flow. Covers the OOXML floating wrap types
- * (`square`, `tight`, `through`, `behind`, `inFront`) and the legacy
+ * (`square`, `tight`, `through`, `behind`, `inFront`), explicitly positioned
+ * `topAndBottom` artwork, and the legacy
  * `displayMode === "float"` escape hatch used by ProseMirror nodes that
  * pre-date the wrap-type round-trip.
  *
@@ -1067,5 +1074,7 @@ declare function floatingTextBoxReservesBand(block: TextBoxFlowAttrs): boolean;
  * and the painter both consult this so their line count and `white-space` agree.
  */
 declare function tableColumnsArePinned(table: TableBlock): boolean;
+/** Return the leading visual offset for a row with omitted grid columns. */
+declare const getTableRowLeadingWidth: (row: TableRow, columnWidths: readonly number[]) => number;
 //#endregion
-export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };
+export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };

package/dist/layout-engine/types.js

@@ -9,6 +9,7 @@ var types_exports = /* @__PURE__ */ __exportAll({
 	FOOTNOTE_SEPARATOR_HEIGHT: () => 12,
 	floatingTextBoxReservesBand: () => floatingTextBoxReservesBand,
 	floatingTextBoxWrapsText: () => floatingTextBoxWrapsText,
+	getTableRowLeadingWidth: () => getTableRowLeadingWidth,
 	isFloatingImageRun: () => isFloatingImageRun,
 	isFloatingTextBoxBlock: () => isFloatingTextBoxBlock,
 	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun,
@@ -46,7 +47,8 @@ const FOOTNOTE_FALLBACK_LINE_HEIGHT = 13;
 /**
 * `true` when the image run is anchored at page-level coordinates instead of
 * participating in inline flow. Covers the OOXML floating wrap types
-* (`square`, `tight`, `through`, `behind`, `inFront`) and the legacy
+* (`square`, `tight`, `through`, `behind`, `inFront`), explicitly positioned
+* `topAndBottom` artwork, and the legacy
 * `displayMode === "float"` escape hatch used by ProseMirror nodes that
 * pre-date the wrap-type round-trip.
 *
@@ -55,6 +57,7 @@ const FOOTNOTE_FALLBACK_LINE_HEIGHT = 13;
 */
 const isFloatingImageRun = (run) => {
 	const wrapType = run.wrapType;
+	if (wrapType === "topAndBottom" && run.position !== void 0) return true;
 	if (wrapType === "square" || wrapType === "tight" || wrapType === "through" || wrapType === "behind" || wrapType === "inFront") return true;
 	return run.displayMode === "float";
 };
@@ -114,5 +117,15 @@ function tableColumnsArePinned(table) {
 	if (table.layout === "fixed") return true;
 	return table.widthType === "dxa" || table.widthType === "pct";
 }
+const tableRowOwnsNestedGrid = (row) => {
+	const cell = row.cells.length === 1 ? row.cells.at(0) : void 0;
+	if (!cell?.blocks.some((block) => block.kind === "table")) return false;
+	return cell.blocks.every((block) => block.kind === "table" || block.kind === "paragraph" && block.runs.length === 0);
+};
+/** Return the leading visual offset for a row with omitted grid columns. */
+const getTableRowLeadingWidth = (row, columnWidths) => {
+	if (tableRowOwnsNestedGrid(row)) return 0;
+	return columnWidths.slice(0, row.gridBefore ?? 0).reduce((sum, columnWidth) => sum + columnWidth, 0);
+};
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };

package/dist/layout-painter/renderPage.js

@@ -1188,12 +1188,12 @@ function applySectionHeaderFooterOptions(page, pageOptions, options) {
 	const useEven = refs.evenAndOddHeaders === true && sectionPageNumber % 2 === 0;
 	const headerRId = (() => {
 		if (useFirst) return refs.headerFirst;
-		if (useEven && refs.headerEven) return refs.headerEven;
+		if (useEven) return refs.headerEven;
 		return refs.headerDefault;
 	})();
 	const footerRId = (() => {
 		if (useFirst) return refs.footerFirst;
-		if (useEven && refs.footerEven) return refs.footerEven;
+		if (useEven) return refs.footerEven;
 		return refs.footerDefault;
 	})();
 	if (headerRId) {

package/dist/layout-painter/renderParagraph.js

@@ -5,7 +5,7 @@ import { calculateTabWidth } from "../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox } from "../utils/rotationBoundingBox.js";
 import { hasCjk, segmentByScript } from "../utils/scriptSegments.js";
 import { isFloatingImageRun } from "../layout-engine/types.js";
-import { getListMarkerInlineWidth } from "../layout-engine/measure/listMarkerWidth.js";
+import { getListMarkerInlineWidth, getListMarkerVisualOffset } from "../layout-engine/measure/listMarkerWidth.js";
 import { applySdtDataAttrs } from "./sdtBoundary.js";
 import { applyImageVisualAttrs, hasImageVisualAttrs, wrapImageWithCrop } from "./renderImage.js";
 import { ommlToMathml } from "../docx/mathToMathml.js";
@@ -1351,7 +1351,7 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			}
 			const markerFontFamily = block.attrs.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? block.attrs.defaultFontFamily;
 			const markerFontSize = block.attrs.listMarkerFontSize ?? firstTextRun?.fontSize ?? block.attrs.defaultFontSize;
-			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
+			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), getListMarkerVisualOffset(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
 			const markerMarginLeft = markerStart - Math.min(indentLeft, 0);
 			if (markerMarginLeft < 0) marker.style.marginLeft = `${markerMarginLeft}px`;
 			lineEl.prepend(marker);
@@ -1362,13 +1362,13 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 }
 /**
 * Render a list marker element as an inline-block at the start of the first
-* body line. `minWidth` (from `getListMarkerInlineWidth`) sizes the marker
+* body line. `inlineWidth` (from `getListMarkerInlineWidth`) sizes the marker
 * so the body text aligns at the next tab stop per ECMA-376 §17.9.25 —
 * this honours `w:suff` (`tab` / `space` / `nothing`) and the document's
 * tab grid. Long markers like "1.1.1." therefore grow to the next stop
 * instead of butting against the body text.
 */
-function renderListMarker(marker, minWidth, doc, fontFamily, fontSize, revision, secondSlotOffsetTwips) {
+function renderListMarker(marker, inlineWidth, visualOffset, doc, fontFamily, fontSize, revision, secondSlotOffsetTwips) {
 	const span = doc.createElement("span");
 	span.className = "layout-list-marker";
 	span.style.display = "inline-block";
@@ -1377,7 +1377,8 @@ function renderListMarker(marker, minWidth, doc, fontFamily, fontSize, revision,
 	span.style.textAlign = "left";
 	span.style.textAlignLast = "left";
 	span.style.boxSizing = "border-box";
-	if (minWidth > 0) span.style.minWidth = `${minWidth}px`;
+	span.style.width = `${inlineWidth}px`;
+	if (visualOffset !== 0) span.style.transform = `translateX(${visualOffset}px)`;
 	if (revision) {
 		const authorIdx = getAuthorColorIdx(revision.author ?? "");
 		const authorColor = AUTHOR_COLORS[authorIdx];