@stll/folio-core 0.29.0 → 0.30.0

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

@@ -2,12 +2,33 @@ import { measuredLineRangeHeight } from "../lineFlow.js";
 import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
 import { isFloatingTextBoxBlock } from "../types.js";
 //#region src/layout-engine/measure/tableCellFlow.ts
+const TABLE_CELL_FLOW_POSITION = {
+	start: "start",
+	interior: "interior"
+};
+const TABLE_CELL_TRAILING_SPACING_TYPE = {
+	none: "none",
+	authored: "authored",
+	automatic: "automatic"
+};
 const createTableCellFlowState = () => ({
 	height: 0,
+	position: TABLE_CELL_FLOW_POSITION.start,
 	previousParagraphWasEmpty: false,
-	trailingSpacing: 0
+	trailingSpacing: { type: TABLE_CELL_TRAILING_SPACING_TYPE.none }
 });
-const finishTableCellFlow = (state) => state.height + state.trailingSpacing;
+const trailingSpacingValue = (spacing) => {
+	switch (spacing.type) {
+		case TABLE_CELL_TRAILING_SPACING_TYPE.none: return 0;
+		case TABLE_CELL_TRAILING_SPACING_TYPE.authored:
+		case TABLE_CELL_TRAILING_SPACING_TYPE.automatic: return spacing.value;
+		default: return spacing;
+	}
+};
+const finishTableCellFlow = (state) => {
+	if (state.trailingSpacing.type === TABLE_CELL_TRAILING_SPACING_TYPE.automatic) return state.height;
+	return state.height + trailingSpacingValue(state.trailingSpacing);
+};
 const isSuppressedParagraphMeasure = (measure) => measure.totalHeight === 0 && measure.lines.every(({ lineHeight }) => lineHeight === 0);
 const paragraphSpacing = (block, measure) => {
 	if (isSuppressedParagraphMeasure(measure)) return {
@@ -42,12 +63,19 @@ const placeTableCellBlock = (state, block, measure) => {
 		contentHeight: 0,
 		leadingSpacing: 0
 	};
+	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return {
+		top,
+		contentTop: top,
+		contentHeight: 0,
+		leadingSpacing: 0
+	};
 	if (block.kind !== "paragraph" || measure.kind !== "paragraph") {
-		const leadingSpacing = state.trailingSpacing;
+		const leadingSpacing = trailingSpacingValue(state.trailingSpacing);
 		const contentTop = top + leadingSpacing;
 		state.height = contentTop + contentHeight;
+		state.position = TABLE_CELL_FLOW_POSITION.interior;
 		state.previousParagraphWasEmpty = false;
-		state.trailingSpacing = 0;
+		state.trailingSpacing = { type: TABLE_CELL_TRAILING_SPACING_TYPE.none };
 		return {
 			top,
 			contentTop,
@@ -57,14 +85,23 @@ const placeTableCellBlock = (state, block, measure) => {
 	}
 	const spacing = paragraphSpacing(block, measure);
 	const empty = isEmptyParagraph(block);
-	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : collapseParagraphSpacing({
-		before: spacing.before,
-		after: state.trailingSpacing
+	const before = state.position === TABLE_CELL_FLOW_POSITION.start && block.attrs?.automaticSpacing?.before === true ? 0 : spacing.before;
+	const trailingSpacing = trailingSpacingValue(state.trailingSpacing);
+	const leadingSpacing = empty && state.previousParagraphWasEmpty ? before + trailingSpacing : collapseParagraphSpacing({
+		before,
+		after: trailingSpacing
 	});
 	const contentTop = top + leadingSpacing;
 	state.height = contentTop + contentHeight;
+	state.position = TABLE_CELL_FLOW_POSITION.interior;
 	state.previousParagraphWasEmpty = empty;
-	state.trailingSpacing = spacing.after;
+	state.trailingSpacing = block.attrs?.automaticSpacing?.after === true ? {
+		type: TABLE_CELL_TRAILING_SPACING_TYPE.automatic,
+		value: spacing.after
+	} : {
+		type: TABLE_CELL_TRAILING_SPACING_TYPE.authored,
+		value: spacing.after
+	};
 	return {
 		top,
 		contentTop,

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

@@ -7,6 +7,14 @@ type TableInlinePlacement = {
   offset: number;
 };
 /** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
-declare const resolveTableInlinePlacement: (table: Pick<TableBlock, "bidi" | "indent" | "justification" | "rows">) => TableInlinePlacement;
+declare const resolveTableInlinePlacement: (table: Pick<TableBlock, "bidi" | "indent" | "justification">, rowJustification?: TableBlock["justification"]) => TableInlinePlacement;
+type ResolveTableInlineOffsetOptions = {
+  table: Pick<TableBlock, "bidi" | "indent" | "justification">;
+  rowJustification?: TableBlock["justification"];
+  frameWidth: number;
+  tableWidth: number;
+};
+/** Resolve a table's physical inline offset within its current content frame. */
+declare const resolveTableInlineOffset: ({ table, rowJustification, frameWidth, tableWidth }: ResolveTableInlineOffsetOptions) => number;
 //#endregion
-export { resolveTableInlinePlacement };
+export { resolveTableInlineOffset, resolveTableInlinePlacement };

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

@@ -1,22 +1,24 @@
-import { resolveTableCellPadding } from "../types.js";
 //#region src/layout-engine/measure/tableInlinePlacement.ts
 /** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
-const resolveTableInlinePlacement = (table) => {
-	if (table.justification === "center") return { alignment: "center" };
-	if (table.justification === "right") return {
-		alignment: "right",
-		offset: 0
-	};
-	const firstCell = table.rows.at(0)?.cells.at(0);
-	const firstCellPadding = firstCell ? resolveTableCellPadding(firstCell) : void 0;
-	if (table.justification === "left" || table.bidi !== true) return {
-		alignment: "left",
-		offset: table.indent ?? -(firstCellPadding?.left ?? 0)
+const resolveTableInlinePlacement = (table, rowJustification) => {
+	const logicalJustification = rowJustification ?? table.justification ?? "left";
+	if (logicalJustification === "center") return { alignment: "center" };
+	const offset = logicalJustification === "left" ? table.indent ?? 0 : 0;
+	if (table.bidi !== true) return {
+		alignment: logicalJustification,
+		offset
 	};
 	return {
-		alignment: "right",
-		offset: table.indent ?? -(firstCellPadding?.right ?? 0)
+		alignment: logicalJustification === "left" ? "right" : "left",
+		offset
 	};
 };
+/** Resolve a table's physical inline offset within its current content frame. */
+const resolveTableInlineOffset = ({ table, rowJustification, frameWidth, tableWidth }) => {
+	const placement = resolveTableInlinePlacement(table, rowJustification);
+	if (placement.alignment === "center") return (frameWidth - tableWidth) / 2;
+	if (placement.alignment === "right") return frameWidth - tableWidth - placement.offset;
+	return placement.offset;
+};
 //#endregion
-export { resolveTableInlinePlacement };
+export { resolveTableInlineOffset, resolveTableInlinePlacement };

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

@@ -65,6 +65,28 @@ type PaginatorOptions = {
 type ForcePageBreakOptions = {
   coalesceBlankPage?: boolean;
 };
+declare const SECTION_START_PLACEMENT: {
+  readonly CONTINUOUS: "continuous";
+  readonly NEXT_PAGE: "nextPage";
+};
+type SectionStartPlacement = (typeof SECTION_START_PLACEMENT)[keyof typeof SECTION_START_PLACEMENT];
+type StartSectionOptions = {
+  sectionIndex: number;
+  pageNumbering?: SectionPageNumbering;
+  placement?: SectionStartPlacement;
+};
+/** Calculate active column widths, preferring authored unequal widths. */
+declare function calculateColumnWidths(pageWidth: number, leftMargin: number, rightMargin: number, columns: ColumnLayout): number[];
+/** Resolve every column's absolute page X in one pass. */
+declare function calculateColumnLefts(leftMargin: number, columnWidths: readonly number[], columns: ColumnLayout): number[];
+type ResolveColumnLeftOptions = {
+  leftMargin: number;
+  columnWidths: readonly number[];
+  columns: ColumnLayout;
+  columnIndex: number;
+};
+/** Resolve an active column's absolute page X from the shared width/gap model. */
+declare function resolveColumnLeft({ leftMargin, columnWidths, columns, columnIndex }: ResolveColumnLeftOptions): number;
 /**
  * Creates a paginator for managing page layout state.
  */
@@ -108,6 +130,8 @@ declare function createPaginator(options: PaginatorOptions): {
   addFootnoteHeight: (additionalHeight: number, footnoteIds?: number[]) => void;
   /** Force a page break. */
   forcePageBreak: (breakOptions?: ForcePageBreakOptions) => PageState;
+  /** Reuse the current sheet while advancing authored page ordinals. */
+  coalescePageBreak: () => PageState;
   /** Reuse an already blank current page for the active section/layout. */
   retargetCurrentBlankPage: () => boolean;
   /** Force a column break. */
@@ -122,8 +146,8 @@ declare function createPaginator(options: PaginatorOptions): {
     h: number;
   }, newMargins?: PageMargins, applyImmediately?: boolean) => void;
   /** Mark the next created page as the first page of a new section. */
-  startSection: (sectionIndex: number, pageNumbering?: SectionPageNumbering) => void;
+  startSection: ({ sectionIndex, pageNumbering, placement }: StartSectionOptions) => void;
 };
 type Paginator = ReturnType<typeof createPaginator>;
 //#endregion
-export { FOOTNOTE_SEPARATOR_HEIGHT, PageState, Paginator, PaginatorOptions, createPaginator };
+export { FOOTNOTE_SEPARATOR_HEIGHT, PageState, Paginator, PaginatorOptions, SECTION_START_PLACEMENT, calculateColumnLefts, calculateColumnWidths, createPaginator, resolveColumnLeft };

package/dist/layout-engine/paginator.js

@@ -8,6 +8,10 @@ import { panic } from "better-result";
 * Tracks the current page, cursor position, and available space.
 * Creates new pages when content doesn't fit.
 */
+const SECTION_START_PLACEMENT = {
+	CONTINUOUS: "continuous",
+	NEXT_PAGE: "nextPage"
+};
 /** Calculate active column widths, preferring authored unequal widths. */
 function calculateColumnWidths(pageWidth, leftMargin, rightMargin, columns) {
 	if (columns.widths?.length === columns.count && columns.widths.every((width) => Number.isFinite(width) && width > 0)) return [...columns.widths];
@@ -15,6 +19,22 @@ function calculateColumnWidths(pageWidth, leftMargin, rightMargin, columns) {
 	return Array.from({ length: columns.count }, () => equalWidth);
 }
 const gapAfterColumn = (columns, columnIndex) => columns.gaps?.[columnIndex] ?? columns.gap;
+/** Resolve every column's absolute page X in one pass. */
+function calculateColumnLefts(leftMargin, columnWidths, columns) {
+	const lefts = [];
+	let x = leftMargin;
+	for (let index = 0; index < columnWidths.length; index++) {
+		lefts.push(x);
+		x += (columnWidths[index] ?? 0) + gapAfterColumn(columns, index);
+	}
+	return lefts;
+}
+/** Resolve an active column's absolute page X from the shared width/gap model. */
+function resolveColumnLeft({ leftMargin, columnWidths, columns, columnIndex }) {
+	let x = leftMargin;
+	for (let index = 0; index < columnIndex; index++) x += (columnWidths[index] ?? columnWidths[0] ?? 0) + gapAfterColumn(columns, index);
+	return x;
+}
 function arePageSizesEqual(left, right) {
 	return left.w === right.w && left.h === right.h;
 }
@@ -37,7 +57,10 @@ function createPaginator(options) {
 	let currentSectionPageNumber = 0;
 	let currentPageNumbering = options.pageNumbering ?? { type: "continue" };
 	let nextLogicalPageNumber = currentPageNumbering.type === "restart" ? currentPageNumbering.start : 1;
-	let sectionStartPending = true;
+	let sectionStart = {
+		type: "pending",
+		placement: "nextPage"
+	};
 	const pages = [];
 	const states = [];
 	function getContentBottom() {
@@ -82,9 +105,12 @@ function createPaginator(options) {
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1, nextLogicalPageNumber).left;
-		for (let index = 0; index < columnIndex; index++) x += (columnWidths[index] ?? columnWidths[0] ?? 0) + gapAfterColumn(columns, index);
-		return x;
+		return resolveColumnLeft({
+			leftMargin: states.at(-1)?.page.margins.left ?? getPageMargins(1, nextLogicalPageNumber).left,
+			columnWidths,
+			columns,
+			columnIndex
+		});
 	}
 	/**
 	* Create a new page and add it to the list.
@@ -94,7 +120,7 @@ function createPaginator(options) {
 		const pageNumber = pages.length + 1;
 		const logicalNumber = nextLogicalPageNumber;
 		nextLogicalPageNumber += 1;
-		sectionStartPending = false;
+		sectionStart = { type: "placed" };
 		currentSectionPageNumber += 1;
 		const pageMargins = getPageMargins(pageNumber, logicalNumber);
 		const topMargin = pageMargins.top;
@@ -208,11 +234,14 @@ function createPaginator(options) {
 			y
 		};
 	}
+	function consumeSharedSectionPage(state) {
+		if (sectionStart.type !== "pending" || sectionStart.placement !== "continuous" || state.page.sectionIndex === currentSectionIndex) return;
+		if (currentPageNumbering.type === "restart") nextLogicalPageNumber = currentPageNumbering.start + 1;
+		currentSectionPageNumber = 1;
+		sectionStart = { type: "placed" };
+	}
 	function commitFragment(state, fragment) {
-		if (sectionStartPending && state.page.sectionIndex !== currentSectionIndex) {
-			if (currentPageNumbering.type === "restart") nextLogicalPageNumber = currentPageNumbering.start + 1;
-			sectionStartPending = false;
-		}
+		consumeSharedSectionPage(state);
 		state.page.fragments.push(fragment);
 	}
 	function addUnflowedFragment(fragment) {
@@ -259,6 +288,7 @@ function createPaginator(options) {
 	*/
 	function forcePageBreak(breakOptions = {}) {
 		const current = states.at(-1);
+		if (current?.page.fragments.length) consumeSharedSectionPage(current);
 		if (breakOptions.coalesceBlankPage && current && current.page.fragments.length === 0 && current.cursorY === current.topMargin) {
 			if (current.page.sectionIndex !== currentSectionIndex) {
 				retargetCurrentBlankPage();
@@ -268,6 +298,33 @@ function createPaginator(options) {
 		}
 		return createNewPage();
 	}
+	function coalescePageBreak() {
+		const state = getCurrentState();
+		consumeSharedSectionPage(state);
+		const previousMargins = state.page.margins;
+		const logicalNumber = nextLogicalPageNumber;
+		nextLogicalPageNumber += 1;
+		currentSectionPageNumber += 1;
+		state.page.logicalNumber = logicalNumber;
+		if (currentPageNumbering.format === void 0) delete state.page.logicalNumberFormat;
+		else state.page.logicalNumberFormat = currentPageNumbering.format;
+		applySectionMetadata(state.page);
+		const pageMargins = getPageMargins(state.page.number, logicalNumber);
+		const xDelta = pageMargins.left - previousMargins.left;
+		const yDelta = pageMargins.top - previousMargins.top;
+		for (const fragment of state.page.fragments) {
+			fragment.x += xDelta;
+			fragment.y += yDelta;
+		}
+		state.page.margins = pageMargins;
+		state.topMargin = pageMargins.top;
+		state.cursorY += yDelta;
+		state.rawContentBottom = pageSize.h - pageMargins.bottom;
+		state.contentBottom = state.rawContentBottom - state.footnoteHeight;
+		columnRegionTop += yDelta;
+		columnRegionMaxBottom += yDelta;
+		return state;
+	}
 	function retargetCurrentBlankPage() {
 		const current = states.at(-1);
 		if (!current || current.page.fragments.length > 0 || current.cursorY !== current.topMargin) return false;
@@ -334,20 +391,23 @@ function createPaginator(options) {
 		pendingPageSize = void 0;
 		pendingMargins = void 0;
 	}
-	function startSection(sectionIndex, pageNumbering = { type: "continue" }) {
+	function startSection({ sectionIndex, pageNumbering = { type: "continue" }, placement = SECTION_START_PLACEMENT.NEXT_PAGE }) {
 		currentSectionIndex = sectionIndex;
 		currentSectionPageNumber = 0;
 		currentPageNumbering = pageNumbering;
-		sectionStartPending = true;
+		sectionStart = {
+			type: "pending",
+			placement
+		};
 		if (pageNumbering.type === "restart") nextLogicalPageNumber = pageNumbering.start;
 	}
 	function retargetSectionMetadata(page) {
 		currentSectionPageNumber = 1;
-		if (sectionStartPending && currentPageNumbering.type === "restart") {
+		if (sectionStart.type === "pending" && currentPageNumbering.type === "restart") {
 			page.logicalNumber = currentPageNumbering.start;
 			nextLogicalPageNumber = currentPageNumbering.start + 1;
 		}
-		sectionStartPending = false;
+		sectionStart = { type: "placed" };
 		if (currentPageNumbering.format === void 0) delete page.logicalNumberFormat;
 		else page.logicalNumberFormat = currentPageNumbering.format;
 		applySectionMetadata(page);
@@ -393,6 +453,8 @@ function createPaginator(options) {
 		addFootnoteHeight,
 		/** Force a page break. */
 		forcePageBreak,
+		/** Reuse the current sheet while advancing authored page ordinals. */
+		coalescePageBreak,
 		/** Reuse an already blank current page for the active section/layout. */
 		retargetCurrentBlankPage,
 		/** Force a column break. */
@@ -408,4 +470,4 @@ function createPaginator(options) {
 	};
 }
 //#endregion
-export { FOOTNOTE_SEPARATOR_HEIGHT, createPaginator };
+export { FOOTNOTE_SEPARATOR_HEIGHT, SECTION_START_PLACEMENT, calculateColumnLefts, calculateColumnWidths, createPaginator, resolveColumnLeft };

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

@@ -12,6 +12,8 @@ type CollapseParagraphSpacingOptions = {
 declare const collapseParagraphSpacing: ({ before, after }: CollapseParagraphSpacingOptions) => number;
 /** Whether a paragraph has no visible run content. */
 declare function isEmptyParagraph(block: ParagraphBlock): boolean;
+/** Whether a visually empty paragraph carries authored formatting semantics. */
+declare const isAuthoredEmptyParagraph: (block: ParagraphBlock) => boolean;
 /**
  * Resolve leading paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
@@ -34,4 +36,4 @@ declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => Effec
 declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
 declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };

package/dist/layout-engine/paragraphSpacing.js

@@ -9,6 +9,8 @@ function isEmptyParagraph(block) {
 	const run = block.runs.at(0);
 	return run?.kind === "text" && run.text === "";
 }
+/** Whether a visually empty paragraph carries authored formatting semantics. */
+const isAuthoredEmptyParagraph = (block) => isEmptyParagraph(block) && (block.attrs?.styleId !== void 0 || block.attrs?.hasDirectParagraphFormatting === true || block.attrs?.hasDirectParagraphMarkFormatting === true);
 /**
 * Resolve leading paragraph spacing after applying the empty-paragraph
 * inherited-spacing collapse rule.
@@ -23,7 +25,7 @@ const getParagraphSpacingAfter = (block) => resolveEffectiveParagraphSpacing(blo
 const resolveEffectiveParagraphSpacing = (block) => {
 	const before = block.attrs?.spacing?.before ?? 0;
 	const after = block.attrs?.spacing?.after ?? 0;
-	if (!isEmptyParagraph(block) || preservesInheritedEmptySpacing(block)) return {
+	if (!isEmptyParagraph(block) || isAuthoredEmptyParagraph(block)) return {
 		before,
 		after
 	};
@@ -49,7 +51,6 @@ const resolveEffectiveParagraphSpacingTree = (blocks) => {
 	return changed ? resolved : blocks;
 };
 const paragraphsShareStyle = (previous, current) => previous.attrs?.styleId === current.attrs?.styleId;
-const preservesInheritedEmptySpacing = (block) => Boolean(block.attrs?.styleId || block.attrs?.hasDirectParagraphFormatting || block.attrs?.hasDirectParagraphMarkFormatting);
 const resolveBlockSpacing = (blocks, index) => {
 	const block = blocks[index];
 	if (block.kind === "paragraph") return resolveParagraphSequenceSpacing(blocks, index, block);
@@ -121,4 +122,4 @@ const resolveTextBoxSpacing = (block) => {
 	};
 };
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };

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

@@ -8,7 +8,12 @@ type RenderedBreakState = {
 } | {
   type: "pageAdvance";
   reason: "authoredBoundary";
-  boundary: "hardBreak" | "sectionBreak";
+  boundary: "hardBreak";
+} | {
+  type: "pageAdvance";
+  reason: "authoredBoundary";
+  boundary: "sectionBreak";
+  nextHardBreak: "coalesce" | "advance";
 };
 declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
 type ReconcileBeforeBlockOptions = {
@@ -20,8 +25,14 @@ type ReconcileBeforeBlockOptions = {
   hasExplicitPageBreak: boolean;
   renderedBreakNeedsSnap: boolean;
 };
+declare const PAGE_ADVANCE: {
+  readonly COALESCED: "coalesced";
+  readonly NONE: "none";
+  readonly PHYSICAL: "physical";
+};
+type PageAdvance = (typeof PAGE_ADVANCE)[keyof typeof PAGE_ADVANCE];
 type BreakDecision = {
-  forcePageBreak: boolean;
+  pageAdvance: PageAdvance;
   suppressSpaceBefore: boolean;
   state: RenderedBreakState;
 };
@@ -45,4 +56,4 @@ type ReconcileAfterBlockOptions = {
 /** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
 declare const reconcileAfterBlock: ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }: ReconcileAfterBlockOptions) => RenderedBreakState;
 //#endregion
-export { INITIAL_RENDERED_BREAK_STATE, RenderedBreakState, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };
+export { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, RenderedBreakState, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

package/dist/layout-engine/renderedBreakReconciliation.js

@@ -1,6 +1,11 @@
 import { continuesNumberedSequence, continuesTabbedParagraphSequence } from "./paragraphSequence.js";
 //#region src/layout-engine/renderedBreakReconciliation.ts
 const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
+const PAGE_ADVANCE = {
+	COALESCED: "coalesced",
+	NONE: "none",
+	PHYSICAL: "physical"
+};
 /**
 * Reconcile an authored or cached break before laying out one block.
 *
@@ -10,13 +15,21 @@ const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
 * independent decisions.
 */
 const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }) => {
-	if (hasExplicitPageBreak) return {
-		forcePageBreak: !(state.type === "pageAdvance" && state.reason === "authoredBoundary" && state.boundary === "sectionBreak" && previousBlock?.kind === "sectionBreak" && previousBlock.type !== "continuous"),
-		suppressSpaceBefore: false,
-		state: INITIAL_RENDERED_BREAK_STATE
-	};
+	if (hasExplicitPageBreak) {
+		const sectionBoundaryAlreadyOpenedPage = state.type === "pageAdvance" && state.reason === "authoredBoundary" && state.boundary === "sectionBreak" && state.nextHardBreak === "coalesce" && !pageHasVisibleBodyContent(page, blocksById);
+		return {
+			pageAdvance: sectionBoundaryAlreadyOpenedPage ? PAGE_ADVANCE.COALESCED : PAGE_ADVANCE.PHYSICAL,
+			suppressSpaceBefore: false,
+			state: sectionBoundaryAlreadyOpenedPage ? {
+				type: "pageAdvance",
+				reason: "authoredBoundary",
+				boundary: "sectionBreak",
+				nextHardBreak: "advance"
+			} : INITIAL_RENDERED_BREAK_STATE
+		};
+	}
 	if (block.kind !== "paragraph" || block.attrs?.renderedPageBreakBefore !== true) return {
-		forcePageBreak: false,
+		pageAdvance: PAGE_ADVANCE.NONE,
 		suppressSpaceBefore: false,
 		state
 	};
@@ -27,9 +40,10 @@ const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksBy
 	const followsPageBreakingSection = followsSectionBreak && previousBlock.type !== "continuous";
 	const followsCarriedSectionBoundary = state.type === "pageAdvance" && state.reason === "authoredBoundary" && state.boundary === "sectionBreak";
 	const preserveSectionLeadingSpacing = (followsSectionBreak || followsCarriedSectionBoundary) && block.attrs?.spacingExplicit?.before === true;
+	const markerAccountsForBoundary = forcePageBreak || markerAlreadySatisfied || followsAuthoredPageBreak || followsPageBreakingSection;
 	return {
-		forcePageBreak,
-		suppressSpaceBefore: (forcePageBreak || markerAlreadySatisfied || followsAuthoredPageBreak || followsPageBreakingSection) && !preserveSectionLeadingSpacing,
+		pageAdvance: forcePageBreak ? PAGE_ADVANCE.PHYSICAL : PAGE_ADVANCE.NONE,
+		suppressSpaceBefore: markerAccountsForBoundary && !preserveSectionLeadingSpacing,
 		state: INITIAL_RENDERED_BREAK_STATE
 	};
 };
@@ -41,16 +55,33 @@ const recordReflowBoundary = (state, crossedPageBoundary) => crossedPageBoundary
 const reconcileAfterBlock = ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }) => {
 	if (isStructuralBreak(block)) {
 		if (pageNumberAfter <= pageNumberBefore) {
-			if (state.type === "pageAdvance" && state.reason === "authoredBoundary") return block.kind === "sectionBreak" ? {
-				...state,
-				boundary: "sectionBreak"
-			} : state;
+			if (state.type === "pageAdvance" && state.reason === "authoredBoundary") {
+				if (block.kind !== "sectionBreak") return state.boundary === "sectionBreak" ? {
+					type: "pageAdvance",
+					reason: "authoredBoundary",
+					boundary: "sectionBreak",
+					nextHardBreak: "advance"
+				} : state;
+				if (state.boundary === "sectionBreak") return state;
+				return {
+					type: "pageAdvance",
+					reason: "authoredBoundary",
+					boundary: "sectionBreak",
+					nextHardBreak: "advance"
+				};
+			}
 			return INITIAL_RENDERED_BREAK_STATE;
 		}
+		if (block.kind === "sectionBreak") return {
+			type: "pageAdvance",
+			reason: "authoredBoundary",
+			boundary: "sectionBreak",
+			nextHardBreak: "coalesce"
+		};
 		return {
 			type: "pageAdvance",
 			reason: "authoredBoundary",
-			boundary: block.kind === "sectionBreak" ? "sectionBreak" : "hardBreak"
+			boundary: "hardBreak"
 		};
 	}
 	if (block.kind === "paragraph" && isPaginationEmptyParagraph(block)) return state;
@@ -83,4 +114,4 @@ const pageStartsWithPreviousParagraphContinuation = (page, previousBlock) => {
 };
 const isStructuralBreak = (block) => block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak";
 //#endregion
-export { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };
+export { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary };

package/dist/layout-engine/section-breaks.d.ts

@@ -53,6 +53,8 @@ type BreakDecision = {
   /** Required page parity (even or odd). */
   requiredParity?: "even" | "odd";
 };
+declare const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
+declare function normalizeSectionBreakType(type: SectionBreakBlock["type"]): "continuous" | "nextPage" | "evenPage" | "oddPage";
 /**
  * Create initial section state from default options.
  */
@@ -92,4 +94,4 @@ declare function getEffectivePageSize(state: SectionState): {
  */
 declare function getEffectiveColumns(state: SectionState): ColumnLayout;
 //#endregion
-export { BreakDecision, SectionState, applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak };
+export { BreakDecision, DEFAULT_SECTION_BREAK_TYPE, SectionState, applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, scheduleSectionBreak };

package/dist/layout-engine/section-breaks.js

@@ -6,6 +6,10 @@ const DEFAULT_COLUMNS = {
 	count: 1,
 	gap: 0
 };
+const DEFAULT_SECTION_BREAK_TYPE = "nextPage";
+function normalizeSectionBreakType(type) {
+	return type ?? "nextPage";
+}
 /**
 * Create initial section state from default options.
 */
@@ -52,7 +56,7 @@ function getColumnConfig(columns) {
 */
 function scheduleSectionBreak(block, state, _baseMargins) {
 	const next = { ...state };
-	const sectionType = block.type ?? "continuous";
+	const sectionType = normalizeSectionBreakType(block.type);
 	const sectionMargins = block.margins;
 	const sectionPageSize = block.pageSize;
 	const sectionOrientation = block.orientation;
@@ -179,4 +183,4 @@ function getEffectiveColumns(state) {
 	return state.pendingColumns ?? state.activeColumns;
 }
 //#endregion
-export { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak };
+export { DEFAULT_SECTION_BREAK_TYPE, applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, scheduleSectionBreak };