@stll/folio-core 0.8.0 → 0.10.0

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

@@ -1,15 +1,18 @@
-import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
-import { buildRunFontStyle, ptToPx } from "./measureHelpers.js";
+import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
+import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
+import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
+import "./lineBreakProvider.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 { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
-import { findWordBreaks, isBreakChar } from "./lineBreaks.js";
+import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
 //#region src/layout-engine/measure/measureParagraph.ts
 /**
 * Paragraph measurement module
@@ -22,9 +25,11 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
+const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
+const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .23;
 const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
-const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .02;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
 const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
@@ -32,18 +37,25 @@ const ALL_CAPS_RATIO_THRESHOLD = .8;
 * Find the longest prefix of `text` that fits within `maxWidth` pixels.
 * Returns the number of characters that fit (at least 1 if `forceMin` is true).
 */
-function findMaxFittingLength(text, style, maxWidth, forceMin = false) {
-	let lo = 1;
-	let hi = text.length;
+function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
+	const boundaries = findGraphemeBreaks(text, policy);
+	let lo = 0;
+	let hi = boundaries.length - 1;
 	let best = 0;
 	while (lo <= hi) {
 		const mid = Math.floor((lo + hi) / 2);
-		if (measureTextWidth(text.slice(0, mid), style) <= maxWidth) {
-			best = mid;
+		const boundary = boundaries[mid];
+		if (measureTextWidth(text.slice(0, boundary), style) <= maxWidth) {
+			best = boundary;
 			lo = mid + 1;
 		} else hi = mid - 1;
 	}
-	return forceMin && best === 0 ? 1 : best;
+	return forceMin && best === 0 ? boundaries.at(0) ?? 0 : best;
+}
+function exceedsHyphenationZone(line, zoneTwips) {
+	if (line.width <= 0) return true;
+	const visibleWidth = Math.max(0, line.width - line.trailingWhitespaceWidth);
+	return Math.max(0, line.availableWidth - visibleWidth) > twipsToPx(zoneTwips) + WIDTH_TOLERANCE;
 }
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
@@ -331,34 +343,63 @@ function uppercaseLetterRatio(text) {
 	}
 	return letters === 0 ? 0 : uppercase / letters;
 }
-function fixedSpaceAdjustedShrinkTolerance({ tolerance, regularSpaceCount, nonBreakingSpaceCount }) {
-	const totalSpaces = regularSpaceCount + nonBreakingSpaceCount;
-	if (totalSpaces === 0) return tolerance;
-	return Math.max(JUSTIFY_SHRINK_TOLERANCE_RATIO, tolerance * (regularSpaceCount / totalSpaces));
-}
-function justifyShrinkToleranceRatio(block, isFirstLine, regularSpaceCount, nonBreakingSpaceCount) {
+function resolveJustifyFitStrategy(block, isFirstLine, profile) {
+	if (isShallowFullHangingListContinuation(block, isFirstLine)) return { type: "rounding" };
 	if (block.attrs?.listMarker !== void 0) {
 		const hanging = block.attrs.indent?.hanging ?? 0;
-		if (isFirstLine) return hanging <= DEFAULT_LIST_HANGING_INDENT_PX ? JUSTIFY_SHRINK_TOLERANCE_RATIO : JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO;
+		if (isFirstLine) return hanging <= DEFAULT_LIST_HANGING_INDENT_PX ? {
+			type: "space",
+			ratio: JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO
+		} : {
+			type: "width",
+			ratio: JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO
+		};
 		const left = block.attrs.indent?.left ?? 0;
-		if (hanging > 0 && left > hanging) return JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO;
-		return fixedSpaceAdjustedShrinkTolerance({
-			tolerance: JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO,
-			regularSpaceCount,
-			nonBreakingSpaceCount
-		});
+		if (hanging > 0 && left > hanging) return {
+			type: "width",
+			ratio: JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO
+		};
+		return {
+			type: "space",
+			ratio: JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO
+		};
 	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
-	const hasTabRuns = block.runs.some(isTabRun);
-	if (isFirstLine && hasTabRuns && (block.attrs?.indent?.hanging ?? 0) > 0) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
-	if (!isFirstLine && hasTabRuns && !hasTabStops) return JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO;
-	if (hasTabRuns && (isFirstLine || hasTabStops)) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
-	if (uppercaseLetterRatio(block.runs.map((run) => isTextRun(run) ? run.text ?? "" : "").join("")) > ALL_CAPS_RATIO_THRESHOLD) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
-	return fixedSpaceAdjustedShrinkTolerance({
-		tolerance: JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO,
-		regularSpaceCount,
-		nonBreakingSpaceCount
-	});
+	if (isFirstLine && profile.hasTabRuns && (block.attrs?.indent?.hanging ?? 0) > 0) return {
+		type: "width",
+		ratio: JUSTIFY_SHRINK_TOLERANCE_RATIO
+	};
+	if (!isFirstLine && profile.hasTabRuns && !hasTabStops) return {
+		type: "width",
+		ratio: JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO
+	};
+	if (profile.hasTabRuns && (isFirstLine || hasTabStops)) return {
+		type: "width",
+		ratio: (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO
+	};
+	if (profile.uppercaseRatio > ALL_CAPS_RATIO_THRESHOLD) return {
+		type: "width",
+		ratio: JUSTIFY_SHRINK_TOLERANCE_RATIO
+	};
+	return {
+		type: "space",
+		ratio: JUSTIFY_SPACE_CONTRACTION_RATIO
+	};
+}
+function compressibleSpaceWidth(text, style) {
+	const count = countCompressibleSpaces(text);
+	return count === 0 ? 0 : count * measureTextWidth(" ", style);
+}
+function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
+	if (strategy.type === "rounding") return WIDTH_TOLERANCE;
+	if (strategy.type === "width") return Math.max(WIDTH_TOLERANCE, line.availableWidth * strategy.ratio);
+	return Math.max(WIDTH_TOLERANCE, (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio);
+}
+function isShallowFullHangingListContinuation(block, isFirstLine) {
+	if (isFirstLine || block.attrs?.listMarker === void 0) return false;
+	const hanging = block.attrs.indent?.hanging ?? 0;
+	const left = block.attrs.indent?.left ?? 0;
+	return hanging > 0 && hanging < DEFAULT_LIST_HANGING_INDENT_PX && Math.abs(left - hanging) <= WIDTH_TOLERANCE;
 }
 function trimTrailingSpacesAndTabs(text) {
 	let end = text.length;
@@ -369,12 +410,20 @@ function trimTrailingSpacesAndTabs(text) {
 	}
 	return text.slice(0, end);
 }
+function trailingHangingPunctuationWidth(text, style, policy, enabled) {
+	if (!enabled || text.length === 0) return 0;
+	const lastStart = findGraphemeBreaks(text, policy).at(-2) ?? 0;
+	const lastGrapheme = text.slice(lastStart);
+	if (!isHangingPunctuation(lastGrapheme, policy)) return 0;
+	return measureTextWidth(lastGrapheme, style);
+}
 /**
 * Width of the unbreakable text glued to the end of each run.
 * A run boundary is not itself a wrap opportunity: adjacent note markers and
 * format-only word splits must wrap as one cluster.
 */
-function computeTrailingGlueWidths(runs) {
+function computeTrailingGlueWidths(block) {
+	const runs = block.runs;
 	const widths = Array.from({ length: runs.length }, () => 0);
 	for (let index = runs.length - 1; index >= 0; index--) {
 		const nextRun = runs[index + 1];
@@ -384,19 +433,124 @@ function computeTrailingGlueWidths(runs) {
 			widths[index] = widths[index + 1] ?? 0;
 			continue;
 		}
-		if (isSpaceOrTab(text[0])) continue;
+		if (isSpaceOrTab(text.at(0))) continue;
 		const style = runToFontStyle(nextRun);
-		const breaks = findWordBreaks(text);
-		if (breaks.length === 0) {
-			widths[index] = measureTextWidth(text, style) + (widths[index + 1] ?? 0);
-			continue;
+		const firstBreak = findWordBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: nextRun
+		}).provider).at(0);
+		widths[index] = measureTextWidth(firstBreak === void 0 ? text : trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
+	}
+	return widths;
+}
+function computeProtectedCrossRunGlueWidths(block) {
+	const widths = Array.from({ length: block.runs.length }, () => 0);
+	for (let index = 0; index < block.runs.length; index++) {
+		const run = block.runs[index];
+		if (!run || !isTextRun(run)) continue;
+		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
+		const token = trailing?.[1];
+		const policy = resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider;
+		if (!token || token.length !== 1 || !policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
+		let separator = trailing[2] ?? "";
+		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
+		let followingWord = "";
+		let unseparatedFollowingText = false;
+		for (let nextIndex = index + 1; nextIndex < block.runs.length; nextIndex++) {
+			const nextRun = block.runs[nextIndex];
+			if (!nextRun || !isTextRun(nextRun)) break;
+			const text = nextRun.text ?? "";
+			let consumed = "";
+			for (const char of text) {
+				const isWhitespace = /\s/u.test(char);
+				if (followingWord.length > 0 && isWhitespace) break;
+				if (separator.length === 0 && !isWhitespace) {
+					unseparatedFollowingText = true;
+					break;
+				}
+				consumed += char;
+				if (isWhitespace) separator += char;
+				else followingWord += char;
+			}
+			if (consumed.length > 0) glueWidth += measureTextWidth(consumed, runToFontStyle(nextRun));
+			if (unseparatedFollowingText) break;
+			if (followingWord.length > 0 && consumed.length < text.length) break;
 		}
-		const firstBreak = breaks[0];
-		if (firstBreak === void 0) continue;
-		widths[index] = measureTextWidth(trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style);
+		if (unseparatedFollowingText || separator.length === 0 || followingWord.length === 0) continue;
+		const boundary = token.length + separator.length;
+		if (!findWordBreaks(token + separator + followingWord, policy).includes(boundary)) widths[index] = glueWidth;
 	}
 	return widths;
 }
+/** Collect one lexical word continued through adjacent formatting runs. */
+function collectCrossRunWord({ block, startRunIndex, startChar }) {
+	const segments = [];
+	let text = "";
+	let width = 0;
+	for (let runIndex = startRunIndex; runIndex < block.runs.length; runIndex++) {
+		const run = block.runs[runIndex];
+		if (!run || !isTextRun(run)) break;
+		const start = runIndex === startRunIndex ? startChar : 0;
+		const remainder = run.text.slice(start);
+		if (remainder.length === 0) continue;
+		if (runIndex !== startRunIndex && isSpaceOrTab(remainder[0])) break;
+		const remainingBudget = 256 - text.length;
+		const boundedRemainder = remainder.slice(0, remainingBudget + 1);
+		const firstBreak = findWordBreaks(boundedRemainder, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run
+		}).provider).at(0);
+		const segmentText = trimTrailingSpacesAndTabs(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
+		if (segmentText.length === 0) break;
+		if (segmentText.length > remainingBudget) return;
+		const style = runToFontStyle(run);
+		segments.push({
+			runIndex,
+			startChar: start,
+			text: segmentText,
+			run,
+			style
+		});
+		text += segmentText;
+		width += measureTextWidth(segmentText, style);
+		if (firstBreak !== void 0) break;
+	}
+	if (segments.length < 2) return;
+	const firstRun = segments[0]?.run;
+	if (!firstRun) return;
+	return {
+		text,
+		width,
+		breaks: findHyphenationBreaks(text, resolveEffectiveLineBreakPolicy({
+			attrs: block.attrs,
+			run: firstRun
+		}).provider),
+		segments
+	};
+}
+function measureCrossRunPrefix(word, breakOffset) {
+	let width = 0;
+	let remaining = breakOffset;
+	const measuredSegments = [];
+	for (const segment of word.segments) {
+		const length = Math.min(remaining, segment.text.length);
+		if (length > 0) {
+			width += measureTextWidth(segment.text.slice(0, length), segment.style);
+			measuredSegments.push(segment);
+		}
+		if (remaining <= segment.text.length) return {
+			width,
+			endRunIndex: segment.runIndex,
+			endChar: segment.startChar + remaining,
+			hyphenStyle: segment.style,
+			segments: measuredSegments
+		};
+		remaining -= segment.text.length;
+	}
+}
 /**
 * Minimum horizontal room a line must offer before we treat it as usable for
 * body text. Below this threshold the line is bumped past obstructing floats
@@ -446,6 +600,12 @@ function measureParagraph(block, maxWidth, options) {
 	const attrs = block.attrs;
 	const spacing = attrs?.spacing;
 	const isJustifiedParagraph = attrs?.alignment === "justify";
+	const justificationProfile = {
+		hasTabRuns: isJustifiedParagraph && runs.some(isTabRun),
+		uppercaseRatio: isJustifiedParagraph ? uppercaseLetterRatio(runs.map((run) => isTextRun(run) ? run.text ?? "" : "").join("")) : 0
+	};
+	const firstLineJustifyFitStrategy = resolveJustifyFitStrategy(block, true, justificationProfile);
+	const continuationJustifyFitStrategy = resolveJustifyFitStrategy(block, false, justificationProfile);
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -476,6 +636,7 @@ function measureParagraph(block, maxWidth, options) {
 	const firstLineFloatingMargins = getFloatingMargins(cumulativeHeight, estimatedFirstLineHeight, floatingZones, paragraphYOffset);
 	const firstLineWidth = Math.max(1, getFloatingAvailableWidth(firstLineFloatingMargins, baseFirstLineWidth));
 	const lines = [];
+	let consecutiveHyphenatedLines = 0;
 	if (runs.length === 0) {
 		if (attrs?.suppressEmptyParagraphHeight) {
 			lines.push({
@@ -534,7 +695,8 @@ function measureParagraph(block, maxWidth, options) {
 			totalHeight
 		};
 	}
-	const trailingGlueWidths = computeTrailingGlueWidths(runs);
+	const trailingGlueWidths = computeTrailingGlueWidths(block);
+	const protectedCrossRunGlueWidths = computeProtectedCrossRunGlueWidths(block);
 	let currentLine = {
 		fromRun: 0,
 		fromChar: 0,
@@ -542,11 +704,11 @@ function measureParagraph(block, maxWidth, options) {
 		toChar: 0,
 		width: 0,
 		trailingWhitespaceWidth: 0,
-		regularSpaceCount: 0,
-		nonBreakingSpaceCount: 0,
+		regularSpaceWidth: 0,
 		maxFontSize: DEFAULT_FONT_SIZE,
 		maxFontMetrics: null,
 		maxImageHeightPx: 0,
+		maxExactImageHeightPx: 0,
 		maxMathHeightPx: 0,
 		availableWidth: firstLineWidth,
 		leftOffset: firstLineFloatingMargins.leftMargin,
@@ -566,9 +728,17 @@ function measureParagraph(block, maxWidth, options) {
 		if (inlineObjectHeight > finalTypography.lineHeight) {
 			const objectHeight = inlineObjectHeight;
 			const buffer = finalTypography.descent;
-			if (line.fromRun === line.toRun) {
-				finalTypography.lineHeight = objectHeight + buffer * 2;
-				finalTypography.ascent = objectHeight + buffer;
+			const soleRun = line.fromRun === line.toRun ? runs[line.fromRun] : void 0;
+			if (line.maxExactImageHeightPx >= objectHeight) {
+				finalTypography.lineHeight = objectHeight;
+				finalTypography.ascent = objectHeight;
+				finalTypography.descent = 0;
+				return finalTypography;
+			}
+			if (soleRun && isImageRun(soleRun)) {
+				finalTypography.lineHeight = objectHeight;
+				finalTypography.ascent = objectHeight;
+				finalTypography.descent = 0;
 			} else {
 				finalTypography.lineHeight = objectHeight + buffer;
 				finalTypography.ascent = objectHeight;
@@ -598,7 +768,8 @@ function measureParagraph(block, maxWidth, options) {
 			toRun: currentLine.toRun,
 			toChar: currentLine.toChar,
 			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
-			...finalTypography
+			...finalTypography,
+			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {}
 		};
 		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
 		if (currentLine.rightOffset > 0) line.rightOffset = currentLine.rightOffset;
@@ -607,6 +778,7 @@ function measureParagraph(block, maxWidth, options) {
 			pendingFloatSkip = 0;
 		}
 		lines.push(line);
+		consecutiveHyphenatedLines = currentLine.discretionaryHyphen ? consecutiveHyphenatedLines + 1 : 0;
 		cumulativeHeight += finalTypography.lineHeight;
 	};
 	/**
@@ -625,11 +797,11 @@ function measureParagraph(block, maxWidth, options) {
 			toChar: charIndex,
 			width: 0,
 			trailingWhitespaceWidth: 0,
-			regularSpaceCount: 0,
-			nonBreakingSpaceCount: 0,
+			regularSpaceWidth: 0,
 			maxFontSize: DEFAULT_FONT_SIZE,
 			maxFontMetrics: null,
 			maxImageHeightPx: 0,
+			maxExactImageHeightPx: 0,
 			maxMathHeightPx: 0,
 			availableWidth: adjustedWidth,
 			leftOffset: floatingMargins.leftMargin,
@@ -651,7 +823,9 @@ function measureParagraph(block, maxWidth, options) {
 		const metrics = getFontMetrics(style);
 		if (metrics.singleLineRatio > currentLine.maxFontMetrics.singleLineRatio) currentLine.maxFontMetrics = metrics;
 	};
+	let crossRunResume;
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
+		if (crossRunResume && runIndex < crossRunResume.runIndex) continue;
 		const run = runs[runIndex];
 		if (isLineBreakRun(run)) {
 			currentLine.toRun = runIndex;
@@ -713,6 +887,7 @@ function measureParagraph(block, maxWidth, options) {
 			if (currentLine.width > 0 && currentLine.width + imageWidth > currentLine.availableWidth + WIDTH_TOLERANCE) startNewLine(runIndex, 0);
 			const imageFootprintPx = imageHeight + (run.distTop ?? 0) + (run.distBottom ?? 0);
 			if (imageFootprintPx > currentLine.maxImageHeightPx) currentLine.maxImageHeightPx = imageFootprintPx;
+			if (run.exactLineHeight === true && imageFootprintPx > currentLine.maxExactImageHeightPx) currentLine.maxExactImageHeightPx = imageFootprintPx;
 			currentLine.width += imageWidth;
 			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
@@ -724,11 +899,14 @@ function measureParagraph(block, maxWidth, options) {
 			const style = buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
 			updateMaxFont(style);
 			const fieldWidth = measureTextWidth(fallback, style);
-			if (currentLine.width > 0 && currentLine.width + fieldWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+			const fieldSpaceWidth = compressibleSpaceWidth(fallback, style);
+			const fieldTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, lines.length === 0 ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, fieldSpaceWidth) : WIDTH_TOLERANCE;
+			if (currentLine.width > 0 && currentLine.width + fieldWidth > currentLine.availableWidth + fieldTolerance) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
 			}
 			currentLine.width += fieldWidth;
+			currentLine.regularSpaceWidth += fieldSpaceWidth;
 			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
@@ -759,6 +937,11 @@ function measureParagraph(block, maxWidth, options) {
 			const textRun = run;
 			const text = textRun.text;
 			const style = runToFontStyle(textRun);
+			const effectiveLineBreakPolicy = resolveEffectiveLineBreakPolicy({
+				attrs: block.attrs,
+				run: textRun
+			});
+			const breakPolicy = effectiveLineBreakPolicy.provider;
 			const lineHeightStyle = cjkLineHeightStyle(textRun, style);
 			updateMaxFont(lineHeightStyle);
 			if (!text || text.length === 0) {
@@ -766,8 +949,10 @@ function measureParagraph(block, maxWidth, options) {
 				currentLine.toChar = 0;
 				continue;
 			}
-			const wordBreaks = findWordBreaks(text);
-			let charIndex = 0;
+			const wordBreaks = findWordBreaks(text, breakPolicy);
+			let charIndex = crossRunResume?.runIndex === runIndex ? crossRunResume.charIndex : 0;
+			if (crossRunResume?.runIndex === runIndex) crossRunResume = void 0;
+			let activeHyphenationWord;
 			while (charIndex < text.length) {
 				let nextBreak = text.length;
 				for (const breakPoint of wordBreaks) if (breakPoint > charIndex) {
@@ -778,29 +963,102 @@ function measureParagraph(block, maxWidth, options) {
 				const measuredWord = trimTrailingSpacesAndTabs(word);
 				const wordWidth = measureTextWidth(measuredWord, style);
 				const fullWordWidth = measureTextWidth(word, style);
-				const regularSpaces = measuredWord.split(" ").length - 1;
-				const nonBreakingSpaces = measuredWord.split("\xA0").length - 1;
-				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyShrinkToleranceRatio(block, lines.length === 0, currentLine.regularSpaceCount + regularSpaces, currentLine.nonBreakingSpaceCount + nonBreakingSpaces)) : WIDTH_TOLERANCE;
-				if (wordWidth > currentLine.availableWidth + widthTolerance) {
+				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, effectiveLineBreakPolicy.hangingPunctuation);
+				const isFirstLine = lines.length === 0;
+				const regularSpaceWidth = compressibleSpaceWidth(measuredWord, style);
+				const widthTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, isFirstLine ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, regularSpaceWidth) : WIDTH_TOLERANCE;
+				const automaticHyphenation = effectiveLineBreakPolicy.automaticHyphenation;
+				const mayHyphenateLine = automaticHyphenation.type === "enabled" && (automaticHyphenation.consecutiveLineLimit === 0 || consecutiveHyphenatedLines < automaticHyphenation.consecutiveLineLimit) && exceedsHyphenationZone(currentLine, automaticHyphenation.hyphenationZoneTwips);
+				const isRunTail = nextBreak === text.length;
+				const crossRunWord = mayHyphenateLine && isRunTail && word.length > 0 && !isBreakChar(word.at(-1)) ? collectCrossRunWord({
+					block,
+					startRunIndex: runIndex,
+					startChar: charIndex
+				}) : void 0;
+				if (mayHyphenateLine && crossRunWord === void 0 && measuredWord.length > 0 && (activeHyphenationWord === void 0 || charIndex < activeHyphenationWord.start || charIndex >= activeHyphenationWord.end)) {
+					const fullWordEnd = charIndex + measuredWord.length;
+					const fullWordText = text.slice(charIndex, fullWordEnd);
+					activeHyphenationWord = {
+						start: charIndex,
+						end: fullWordEnd,
+						text: fullWordText,
+						breaks: findHyphenationBreaks(fullWordText, breakPolicy)
+					};
+				}
+				const overflowsCurrentLine = wordWidth > 0 && currentLine.width + wordWidth > currentLine.availableWidth + widthTolerance;
+				if (mayHyphenateLine && overflowsCurrentLine && activeHyphenationWord) {
+					const consumed = charIndex - activeHyphenationWord.start;
+					const spaceLeft = currentLine.availableWidth - currentLine.width + widthTolerance;
+					const hyphenWidth = measureTextWidth("-", style);
+					let fittingBreak;
+					for (const breakOffset of activeHyphenationWord.breaks) {
+						if (breakOffset <= consumed || breakOffset >= activeHyphenationWord.text.length) continue;
+						if (measureTextWidth(activeHyphenationWord.text.slice(consumed, breakOffset), style) + hyphenWidth <= spaceLeft) fittingBreak = breakOffset;
+					}
+					if (fittingBreak !== void 0) {
+						const absoluteBreak = activeHyphenationWord.start + fittingBreak;
+						const prefix = text.slice(charIndex, absoluteBreak);
+						currentLine.width += measureTextWidth(prefix, style) + hyphenWidth;
+						currentLine.trailingWhitespaceWidth = 0;
+						currentLine.toRun = runIndex;
+						currentLine.toChar = absoluteBreak;
+						currentLine.discretionaryHyphen = { runIndex };
+						startNewLine(runIndex, absoluteBreak);
+						updateMaxFont(lineHeightStyle);
+						charIndex = absoluteBreak;
+						continue;
+					}
+				}
+				if (crossRunWord && currentLine.width + crossRunWord.width > currentLine.availableWidth + widthTolerance) {
+					const spaceLeft = currentLine.availableWidth - currentLine.width + widthTolerance;
+					let fittingPrefix;
+					for (let breakIndex = crossRunWord.breaks.length - 1; breakIndex >= 0; breakIndex -= 1) {
+						const breakOffset = crossRunWord.breaks[breakIndex];
+						if (breakOffset === void 0) continue;
+						if (breakOffset <= 0 || breakOffset >= crossRunWord.text.length) continue;
+						const prefix = measureCrossRunPrefix(crossRunWord, breakOffset);
+						if (prefix && prefix.width + measureTextWidth("-", prefix.hyphenStyle) <= spaceLeft) {
+							fittingPrefix = prefix;
+							break;
+						}
+					}
+					if (fittingPrefix) {
+						for (const segment of fittingPrefix.segments) updateMaxFont(cjkLineHeightStyle(segment.run, segment.style));
+						currentLine.width += fittingPrefix.width + measureTextWidth("-", fittingPrefix.hyphenStyle);
+						currentLine.trailingWhitespaceWidth = 0;
+						currentLine.toRun = fittingPrefix.endRunIndex;
+						currentLine.toChar = fittingPrefix.endChar;
+						currentLine.discretionaryHyphen = { runIndex: fittingPrefix.endRunIndex };
+						startNewLine(fittingPrefix.endRunIndex, fittingPrefix.endChar);
+						if (fittingPrefix.endRunIndex === runIndex) {
+							updateMaxFont(lineHeightStyle);
+							charIndex = fittingPrefix.endChar;
+							continue;
+						}
+						crossRunResume = {
+							runIndex: fittingPrefix.endRunIndex,
+							charIndex: fittingPrefix.endChar
+						};
+						charIndex = text.length;
+						continue;
+					}
+				}
+				if (wordWidth - hangingPunctuationWidth > currentLine.availableWidth + widthTolerance) {
 					let chunkStart = 0;
 					while (chunkStart < measuredWord.length) {
 						const spaceLeft = currentLine.availableWidth - currentLine.width + WIDTH_TOLERANCE;
-						let bestEnd = findMaxFittingLength(measuredWord.slice(chunkStart), style, spaceLeft);
+						let bestEnd = findMaxFittingLength(measuredWord.slice(chunkStart), style, spaceLeft, currentLine.width === 0, breakPolicy);
 						if (bestEnd === 0) {
-							if (currentLine.width > 0) {
-								startNewLine(runIndex, charIndex + chunkStart);
-								updateMaxFont(lineHeightStyle);
-								continue;
-							}
-							bestEnd = 1;
+							startNewLine(runIndex, charIndex + chunkStart);
+							updateMaxFont(lineHeightStyle);
+							continue;
 						}
 						const chunkEnd = chunkStart + bestEnd;
 						const chunk = measuredWord.slice(chunkStart, chunkEnd);
 						const chunkWidth = measureTextWidth(chunk, style);
 						currentLine.width += chunkWidth;
 						currentLine.trailingWhitespaceWidth = chunkWidth - measureTextWidth(trimTrailingSpacesAndTabs(chunk), style);
-						currentLine.regularSpaceCount += chunk.split(" ").length - 1;
-						currentLine.nonBreakingSpaceCount += chunk.split("\xA0").length - 1;
+						currentLine.regularSpaceWidth += compressibleSpaceWidth(chunk, style);
 						currentLine.toRun = runIndex;
 						currentLine.toChar = charIndex + chunkEnd;
 						chunkStart = chunkEnd;
@@ -812,23 +1070,24 @@ function measureParagraph(block, maxWidth, options) {
 					const trailingWhitespaceWidth = fullWordWidth - wordWidth;
 					currentLine.width += trailingWhitespaceWidth;
 					currentLine.trailingWhitespaceWidth = trailingWhitespaceWidth;
-					currentLine.regularSpaceCount += word.split(" ").length - 1;
-					currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
+					currentLine.regularSpaceWidth += compressibleSpaceWidth(word, style);
 					currentLine.toChar = nextBreak;
 					charIndex = nextBreak;
 					continue;
 				}
-				const rawGlueWidth = nextBreak === text.length && word.length > 0 && !isBreakChar(word[word.length - 1]) ? trailingGlueWidths[runIndex] ?? 0 : 0;
+				const wordTail = word.at(-1);
+				const protectedGlueWidth = protectedCrossRunGlueWidths[runIndex] ?? 0;
+				const rawGlueWidth = isRunTail && wordTail !== void 0 && (!isBreakChar(wordTail) || protectedGlueWidth > 0) ? Math.max(trailingGlueWidths[runIndex] ?? 0, protectedGlueWidth) : 0;
 				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
-				if (wordWidth > 0 && currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance) {
+				const hangingAllowance = glueWidth === 0 ? hangingPunctuationWidth : 0;
+				if (wordWidth > 0 && currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance + hangingAllowance) {
 					startNewLine(runIndex, charIndex);
 					updateMaxFont(lineHeightStyle);
 				}
 				currentLine.width += fullWordWidth;
 				const wordTrailingWhitespaceWidth = fullWordWidth - wordWidth;
 				currentLine.trailingWhitespaceWidth = wordWidth === 0 ? currentLine.trailingWhitespaceWidth + wordTrailingWhitespaceWidth : wordTrailingWhitespaceWidth;
-				currentLine.regularSpaceCount += word.split(" ").length - 1;
-				currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
+				currentLine.regularSpaceWidth += compressibleSpaceWidth(word, style);
 				currentLine.toRun = runIndex;
 				currentLine.toChar = nextBreak;
 				charIndex = nextBreak;

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

@@ -27,7 +27,8 @@ type FontStyle = {
   letterSpacing?: number;
   textTransform?: "uppercase";
   fontVariant?: "small-caps";
-  horizontalScale?: number;
+  horizontalScale?: number; /** Enable pair kerning for runs whose authored threshold is met. */
+  kerning?: boolean;
 };
 /**
  * Typography metrics for a font

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

@@ -1,4 +1,4 @@
-import { MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
+import { MeasureRequestEntry, MeasureWorkerRequest, MeasureWorkerResponse } from "./measureWorkerProtocol.js";
 
 //#region src/layout-engine/measure/measureWorker.d.ts
 /**
@@ -32,7 +32,7 @@ declare function __setMeasureWorkerTransport(factory: TransportFactory | null):
  * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
  * a previous error.
  */
-declare function prefetchMeasurement(text: string, font: string, letterSpacing: number, horizontalScale: number, fontCacheKey: string, fontFingerprintWidth: number): void;
+declare function prefetchMeasurement(request: MeasureRequestEntry): void;
 declare function canPrefetchMeasurement(): boolean;
 /**
  * Test-only: synchronously drain the pending queue. The caller is