@stll/folio-core 0.1.3 → 0.3.0

package/dist/layout-bridge/cellSelectionHighlight.js

@@ -0,0 +1,36 @@
+//#region src/layout-bridge/cellSelectionHighlight.ts
+/**
+* Apply the `.layout-table-cell-selected` class to painted layout cells
+* matching a CellSelection in the PM state. Clears the class everywhere
+* (within scope) first so toggling off (or moving to a TextSelection) erases
+* prior highlights.
+*
+* Duck-types CellSelection via `$anchorCell` / `forEachCell` rather than
+* `instanceof` to dodge bundling issues across `prosemirror-tables` copies
+* (the same trick used inline in the selection-overlay update).
+*/
+function applyCellSelectionHighlight(pagesContainer, state, options = {}) {
+	const scope = options.scope ?? "body";
+	const scopeClass = scope === "body" ? "layout-page-content" : `layout-page-${scope}`;
+	const scopeSelector = `.${scopeClass} .layout-table-cell`;
+	const prevSelected = pagesContainer.querySelectorAll(`.${scopeClass} .layout-table-cell-selected`);
+	for (const el of Array.from(prevSelected)) el.classList.remove("layout-table-cell-selected");
+	const sel = state.selection;
+	if (!("$anchorCell" in sel && typeof sel.forEachCell === "function") || !sel.forEachCell) return;
+	const selectedRanges = [];
+	sel.forEachCell((node, pos) => {
+		selectedRanges.push([pos, pos + node.nodeSize]);
+	});
+	const allCells = pagesContainer.querySelectorAll(scopeSelector);
+	for (const cellEl of Array.from(allCells)) {
+		const pmStartAttr = cellEl.dataset["pmStart"];
+		if (pmStartAttr === void 0) continue;
+		const pmPos = Number(pmStartAttr);
+		for (const [start, end] of selectedRanges) if (pmPos >= start && pmPos < end) {
+			cellEl.classList.add("layout-table-cell-selected");
+			break;
+		}
+	}
+}
+//#endregion
+export { applyCellSelectionHighlight };

package/dist/layout-bridge/headerFooterLayout.d.ts

@@ -0,0 +1,50 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/layout-bridge/headerFooterLayout.d.ts
+/**
+ * Drop the cached HF host + span lists. Hosts/painters call this after
+ * a repaint (or HF mode toggle) so the next caret / selection compute
+ * re-walks the DOM. Public so adapters can call it from their painter
+ * commit signal.
+ *
+ * @public
+ */
+declare function invalidateHfDomCache(): void;
+/**
+ * Viewport-relative caret rect for a persistent HF EditorView's selection
+ * head. Resolves against the painter's `data-pm-start`/`data-pm-end` spans
+ * inside `.layout-page-header` / `.layout-page-footer`. The same HF doc is
+ * painted on every page (multi-page docs, titlePg), so this walks every
+ * candidate host and picks the one whose spans bracket the PM head; falls
+ * back to the first so empty paragraphs still resolve to a paragraph anchor.
+ *
+ * Public so the React + Vue adapters can share a single implementation
+ * (`packages/{react,vue}` adapters used to carry byte-identical copies).
+ *
+ * @public
+ */
+declare function computeHfCaretRectFromView(view: EditorView, section: "header" | "footer", doc?: globalThis.Document): {
+  top: number;
+  left: number;
+  height: number;
+} | null;
+/**
+ * Selection-rect set for a non-empty HF selection, projected against the
+ * painted HF spans. Mirror of `computeSelectionRectsFromDom` but scoped to
+ * `.layout-page-header` / `.layout-page-footer` instead of the body. Used
+ * so the painter draws a visible highlight when the user drag-selects
+ * inside a header/footer in edit mode.
+ *
+ * Returns viewport-relative `{top, left, width, height}` rects. Empty
+ * array when selection is collapsed or no painted spans overlap the range.
+ *
+ * @public
+ */
+declare function computeHfSelectionRectsFromView(view: EditorView, section: "header" | "footer", doc?: globalThis.Document): Array<{
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+}>;
+//#endregion
+export { computeHfCaretRectFromView, computeHfSelectionRectsFromView, invalidateHfDomCache };

package/dist/layout-bridge/headerFooterLayout.js

@@ -0,0 +1,216 @@
+//#region src/layout-bridge/headerFooterLayout.ts
+const hfDomCache = {
+	header: null,
+	footer: null
+};
+/**
+* Drop the cached HF host + span lists. Hosts/painters call this after
+* a repaint (or HF mode toggle) so the next caret / selection compute
+* re-walks the DOM. Public so adapters can call it from their painter
+* commit signal.
+*
+* @public
+*/
+function invalidateHfDomCache() {
+	hfDomCache.header = null;
+	hfDomCache.footer = null;
+}
+function getHfDomSnapshot(section, doc) {
+	const hosts = doc.querySelectorAll(`.layout-page-${section}`);
+	if (hosts.length === 0) return null;
+	const win = doc.defaultView;
+	const vpCenter = win ? win.innerHeight / 2 : 0;
+	let host = hosts[0];
+	if (!host) return null;
+	let bestDist = Infinity;
+	for (const h of Array.from(hosts)) {
+		const r = h.getBoundingClientRect();
+		const dist = Math.abs((r.top + r.bottom) / 2 - vpCenter);
+		if (dist < bestDist) {
+			bestDist = dist;
+			host = h;
+		}
+	}
+	const cached = hfDomCache[section];
+	if (cached && cached.host === host && cached.host.isConnected) return cached;
+	const spans = Array.from(host.querySelectorAll("span[data-pm-start][data-pm-end]"));
+	const ranged = Array.from(host.querySelectorAll("[data-pm-start][data-pm-end]"));
+	const snapshot = {
+		host,
+		spans,
+		ranged
+	};
+	hfDomCache[section] = snapshot;
+	return snapshot;
+}
+/**
+* Viewport-relative caret rect for a persistent HF EditorView's selection
+* head. Resolves against the painter's `data-pm-start`/`data-pm-end` spans
+* inside `.layout-page-header` / `.layout-page-footer`. The same HF doc is
+* painted on every page (multi-page docs, titlePg), so this walks every
+* candidate host and picks the one whose spans bracket the PM head; falls
+* back to the first so empty paragraphs still resolve to a paragraph anchor.
+*
+* Public so the React + Vue adapters can share a single implementation
+* (`packages/{react,vue}` adapters used to carry byte-identical copies).
+*
+* @public
+*/
+function computeHfCaretRectFromView(view, section, doc = globalThis.document) {
+	const sel = view.state.selection;
+	if (!sel.empty) return null;
+	const pmPos = sel.head;
+	const snapshot = getHfDomSnapshot(section, doc);
+	if (!snapshot) return null;
+	const { host, spans } = snapshot;
+	for (const span of spans) {
+		const start = Number(span.dataset["pmStart"]);
+		const end = Number(span.dataset["pmEnd"]);
+		if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+		if (pmPos >= start && pmPos <= end) {
+			const range = host.ownerDocument.createRange();
+			const walker = host.ownerDocument.createTreeWalker(span, NodeFilter.SHOW_TEXT);
+			let remaining = pmPos - start;
+			let textNode = walker.nextNode();
+			while (textNode) {
+				const len = textNode.data.length;
+				if (remaining <= len) {
+					try {
+						range.setStart(textNode, remaining);
+						range.setEnd(textNode, remaining);
+						const rect = range.getClientRects()[0] ?? range.getBoundingClientRect();
+						if (rect && rect.height > 0) return {
+							top: rect.top,
+							left: rect.left,
+							height: rect.height
+						};
+					} catch {}
+					break;
+				}
+				remaining -= len;
+				textNode = walker.nextNode();
+			}
+			const spanRect = span.getBoundingClientRect();
+			const ratio = (pmPos - start) / Math.max(1, end - start);
+			return {
+				top: spanRect.top,
+				left: spanRect.left + spanRect.width * ratio,
+				height: spanRect.height
+			};
+		}
+	}
+	const anchor = host.querySelector(`[data-pm-start="${pmPos}"]`);
+	if (anchor) {
+		const rect = anchor.getBoundingClientRect();
+		return {
+			top: rect.top,
+			left: rect.left + 1,
+			height: rect.height || 16
+		};
+	}
+	const ranged = snapshot.ranged;
+	let bestEl = null;
+	let bestSpan = Infinity;
+	for (const el of ranged) {
+		const start = Number(el.dataset["pmStart"]);
+		const end = Number(el.dataset["pmEnd"]);
+		if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+		if (pmPos < start || pmPos > end) continue;
+		const span = end - start;
+		if (span < bestSpan) {
+			bestSpan = span;
+			bestEl = el;
+		}
+	}
+	if (bestEl) {
+		const rect = bestEl.getBoundingClientRect();
+		const atEnd = pmPos >= Number(bestEl.dataset["pmEnd"]);
+		return {
+			top: rect.top,
+			left: atEnd ? rect.right : rect.left + 1,
+			height: rect.height || 16
+		};
+	}
+	let trailingEl = null;
+	let trailingStart = -Infinity;
+	for (const el of ranged) {
+		const start = Number(el.dataset["pmStart"]);
+		if (!Number.isFinite(start)) continue;
+		if (start > pmPos) continue;
+		if (start > trailingStart) {
+			trailingStart = start;
+			trailingEl = el;
+		}
+	}
+	if (trailingEl) {
+		const rect = trailingEl.getBoundingClientRect();
+		return {
+			top: rect.top,
+			left: rect.right,
+			height: rect.height || 16
+		};
+	}
+	const hostRect = host.getBoundingClientRect();
+	return {
+		top: hostRect.top + 2,
+		left: hostRect.left + 2,
+		height: 16
+	};
+}
+/**
+* Selection-rect set for a non-empty HF selection, projected against the
+* painted HF spans. Mirror of `computeSelectionRectsFromDom` but scoped to
+* `.layout-page-header` / `.layout-page-footer` instead of the body. Used
+* so the painter draws a visible highlight when the user drag-selects
+* inside a header/footer in edit mode.
+*
+* Returns viewport-relative `{top, left, width, height}` rects. Empty
+* array when selection is collapsed or no painted spans overlap the range.
+*
+* @public
+*/
+function computeHfSelectionRectsFromView(view, section, doc = globalThis.document) {
+	const sel = view.state.selection;
+	if (sel.empty) return [];
+	const from = sel.from;
+	const to = sel.to;
+	const out = [];
+	const snapshot = getHfDomSnapshot(section, doc);
+	if (!snapshot) return out;
+	const { host, spans } = snapshot;
+	for (const spanEl of spans) {
+		const pmStart = Number(spanEl.dataset["pmStart"]);
+		const pmEnd = Number(spanEl.dataset["pmEnd"]);
+		if (!Number.isFinite(pmStart) || !Number.isFinite(pmEnd)) continue;
+		if (pmEnd <= from || pmStart >= to) continue;
+		if (spanEl.classList.contains("layout-run-tab")) {
+			const rect = spanEl.getBoundingClientRect();
+			out.push({
+				top: rect.top,
+				left: rect.left,
+				width: rect.width,
+				height: rect.height
+			});
+			continue;
+		}
+		let textNode = null;
+		if (spanEl.firstChild?.nodeType === Node.TEXT_NODE) textNode = spanEl.firstChild;
+		else if (spanEl.firstChild?.nodeType === Node.ELEMENT_NODE && spanEl.firstChild.tagName === "A" && spanEl.firstChild.firstChild?.nodeType === Node.TEXT_NODE) textNode = spanEl.firstChild.firstChild;
+		if (!textNode) continue;
+		const startChar = Math.max(0, from - pmStart);
+		const endChar = Math.min(textNode.length, to - pmStart);
+		if (startChar >= endChar) continue;
+		const range = host.ownerDocument.createRange();
+		range.setStart(textNode, startChar);
+		range.setEnd(textNode, endChar);
+		for (const rect of Array.from(range.getClientRects())) out.push({
+			top: rect.top,
+			left: rect.left,
+			width: rect.width,
+			height: rect.height
+		});
+	}
+	return out;
+}
+//#endregion
+export { computeHfCaretRectFromView, computeHfSelectionRectsFromView, invalidateHfDomCache };

