@stll/folio-core 0.52.0 → 0.53.0

package/dist/internal/compare/inline-presentation.js

@@ -43,7 +43,7 @@ const CANONICAL_INLINE_PRESENTATION_PROPERTIES = Object.freeze([
 	...INLINE_PRESENTATION_GRAMMAR.color
 ]);
 const canonicalColor = (value) => value === null || value === void 0 ? value : normalizeInlinePresentationColor(value);
-const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
+const writeCanonicalInlinePresentationDifferences = (base, revised, patch, presentationBasis = "full") => {
 	let changed = false;
 	const baseDirect = base?.directFormatting ?? {};
 	const revisedDirect = revised?.directFormatting ?? {};
@@ -54,7 +54,7 @@ const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
 		const revisedEffective = revised?.[property] === true;
 		let value;
 		if (baseAuthored !== revisedAuthored) value = revisedAuthored ?? null;
-		else if (baseEffective === revisedEffective) value = NO_PRESENTATION_DIFFERENCE;
+		else if (presentationBasis === "authored" || baseEffective === revisedEffective) value = NO_PRESENTATION_DIFFERENCE;
 		else value = revisedEffective;
 		if (value !== NO_PRESENTATION_DIFFERENCE) {
 			changed = true;
@@ -64,7 +64,7 @@ const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
 	const stringProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.string[0];
 	let stringValue;
 	if (baseDirect[stringProperty] !== revisedDirect[stringProperty]) stringValue = revisedDirect[stringProperty] ?? null;
-	else if (base?.[stringProperty] === revised?.[stringProperty]) stringValue = NO_PRESENTATION_DIFFERENCE;
+	else if (presentationBasis === "authored" || base?.[stringProperty] === revised?.[stringProperty]) stringValue = NO_PRESENTATION_DIFFERENCE;
 	else stringValue = revised?.[stringProperty] ?? null;
 	if (stringValue !== NO_PRESENTATION_DIFFERENCE) {
 		changed = true;
@@ -73,7 +73,7 @@ const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
 	const numberProperty = INLINE_PRESENTATION_HOT_PATH_GRAMMAR.number[0];
 	let numberValue;
 	if (baseDirect[numberProperty] !== revisedDirect[numberProperty]) numberValue = revisedDirect[numberProperty] ?? null;
-	else if (base?.[numberProperty] === revised?.[numberProperty]) numberValue = NO_PRESENTATION_DIFFERENCE;
+	else if (presentationBasis === "authored" || base?.[numberProperty] === revised?.[numberProperty]) numberValue = NO_PRESENTATION_DIFFERENCE;
 	else numberValue = revised?.[numberProperty] ?? null;
 	if (numberValue !== NO_PRESENTATION_DIFFERENCE) {
 		changed = true;
@@ -86,7 +86,7 @@ const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
 	const revisedEffectiveColor = canonicalColor(revised?.[colorProperty]);
 	let color;
 	if (baseAuthoredColor !== revisedAuthoredColor) color = revisedAuthoredColor ?? null;
-	else if (baseEffectiveColor === revisedEffectiveColor) color = NO_PRESENTATION_DIFFERENCE;
+	else if (presentationBasis === "authored" || baseEffectiveColor === revisedEffectiveColor) color = NO_PRESENTATION_DIFFERENCE;
 	else color = revisedEffectiveColor ?? null;
 	if (color !== NO_PRESENTATION_DIFFERENCE) {
 		changed = true;
@@ -95,9 +95,9 @@ const writeCanonicalInlinePresentationDifferences = (base, revised, patch) => {
 	return changed;
 };
 const canonicalInlinePresentationsEqual = (base, revised) => !writeCanonicalInlinePresentationDifferences(base, revised, null);
-const changedCanonicalInlinePresentation = (base, revised) => {
+const changedCanonicalInlinePresentation = (base, revised, presentationBasis) => {
 	const patch = {};
-	return writeCanonicalInlinePresentationDifferences(base, revised, patch) ? patch : null;
+	return writeCanonicalInlinePresentationDifferences(base, revised, patch, presentationBasis) ? patch : null;
 };
 const sameCanonicalInlinePresentationPatch = (left, right) => {
 	for (const property of INLINE_PRESENTATION_GRAMMAR.boolean) if (left[property] !== right[property]) return false;
@@ -148,7 +148,7 @@ const visitAlignedRunRanges = (options) => {
 		if (options.type === "equivalence") {
 			if (!canonicalInlinePresentationsEqual(baseRun, revisedRun)) return "stopped";
 		} else if (!exceededBudget) {
-			const formatting = changedCanonicalInlinePresentation(baseRun, revisedRun);
+			const formatting = changedCanonicalInlinePresentation(baseRun, revisedRun, options.presentationBasis);
 			if (formatting !== null) {
 				const previous = options.segments.at(-1);
 				if (previous && previous.endOffset === baseBlockOffset && sameCanonicalInlinePresentationPatch(previous.formatting, formatting)) previous.endOffset += length;
@@ -180,14 +180,15 @@ const hasAlignedRunStream = (block) => {
 * Invalid run streams take precedence over the segment budget, so malformed
 * content cannot change meaning as the caller's remaining budget changes.
 */
-const canonicalInlinePresentationSegments = ({ baseBlock, revisedBlock, maxSegments }) => {
+const canonicalInlinePresentationSegments = ({ baseBlock, revisedBlock, maxSegments, presentationBasis = "full" }) => {
 	const segments = [];
 	const result = visitAlignedRunRanges({
 		type: "segments",
 		baseBlock,
 		revisedBlock,
 		maxSegments,
-		segments
+		segments,
+		presentationBasis
 	});
 	switch (result) {
 		case "complete": return {

package/dist/internal/headlessRevisionResolutionGuard.d.ts

@@ -1,12 +1,6 @@
-import { EditorState, Plugin } from "prosemirror-state";
+import { Plugin } from "prosemirror-state";
 //#region src/internal/headlessRevisionResolutionGuard.d.ts
-/**
- * Whether a state can consume an unmapped replacement before it returns.
- * Only the internal headless plugin set opts in; history and collaboration
- * plugins always keep the state on the legacy editor-command path.
- */
-declare const stateAllowsHeadlessRevisionResolution: (state: EditorState) => boolean;
 /** Build the private plugin set for synchronous headless review states. */
 declare const pluginsForHeadlessRevisionResolution: (plugins: readonly Plugin[]) => readonly Plugin[];
 //#endregion
-export { pluginsForHeadlessRevisionResolution, stateAllowsHeadlessRevisionResolution };
+export { pluginsForHeadlessRevisionResolution };

package/dist/internal/headlessRevisionResolutionGuard.js

@@ -1,4 +1,3 @@
-import { Plugin, PluginKey } from "prosemirror-state";
 //#region src/internal/headlessRevisionResolutionGuard.ts
 const UNSAFE_PLUGIN_KEY_PREFIXES = [
 	"collab$",
@@ -6,8 +5,6 @@ const UNSAFE_PLUGIN_KEY_PREFIXES = [
 	"y-sync$",
 	"y-undo$"
 ];
-const headlessRevisionResolutionKey = new PluginKey("folioHeadlessRevisionResolution");
-const headlessRevisionResolutionPlugin = new Plugin({ key: headlessRevisionResolutionKey });
 const pluginRuntimeKey = (plugin) => {
 	const key = Reflect.get(plugin, "key");
 	return typeof key === "string" ? key : null;
@@ -16,13 +13,7 @@ const retainsOrTransportsSteps = (plugin) => {
 	const key = pluginRuntimeKey(plugin);
 	return key !== null && UNSAFE_PLUGIN_KEY_PREFIXES.some((prefix) => key.startsWith(prefix));
 };
-/**
-* Whether a state can consume an unmapped replacement before it returns.
-* Only the internal headless plugin set opts in; history and collaboration
-* plugins always keep the state on the legacy editor-command path.
-*/
-const stateAllowsHeadlessRevisionResolution = (state) => headlessRevisionResolutionKey.get(state) === headlessRevisionResolutionPlugin && !state.plugins.some(retainsOrTransportsSteps);
 /** Build the private plugin set for synchronous headless review states. */
-const pluginsForHeadlessRevisionResolution = (plugins) => [...plugins.filter((plugin) => !retainsOrTransportsSteps(plugin)), headlessRevisionResolutionPlugin];
+const pluginsForHeadlessRevisionResolution = (plugins) => plugins.filter((plugin) => !retainsOrTransportsSteps(plugin));
 //#endregion
-export { pluginsForHeadlessRevisionResolution, stateAllowsHeadlessRevisionResolution };
+export { pluginsForHeadlessRevisionResolution };

package/dist/internal/indexedPositionMap.d.ts

@@ -0,0 +1,11 @@
+import { StepMap } from "prosemirror-transform";
+//#region src/internal/indexedPositionMap.d.ts
+/** StepMap.map scans its ranges; index them once for many paragraph lookups. */
+declare const indexedPositionMap: (map: StepMap) => ((position: number, assoc: 1 | -1) => number) & {
+  mapResult: (position: number, assoc: 1 | -1) => {
+    pos: number;
+    deletedAcross: boolean;
+  };
+};
+//#endregion
+export { indexedPositionMap };

package/dist/internal/indexedPositionMap.js

@@ -0,0 +1,42 @@
+//#region src/internal/indexedPositionMap.ts
+/** StepMap.map scans its ranges; index them once for many paragraph lookups. */
+const indexedPositionMap = (map) => {
+	const changes = [];
+	map.forEach((oldStart, oldEnd, newStart, newEnd) => {
+		changes.push({
+			oldStart,
+			oldEnd,
+			newStart,
+			newEnd
+		});
+	});
+	const mapResult = (position, assoc) => {
+		let low = 0;
+		let high = changes.length;
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+			const candidate = changes.at(middle);
+			if (candidate && candidate.oldEnd < position) low = middle + 1;
+			else high = middle;
+		}
+		const change = changes.at(low);
+		if (change && change.oldStart <= position) {
+			const oldSize = change.oldEnd - change.oldStart;
+			let side = assoc;
+			if (oldSize > 0 && position === change.oldStart) side = -1;
+			else if (oldSize > 0 && position === change.oldEnd) side = 1;
+			return {
+				pos: side < 0 ? change.newStart : change.newEnd,
+				deletedAcross: position > change.oldStart && position < change.oldEnd
+			};
+		}
+		const previous = low === 0 ? void 0 : changes.at(low - 1);
+		return {
+			pos: position + (previous ? previous.newEnd - previous.oldEnd : 0),
+			deletedAcross: false
+		};
+	};
+	return Object.assign((position, assoc) => mapResult(position, assoc).pos, { mapResult });
+};
+//#endregion
+export { indexedPositionMap };

package/dist/internal/pageBreakRunSourceDescendantIndex.js

@@ -95,7 +95,8 @@ const buildPageBreakRunSourceDescendantIndex = (rootContent) => {
 		switch (block.type) {
 			case "paragraph": return inspectMany(block.content, inspectParagraphContent);
 			case "table": return inspectMany(block.rows, inspectTableRow);
-			case "blockSdt": return inspectBlocks(block.content);
+			case "blockSdt":
+			case "blockCustomXml": return inspectBlocks(block.content);
 			case "preservedBlock":
 			case "bookmarkStart":
 			case "bookmarkEnd": return 0;

package/dist/internal/revisionResolutionEdits.d.ts

@@ -0,0 +1,13 @@
+import { Node } from "prosemirror-model";
+import { Step } from "prosemirror-transform";
+//#region src/internal/revisionResolutionEdits.d.ts
+type RecordNodeResolutionOptions = {
+  before: Node;
+  after: Node;
+  position: number;
+  steps: Step[];
+};
+/** Record only carrier edits; content replacements are recorded by their owning walk. */
+declare const recordNodeResolution: ({ before, after, position, steps }: RecordNodeResolutionOptions) => void;
+//#endregion
+export { recordNodeResolution };

package/dist/internal/revisionResolutionEdits.js

@@ -0,0 +1,19 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep } from "prosemirror-transform";
+//#region src/internal/revisionResolutionEdits.ts
+/** Record only carrier edits; content replacements are recorded by their owning walk. */
+const recordNodeResolution = ({ before, after, position, steps }) => {
+	if (before === after) return;
+	if (!before.isText) {
+		for (const name of Object.keys(after.attrs)) if (before.attrs[name] !== after.attrs[name]) steps.push(new AttrStep(position, name, after.attrs[name]));
+	}
+	for (const mark of before.marks) {
+		if (mark.isInSet(after.marks)) continue;
+		steps.push(before.isText ? new RemoveMarkStep(position, position + before.nodeSize, mark) : new RemoveNodeMarkStep(position, mark));
+	}
+	for (const mark of after.marks) {
+		if (mark.isInSet(before.marks)) continue;
+		steps.push(before.isText ? new AddMarkStep(position, position + before.nodeSize, mark) : new AddNodeMarkStep(position, mark));
+	}
+};
+//#endregion
+export { recordNodeResolution };

package/dist/internal/revisionResolutionInline.d.ts

@@ -0,0 +1,24 @@
+import { RunStyleResolver } from "../prosemirror/runStyleFormatting.js";
+import { MarkType, Node } from "prosemirror-model";
+import { Step, StepMap } from "prosemirror-transform";
+//#region src/internal/revisionResolutionInline.d.ts
+type RevisionResolutionMode = "accept" | "reject";
+type RevisionRange = {
+  from: number;
+  to: number;
+};
+type ResolveInlineRevisionsOptions = {
+  doc: Node;
+  mode: RevisionResolutionMode;
+  keepType: MarkType | undefined;
+  removeType: MarkType | undefined;
+  styleResolver: RunStyleResolver | null;
+};
+declare const resolveInlineRevisions: ({ doc, mode, keepType, removeType, styleResolver }: ResolveInlineRevisionsOptions) => {
+  resolved: Node;
+  positionMap: StepMap;
+  ranges: RevisionRange[];
+  steps: Step[];
+} | null;
+//#endregion
+export { RevisionResolutionMode, resolveInlineRevisions };

package/dist/internal/{headlessRevisionResolution.js → revisionResolutionInline.js}

@@ -1,15 +1,17 @@
 import { recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
-import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectFieldAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "../prosemirror/attrs/index.js";
 import { resolutionRemovesControl, withoutResolvedEnclosures } from "../prosemirror/contentControlRevisions.js";
+import { resolveEmptyFieldResultRuns } from "../prosemirror/emptyFieldResultRuns.js";
 import "../prosemirror/extensions/nodes/SdtExtension.js";
 import { continuedRunMarks } from "../prosemirror/rejoinRunCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../prosemirror/runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../prosemirror/runPropertyChangeResolution.js";
 import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
+import { recordNodeResolution } from "./revisionResolutionEdits.js";
 import { panic } from "better-result";
 import { Fragment, Slice } from "prosemirror-model";
 import { ReplaceStep, StepMap } from "prosemirror-transform";
-//#region src/internal/headlessRevisionResolution.ts
+//#region src/internal/revisionResolutionInline.ts
 const EMPTY_PARAGRAPH_RUN_STYLE_CONTEXT = {
 	baseParagraphFormatting: void 0,
 	paragraphFormatting: void 0,
@@ -21,30 +23,6 @@ const resolveParagraphRunStyleScope = (scope, styleResolver) => {
 	scope.resolved ??= paragraphRunStyleContext(scope.paragraph, styleResolver);
 	return scope.resolved;
 };
-/**
-* A synchronous headless replacement with the granular position map of the
-* inline deletions it applies. It must never enter history or collaboration;
-* map and serialization fail loudly if that invariant is broken.
-*/
-var HeadlessInlineResolutionStep = class HeadlessInlineResolutionStep extends ReplaceStep {
-	positionMap;
-	constructor(from, to, slice, positionMap) {
-		super(from, to, slice);
-		this.positionMap = positionMap;
-	}
-	getMap() {
-		return this.positionMap;
-	}
-	invert(doc) {
-		return new HeadlessInlineResolutionStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to), this.positionMap.invert());
-	}
-	map(_mapping) {
-		return panic("A headless revision-resolution step cannot be mapped");
-	}
-	toJSON() {
-		return panic("A headless revision-resolution step cannot be serialized");
-	}
-};
 const marksEqual = (left, right) => left.length === right.length && left.every((mark, index) => {
 	const candidate = right[index];
 	return candidate !== void 0 && mark.eq(candidate);
@@ -56,14 +34,25 @@ const rebuildNode = (source, attrs, content, marks = source.marks) => recreatePr
 });
 const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	let marks = node.marks;
+	let attrs = node.attrs;
 	const runPropertyChangeMark = marks.find((mark) => mark.type.name === "runPropertyChange");
 	if (runPropertyChangeMark) {
 		const { changes } = expectRunPropertyChangeMarkAttrs(runPropertyChangeMark);
 		if (changes.length > 0) {
 			marks = marks.filter((mark) => mark !== runPropertyChangeMark);
-			if (context.mode === "reject") {
+			const emptyRuns = node.type.name === "field" || node.type.name === "structuredField" ? expectFieldAttrs(node)._docxEmptyResultRuns : void 0;
+			const resolvedRuns = emptyRuns ? resolveEmptyFieldResultRuns({
+				runs: emptyRuns,
+				mode: context.mode,
+				revisionIds: null
+			}) : null;
+			if (resolvedRuns) attrs = {
+				...attrs,
+				_docxEmptyResultRuns: resolvedRuns.runs
+			};
+			if (context.mode === "reject" && (!resolvedRuns || resolvedRuns.visibleFormattingChanged)) {
 				marks = marks.filter((mark) => !RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
-				const previousFormatting = changes.at(0)?.previousFormatting;
+				const previousFormatting = resolvedRuns ? resolvedRuns.visibleFormatting : changes.at(0)?.previousFormatting;
 				for (const previousMark of reconstructRejectedRunFormattingMarks({
 					node,
 					paragraphContext: resolveParagraphRunStyleScope(paragraphScope, context.styleResolver),
@@ -73,16 +62,17 @@ const resolveInlineNode = ({ node, context, paragraphScope }) => {
 			}
 		}
 	}
-	if (context.removeType && node.marks.some((mark) => mark.type === context.removeType)) return null;
+	if (node.marks.some((mark) => (mark.type.name === "insertion" || mark.type.name === "deletion") && expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => context.mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo")) || context.removeType && node.marks.some((mark) => mark.type === context.removeType)) return null;
 	if (context.keepType) marks = marks.filter((mark) => mark.type !== context.keepType);
+	if (attrs !== node.attrs) return rebuildNode(node, attrs, node.content, marks);
 	return marksEqual(marks, node.marks) ? node : node.mark(marks);
 };
 /**
-* The pieces a revision split off its run, one run again: the headless half of
+* The pieces a revision split off its run, one run again: the tree-walk counterpart of
 * `rejoinRunsAt`, over the children of one inline container.
 */
-const rejoinResolvedRuns = ({ children, resolvedBoundaries, paragraphScope, context }) => {
-	for (const index of [...resolvedBoundaries].toSorted((left, right) => left - right)) {
+const rejoinResolvedRuns = ({ children, positions, resolvedBoundaries, paragraphScope, context }) => {
+	for (const index of resolvedBoundaries) {
 		const left = children[index - 1];
 		const right = children[index];
 		if (!left || !right) continue;
@@ -92,7 +82,16 @@ const rejoinResolvedRuns = ({ children, resolvedBoundaries, paragraphScope, cont
 			context: () => resolveParagraphRunStyleScope(paragraphScope, context.styleResolver),
 			styleResolver: context.styleResolver
 		});
-		if (marks !== null) children[index] = right.mark(marks);
+		if (marks !== null) {
+			const joined = right.mark(marks);
+			recordNodeResolution({
+				before: right,
+				after: joined,
+				position: positions[index] ?? 0,
+				steps: context.steps
+			});
+			children[index] = joined;
+		}
 	}
 };
 const resolveInlineContent = ({ node, position, context, inheritedParagraphScope }) => {
@@ -114,6 +113,12 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 			return null;
 		}
 		resolvedNode = resolved;
+		recordNodeResolution({
+			before: node,
+			after: resolvedNode,
+			position,
+			steps: context.steps
+		});
 		if (resolvedNode.isLeaf) return resolvedNode;
 	}
 	if (resolutionRemovesControl({
@@ -129,6 +134,7 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		return null;
 	}
 	const children = [];
+	const positions = [];
 	/** Indices into `children` where resolved content began or ended. */
 	const resolvedBoundaries = /* @__PURE__ */ new Set();
 	const contentStart = resolvedNode.type.name === "doc" ? 0 : position + 1;
@@ -146,13 +152,21 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		}
 		if (resolved) {
 			children.push(resolved);
+			positions.push(contentStart + offset);
 			if (resolved !== child) resolvedBoundaries.add(children.length);
 		}
 	});
 	const resolvedAttrs = resolvedNode.type.name === "sdt" ? withoutResolvedEnclosures(resolvedNode, () => true) ?? resolvedNode.attrs : resolvedNode.attrs;
+	if (resolvedAttrs !== resolvedNode.attrs) recordNodeResolution({
+		before: resolvedNode,
+		after: rebuildNode(resolvedNode, resolvedAttrs, resolvedNode.content),
+		position,
+		steps: context.steps
+	});
 	if (!contentChanged && resolvedAttrs === resolvedNode.attrs) return resolvedNode;
 	if (contentChanged && resolvedNode.inlineContent) rejoinResolvedRuns({
 		children,
+		positions,
 		resolvedBoundaries,
 		paragraphScope,
 		context
@@ -161,7 +175,7 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 	if (!resolvedNode.type.validContent(resolvedContent)) {
 		const fitted = resolvedNode.type.createAndFill(resolvedNode.attrs, resolvedContent, resolvedNode.marks);
 		if (!fitted || !resolvedNode.type.validContent(fitted.content)) {
-			if (!resolvedNode.isInline) return panic(`Headless inline resolution invalidated ${resolvedNode.type.name} content`);
+			if (!resolvedNode.isInline) return panic(`Revision inline resolution invalidated ${resolvedNode.type.name} content`);
 			context.replacementRanges.splice(replacementRangeStart, context.replacementRanges.length - replacementRangeStart, {
 				from: position,
 				to: position + node.nodeSize,
@@ -172,7 +186,8 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		context.replacementRanges.splice(replacementRangeStart, context.replacementRanges.length - replacementRangeStart, {
 			from: contentStart,
 			to: contentStart + node.content.size,
-			newSize: fitted.content.size
+			newSize: fitted.content.size,
+			slice: new Slice(fitted.content, 0, 0)
 		});
 		resolvedContent = fitted.content;
 	}
@@ -191,32 +206,35 @@ const coalesceReplacementRanges = (replacementRanges) => {
 	}
 	return coalesced;
 };
-const appendHeadlessInlineResolution = ({ tr, mode, keepType, removeType, styleResolver }) => {
+const resolveInlineRevisions = ({ doc, mode, keepType, removeType, styleResolver }) => {
 	const context = {
 		mode,
 		keepType,
 		removeType,
 		replacementRanges: [],
+		steps: [],
 		changedParagraphRanges: [],
 		styleResolver
 	};
 	const resolved = resolveInlineContent({
-		node: tr.doc,
+		node: doc,
 		position: -1,
 		context
 	});
-	if (!resolved || resolved.eq(tr.doc)) return null;
-	const positionMap = new StepMap(coalesceReplacementRanges(context.replacementRanges).flatMap(({ from, to, newSize }) => [
+	if (!resolved || resolved.eq(doc)) return null;
+	const replacementRanges = coalesceReplacementRanges(context.replacementRanges);
+	const positionMap = new StepMap(replacementRanges.flatMap(({ from, to, newSize }) => [
 		from,
 		to - from,
 		newSize
 	]));
-	const mappingFrom = tr.steps.length;
-	tr.step(new HeadlessInlineResolutionStep(0, tr.doc.content.size, new Slice(resolved.content, 0, 0), positionMap));
+	for (const { from, to, slice } of replacementRanges.toReversed()) context.steps.push(new ReplaceStep(from, to, slice ?? Slice.empty));
 	return {
+		resolved,
+		positionMap,
 		ranges: context.changedParagraphRanges,
-		mappingFrom
+		steps: context.steps
 	};
 };
 //#endregion
-export { appendHeadlessInlineResolution };
+export { resolveInlineRevisions };

package/dist/internal/revisionResolutionStep.d.ts

@@ -0,0 +1,34 @@
+import { Node, Schema } from "prosemirror-model";
+import { Mappable, Step, StepMap, StepResult } from "prosemirror-transform";
+//#region src/internal/revisionResolutionStep.d.ts
+type DeferredInverse = {
+  doc: Node;
+  steps: readonly Step[];
+};
+type RevisionResolutionStepOptions = {
+  beforeDoc: Node | null;
+  afterDoc: Node | null;
+  steps: readonly Step[];
+  positionMap: StepMap;
+  deferredInverse?: DeferredInverse;
+};
+/** Compose by retaining precisely the source positions that survive both maps. */
+declare const composeRevisionResolutionMaps: (first: StepMap, second: StepMap) => StepMap;
+/** One transaction step for a bulk resolution, with a granular position map. */
+declare class RevisionResolutionStep extends Step {
+  private materializedSteps;
+  private readonly beforeDoc;
+  private readonly afterDoc;
+  private readonly positionMap;
+  private readonly deferredInverse;
+  constructor({ beforeDoc, afterDoc, steps, positionMap, deferredInverse }: RevisionResolutionStepOptions);
+  private steps;
+  apply(doc: Node): StepResult;
+  getMap(): StepMap;
+  invert(doc: Node): RevisionResolutionStep;
+  map(mapping: Mappable): RevisionResolutionStep | null;
+  toJSON(): unknown;
+  static fromJSON(schema: Schema, json: unknown): RevisionResolutionStep;
+}
+//#endregion
+export { RevisionResolutionStep, composeRevisionResolutionMaps };