@stll/folio-core 0.8.0 → 0.9.0

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

@@ -142,16 +142,10 @@ function flush(current) {
 	const entries = [];
 	for (const entry of current.pending.values()) {
 		if (entries.length >= MAX_BATCH_SIZE) break;
-		current.pending.delete(makeKey(entry.text, entry.fontCacheKey, entry.letterSpacing));
-		if (entry.cacheGeneration !== cacheGeneration) continue;
-		entries.push({
-			text: entry.text,
-			font: entry.font,
-			fontCacheKey: entry.fontCacheKey,
-			fontFingerprintWidth: entry.fontFingerprintWidth,
-			letterSpacing: entry.letterSpacing,
-			horizontalScale: entry.horizontalScale
-		});
+		const { cacheGeneration: entryGeneration, ...request } = entry;
+		current.pending.delete(makeKey(request.text, request.fontCacheKey, request.letterSpacing));
+		if (entryGeneration !== cacheGeneration) continue;
+		entries.push(request);
 	}
 	if (entries.length === 0) {
 		if (current.pending.size > 0) scheduleFlush(current);
@@ -196,20 +190,15 @@ function handleResponse(current, message) {
 * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
 * a previous error.
 */
-function prefetchMeasurement(text, font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth) {
+function prefetchMeasurement(request) {
 	if (!isWorkerFontMetricsEnabled()) return;
-	if (!text) return;
+	if (!request.text) return;
 	const current = ensureProxy();
 	if (current === null) return;
-	const key = makeKey(text, fontCacheKey, letterSpacing);
+	const key = makeKey(request.text, request.fontCacheKey, request.letterSpacing);
 	if (current.pending.has(key)) return;
 	current.pending.set(key, {
-		text,
-		font,
-		fontCacheKey,
-		fontFingerprintWidth,
-		letterSpacing,
-		horizontalScale,
+		...request,
 		cacheGeneration: getTextWidthCacheGeneration()
 	});
 	scheduleFlush(current);

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

@@ -1,18 +1,6 @@
+import { FontKerningMode } from "./textMeasurementPolicy.js";
+
 //#region src/layout-engine/measure/measureWorkerProtocol.d.ts
-/**
- * Wire format shared between the main-thread proxy
- * (`measureWorker.ts`) and the worker entry
- * (`font-metrics.worker.ts`).
- *
- * The protocol is intentionally minimal: a batched request carrying an
- * array of measurement inputs, and a matching response with widths in
- * the same order. The worker is a pure function — no state, no cache.
- * The main thread owns the LRU cache and is the sole authority on what
- * is worth measuring.
- *
- * Keep this file tiny and dependency-free so it can be imported from
- * both contexts.
- */
 /**
  * Single measurement request inside a batch. Mirrors the inputs that
  * `measureTextWidth` already takes on the main thread.
@@ -40,6 +28,7 @@ type MeasureRequestEntry = {
   fontFingerprintWidth: number;
   letterSpacing: number;
   horizontalScale: number;
+  fontKerning: FontKerningMode;
 };
 declare const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
 /**

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

@@ -1,4 +1,4 @@
-import { TableCell, TableCellMeasure } from "../types.js";
+import { ImageRun, TableCell, TableCellMeasure } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 
 //#region src/layout-engine/measure/tableCellFloating.d.ts
@@ -8,6 +8,11 @@ type TableCellFloatingImage = {
   height: number;
   alt?: string;
   transform?: string;
+  opacity?: number;
+  cropTop?: number;
+  cropRight?: number;
+  cropBottom?: number;
+  cropLeft?: number;
   x: number;
   y: number;
   side: "left" | "right";
@@ -19,8 +24,10 @@ type TableCellFloatingImage = {
   pmStart?: number;
   pmEnd?: number;
 };
+type TableCellFloatingPosition = Pick<TableCellFloatingImage, "x" | "y" | "side">;
+type ResolveTableCellFloatingPosition = (run: ImageRun, paragraphY: number) => TableCellFloatingPosition;
 declare function getTableCellContentWidth(cell: TableCell | undefined, cellMeasure: TableCellMeasure): number;
-declare function getTableCellFloatingImages(cell: TableCell, cellMeasure: TableCellMeasure, contentWidth: number): TableCellFloatingImage[];
+declare function getTableCellFloatingImages(cell: TableCell, cellMeasure: TableCellMeasure, contentWidth: number, resolvePosition?: ResolveTableCellFloatingPosition): TableCellFloatingImage[];
 declare function buildTableCellFloatingZones(floatingImages: TableCellFloatingImage[], contentWidth: number): FloatingImageZone[];
 //#endregion
-export { TableCellFloatingImage, buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };
+export { ResolveTableCellFloatingPosition, TableCellFloatingImage, buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };

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

@@ -1,22 +1,22 @@
 import { emuToPixels } from "../../utils/units.js";
 import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { createTableCellFlowState, placeTableCellBlock } from "./tableCellFlow.js";
 //#region src/layout-engine/measure/tableCellFloating.ts
 function getTableCellContentWidth(cell, cellMeasure) {
 	const padLeft = cell?.padding?.left ?? 7;
 	const padRight = cell?.padding?.right ?? 7;
 	return Math.max(0, cellMeasure.width - padLeft - padRight);
 }
-function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
+function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosition) {
 	const result = [];
-	let paragraphY = 0;
+	const flowState = createTableCellFlowState();
 	for (let blockIndex = 0; blockIndex < cell.blocks.length; blockIndex++) {
 		const block = cell.blocks[blockIndex];
-		if (block?.kind !== "paragraph") {
-			const blockMeasure = cellMeasure.blocks[blockIndex];
-			if (blockMeasure?.kind === "table") paragraphY += blockMeasure.totalHeight;
-			continue;
-		}
+		const blockMeasure = cellMeasure.blocks[blockIndex];
+		if (!block || !blockMeasure) continue;
+		const placement = placeTableCellBlock(flowState, block, blockMeasure);
+		if (block.kind !== "paragraph") continue;
 		for (const run of block.runs) {
 			if (run.kind !== "image" || !isFloatingImageRun(run)) continue;
 			const position = run.position;
@@ -24,30 +24,35 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 			const distBottom = run.distBottom ?? 0;
 			const distLeft = run.distLeft ?? 12;
 			const distRight = run.distRight ?? 12;
-			let side = "left";
-			let x = 0;
-			if (position?.horizontal) {
-				const horizontal = position.horizontal;
-				if (horizontal.align === "right") {
+			let side;
+			let x;
+			let y;
+			if (resolvePosition) ({side, x, y} = resolvePosition(run, placement.contentTop));
+			else {
+				side = "left";
+				x = 0;
+				if (position?.horizontal) {
+					const horizontal = position.horizontal;
+					if (horizontal.align === "right") {
+						side = "right";
+						x = contentWidth - run.width;
+					} else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
+					else if (horizontal.posOffset !== void 0) {
+						x = emuToPixels(horizontal.posOffset);
+						side = x > contentWidth / 2 ? "right" : "left";
+					}
+				} else if (run.cssFloat === "right") {
 					side = "right";
 					x = contentWidth - run.width;
-				} else if (horizontal.align === "left") x = 0;
-				else if (horizontal.align === "center") x = (contentWidth - run.width) / 2;
-				else if (horizontal.posOffset !== void 0) {
-					x = emuToPixels(horizontal.posOffset);
-					side = x > contentWidth / 2 ? "right" : "left";
 				}
-			} else if (run.cssFloat === "right") {
-				side = "right";
-				x = contentWidth - run.width;
-			}
-			let y = paragraphY;
-			if (position?.vertical) {
-				const vertical = position.vertical;
-				if (vertical.posOffset !== void 0) y = paragraphY + emuToPixels(vertical.posOffset);
-				else if (vertical.align === "top") y = 0;
+				y = placement.contentTop;
+				if (position?.vertical) {
+					const vertical = position.vertical;
+					if (vertical.posOffset !== void 0) y = placement.contentTop + emuToPixels(vertical.posOffset);
+					else if (vertical.align === "top") y = 0;
+				}
+				x = Math.max(0, Math.min(x, contentWidth - run.width));
 			}
-			x = Math.max(0, Math.min(x, contentWidth - run.width));
 			let wrapText = "bothSides";
 			if (run.cssFloat === "left") wrapText = "right";
 			else if (run.cssFloat === "right") wrapText = "left";
@@ -57,6 +62,11 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 				height: run.height,
 				...run.alt !== void 0 ? { alt: run.alt } : {},
 				...run.transform !== void 0 ? { transform: run.transform } : {},
+				...run.opacity != null ? { opacity: run.opacity } : {},
+				...run.cropTop != null ? { cropTop: run.cropTop } : {},
+				...run.cropRight != null ? { cropRight: run.cropRight } : {},
+				...run.cropBottom != null ? { cropBottom: run.cropBottom } : {},
+				...run.cropLeft != null ? { cropLeft: run.cropLeft } : {},
 				x,
 				y,
 				side,
@@ -69,8 +79,6 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth) {
 				...run.pmEnd !== void 0 ? { pmEnd: run.pmEnd } : {}
 			});
 		}
-		const blockMeasure = cellMeasure.blocks[blockIndex];
-		if (blockMeasure?.kind === "paragraph") paragraphY += blockMeasure.totalHeight;
 	}
 	return result;
 }

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

@@ -0,0 +1,27 @@
+import { FlowBlock, Measure } from "../types.js";
+
+//#region src/layout-engine/measure/tableCellFlow.d.ts
+type TableCellBlockPlacement = {
+  top: number;
+  contentTop: number;
+  contentHeight: number;
+  leadingSpacing: number;
+};
+type TableCellFlowState = {
+  height: number;
+  previousParagraphWasEmpty: boolean;
+  trailingSpacing: number;
+};
+declare const createTableCellFlowState: () => TableCellFlowState;
+declare const finishTableCellFlow: (state: TableCellFlowState) => number;
+declare const getTableCellBlockContentHeight: (block: FlowBlock, measure: Measure) => number;
+/**
+ * Place one block in an unpaginated table-cell story.
+ *
+ * Adjacent paragraph spacing collapses to the larger side. Consecutive
+ * authored empty paragraphs remain independent vertical spacers, including
+ * at the end of the cell.
+ */
+declare const placeTableCellBlock: (state: TableCellFlowState, block: FlowBlock, measure: Measure) => TableCellBlockPlacement;
+//#endregion
+export { TableCellBlockPlacement, TableCellFlowState, createTableCellFlowState, finishTableCellFlow, getTableCellBlockContentHeight, placeTableCellBlock };

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

@@ -0,0 +1,73 @@
+import { measuredLineRangeHeight } from "../lineFlow.js";
+import { isFloatingTextBoxBlock } from "../types.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
+//#region src/layout-engine/measure/tableCellFlow.ts
+const createTableCellFlowState = () => ({
+	height: 0,
+	previousParagraphWasEmpty: false,
+	trailingSpacing: 0
+});
+const finishTableCellFlow = (state) => state.height + state.trailingSpacing;
+const isSuppressedParagraphMeasure = (measure) => measure.totalHeight === 0 && measure.lines.every(({ lineHeight }) => lineHeight === 0);
+const paragraphSpacing = (block, measure) => {
+	if (isSuppressedParagraphMeasure(measure)) return {
+		before: 0,
+		after: 0
+	};
+	return {
+		before: getParagraphSpacingBefore(block),
+		after: getParagraphSpacingAfter(block)
+	};
+};
+const getTableCellBlockContentHeight = (block, measure) => {
+	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return 0;
+	if (block.kind === "paragraph" && measure.kind === "paragraph") return measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+	if ("totalHeight" in measure) return measure.totalHeight;
+	if ("height" in measure) return measure.height;
+	return 0;
+};
+/**
+* Place one block in an unpaginated table-cell story.
+*
+* Adjacent paragraph spacing collapses to the larger side. Consecutive
+* authored empty paragraphs remain independent vertical spacers, including
+* at the end of the cell.
+*/
+const placeTableCellBlock = (state, block, measure) => {
+	const top = state.height;
+	const contentHeight = getTableCellBlockContentHeight(block, measure);
+	if (block.kind === "paragraph" && measure.kind === "paragraph" && isSuppressedParagraphMeasure(measure)) return {
+		top,
+		contentTop: top,
+		contentHeight: 0,
+		leadingSpacing: 0
+	};
+	if (block.kind !== "paragraph" || measure.kind !== "paragraph") {
+		const leadingSpacing = state.trailingSpacing;
+		const contentTop = top + leadingSpacing;
+		state.height = contentTop + contentHeight;
+		state.previousParagraphWasEmpty = false;
+		state.trailingSpacing = 0;
+		return {
+			top,
+			contentTop,
+			contentHeight,
+			leadingSpacing
+		};
+	}
+	const spacing = paragraphSpacing(block, measure);
+	const empty = isEmptyParagraph(block);
+	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : Math.max(spacing.before, state.trailingSpacing);
+	const contentTop = top + leadingSpacing;
+	state.height = contentTop + contentHeight;
+	state.previousParagraphWasEmpty = empty;
+	state.trailingSpacing = spacing.after;
+	return {
+		top,
+		contentTop,
+		contentHeight,
+		leadingSpacing
+	};
+};
+//#endregion
+export { createTableCellFlowState, finishTableCellFlow, getTableCellBlockContentHeight, placeTableCellBlock };

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

@@ -36,7 +36,7 @@ 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";
+	const aboveOwnsEdge = aboveBottom !== void 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) => {

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

@@ -0,0 +1,18 @@
+import { RunFormatting } from "../types.js";
+import { FontStyle } from "./measureTypes.js";
+
+//#region src/layout-engine/measure/textMeasurementPolicy.d.ts
+declare const FONT_KERNING_MODE: {
+  readonly enabled: "normal";
+  readonly disabled: "none";
+};
+type FontKerningMode = (typeof FONT_KERNING_MODE)[keyof typeof FONT_KERNING_MODE];
+type RunKerningInput = Pick<RunFormatting, "fontSize" | "kerningMinPt">;
+/** Resolve an authored kerning threshold against the effective run size. */
+declare function getRunFontKerningMode(run: RunKerningInput, fallbackFontSize: number): FontKerningMode;
+/** Convert normalized measurement style into the canvas/CSS kerning mode. */
+declare function getFontKerningMode(style: Pick<FontStyle, "kerning">): FontKerningMode;
+/** Count ordinary ASCII spaces that justification may compress. */
+declare function countCompressibleSpaces(text: string): number;
+//#endregion
+export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };

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

@@ -0,0 +1,24 @@
+//#region src/layout-engine/measure/textMeasurementPolicy.ts
+const FONT_KERNING_MODE = {
+	enabled: "normal",
+	disabled: "none"
+};
+/** Resolve an authored kerning threshold against the effective run size. */
+function getRunFontKerningMode(run, fallbackFontSize) {
+	const threshold = run.kerningMinPt;
+	const fontSize = run.fontSize ?? fallbackFontSize;
+	if (threshold === void 0 || fontSize < threshold) return FONT_KERNING_MODE.disabled;
+	return FONT_KERNING_MODE.enabled;
+}
+/** Convert normalized measurement style into the canvas/CSS kerning mode. */
+function getFontKerningMode(style) {
+	return style.kerning ? FONT_KERNING_MODE.enabled : FONT_KERNING_MODE.disabled;
+}
+/** Count ordinary ASCII spaces that justification may compress. */
+function countCompressibleSpaces(text) {
+	let count = 0;
+	for (const char of text) if (char === " ") count += 1;
+	return count;
+}
+//#endregion
+export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };

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

@@ -6,6 +6,10 @@ type RenderedBreakState = {
 } | {
   type: "pageAdvance";
   reason: "ordinary" | "reflowBoundary";
+} | {
+  type: "pageAdvance";
+  reason: "authoredBoundary";
+  boundary: "hardBreak" | "sectionBreak";
 };
 declare const INITIAL_RENDERED_BREAK_STATE: RenderedBreakState;
 type ReconcileBeforeBlockOptions = {
@@ -19,6 +23,7 @@ type ReconcileBeforeBlockOptions = {
 };
 type BreakDecision = {
   forcePageBreak: boolean;
+  suppressSpaceBefore: boolean;
   state: RenderedBreakState;
 };
 /**
@@ -46,7 +51,7 @@ type ReconcileAfterBlockOptions = {
   pageNumberAfter: number;
   previousPage: Page | undefined;
 };
-/** Record page movement caused by laying out a block, or reset at a structural break. */
+/** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
 declare const reconcileAfterBlock: ({
   state,
   block,

package/dist/layout-engine/renderedBreakReconciliation.js

@@ -1,4 +1,3 @@
-import { isEmptyParagraph } from "./paragraphSpacing.js";
 import { continuesNumberedSequence, continuesTabbedParagraphSequence } from "./paragraphSequence.js";
 //#region src/layout-engine/renderedBreakReconciliation.ts
 const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
@@ -13,15 +12,24 @@ const INITIAL_RENDERED_BREAK_STATE = { type: "noPageAdvance" };
 const reconcileBreakBeforeBlock = ({ state, block, previousBlock, page, blocksById, hasExplicitPageBreak, renderedBreakNeedsSnap }) => {
 	if (hasExplicitPageBreak) return {
 		forcePageBreak: true,
+		suppressSpaceBefore: false,
 		state: INITIAL_RENDERED_BREAK_STATE
 	};
 	if (block.kind !== "paragraph" || block.attrs?.renderedPageBreakBefore !== true) return {
 		forcePageBreak: false,
+		suppressSpaceBefore: 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));
+	const markerAlreadySatisfied = pageStartsWithPreviousParagraphContinuation(page, previousBlock) || state.type === "pageAdvance" && state.reason === "authoredBoundary" || state.type === "pageAdvance" && state.reason === "reflowBoundary" || state.type === "pageAdvance" && isPaginationEmptyParagraph(block) || state.type === "pageAdvance" && (continuesNumberedSequence(previousBlock, block) || continuesTabbedParagraphSequence(previousBlock, block));
+	const forcePageBreak = (renderedBreakNeedsSnap || block.attrs?.keepNext === true) && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById);
+	const followsAuthoredPageBreak = previousBlock?.kind === "pageBreak";
+	const followsSectionBreak = previousBlock?.kind === "sectionBreak";
+	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;
 	return {
-		forcePageBreak: renderedBreakNeedsSnap && !markerAlreadySatisfied && pageHasVisibleBodyContent(page, blocksById),
+		forcePageBreak,
+		suppressSpaceBefore: (forcePageBreak || markerAlreadySatisfied || followsAuthoredPageBreak || followsPageBreakingSection) && !preserveSectionLeadingSpacing,
 		state: INITIAL_RENDERED_BREAK_STATE
 	};
 };
@@ -29,19 +37,38 @@ 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. */
+/** Record page movement and carry authored boundaries across pagination-empty paragraphs. */
 const reconcileAfterBlock = ({ state, block, pageNumberBefore, pageNumberAfter, previousPage }) => {
-	if (isStructuralBreak(block)) return INITIAL_RENDERED_BREAK_STATE;
-	if (!isVisibleBodyBlock(block) || pageNumberAfter <= pageNumberBefore) return state;
+	if (isStructuralBreak(block)) {
+		if (pageNumberAfter <= pageNumberBefore) {
+			if (state.type === "pageAdvance" && state.reason === "authoredBoundary") return block.kind === "sectionBreak" ? {
+				...state,
+				boundary: "sectionBreak"
+			} : state;
+			return INITIAL_RENDERED_BREAK_STATE;
+		}
+		return {
+			type: "pageAdvance",
+			reason: "authoredBoundary",
+			boundary: block.kind === "sectionBreak" ? "sectionBreak" : "hardBreak"
+		};
+	}
+	if (block.kind === "paragraph" && isPaginationEmptyParagraph(block)) return state;
+	if (pageNumberAfter <= pageNumberBefore) return state.type === "pageAdvance" && state.reason === "authoredBoundary" ? INITIAL_RENDERED_BREAK_STATE : state;
 	return {
 		type: "pageAdvance",
 		reason: previousPage?.fragments.some(({ blockId }) => blockId === block.id) ? "reflowBoundary" : "ordinary"
 	};
 };
-const isPaginationEmptyParagraph = (block) => block.runs.every((run) => {
+const isPaginationEmptyParagraph = (block) => !hasVisibleEmptyParagraphDecoration(block) && block.runs.every((run) => {
 	if (run.kind === "text") return run.text.trim().length === 0;
 	return run.kind === "tab" || run.kind === "lineBreak";
 });
+const hasVisibleEmptyParagraphDecoration = (block) => {
+	if (block.attrs?.listMarker !== void 0 && block.attrs.listMarker.length > 0 && block.attrs.listMarkerHidden !== true) return true;
+	if (block.attrs?.shading) return true;
+	return Object.values(block.attrs?.borders ?? {}).some((border) => border !== void 0 && border.style !== "none" && border.style !== "nil" && border.width !== 0);
+};
 const pageHasVisibleBodyContent = (page, blocksById) => {
 	for (const fragment of page.fragments) {
 		if (fragment.kind !== "paragraph") return true;
@@ -55,9 +82,5 @@ const pageStartsWithPreviousParagraphContinuation = (page, previousBlock) => {
 	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/tableRowBreak.d.ts

@@ -9,10 +9,13 @@ type TableRowBreakInfo = {
    * at which a break is clean. Always includes the row's full height as the
    * final boundary.
    */
-  breakOffsets: number[][];
+  breakOffsets: number[][]; /** Suppressible leading paragraph whitespace after each matching break offset. */
+  continuationSkips: number[][];
 };
 /** Build break geometry for a table from its block + measure. */
 declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure): TableRowBreakInfo;
+/** Leading empty-paragraph whitespace to consume when a row resumes after `offset`. */
+declare function getRowContinuationSkip(info: TableRowBreakInfo, rowIndex: number, offset: number): number;
 /**
  * Given a row and how much of it has already been placed (`fromOffset`), return
  * how many more px can be placed ending on a whole line, without exceeding
@@ -20,4 +23,4 @@ declare function buildTableRowBreakInfo(block: TableBlock, measure: TableMeasure
  */
 declare function snapRowBreak(info: TableRowBreakInfo, rowIndex: number, fromOffset: number, maxSlice: number): number;
 //#endregion
-export { TableRowBreakInfo, buildTableRowBreakInfo, snapRowBreak };
+export { TableRowBreakInfo, buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak };