@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

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

@@ -0,0 +1,44 @@
+//#region src/layout-engine/measure/featureFlags.d.ts
+/**
+ * Feature flags for the measurement subsystem.
+ *
+ * Flags are read from `globalThis.__folioFeatureFlags`. This mirrors the
+ * existing `__folioLayoutInstrumentation` pattern: callers from `apps/web`
+ * (or any host app) install the bag before mounting `DocxEditor`, and the
+ * measurement code reads it on demand without taking a hard dependency on
+ * any host framework.
+ *
+ * All flags default OFF so that callers who never set the bag see exactly
+ * the same behaviour as before any of this code existed.
+ */
+/**
+ * Flag bag shape. Adding a new flag means adding a key here and a `get*Flag`
+ * accessor below.
+ */
+type FolioMeasurementFeatureFlags = {
+  /**
+   * Pre-warm the text-width cache from a Web Worker so cache misses during
+   * the line-break binary search become cache hits on subsequent probes.
+   *
+   * When OFF (default), no worker is ever created and every measurement
+   * runs on the main thread exactly as before.
+   */
+  workerFontMetrics?: boolean;
+};
+declare global {
+  var __folioFeatureFlags: FolioMeasurementFeatureFlags | undefined;
+}
+/**
+ * Read the worker-font-metrics flag. Returns `false` if the bag is missing,
+ * the key is unset, or the value is anything other than `true`. The strict
+ * comparison ensures truthy-but-not-true values (strings, numbers) cannot
+ * accidentally enable the worker path.
+ */
+declare function isWorkerFontMetricsEnabled(): boolean;
+/**
+ * Test-only helper to set the flag bag without polluting host state.
+ * Production callers should set `globalThis.__folioFeatureFlags` directly.
+ */
+declare function setFolioMeasurementFlags(flags: FolioMeasurementFeatureFlags | undefined): void;
+//#endregion
+export { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags };

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

@@ -0,0 +1,19 @@
+//#region src/layout-engine/measure/featureFlags.ts
+/**
+* Read the worker-font-metrics flag. Returns `false` if the bag is missing,
+* the key is unset, or the value is anything other than `true`. The strict
+* comparison ensures truthy-but-not-true values (strings, numbers) cannot
+* accidentally enable the worker path.
+*/
+function isWorkerFontMetricsEnabled() {
+	return globalThis.__folioFeatureFlags?.workerFontMetrics === true;
+}
+/**
+* Test-only helper to set the flag bag without polluting host state.
+* Production callers should set `globalThis.__folioFeatureFlags` directly.
+*/
+function setFolioMeasurementFlags(flags) {
+	globalThis.__folioFeatureFlags = flags;
+}
+//#endregion
+export { isWorkerFontMetricsEnabled, setFolioMeasurementFlags };

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

