@stll/folio-core 0.33.2 → 0.35.0

package/dist/ai-edits/apply.js

@@ -1,4 +1,4 @@
-import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
 import { PPR_CHANGE_SCOPED_ATTR_KEYS } from "../prosemirror/commands/propertyChangeScope.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../prosemirror/containerFinalParagraph.js";
 import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.js";
@@ -154,24 +154,132 @@ const REPLACEMENT_BACKGROUND_CLEAR_FORMATTING = {
 	highlight: false,
 	runShading: false
 };
-const applyInlineFormatting = ({ tr, schema, from, to, formatting }) => {
-	for (const [name, enabled] of Object.entries(formatting)) {
-		const markType = schema.marks[name];
+const INLINE_FORMATTING_MARK_NAMES = {
+	bold: "bold",
+	italic: "italic",
+	underline: "underline",
+	strike: "strike",
+	fontFamily: "fontFamily",
+	fontSizePt: "fontSize",
+	color: "textColor",
+	highlight: "highlight",
+	runShading: "runShading"
+};
+const DIRECT_FONT_PROPERTIES = [
+	"fontFamily",
+	"fontSize",
+	"color"
+];
+const formattingMarkName = (property) => {
+	if (!Object.hasOwn(INLINE_FORMATTING_MARK_NAMES, property)) return null;
+	const name = Reflect.get(INLINE_FORMATTING_MARK_NAMES, property);
+	return typeof name === "string" ? name : null;
+};
+const formattingMarkAttrs = (property, value) => {
+	switch (property) {
+		case "underline": return { style: "single" };
+		case "fontFamily": return typeof value === "string" ? {
+			ascii: value,
+			hAnsi: value
+		} : null;
+		case "fontSizePt": return typeof value === "number" ? { size: value * 2 } : null;
+		case "color": return typeof value === "string" ? { rgb: value.replace(/^#/u, "").toUpperCase() } : null;
+		default: return {};
+	}
+};
+const applyInlineFormatting = ({ tr, schema, from, to, formatting, includedProperties }) => {
+	for (const [property, value] of Object.entries(formatting)) {
+		if (includedProperties && !includedProperties.includes(property)) continue;
+		const markName = formattingMarkName(property);
+		const markType = markName ? schema.marks[markName] : void 0;
 		if (!markType) continue;
-		if (enabled) {
-			tr.addMark(from, to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
+		if (value !== false && value !== null) {
+			const attrs = formattingMarkAttrs(property, value);
+			if (attrs) tr.addMark(from, to, markType.create(attrs));
 			continue;
 		}
 		tr.removeMark(from, to, markType);
 	}
+	applyDirectFontProvenance({
+		tr,
+		schema,
+		from,
+		to,
+		formatting,
+		...includedProperties ? { includedProperties } : {}
+	});
 	return tr;
 };
-const formattingWouldChange = (marks, formatting) => Object.entries(formatting).some(([name, enabled]) => {
-	const mark = marks.find((candidate) => candidate.type.name === name);
-	if (!enabled) return mark !== void 0;
-	if (name === "underline") return mark?.attrs["style"] !== "single";
+const applyDirectFontProvenance = ({ tr, schema, from, to, formatting, includedProperties }) => {
+	if ("highlight" in formatting) return;
+	const changed = [
+		[
+			"fontFamily",
+			"fontFamily",
+			formatting.fontFamily
+		],
+		[
+			"fontSize",
+			"fontSizePt",
+			formatting.fontSizePt
+		],
+		[
+			"color",
+			"color",
+			formatting.color
+		]
+	].filter(([, inputProperty, value]) => value !== void 0 && (!includedProperties || includedProperties.includes(inputProperty)));
+	const markType = schema.marks["runFormattingOverride"];
+	if (!markType || changed.length === 0) return;
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isText) return;
+		const segmentFrom = Math.max(from, pos);
+		const segmentTo = Math.min(to, pos + node.nodeSize);
+		const existing = node.marks.find((mark) => mark.type === markType);
+		const attrs = existing ? expectRunFormattingOverrideMarkAttrs(existing) : {};
+		const directFontProperties = new Set(attrs.directFontProperties);
+		for (const [property, , value] of changed) if (value === null) directFontProperties.delete(property);
+		else directFontProperties.add(property);
+		tr.removeMark(segmentFrom, segmentTo, markType);
+		const nextAttrs = {
+			...attrs,
+			directFontProperties: DIRECT_FONT_PROPERTIES.filter((property) => directFontProperties.has(property))
+		};
+		if (Object.entries(nextAttrs).some(([key, value]) => key === "directFontProperties" ? Array.isArray(value) && value.length > 0 : value !== null && value !== void 0)) tr.addMark(segmentFrom, segmentTo, markType.create(nextAttrs));
+	});
+};
+const directFontPropertyForFormattingProperty = (property) => {
+	switch (property) {
+		case "fontFamily": return "fontFamily";
+		case "fontSizePt": return "fontSize";
+		case "color": return "color";
+		default: return null;
+	}
+};
+const formattingPropertyWouldChange = (marks, property, value) => {
+	const markName = formattingMarkName(property);
+	const mark = marks.find((candidate) => candidate.type.name === markName);
+	const directFontProperty = directFontPropertyForFormattingProperty(property);
+	if (directFontProperty) {
+		const overrideMark = marks.find((candidate) => candidate.type.name === "runFormattingOverride");
+		const isDirect = overrideMark ? (expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties ?? []).includes(directFontProperty) : false;
+		if (value === false || value === null) return isDirect;
+		if (!isDirect) return true;
+	} else if (value === false || value === null) return mark !== void 0;
+	if (property === "underline") return mark?.attrs["style"] !== "single";
+	if (property === "fontFamily") return mark?.attrs["ascii"] !== value || mark?.attrs["hAnsi"] !== value;
+	if (property === "fontSizePt") return Number(mark?.attrs["size"]) !== Number(value) * 2;
+	if (property === "color") {
+		const current = mark?.attrs["rgb"];
+		return (typeof current === "string" ? current.replace(/^#/u, "").toUpperCase() : null) !== String(value).replace(/^#/u, "").toUpperCase();
+	}
 	return mark === void 0;
-});
+};
+const formattingChangesForMarks = (marks, formatting) => {
+	const changes = [];
+	for (const [property, value] of Object.entries(formatting)) if (formattingPropertyWouldChange(marks, property, value)) changes.push(property);
+	return changes;
+};
 const clearReplacementBackground = ({ tr, schema, from, to, mode, revisionId, author, date, initials, suggestionId = null }) => {
 	if (![schema.marks["highlight"], schema.marks["runShading"]].some((markType) => markType !== void 0 && tr.doc.rangeHasMark(from, to, markType))) return tr;
 	if (mode === "direct") return applyInlineFormatting({
@@ -200,7 +308,9 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 	if (!propertyChangeType) return tr;
 	const segments = [];
 	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText || !formattingWouldChange(node.marks, formatting)) return;
+		if (!node.isText) return;
+		const includedProperties = formattingChangesForMarks(node.marks, formatting);
+		if (includedProperties.length === 0) return;
 		const segmentFrom = Math.max(from, pos);
 		const segmentTo = Math.min(to, pos + node.nodeSize);
 		const previousFormatting = marksToTextFormatting(node.marks);
@@ -219,6 +329,7 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 		segments.push({
 			from: segmentFrom,
 			to: segmentTo,
+			includedProperties,
 			changes: [...existingChanges, change]
 		});
 	});
@@ -227,17 +338,20 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 		provenance: "suggested",
 		suggestionId
 	};
-	applyInlineFormatting({
-		tr,
-		schema,
-		from,
-		to,
-		formatting
-	});
-	for (const segment of segments) tr.addMark(segment.from, segment.to, propertyChangeType.create({
-		changes: segment.changes,
-		...suggestionAttrs
-	}));
+	for (const segment of segments) {
+		applyInlineFormatting({
+			tr,
+			schema,
+			from: segment.from,
+			to: segment.to,
+			formatting,
+			includedProperties: segment.includedProperties
+		});
+		tr.addMark(segment.from, segment.to, propertyChangeType.create({
+			changes: segment.changes,
+			...suggestionAttrs
+		}));
+	}
 	return tr;
 };
 /**

package/dist/ai-edits/snapshot.d.ts

@@ -1,6 +1,8 @@
 import { FolioAIBlock, FolioAIEditSnapshot, FolioAITextRangeHandle } from "./types.js";
 import { Node } from "prosemirror-model";
 //#region src/ai-edits/snapshot.d.ts
+/** @internal Numbering references collected during the snapshot's document walk. */
+declare const numberingReferenceKeysOf: (snapshot: FolioAIEditSnapshot) => readonly string[];
 declare const normalizeFolioAIBlockText: (text: string) => string;
 /**
  * Whether a block carries text a reader would see.
@@ -70,4 +72,4 @@ type FolioStoryTable = {
 declare const folioStoryTables: (doc: Node) => FolioStoryTable[];
 declare const createFolioAIEditSnapshot: (doc: Node) => FolioAIEditSnapshot;
 //#endregion
-export { FolioStoryTable, createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };
+export { FolioStoryTable, createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, numberingReferenceKeysOf, trailingBodyBlockId };

package/dist/ai-edits/snapshot.js

@@ -1,7 +1,12 @@
+import { expectRunFormattingOverrideMarkAttrs } from "../prosemirror/attrs/index.js";
 import { deriveBlankBlockId, deriveBlockId } from "../types/block-id.js";
 import { buildCleanBlockText } from "./clean-text.js";
+import { panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 //#region src/ai-edits/snapshot.ts
+const numberingReferenceKeysBySnapshot = /* @__PURE__ */ new WeakMap();
+/** @internal Numbering references collected during the snapshot's document walk. */
+const numberingReferenceKeysOf = (snapshot) => numberingReferenceKeysBySnapshot.get(snapshot) ?? panic("A numbering census was requested for a snapshot that did not record one");
 const normalizeFolioAIBlockText = (text) => text.replace(/\s+/gu, " ").trim();
 /**
 * Whether a block carries text a reader would see.
@@ -125,6 +130,7 @@ const createFolioAIEditSnapshot = (doc) => {
 	const draftBlocks = [];
 	const hashCounts = /* @__PURE__ */ new Map();
 	const usedBlockIds = /* @__PURE__ */ new Set();
+	const numberingReferenceKeys = /* @__PURE__ */ new Set();
 	const tableIndexByStart = new Map(folioStoryTables(doc).map(({ start, index }) => [start, index]));
 	const path = [];
 	let blockIndex = 0;
@@ -170,6 +176,8 @@ const createFolioAIEditSnapshot = (doc) => {
 		const displayLabel = getDisplayLabel(node);
 		const styleId = getStyleId(node);
 		const listLevel = getListLevel(node);
+		const numberingReferenceKey = getNumberingReferenceKey(node);
+		if (numberingReferenceKey) numberingReferenceKeys.add(numberingReferenceKey);
 		const previewRuns = getPreviewRuns(node);
 		const table = getTableLocation({
 			path,
@@ -208,10 +216,12 @@ const createFolioAIEditSnapshot = (doc) => {
 			hashOccurrenceCount: hashCounts.get(draft.anchor.textHash) ?? 0
 		};
 	}
-	return {
+	const snapshot = {
 		blocks,
 		anchors
 	};
+	numberingReferenceKeysBySnapshot.set(snapshot, [...numberingReferenceKeys]);
+	return snapshot;
 };
 const getBlockKind = (node, headingLevel) => {
 	const listMarker = node.attrs["listMarker"];
@@ -240,6 +250,15 @@ const getListLevel = (node) => {
 	const { ilvl } = numPr;
 	return typeof ilvl === "number" && Number.isInteger(ilvl) && ilvl >= 0 ? ilvl : void 0;
 };
+const getNumberingReferenceKey = (node) => {
+	const numPr = node.attrs["numPr"];
+	if (typeof numPr !== "object" || numPr === null || !("numId" in numPr)) return null;
+	const { numId } = numPr;
+	if (typeof numId !== "number" || !Number.isInteger(numId) || numId <= 0) return null;
+	const level = "ilvl" in numPr ? numPr.ilvl : void 0;
+	if (level !== void 0 && (typeof level !== "number" || !Number.isInteger(level) || level < 0)) return null;
+	return `${String(numId)}:${String(level ?? 0)}`;
+};
 const getStyleId = (node) => {
 	const styleId = node.attrs["styleId"];
 	return typeof styleId === "string" && styleId.length > 0 ? styleId : void 0;
@@ -252,14 +271,16 @@ const getPreviewRuns = (node) => {
 		if (!child.isText || child.text === void 0) return true;
 		if (child.marks.some((mark) => mark.type.name === DELETION_MARK)) return false;
 		const style = getPreviewRunStyle(child.marks, defaultStyle);
+		const directFormatting = getDirectPreviewRunStyle(child.marks, defaultStyle);
 		const previous = runs.at(-1);
-		if (previous && samePreviewRunStyle(previous, style)) {
+		if (previous && samePreviewRunStyle(previous, style) && sameDirectFormatting(previous.directFormatting, directFormatting)) {
 			previous.text += child.text;
 			return false;
 		}
 		runs.push({
 			text: child.text,
-			...style
+			...style,
+			...!isEmptyPreviewRunStyle(directFormatting) && { directFormatting }
 		});
 		return false;
 	});
@@ -310,6 +331,23 @@ const getPreviewRunStyle = (marks, defaultStyle) => {
 	}
 	return style;
 };
+const getDirectPreviewRunStyle = (marks, inheritedStyle) => {
+	const markedStyle = getPreviewRunStyle(marks, {});
+	const directStyle = {};
+	const overrideMark = marks.find(({ type }) => type.name === "runFormattingOverride");
+	const hasFormattingProvenance = overrideMark !== void 0 || marks.some(({ type }) => type.name === "characterStyle");
+	const directFontProperties = overrideMark ? expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties : void 0;
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	]) if (Boolean(markedStyle[property]) !== Boolean(inheritedStyle[property])) directStyle[property] = Boolean(markedStyle[property]);
+	if (markedStyle.fontFamily !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontFamily") : markedStyle.fontFamily !== inheritedStyle.fontFamily)) directStyle.fontFamily = markedStyle.fontFamily;
+	if (markedStyle.fontSizePt !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontSize") : markedStyle.fontSizePt !== inheritedStyle.fontSizePt)) directStyle.fontSizePt = markedStyle.fontSizePt;
+	if (markedStyle.color !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("color") : markedStyle.color !== inheritedStyle.color)) directStyle.color = markedStyle.color;
+	return directStyle;
+};
 const getBooleanTextFormatting = (formatting) => ({
 	...Reflect.get(formatting, "bold") === true && { bold: true },
 	...Reflect.get(formatting, "italic") === true && { italic: true },
@@ -352,6 +390,8 @@ const getColorFromAttrs = (attrs) => {
 	return `#${rgb}`;
 };
 const samePreviewRunStyle = (run, style) => run.bold === style.bold && run.italic === style.italic && run.underline === style.underline && run.strike === style.strike && run.fontFamily === style.fontFamily && run.fontSizePt === style.fontSizePt && run.color === style.color;
+const isEmptyPreviewRunStyle = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
+const sameDirectFormatting = (left, right) => left === void 0 && isEmptyPreviewRunStyle(right) || left !== void 0 && left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
 const isUnstyledPreviewRun = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
 //#endregion
-export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };
+export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, numberingReferenceKeysOf, trailingBodyBlockId };

package/dist/ai-edits/types.d.ts

@@ -1,5 +1,10 @@
 //#region src/ai-edits/types.d.ts
 type FolioAIBlockKind = "heading" | "listItem" | "paragraph";
+type FolioAIInlineFormatting = Partial<Record<"bold" | "italic" | "underline" | "strike", boolean>> & {
+  fontFamily?: string | null;
+  fontSizePt?: number | null;
+  color?: string | null;
+};
 type FolioAIBlockPreviewRun = {
   text: string;
   bold?: boolean;
@@ -9,6 +14,7 @@ type FolioAIBlockPreviewRun = {
   fontFamily?: string;
   fontSizePt?: number;
   color?: string;
+  directFormatting?: FolioAIInlineFormatting;
 };
 /**
  * Where a block sits inside its innermost enclosing table. Every index is
@@ -165,12 +171,6 @@ type FolioDocumentNavigationTarget = {
   story: "main";
   blockId: string;
 } | FolioAITextRangeHandle;
-type FolioAIInlineFormatting = {
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  strike?: boolean;
-};
 /**
  * A party in an `insertSignatureTable` op. Mirrors the
  * `signatureTable` helper in `docx-core/legal-source/compile.ts`:

package/dist/compare/compare.js

@@ -1,4 +1,5 @@
 import { FolioDocxReviewer } from "../ai-edits/headless.js";
+import { numberingReferenceKeysOf } from "../ai-edits/snapshot.js";
 import { projectTableGeometry } from "../ai-edits/table-geometry.js";
 import "../document-operations.js";
 import { pairFolioDocumentStories } from "../document-stories.js";
@@ -114,11 +115,12 @@ const formattingRoundTripFailure = ({ invariant, story, changes, actualBlocks, e
 };
 const numberingKey = ({ numId, level }) => `${String(numId)}:${String(level)}`;
 const sameNumbering = (left, right) => left.format === right.format && left.levelText === right.levelText && left.start === right.start;
-const compareNumbering = (base, target) => {
+const compareNumbering = (base, target, referenced) => {
 	const baseLevels = new Map(base.readNumberingDefinitions().map((level) => [numberingKey(level), level]));
 	const targetLevels = new Map(target.readNumberingDefinitions().map((level) => [numberingKey(level), level]));
 	const changes = [];
 	for (const [key, before] of baseLevels) {
+		if (!referenced.has(key)) continue;
 		const after = targetLevels.get(key) ?? null;
 		if (after === null || !sameNumbering(before, after)) changes.push({
 			kind: "numbering",
@@ -128,7 +130,7 @@ const compareNumbering = (base, target) => {
 			after
 		});
 	}
-	for (const [key, after] of targetLevels) if (!baseLevels.has(key)) changes.push({
+	for (const [key, after] of targetLevels) if (referenced.has(key) && !baseLevels.has(key)) changes.push({
 		kind: "numbering",
 		numId: after.numId,
 		level: after.level,
@@ -162,8 +164,15 @@ const parseComparison = async (base, target, options) => {
 	});
 	const pairs = [];
 	const unsupported = [];
+	const referencedNumberingLevels = /* @__PURE__ */ new Set();
+	const collectNumberingReferences = (snapshot) => {
+		if (!snapshot) return;
+		for (const referenceKey of numberingReferenceKeysOf(snapshot)) referencedNumberingLevels.add(referenceKey);
+	};
 	for (const { baseStory, revisedStory: targetStory } of pairFolioDocumentStories(reviewer.listStories().map(({ handle }) => handle), targetReviewer.listStories().map(({ handle }) => handle))) {
 		if (!baseStory) {
+			if (!targetStory) panic("A story pair contained neither a base nor a target story");
+			collectNumberingReferences(targetReviewer.snapshotStory(targetStory));
 			unsupported.push({
 				reason: "story-missing-in-base",
 				baseStory: null,
@@ -172,6 +181,7 @@ const parseComparison = async (base, target, options) => {
 			continue;
 		}
 		if (!targetStory) {
+			collectNumberingReferences(reviewer.snapshotStory(baseStory));
 			unsupported.push({
 				reason: "story-missing-in-target",
 				baseStory,
@@ -181,6 +191,8 @@ const parseComparison = async (base, target, options) => {
 		}
 		const baseSnapshot = reviewer.snapshotStory(baseStory);
 		const targetSnapshot = targetReviewer.snapshotStory(targetStory);
+		collectNumberingReferences(baseSnapshot);
+		collectNumberingReferences(targetSnapshot);
 		if (!baseSnapshot || !targetSnapshot) {
 			unsupported.push({
 				reason: "story-not-editable",
@@ -208,7 +220,7 @@ const parseComparison = async (base, target, options) => {
 		},
 		packageDate,
 		pairs,
-		numberingChanges: compareNumbering(reviewer, targetReviewer),
+		numberingChanges: compareNumbering(reviewer, targetReviewer, referencedNumberingLevels),
 		unsupported
 	});
 };

package/dist/compare/formatting.d.ts

@@ -15,7 +15,7 @@ type InlineFormattingSegmentsOptions = {
   maxSegments: number;
 };
 /**
- * Segments where `targetBlock`'s bold / italic / underline / strike differs from
+ * Segments where `targetBlock`'s supported run formatting differs from
  * `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
  * when the diff would exceed `maxSegments`.
  *

package/dist/compare/formatting.js

@@ -1,12 +1,41 @@
+import { resolveColorToHex } from "../utils/colorResolver.js";
 //#region src/compare/formatting.ts
-const changedSupportedFormatting = (base, target) => ({
-	...Boolean(base.bold) !== Boolean(target.bold) && { bold: Boolean(target.bold) },
-	...Boolean(base.italic) !== Boolean(target.italic) && { italic: Boolean(target.italic) },
-	...Boolean(base.underline) !== Boolean(target.underline) && { underline: Boolean(target.underline) },
-	...Boolean(base.strike) !== Boolean(target.strike) && { strike: Boolean(target.strike) }
-});
-const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike;
-const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0 || formatting.strike !== void 0;
+const normalizeInlineFormattingColor = (color) => resolveColorToHex(color === void 0 ? void 0 : { rgb: color }, null);
+const changedStringValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
+	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
+	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
+};
+const changedNumberValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
+	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
+	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
+};
+const changedSupportedFormatting = (base, target) => {
+	const baseDirect = base.directFormatting ?? {};
+	const targetDirect = target.directFormatting ?? {};
+	const formatting = {};
+	const changedBoolean = (property) => {
+		if (baseDirect[property] !== targetDirect[property]) return targetDirect[property] === true;
+		return Boolean(base[property]) === Boolean(target[property]) ? void 0 : Boolean(target[property]);
+	};
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	]) {
+		const changed = changedBoolean(property);
+		if (changed !== void 0) formatting[property] = changed;
+	}
+	const fontFamily = changedStringValue(base.fontFamily, target.fontFamily, baseDirect.fontFamily, targetDirect.fontFamily);
+	if (fontFamily !== void 0) formatting.fontFamily = fontFamily;
+	const fontSizePt = changedNumberValue(base.fontSizePt, target.fontSizePt, baseDirect.fontSizePt, targetDirect.fontSizePt);
+	if (fontSizePt !== void 0) formatting.fontSizePt = fontSizePt;
+	const color = changedStringValue(normalizeInlineFormattingColor(base.color), normalizeInlineFormattingColor(target.color), normalizeInlineFormattingColor(baseDirect.color ?? void 0), normalizeInlineFormattingColor(targetDirect.color ?? void 0));
+	if (color !== void 0) formatting.color = color;
+	return formatting;
+};
+const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
+const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0 || formatting.strike !== void 0 || formatting.fontFamily !== void 0 || formatting.fontSizePt !== void 0 || formatting.color !== void 0;
 /**
 * A block's runs, or `null` when they cannot describe the block's text.
 * Non-text inline content (a field, an image) leaves the concatenated run text
@@ -18,7 +47,7 @@ const previewRunsForBlock = (block) => {
 	return runs.map(({ text }) => text).join("") === block.text ? runs : null;
 };
 /**
-* Segments where `targetBlock`'s bold / italic / underline / strike differs from
+* Segments where `targetBlock`'s supported run formatting differs from
 * `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
 * when the diff would exceed `maxSegments`.
 *

package/dist/compare/verification.js

@@ -1,3 +1,4 @@
+import { resolveColorToHex } from "../utils/colorResolver.js";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 //#region src/compare/verification.ts
 /**
@@ -14,6 +15,7 @@ import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 * Never a phrase of either document, because a caller may log it, put it in a
 * report, or quote it in a review.
 */
+const normalizeInlineFormattingColor = (color) => resolveColorToHex(color === void 0 ? void 0 : { rgb: color }, null);
 /** The two directions of the round trip, each an invariant of its own. */
 const COMPARE_VERIFICATION_INVARIANTS = Object.freeze(["accept-reproduces-target", "reject-reproduces-base"]);
 /**
@@ -32,7 +34,22 @@ const COMPARE_VERIFICATION_CAUSES = Object.freeze([
 	"whitespace",
 	"text"
 ]);
-const supportedInlineStyle = ({ bold, italic, underline, strike }) => `${bold === true ? "b" : ""}${italic === true ? "i" : ""}${underline === true ? "u" : ""}${strike === true ? "s" : ""}`;
+const supportedInlineStyle = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color, directFormatting }) => JSON.stringify([
+	bold === true,
+	italic === true,
+	underline === true,
+	strike === true,
+	fontFamily ?? null,
+	fontSizePt ?? null,
+	normalizeInlineFormattingColor(color) ?? null,
+	directFormatting?.bold === true,
+	directFormatting?.italic === true,
+	directFormatting?.underline === true,
+	directFormatting?.strike === true,
+	directFormatting?.fontFamily ?? null,
+	directFormatting?.fontSizePt ?? null,
+	normalizeInlineFormattingColor(directFormatting?.color ?? void 0) ?? null
+]);
 /** Effective supported formatting with equivalent adjacent runs normalized. */
 const projectSupportedInlineFormatting = ({ text, previewRuns }) => {
 	const projected = [];

package/dist/controller/headerFooterEditorManager.js

@@ -10,19 +10,21 @@ import { schema } from "../prosemirror/schema/index.js";
 import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/headerFooterEditorManager.ts
-/**
-* Framework-neutral lifecycle owner for persistent header/footer EditorViews.
-*
-* Each distinct relationship id owns one off-screen ProseMirror view. Painted
-* header/footer instances that share that relationship therefore share live
-* editor state, and adapters only decide when to synchronize or destroy the
-* manager.
-*/
+const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
+const headerFooterToProseDocWithDetachedWatermarkHost = (headerFooter, options) => {
+	return headerFooterToProseDoc(headerFooter.content.map((block, blockIndex) => {
+		if (blockIndex !== headerFooter.watermarkBlockIndex || block.type !== "paragraph") return block;
+		return {
+			...block,
+			[DETACHED_WATERMARK_HOST]: true
+		};
+	}), options);
+};
 const buildInitialState = (headerFooter, styles, theme, manager) => {
 	const proseDocOptions = {};
 	if (styles) proseDocOptions.styles = styles;
 	if (theme !== void 0) proseDocOptions.theme = theme;
-	const document = headerFooterToProseDoc(headerFooter.content, proseDocOptions);
+	const document = headerFooter.watermarkBlockIndex === void 0 ? headerFooterToProseDoc(headerFooter.content, proseDocOptions) : headerFooterToProseDocWithDetachedWatermarkHost(headerFooter, proseDocOptions);
 	return ensureBaseDirectionInState(ensureParaIdsInState(EditorState.create({
 		doc: document,
 		schema,

package/dist/controller/layoutPipeline.js

@@ -1,6 +1,7 @@
 import { createDisplayListPagePainter } from "../display-list/editor/displayListPagePainter.js";
 import { PAGE_RENDERER, displayListFurnitureFrom } from "../display-list/editor/pageRenderer.js";
 import { resolveDocumentGridLinePitch } from "../docx/documentGrid.js";
+import { formatOoxmlCounter } from "../docx/ooxmlCounterFormatter.js";
 import { buildBookmarkPageMap } from "../fields/bookmarkPages.js";
 import { buildBookmarkText } from "../fields/bookmarkText.js";
 import { buildHeaderFooterFieldValues, fieldValuesEqual, resolveFieldValues } from "../fields/resolveFieldValues.js";
@@ -26,6 +27,17 @@ import { getMargins, getPageNumbering, getPageSize, twipsToPixels } from "../pag
 import { templatePreviewValuesKey } from "../prosemirror/plugins/templatePreviewValues.js";
 import { getDocumentWatermark } from "../watermark/index.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;
+};
+/** Resolve only package-owned picture-watermark bytes for the DOM painter. */
+const resolveWatermarkImageSrc = (document, watermark) => {
+	if (watermark?.kind !== "picture" || watermark.imageTargetExternal === true) return;
+	const target = watermark.imageTarget;
+	return target === void 0 ? void 0 : document.package.media?.get(target)?.dataUrl;
+};
 function bodyMarginsClearHeaderFooter({ authoredMargins, preparedHeader, preparedFooter }) {
 	const headerBottom = preparedHeader ? (authoredMargins.header ?? 0) + (preparedHeader.marginPushBottom ?? preparedHeader.height) : authoredMargins.top;
 	const footerClearance = preparedFooter ? (authoredMargins.footer ?? 0) + (preparedFooter.marginPushBottom ?? preparedFooter.height) : authoredMargins.bottom;
@@ -123,7 +135,10 @@ function runLayoutPipeline(deps, state, options = {}) {
 		};
 		const finalSectionDocumentGridLinePitchTwips = resolveDocumentGridLinePitch(document?.package.document.sections?.at(-1)?.properties.docGrid);
 		if (finalSectionDocumentGridLinePitchTwips !== void 0) flowOpts.finalSectionDocumentGridLinePitchTwips = finalSectionDocumentGridLinePitchTwips;
-		let newBlocks = toFlowBlocks(state.doc, flowOpts);
+		let newBlocks = toFlowBlocks(document === null ? state.doc.type.create({
+			...state.doc.attrs,
+			_finalSectionStart: sectionProperties?.sectionStart ?? null
+		}, state.doc.content, state.doc.marks) : state.doc, flowOpts);
 		const previewState = templatePreviewValuesKey.getState(state);
 		const previewEntries = previewState?.entries ?? EMPTY_TEMPLATE_PREVIEW_ENTRIES;
 		const previewMode = previewState?.preview?.mode ?? "plain";
@@ -144,9 +159,11 @@ 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 endnoteTexts = endnoteDisplayNumbers ? formatEndnoteTexts(endnoteDisplayNumbers, (displayNumber) => formatOoxmlCounter(displayNumber, endnoteNumberFormat)) : void 0;
 		newBlocks = remapNoteMarkerText(newBlocks, {
 			...footnoteDisplayNumbers ? { footnoteNumbers: footnoteDisplayNumbers } : {},
-			...endnoteDisplayNumbers ? { endnoteNumbers: endnoteDisplayNumbers } : {}
+			...endnoteTexts ? { endnoteTexts } : {}
 		});
 		outcome.blocks = newBlocks;
 		const hfMetricsHeader = {
@@ -479,12 +496,16 @@ function runLayoutPipeline(deps, state, options = {}) {
 			if (document) {
 				const watermark = getDocumentWatermark(document);
 				if (watermark) renderOpts.watermark = watermark;
+				let watermarkByHeaderRId;
 				const headers = document.package.headers;
 				if (headers) {
-					const watermarkByHeaderRId = /* @__PURE__ */ new Map();
+					watermarkByHeaderRId = /* @__PURE__ */ new Map();
 					for (const [rId, header] of headers) if (header.watermark) watermarkByHeaderRId.set(rId, header.watermark);
 					if (watermarkByHeaderRId.size > 0) renderOpts.watermarkByHeaderRId = watermarkByHeaderRId;
 				}
+				const pictureSources = new Set([watermark, ...watermarkByHeaderRId?.values() ?? []].filter((candidate) => candidate !== void 0).map((candidate) => resolveWatermarkImageSrc(document, candidate)));
+				const watermarkImageSrc = pictureSources.size === 1 ? [...pictureSources].at(0) : void 0;
+				if (watermarkImageSrc !== void 0) renderOpts.watermarkImageSrc = watermarkImageSrc;
 			}
 			if (pageRenderer === PAGE_RENDERER.displayList) renderOpts.paintPage = createDisplayListPagePainter({
 				layout: newLayout,