package/dist/layout-bridge/measuring/measureBlocksPipeline.d.ts

@@ -0,0 +1,33 @@
+//#region src/layout-bridge/measuring/measureBlocksPipeline.d.ts
+/**
+ * Floating-aware block measurement pipeline (adapter-facing surface).
+ *
+ * Upstream exposes a generic `measureBlocksWithFloats(blocks, contentWidth,
+ * measureBlock, pageGeometry)` orchestrator: it pre-scans blocks for floating
+ * exclusion zones, groups co-located floats, then walks the blocks calling a
+ * caller-supplied `measureBlock` with the active zones + cumulative Y.
+ *
+ * @packageDocumentation
+ * @public
+ */
+/**
+ * Page geometry (CSS px) used to resolve page/margin-relative anchored objects
+ * into content-area coordinates — currently the vertical anchor of a top-pinned
+ * `topAndBottom` band. Structurally identical to the painter's `PageGeometry`,
+ * declared here rather than imported because layout-bridge must not import from
+ * layout-painter (arch boundary); both paths resolve to identical positions.
+ *
+ * @public
+ */
+type FloatPageGeometry = {
+  pageWidth: number;
+  pageHeight: number;
+  marginLeft: number;
+  marginTop: number;
+  marginRight: number;
+  marginBottom: number;
+  contentWidth: number;
+  contentHeight: number;
+};
+//#endregion
+export { FloatPageGeometry };

