@stll/folio-core 0.6.1 → 0.8.0

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,
@@ -72,11 +73,12 @@ function createPaginator(options) {
 		return pageMargins;
 	}
 	let columnRegionTop = margins.top;
+	let columnRegionMaxBottom = margins.top;
 	/**
 	* 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;
 	}
@@ -87,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;
@@ -114,6 +116,7 @@ function createPaginator(options) {
 		pages.push(page);
 		states.push(state);
 		columnRegionTop = topMargin;
+		columnRegionMaxBottom = topMargin;
 		if (options.onNewPage) options.onNewPage(state);
 		return state;
 	}
@@ -143,6 +146,7 @@ function createPaginator(options) {
 	*/
 	function advanceColumn(state) {
 		if (state.columnIndex < columns.count - 1) {
+			columnRegionMaxBottom = Math.max(columnRegionMaxBottom, state.cursorY);
 			state.columnIndex += 1;
 			state.cursorY = columnRegionTop;
 			state.trailingSpacing = 0;
@@ -159,7 +163,7 @@ function createPaginator(options) {
 		let state = getCurrentState();
 		const safeHeight = Number.isFinite(height) && height > 0 ? height : 0;
 		while (!fits(safeHeight, state)) {
-			if (safeHeight > state.contentBottom - state.topMargin) {
+			if (safeHeight > state.contentBottom - columnRegionTop) {
 				if (state.cursorY !== state.topMargin) state = advanceColumn(state);
 				return state;
 			}
@@ -241,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;
@@ -276,12 +280,17 @@ function createPaginator(options) {
 	* column advancement stays below existing content (for continuous breaks).
 	*/
 	function updateColumns(newColumns) {
+		const previousColumnCount = columns.count;
+		const state = getCurrentState();
+		const previousRegionBottom = Math.max(columnRegionMaxBottom, state.cursorY);
 		columns = newColumns;
 		recalculateColumnWidths();
-		const state = getCurrentState();
 		if (columns.count > 1) state.page.columns = { ...columns };
 		else delete state.page.columns;
+		state.contentBottom = state.rawContentBottom - state.footnoteHeight;
+		if (previousColumnCount > 1) state.cursorY = previousRegionBottom;
 		columnRegionTop = state.cursorY;
+		columnRegionMaxBottom = state.cursorY;
 		state.columnIndex = 0;
 	}
 	function updatePageLayout(newPageSize, newMargins, applyImmediately = true) {

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.
@@ -286,8 +286,13 @@ type ListNumPr = {
  * Paragraph block attributes.
  */
 type ParagraphAttrs = {
-  alignment?: "left" | "center" | "right" | "justify";
-  spacing?: ParagraphSpacing;
+  alignment?: "left" | "center" | "right" | "justify"; /** OOXML outline level (`w:outlineLvl`), where zero is the top level. */
+  outlineLevel?: number;
+  spacing?: ParagraphSpacing; /** Spacing sides resolved from OOXML automatic paragraph spacing. */
+  automaticSpacing?: {
+    before?: boolean;
+    after?: boolean;
+  };
   /**
    * Tracks which `spacing` sides came from inline (`<w:pPr><w:spacing>`)
    * formatting versus inherited via paragraph style. Word collapses
@@ -300,6 +305,13 @@ type ParagraphAttrs = {
     before?: boolean;
     after?: boolean;
   };
+  /**
+   * Whether an empty paragraph carries direct paragraph formatting in its
+   * 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; /** Whether an empty paragraph carries direct formatting on its paragraph mark. */
+  hasDirectParagraphMarkFormatting?: boolean;
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
@@ -319,13 +331,15 @@ type ParagraphAttrs = {
   borders?: ParagraphBorders;
   shading?: string;
   tabs?: TabStop[]; /** Render structural empty paragraphs as zero-height anchors. */
-  suppressEmptyParagraphHeight?: boolean;
+  suppressEmptyParagraphHeight?: boolean; /** Reserve the reference extra line advance for a story-leading empty level-0 outline paragraph. */
+  reserveEmptyOutlineHeight?: boolean;
   numPr?: ListNumPr;
   listMarker?: string;
   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
@@ -431,6 +445,8 @@ type TableCell = {
 type TableRow = {
   id: BlockId;
   cells: TableCell[];
+  gridBefore?: number;
+  gridAfter?: number;
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
@@ -570,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. */
@@ -901,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;
@@ -1004,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.
  *
@@ -1055,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) {