@stll/folio-core 0.52.0 → 0.54.0

package/dist/controller/fontReadiness.js

@@ -1,5 +1,6 @@
+import { blockPlainText } from "../docx/blockPlainText.js";
 import { buildFontAlternates, getFontAlternate } from "../fonts/fontAlternates.js";
-import { DEFAULT_FONT_FAMILY } from "../layout-engine/measure/measureHelpers.js";
+import { DEFAULT_FONT_FAMILY, isLayoutFontFamily } from "../layout-engine/measure/measureHelpers.js";
 import { expectFontFamilyMarkAttrs, expectParagraphAttrs } from "../prosemirror/attrs/index.js";
 import { parseFontFamilyList, resolveFontFamily } from "../utils/fontResolver.js";
 //#region src/controller/fontReadiness.ts
@@ -7,9 +8,62 @@ function getDocumentFontSet() {
 	if (typeof document === "undefined" || !("fonts" in document)) return null;
 	return document.fonts;
 }
-function documentFontsAreLoaded() {
-	const fontSet = getDocumentFontSet();
-	return !fontSet || fontSet.status === "loaded";
+/**
+* Names the faces available to measurement: which faces of the families
+* measured stacks name have loaded. Equal signatures mean every measured glyph
+* resolves to the same face, so a measurement taken under one is valid under
+* the other; a host UI face loading leaves it unchanged.
+*
+* Counted over loaded faces only (a face never unloads, and a failed one adds
+* no glyphs) with a per-face identity sum, so a removal replaced by an addition
+* still changes it: a new face's id exceeds every earlier one. The family set
+* only grows, and a family joins it when first measured, so read it after
+* measuring to name what a layout measured in. Without a font set (a server or
+* headless host) there is nothing to load and the signature is constant.
+*/
+function readFontSetSignature(fontSet = getDocumentFontSet()) {
+	if (!fontSet) return NO_FONT_SET_SIGNATURE;
+	let loadedFaces = 0;
+	let loadedFaceIdSum = 0;
+	for (const face of fontSet) {
+		if (face.status !== "loaded" || !isLayoutFontFamily(face.family)) continue;
+		loadedFaces += 1;
+		loadedFaceIdSum += fontFaceId(face);
+	}
+	return `${loadedFaces}:${loadedFaceIdSum}`;
+}
+const NO_FONT_SET_SIGNATURE = "none";
+const fontFaceIds = /* @__PURE__ */ new WeakMap();
+let nextFontFaceId = 1;
+const fontFaceId = (face) => {
+	const known = fontFaceIds.get(face);
+	if (known !== void 0) return known;
+	const id = nextFontFaceId;
+	nextFontFaceId += 1;
+	fontFaceIds.set(face, id);
+	return id;
+};
+/**
+* Re-run layout whenever a face that can change a measured width finishes
+* loading after the committed layout measured without it.
+*
+* Tied to what loaded, never to a time window: fontsource splits each face
+* into `unicode-range` subsets the browser fetches when painted text first
+* needs them, so a subset can land at any moment after the first layout. A
+* load the committed layout already saw (its event can arrive after the layout
+* ran) leaves the signature unchanged and relays nothing, as does a face of a
+* family no measured stack names (a host UI font). Returns the unsubscribe
+* function.
+*/
+function watchLayoutFontLoads({ measuredFontSet, relayout, fontSet = getDocumentFontSet() }) {
+	if (!fontSet) return () => void 0;
+	const handleLoadingDone = () => {
+		const measured = measuredFontSet();
+		if (measured === null || measured === readFontSetSignature(fontSet)) return;
+		relayout();
+	};
+	fontSet.addEventListener("loadingdone", handleLoadingDone);
+	return () => fontSet.removeEventListener("loadingdone", handleLoadingDone);
 }
 const INITIAL_LAYOUT_FONT_TIMEOUT_MS = 2e3;
 const CSS_GENERIC_FONT_FAMILIES = /* @__PURE__ */ new Set([
@@ -38,15 +92,51 @@ const REGULAR_LAYOUT_FONT_DESCRIPTOR = [
 		weight: 700
 	}
 ][0];
-function waitForInitialLayoutFonts(documentModel, pmDoc) {
-	const fontSet = getDocumentFontSet();
+/**
+* Resolve once every face the first layout will measure has loaded (`true`),
+* or after a timeout (`false`), so the first layout does not measure fallbacks.
+*
+* Each face is loaded for the document's own characters. A bundled face is a
+* set of `unicode-range` subsets, and `FontFaceSet.load` fetches only the
+* subsets covering the text it is given; without text it takes a single space
+* and loads only the Latin subset, so Czech, Polish, Greek and Cyrillic were
+* measured in a fallback.
+*/
+function waitForInitialLayoutFonts(documentModel, pmDoc, fontSet = getDocumentFontSet()) {
 	if (!fontSet) return Promise.resolve(true);
+	const text = collectLayoutText(documentModel, pmDoc);
 	const loadChecks = [];
 	for (const face of collectInitialLayoutFontFaces(documentModel, pmDoc)) loadChecks.push(`${face.style} ${face.weight} 16px "${escapeCssFontFamily(face.family)}"`);
-	const loadFonts = Promise.allSettled(loadChecks.map((check) => fontSet.load(check))).then(() => fontSet.ready).then(() => true);
+	let timeout;
+	const loadFonts = Promise.allSettled(loadChecks.map((check) => fontSet.load(check, text))).then(() => fontSet.ready).then(() => true);
 	return Promise.race([loadFonts, new Promise((resolve) => {
-		globalThis.setTimeout(() => resolve(false), INITIAL_LAYOUT_FONT_TIMEOUT_MS);
-	})]);
+		timeout = globalThis.setTimeout(() => resolve(false), INITIAL_LAYOUT_FONT_TIMEOUT_MS);
+	})]).finally(() => globalThis.clearTimeout(timeout));
+}
+/**
+* Every distinct character the layout will measure, as one string: the body
+* text (tracked deletions included, since All Markup paints them), list
+* markers, headers, footers and notes. Always carries a space, which every
+* line measures.
+*/
+function collectLayoutText(documentModel, pmDoc) {
+	const characters = /* @__PURE__ */ new Set([" "]);
+	const addText = (text) => {
+		for (const character of text) if (character >= " ") characters.add(character);
+	};
+	pmDoc.descendants((node) => {
+		if (node.isText) addText(node.text ?? "");
+		else if (node.type.name === "paragraph") addText(expectParagraphAttrs(node).listMarker ?? "");
+		return true;
+	});
+	const documentPackage = documentModel?.package;
+	for (const story of [
+		...documentPackage?.headers?.values() ?? [],
+		...documentPackage?.footers?.values() ?? [],
+		...documentPackage?.footnotes ?? [],
+		...documentPackage?.endnotes ?? []
+	]) addText(blockPlainText(story.content));
+	return Array.from(characters).join("");
 }
 function collectInitialLayoutFontFamilies(documentModel, pmDoc) {
 	return new Set(collectInitialLayoutFontFaces(documentModel, pmDoc).map(({ family }) => family));
@@ -150,4 +240,4 @@ function escapeCssFontFamily(family) {
 	return family.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"");
 }
 //#endregion
-export { collectInitialLayoutFontFaces, collectInitialLayoutFontFamilies, documentFontsAreLoaded, getDocumentFontSet, waitForInitialLayoutFonts };
+export { collectInitialLayoutFontFaces, collectInitialLayoutFontFamilies, collectLayoutText, getDocumentFontSet, readFontSetSignature, waitForInitialLayoutFonts, watchLayoutFontLoads };

package/dist/controller/headerFooterEditorManager.js

@@ -9,6 +9,7 @@ import { ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdA
 import { createDocumentNumberingPlugin } from "../prosemirror/plugins/documentNumbering.js";
 import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
 import { schema } from "../prosemirror/schema/index.js";
+import { storyListNumbering } from "../prosemirror/storyListNumbering.js";
 import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/headerFooterEditorManager.ts
@@ -153,14 +154,17 @@ const createHeaderFooterEditorManager = (deps) => {
 			let footers = document.package.footers;
 			let headersChanged = false;
 			let footersChanged = false;
+			let numbering = document.package.numbering;
 			for (const { dirty, kind, rId, view } of mounted.values()) {
 				if (!dirty) continue;
 				const source = kind === "header" ? headers : footers;
 				const existing = source?.get(rId);
 				if (!source || !existing) continue;
+				const story = storyListNumbering(view.state, numbering);
+				numbering = story.numbering;
 				const updated = {
 					...existing,
-					content: proseDocToBlocks(view.state.doc, existing.content, document.package.styles)
+					content: proseDocToBlocks(story.doc, existing.content, document.package.styles)
 				};
 				clearHeaderFooterVerbatimXml(updated);
 				if (kind === "header") {
@@ -179,6 +183,7 @@ const createHeaderFooterEditorManager = (deps) => {
 			}
 			if (!headersChanged && !footersChanged) return document;
 			const packageWithSnapshots = { ...document.package };
+			if (numbering) packageWithSnapshots.numbering = numbering;
 			if (headersChanged && headers) packageWithSnapshots.headers = headers;
 			if (footersChanged && footers) packageWithSnapshots.footers = footers;
 			return {

package/dist/controller/layoutPipeline.d.ts

@@ -1,8 +1,9 @@
 import { document_d_exports } from "../types/document.js";
 import { TemplatePreviewEntry, TemplatePreviewHiddenRange } from "../prosemirror/plugins/templatePreviewValues.js";
 import { ColumnLayout, FlowBlock, FootnoteContent, HeaderFooterContent, Layout, Measure, PageHeaderFooterRefs, PageMargins } from "../layout-engine/types.js";
-import { LayoutRunReason } from "../layout-engine/layoutInstrumentation.js";
-import { DirtyRange } from "../paged-layout/incrementalMeasure.js";
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { LayoutSession } from "./layoutSession.js";
+import { LayoutRunOptions } from "./layoutRunOptions.js";
 import { HyphenationReadiness } from "./hyphenationReadiness.js";
 import { ConvertHeaderFooterOptions, HeaderFooterMetrics } from "../layout-bridge/convert/headerFooterLayout.js";
 import "../layout-engine/index.js";
@@ -10,14 +11,8 @@ import { FootnoteRenderItem } from "../layout-painter/renderPage.js";
 import { BlockLookup, LayoutPainter } from "../layout-painter/index.js";
 import { PageRendererName } from "../display-list/editor/pageRenderer.js";
 import { LayoutSelectionGate } from "../paged-layout/LayoutSelectionGate.js";
-import { LayoutSession } from "./layoutSession.js";
 import { EditorState } from "prosemirror-state";
 //#region src/controller/layoutPipeline.d.ts
-type LayoutRunOptions = {
-  dirtyRange?: DirtyRange;
-  forceFull?: boolean;
-  reason?: LayoutRunReason;
-};
 type LayoutOutcome = {
   blocks?: FlowBlock[];
   measures?: Measure[];
@@ -58,7 +53,8 @@ type LayoutPipelineDeps<THfPMs> = {
   session: LayoutSession;
   renderHfFromContentOrPm: (hf: document_d_exports.HeaderFooter | null | undefined, rId: string | null | undefined, hfPMs: THfPMs, contentWidth: number, metrics: HeaderFooterMetrics, options: ConvertHeaderFooterOptions) => HeaderFooterContent | undefined;
   renderHeaderFooterContentByRId: (source: Map<string, document_d_exports.HeaderFooter> | undefined, hfPMs: THfPMs, contentWidth: number, metrics: HeaderFooterMetrics, options: ConvertHeaderFooterOptions) => Map<string, HeaderFooterContent> | undefined;
-  documentFontsAreLoaded: () => boolean;
+  /** Names the faces measurement can use now (`fontReadiness.readFontSetSignature`). */
+  readFontSetSignature: () => string;
   buildFootnoteRenderItems: (pageFootnoteMap: Map<number, number[]>, footnoteContentMap: Map<number, FootnoteContent>, doc: document_d_exports.Document | null) => Map<number, FootnoteRenderItem[]>;
   describeInvalidHighlightMarks: (doc: EditorState["doc"]) => string;
   /**
@@ -77,7 +73,13 @@ type LayoutPipelineDeps<THfPMs> = {
   emptyTemplatePreviewHidden: readonly TemplatePreviewHiddenRange[];
   /** Follows up on the hyphenation dictionaries a run lacked (relayout or error). */
   hyphenationReadiness: HyphenationReadiness;
+  /**
+   * The review view the body is laid out for. A view other than All Markup
+   * lays out the text it shows (every revision accepted or rejected), not the
+   * authored text with runs hidden afterwards.
+   */
+  markupView: DisplayMode;
 };
 declare function runLayoutPipeline<THfPMs>(deps: LayoutPipelineDeps<THfPMs>, state: EditorState, options?: LayoutRunOptions): LayoutOutcome;
 //#endregion
-export { LayoutOutcome, LayoutPipelineDeps, LayoutRunOptions, runLayoutPipeline };
+export { LayoutOutcome, LayoutPipelineDeps, runLayoutPipeline };

package/dist/controller/layoutPipeline.js

@@ -11,16 +11,18 @@ import { buildSeqValues } from "../fields/seqValues.js";
 import { buildFontAlternates } from "../fonts/fontAlternates.js";
 import { prepareEndnoteAreas, resolveEndnotePosition, spliceEndnoteAreas, trailingEndnoteIds } from "../layout-bridge/convert/endnoteLayout.js";
 import { buildFootnoteContentMap, collectEndnoteRefs, collectFootnoteRefs, computeNoteDisplayNumbers, remapNoteMarkerText } from "../layout-bridge/convert/footnoteLayout.js";
+import { remapMarkupViewBlocks } from "../layout-bridge/convert/markupViewFlow.js";
 import { applyTemplatePreviewToBlocks } from "../layout-bridge/convert/templatePreviewFlow.js";
 import { toFlowBlocks } from "../layout-bridge/convert/toFlowBlocks.js";
 import { getColumns } from "../layout-bridge/sectionColumns.js";
 import { resolveAnchorLayoutInCellCompatibility } from "../layout-engine/anchorLayoutInCellCompatibility.js";
 import { layoutDocument } from "../layout-engine/index.js";
 import { resolveJustificationCompatibility } from "../layout-engine/justificationCompatibility.js";
-import { recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart } from "../layout-engine/layoutInstrumentation.js";
+import { recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMarkupViewIncomplete } from "../layout-engine/layoutInstrumentation.js";
+import { labelMeasureCachesFontSet, syncMeasureCachesToFontSet } from "../layout-engine/measure/cache.js";
 import { collectRequestedHyphenationDictionaries } from "../layout-engine/measure/hyphenationDictionaries.js";
 import { measureBlocks, measureSingleBlockWithoutFloatingZones } from "../layout-engine/measure/measureBlocks.js";
-import { installCanvasMeasureProvider } from "../layout-engine/measure/measureContainer.js";
+import { installCanvasMeasureProvider, resetCanvasContext } from "../layout-engine/measure/measureContainer.js";
 import { resolveEffectiveParagraphSpacingTree } from "../layout-engine/paragraphSpacing.js";
 import { resolveTableIndentCompatibility } from "../layout-engine/tableIndentCompatibility.js";
 import "../layout-engine/types.js";
@@ -28,14 +30,40 @@ import { renderPages } from "../layout-painter/renderPage.js";
 import { tryBuildIncrementalMeasures } from "../paged-layout/incrementalMeasure.js";
 import { computePerBlockMeasureInputs } from "../paged-layout/sectionBlockWidths.js";
 import { getMargins, getPageNumbering, getPageSize, twipsToPixels } from "../paged-layout/sectionGeometry.js";
+import { markupViewNotes } from "../prosemirror/markupViewNotes.js";
+import { projectMarkupView } from "../prosemirror/markupViewProjection.js";
 import { templatePreviewValuesKey } from "../prosemirror/plugins/templatePreviewValues.js";
 import { getDocumentWatermark } from "../watermark/index.js";
+import { diffAgainstCommittedLayout } from "./committedLayoutDiff.js";
+import { LAYOUT_MEASURE } from "./layoutRunOptions.js";
 //#region src/controller/layoutPipeline.ts
 const formatEndnoteTexts = (numbers, formatNumber) => {
 	const texts = /* @__PURE__ */ new Map();
 	for (const [id, displayNumber] of numbers) texts.set(id, formatNumber(displayNumber));
 	return texts;
 };
+const sameMeasureInputs = (left, right) => left.styles === right.styles && left.theme === right.theme && left.defaultTabStop === right.defaultTabStop && left.pageContentHeight === right.pageContentHeight && left.fontSet === right.fontSet && left.fontAlternates.size === right.fontAlternates.size && [...left.fontAlternates].every(([name, alternate]) => right.fontAlternates.get(name) === alternate) && left.markupView === right.markupView;
+/**
+* The range an incremental pass re-measures, or `null` for a full measure: the
+* committed measures must come from the same measure inputs, and the range is
+* where the current document and preview differ from the committed ones.
+*/
+const incrementalDirtyRange = ({ session, state, preview, measureInputs }) => {
+	const { lastPmDoc, lastMeasureInputs } = session;
+	if (!lastPmDoc || !lastMeasureInputs || !sameMeasureInputs(lastMeasureInputs, measureInputs)) return null;
+	const diff = diffAgainstCommittedLayout({
+		doc: lastPmDoc,
+		preview: session.lastTemplatePreview
+	}, {
+		doc: state.doc,
+		preview
+	});
+	switch (diff.type) {
+		case "full": return null;
+		case "range": return diff.range;
+		default: return diff;
+	}
+};
 /** Resolve only package-owned picture-watermark bytes for the DOM painter. */
 const resolveWatermarkImageSrc = (document, watermark) => {
 	if (watermark?.kind !== "picture" || watermark.imageTargetExternal === true) return;
@@ -108,11 +136,13 @@ function runLayoutPipeline(deps, state, options = {}) {
 	return result;
 }
 function runLayoutPipelineMeasured(deps, state, options) {
-	const { contentWidth, columns, pageSize, margins, pageGap, showMarginGuides, marginGuideColor, syncCoordinator, headerContent, footerContent, firstPageHeaderContent, firstPageFooterContent, headerContentRId, footerContentRId, firstPageHeaderContentRId, firstPageFooterContentRId, sectionHeaderFooterRefs, theme: _theme, sectionProperties, document, defaultTabStop, mirrorMargins, styles, layout, hfPMs, painter, pagesContainer, session, renderHfFromContentOrPm, renderHeaderFooterContentByRId, documentFontsAreLoaded, buildFootnoteRenderItems, describeInvalidHighlightMarks, pageRenderer = PAGE_RENDERER.legacy, emptyTemplatePreviewEntries: EMPTY_TEMPLATE_PREVIEW_ENTRIES, emptyTemplatePreviewHidden: EMPTY_TEMPLATE_PREVIEW_HIDDEN } = deps;
+	const { contentWidth, columns, pageSize, margins, pageGap, showMarginGuides, marginGuideColor, syncCoordinator, headerContent, footerContent, firstPageHeaderContent, firstPageFooterContent, headerContentRId, footerContentRId, firstPageHeaderContentRId, firstPageFooterContentRId, sectionHeaderFooterRefs, theme: _theme, sectionProperties, document, defaultTabStop, mirrorMargins, styles, layout, hfPMs, painter, pagesContainer, session, renderHfFromContentOrPm, renderHeaderFooterContentByRId, readFontSetSignature, buildFootnoteRenderItems, describeInvalidHighlightMarks, pageRenderer = PAGE_RENDERER.legacy, emptyTemplatePreviewEntries: EMPTY_TEMPLATE_PREVIEW_ENTRIES, emptyTemplatePreviewHidden: EMPTY_TEMPLATE_PREVIEW_HIDDEN, markupView } = deps;
 	let outcome = {};
 	let pendingArtifacts;
 	let pendingTemplatePreview;
 	installCanvasMeasureProvider();
+	const fontSet = readFontSetSignature();
+	if (syncMeasureCachesToFontSet(fontSet)) resetCanvasContext();
 	const reason = options.reason ?? "manual";
 	const recordPhaseDuration = (phase, startedAt) => {
 		recordLayoutPhase(reason, phase, performance.now() - startedAt);
@@ -124,6 +154,15 @@ function runLayoutPipelineMeasured(deps, state, options) {
 		let phaseStartedAt = performance.now();
 		const pageContentHeight = pageSize.h - margins.top - margins.bottom;
 		const fontAlternates = buildFontAlternates(document?.package.fontTable);
+		const measureInputs = {
+			styles,
+			theme: _theme,
+			defaultTabStop,
+			pageContentHeight,
+			fontSet,
+			fontAlternates,
+			markupView
+		};
 		const flowOpts = {
 			pageContentHeight,
 			fontAlternates,
@@ -151,10 +190,14 @@ function runLayoutPipelineMeasured(deps, state, options) {
 		const endnotePosition = resolveEndnotePosition(document?.package.settings?.endnotePr?.position, document?.package.document.sections?.at(-1)?.properties);
 		const bodyTrailingEndnoteIds = trailingEndnoteIds(document?.package.endnotes, endnotePosition);
 		if (bodyTrailingEndnoteIds.size > 0) flowOpts.trailingEndnoteIds = bodyTrailingEndnoteIds;
-		let newBlocks = toFlowBlocks(document === null ? state.doc.type.create({
-			...state.doc.attrs,
+		const projection = projectMarkupView(state, markupView);
+		if (projection.type === "resolved" && projection.completeness === "partial") recordMarkupViewIncomplete(markupView);
+		const viewDoc = projection.type === "resolved" ? projection.doc : state.doc;
+		let newBlocks = toFlowBlocks(document === null ? viewDoc.type.create({
+			...viewDoc.attrs,
 			_finalSectionStart: sectionProperties?.sectionStart ?? null
-		}, state.doc.content, state.doc.marks) : state.doc, flowOpts);
+		}, viewDoc.content, viewDoc.marks) : viewDoc, flowOpts);
+		if (projection.type === "resolved") newBlocks = remapMarkupViewBlocks(newBlocks, projection);
 		const previewState = templatePreviewValuesKey.getState(state);
 		const previewEntries = previewState?.entries ?? EMPTY_TEMPLATE_PREVIEW_ENTRIES;
 		const previewHidden = previewState?.hidden ?? EMPTY_TEMPLATE_PREVIEW_HIDDEN;
@@ -173,10 +216,10 @@ function runLayoutPipelineMeasured(deps, state, options) {
 		recordPhaseDuration("flow-blocks", phaseStartedAt);
 		phaseStartedAt = performance.now();
 		const footnoteRefs = collectFootnoteRefs(newBlocks);
-		const documentFootnotes = document?.package.footnotes;
+		const documentFootnotes = markupViewNotes(document?.package.footnotes, markupView, state, document);
 		const hasFootnotes = footnoteRefs.length > 0 && documentFootnotes !== void 0;
 		const footnoteDisplayNumbers = documentFootnotes ? computeNoteDisplayNumbers(documentFootnotes, footnoteRefs.map((ref) => ref.footnoteId)) : void 0;
-		const documentEndnotes = document?.package.endnotes;
+		const documentEndnotes = markupViewNotes(document?.package.endnotes, markupView, state, document);
 		const endnoteDisplayNumbers = documentEndnotes ? computeNoteDisplayNumbers(documentEndnotes, collectEndnoteRefs(newBlocks).map((ref) => ref.endnoteId)) : void 0;
 		const endnoteNumberFormat = document?.package.document.sections?.at(-1)?.properties.endnotePr?.numFmt ?? document?.package.settings?.endnotePr?.numFmt ?? "lowerRoman";
 		const endnoteTexts = endnoteDisplayNumbers ? formatEndnoteTexts(endnoteDisplayNumbers, (displayNumber) => formatOoxmlCounter(displayNumber, endnoteNumberFormat)) : void 0;
@@ -286,13 +329,19 @@ function runLayoutPipelineMeasured(deps, state, options) {
 		});
 		const blockWidths = blockMeasureInputs.widths;
 		const previousArtifacts = session.artifacts;
-		const incrementalResult = options.dirtyRange && !options.forceFull && previousArtifacts ? tryBuildIncrementalMeasures({
+		const dirtyRange = options.measure === LAYOUT_MEASURE.incremental ? incrementalDirtyRange({
+			session,
+			state,
+			preview: pendingTemplatePreview,
+			measureInputs
+		}) : null;
+		const incrementalResult = dirtyRange && previousArtifacts ? tryBuildIncrementalMeasures({
 			previousBlocks: previousArtifacts.blocks,
 			previousMeasures: previousArtifacts.measures,
 			previousBlockWidths: previousArtifacts.blockWidths,
 			nextBlocks: newBlocks,
 			nextBlockWidths: blockWidths,
-			dirtyRange: options.dirtyRange,
+			dirtyRange,
 			measureBlock: measureSingleBlockWithoutFloatingZones
 		}) : null;
 		let newMeasures = incrementalResult?.measures ?? measureBlocks(newBlocks, blockWidths, blockMeasureInputs.marginTops, {
@@ -583,11 +632,16 @@ function runLayoutPipelineMeasured(deps, state, options) {
 			renderPages(newLayout.pages, pagesContainer, renderOpts);
 			recordPhaseDuration("render-pages", phaseStartedAt);
 		}
+		const measuredFontSet = readFontSetSignature();
+		labelMeasureCachesFontSet(measuredFontSet);
 		session.artifacts = pendingArtifacts;
 		session.lastTemplatePreview = pendingTemplatePreview;
 		session.lastEditorState = state;
 		session.lastPmDoc = state.doc;
-		session.usedLoadedFonts = documentFontsAreLoaded();
+		session.lastMeasureInputs = {
+			...measureInputs,
+			fontSet: measuredFontSet
+		};
 		recordLayoutComplete(reason);
 	} catch (error) {
 		const invalidHighlights = describeInvalidHighlightMarks(state.doc);

package/dist/controller/layoutRunOptions.d.ts

@@ -0,0 +1,24 @@
+import { LayoutRunReason } from "../layout-engine/layoutInstrumentation.js";
+//#region src/controller/layoutRunOptions.d.ts
+/**
+ * How a layout pass measures its blocks.
+ *
+ * - `full` measures every block.
+ * - `incremental` may keep the committed layout's measures for the blocks the
+ *   current document shares with the document that layout was computed for.
+ *   The pass derives what changed from those two documents itself; a caller
+ *   never supplies a changed range, so the range cannot be relative to a
+ *   document the committed measures did not come from.
+ */
+declare const LAYOUT_MEASURE: {
+  readonly full: "full";
+  readonly incremental: "incremental";
+};
+type LayoutMeasure = (typeof LAYOUT_MEASURE)[keyof typeof LAYOUT_MEASURE];
+type LayoutRunOptions = {
+  /** Defaults to {@link LAYOUT_MEASURE.full}. */
+  measure?: LayoutMeasure;
+  reason?: LayoutRunReason;
+};
+//#endregion
+export { LAYOUT_MEASURE, LayoutMeasure, LayoutRunOptions };

package/dist/controller/layoutRunOptions.js

@@ -0,0 +1,17 @@
+//#region src/controller/layoutRunOptions.ts
+/**
+* How a layout pass measures its blocks.
+*
+* - `full` measures every block.
+* - `incremental` may keep the committed layout's measures for the blocks the
+*   current document shares with the document that layout was computed for.
+*   The pass derives what changed from those two documents itself; a caller
+*   never supplies a changed range, so the range cannot be relative to a
+*   document the committed measures did not come from.
+*/
+const LAYOUT_MEASURE = {
+	full: "full",
+	incremental: "incremental"
+};
+//#endregion
+export { LAYOUT_MEASURE };

package/dist/controller/layoutScheduler.d.ts

@@ -1,11 +1,5 @@
-import { LayoutRunReason } from "../layout-engine/layoutInstrumentation.js";
-import { DirtyRange } from "../paged-layout/incrementalMeasure.js";
+import { LayoutRunOptions } from "./layoutRunOptions.js";
 //#region src/controller/layoutScheduler.d.ts
-type LayoutRunOptions = {
-  dirtyRange?: DirtyRange;
-  forceFull?: boolean;
-  reason: LayoutRunReason;
-};
 type RunLayout<TState> = (state: TState, options: LayoutRunOptions) => void;
 type SchedulerClock = {
   requestFrame: (callback: () => void) => number;
@@ -16,6 +10,11 @@ type SchedulerClock = {
 };
 declare const browserClock: SchedulerClock;
 type LayoutSchedulerConfig<TState> = {
+  /**
+   * The editor's current state, read when a pass runs; `null` (no editor)
+   * skips the pass.
+   */
+  readState: () => TState | null;
   runLayout: RunLayout<TState>;
   /** Quiet-window debounce before an interactive layout pass. */
   debounceMs: number;
@@ -30,16 +29,22 @@ type LayoutSchedulerConfig<TState> = {
    */
   clock: SchedulerClock;
 };
-type LayoutScheduler<TState> = {
+/** Interactive transaction layout timing shared by framework adapters. */
+declare const TRANSACTION_LAYOUT_TIMING: {
+  readonly debounceMs: 32;
+  readonly maxDelayMs: 96;
+  readonly leadingFrame: true;
+};
+type LayoutScheduler = {
   /**
-   * Schedule a layout pass after a short coalescing window. Repeated calls in
-   * the window replace the pending state and merge dirty ranges, so a typing
-   * burst paints once while still honoring the max-latency cap.
+   * Request an incremental layout pass after a short coalescing window.
+   * Repeated calls in the window join the pending request, so a typing burst
+   * paints once while still honoring the max-latency cap.
    */
-  schedule: (state: TState, dirtyRange: DirtyRange | null) => void;
+  schedule: () => void;
   /** Cancel any pending timer/frame. Call on teardown. */
   dispose: () => void;
 };
-declare const createLayoutScheduler: <TState>(config: LayoutSchedulerConfig<TState>) => LayoutScheduler<TState>;
+declare const createLayoutScheduler: <TState>(config: LayoutSchedulerConfig<TState>) => LayoutScheduler;
 //#endregion
-export { LayoutRunOptions, LayoutScheduler, LayoutSchedulerConfig, RunLayout, SchedulerClock, browserClock, createLayoutScheduler };
+export { LayoutScheduler, LayoutSchedulerConfig, RunLayout, SchedulerClock, TRANSACTION_LAYOUT_TIMING, browserClock, createLayoutScheduler };

package/dist/controller/layoutScheduler.js

@@ -1,4 +1,4 @@
-import { mergeDirtyRanges } from "../paged-layout/incrementalMeasure.js";
+import { LAYOUT_MEASURE } from "./layoutRunOptions.js";
 //#region src/controller/layoutScheduler.ts
 const browserClock = {
 	requestFrame: (callback) => window.requestAnimationFrame(callback),
@@ -7,6 +7,12 @@ const browserClock = {
 	clearTimer: (id) => window.clearTimeout(id),
 	now: () => window.performance.now()
 };
+/** Interactive transaction layout timing shared by framework adapters. */
+const TRANSACTION_LAYOUT_TIMING = {
+	debounceMs: 32,
+	maxDelayMs: 96,
+	leadingFrame: true
+};
 const createLayoutScheduler = (config) => {
 	const clock = config.clock;
 	let lastRunAt = null;
@@ -15,13 +21,14 @@ const createLayoutScheduler = (config) => {
 		if (!pending || pending.rafId !== null) return;
 		pending.timerId = null;
 		pending.rafId = clock.requestFrame(() => {
-			const latest = pending;
 			pending = null;
-			if (!latest) return;
 			lastRunAt = clock.now();
-			const options = { reason: "transaction" };
-			if (latest.dirtyRange) options.dirtyRange = latest.dirtyRange;
-			config.runLayout(latest.state, options);
+			const state = config.readState();
+			if (state === null) return;
+			config.runLayout(state, {
+				reason: "transaction",
+				measure: LAYOUT_MEASURE.incremental
+			});
 		});
 	};
 	const armTimer = (request) => {
@@ -32,18 +39,14 @@ const createLayoutScheduler = (config) => {
 		request.timerId = clock.setTimer(flushPending, delayMs);
 	};
 	return {
-		schedule(state, dirtyRange) {
+		schedule() {
 			if (pending) {
-				pending.state = state;
-				pending.dirtyRange = mergeDirtyRanges(pending.dirtyRange, dirtyRange);
 				armTimer(pending);
 				return;
 			}
 			const next = {
-				dirtyRange,
 				firstScheduledAt: clock.now(),
 				rafId: null,
-				state,
 				timerId: null
 			};
 			pending = next;
@@ -62,4 +65,4 @@ const createLayoutScheduler = (config) => {
 	};
 };
 //#endregion
-export { browserClock, createLayoutScheduler };
+export { TRANSACTION_LAYOUT_TIMING, browserClock, createLayoutScheduler };

package/dist/controller/layoutSession.d.ts

@@ -1,5 +1,8 @@
+import { document_d_exports } from "../types/document.js";
 import { TemplatePreviewEntry, TemplatePreviewHiddenRange, TemplatePreviewValues } from "../prosemirror/plugins/templatePreviewValues.js";
 import { FlowBlock, Measure } from "../layout-engine/types.js";
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { FontAlternates } from "../fonts/fontAlternates.js";
 import { EditorState } from "prosemirror-state";
 //#region src/controller/layoutSession.d.ts
 type LayoutArtifacts = {
@@ -12,13 +15,34 @@ type LayoutTemplatePreview = {
   hidden: readonly TemplatePreviewHiddenRange[];
   mode: TemplatePreviewValues["mode"];
 };
+/**
+ * The inputs besides the ProseMirror document and block widths that a block's
+ * measure depends on. An incremental pass keeps committed measures only when
+ * these are the ones they were computed with. The `Document` model itself is
+ * not among them: adapters hand back a new one after every edit, while a load
+ * that changes how text measures brings new styles or font alternates.
+ */
+type LayoutMeasureInputs = {
+  styles: document_d_exports.StyleDefinitions | null | undefined;
+  theme: document_d_exports.Theme | null | undefined;
+  defaultTabStop: number | undefined;
+  pageContentHeight: number;
+  /**
+   * The font set (`readFontSetSignature`) the measures were taken in. A face
+   * that loads afterwards changes it, so fallback measures are never reused.
+   */
+  fontSet: string;
+  fontAlternates: FontAlternates;
+  /** The review view: each lays out different text, so a measure is reusable only within one. */
+  markupView: DisplayMode;
+};
 type LayoutSession = {
   artifacts: LayoutArtifacts | null;
   lastEditorState: EditorState | null;
   lastPmDoc: EditorState["doc"] | null;
-  usedLoadedFonts: boolean;
+  lastMeasureInputs: LayoutMeasureInputs | null;
   lastTemplatePreview: LayoutTemplatePreview;
 };
 declare const createLayoutSession: () => LayoutSession;
 //#endregion
-export { LayoutArtifacts, LayoutSession, LayoutTemplatePreview, createLayoutSession };
+export { LayoutArtifacts, LayoutMeasureInputs, LayoutSession, LayoutTemplatePreview, createLayoutSession };

package/dist/controller/layoutSession.js

@@ -3,7 +3,7 @@ const createLayoutSession = () => ({
 	artifacts: null,
 	lastEditorState: null,
 	lastPmDoc: null,
-	usedLoadedFonts: false,
+	lastMeasureInputs: null,
 	lastTemplatePreview: {
 		entries: [],
 		hidden: [],

package/dist/controller/noteEditorManager.js

@@ -8,6 +8,7 @@ import { ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdA
 import { createDocumentNumberingPlugin } from "../prosemirror/plugins/documentNumbering.js";
 import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
 import { schema } from "../prosemirror/schema/index.js";
+import { storyListNumbering } from "../prosemirror/storyListNumbering.js";
 import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/noteEditorManager.ts
@@ -163,8 +164,11 @@ const createNoteEditorManager = (deps) => {
 			let endnotes = document.package.endnotes;
 			let footnotesChanged = false;
 			let endnotesChanged = false;
+			let numbering = document.package.numbering;
 			for (const story of mounted.values()) {
 				if (!story.dirty) continue;
+				const lists = storyListNumbering(story.view.state, numbering);
+				numbering = lists.numbering;
 				if (story.note.kind === "footnote") {
 					const index = footnotes?.findIndex(({ id }) => id === story.note.noteId) ?? -1;
 					const current = index === -1 ? null : footnotes?.at(index);
@@ -175,7 +179,7 @@ const createNoteEditorManager = (deps) => {
 					}
 					const updated = {
 						...current,
-						content: proseDocToBlocks(story.view.state.doc, current.content, document.package.styles)
+						content: proseDocToBlocks(lists.doc, current.content, document.package.styles)
 					};
 					footnotes[index] = updated;
 					story.appliedNote = updated;
@@ -192,7 +196,7 @@ const createNoteEditorManager = (deps) => {
 				}
 				const updated = {
 					...current,
-					content: proseDocToBlocks(story.view.state.doc, current.content, document.package.styles)
+					content: proseDocToBlocks(lists.doc, current.content, document.package.styles)
 				};
 				endnotes[index] = updated;
 				story.appliedNote = updated;
@@ -205,7 +209,8 @@ const createNoteEditorManager = (deps) => {
 				package: {
 					...document.package,
 					...footnotesChanged && footnotes ? { footnotes } : {},
-					...endnotesChanged && endnotes ? { endnotes } : {}
+					...endnotesChanged && endnotes ? { endnotes } : {},
+					...numbering ? { numbering } : {}
 				}
 			};
 		},