@stll/folio-core 0.52.0 → 0.54.0

package/dist/layout-bridge/convert/markupViewFlow.js

@@ -0,0 +1,123 @@
+import { indexedPositionMap } from "../../internal/indexedPositionMap.js";
+//#region src/layout-bridge/convert/markupViewFlow.ts
+/**
+* Re-address blocks built from a view projection in editor positions, and mark
+* the paragraphs the view flags with a change bar.
+*/
+function remapMarkupViewBlocks(blocks, { positionMap, changeBarRanges }) {
+	const inverse = positionMap.invert();
+	const cutSet = /* @__PURE__ */ new Set();
+	inverse.forEach((oldStart, oldEnd) => {
+		cutSet.add(oldStart);
+		cutSet.add(oldEnd);
+	});
+	const context = {
+		toSource: indexedPositionMap(inverse),
+		cuts: [...cutSet].sort((left, right) => left - right),
+		changeBarRanges
+	};
+	return blocks.map((block) => remapBlock(block, context));
+}
+const touchesChangeBar = (block, ranges) => {
+	const { pmStart, pmEnd } = block;
+	if (pmStart === void 0 || pmEnd === void 0) return false;
+	return ranges.some((range) => range.from < pmEnd && range.to > pmStart);
+};
+/** A node's own positions: its start after any hidden content before it, its end before any after. */
+const remapNodeRange = (range, toSource) => {
+	if (range.pmStart === void 0 || range.pmEnd === void 0) return {};
+	const pmStart = toSource(range.pmStart, 1);
+	return {
+		pmStart,
+		pmEnd: Math.max(pmStart, toSource(range.pmEnd, -1))
+	};
+};
+const remapSdtGroups = (groups, toSource) => groups === void 0 ? {} : { sdtGroups: groups.map((group) => ({
+	...group,
+	pmPos: toSource(group.pmPos, 1)
+})) };
+function remapBlock(block, context) {
+	switch (block.kind) {
+		case "paragraph": return remapParagraph(block, context);
+		case "table": return remapTable(block, context);
+		case "image":
+		case "pageBreak":
+		case "columnBreak": return {
+			...block,
+			...remapNodeRange(block, context.toSource)
+		};
+		case "textBox": return {
+			...block,
+			...remapNodeRange(block, context.toSource),
+			content: block.content.map((contentBlock) => contentBlock.kind === "table" ? remapTable(contentBlock, context) : remapParagraph(contentBlock, context))
+		};
+		case "sectionBreak": return block;
+		default: return block;
+	}
+}
+function remapTable(block, context) {
+	return {
+		...block,
+		...remapNodeRange(block, context.toSource),
+		...remapSdtGroups(block.sdtGroups, context.toSource),
+		rows: block.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell) => ({
+				...cell,
+				blocks: cell.blocks.map((cellBlock) => remapBlock(cellBlock, context))
+			}))
+		}))
+	};
+}
+function remapParagraph(block, context) {
+	const runs = [];
+	for (const run of block.runs) pushRemappedRun(run, context, runs);
+	return {
+		...block,
+		...remapNodeRange(block, context.toSource),
+		...remapSdtGroups(block.sdtGroups, context.toSource),
+		...touchesChangeBar(block, context.changeBarRanges) ? { reviewIndicator: "change-bar" } : {},
+		runs
+	};
+}
+/** Index of the first cut strictly after `position`. */
+const firstCutAfter = (cuts, position) => {
+	let low = 0;
+	let high = cuts.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const cut = cuts.at(middle);
+		if (cut !== void 0 && cut <= position) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+/** Whether each character of the run occupies exactly one position. */
+const addressesPerCharacter = (run) => run.pmStart !== void 0 && run.pmEnd !== void 0 && run.templatePreview === void 0 && run.text.length === run.pmEnd - run.pmStart;
+function pushRemappedRun(run, context, out) {
+	if (run.kind !== "text" || !addressesPerCharacter(run)) {
+		out.push({
+			...run,
+			...remapNodeRange(run, context.toSource)
+		});
+		return;
+	}
+	const { pmStart, pmEnd } = run;
+	let pieceStart = pmStart;
+	for (let index = firstCutAfter(context.cuts, pmStart);; index++) {
+		const cut = context.cuts.at(index);
+		const pieceEnd = cut === void 0 || cut >= pmEnd ? pmEnd : cut;
+		out.push({
+			...run,
+			text: run.text.slice(pieceStart - pmStart, pieceEnd - pmStart),
+			...remapNodeRange({
+				pmStart: pieceStart,
+				pmEnd: pieceEnd
+			}, context.toSource)
+		});
+		if (pieceEnd === pmEnd) return;
+		pieceStart = pieceEnd;
+	}
+}
+//#endregion
+export { remapMarkupViewBlocks };

package/dist/layout-bridge/convert/tableConversion.js

@@ -65,7 +65,7 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 			blocks.push(block);
 		} else if (child.type.name === "table") blocks.push(convertTable(child, childStart, options));
 		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, childStart, options));
-		else if (child.type.name === "blockSdt") {
+		else if (child.type.name === "blockSdt" || child.type.name === "blockCustomXml") {
 			let sdtChildStart = childStart + 1;
 			child.forEach((sdtChild) => {
 				convertCellChild(sdtChild, sdtChildStart);

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -192,13 +192,22 @@ function toFlowBlocks(doc, options = {}) {
 				trailingPageBreakSectionPositions.add(childStart);
 				consumedPageBreakPositions.add(childStart + child.nodeSize);
 			}
-			if (child.type.name === "blockSdt") collectTrailingPageBreakSections(child, childStart + 1);
+			if (child.type.name === "blockSdt" || child.type.name === "blockCustomXml") collectTrailingPageBreakSections(child, childStart + 1);
 			childStart += child.nodeSize;
 		}
 	};
 	collectTrailingPageBreakSections(doc, offset);
 	const visit = (node, pos) => {
 		switch (node.type.name) {
+			case "blockCustomXml": {
+				let childOffset = pos + 1;
+				for (let i = 0; i < node.childCount; i += 1) {
+					const child = node.child(i);
+					visit(child, childOffset);
+					childOffset += child.nodeSize;
+				}
+				return;
+			}
 			case "blockSdt": {
 				const attrs = expectBlockSdtAttrs(node);
 				sdtSeq += 1;

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

@@ -32,6 +32,13 @@ type LayoutInstrumentation = {
   onLayoutStart?: (event: {
     reason: LayoutRunReason;
   }) => void;
+  /**
+   * A review view (the editor's `DisplayMode`) laid out part of the story as
+   * authored: a revision there has no resolution.
+   */
+  onMarkupViewIncomplete?: (event: {
+    view: string;
+  }) => void;
   onLayoutPhase?: (event: {
     durationMs: number;
     phase: LayoutPhase;
@@ -55,6 +62,7 @@ declare function recordMeasureBlockError(blockIndex: number, block: FlowBlock, e
 declare function recordLayoutComplete(reason?: LayoutRunReason): void;
 declare function recordLayoutStart(reason: LayoutRunReason): void;
 declare function recordLayoutError(reason: LayoutRunReason, error: unknown): void;
+declare function recordMarkupViewIncomplete(view: string): void;
 /** A dictionary failed to load; layout continues without hyphenating that language. */
 declare function recordHyphenationDictionaryError(dictionary: string, error: Error): void;
 declare function recordLayoutPhase(reason: LayoutRunReason, phase: LayoutPhase, durationMs: number): void;
@@ -62,4 +70,4 @@ declare function recordHiddenEditorStateCreate(reason: HiddenEditorStateReason):
 declare function recordHiddenEditorPhase(reason: HiddenEditorStateReason, phase: HiddenEditorPhase, durationMs: number): void;
 declare function recordDocumentLoadPhase(phase: DocumentLoadPhase, durationMs: number): void;
 //#endregion
-export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };
+export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMarkupViewIncomplete, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/layoutInstrumentation.js

@@ -25,6 +25,9 @@ function recordLayoutError(reason, error) {
 		reason
 	});
 }
+function recordMarkupViewIncomplete(view) {
+	globalThis.__folioLayoutInstrumentation?.onMarkupViewIncomplete?.({ view });
+}
 /** A dictionary failed to load; layout continues without hyphenating that language. */
 function recordHyphenationDictionaryError(dictionary, error) {
 	globalThis.__folioLayoutInstrumentation?.onHyphenationDictionaryError?.({
@@ -56,4 +59,4 @@ function recordDocumentLoadPhase(phase, durationMs) {
 	});
 }
 //#endregion
-export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };
+export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMarkupViewIncomplete, recordMeasureBlock, recordMeasureBlockError };

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

@@ -83,9 +83,26 @@ declare function getParagraphCacheSize(): number;
  * Call when fonts change, page width changes, or for testing
  */
 declare function clearAllCaches(): void;
+/**
+ * Bind the caches to the font set the next measurements are taken in. When a
+ * face has loaded (or been added or removed) since the cached entries were
+ * measured, they are dropped: a width measured in a fallback cannot be served
+ * once the face it stood in for is available. Entries measured before the
+ * caches were first bound are dropped too: nothing records their font set.
+ * Returns whether it cleared.
+ */
+declare function syncMeasureCachesToFontSet(fontSet: string): boolean;
+/**
+ * Rename the font set the cached entries were measured in, without dropping
+ * them: for a layout run that has just measured, whose signature now also
+ * names the families it measured first. Only valid within the run that bound
+ * the caches with {@link syncMeasureCachesToFontSet}, since no face can load
+ * during a synchronous run.
+ */
+declare function labelMeasureCachesFontSet(fontSet: string): void;
 /**
  * Get total size of all caches
  */
 declare function getTotalCacheSize(): number;
 //#endregion
-export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize };
+export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, labelMeasureCachesFontSet, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize, syncMeasureCachesToFontSet };

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

@@ -259,6 +259,11 @@ function getParagraphCacheSize() {
 	return paragraphMeasureCache.size;
 }
 /**
+* The font set (a `readFontSetSignature` value) every cached measurement was
+* taken in; `null` once the caches are cleared and before anything measures.
+*/
+let cachedFontSet = null;
+/**
 * Clear all measurement caches
 * Call when fonts change, page width changes, or for testing
 */
@@ -267,6 +272,31 @@ function clearAllCaches() {
 	clearFontMetricsCache();
 	clearParagraphMeasureCache();
 	clearFontResolvedCache();
+	cachedFontSet = null;
+}
+/**
+* Bind the caches to the font set the next measurements are taken in. When a
+* face has loaded (or been added or removed) since the cached entries were
+* measured, they are dropped: a width measured in a fallback cannot be served
+* once the face it stood in for is available. Entries measured before the
+* caches were first bound are dropped too: nothing records their font set.
+* Returns whether it cleared.
+*/
+function syncMeasureCachesToFontSet(fontSet) {
+	if (cachedFontSet === fontSet) return false;
+	clearAllCaches();
+	cachedFontSet = fontSet;
+	return true;
+}
+/**
+* Rename the font set the cached entries were measured in, without dropping
+* them: for a layout run that has just measured, whose signature now also
+* names the families it measured first. Only valid within the run that bound
+* the caches with {@link syncMeasureCachesToFontSet}, since no face can load
+* during a synchronous run.
+*/
+function labelMeasureCachesFontSet(fontSet) {
+	cachedFontSet = fontSet;
 }
 /**
 * Get total size of all caches
@@ -275,4 +305,4 @@ function getTotalCacheSize() {
 	return getTextCacheSize() + getFontCacheSize() + getParagraphCacheSize();
 }
 //#endregion
-export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize };
+export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, labelMeasureCachesFontSet, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize, syncMeasureCachesToFontSet };

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

@@ -1,4 +1,4 @@
-import { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints } from "./measureWorkerProtocol.js";
+import { countCodePoints } from "./measureWorkerProtocol.js";
 import { TaggedError } from "better-result";
 //#region src/layout-engine/measure/font-metrics.worker.ts
 /**
@@ -36,16 +36,12 @@ function getCtx() {
 	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;
 	context.fontKerning = entry.fontKerning;
-	if (!isFontFingerprintMatch(context, entry.fontFingerprintWidth)) return null;
+	const actualFingerprintWidth = context.measureText(entry.fontFingerprintText).width;
+	if (Math.abs(actualFingerprintWidth - entry.fontFingerprintWidth) > FONT_FINGERPRINT_EPSILON) 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);

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

@@ -1,11 +1,11 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
-import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
+import { getCachedFontMetrics, getCachedTextWidth, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
 import { setMeasureProvider } from "./measureProvider.js";
 import { canPrefetchMeasurement, prefetchMeasurement } from "./measureWorker.js";
-import { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints } from "./measureWorkerProtocol.js";
+import { countCodePoints } from "./measureWorkerProtocol.js";
 import { SMALL_CAPS_SCALE, smallCapsMask, smallCapsSegments } from "./smallCapsCasing.js";
 import { getFontKerningMode } from "./textMeasurementPolicy.js";
 import { panic } from "better-result";
@@ -31,7 +31,6 @@ const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const DEFAULT_ASCENT_RATIO = .8;
 const DEFAULT_DESCENT_RATIO = .2;
 let canvasContext = null;
-const workerFontFingerprintCache = /* @__PURE__ */ new Map();
 /**
 * Get or create a canvas 2D context for text measurement
 */
@@ -50,19 +49,6 @@ function getCanvasContext() {
 function resetCanvasContext() {
 	canvasContext = null;
 }
-function getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning) {
-	const generation = getTextWidthCacheGeneration();
-	const cached = workerFontFingerprintCache.get(fontCacheKey);
-	if (cached?.generation === generation) return cached.width;
-	ctx.font = font;
-	ctx.fontKerning = fontKerning;
-	const width = ctx.measureText(WORKER_FONT_FINGERPRINT_TEXT).width;
-	workerFontFingerprintCache.set(fontCacheKey, {
-		generation,
-		width
-	});
-	return width;
-}
 /**
 * Get typography metrics for a given font size and family
 *
@@ -149,7 +135,8 @@ function canvasMeasureTextWidth(text, sourceStyle) {
 	if (cached !== void 0) return cached;
 	ctx.font = font;
 	ctx.fontKerning = fontKerning;
-	let width = ctx.measureText(measuredText).width;
+	const metrics = ctx.measureText(measuredText);
+	let width = metrics.width;
 	if (letterSpacing) {
 		const codePoints = countCodePoints(measuredText);
 		if (codePoints > 1) width += letterSpacing * (codePoints - 1);
@@ -157,17 +144,18 @@ function canvasMeasureTextWidth(text, sourceStyle) {
 	const scaledWidth = width * horizontalScale;
 	setCachedTextWidth(measuredText, fontCacheKey, letterSpacing, scaledWidth);
 	if (!canPrefetchMeasurement()) return scaledWidth;
-	const fontFingerprintWidth = getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning);
+	const fontFingerprintText = measuredText;
+	const fontFingerprintWidth = metrics.width;
 	prefetchMeasurement({
 		text: measuredText,
 		font,
 		letterSpacing,
 		horizontalScale,
 		fontCacheKey,
+		fontFingerprintText,
 		fontFingerprintWidth,
 		fontKerning
 	});
-	prefetchBinarySearchProbes(measuredText, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale, fontKerning);
 	return scaledWidth;
 }
 /**
@@ -262,34 +250,6 @@ function measureSmallCapsWidth(measuredText, style) {
 	return width * horizontalScale;
 }
 /**
-* Speculatively enqueue the slice lengths that a subsequent
-* `findMaxFittingLength` binary search is likely to probe. We pick the
-* geometric series (full, half, quarter, eighth) which covers the
-* majority of probe points the binary search uses, without flooding
-* the worker for runs that will never trigger a line break.
-*
-* The worker is racing the main thread here: if the main thread asks
-* for slice(0, n/2) before the worker has answered, the cache miss
-* pays the main-thread cost as usual. When the worker wins, that probe
-* lands on a hit.
-*/
-function prefetchBinarySearchProbes(text, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale, fontKerning) {
-	if (text.length < 4) return;
-	for (let denom = 2; denom <= 8; denom *= 2) {
-		const len = Math.floor(text.length / denom);
-		if (len < 2) break;
-		prefetchMeasurement({
-			text: text.slice(0, len),
-			font,
-			letterSpacing,
-			horizontalScale,
-			fontCacheKey,
-			fontFingerprintWidth,
-			fontKerning
-		});
-	}
-}
-/**
 * Measure text and return full metrics
 */
 function canvasMeasureText(text, style) {

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

@@ -34,6 +34,11 @@ type ResolvedFontCache = {
  * Get the resolved font data for a font family, with caching.
  */
 declare function getResolvedData(fontFamily: string, alternateFontFamily?: string): ResolvedFontCache;
+/**
+ * Whether a face of `family` (a `FontFace.family`, possibly quoted) can change
+ * a width this page has measured.
+ */
+declare function isLayoutFontFamily(family: string): boolean;
 /**
  * Clear the resolved-font-family cache. `resolveFontFamily`'s output for a
  * given key can change even when the raw font names don't — e.g. when the
@@ -100,4 +105,4 @@ declare function halfPtToPx(halfPt: number): number;
  */
 declare function pxToHalfPt(px: number): number;
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, isLayoutFontFamily, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -1,4 +1,4 @@
-import { resolveFontFamily } from "../../utils/fontResolver.js";
+import { parseFontFamilyList, resolveFontFamily } from "../../utils/fontResolver.js";
 import "../../utils/fontWeights.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { eastAsiaHintApplies } from "../../utils/scriptSegments.js";
@@ -93,10 +93,30 @@ function getResolvedData(fontFamily, alternateFontFamily) {
 			singleLineRatio: resolved.singleLineRatio
 		};
 		fontResolvedCache.set(cacheKey, cached);
+		for (const family of parseFontFamilyList(resolved.cssFallback)) layoutFontFamilies.add(normalizeFontFamilyName(family));
 	}
 	return cached;
 }
 /**
+* Every family a measured font stack has named on this page, normalized.
+*
+* Recorded where measurement resolves its stacks, so it is exactly the set of
+* families whose faces can change a measured width: a face of any other family
+* loading (the host's UI font, say) cannot. Never cleared, because a family
+* stays relevant for as long as a cached or committed measurement may hold it,
+* and the set is bounded by the families the page's documents name.
+*/
+const layoutFontFamilies = /* @__PURE__ */ new Set();
+/** CSS family names match ASCII case-insensitively, quotes aside. */
+const normalizeFontFamilyName = (family) => family.trim().replace(/^(["'])(.*)\1$/u, "$2").toLowerCase();
+/**
+* Whether a face of `family` (a `FontFace.family`, possibly quoted) can change
+* a width this page has measured.
+*/
+function isLayoutFontFamily(family) {
+	return layoutFontFamilies.has(normalizeFontFamilyName(family));
+}
+/**
 * Get the CSS fallback string for a font family, with caching.
 */
 function getResolvedFallback(fontFamily, alternateFontFamily) {
@@ -207,4 +227,4 @@ function pxToHalfPt(px) {
 	return pxToPt(px) * 2;
 }
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, isLayoutFontFamily, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -15,7 +15,7 @@ import { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyM
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "./measureHelpers.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
-import { WIDTH_TOLERANCE, fieldMeasureText, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
+import { WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
 import { canClampTabToRightEdge, hasFollowingTabOnLine, hasPriorTabOnLine, measureDecimalPrefixWidthAfterTab, measureInlineWidthAfterTab } from "./paragraphTabs.js";
 import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
 //#region src/layout-engine/measure/measureParagraph.ts
@@ -215,7 +215,7 @@ function measureParagraph(block, maxWidth, options) {
 			fromChar: currentLine.fromChar,
 			toRun: currentLine.toRun,
 			toChar: currentLine.toChar,
-			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
+			width: canonicalLineWidth(currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography,
 			...currentLine.justificationPaint !== void 0 ? { justificationPaint: currentLine.justificationPaint } : {},
 			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {},

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

@@ -118,9 +118,8 @@ function ensureProxy() {
 }
 /**
 * How long to wait before flushing the queue, in milliseconds. Short
-* enough to keep the worker warm and ahead of the binary-search probes,
-* long enough to amortise `postMessage` overhead across a typical
-* paragraph's worth of probes.
+* enough to process measured entries promptly, long enough to amortise
+* `postMessage` overhead across a typical paragraph's runs.
 */
 const FLUSH_INTERVAL_MS = 10;
 /**

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

@@ -14,22 +14,21 @@ import { FontKerningMode } from "./textMeasurementPolicy.js";
  * `fontCacheKey` is the main-thread cache identity. It intentionally
  * differs from `font` when scale metadata is appended.
  *
- * `fontFingerprintWidth` is the main-thread width for
- * `WORKER_FONT_FINGERPRINT_TEXT` in the same `font`. The worker checks
- * the same sentinel before measuring and skips entries whose font
- * metrics do not match, which prevents worker fallback fonts from
- * poisoning the main-thread cache.
+ * `fontFingerprintText` is text already measured on the main thread in
+ * this font. The worker checks its unscaled width against
+ * `fontFingerprintWidth` before caching a result. This covers the actual
+ * glyphs and font subsets used by the request, including non-Latin text.
  */
 type MeasureRequestEntry = {
   text: string;
   font: string;
   fontCacheKey: string;
+  fontFingerprintText: string;
   fontFingerprintWidth: number;
   letterSpacing: number;
   horizontalScale: number;
   fontKerning: FontKerningMode;
 };
-declare const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
 /**
  * Count whole code points (not UTF-16 units) so letter spacing is applied once
  * per rendered glyph — an astral character is one glyph spanning two units.
@@ -73,4 +72,4 @@ type MeasureWorkerResponse = {
   error: string;
 };
 //#endregion
-export { MeasureRequestEntry, MeasureResponseEntry, MeasureWorkerRequest, MeasureWorkerResponse, WORKER_FONT_FINGERPRINT_TEXT, countCodePoints };
+export { MeasureRequestEntry, MeasureResponseEntry, MeasureWorkerRequest, MeasureWorkerResponse, countCodePoints };

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

@@ -1,5 +1,4 @@
 //#region src/layout-engine/measure/measureWorkerProtocol.ts
-const WORKER_FONT_FINGERPRINT_TEXT = "HAMBURGEFONTS ivwqy 0123456789";
 /**
 * Count whole code points (not UTF-16 units) so letter spacing is applied once
 * per rendered glyph — an astral character is one glyph spanning two units.
@@ -17,4 +16,4 @@ function countCodePoints(text) {
 	return count;
 }
 //#endregion
-export { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints };
+export { countCodePoints };

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

@@ -5,6 +5,17 @@ import { FloatingLineSegmentZone } from "./floatingZones.js";
 declare const DEFAULT_FONT_SIZE = 11;
 declare const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 declare const WIDTH_TOLERANCE = 0.5;
+/**
+ * The width a finished line reports. A line's width is a floating-point sum
+ * of per-token measurements, and the same text can reach it through different
+ * token groupings, e.g. a run split where a hidden revision sat measures
+ * "confirm" + "ation" where the resolved text measures "confirmation". Those
+ * sums agree only up to the last few bits, so the result snaps to a
+ * binary-exact 1/1024 px grid (under 0.0005 px, far below a device pixel):
+ * the same text yields the same width whichever grouping summed it, and the
+ * alignment offsets derived from it agree too.
+ */
+declare const canonicalLineWidth: (width: number) => number;
 /**
  * Typography metrics for a line
  */
@@ -106,4 +117,4 @@ declare function isEmptyTextRun(run: TextRun): boolean;
 declare function isBlockLayoutImageRun(run: ImageRun): boolean;
 declare function isSpaceOrTab(char: string | undefined): boolean;
 //#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, LineState, LineTypography, WIDTH_TOLERANCE, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, LineState, LineTypography, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };

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

@@ -4,6 +4,19 @@ import { DEFAULT_FONT_FAMILY, buildRunFontStyle } from "./measureHelpers.js";
 const DEFAULT_FONT_SIZE = 11;
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
+/** Grid a finished line's width snaps to: 1/1024 px, exact in binary floating point. */
+const LINE_WIDTH_GRID = 1024;
+/**
+* The width a finished line reports. A line's width is a floating-point sum
+* of per-token measurements, and the same text can reach it through different
+* token groupings, e.g. a run split where a hidden revision sat measures
+* "confirm" + "ation" where the resolved text measures "confirmation". Those
+* sums agree only up to the last few bits, so the result snaps to a
+* binary-exact 1/1024 px grid (under 0.0005 px, far below a device pixel):
+* the same text yields the same width whichever grouping summed it, and the
+* alignment offsets derived from it agree too.
+*/
+const canonicalLineWidth = (width) => Math.round(Math.max(0, width) * LINE_WIDTH_GRID) / LINE_WIDTH_GRID;
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
 * field). All three share the same formatting shape, so they measure the
@@ -79,4 +92,4 @@ function isSpaceOrTab(char) {
 	return char === " " || char === "	";
 }
 //#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };

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

@@ -585,6 +585,12 @@ type ParagraphBlock = {
    * the innermost group and draws boundary chrome per outer→inner level.
    */
   sdtGroups?: SdtGroup[];
+  /**
+   * Set by a review view that lays out resolved text (Simple Markup) on a
+   * paragraph whose authored text carries a revision the view resolved: the
+   * painter marks it with the change bar its runs no longer show.
+   */
+  reviewIndicator?: "change-bar";
 };
 /**
  * Cell border specification for rendering.

package/dist/layout-painter/renderPage.js

@@ -1326,6 +1326,7 @@ function collectContentFingerprint(block, parts) {
 	if (block.kind === "paragraph") {
 		if (block.attrs?.styleId) parts.push(`p:st:${block.attrs.styleId}`);
 		if (block.attrs?.alignment) parts.push(`p:al:${block.attrs.alignment}`);
+		if (block.reviewIndicator) parts.push(`p:ri:${block.reviewIndicator}`);
 		for (let index = 0; index < block.runs.length; index++) {
 			const run = block.runs[index];
 			if (!run) continue;

package/dist/layout-painter/renderParagraph.js

@@ -1500,7 +1500,7 @@ function bordersFormGroup(a, b) {
 	if (!a || !b) return false;
 	return bordersEqual(a.top, b.top) && bordersEqual(a.bottom, b.bottom) && bordersEqual(a.left, b.left) && bordersEqual(a.right, b.right) && bordersEqual(a.between, b.between);
 }
-const paragraphHasTrackedChanges = (block) => block.attrs?.listMarkerRevision !== void 0 || block.runs.some((run) => run.kind !== "lineBreak" && (run.isInsertion === true || run.isDeletion === true));
+const paragraphHasTrackedChanges = (block) => block.reviewIndicator === "change-bar" || block.attrs?.listMarkerRevision !== void 0 || block.runs.some((run) => run.kind !== "lineBreak" && (run.isInsertion === true || run.isDeletion === true));
 /**
 * Render a paragraph fragment
 *