@@ -0,0 +1,89 @@
+//#region src/layout-engine/measure/floatingZones.d.ts
+/**
+ * Floating exclusion zones — shared between floating images and anchored
+ * text boxes. Ported from eigenpal docx-editor #474 to extract per-object
+ * zone construction out of the page renderer so text-box anchors can
+ * contribute exclusion rects through the same pipeline.
+ *
+ * Folio adds `clampFloatingWrapMargins` (near-full-width float guard) on top
+ * of the upstream conversion; without it, body text after a wide float
+ * collapses to ~1 glyph per line.
+ */
+type WrapTextDirection = "bothSides" | "left" | "right" | "largest";
+/**
+ * A single floating object's exclusion rectangle in content-area coordinates.
+ * Produced from images and anchored text boxes; consumed by
+ * `rectsToFloatingZones` to derive per-line wrap margins.
+ */
+type FloatingExclusionRect = {
+  /** Which side the object is on for simple one-sided wrapping. */side: "left" | "right"; /** X position relative to the content area. */
+  x: number; /** Y position relative to the content area. */
+  y: number;
+  width: number;
+  height: number;
+  distTop: number;
+  distBottom: number;
+  distLeft: number;
+  distRight: number;
+  wrapText?: WrapTextDirection;
+  wrapType?: string;
+};
+/**
+ * Per-object exclusion zone in the measurement coordinate space. Each rect
+ * becomes its own zone so lines at different Y positions get independently
+ * correct widths.
+ */
+type FloatingImageZone = {
+  /** Left margin reduction (pixels from left edge). */leftMargin: number; /** Right margin reduction (pixels from right edge). */
+  rightMargin: number; /** Top Y coordinate of the exclusion zone. */
+  topY: number; /** Bottom Y coordinate of the exclusion zone. */
+  bottomY: number; /** Optional split segments for centered both-sides wrapping. */
+  segments?: FloatingLineSegmentZone[];
+  /**
+   * Full-width vertical band (OOXML `topAndBottom` wrap): no text fits beside
+   * it, so any line overlapping `[topY, bottomY]` is pushed below the band
+   * (via `findClearLineY`). Ported from eigenpal docx-editor #694.
+   */
+  fullWidthBlock?: boolean;
+};
+type FloatingLineSegmentZone = {
+  leftOffset: number;
+  availableWidth: number;
+};
+type FloatingLineMargins = {
+  leftMargin: number;
+  rightMargin: number;
+  segments?: FloatingLineSegmentZone[];
+};
+/**
+ * Convert floating exclusion rectangles to per-object zones for the
+ * measurement system. Mirrors eigenpal #474.
+ *
+ * `wrapText` controls which side(s) text flows on:
+ *   - `right`     → text only on right → object blocks left side (leftMargin)
+ *   - `left`      → text only on left  → object blocks right side (rightMargin)
+ *   - `bothSides` → ideally splits the line into two segments when the
+ *                   object is centered in the column; folio currently falls
+ *                   back to the wider side because split-segment rendering
+ *                   is not yet plumbed through the painter (see comment in
+ *                   the function body).
+ *   - `largest`   → pick whichever side has more remaining room and reduce
+ *                   the line to that single side (no split).
+ */
+declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWidth: number): FloatingImageZone[];
+/**
+ * Effective horizontal text width for a line under the given margins.
+ * When the zone provides split segments (centered both-sides wrap), each
+ * segment is clipped against `leftMargin`/`rightMargin` so a side float
+ * overlapping vertically with the centered float still reduces the budget.
+ * Otherwise falls back to `baseWidth - leftMargin - rightMargin`.
+ */
+declare function getFloatingAvailableWidth(margins: FloatingLineMargins, baseWidth: number): number;
+/**
+ * Calculate width reduction for a line based on floating object zones.
+ * Returns the left and right margins (plus optional segments) that apply
+ * at this vertical position.
+ */
+declare function getFloatingMargins(lineY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, paragraphYOffset: number): FloatingLineMargins;
+//#endregion
+export { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones };

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

@@ -0,0 +1,152 @@
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+//#region src/layout-engine/measure/floatingZones.ts
+/**
+* Floating exclusion zones — shared between floating images and anchored
+* text boxes. Ported from eigenpal docx-editor #474 to extract per-object
+* zone construction out of the page renderer so text-box anchors can
+* contribute exclusion rects through the same pipeline.
+*
+* Folio adds `clampFloatingWrapMargins` (near-full-width float guard) on top
+* of the upstream conversion; without it, body text after a wide float
+* collapses to ~1 glyph per line.
+*/
+/**
+* Convert floating exclusion rectangles to per-object zones for the
+* measurement system. Mirrors eigenpal #474.
+*
+* `wrapText` controls which side(s) text flows on:
+*   - `right`     → text only on right → object blocks left side (leftMargin)
+*   - `left`      → text only on left  → object blocks right side (rightMargin)
+*   - `bothSides` → ideally splits the line into two segments when the
+*                   object is centered in the column; folio currently falls
+*                   back to the wider side because split-segment rendering
+*                   is not yet plumbed through the painter (see comment in
+*                   the function body).
+*   - `largest`   → pick whichever side has more remaining room and reduce
+*                   the line to that single side (no split).
+*/
+function rectsToFloatingZones(rects, contentWidth) {
+	return rects.map((rect) => {
+		const rectLeft = rect.x - rect.distLeft;
+		const rectRight = rect.x + rect.width + rect.distRight;
+		const rectTop = rect.y - rect.distTop;
+		const rectBottom = rect.y + rect.height + rect.distBottom;
+		if (rect.wrapType === "topAndBottom") return {
+			leftMargin: 0,
+			rightMargin: 0,
+			topY: rectTop,
+			bottomY: rectBottom,
+			fullWidthBlock: true
+		};
+		let leftMargin = 0;
+		let rightMargin = 0;
+		if (rect.wrapText === "right") leftMargin = leftObjectMargin(rectRight);
+		else if (rect.wrapText === "left") rightMargin = rightObjectMargin(rectLeft, contentWidth);
+		else if (rect.wrapText === "largest" || rect.wrapText === "bothSides" && canSplitCenteredBothSidesWrap(rectLeft, rectRight, contentWidth)) ({leftMargin, rightMargin} = largestSideMargins(rectLeft, rectRight, contentWidth));
+		else if (rect.side === "left") leftMargin = leftObjectMargin(rectRight);
+		else rightMargin = rightObjectMargin(rectLeft, contentWidth);
+		const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
+		return {
+			leftMargin: clamped.leftMargin,
+			rightMargin: clamped.rightMargin,
+			topY: rectTop,
+			bottomY: rectBottom
+		};
+	});
+}
+/**
+* Effective horizontal text width for a line under the given margins.
+* When the zone provides split segments (centered both-sides wrap), each
+* segment is clipped against `leftMargin`/`rightMargin` so a side float
+* overlapping vertically with the centered float still reduces the budget.
+* Otherwise falls back to `baseWidth - leftMargin - rightMargin`.
+*/
+function getFloatingAvailableWidth(margins, baseWidth) {
+	if (margins.segments?.length) {
+		const leftLimit = margins.leftMargin;
+		const rightLimit = baseWidth - margins.rightMargin;
+		let total = 0;
+		for (const segment of margins.segments) {
+			const start = Math.max(segment.leftOffset, leftLimit);
+			const end = Math.min(segment.leftOffset + segment.availableWidth, rightLimit);
+			total += Math.max(0, end - start);
+		}
+		return total;
+	}
+	return baseWidth - margins.leftMargin - margins.rightMargin;
+}
+/**
+* Calculate width reduction for a line based on floating object zones.
+* Returns the left and right margins (plus optional segments) that apply
+* at this vertical position.
+*/
+function getFloatingMargins(lineY, lineHeight, zones, paragraphYOffset) {
+	if (!zones || zones.length === 0) return {
+		leftMargin: 0,
+		rightMargin: 0
+	};
+	let leftMargin = 0;
+	let rightMargin = 0;
+	let segments;
+	const absoluteLineTop = paragraphYOffset + lineY;
+	const absoluteLineBottom = absoluteLineTop + lineHeight;
+	for (const zone of zones) {
+		if (absoluteLineBottom <= zone.topY || absoluteLineTop >= zone.bottomY) continue;
+		if (zone.fullWidthBlock) return {
+			leftMargin: 0,
+			rightMargin: 0,
+			segments: [{
+				leftOffset: 0,
+				availableWidth: 0
+			}]
+		};
+		if (zone.segments?.length) {
+			segments = segments ? intersectSegments(segments, zone.segments) : zone.segments;
+			continue;
+		}
+		leftMargin = Math.max(leftMargin, zone.leftMargin);
+		rightMargin = Math.max(rightMargin, zone.rightMargin);
+	}
+	if (segments) return {
+		leftMargin,
+		rightMargin,
+		segments
+	};
+	return {
+		leftMargin,
+		rightMargin
+	};
+}
+function intersectSegments(a, b) {
+	const result = [];
+	for (const left of a) for (const right of b) {
+		const start = Math.max(left.leftOffset, right.leftOffset);
+		const end = Math.min(left.leftOffset + left.availableWidth, right.leftOffset + right.availableWidth);
+		if (end > start) result.push({
+			leftOffset: start,
+			availableWidth: end - start
+		});
+	}
+	return result;
+}
+function canSplitCenteredBothSidesWrap(rectLeft, rectRight, contentWidth) {
+	return rectLeft > 0 && rectRight < contentWidth;
+}
+function largestSideMargins(rectLeft, rectRight, contentWidth) {
+	const leftWidth = Math.max(0, rectLeft);
+	return Math.max(0, contentWidth - rectRight) >= leftWidth ? {
+		leftMargin: leftObjectMargin(rectRight),
+		rightMargin: 0
+	} : {
+		leftMargin: 0,
+		rightMargin: rightObjectMargin(rectLeft, contentWidth)
+	};
+}
+function leftObjectMargin(rectRight) {
+	return Math.max(0, rectRight);
+}
+function rightObjectMargin(rectLeft, contentWidth) {
+	return Math.max(0, contentWidth - rectLeft);
+}
+//#endregion
+export { getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones };

package/dist/layout-engine/measure/font-metrics.worker.d.ts

@@ -0,0 +1,17 @@
+import { MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
+
+//#region src/layout-engine/measure/font-metrics.worker.d.ts
+/**
+ * Test-only: reset the cached OffscreenCanvas context. Used by unit
+ * tests that toggle the global `OffscreenCanvas` between cases. The
+ * worker itself never needs this — its lifetime is one tab.
+ */
+declare function __resetWorkerCtxForTests(): void;
+/**
+ * Pure-function entry point. Exported so tests can exercise the worker
+ * contract without spawning a real `Worker`. Production code only
+ * reaches this via `postMessage`.
+ */
+declare function handleMeasureRequest(req: MeasureWorkerRequest): MeasureWorkerResponse;
+//#endregion
+export { __resetWorkerCtxForTests, handleMeasureRequest };

package/dist/layout-engine/measure/font-metrics.worker.js

@@ -0,0 +1,104 @@
+import { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints } from "./measureWorkerProtocol.js";
+import { TaggedError } from "better-result";
+//#region src/layout-engine/measure/font-metrics.worker.ts
+/**
+* Web Worker entry for off-main-thread text-width measurement.
+*
+* The worker holds a single `OffscreenCanvas` 2D context and answers
+* batched `measure` requests. It is a pure function over its inputs —
+* no cache and no font-loading orchestration. The main thread owns all
+* of that.
+*
+* On any failure (no `OffscreenCanvas`, no 2D context), it replies with
+* `ok: false` so the proxy disables itself for the session and every
+* future read falls back to the main-thread canvas.
+*
+* NOTE: this file runs in worker scope. It must not import anything
+* that touches `document`, `window`, or React. The protocol module is
+* deliberately dependency-free.
+*/
+var WorkerInitError = class extends TaggedError("WorkerInitError")() {};
+let ctx = null;
+let initError = null;
+const FONT_FINGERPRINT_EPSILON = .01;
+function getCtx() {
+	if (ctx !== null) return ctx;
+	if (initError !== null) throw new WorkerInitError({ message: initError });
+	if (typeof OffscreenCanvas === "undefined") {
+		initError = "OffscreenCanvas not available in worker scope";
+		throw new WorkerInitError({ message: initError });
+	}
+	const next = new OffscreenCanvas(1, 1).getContext("2d");
+	if (next === null) {
+		initError = "Failed to acquire OffscreenCanvas 2D context";
+		throw new WorkerInitError({ message: initError });
+	}
+	ctx = next;
+	return ctx;
+}
+function isFontFingerprintMatch(context, expectedWidth) {
+	const actualWidth = context.measureText(WORKER_FONT_FINGERPRINT_TEXT).width;
+	const tolerance = Math.max(FONT_FINGERPRINT_EPSILON, expectedWidth * 1e-4);
+	return Math.abs(actualWidth - expectedWidth) <= tolerance;
+}
+function measureEntry(entry) {
+	const context = getCtx();
+	context.font = entry.font;
+	if (!isFontFingerprintMatch(context, entry.fontFingerprintWidth)) return null;
+	let width = context.measureText(entry.text).width;
+	const codePoints = countCodePoints(entry.text);
+	if (entry.letterSpacing !== 0 && codePoints > 1) width += entry.letterSpacing * (codePoints - 1);
+	width *= entry.horizontalScale;
+	return {
+		text: entry.text,
+		fontCacheKey: entry.fontCacheKey,
+		letterSpacing: entry.letterSpacing,
+		width
+	};
+}
+/**
+* Test-only: reset the cached OffscreenCanvas context. Used by unit
+* tests that toggle the global `OffscreenCanvas` between cases. The
+* worker itself never needs this — its lifetime is one tab.
+*/
+function __resetWorkerCtxForTests() {
+	ctx = null;
+	initError = null;
+}
+/**
+* Pure-function entry point. Exported so tests can exercise the worker
+* contract without spawning a real `Worker`. Production code only
+* reaches this via `postMessage`.
+*/
+function handleMeasureRequest(req) {
+	try {
+		const entries = [];
+		for (const entry of req.entries) {
+			const measured = measureEntry(entry);
+			if (measured !== null) entries.push(measured);
+		}
+		return {
+			type: "measure-result",
+			id: req.id,
+			ok: true,
+			entries
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			type: "measure-result",
+			id: req.id,
+			ok: false,
+			error: message
+		};
+	}
+}
+if (typeof self !== "undefined" && typeof addEventListener === "function") {
+	const workerScope = self;
+	addEventListener("message", (event) => {
+		const reply = handleMeasureRequest(event.data);
+		workerScope.postMessage(reply);
+	});
+}
+//#endregion
+export { __resetWorkerCtxForTests, handleMeasureRequest };

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

@@ -0,0 +1,9 @@
+import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "./measureTypes.js";
+import { MeasureProvider, getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
+import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { MeasureParagraphOptions, getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
+import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
+import { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
+export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, type MeasureParagraphOptions, type MeasureProvider, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -0,0 +1,8 @@
+import { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
+import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
+import { getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
+import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
+import { isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
+export { buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -0,0 +1,40 @@
+import { ParagraphBlock } from "../types.js";
+
+//#region src/layout-engine/measure/listMarkerWidth.d.ts
+/**
+ * OOXML default `w:defaultTabStop` (§17.6.13) when settings.xml omits it.
+ * 720 twips = 0.5 inch = 48 CSS px at 96 DPI. Folio doesn't currently parse
+ * settings.xml; documents that override this fall back to the OOXML default.
+ */
+declare const DEFAULT_TAB_STOP_TWIPS = 720;
+/**
+ * Marker font resolution per ECMA-376 §17.9.6:
+ *  1. explicit numbering-level rPr (`attrs.listMarkerFont*`),
+ *  2. first body text run's font,
+ *  3. paragraph defaults, then document defaults.
+ */
+declare function resolveListMarkerFont(block: ParagraphBlock): {
+  fontFamily: string;
+  fontSize: number;
+};
+/**
+ * Compute the marker's inline-block width in pixels, or 0 if the paragraph
+ * has no rendered marker.
+ *
+ * Honors:
+ *  - hanging indent — body wraps at `indentLeft`, marker sits at
+ *    `indentLeft - hanging`. Width is `hanging` so the marker fills the slot.
+ *  - `w:suff` (§17.9.25): `nothing` → natural width, `space` → natural +
+ *    one space glyph, `tab` (default) → grow to the next tab stop.
+ *  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
+ *    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
+ *  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,
+ *    anchored at 0 (start of body content area, NOT `w:ind`).
+ *
+ * Word interleaves the two — both custom tabs and default-grid stops are
+ * candidates; the closest stop past the marker wins (§17.6.13: the default
+ * grid is not erased by custom tabs, just augmented).
+ */
+declare function getListMarkerInlineWidth(block: ParagraphBlock): number;
+//#endregion
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };

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

@@ -0,0 +1,76 @@
+import { measureTextWidth } from "./measureProvider.js";
+import { ptToPx } from "./measureHelpers.js";
+//#region src/layout-engine/measure/listMarkerWidth.ts
+const DEFAULT_FONT_FAMILY = "Calibri";
+const DEFAULT_FONT_SIZE = 11;
+/**
+* OOXML default `w:defaultTabStop` (§17.6.13) when settings.xml omits it.
+* 720 twips = 0.5 inch = 48 CSS px at 96 DPI. Folio doesn't currently parse
+* settings.xml; documents that override this fall back to the OOXML default.
+*/
+const DEFAULT_TAB_STOP_TWIPS = 720;
+const TWIPS_TO_PX = 96 / 1440;
+/**
+* Marker font resolution per ECMA-376 §17.9.6:
+*  1. explicit numbering-level rPr (`attrs.listMarkerFont*`),
+*  2. first body text run's font,
+*  3. paragraph defaults, then document defaults.
+*/
+function resolveListMarkerFont(block) {
+	const attrs = block.attrs;
+	const firstTextRun = block.runs.find((r) => r.kind === "text");
+	return {
+		fontFamily: attrs?.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY,
+		fontSize: attrs?.listMarkerFontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE
+	};
+}
+/**
+* Compute the marker's inline-block width in pixels, or 0 if the paragraph
+* has no rendered marker.
+*
+* Honors:
+*  - hanging indent — body wraps at `indentLeft`, marker sits at
+*    `indentLeft - hanging`. Width is `hanging` so the marker fills the slot.
+*  - `w:suff` (§17.9.25): `nothing` → natural width, `space` → natural +
+*    one space glyph, `tab` (default) → grow to the next tab stop.
+*  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
+*    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
+*  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,
+*    anchored at 0 (start of body content area, NOT `w:ind`).
+*
+* Word interleaves the two — both custom tabs and default-grid stops are
+* candidates; the closest stop past the marker wins (§17.6.13: the default
+* grid is not erased by custom tabs, just augmented).
+*/
+function getListMarkerInlineWidth(block) {
+	const attrs = block.attrs;
+	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
+	const { fontFamily, fontSize } = resolveListMarkerFont(block);
+	const style = {
+		fontFamily,
+		fontSize
+	};
+	const naturalWidth = measureTextWidth(attrs.listMarker, style);
+	const suffix = attrs.listMarkerSuffix ?? "tab";
+	if (suffix === "nothing") return naturalWidth;
+	if (suffix === "space") return naturalWidth + measureTextWidth(" ", style);
+	const indent = attrs.indent;
+	const indentLeft = indent?.left ?? 0;
+	const firstLine = indent?.firstLine ?? 0;
+	const hanging = indent?.hanging ?? 0;
+	const markerStartPx = hanging > 0 ? indentLeft - hanging : indentLeft + firstLine;
+	const minBodyStart = markerStartPx + naturalWidth;
+	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX);
+	if (hanging > 0) customTabs.push(indentLeft);
+	const searchStart = hanging > 0 ? Math.max(minBodyStart, indentLeft) : minBodyStart;
+	const firstCustomPast = customTabs.filter((px) => px >= searchStart).sort((a, b) => a - b)[0];
+	const defaultTabStopPx = (attrs.defaultTabStopTwips ?? 720) * TWIPS_TO_PX;
+	const firstGridPast = defaultTabStopPx > 0 ? Math.ceil(searchStart / defaultTabStopPx) * defaultTabStopPx : void 0;
+	let bodyStart;
+	if (firstCustomPast !== void 0 && firstGridPast !== void 0) bodyStart = Math.min(firstCustomPast, firstGridPast);
+	else bodyStart = firstCustomPast ?? firstGridPast;
+	if (bodyStart === void 0) return naturalWidth + ptToPx(fontSize) * .5;
+	return bodyStart - markerStartPx;
+}
+//#endregion
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };

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

@@ -0,0 +1,25 @@
+import { FlowBlock, Measure, TableBlock, TableMeasure, TextBoxBlock, TextBoxMeasure } from "../types.js";
+import { FloatingImageZone } from "./floatingZones.js";
+//#region src/layout-engine/measure/measureBlocks.d.ts
+declare function measureTableCellBlockVisualHeight(block: FlowBlock, blockMeasure: Measure): number;
+declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
+type BandPageGeometry = {
+  pageHeight: number | number[];
+  marginBottom: number | number[];
+};
+/**
+ * Measure a block based on its type.
+ */
+declare function measureBlock(block: FlowBlock, contentWidth: number, floatingZones?: FloatingImageZone[], cumulativeY?: number, fieldValues?: ReadonlyMap<number, string>): Measure;
+declare function measureTextBoxBlock(tb: TextBoxBlock, fieldValues?: ReadonlyMap<number, string>): TextBoxMeasure;
+/**
+ * Measure all blocks with floating image support.
+ *
+ * Pre-scans all blocks to find floating images and creates exclusion zones.
+ * Then measures each block, passing the zones so paragraphs can calculate
+ * per-line widths based on vertical overlap with floating images.
+ */
+declare function measureBlocks(blocks: FlowBlock[], contentWidth: number | number[], marginTop?: number | number[], pageGeometry?: BandPageGeometry, fieldValues?: ReadonlyMap<number, string>): Measure[];
+declare function measureSingleBlockWithoutFloatingZones(block: FlowBlock, blockWidth: number, blockIndex: number): Measure;
+//#endregion
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };