@stll/folio-core 0.55.0 → 0.57.0

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/paragraphPropertyCarry.d.ts

@@ -4,6 +4,7 @@ import { NumberingMap } from "../docx/numberingParser.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/paragraphPropertyCarry.d.ts
+type RecordedFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
 type CarryParagraphPropertiesOptions = {
   tr: Transaction;
   /** The paragraph that takes the properties. */
@@ -17,6 +18,11 @@ type CarryParagraphPropertiesOptions = {
   /** Properties the paragraph keeps its own values of: ones its own batch set. */
   keep?: ReadonlySet<string>;
 };
+type CarriedParagraphPropertiesOptions = Pick<CarryParagraphPropertiesOptions, "source" | "keep"> & {
+  target: Node;
+};
+/** The exact formatting transfer, shared with pre-mutation capacity checks. */
+declare const carriedParagraphProperties: ({ source, target, keep }: CarriedParagraphPropertiesOptions) => RecordedFormatting;
 /**
  * Give a paragraph another one's properties: the pPr a property change
  * covers. Its identity, mark, mark run properties and section stay its own,
@@ -61,4 +67,4 @@ declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revi
  */
 declare const propertiesSetInBatch: (node: Node, batchRevisionIds: ReadonlySet<number>) => ReadonlySet<string>;
 //#endregion
-export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };
+export { carriedParagraphProperties, carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -17,6 +17,8 @@ import { panic } from "better-result";
 * revision, so accepting reads as the direct edit and rejecting restores the
 * second's own.
 */
+/** The exact formatting transfer, shared with pre-mutation capacity checks. */
+const carriedParagraphProperties = ({ source, target, keep }) => Object.fromEntries([...Object.entries(paragraphPropertiesSnapshot(source)).filter(([key]) => !keep?.has(key)), ...Object.entries(paragraphPropertiesSnapshot(target)).filter(([key]) => keep?.has(key))]);
 /**
 * Give a paragraph another one's properties: the pPr a property change
 * covers. Its identity, mark, mark run properties and section stay its own,
@@ -32,8 +34,11 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 		tracked: false
 	};
 	const previousFormatting = paragraphPropertiesSnapshot(target);
-	const own = previousFormatting;
-	const formatting = Object.fromEntries([...Object.entries(paragraphPropertiesSnapshot(source)).filter(([key]) => !keep?.has(key)), ...Object.entries(own).filter(([key]) => keep?.has(key))]);
+	const formatting = carriedParagraphProperties({
+		source,
+		target,
+		...keep === void 0 ? {} : { keep }
+	});
 	if (JSON.stringify(previousFormatting) === JSON.stringify(formatting)) return {
 		tr,
 		changed: false,
@@ -152,4 +157,4 @@ const propertiesSetInBatch = (node, batchRevisionIds) => {
 	return new Set([.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(now)])].filter((key) => JSON.stringify(before[key]) !== JSON.stringify(now[key])));
 };
 //#endregion
-export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };
+export { carriedParagraphProperties, carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };

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 };

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,3 +1,4 @@
+import { addTrackedDeletionMark } from "../addTrackedDeletionMark.js";
 import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { clearIndentOnBackspace } from "../commands/clearParagraphIndent.js";
 import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
@@ -117,20 +118,13 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 * Retract the current author's own inserted text.
 * Processes in reverse order to maintain position validity.
 */
-function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState, joinState) {
-	const ranges = [];
+function markRangeAsDeleted(tr, doc, from, to, deletionType, pluginState, joinState) {
+	let hasMarkableContent = false;
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (!canCarryTrackedRunMark(node)) return;
-		const start = Math.max(pos, from);
-		const end = Math.min(pos + node.nodeSize, to);
-		if (start >= end) return;
-		const isOwnInsert = node.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
+		if (Math.max(pos, from) >= Math.min(pos + node.nodeSize, to)) return;
 		if (node.marks.some((m) => m.type === deletionType)) return;
-		ranges.push({
-			from: start,
-			to: end,
-			isOwnInsert
-		});
+		hasMarkableContent = true;
 	});
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
 	let removedMark = false;
@@ -165,18 +159,20 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 			date: delAttrs.date
 		});
 	}
-	if (ranges.length === 0) return;
+	if (!hasMarkableContent) return;
 	encloseWholeControls({
 		tr,
 		from,
 		to,
 		revisionId: delAttrs.revisionId
 	});