package/dist/layout-bridge/sectionColumns.d.ts

@@ -0,0 +1,11 @@
+import { document_d_exports } from "../types/document.js";
+import { ColumnLayout } from "../layout-engine/types.js";
+
+//#region src/layout-bridge/sectionColumns.d.ts
+/**
+ * Extract column layout from section properties.
+ * Returns undefined for single-column (default) to avoid unnecessary paginator overhead.
+ */
+declare function getColumns(sectionProps: document_d_exports.SectionProperties | null | undefined): ColumnLayout | undefined;
+//#endregion
+export { getColumns };

package/dist/layout-bridge/sectionColumns.js

@@ -0,0 +1,21 @@
+import { twipsToPixels } from "../paged-layout/sectionGeometry.js";
+//#region src/layout-bridge/sectionColumns.ts
+/** Default column spacing per OOXML spec: 720 twips (0.5 inch). */
+const DEFAULT_COLUMN_SPACE_TWIPS = 720;
+/**
+* Extract column layout from section properties.
+* Returns undefined for single-column (default) to avoid unnecessary paginator overhead.
+*/
+function getColumns(sectionProps) {
+	const count = sectionProps?.columnCount ?? 1;
+	if (count <= 1) return void 0;
+	const columns = {
+		count,
+		gap: twipsToPixels(sectionProps?.columnSpace ?? DEFAULT_COLUMN_SPACE_TWIPS),
+		equalWidth: sectionProps?.equalWidth ?? true
+	};
+	if (sectionProps?.separator !== void 0) columns.separator = sectionProps.separator;
+	return columns;
+}
+//#endregion
+export { getColumns };

package/dist/layout-bridge/tableInsertHover.d.ts

@@ -0,0 +1,42 @@
+//#region src/layout-bridge/tableInsertHover.d.ts
+/**
+ * Table-insert "+" hover hit-test.
+ *
+ * Pure DOM logic for the floating row/column insert button that shows
+ * when the mouse is near the left or top edge of a layout table. Lives
+ * in core so React + Vue + any future adapter can share the hit-test
+ * and just wire up their own UI rendering of the button.
+ *
+ * The function is gated by `hfEditMode`: tables in inactive HF/body
+ * regions don't surface the affordance. A header table only matches
+ * when the user is editing the header; a body table only matches when
+ * not in any HF edit mode.
+ * @packageDocumentation
+ * @public
+ */
+declare const TABLE_INSERT_EDGE_PROXIMITY = 30;
+declare const TABLE_INSERT_HIDE_DELAY_MS = 200;
+type TableInsertHoverHit = {
+  type: "row" | "column"; /** Client-coordinate anchor for the button. Caller converts to its UI frame. */
+  clientX: number;
+  clientY: number; /** PM position of the cell the button targets. */
+  cellPmPos: number;
+};
+type TableInsertHoverInput = {
+  mouseX: number;
+  mouseY: number;
+  pagesContainer: HTMLElement; /** Element under the cursor at the time of the event (e.target). */
+  target: HTMLElement;
+  hfEditMode: "header" | "footer" | null; /** Override edge proximity in pixels (defaults to TABLE_INSERT_EDGE_PROXIMITY). */
+  edgeProximity?: number;
+};
+/**
+ * Detect whether a mousemove should surface a row/column insert "+" button.
+ *
+ * Returns the button anchor + target cell PM position, or `null` if the
+ * mouse isn't near a row's left edge or a column's top edge — or if the
+ * relevant table belongs to an inactive HF/body region.
+ */
+declare function detectTableInsertHover(input: TableInsertHoverInput): TableInsertHoverHit | null;
+//#endregion
+export { TABLE_INSERT_EDGE_PROXIMITY, TABLE_INSERT_HIDE_DELAY_MS, TableInsertHoverHit, TableInsertHoverInput, detectTableInsertHover };

package/dist/layout-bridge/tableInsertHover.js

@@ -0,0 +1,102 @@
+//#region src/layout-bridge/tableInsertHover.ts
+/**
+* Table-insert "+" hover hit-test.
+*
+* Pure DOM logic for the floating row/column insert button that shows
+* when the mouse is near the left or top edge of a layout table. Lives
+* in core so React + Vue + any future adapter can share the hit-test
+* and just wire up their own UI rendering of the button.
+*
+* The function is gated by `hfEditMode`: tables in inactive HF/body
+* regions don't surface the affordance. A header table only matches
+* when the user is editing the header; a body table only matches when
+* not in any HF edit mode.
+* @packageDocumentation
+* @public
+*/
+const TABLE_INSERT_EDGE_PROXIMITY = 30;
+const TABLE_INSERT_HIDE_DELAY_MS = 200;
+const ROW_BUTTON_OFFSET_X = 24;
+const ROW_BUTTON_OFFSET_Y = 10;
+const COL_BUTTON_OFFSET_X = 10;
+const COL_BUTTON_OFFSET_Y = 24;
+/**
+* Detect whether a mousemove should surface a row/column insert "+" button.
+*
+* Returns the button anchor + target cell PM position, or `null` if the
+* mouse isn't near a row's left edge or a column's top edge — or if the
+* relevant table belongs to an inactive HF/body region.
+*/
+function detectTableInsertHover(input) {
+	const { mouseX, mouseY, pagesContainer, target, hfEditMode, edgeProximity = 30 } = input;
+	const tableSelector = ".layout-table";
+	const rowSelector = ".layout-table-row";
+	const cellSelector = ".layout-table-cell";
+	const headerSelector = ".layout-page-header";
+	const footerSelector = ".layout-page-footer";
+	const tableIsActive = (t) => {
+		const inHeader = !!t.closest(headerSelector);
+		const inFooter = !!t.closest(footerSelector);
+		if (!inHeader && !inFooter) return !hfEditMode;
+		if (inHeader) return hfEditMode === "header";
+		return hfEditMode === "footer";
+	};
+	let tableEl = target.closest(tableSelector);
+	if (tableEl && !tableIsActive(tableEl)) tableEl = null;
+	if (!tableEl) {
+		const tables = pagesContainer.querySelectorAll(tableSelector);
+		for (const t of Array.from(tables)) {
+			if (!tableIsActive(t)) continue;
+			const r = t.getBoundingClientRect();
+			const nearLeft = mouseX >= r.left - edgeProximity && mouseX < r.left;
+			const nearTop = mouseY >= r.top - edgeProximity && mouseY < r.top;
+			const withinX = mouseX >= r.left - edgeProximity && mouseX <= r.right;
+			const withinY = mouseY >= r.top - edgeProximity && mouseY <= r.bottom;
+			if (nearLeft && withinY || nearTop && withinX) {
+				tableEl = t;
+				break;
+			}
+		}
+	}
+	if (!tableEl) return null;
+	const tableRect = tableEl.getBoundingClientRect();
+	const nearLeftEdge = mouseX < tableRect.left + edgeProximity && mouseX >= tableRect.left - edgeProximity;
+	const nearTopEdge = mouseY < tableRect.top + edgeProximity && mouseY >= tableRect.top - edgeProximity;
+	if (!nearLeftEdge && !nearTopEdge) return null;
+	const rows = tableEl.querySelectorAll(`:scope > ${rowSelector}`);
+	if (rows.length === 0) return null;
+	const getCellPmPos = (el) => el ? Number(el.dataset["pmStart"]) || 0 : 0;
+	if (nearLeftEdge) for (const row of Array.from(rows)) {
+		const rowRect = row.getBoundingClientRect();
+		if (mouseY >= rowRect.top && mouseY <= rowRect.bottom) {
+			const pmPos = getCellPmPos(row.querySelector(cellSelector));
+			if (!pmPos) break;
+			return {
+				type: "row",
+				clientX: tableRect.left - ROW_BUTTON_OFFSET_X,
+				clientY: rowRect.top + rowRect.height / 2 - ROW_BUTTON_OFFSET_Y,
+				cellPmPos: pmPos
+			};
+		}
+	}
+	const firstRow = rows[0];
+	if (nearTopEdge && firstRow) {
+		const cells = firstRow.querySelectorAll(`:scope > ${cellSelector}`);
+		for (const cell of Array.from(cells)) {
+			const cellRect = cell.getBoundingClientRect();
+			if (mouseX >= cellRect.left && mouseX <= cellRect.right) {
+				const pmPos = getCellPmPos(cell);
+				if (!pmPos) break;
+				return {
+					type: "column",
+					clientX: cellRect.left + cellRect.width / 2 - COL_BUTTON_OFFSET_X,
+					clientY: tableRect.top - COL_BUTTON_OFFSET_Y,
+					cellPmPos: pmPos
+				};
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+export { TABLE_INSERT_EDGE_PROXIMITY, TABLE_INSERT_HIDE_DELAY_MS, detectTableInsertHover };

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

@@ -2,6 +2,7 @@ import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, Co
 import { PageState, Paginator, PaginatorOptions, createPaginator } from "./paginator.js";
 import { KeepNextChain, calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { BreakDecision, SectionState, applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
+import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
 
 //#region src/layout-engine/index.d.ts
 type SectionLayoutConfig = {
@@ -41,4 +42,4 @@ declare function layoutDocument(blocks: FlowBlock[], measures: Measure[], option
  */
 declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
 //#endregion
-export { BlockId, BorderStyle, type BreakDecision, 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, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, applyContextualSpacing, applyPendingToActive, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };
+export { BlockId, BorderStyle, type BreakDecision, 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, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };

package/dist/layout-engine/index.js

@@ -6,6 +6,7 @@ import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
 import { buildTableRowBreakInfo, snapRowBreak } from "./tableRowBreak.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
 import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
+import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
 import { panic } from "better-result";
 //#region src/layout-engine/index.ts
 /**
@@ -688,4 +689,4 @@ function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionTyp
 	paginator.updateColumns(nextSectionConfig.columns ?? DEFAULT_COLUMNS);
 }
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyContextualSpacing, applyPendingToActive, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };

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

@@ -1,8 +1,9 @@
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
-import "../../utils/fontResolver.js";
+import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
 import { buildRunFontStyle, ptToPx } from "./measureHelpers.js";
 import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
+import { hasCjk } from "../../utils/scriptSegments.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
@@ -47,6 +48,35 @@ function runToFontStyle(run) {
 	return buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
 }
 /**
+* Line-HEIGHT style for a text run. Word derives a CJK line's height from an
+* East-Asian face, not the run's ascii font: real documents routinely put CJK
+* glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
+* "Century"), and Word font-links those glyphs to the default East-Asian face
+* and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
+*
+* When the run holds CJK text, swap `fontFamily` to the face whose
+* `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
+* it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
+* `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
+* unchanged, so Latin-only documents are unaffected by construction.
+*
+* The result feeds `updateMaxFont` (line height) ONLY — width measurement
+* keeps the base style so wrapping is untouched.
+*/
+function cjkLineHeightStyle(run, baseStyle) {
+	if (!run.text || !hasCjk(run.text)) return baseStyle;
+	const eastAsia = baseStyle.eastAsiaFontFamily;
+	if (eastAsia !== void 0 && isCjkFont(eastAsia)) return {
+		...baseStyle,
+		fontFamily: eastAsia
+	};
+	if (isCjkFont(baseStyle.fontFamily ?? DEFAULT_FONT_FAMILY)) return baseStyle;
+	return {
+		...baseStyle,
+		fontFamily: CJK_FALLBACK_FONT_FAMILY
+	};
+}
+/**
 * Calculate typography metrics from font size and spacing settings
 *
 * @param fontSize - Font size in points
@@ -537,7 +567,11 @@ function measureParagraph(block, maxWidth, options) {
 		if (!currentLine.maxFontMetrics || fontSize > currentLine.maxFontSize) {
 			currentLine.maxFontSize = fontSize;
 			currentLine.maxFontMetrics = getFontMetrics(style);
+			return;
 		}
+		if (fontSize !== currentLine.maxFontSize || !isCjkFont(style.fontFamily ?? "")) return;
+		const metrics = getFontMetrics(style);
+		if (metrics.singleLineRatio > currentLine.maxFontMetrics.singleLineRatio) currentLine.maxFontMetrics = metrics;
 	};
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
 		const run = runs[runIndex];
@@ -640,7 +674,8 @@ function measureParagraph(block, maxWidth, options) {
 			const textRun = run;
 			const text = textRun.text;
 			const style = runToFontStyle(textRun);
-			updateMaxFont(style);
+			const lineHeightStyle = cjkLineHeightStyle(textRun, style);
+			updateMaxFont(lineHeightStyle);
 			if (!text || text.length === 0) {
 				currentLine.toRun = runIndex;
 				currentLine.toChar = 0;
@@ -664,7 +699,7 @@ function measureParagraph(block, maxWidth, options) {
 						if (bestEnd === 0) {
 							if (currentLine.width > 0) {
 								startNewLine(runIndex, charIndex + chunkStart);
-								updateMaxFont(style);
+								updateMaxFont(lineHeightStyle);
 								continue;
 							}
 							bestEnd = 1;
@@ -677,7 +712,7 @@ function measureParagraph(block, maxWidth, options) {
 						chunkStart = chunkEnd;
 						if (chunkStart < word.length) {
 							startNewLine(runIndex, charIndex + chunkStart);
-							updateMaxFont(style);
+							updateMaxFont(lineHeightStyle);
 						}
 					}
 					charIndex = nextBreak;
@@ -687,7 +722,7 @@ function measureParagraph(block, maxWidth, options) {
 				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + WIDTH_TOLERANCE ? rawGlueWidth : 0;
 				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 					startNewLine(runIndex, charIndex);
-					updateMaxFont(style);
+					updateMaxFont(lineHeightStyle);
 				}
 				currentLine.width += wordWidth;
 				currentLine.toRun = runIndex;

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

@@ -0,0 +1,24 @@
+import { Layout } from "./types.js";
+
+//#region src/layout-engine/pmPageIndex.d.ts
+/**
+ * Exhaustiveness guard for `FlowBlock`-shaped switches. Call from the
+ * `default` arm with the still-typed value; TypeScript will refuse to
+ * compile if any variant of `FlowBlock` was missed. The thrown error
+ * names the calling site so runtime failures (e.g. an old adapter
+ * compiled against a newer core) point future debuggers at the contract.
+ */
+declare function assertExhaustiveFlowBlock(block: never, site: string): never;
+/**
+ * Page index (0-based) whose layout fragments cover `pmPos`, or null if none.
+ * Used when the painted DOM may not yet have `[data-pm-start]` for this position (virtualization).
+ *
+ * Range semantics: `[pmStart, pmEnd)` — half-open, matching ProseMirror's
+ * `pos + nodeSize` convention. Boundary positions belong to the next fragment,
+ * so when a fragment ends at the same position the next one starts, the next
+ * fragment wins (avoids returning the previous page for the start of the
+ * next paragraph).
+ */
+declare function findPageIndexContainingPmPos(layout: Layout, pmPos: number): number | null;
+//#endregion
+export { assertExhaustiveFlowBlock, findPageIndexContainingPmPos };