@stll/folio-core 0.47.7 → 0.49.0

package/dist/ai-edits/minimal-replacement.d.ts

@@ -0,0 +1,64 @@
+import { WordDiffSegment } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.d.ts
+/** Replace `source.slice(start, end)` with `text`; offsets index the source span. */
+type TextChange = {
+  start: number;
+  end: number;
+  text: string;
+};
+/** A clean-text span that can only be replaced whole (a field result). */
+type AtomicTextSpan = {
+  offset: number;
+  length: number;
+};
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+declare const commonPrefixLength: (a: string, b: string) => number;
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+declare const commonSuffixLength: (a: string, b: string) => number;
+/**
+ * Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+ * at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+ * nothing of its source worth aligning to anyway.
+ */
+declare const MAX_TOKEN_EDITS = 1024;
+/**
+ * The shortest edit script between two token sequences (Myers, 1986), as
+ * segments of joined token text, or `null` past `maxEdits` edits.
+ *
+ * Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+ * short matches between changes so a reader sees whole phrases replaced; an
+ * edit applied directly has no reader to serve, and every token it gives up is
+ * text rewritten with someone else's formatting.
+ */
+declare const shortestTokenDiff: (before: readonly string[], after: readonly string[], maxEdits?: number) => WordDiffSegment[] | null;
+/**
+ * The changes from `source` to `replacement`, in source order and disjoint.
+ *
+ * Words (with their leading whitespace, and edge punctuation on its own; see
+ * `tokenizeWords`) are aligned by the shortest edit script, and each changed
+ * stretch is then trimmed to the characters that actually differ, so
+ * appending a letter to a word that spans two runs leaves both runs alone. A
+ * rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+ * both strings exactly (it never should), is one change over the whole span,
+ * trimmed the same way.
+ */
+declare const planTextChanges: (source: string, replacement: string) => TextChange[];
+/**
+ * The changes a diff's segments describe, in source order and disjoint: each
+ * run of `del` and `ins` segments between two `equal` ones is one change,
+ * exactly as wide as the segments say. A redline's segments come cut to the
+ * granularity its reader asked for, so they are not trimmed further.
+ */
+declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => TextChange[];
+/**
+ * `changes` widened so none cuts into an atomic span, then merged where the
+ * widening made two overlap. A widened change re-emits the source text it
+ * absorbed, so applying the result still yields exactly the replacement.
+ *
+ * `spans` are in the same coordinates as the changes (the source span's).
+ */
+declare const widenChangesToAtomicSpans: (source: string, changes: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
+/** `source` with `changes` applied; the invariant the planner owes. */
+declare const applyTextChanges: (source: string, changes: readonly TextChange[]) => string;
+//#endregion
+export { AtomicTextSpan, MAX_TOKEN_EDITS, TextChange, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/ai-edits/minimal-replacement.js

@@ -0,0 +1,282 @@
+import { tokenizeWords } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.ts
+/**
+* The smallest set of text changes that turns one clean-text span into another.
+*
+* A direct-mode replacement (`replaceInBlock`, `replaceRange`, `replaceBlock`)
+* names the text it matched and the text it wants. Swapping the whole match
+* gives every character of the result the formatting of the first one, drops
+* the inline content controls, note references and fields the match crossed,
+* and makes a one-character edit rewrite the paragraph. The edit is the
+* difference between the two strings, so that is all the applier writes:
+*
+* - Text outside a change is not touched: its runs, marks and every inline node
+*   between its characters stay exactly as they were.
+* - A change deletes only the characters it removes (text, tabs, breaks and
+*   whole field results). Non-text inline content between those characters —
+*   bookmarks, comment anchors, drawings, content-control boundaries, rendered
+*   page breaks — stays where it was; the new text is written where the first
+*   removed character stood and takes its formatting.
+* - A pure insertion follows the character before it, with the formatting that
+*   character has, the way typed text does. At the start of the matched span
+*   there is no such character inside the match, so it takes the formatting of
+*   the first matched character. A note reference's number lends no
+*   formatting: prose beside it is not superscript.
+* - An insertion at the edge of an inline content control (`w:sdt`), a link or
+*   a comment range stays inside it only when the whole match lies inside it.
+*   Matching a control's or a link's text edits it; appending to a paragraph
+*   that ends in a checkbox or a link writes after it.
+* - A field result is one unit: a change that would cut into it is widened to
+*   the whole result, which the new text then replaces as plain text (a result
+*   cannot be partly edited; it is regenerated from the field code). A field
+*   whose displayed text the replacement keeps is never touched. A match that
+*   itself starts or ends inside a field result is refused as before
+*   (`unsupportedBlock`).
+*
+* A replacement carrying inline emphasis markup (`**bold**`) states its own
+* formatting and still replaces the match whole in direct mode.
+*
+* Tracked-changes and suggested modes cut their changes from the redline diff
+* instead ({@link changesFromSegments}: word or character granularity, as the
+* caller asked), and map them onto the document by the same rules. A change
+* marks exactly the characters it removes as a deletion, which keeps their
+* runs, and writes its text as an insertion after them, formatted as the
+* first removed character that is not a note reference; a pure insertion is
+* placed and formatted as above. Nothing outside a change is wrapped in a
+* revision.
+*
+* This module is the pure half: clean-text offsets in, changes out. The
+* applier maps each change onto the document.
+*/
+const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+const commonPrefixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let index = 0;
+	while (index < limit && a.charCodeAt(index) === b.charCodeAt(index)) index++;
+	return index > 0 && isHighSurrogate(a.charCodeAt(index - 1)) ? index - 1 : index;
+};
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+const commonSuffixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let length = 0;
+	while (length < limit && a.charCodeAt(a.length - 1 - length) === b.charCodeAt(b.length - 1 - length)) length++;
+	return length > 0 && isLowSurrogate(a.charCodeAt(a.length - length)) ? length - 1 : length;
+};
+/** `change` without the characters its deleted and inserted text share at either end. */
+const trimChange = (source, change) => {
+	const removed = source.slice(change.start, change.end);
+	const prefix = commonPrefixLength(removed, change.text);
+	const suffix = commonSuffixLength(removed.slice(prefix), change.text.slice(prefix));
+	const trimmed = {
+		start: change.start + prefix,
+		end: change.end - suffix,
+		text: change.text.slice(prefix, change.text.length - suffix)
+	};
+	return trimmed.start === trimmed.end && trimmed.text.length === 0 ? null : trimmed;
+};
+const reconstructs = (segments, source, replacement) => {
+	let before = "";
+	let after = "";
+	for (const segment of segments) {
+		if (segment.type !== "ins") before += segment.text;
+		if (segment.type !== "del") after += segment.text;
+	}
+	return before === source && after === replacement;
+};
+/**
+* Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+* at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+* nothing of its source worth aligning to anyway.
+*/
+const MAX_TOKEN_EDITS = 1024;
+/**
+* The shortest edit script between two token sequences (Myers, 1986), as
+* segments of joined token text, or `null` past `maxEdits` edits.
+*
+* Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+* short matches between changes so a reader sees whole phrases replaced; an
+* edit applied directly has no reader to serve, and every token it gives up is
+* text rewritten with someone else's formatting.
+*/
+const shortestTokenDiff = (before, after, maxEdits = MAX_TOKEN_EDITS) => {
+	const n = before.length;
+	const m = after.length;
+	const limit = Math.min(n + m, maxEdits);
+	const offset = limit + 1;
+	const frontier = new Int32Array(2 * limit + 3);
+	const trace = [];
+	let edits = -1;
+	search: for (let d = 0; d <= limit; d++) {
+		trace.push(frontier.slice(offset - d, offset + d + 1));
+		for (let k = -d; k <= d; k += 2) {
+			let x = k === -d || k !== d && frontier[offset + k - 1] < frontier[offset + k + 1] ? frontier[offset + k + 1] : frontier[offset + k - 1] + 1;
+			let y = x - k;
+			while (x < n && y < m && before[x] === after[y]) {
+				x++;
+				y++;
+			}
+			frontier[offset + k] = x;
+			if (x >= n && y >= m) {
+				edits = d;
+				break search;
+			}
+		}
+	}
+	if (edits < 0) return null;
+	const reversed = [];
+	const push = (type, text) => {
+		const last = reversed.at(-1);
+		if (last?.type === type) last.text = text + last.text;
+		else reversed.push({
+			type,
+			text
+		});
+	};
+	let x = n;
+	let y = m;
+	for (let d = edits; d > 0; d--) {
+		const previous = trace[d];
+		const at = (diagonal) => previous[diagonal + d];
+		const k = x - y;
+		const down = k === -d || k !== d && at(k - 1) < at(k + 1);
+		const previousK = down ? k + 1 : k - 1;
+		const previousX = at(previousK);
+		const previousY = previousX - previousK;
+		while (x > previousX && y > previousY) {
+			x--;
+			y--;
+			push("equal", before[x]);
+		}
+		if (down) {
+			y--;
+			push("ins", after[y]);
+		} else {
+			x--;
+			push("del", before[x]);
+		}
+	}
+	while (x > 0 && y > 0) {
+		x--;
+		y--;
+		push("equal", before[x]);
+	}
+	return reversed.toReversed();
+};
+/**
+* The changes from `source` to `replacement`, in source order and disjoint.
+*
+* Words (with their leading whitespace, and edge punctuation on its own; see
+* `tokenizeWords`) are aligned by the shortest edit script, and each changed
+* stretch is then trimmed to the characters that actually differ, so
+* appending a letter to a word that spans two runs leaves both runs alone. A
+* rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+* both strings exactly (it never should), is one change over the whole span,
+* trimmed the same way.
+*/
+const planTextChanges = (source, replacement) => {
+	if (source === replacement) return [];
+	const diffed = shortestTokenDiff(tokenizeWords(source), tokenizeWords(replacement));
+	const segments = diffed !== null && reconstructs(diffed, source, replacement) ? diffed : [{
+		type: "del",
+		text: source
+	}, {
+		type: "ins",
+		text: replacement
+	}];
+	return changesFromSegments(segments).flatMap((change) => trimChange(source, change) ?? []);
+};
+/**
+* The changes a diff's segments describe, in source order and disjoint: each
+* run of `del` and `ins` segments between two `equal` ones is one change,
+* exactly as wide as the segments say. A redline's segments come cut to the
+* granularity its reader asked for, so they are not trimmed further.
+*/
+const changesFromSegments = (segments) => {
+	const changes = [];
+	let cursor = 0;
+	let pending = null;
+	for (const segment of segments) {
+		if (segment.type === "equal") {
+			if (pending !== null) {
+				changes.push(pending);
+				pending = null;
+			}
+			cursor += segment.text.length;
+			continue;
+		}
+		pending ??= {
+			start: cursor,
+			end: cursor,
+			text: ""
+		};
+		if (segment.type === "del") {
+			cursor += segment.text.length;
+			pending.end = cursor;
+		} else pending.text += segment.text;
+	}
+	if (pending !== null) changes.push(pending);
+	return changes;
+};
+const cutsInto = ({ offset, length }, position) => position > offset && position < offset + length;
+/**
+* `changes` widened so none cuts into an atomic span, then merged where the
+* widening made two overlap. A widened change re-emits the source text it
+* absorbed, so applying the result still yields exactly the replacement.
+*
+* `spans` are in the same coordinates as the changes (the source span's).
+*/
+const widenChangesToAtomicSpans = (source, changes, spans) => {
+	if (spans.length === 0 || changes.length === 0) return [...changes];
+	const windows = changes.map(({ start, end }) => {
+		let from = start;
+		let to = end;
+		for (const span of spans) {
+			if (cutsInto(span, from)) from = span.offset;
+			if (cutsInto(span, to)) to = span.offset + span.length;
+		}
+		return {
+			from,
+			to
+		};
+	});
+	const merged = [];
+	let index = 0;
+	while (index < changes.length) {
+		const { from } = windows[index];
+		let { to } = windows[index];
+		const group = [changes[index]];
+		index++;
+		while (index < changes.length && windows[index].from < to) {
+			to = Math.max(to, windows[index].to);
+			group.push(changes[index]);
+			index++;
+		}
+		let text = "";
+		let cursor = from;
+		for (const change of group) {
+			text += source.slice(cursor, change.start) + change.text;
+			cursor = change.end;
+		}
+		text += source.slice(cursor, to);
+		merged.push({
+			start: from,
+			end: to,
+			text
+		});
+	}
+	return merged;
+};
+/** `source` with `changes` applied; the invariant the planner owes. */
+const applyTextChanges = (source, changes) => {
+	let result = "";
+	let cursor = 0;
+	for (const change of changes) {
+		result += source.slice(cursor, change.start) + change.text;
+		cursor = change.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+export { MAX_TOKEN_EDITS, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/controller/fontReadiness.js

@@ -1,4 +1,5 @@
 import { buildFontAlternates, getFontAlternate } from "../fonts/fontAlternates.js";
+import { DEFAULT_FONT_FAMILY } 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
@@ -11,7 +12,6 @@ function documentFontsAreLoaded() {
 	return !fontSet || fontSet.status === "loaded";
 }
 const INITIAL_LAYOUT_FONT_TIMEOUT_MS = 2e3;
-const DEFAULT_LAYOUT_FONT_FAMILY = "Calibri";
 const CSS_GENERIC_FONT_FAMILIES = /* @__PURE__ */ new Set([
 	"serif",
 	"sans-serif",
@@ -54,7 +54,7 @@ function collectInitialLayoutFontFamilies(documentModel, pmDoc) {
 function collectInitialLayoutFontFaces(documentModel, pmDoc) {
 	const faces = /* @__PURE__ */ new Map();
 	const fontAlternates = buildFontAlternates(documentModel?.package.fontTable);
-	addLayoutFontFamilyFace(faces, DEFAULT_LAYOUT_FONT_FAMILY, REGULAR_LAYOUT_FONT_DESCRIPTOR, fontAlternates);
+	addLayoutFontFamilyFace(faces, DEFAULT_FONT_FAMILY, REGULAR_LAYOUT_FONT_DESCRIPTOR, fontAlternates);
 	for (const family of documentModel?.requiredFonts ?? []) addLayoutFontFamilyFace(faces, family, REGULAR_LAYOUT_FONT_DESCRIPTOR, fontAlternates);
 	addLayoutFontFamilyFace(faces, documentModel?.package.theme?.fontScheme?.majorFont?.latin, REGULAR_LAYOUT_FONT_DESCRIPTOR, fontAlternates);
 	addLayoutFontFamilyFace(faces, documentModel?.package.theme?.fontScheme?.minorFont?.latin, REGULAR_LAYOUT_FONT_DESCRIPTOR, fontAlternates);
@@ -75,7 +75,7 @@ function collectProseMirrorFontFaces(faces, node, inheritedTextFormatting, fontA
 	if (node.type.name === "paragraph") addTextFormattingFontFaces(faces, expectParagraphAttrs(node).listMarkerFormatting, fontAlternates);
 	if (node.isText) {
 		const descriptor = layoutDescriptorFromFormattingAndMarks(textFormatting, node.marks);
-		addLayoutFontFamilyFace(faces, readFontFamilyMarkAttrs(node.marks) ?? textFormatting?.fontFamily ?? DEFAULT_LAYOUT_FONT_FAMILY, descriptor, fontAlternates);
+		addLayoutFontFamilyFace(faces, readFontFamilyMarkAttrs(node.marks) ?? textFormatting?.fontFamily ?? "Times New Roman", descriptor, fontAlternates);
 	}
 	node.forEach((child) => {
 		collectProseMirrorFontFaces(faces, child, textFormatting, fontAlternates);

package/dist/controller/hyphenationReadiness.d.ts

@@ -0,0 +1,19 @@
+import { HyphenationDictionaryError, HyphenationDictionaryId } from "../layout-engine/measure/hyphenationDictionaries.js";
+//#region src/controller/hyphenationReadiness.d.ts
+type HyphenationReadiness = {
+  /** Follow up on the dictionaries one layout run lacked. */
+  track: (missing: ReadonlySet<HyphenationDictionaryId>) => void;
+  /**
+   * Ignore loads still pending, as on unmount. A later `track` follows up
+   * afresh, so an adapter whose lifecycle re-attaches (React Strict Mode
+   * effects) keeps working.
+   */
+  cancel: () => void;
+};
+type HyphenationReadinessOptions = {
+  relayout: () => void;
+  onError: (error: HyphenationDictionaryError) => void;
+};
+declare const createHyphenationReadiness: ({ relayout, onError }: HyphenationReadinessOptions) => HyphenationReadiness;
+//#endregion
+export { HyphenationReadiness, HyphenationReadinessOptions, createHyphenationReadiness };

package/dist/controller/hyphenationReadiness.js

@@ -0,0 +1,47 @@
+import { requestHyphenationDictionary } from "../layout-engine/measure/hyphenationDictionaries.js";
+//#region src/controller/hyphenationReadiness.ts
+/**
+* Per-editor follow-up for hyphenation dictionaries a layout run lacked.
+*
+* Framework-neutral so both adapters share one implementation. The layout
+* pipeline hands {@link HyphenationReadiness.track} the dictionaries its run
+* requested but could not use; this editor then re-runs layout when one loads
+* (the load has already invalidated measured paragraphs) and reports a failed
+* one once. Editors that never asked for a dictionary hear nothing about it,
+* and an editor mounted after a failure still learns of it on its first run.
+*/
+const createHyphenationReadiness = ({ relayout, onError }) => {
+	let epoch = 0;
+	const pending = /* @__PURE__ */ new Set();
+	const reported = /* @__PURE__ */ new Set();
+	const follow = async (dictionary) => {
+		const startedIn = epoch;
+		pending.add(dictionary);
+		const settled = await requestHyphenationDictionary(dictionary);
+		if (startedIn !== epoch) return;
+		pending.delete(dictionary);
+		switch (settled.status) {
+			case "loaded":
+				relayout();
+				return;
+			case "failed":
+				if (!reported.has(dictionary)) {
+					reported.add(dictionary);
+					onError(settled.error);
+				}
+				return;
+			default:
+		}
+	};
+	return {
+		track: (missing) => {
+			for (const dictionary of missing) if (!pending.has(dictionary)) follow(dictionary);
+		},
+		cancel: () => {
+			epoch += 1;
+			pending.clear();
+		}
+	};
+};
+//#endregion
+export { createHyphenationReadiness };

package/dist/controller/layoutPipeline.d.ts

@@ -3,6 +3,7 @@ import { TemplatePreviewEntry, TemplatePreviewHiddenRange } from "../prosemirror
 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 { HyphenationReadiness } from "./hyphenationReadiness.js";
 import { ConvertHeaderFooterOptions, HeaderFooterMetrics } from "../layout-bridge/convert/headerFooterLayout.js";
 import "../layout-engine/index.js";
 import { FootnoteRenderItem } from "../layout-painter/renderPage.js";
@@ -74,6 +75,8 @@ type LayoutPipelineDeps<THfPMs> = {
   pageRenderer?: PageRendererName;
   emptyTemplatePreviewEntries: readonly TemplatePreviewEntry[];
   emptyTemplatePreviewHidden: readonly TemplatePreviewHiddenRange[];
+  /** Follows up on the hyphenation dictionaries a run lacked (relayout or error). */
+  hyphenationReadiness: HyphenationReadiness;
 };
 declare function runLayoutPipeline<THfPMs>(deps: LayoutPipelineDeps<THfPMs>, state: EditorState, options?: LayoutRunOptions): LayoutOutcome;
 //#endregion

package/dist/controller/layoutPipeline.js

@@ -9,13 +9,16 @@ import { buildHeaderFooterFieldValues, fieldValuesEqual, resolveFieldValues } fr
 import { buildSectionPageCounts } from "../fields/sectionPageCounts.js";
 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 { 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 { 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 { resolveEffectiveParagraphSpacingTree } from "../layout-engine/paragraphSpacing.js";
@@ -100,6 +103,11 @@ function attachAuthoredMarginsToLayoutPages(layout, options) {
 	} : layout;
 }
 function runLayoutPipeline(deps, state, options = {}) {
+	const { result, missing } = collectRequestedHyphenationDictionaries(() => runLayoutPipelineMeasured(deps, state, options));
+	deps.hyphenationReadiness.track(missing);
+	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;
 	let outcome = {};
 	let pendingArtifacts;
@@ -131,6 +139,7 @@ function runLayoutPipeline(deps, state, options = {}) {
 		if (justificationCompatibility) flowOpts.justificationCompatibility = justificationCompatibility;
 		const tableIndentCompatibility = resolveTableIndentCompatibility(documentSettings?.compatibilityMode);
 		if (tableIndentCompatibility) flowOpts.tableIndentCompatibility = tableIndentCompatibility;
+		if (resolveAnchorLayoutInCellCompatibility(documentSettings?.compatibilityMode)) flowOpts.forceAnchorLayoutInCell = true;
 		if (documentSettings?.autoHyphenation === true) flowOpts.automaticHyphenation = {
 			enabled: true,
 			...documentSettings.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: documentSettings.doNotHyphenateCaps } : {},
@@ -139,6 +148,9 @@ function runLayoutPipeline(deps, state, options = {}) {
 		};
 		const finalSectionDocumentGridLinePitchTwips = resolveDocumentGridLinePitch(document?.package.document.sections?.at(-1)?.properties.docGrid);
 		if (finalSectionDocumentGridLinePitchTwips !== void 0) flowOpts.finalSectionDocumentGridLinePitchTwips = finalSectionDocumentGridLinePitchTwips;
+		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,
 			_finalSectionStart: sectionProperties?.sectionStart ?? null
@@ -166,7 +178,7 @@ function runLayoutPipeline(deps, state, options = {}) {
 		const footnoteDisplayNumbers = documentFootnotes ? computeNoteDisplayNumbers(documentFootnotes, footnoteRefs.map((ref) => ref.footnoteId)) : void 0;
 		const documentEndnotes = document?.package.endnotes;
 		const endnoteDisplayNumbers = documentEndnotes ? computeNoteDisplayNumbers(documentEndnotes, collectEndnoteRefs(newBlocks).map((ref) => ref.endnoteId)) : void 0;
-		const endnoteNumberFormat = document?.package.document.sections?.at(-1)?.properties.endnotePr?.numFmt ?? "lowerRoman";
+		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;
 		newBlocks = remapNoteMarkerText(newBlocks, {
 			...footnoteDisplayNumbers ? { footnoteNumbers: footnoteDisplayNumbers } : {},
@@ -218,6 +230,15 @@ function runLayoutPipeline(deps, state, options = {}) {
 				preparedFooter: refs.footerEven ? footerContentByRId?.get(refs.footerEven) : void 0
 			});
 		});
+		const sectionFirstPageMargins = sectionHeaderFooterRefs?.map((refs, index) => {
+			if (refs.titlePg !== true) return;
+			const properties = sectionPropertiesForMargins[index];
+			return bodyMarginsClearHeaderFooter({
+				authoredMargins: properties ? getMargins(properties) : margins,
+				preparedHeader: refs.headerFirst ? headerContentByRId?.get(refs.headerFirst) : void 0,
+				preparedFooter: refs.footerFirst ? footerContentByRId?.get(refs.footerFirst) : void 0
+			});
+		});
 		newBlocks = bodyBlocksClearSectionHeaderFooter(newBlocks, {
 			authoredMargins: margins,
 			sectionHeaderFooterRefs,
@@ -302,6 +323,36 @@ function runLayoutPipeline(deps, state, options = {}) {
 		};
 		outcome.measures = newMeasures;
 		recordPhaseDuration("measure-blocks", phaseStartedAt);
+		const buildNoteOptions = () => {
+			const noteOptions = { measureBlocks };
+			if (flowOpts.styles) noteOptions.styles = flowOpts.styles;
+			if (flowOpts.defaultSize !== void 0) noteOptions.defaultSize = flowOpts.defaultSize;
+			if (_theme !== void 0) noteOptions.theme = _theme;
+			noteOptions.fontAlternates = fontAlternates;
+			if (defaultTabStop !== void 0) noteOptions.defaultTabStopTwips = defaultTabStop;
+			if (flowOpts.lineBreakRules) noteOptions.lineBreakRules = flowOpts.lineBreakRules;
+			if (flowOpts.justificationCompatibility) noteOptions.justificationCompatibility = flowOpts.justificationCompatibility;
+			if (flowOpts.tableIndentCompatibility) noteOptions.tableIndentCompatibility = flowOpts.tableIndentCompatibility;
+			if (flowOpts.automaticHyphenation) noteOptions.automaticHyphenation = flowOpts.automaticHyphenation;
+			return noteOptions;
+		};
+		const endnoteAreas = documentEndnotes && endnoteDisplayNumbers && endnoteTexts ? prepareEndnoteAreas({
+			blocks: newBlocks,
+			endnotes: documentEndnotes,
+			displayNumbers: endnoteDisplayNumbers,
+			displayTexts: endnoteTexts,
+			position: endnotePosition,
+			sections: sectionPropertiesForMargins,
+			options: buildNoteOptions()
+		}) : void 0;
+		const layoutWithNoteAreas = (measures, nextLayoutOpts) => {
+			if (endnoteAreas === void 0) return layoutDocument(newBlocks, measures, nextLayoutOpts);
+			const flow = spliceEndnoteAreas(newBlocks, measures, endnoteAreas);
+			return layoutDocument(flow.blocks, flow.measures, {
+				...nextLayoutOpts,
+				noteAreas: endnoteAreas.noteAreas
+			});
+		};
 		phaseStartedAt = performance.now();
 		let newLayout;
 		let pageFootnoteMap = /* @__PURE__ */ new Map();
@@ -316,7 +367,8 @@ function runLayoutPipeline(deps, state, options = {}) {
 			};
 			if (document?.package.document.sections !== void 0) nextLayoutOpts.sectionVerticalAlignments = document.package.document.sections.map(({ properties }) => properties.verticalAlign);
 			else if (sectionProperties !== null && sectionProperties !== void 0) nextLayoutOpts.sectionVerticalAlignments = [sectionProperties.verticalAlign];
-			if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
+			if (sectionFirstPageMargins !== void 0) nextLayoutOpts.sectionFirstPageMargins = sectionFirstPageMargins;
+			else if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
 				authoredMargins: margins,
 				preparedHeader: firstPageHeaderForRender,
 				preparedFooter: firstPageFooterForRender
@@ -338,29 +390,17 @@ function runLayoutPipeline(deps, state, options = {}) {
 		const layoutOpts = buildLayoutOpts();
 		let layoutOptsUsed = layoutOpts;
 		if (hasFootnotes) {
-			footnoteContentMap = buildFootnoteContentMap(documentFootnotes, footnoteRefs, contentWidth, (() => {
-				const footnoteOptions = { measureBlocks };
-				if (flowOpts.styles) footnoteOptions.styles = flowOpts.styles;
-				if (flowOpts.defaultSize !== void 0) footnoteOptions.defaultSize = flowOpts.defaultSize;
-				if (_theme !== void 0) footnoteOptions.theme = _theme;
-				footnoteOptions.fontAlternates = fontAlternates;
-				if (defaultTabStop !== void 0) footnoteOptions.defaultTabStopTwips = defaultTabStop;
-				if (flowOpts.lineBreakRules) footnoteOptions.lineBreakRules = flowOpts.lineBreakRules;
-				if (flowOpts.justificationCompatibility) footnoteOptions.justificationCompatibility = flowOpts.justificationCompatibility;
-				if (flowOpts.tableIndentCompatibility) footnoteOptions.tableIndentCompatibility = flowOpts.tableIndentCompatibility;
-				if (flowOpts.automaticHyphenation) footnoteOptions.automaticHyphenation = flowOpts.automaticHyphenation;
-				return footnoteOptions;
-			})());
+			footnoteContentMap = buildFootnoteContentMap(documentFootnotes, footnoteRefs, contentWidth, buildNoteOptions());
 			const footnoteHeightById = /* @__PURE__ */ new Map();
 			for (const [id, content] of footnoteContentMap) footnoteHeightById.set(id, content.height + 0);
 			layoutOptsUsed = {
 				...layoutOpts,
 				footnoteHeightById
 			};
-			newLayout = layoutDocument(newBlocks, newMeasures, layoutOptsUsed);
+			newLayout = layoutWithNoteAreas(newMeasures, layoutOptsUsed);
 			pageFootnoteMap = /* @__PURE__ */ new Map();
 			for (const page of newLayout.pages) if (page.footnoteIds && page.footnoteIds.length > 0) pageFootnoteMap.set(page.number, page.footnoteIds);
-		} else newLayout = layoutDocument(newBlocks, newMeasures, layoutOpts);
+		} else newLayout = layoutWithNoteAreas(newMeasures, layoutOpts);
 		const rebuildFootnotePageMap = () => {
 			pageFootnoteMap = /* @__PURE__ */ new Map();
 			for (const page of newLayout.pages) if (page.footnoteIds && page.footnoteIds.length > 0) pageFootnoteMap.set(page.number, page.footnoteIds);
@@ -376,7 +416,7 @@ function runLayoutPipeline(deps, state, options = {}) {
 		};
 		const relayoutWithCurrentMeasures = (nextLayoutOpts) => {
 			layoutOptsUsed = withFootnoteHeights(nextLayoutOpts);
-			newLayout = layoutDocument(newBlocks, newMeasures, layoutOptsUsed);
+			newLayout = layoutWithNoteAreas(newMeasures, layoutOptsUsed);
 			if (hasFootnotes) rebuildFootnotePageMap();
 		};
 		const stabilizeFieldWidths = () => {
@@ -473,6 +513,18 @@ function runLayoutPipeline(deps, state, options = {}) {
 					measure
 				});
 			}
+			for (const area of endnoteAreas?.areas ?? []) for (const [index, block] of area.blocks.entries()) {
+				const measure = area.measures[index];
+				if (!measure) continue;
+				const noteStory = endnoteAreas?.noteStoryByBlockId.get(String(block.id));
+				blockLookup.set(String(block.id), {
+					block,
+					measure,
+					...noteStory === void 0 ? {} : { noteStory }
+				});
+			}
+			const continuationSeparator = endnoteAreas?.noteAreas.continuationSeparator;
+			if (continuationSeparator) blockLookup.set(String(continuationSeparator.block.id), continuationSeparator);
 			outcome.blockLookup = blockLookup;
 			const footnotesByPage = hasFootnotes ? buildFootnoteRenderItems(pageFootnoteMap, footnoteContentMap, document) : void 0;
 			const renderOpts = {