-	for (let i = ranges.length - 1; i >= 0; i--) {
-		const range = ranges[i];
-		if (range.isOwnInsert) tr.delete(range.from, range.to);
-		else tr.addMark(range.from, range.to, deletionType.create(delAttrs));
-	}
+	addTrackedDeletionMark({
+		tr,
+		from,
+		to,
+		mark: deletionType.create(delAttrs),
+		insertionPolicy: "retract-own"
+	});
 }
 /** Preserve clipboard revisions inside the revision that inserted their content. */
 function enclosePastedRunRevisions({ tr, from, to, revision: insertion }) {
@@ -298,7 +294,7 @@ function handleSuggestionPaste(view, slice, pluginState) {
 	const endsContainer = wholeBlocks && paragraphEndsItsContainer(doc.resolve($to.before()), $to.parent.type.name);
 	const rotates = endsContainer && slice.content.firstChild?.type === $to.parent.type && slice.content.lastChild?.type === $to.parent.type;
 	const tableFirst = endsContainer && !rotates;
-	if (!tableFirst) markRangeAsDeleted(tr, doc, from, wholeBlocks && !endsContainer ? $to.after() : to, insertionType, deletionType, pluginState);
+	if (!tableFirst) markRangeAsDeleted(tr, doc, from, wholeBlocks && !endsContainer ? $to.after() : to, deletionType, pluginState);
 	const carryAcross = () => {
 		if (selectsAll || $from.parent.type.name !== "paragraph" || $from.parent === $to.parent || from <= $from.start()) return;
 		const firstPos = tr.mapping.map($from.before());
@@ -332,7 +328,7 @@ function handleSuggestionPaste(view, slice, pluginState) {
 	let insertTo = placed.length === 0 ? at : Math.max(...placed.map((range) => range.to));
 	if (tableFirst) {
 		const struck = tr.steps.length;
-		markRangeAsDeleted(tr, tr.doc, tr.mapping.map(from), tr.mapping.map(to), insertionType, deletionType, pluginState);
+		markRangeAsDeleted(tr, tr.doc, tr.mapping.map(from), tr.mapping.map(to), deletionType, pluginState);
 		const since = tr.mapping.slice(struck);
 		insertFrom = since.map(insertFrom, -1);
 		insertTo = since.map(insertTo, -1);
@@ -405,7 +401,7 @@ function handleSuggestionTableCellPaste(view, slice, pluginState) {
 			if (!cell) return;
 			const { from, to } = cellPasteRange(cell, cellPos, content);
 			const mapFrom = tr.mapping.maps.length;
-			markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+			markRangeAsDeleted(tr, tr.doc, from, to, deletionType, pluginState);
 			const insertFrom = tr.mapping.slice(mapFrom).map(to);
 			const sizeBefore = tr.doc.content.size;
 			tr.replaceRange(insertFrom, insertFrom, content);
@@ -538,7 +534,7 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
 	if (from !== to) {
 		const deletionType = view.state.schema.marks["deletion"];
-		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState, view.state);
+		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, deletionType, pluginState, view.state);
 	}
 	const insertAt = tr.mapping.map(to);
 	tr.insertText(text, insertAt, insertAt);
@@ -597,7 +593,7 @@ function suggestRangeDeletion(state, tr, from, to) {
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
 	if (!pluginState?.active || !insertionType || !deletionType) return false;
-	markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+	markRangeAsDeleted(tr, tr.doc, from, to, deletionType, pluginState);
 	return true;
 }
 /**
@@ -661,21 +657,23 @@ function handleSuggestionEnter(view, pluginState) {
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
-/** Find the adjacent visible unit without consuming a bookmark range marker. */
+/** Find the adjacent visible unit without consuming retained deletions or bookmark markers. */
 function caretDeleteTarget(state, direction) {
 	const { $from } = state.selection;
 	const backward = direction === "backward";
-	let from = backward ? $from.pos - 1 : $from.pos;
-	let to = backward ? $from.pos : $from.pos + 1;
-	while (from >= $from.start() && to <= $from.end()) {
-		const adjacent = state.doc.resolve(from).nodeAfter;
-		if (adjacent?.type.name !== "bookmarkBoundary") return {
-			type: "inlineUnit",
-			from,
-			to
-		};
-		from += backward ? -adjacent.nodeSize : adjacent.nodeSize;
-		to += backward ? -adjacent.nodeSize : adjacent.nodeSize;
+	let cursor = $from.pos;
+	while (cursor >= $from.start() && cursor <= $from.end()) {
+		const adjacent = backward ? state.doc.resolve(cursor).nodeBefore : state.doc.resolve(cursor).nodeAfter;
+		if (!adjacent) return { type: "paragraphEdge" };
+		if (adjacent.type.name !== "bookmarkBoundary" && !adjacent.marks.some((mark) => mark.type === state.schema.marks["deletion"])) {
+			const size = adjacent.isAtom && !adjacent.isText ? adjacent.nodeSize : 1;
+			return {
+				type: "inlineUnit",
+				from: backward ? cursor - size : cursor,
+				to: backward ? cursor : cursor + size
+			};
+		}
+		cursor += backward ? -adjacent.nodeSize : adjacent.nodeSize;
 	}
 	return { type: "paragraphEdge" };
 }
@@ -793,7 +791,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 			from: rangeFrom.pos,
 			to: rangeTo.pos
 		}).sort((a, b) => b.from - a.from);
-		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState, state);
+		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, deletionType, pluginState, state);
 		if (state.selection instanceof CellSelection) tr.setSelection(state.selection.map(tr.doc, tr.mapping));
 		else {
 			const cursorPos = tr.mapping.map($to.pos);
@@ -821,17 +819,20 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const rangeTo = noteRange?.to ?? deleteEnd;
 	const nodeAfter = state.doc.resolve(rangeFrom).nodeAfter;
 	if (!nodeAfter || !canCarryTrackedRunMark(nodeAfter)) return false;
-	const hasOwnInsertion = nodeAfter.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
-	if (nodeAfter.marks.some((m) => m.type === deletionType)) {
-		const newPos = isBackward ? rangeFrom : rangeTo;
-		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
-	} else if (hasOwnInsertion) tr.delete(rangeFrom, rangeTo);
-	else {
+	const mapFrom = tr.mapping.maps.length;
+	if (noteRange) markRangeAsDeleted(tr, state.doc, noteRange.from, noteRange.to, deletionType, pluginState);
+	else if (!nodeAfter.marks.some((m) => m.type === deletionType)) {
 		const delAttrs = findAdjacentRevisionForRange(state.doc, rangeFrom, rangeTo, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
-		tr.addMark(rangeFrom, rangeTo, deletionType.create(delAttrs));
-		const newPos = isBackward ? rangeFrom : rangeTo;
-		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
+		addTrackedDeletionMark({
+			insertionPolicy: "retract-own",
+			tr,
+			from: rangeFrom,
+			to: rangeTo,
+			mark: deletionType.create(delAttrs)
+		});
 	}
+	const newPos = tr.mapping.slice(mapFrom).map(isBackward ? rangeFrom : rangeTo);
+	tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
 	dispatch(tr.scrollIntoView());
 	return true;
 }
@@ -848,7 +849,7 @@ function markComposedAsInsertion({ view, from, pluginState, replaced, compositio
 	if (compositionId !== null) tr.setMeta("composition", compositionId);
 	if (replaced) {
 		tr.replaceRange(from, from, replaced);
-		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), insertionType, deletionType, pluginState);
+		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), deletionType, pluginState);
 		const restoredEnd = tr.doc.resolve(tr.mapping.map(from, 1));
 		const restoredStart = tr.doc.resolve(from);
 		if (restoredStart.parent.type.name === "paragraph" && restoredEnd.parent.type.name === "paragraph" && restoredStart.parent !== restoredEnd.parent) {
@@ -918,14 +919,14 @@ function replacedInline(before, step) {
 * rejecting restores it and accepting removes it. The author's own
 * insertions are retracted instead.
 */
-function restoreReplacedInline({ tr, replaced, insertionType, deletionType, pluginState }) {
+function restoreReplacedInline({ tr, replaced, deletionType, pluginState }) {
 	for (const { at, content } of replaced) {
 		const pos = tr.mapping.map(at, -1);
 		const $pos = tr.doc.resolve(pos);
 		const index = $pos.index();
 		if (!$pos.parent.canReplace(index, index, content)) continue;
 		tr.insert(pos, content);
-		markRangeAsDeleted(tr, tr.doc, pos, pos + content.size, insertionType, deletionType, pluginState);
+		markRangeAsDeleted(tr, tr.doc, pos, pos + content.size, deletionType, pluginState);
 	}
 }
 /**
@@ -1101,7 +1102,6 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			if (deletionType) restoreReplacedInline({
 				tr,
 				replaced,
-				insertionType,
 				deletionType,
 				pluginState
 			});

package/dist/prosemirror/preservedXmlReview.d.ts

@@ -0,0 +1,6 @@
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/preservedXmlReview.d.ts
+/** A retained opaque deleted result becomes ordinary text when its last deletion resolves. */
+declare const resolvedPreservedXmlAttrs: (node: Node, marks: readonly Mark[]) => import("prosemirror-model").Attrs;
+//#endregion
+export { resolvedPreservedXmlAttrs };

package/dist/prosemirror/preservedXmlReview.js

@@ -0,0 +1,35 @@
+import { captureVerbatimXml } from "../docx/verbatimCapture.js";
+import { OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, getChildElements, getLocalName, parseXml } from "../docx/xmlParser.js";
+import { expectPreservedXmlAttrs, expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+//#region src/prosemirror/preservedXmlReview.ts
+const restoreDeletedText = (node) => {
+	if (node.type !== "element") return node;
+	const name = getLocalName(node.name);
+	let target;
+	if (name === "delText") target = "t";
+	if (name === "delInstrText") target = "instrText";
+	const renamed = target !== void 0 && WORDPROCESSINGML_NAMESPACE_URIS.has(node.namespaceUri ?? "") ? node.name?.replace(/[^:]+$/u, target) : node.name;
+	const elements = node.elements?.map(restoreDeletedText);
+	if (renamed === node.name && elements?.every((child, index) => child === node.elements?.[index]) !== false) return node;
+	return cloneElement(node, {
+		...renamed !== void 0 && renamed !== node.name ? { name: renamed } : {},
+		...elements ? { elements } : {}
+	});
+};
+const hasPendingDeletion = (marks) => marks.some((mark) => {
+	if (mark.type.name === "deletion") return true;
+	if (mark.type.name !== "insertion") return false;
+	return expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((ancestor) => ancestor.type === "deletion" || ancestor.type === "moveFrom") ?? false;
+});
+/** A retained opaque deleted result becomes ordinary text when its last deletion resolves. */
+const resolvedPreservedXmlAttrs = (node, marks) => {
+	if (node.type.name !== "preservedXml" || !hasPendingDeletion(node.marks) || hasPendingDeletion(marks)) return node.attrs;
+	const attrs = expectPreservedXmlAttrs(node);
+	const xml = getChildElements(parseXml(attrs.xml, OOXML_NAMESPACE_SCOPE)).map((element) => captureVerbatimXml(restoreDeletedText(element))).join("");
+	return xml === attrs.xml ? node.attrs : {
+		...node.attrs,
+		xml
+	};
+};
+//#endregion
+export { resolvedPreservedXmlAttrs };

package/dist/prosemirror/runFormattingFromMarks.js

@@ -4,7 +4,7 @@ import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectE
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./conversion/runShadingMark.js";
 import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "./extensions/marks/RunFormattingOverrideExtension.js";
 import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "./runFormattingProvenance.js";
-import { paragraphFormattingForRun, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "./runStyleFormatting.js";
+import { isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "./runStyleFormatting.js";
 //#region src/prosemirror/runFormattingFromMarks.ts
 const RUN_FORMATTING_VISUAL_GROUPS = {
 	bold: "bold",
@@ -570,7 +570,7 @@ function marksToTextFormatting(marks, options) {
 			inheritedFormatting: suppressedInheritedFormatting,
 			observedFormatting: formatting
 		});
-		if (formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
+		if (isParagraphMarkSuppressionEligible(suppressed) && formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
 	}
 	return {
 		...reconciled,

package/dist/prosemirror/runFormattingReconciliation.js

@@ -3,7 +3,7 @@ import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
 import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
 import { marksToTextFormatting } from "./runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
-import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
+import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
@@ -37,14 +37,15 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 		paragraphFormatting,
 		...styleResolver !== void 0 ? { styleResolver } : {}
 	}), authoredFormatting);
-	const overrideFormatting = mergeTextFormatting(getParagraphMarkSuppressionOverrides({
+	const overrideFormatting = mergeTextFormatting(isParagraphMarkSuppressionEligible(authoredFormatting) ? getParagraphMarkSuppressionOverrides({
 		directFormatting: authoredFormatting,
 		paragraphMarkFormatting: context.paragraphMarkFormatting,
 		suppressedFormatting: paragraphFormatting
-	}), authoredFormatting);
+	}) : void 0, authoredFormatting);
 	const formattingMarks = textFormattingToMarks(effectiveFormatting, node.type.schema, {
 		overrideFormatting,
-		directFormatting: authoredFormatting
+		directFormatting: authoredFormatting,
+		authoredCarrier: "preserve"
 	});
 	return Mark.setFrom([
 		...marks.filter(({ type }) => !RUN_FORMATTING_MARK_NAMES.has(type.name)),

package/dist/prosemirror/runPropertyChangeResolution.d.ts

@@ -14,5 +14,12 @@ type ReconstructRejectedRunFormattingMarksOptions = {
  * owner so their reject semantics cannot diverge at the bulk threshold.
  */
 declare const reconstructRejectedRunFormattingMarks: ({ node, paragraphContext, previousFormatting, styleResolver }: ReconstructRejectedRunFormattingMarksOptions) => readonly Mark[];
+type RestoreHistoricalRunFormattingOptions = {
+  node: Node;
+  paragraphContext: ParagraphRunStyleContext;
+  styleResolver?: RunStyleResolver | null;
+};
+/** Restored deletions inherit the live paragraph cascade without authoring their historical visuals. */
+declare const restoreHistoricalRunFormatting: ({ node, paragraphContext, styleResolver }: RestoreHistoricalRunFormattingOptions) => readonly Mark[];
 //#endregion
-export { reconstructRejectedRunFormattingMarks };
+export { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting };