@stll/folio-core 0.56.0 → 0.57.0

package/dist/prosemirror/extensions/marks/HyperlinkExtension.js

@@ -3,7 +3,7 @@ import { anchorTargetAttrs, normalizeUserUrl, sanitizeExternalUrl } from "../../
 import { expectHyperlinkMarkAttrs } from "../../attrs/index.js";
 import { withCanonicalCommand } from "../../canonicalCommands.js";
 import { canonicalSelectionRange } from "../../canonicalSelectionRange.js";
-import { removeHyperlinkInRange } from "../../hyperlinkRemoval.js";
+import { assertHyperlinkRemovalRange, removeHyperlinkInRange } from "../../hyperlinkRemoval.js";
 import { getDocumentBuiltInStyles } from "../../plugins/documentStyleState.js";
 import { createMarkExtension } from "../create.js";
 import { isMarkActive } from "./markUtils.js";
@@ -149,26 +149,34 @@ const HyperlinkExtension = createMarkExtension({
 		const removalRange = (state) => {
 			const { empty, $from } = state.selection;
 			const { from, to } = canonicalSelectionRange(state);
+			assertHyperlinkRemovalRange({
+				doc: state.doc,
+				from,
+				to
+			});
 			if (!empty) return {
 				from,
 				to
 			};
-			const hlType = documentHyperlinkType(state);
-			if (!$from.marks().some((mark) => mark.type === hlType)) return void 0;
-			let start = from;
-			let end = to;
+			const linkMark = $from.marks().find((mark) => mark.type === documentHyperlinkType(state));
+			if (!linkMark) return void 0;
+			let contiguous;
+			let selected;
 			$from.parent.forEach((node, offset) => {
-				const nodeStart = $from.start() + offset;
-				const nodeEnd = nodeStart + node.nodeSize;
-				if (node.isText && nodeStart <= from && from <= nodeEnd && node.marks.some((mark) => mark.type === hlType)) {
-					start = Math.min(start, nodeStart);
-					end = Math.max(end, nodeEnd);
+				if (!node.isInline || !node.marks.some((mark) => mark.eq(linkMark))) {
+					contiguous = void 0;
+					return;
 				}
+				const start = $from.start() + offset;
+				const end = start + node.nodeSize;
+				if (contiguous?.to === start) contiguous.to = end;
+				else contiguous = {
+					from: start,
+					to: end
+				};
+				if (start <= from && from <= end) selected = contiguous;
 			});
-			return {
-				from: start,
-				to: end
-			};
+			return selected;
 		};
 		const removeHyperlink = withCanonicalCommand((state, dispatch) => {
 			const range = removalRange(state);

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -1,7 +1,7 @@
 import { FONT_THEME_VALUES } from "../../../types/documentEnumValues.js";
 import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
 import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.js";
-import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
+import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
 import { canonicalRunFormatting, withCanonicalCommand } from "../../canonicalCommands.js";
 import { canonicalSelectionRange } from "../../canonicalSelectionRange.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
@@ -147,14 +147,15 @@ function saveStoredMarksToParagraph(state, tr, marks) {
 	const paragraph = $from.parent;
 	if (paragraph.type.name !== "paragraph") return tr;
 	if (paragraph.textContent.length > 0) return tr;
-	if (marks.length === 0) return tr.setNodeMarkup($from.before(), void 0, {
-		...paragraph.attrs,
-		defaultTextFormatting: null
-	});
-	const defaultTextFormatting = marksToTextFormatting(marks);
+	const attrs = expectParagraphAttrs(paragraph);
+	const defaultTextFormatting = marks.length === 0 ? null : marksToTextFormatting(marks);
 	return tr.setNodeMarkup($from.before(), void 0, {
 		...paragraph.attrs,
-		defaultTextFormatting
+		defaultTextFormatting,
+		_originalFormatting: {
+			...attrs._originalFormatting,
+			runProperties: defaultTextFormatting ?? void 0
+		}
 	});
 }
 function dispatchStoredMarks(state, dispatch, marks) {

package/dist/prosemirror/extensions/marks/noteReferenceDeletion.js

@@ -1,3 +1,4 @@
+import { expectFootnoteRefMarkAttrs } from "../../attrs/index.js";
 //#region src/prosemirror/extensions/marks/noteReferenceDeletion.ts
 /** Keep the text carrying one OOXML note reference together during deletion. */
 const expandNoteReferenceDeletionRange = (doc, from, to) => {
@@ -7,6 +8,8 @@ const expandNoteReferenceDeletionRange = (doc, from, to) => {
 	doc.nodesBetween(from, to, (node, pos) => {
 		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
 		if (!node.isText || !reference) return;
+		const { occurrenceId } = expectFootnoteRefMarkAttrs(reference);
+		const sameOccurrence = (sibling) => sibling.isText && sibling.marks.some((mark) => mark.type.name === "footnoteRef" && expectFootnoteRefMarkAttrs(mark).occurrenceId === occurrenceId);
 		intersectsReference = true;
 		const $pos = doc.resolve(pos);
 		const parent = $pos.parent;
@@ -15,12 +18,12 @@ const expandNoteReferenceDeletionRange = (doc, from, to) => {
 		let referenceTo = pos + node.nodeSize;
 		for (let left = index - 1; left >= 0; left--) {
 			const sibling = parent.child(left);
-			if (!sibling.isText || !sibling.marks.some((mark) => mark.eq(reference))) break;
+			if (!sameOccurrence(sibling)) break;
 			referenceFrom -= sibling.nodeSize;
 		}
 		for (let right = index + 1; right < parent.childCount; right++) {
 			const sibling = parent.child(right);
-			if (!sibling.isText || !sibling.marks.some((mark) => mark.eq(reference))) break;
+			if (!sameOccurrence(sibling)) break;
 			referenceTo += sibling.nodeSize;
 		}
 		expandedFrom = Math.min(expandedFrom, referenceFrom);

package/dist/prosemirror/fieldRepresentation.d.ts

@@ -0,0 +1,8 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/fieldRepresentation.d.ts
+/** Current children alone decide whether a field needs editable structural content. */
+declare const fieldRequiresStructuredContent: (children: readonly Node[]) => boolean;
+/** Resolution returns text-only fields to the same atom representation as initial conversion. */
+declare const canonicalFieldNode: (node: Node) => Node;
+//#endregion
+export { canonicalFieldNode, fieldRequiresStructuredContent };

package/dist/prosemirror/fieldRepresentation.js

@@ -0,0 +1,18 @@
+import "./extensions/marks/InlineWrapperExtension.js";
+//#region src/prosemirror/fieldRepresentation.ts
+/** Current children alone decide whether a field needs editable structural content. */
+const fieldRequiresStructuredContent = (children) => children.some((child) => !child.isText || child.marks.some((mark) => mark.type.name === "hyperlink" || mark.type.name === "inlineWrapper" || mark.type.name === "insertion" || mark.type.name === "deletion"));
+/** Resolution returns text-only fields to the same atom representation as initial conversion. */
+const canonicalFieldNode = (node) => {
+	if (node.type.name !== "structuredField") return node;
+	const attrs = {
+		...node.attrs,
+		displayText: node.textContent
+	};
+	if (fieldRequiresStructuredContent(node.content.content)) return node.attrs["displayText"] === node.textContent ? node : node.type.create(attrs, node.content, node.marks);
+	let marks = node.marks;
+	for (const mark of node.firstChild?.marks ?? []) marks = mark.addToSet(marks);
+	return node.type.schema.node("field", attrs, void 0, marks);
+};
+//#endregion
+export { canonicalFieldNode, fieldRequiresStructuredContent };

package/dist/prosemirror/hyperlinkRemoval.d.ts

@@ -1,9 +1,21 @@
+import { Node } from "prosemirror-model";
 import { EditorState, Transaction } from "prosemirror-state";
 //#region src/prosemirror/hyperlinkRemoval.d.ts
+declare const HyperlinkRemovalRefusal_base: import("better-result").TaggedErrorClass<"HyperlinkRemovalRefusal">;
+declare class HyperlinkRemovalRefusal extends HyperlinkRemovalRefusal_base<{
+  message: string;
+}> {}
+type HyperlinkRemovalRangeOptions = {
+  doc: Node;
+  from: number;
+  to: number;
+};
+/** Canonical inline elements have no addressable interior gaps. */
+declare const assertHyperlinkRemovalRange: ({ doc, from, to }: HyperlinkRemovalRangeOptions) => void;
 /**
  * Remove the hyperlinks from [`from`, `to`) of `tr.doc`: directly, or, with
  * suggestions on, as a tracked replacement of the linked text by plain text.
  */
 declare const removeHyperlinkInRange: (state: EditorState, tr: Transaction, from: number, to: number) => Transaction;
 //#endregion
-export { removeHyperlinkInRange };
+export { HyperlinkRemovalRefusal, assertHyperlinkRemovalRange, removeHyperlinkInRange };

package/dist/prosemirror/hyperlinkRemoval.js

@@ -3,19 +3,33 @@ import { getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/do
 import { isSuggestionModeActive, makeRevisionInfo, suggestRangeDeletion } from "./plugins/suggestionMode.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
 import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+import { TaggedError } from "better-result";
 //#region src/prosemirror/hyperlinkRemoval.ts
-/** Contiguous stretches of linked, not yet deleted, text in [`from`, `to`) of `doc`. */
+var HyperlinkRemovalRefusal = class extends TaggedError("HyperlinkRemovalRefusal") {};
+const partialInlineRefusal = () => new HyperlinkRemovalRefusal({ message: "Hyperlink removal cannot split an indivisible inline element." });
+/** Canonical inline elements have no addressable interior gaps. */
+const assertHyperlinkRemovalRange = ({ doc, from, to }) => {
+	for (const position of [from, to]) {
+		const resolved = doc.resolve(position);
+		for (let depth = 1; depth <= resolved.depth; depth += 1) {
+			const node = resolved.node(depth);
+			if (node.isInline && node.marks.some(({ type }) => type.name === "hyperlink")) throw partialInlineRefusal();
+		}
+	}
+};
+/** Contiguous stretches of linked, not yet deleted, inline content in [`from`, `to`) of `doc`. */
 const linkedRanges = (doc, from, to) => {
 	const ranges = [];
 	doc.nodesBetween(from, to, (node, position) => {
-		if (!node.isText || !node.marks.some(({ type }) => type.name === "hyperlink") || node.marks.some(({ type }) => type.name === "deletion")) return true;
+		if (!node.isInline || !node.marks.some(({ type }) => type.name === "hyperlink") || node.marks.some(({ type }) => type.name === "deletion")) return true;
 		const start = Math.max(position, from);
 		const end = Math.min(position + node.nodeSize, to);
 		if (start >= end) return true;
+		if (!node.isText && (start !== position || end !== position + node.nodeSize)) throw partialInlineRefusal();
 		const piece = {
 			from: start,
 			to: end,
-			node: node.cut(start - position, end - position)
+			node: node.isText ? node.cut(start - position, end - position) : node
 		};
 		const last = ranges.at(-1);
 		if (last && last.to === start) {
@@ -26,7 +40,7 @@ const linkedRanges = (doc, from, to) => {
 			to: end,
 			pieces: [piece]
 		});
-		return true;
+		return false;
 	});
 	return ranges;
 };
@@ -60,8 +74,8 @@ const withoutHyperlinkStyle = (state, doc, piece) => {
 		previousFormatting
 	};
 };
-/** Replace the marks of the text at [`from`, `to`) of `tr.doc` with `marks`. */
-const setTextMarks = (tr, from, to, current, marks) => {
+/** Replace the marks of the inline content at [`from`, `to`) of `tr.doc` with `marks`. */
+const setInlineMarks = (tr, from, to, current, marks) => {
 	for (const mark of current) if (!mark.isInSet(marks)) tr.removeMark(from, to, mark);
 	for (const mark of marks) if (!mark.isInSet(current)) tr.addMark(from, to, mark);
 };
@@ -70,6 +84,11 @@ const setTextMarks = (tr, from, to, current, marks) => {
 * suggestions on, as a tracked replacement of the linked text by plain text.
 */
 const removeHyperlinkInRange = (state, tr, from, to) => {
+	assertHyperlinkRemovalRange({
+		doc: tr.doc,
+		from,
+		to
+	});
 	const { schema } = state;
 	const hyperlinkType = schema.marks["hyperlink"];
 	if (!hyperlinkType) return tr;
@@ -108,7 +127,7 @@ const removeHyperlinkInRange = (state, tr, from, to) => {
 			...withoutHyperlinkStyle(state, tr.doc, piece)
 		}));
 		if (!insertion || !deletionType) {
-			for (const { piece, marks } of unlinked) setTextMarks(tr, piece.from, piece.to, piece.node.marks, marks.filter(({ type }) => type !== hyperlinkType));
+			for (const { piece, marks } of unlinked) setInlineMarks(tr, piece.from, piece.to, piece.node.marks, marks.filter(({ type }) => type !== hyperlinkType));
 			continue;
 		}
 		const plain = unlinked.map(({ piece, marks, previousFormatting }) => {
@@ -119,11 +138,11 @@ const removeHyperlinkInRange = (state, tr, from, to) => {
 		tr.insert(range.to, plain);
 		for (const { piece, marks, previousFormatting } of unlinked.toReversed()) {
 			const change = previousFormatting && !hasPendingPropertyChange(piece.node.marks) ? propertyChange(previousFormatting) : null;
-			setTextMarks(tr, piece.from, piece.to, piece.node.marks, change ? change.addToSet(marks) : marks);
+			setInlineMarks(tr, piece.from, piece.to, piece.node.marks, change ? change.addToSet(marks) : marks);
 		}
 		suggestRangeDeletion(state, tr, range.from, range.to);
 	}
 	return tr;
 };
 //#endregion
-export { removeHyperlinkInRange };
+export { HyperlinkRemovalRefusal, assertHyperlinkRemovalRange, removeHyperlinkInRange };

package/dist/prosemirror/listNumbering.js

@@ -10,7 +10,7 @@ import { directParagraphIndentation } from "./paragraphIndentation.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
 import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
-import { listAttrsFromNumbering, listLevelIndentAttrPatch } from "./styles/resolvedStyleAttrs.js";
+import { listAttrsFromNumbering, listIndentationProvenancePatch } from "./styles/resolvedStyleAttrs.js";
 //#region src/prosemirror/listNumbering.ts
 /**
 * Which numbering instance a list command puts a paragraph in, and the
@@ -199,10 +199,16 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 		numId,
 		ilvl
 	}, numbering),
-	...listLevelIndentAttrPatch(directParagraphIndentation(attrs), {
-		numId,
-		ilvl
-	}, numbering),
+	...listIndentationProvenancePatch({
+		direct: directParagraphIndentation(attrs),
+		styleFormatting: attrs._styleResolvedFormatting,
+		numberingSource: "paragraph",
+		numPr: {
+			numId,
+			ilvl
+		},
+		numbering
+	}),
 	listImplicitChildLevelAdvances: attrs["listImplicitChildLevelAdvances"] ?? null,
 	listFoldedMarkerSuffix: attrs["listFoldedMarkerSuffix"] ?? void 0,
 	listMarkerSecondSlotOffsetTwips: attrs["listMarkerSecondSlotOffsetTwips"] ?? null

package/dist/prosemirror/noteReferenceOccurrenceId.d.ts

@@ -0,0 +1,5 @@
+//#region src/prosemirror/noteReferenceOccurrenceId.d.ts
+/** Occurrence identities are opaque, nonblank attribution tokens. */
+declare const isNoteReferenceOccurrenceId: (value: unknown) => value is string;
+//#endregion
+export { isNoteReferenceOccurrenceId };

package/dist/prosemirror/noteReferenceOccurrenceId.js

@@ -0,0 +1,5 @@
+//#region src/prosemirror/noteReferenceOccurrenceId.ts
+/** Occurrence identities are opaque, nonblank attribution tokens. */
+const isNoteReferenceOccurrenceId = (value) => typeof value === "string" && value.trim().length > 0;
+//#endregion
+export { isNoteReferenceOccurrenceId };

package/dist/prosemirror/noteReferenceOccurrences.d.ts

@@ -0,0 +1,21 @@
+import { Node } from "prosemirror-model";
+import { Plugin, Transaction } from "prosemirror-state";
+//#region src/prosemirror/noteReferenceOccurrences.d.ts
+declare const NoteReferenceEditRefusal_base: import("better-result").TaggedErrorClass<"NoteReferenceEditRefusal">;
+declare class NoteReferenceEditRefusal extends NoteReferenceEditRefusal_base<{
+  message: string;
+}> {}
+declare const NoteReferenceReplayDefect_base: import("better-result").TaggedErrorClass<"NoteReferenceReplayDefect">;
+declare class NoteReferenceReplayDefect extends NoteReferenceReplayDefect_base<{
+  message: string;
+}> {}
+declare const markNoteReferenceReplay: (transaction: Transaction) => void;
+declare const noteReferenceTransactionIssue: (transaction: Transaction) => NoteReferenceEditRefusal | NoteReferenceReplayDefect | undefined;
+declare const mintNoteReferenceOccurrenceId: () => string;
+/** Saving asserts the edit-owner invariant and emits each occurrence once. */
+declare const coalesceNoteReferenceOccurrences: (paragraph: Node) => Node;
+declare const assertNoteReferenceOccurrences: (doc: Node) => void;
+/** Production edit boundary: refuse before committing an unsaveable occurrence. */
+declare const noteReferenceOccurrencePlugin: () => Plugin<any>;
+//#endregion
+export { NoteReferenceEditRefusal, NoteReferenceReplayDefect, assertNoteReferenceOccurrences, coalesceNoteReferenceOccurrences, markNoteReferenceReplay, mintNoteReferenceOccurrenceId, noteReferenceOccurrencePlugin, noteReferenceTransactionIssue };

package/dist/prosemirror/noteReferenceOccurrences.js

@@ -0,0 +1,185 @@
+import { readFootnoteRefMarkAttrs } from "./attrs/index.js";
+import { Result, TaggedError, panic } from "better-result";
+import { Fragment, Mark, Slice } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { isHistoryTransaction } from "prosemirror-history";
+//#region src/prosemirror/noteReferenceOccurrences.ts
+var NoteReferenceEditRefusal = class extends TaggedError("NoteReferenceEditRefusal") {};
+var NoteReferenceReplayDefect = class extends TaggedError("NoteReferenceReplayDefect") {};
+const NOTE_OCCURRENCE_REPLAY_META = "noteReferenceOccurrenceReplay";
+const markNoteReferenceReplay = (transaction) => {
+	transaction.setMeta(NOTE_OCCURRENCE_REPLAY_META, true);
+};
+const NOTE_OCCURRENCE_REPORT_META = "noteReferenceOccurrenceReport";
+const noteReferenceTransactionIssue = (transaction) => {
+	const issue = transaction.getMeta(NOTE_OCCURRENCE_REPORT_META);
+	return issue instanceof NoteReferenceEditRefusal || issue instanceof NoteReferenceReplayDefect ? issue : void 0;
+};
+const mintNoteReferenceOccurrenceId = () => crypto.randomUUID();
+/** Identity establishes boundaries; text only validates the already bounded unit. */
+const readOccurrences = (paragraph) => {
+	const referenceType = paragraph.type.schema.marks["footnoteRef"];
+	if (!referenceType || !paragraph.rangeHasMark(0, paragraph.content.size, referenceType)) return Result.ok([]);
+	const occurrences = [];
+	const seen = /* @__PURE__ */ new Set();
+	let previous;
+	let issue;
+	paragraph.forEach((node, from) => {
+		if (issue !== void 0) return;
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		if (!reference) {
+			previous = void 0;
+			return;
+		}
+		const attrs = readFootnoteRefMarkAttrs(reference);
+		if (!attrs.ok || !node.isText) {
+			issue = "Note references require attributed text occurrences.";
+			return;
+		}
+		const id = attrs.value.occurrenceId;
+		if (previous?.id === id) {
+			if (!Mark.sameSet(previous.node.marks, node.marks)) {
+				issue = "A note reference cannot have different formatting or revision owners within one occurrence.";
+				return;
+			}
+			previous.text += node.text ?? "";
+			previous.to = from + node.nodeSize;
+			return;
+		}
+		if (seen.has(id)) {
+			issue = "A note-reference occurrence must remain contiguous.";
+			return;
+		}
+		seen.add(id);
+		previous = {
+			id,
+			node,
+			text: node.text ?? "",
+			from,
+			to: from + node.nodeSize
+		};
+		occurrences.push(previous);
+	});
+	for (const occurrence of occurrences) {
+		const reference = occurrence.node.marks.find((mark) => mark.type.name === "footnoteRef");
+		if (!reference) return panic("Missing note-reference mark in an occurrence.");
+		const attrs = readFootnoteRefMarkAttrs(reference);
+		if (!attrs.ok) return panic("Invalid attributed note-reference occurrence.");
+		if (occurrence.text !== String(attrs.value.id)) issue ??= "Edit the whole note reference; its rendered label is indivisible.";
+	}
+	return issue === void 0 ? Result.ok(occurrences) : Result.err(new NoteReferenceEditRefusal({ message: issue }));
+};
+/** Saving asserts the edit-owner invariant and emits each occurrence once. */
+const coalesceNoteReferenceOccurrences = (paragraph) => {
+	if (saveOccurrenceValidator?.cachedIds(paragraph)?.length === 0) return paragraph;
+	const referenceType = paragraph.type.schema.marks["footnoteRef"];
+	if (!referenceType || !paragraph.rangeHasMark(0, paragraph.content.size, referenceType)) return paragraph;
+	const result = readOccurrences(paragraph);
+	if (result.isErr()) return panic(result.error.message);
+	if (result.value.every(({ node, from, to }) => node.nodeSize === to - from)) return paragraph;
+	const byStart = new Map(result.value.map((occurrence) => [occurrence.from, occurrence]));
+	const nodes = [];
+	let through = -1;
+	paragraph.forEach((node, from) => {
+		if (from < through) return;
+		const occurrence = byStart.get(from);
+		if (occurrence) {
+			nodes.push(node.type.schema.text(occurrence.text, node.marks));
+			through = occurrence.to;
+		} else nodes.push(node);
+	});
+	return paragraph.copy(Fragment.fromArray(nodes));
+};
+const createOccurrenceValidator = () => {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const validate = (node) => {
+		const cached = cache.get(node);
+		if (cached) return cached;
+		const ids = /* @__PURE__ */ new Set();
+		const include = (id) => {
+			if (ids.has(id)) return new NoteReferenceEditRefusal({ message: "Separate note references require distinct occurrence identities." });
+			ids.add(id);
+		};
+		if (node.inlineContent) {
+			const own = readOccurrences(node);
+			if (own.isErr()) return Result.err(own.error);
+			for (const occurrence of own.value) {
+				const issue = include(occurrence.id);
+				if (issue) return Result.err(issue);
+			}
+		}
+		for (let index = 0; index < node.childCount; index += 1) {
+			const child = node.child(index);
+			if (child.isLeaf) continue;
+			const nested = validate(child);
+			if (nested.isErr()) return nested;
+			for (const id of nested.value) {
+				const issue = include(id);
+				if (issue) return Result.err(issue);
+			}
+		}
+		const result = Result.ok([...ids]);
+		cache.set(node, result);
+		return result;
+	};
+	return {
+		validate,
+		cachedIds: (node) => {
+			const facts = cache.get(node);
+			return facts?.isOk() ? facts.value : void 0;
+		},
+		validateSave: (doc) => {
+			const facts = cache.get(doc);
+			if (facts?.isOk() && facts.value.length === 0) return facts;
+			cache.delete(doc);
+			return validate(doc);
+		}
+	};
+};
+let saveOccurrenceValidator;
+const assertNoteReferenceOccurrences = (doc) => {
+	const result = (saveOccurrenceValidator ??= createOccurrenceValidator()).validateSave(doc);
+	if (result.isErr()) panic(result.error.message);
+};
+/** Production edit boundary: refuse before committing an unsaveable occurrence. */
+const noteReferenceOccurrencePlugin = () => {
+	const { validate } = createOccurrenceValidator();
+	return new Plugin({
+		filterTransaction(transaction) {
+			if (!transaction.docChanged) return true;
+			const result = validate(transaction.doc);
+			if (result.isOk()) return true;
+			const replay = isHistoryTransaction(transaction) || transaction.getMeta(NOTE_OCCURRENCE_REPLAY_META) === true;
+			transaction.setMeta(NOTE_OCCURRENCE_REPORT_META, replay ? new NoteReferenceReplayDefect({ message: result.error.message }) : result.error);
+			return replay;
+		},
+		props: { transformPasted(slice) {
+			const identities = /* @__PURE__ */ new Map();
+			const remint = (fragment) => {
+				const nodes = [];
+				fragment.forEach((node) => {
+					const marks = node.marks.map((mark) => {
+						if (mark.type.name !== "footnoteRef") return mark;
+						const attrs = readFootnoteRefMarkAttrs(mark);
+						if (!attrs.ok) return mark;
+						const id = attrs.value.occurrenceId;
+						let replacement = identities.get(id);
+						if (replacement === void 0) {
+							replacement = mintNoteReferenceOccurrenceId();
+							identities.set(id, replacement);
+						}
+						return mark.type.create({
+							...mark.attrs,
+							occurrenceId: replacement
+						});
+					});
+					nodes.push(node.copy(remint(node.content)).mark(marks));
+				});
+				return Fragment.fromArray(nodes);
+			};
+			return new Slice(remint(slice.content), slice.openStart, slice.openEnd);
+		} }
+	});
+};
+//#endregion
+export { NoteReferenceEditRefusal, NoteReferenceReplayDefect, assertNoteReferenceOccurrences, coalesceNoteReferenceOccurrences, markNoteReferenceReplay, mintNoteReferenceOccurrenceId, noteReferenceOccurrencePlugin, noteReferenceTransactionIssue };

package/dist/prosemirror/noteReferenceReview.js

@@ -2,6 +2,7 @@ import { withoutLostCommentThreads } from "../ai-edits/comment-lifecycle.js";
 import { visitCommentMarkers } from "../docx/commentAnchorIndex.js";
 import { isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.js";
 import { pluginsForHeadlessRevisionResolution } from "../internal/headlessRevisionResolutionGuard.js";
+import { addTrackedDeletionMark } from "./addTrackedDeletionMark.js";
 import { expectFootnoteRefMarkAttrs, expectParagraphAttrs } from "./attrs/index.js";
 import { rejectAIEditRevision } from "./commands/comments.js";
 import { proseDocToBlocks } from "./conversion/fromProseDoc.js";
@@ -13,6 +14,12 @@ import { schema, singletonManager } from "./schema/index.js";
 import { Transform } from "prosemirror-transform";
 import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/noteReferenceReview.ts
+/**
+* A note goes with its reference. Deleting a note's reference while tracking
+* changes deletes the note's text too, so rejecting that deletion must give
+* the note its text back, whichever surface resolves it: the body editor
+* resolves the reference, and this resolves the note's story to match.
+*/
 const noteKey = (kind, id) => `${kind}:${id}`;
 /**
 * The notes a story's text refers to, and whether each reference is pending
@@ -155,7 +162,13 @@ const deleteNoteWithReference = (transform, reference) => {
 			kind: "del",
 			info: markInfo
 		});
-		if (node.isInline && !deletion.type.isInSet(node.marks)) transform.addMark(position, position + node.nodeSize, deletion);
+		if (node.isInline && !deletion.type.isInSet(node.marks)) addTrackedDeletionMark({
+			insertionPolicy: "preserve-pending",
+			tr: transform,
+			from: position,
+			to: position + node.nodeSize,
+			mark: deletion
+		});
 		return !node.isInline;
 	});
 	return transform;

package/dist/prosemirror/plugins/documentStyles.d.ts

@@ -3,6 +3,9 @@ import { StyleResolver } from "../styles/styleResolver.js";
 import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver } from "./documentStyleState.js";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
+type DocumentStylesInput = document_d_exports.StyleDefinitions | StyleResolver | null | undefined;
+/** Canonical projections own formatting; expose the resolver without PM repair transactions. */
+declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) => Plugin;
 /**
  * Create the plugin holding a StyleResolver for the document's `styles` for
  * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -14,4 +17,4 @@ declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefi
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStyleContextPlugin, createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };

package/dist/prosemirror/plugins/documentStyles.js

@@ -76,6 +76,21 @@ const bareResolver = () => {
 	bareStyleResolver ??= createStyleResolver(void 0);
 	return bareStyleResolver;
 };
+const documentStyleContextSpec = (styles) => {
+	let resolver;
+	if (styles instanceof StyleResolver) resolver = styles;
+	else if (styles) resolver = createStyleResolver(styles);
+	else resolver = null;
+	return {
+		key: documentStylesKey,
+		state: {
+			init: () => resolver,
+			apply: (_tr, value) => value
+		}
+	};
+};
+/** Canonical projections own formatting; expose the resolver without PM repair transactions. */
+const createDocumentStyleContextPlugin = (styles) => new Plugin(documentStyleContextSpec(styles));
 /**
 * Create the plugin holding a StyleResolver for the document's `styles` for
 * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -84,16 +99,8 @@ const bareResolver = () => {
 * have one.
 */
 function createDocumentStylesPlugin(styles) {
-	let resolver;
-	if (styles instanceof StyleResolver) resolver = styles;
-	else if (styles) resolver = createStyleResolver(styles);
-	else resolver = null;
 	return new Plugin({
-		key: documentStylesKey,
-		state: {
-			init: () => resolver,
-			apply: (_tr, value) => value
-		},
+		...documentStyleContextSpec(styles),
 		appendTransaction: (transactions, _oldState, newState) => {
 			const styleResolver = documentStylesKey.getState(newState) ?? bareResolver();
 			const tr = resolveEditedParagraphStyles(transactions, newState, styleResolver, () => getDocumentNumbering(newState)) ?? newState.tr;
@@ -109,4 +116,4 @@ const withDocumentStyles = (state, styles) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentStylesPlugin(styles)] });
 };
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStyleContextPlugin, createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };