@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/commands/comments.js

@@ -1,29 +1,36 @@
 import { sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
-import { joinProseParagraphsWithRightPropertySource } from "../../docx/paragraphPropertySource.js";
-import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionResolution.js";
-import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
-import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
+import { getProseParagraphPropertySourceToken, markParagraphPropertySourceTransfers } from "../../docx/paragraphPropertySource.js";
+import { RevisionResolutionStep } from "../../internal/revisionResolutionStep.js";
+import { finalRevisionParagraphRanges } from "../../internal/revisionResolutionTracking.js";
+import { deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, moveTextBoxesPastNextParagraph } from "../anchoredTextBoxes.js";
+import { expectFieldAttrs, expectParagraphAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { enclosingRevisionIds, resolutionRemovesControl, withoutResolvedEnclosures } from "../contentControlRevisions.js";
-import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
+import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
+import { resolveStateStory } from "../markupViewProjection.js";
+import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
+import { getDocumentNumbering } from "../plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
 import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
-import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords } from "../revisionCarriers.js";
+import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
-import { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
+import { reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
+import { resolveNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
+import { resolveParagraphChangeAttrs } from "./resolveParagraphProperties.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { panic } from "better-result";
 import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
-import { TableMap, removeRow } from "prosemirror-tables";
+import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.ts
 /**
@@ -74,17 +81,6 @@ const revisionLayerOf = (mark) => {
 	};
 };
 const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
-const containsNestedRevision = (doc) => {
-	let found = false;
-	doc.descendants((node) => {
-		if (found) return false;
-		for (const mark of node.marks) if ((mark.type.name === "insertion" || mark.type.name === "deletion") && (expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.length ?? 0) > 0) {
-			found = true;
-			return false;
-		}
-	});
-	return found;
-};
 /**
 * Resolve a tracked change: accept or reject.
 * - Accept: keep insertions (remove mark), delete deletions (remove text)
@@ -97,16 +93,16 @@ const containsNestedRevision = (doc) => {
 * the operation matches every revision mark or property-change entry in the
 * range (the bulk accept-all/reject-all path).
 */
-function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
+function resolveChange(from, to, mode, revisionIds) {
 	return (state, dispatch) => {
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
 		const styleResolver = getDocumentStyleResolver(state);
+		const numbering = getDocumentNumbering(state);
 		const keepType = mode === "accept" ? insertionType : deletionType;
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
 		const removeKeptMarksInBulk = revisionSet === null && keepType !== void 0;
-		const canBulkInlineResolution = execution === "headless-bulk-inline" && revisionSet === null && from === 0 && to === state.doc.content.size && stateAllowsHeadlessRevisionResolution(state) && !containsNestedRevision(state.doc);
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
@@ -122,51 +118,14 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				if (node.type.name === "paragraph") {
 					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
 					if (op) pPrMarkOps.push(op);
-					const boundaryCovered = rangeCoversParagraphBoundary(from, to, pos, node);
-					let nextAttrs = null;
-					const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
-					if (Array.isArray(propertyChanges) && propertyChanges.length > 0 && boundaryCovered) {
-						const matchesPropertyChange = (change) => revisionSet === null || revisionSet.has(change.info.id);
-						if (propertyChanges.some(matchesPropertyChange)) {
-							const rejection = mode === "reject" ? removeParagraphPropertyChanges(propertyChanges, matchesPropertyChange) : null;
-							let remaining;
-							if (rejection === null) remaining = propertyChanges.filter((change) => !matchesPropertyChange(change));
-							else if (rejection.type === "unchanged") remaining = propertyChanges;
-							else remaining = rejection.remaining;
-							nextAttrs = {
-								...node.attrs,
-								_propertyChanges: remaining.length > 0 ? remaining : null
-							};
-							if (rejection?.type === "restore-previous") {
-								const inheritedAlignment = expectParagraphAttrs(node).alignmentFromStyle;
-								let previousFormattingFromStyle;
-								if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting;
-								else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
-								Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousFormattingFromStyle));
-								const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
-								nextAttrs["_originalFormatting"] = restoredFormatting;
-								if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;
-							}
-						}
-					}
-					const sectionProperties = node.attrs["_sectionProperties"];
-					const sectionChanges = sectionProperties?.propertyChanges;
-					if (sectionProperties && Array.isArray(sectionChanges) && sectionChanges.length > 0 && boundaryCovered) {
-						const matches = sectionChanges.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
-						if (matches.length > 0) {
-							const remaining = sectionChanges.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
-							let restored = { ...sectionProperties };
-							if (mode === "reject") for (const change of matches.toReversed()) restored = sectionRejectProperties({
-								live: restored,
-								previousProperties: change.previousProperties,
-								previousReferences: change.previousReferences
-							});
-							delete restored.propertyChanges;
-							if (remaining.length > 0) restored.propertyChanges = remaining;
-							nextAttrs = nextAttrs ?? { ...node.attrs };
-							nextAttrs["_sectionProperties"] = restored;
-						}
-					}
+					const nextAttrs = resolveParagraphChangeAttrs({
+						node,
+						boundaryCovered: rangeCoversParagraphBoundary(from, to, pos, node),
+						mode,
+						revisionSet,
+						styleResolver,
+						numbering
+					});
 					if (nextAttrs) if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
 						nextAttrs,
 						paragraphPosition: pos,
@@ -189,7 +148,12 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				const nodeAttrSites = nodePropertyRevisionSites(node.type.name).filter((site) => site.resolution === "node-attrs");
 				if (nodeAttrSites.length > 0) {
 					if (rangeCoversNode(from, to, pos, node)) for (const site of nodeAttrSites) {
-						const nextAttrs = resolveNodePropertyChangeAttrs(tr.doc.nodeAt(pos) ?? node, site, mode, revisionSet);
+						const nextAttrs = resolveNodePropertyChangeAttrs({
+							node: tr.doc.nodeAt(pos) ?? node,
+							site,
+							mode,
+							revisionSet
+						});
 						if (nextAttrs) {
 							tr.setNodeMarkup(pos, void 0, nextAttrs);
 							markStructuralChange(tr);
@@ -198,7 +162,6 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 					return true;
 				}
 				if (!node.isInline) return true;
-				if (canBulkInlineResolution) return true;
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
@@ -272,82 +235,25 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				}
 				return true;
 			});
-			let bulkInlineChangeTracking = null;
-			if (canBulkInlineResolution) bulkInlineChangeTracking = appendHeadlessInlineResolution({
-				tr,
-				mode,
-				keepType,
-				removeType,
-				styleResolver
-			});
-			else {
-				if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
-				let rangesToDelete = deleteRanges;
-				if (revisionSet === null) {
-					const coalescedDeleteRanges = [];
-					for (const range of deleteRanges) {
-						const previous = coalescedDeleteRanges.at(-1);
-						if (previous && range.from <= previous.to) {
-							previous.to = Math.max(previous.to, range.to);
-							continue;
-						}
-						coalescedDeleteRanges.push({
-							from: range.from,
-							to: range.to
-						});
-					}
-					rangesToDelete = coalescedDeleteRanges;
-				}
-				for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
-			}
-			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
-			for (const op of pPrMarkOps) {
-				const mappedPos = tr.mapping.map(op.paragraphPos);
-				const paragraph = tr.doc.nodeAt(mappedPos);
-				if (!paragraph || paragraph.type.name !== "paragraph") continue;
-				if (op.action === "clear") {
-					tr.setNodeAttribute(mappedPos, "pPrMark", null);
-					continue;
-				}
-				const joinPos = mappedPos + paragraph.nodeSize;
-				const nextNode = joinPos < tr.doc.content.size ? tr.doc.nodeAt(joinPos) : null;
-				if (!(nextNode?.type.name === paragraph.type.name)) {
-					const resolved = tr.doc.resolve(mappedPos);
-					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
-					const canGo = op.markWasAdded || !endsItsContainer;
-					if (holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
-						if (ownsSectionEndpoint(paragraph)) {
-							removedSectionEndpointCount++;
-							removedSectionReferences.push(...sectionReferencesOf(paragraph));
-						}
-						tr.delete(mappedPos, mappedPos + paragraph.nodeSize);
+			if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
+			let rangesToDelete = deleteRanges;
+			if (revisionSet === null) {
+				const coalescedDeleteRanges = [];
+				for (const range of deleteRanges) {
+					const previous = coalescedDeleteRanges.at(-1);
+					if (previous && range.from <= previous.to) {
+						previous.to = Math.max(previous.to, range.to);
 						continue;
 					}
-					tr.setNodeAttribute(mappedPos, "pPrMark", null);
-					continue;
-				}
-				const emptyFirstParagraph = holdsNoContent(paragraph);
-				const joinedAttrs = {
-					...(emptyFirstParagraph ? nextNode : paragraph).attrs,
-					pPrMark: nextNode.attrs["pPrMark"],
-					_sectionProperties: nextNode.attrs["_sectionProperties"]
-				};
-				try {
-					if (emptyFirstParagraph) joinProseParagraphsWithRightPropertySource({
-						attrs: joinedAttrs,
-						pos: joinPos,
-						transaction: tr
+					coalescedDeleteRanges.push({
+						from: range.from,
+						to: range.to
 					});
-					else {
-						tr.join(joinPos);
-						tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
-					}
-					if (ownsSectionEndpoint(paragraph)) {
-						removedSectionEndpointCount++;
-						removedSectionReferences.push(...sectionReferencesOf(paragraph));
-					}
-				} catch {}
+				}
+				rangesToDelete = coalescedDeleteRanges;
 			}
+			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
+			if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(state.doc, tr.doc))) markStructuralChange(tr);
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
 			let resolvedTableRowStructure = false;
 			for (const op of tableRowStructuralOps) {
@@ -372,6 +278,7 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 			tableCellStructuralOps.sort((left, right) => right.cellPos - left.cellPos);
 			let resolvedTableCellStructure = false;
 			let failedTableCellMergeResolution = false;
+			const emptiedTables = [];
 			for (const op of tableCellStructuralOps) {
 				const mappedPos = tr.mapping.map(op.cellPos);
 				const cell = tr.doc.nodeAt(mappedPos);
@@ -390,12 +297,81 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 					resolvedTableCellStructure = true;
 					continue;
 				}
-				deleteTableCellAt(tr, mappedPos);
+				deleteTableCellAt(tr, mappedPos, emptiedTables);
 				resolvedTableCellStructure = true;
 			}
 			if (failedTableCellMergeResolution) return false;
+			for (const { position, mapFrom } of emptiedTables) removeRowsWithoutCells(tr, tr.mapping.slice(mapFrom).map(position));
 			if (resolvedTableCellStructure) markStructuralChange(tr);
-			if (bulkInlineChangeTracking) markChangedParagraphRanges(tr, bulkInlineChangeTracking);
+			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
+			for (const op of pPrMarkOps) {
+				const mappedPos = tr.mapping.map(op.paragraphPos);
+				const paragraph = tr.doc.nodeAt(mappedPos);
+				if (!paragraph || paragraph.type.name !== "paragraph") continue;
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+					continue;
+				}
+				if (moveTextBoxesPastNextParagraph(tr, mappedPos)) markStructuralChange(tr);
+				const joinPos = mappedPos + paragraph.nodeSize;
+				let nextPos = joinPos;
+				const boundaries = [];
+				while (nextPos < tr.doc.content.size) {
+					const boundary = tr.doc.nodeAt(nextPos);
+					if (boundary?.type.name !== "blockBookmarkBoundary") break;
+					boundaries.push(boundary);
+					nextPos += boundary.nodeSize;
+				}
+				const nextNode = nextPos < tr.doc.content.size ? tr.doc.nodeAt(nextPos) : null;
+				if (!(nextNode?.type.name === paragraph.type.name)) {
+					const resolved = tr.doc.resolve(mappedPos);
+					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
+					const canGo = op.markWasAdded || !endsItsContainer;
+					if (holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
+						if (ownsSectionEndpoint(paragraph)) {
+							removedSectionEndpointCount++;
+							removedSectionReferences.push(...sectionReferencesOf(paragraph));
+						}
+						tr.delete(mappedPos, mappedPos + paragraph.nodeSize);
+						continue;
+					}
+					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+					continue;
+				}
+				try {
+					if (boundaries.length > 0) {
+						const emptyFirstParagraph = holdsNoContent(paragraph);
+						const joinedAttrs = {
+							...(emptyFirstParagraph ? nextNode : paragraph).attrs,
+							pPrMark: nextNode.attrs["pPrMark"],
+							_sectionProperties: nextNode.attrs["_sectionProperties"]
+						};
+						const leftToken = getProseParagraphPropertySourceToken(paragraph);
+						const rightToken = getProseParagraphPropertySourceToken(nextNode);
+						const inlineBookmarks = inlineBookmarksForParagraphJoin({
+							first: paragraph,
+							boundaries,
+							second: nextNode
+						});
+						if (!inlineBookmarks) continue;
+						tr.replaceWith(joinPos - 1, nextPos + 1, inlineBookmarks);
+						tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
+						if (emptyFirstParagraph) markParagraphPropertySourceTransfers(tr, [{
+							displacedToken: typeof leftToken === "string" ? leftToken : null,
+							selectedToken: typeof rightToken === "string" ? rightToken : null
+						}]);
+					} else joinAtParagraphMark({
+						tr,
+						paragraphPos: mappedPos,
+						paragraph,
+						next: nextNode
+					});
+					if (ownsSectionEndpoint(paragraph)) {
+						removedSectionEndpointCount++;
+						removedSectionReferences.push(...sectionReferencesOf(paragraph));
+					}
+				} catch {}
+			}
 			if (removedSectionEndpointCount > 0) markTrackedSectionEndpointRemoval(tr, {
 				sourceDoc: state.doc,
 				removedEndpointCount: removedSectionEndpointCount,
@@ -452,6 +428,35 @@ const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet,
 	tr.removeMark(from, to, mark);
 	const remaining = changes.filter((change) => revisionSet !== null && !revisionSet.has(change.info.id));
 	if (remaining.length > 0) tr.addMark(from, to, mark.type.create({ changes: remaining }));
+	const emptyRuns = node.type.name === "field" || node.type.name === "structuredField" ? expectFieldAttrs(node)._docxEmptyResultRuns : void 0;
+	const resolvedRuns = emptyRuns ? resolveEmptyFieldResultRuns({
+		runs: emptyRuns,
+		mode,
+		revisionIds: revisionSet
+	}) : null;
+	if (resolvedRuns) {
+		const current = tr.doc.nodeAt(from);
+		if (!current) panic("A resolved field has no node at its position");
+		tr.setNodeMarkup(from, void 0, {
+			...current.attrs,
+			_docxEmptyResultRuns: resolvedRuns.runs
+		});
+		if (resolvedRuns.visibleFormattingChanged) {
+			const styleContext = paragraphRunStyleContextAt({
+				doc: tr.doc,
+				pos: from,
+				styleResolver
+			});
+			for (const currentMark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(currentMark.type.name)) tr.removeMark(from, to, currentMark.type);
+			for (const nextMark of reconstructRejectedRunFormattingMarks({
+				node,
+				paragraphContext: styleContext,
+				previousFormatting: resolvedRuns.visibleFormatting,
+				styleResolver
+			})) tr.addMark(from, to, nextMark);
+		}
+		return;
+	}
 	if (mode === "accept") return;
 	const previousFormatting = matches.at(0)?.previousFormatting;
 	const styleContext = paragraphRunStyleContextAt({
@@ -554,7 +559,7 @@ function isTableCellRevisionAttr(value) {
 	const info = value.info;
 	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
 }
-function deleteTableCellAt(tr, cellPos) {
+function deleteTableCellAt(tr, cellPos, emptied) {
 	const cell = tr.doc.nodeAt(cellPos);
 	if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") return;
 	const resolved = tr.doc.resolve(cellPos);
@@ -566,7 +571,12 @@ function deleteTableCellAt(tr, cellPos) {
 	const tablePosition = resolved.before(tableDepth);
 	const cellOffset = cellPos - resolved.start(tableDepth);
 	const removedColumn = TableMap.get(table).findCell(cellOffset).left;
-	if (row.childCount > 1) {
+	const spansDown = Number(cell.attrs["rowspan"]) > 1;
+	if (row.childCount > 1 || spansDown) {
+		if (row.childCount === 1) emptied.push({
+			position: tablePosition,
+			mapFrom: tr.mapping.maps.length
+		});
 		tr.delete(cellPos, cellPos + cell.nodeSize);
 		reconcileTableGridAfterColumnRemoval({
 			tr,
@@ -594,15 +604,10 @@ function deleteTableRowAt(tr, rowPos) {
 	if (table.type.spec["tableRole"] !== "table") return;
 	const rowIndex = resolved.index();
 	if (table.childCount > 1) {
-		const map = TableMap.get(table);
-		removeRow(tr, {
-			map,
+		removeTableRow(tr, {
+			map: TableMap.get(table),
 			table,
-			tableStart: resolved.start(),
-			left: 0,
-			top: rowIndex,
-			right: map.width,
-			bottom: rowIndex + 1
+			tableStart: resolved.start()
 		}, rowIndex);
 		return;
 	}
@@ -640,48 +645,6 @@ function rangeCoversParagraphBoundary(from, to, pos, node) {
 function rangeCoversNode(from, to, pos, node) {
 	return from <= pos && to >= pos + node.nodeSize;
 }
-/**
-* The attrs a reject restores for each property revision the shared node-attr
-* pass owns. Total over those kinds, so a revision the model gains either
-* declares a different resolution or states here what rejecting it restores.
-*
-* Each patch narrows the stored set to the property set its own element
-* carries. The casts are the ProseMirror attrs boundary: attrs are untyped,
-* and a record reached through the site filed under a kind is the one that
-* kind's parser and converter wrote.
-*/
-const NODE_ATTRS_REJECT_PATCHES = {
-	tablePropertyChange: (previousFormatting) => tableRejectAttrPatch(previousFormatting),
-	tablePropertyExceptionChange: (previousFormatting) => tablePropertyExceptionsRejectAttrPatch(previousFormatting),
-	tableRowPropertyChange: (previousFormatting) => tableRowRejectAttrPatch(previousFormatting),
-	tableCellPropertyChange: (previousFormatting, node) => tableCellRejectAttrPatch(previousFormatting, node.attrs["_originalFormatting"])
-};
-/**
-* Resolve the tracked property-change records one site carries on a node.
-* Accept keeps the live formatting and clears the matched records; reject
-* additionally restores the stored previous formatting wholesale (the change
-* element stores the complete old property set — see propertyChangeScope.ts).
-* Returns the next attrs, or `null` when no record matches.
-*/
-function resolveNodePropertyChangeAttrs(node, site, mode, revisionSet) {
-	const changes = propertyRevisionRecords(node, site);
-	if (changes.length === 0) return null;
-	const matches = changes.filter((change) => {
-		const metadata = propertyRevisionMetadata(change.info);
-		return revisionSet === null || metadata !== null && revisionSet.has(metadata.id);
-	});
-	if (matches.length === 0) return null;
-	const remaining = revisionSet === null ? [] : changes.filter((change) => !matches.includes(change));
-	const nextAttrs = {
-		...node.attrs,
-		[site.attr]: remaining.length > 0 ? remaining : null
-	};
-	if (mode === "reject") {
-		const rejectPatch = NODE_ATTRS_REJECT_PATCHES[site.kind];
-		for (const change of matches.toReversed()) Object.assign(nextAttrs, rejectPatch(change.previousFormatting, node));
-	}
-	return nextAttrs;
-}
 function isPPrMarkAttr(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const kind = value.kind;
@@ -765,41 +728,68 @@ function acceptChange(from, to) {
 function rejectChange(from, to) {
 	return resolveChange(from, to, "reject");
 }
+const resolveAllChanges = (mode) => (state, dispatch) => {
+	if (!dispatch) return true;
+	const result = resolveStateStory(state, mode);
+	if (result.failed) return false;
+	if (result.resolved.eq(state.doc)) return true;
+	const tr = state.tr.step(new RevisionResolutionStep({
+		beforeDoc: state.doc,
+		afterDoc: result.resolved,
+		steps: result.steps,
+		positionMap: result.positionMap
+	}));
+	markChangedParagraphRanges(tr, {
+		ranges: finalRevisionParagraphRanges(result),
+		mappingFrom: tr.steps.length,
+		replacesStepMapAt: 0
+	});
+	markParagraphPropertySourceTransfers(tr, result.transfers);
+	if (result.structural) markStructuralChange(tr);
+	if (result.removedEndpointCount > 0) markTrackedSectionEndpointRemoval(tr, {
+		sourceDoc: state.doc,
+		removedEndpointCount: result.removedEndpointCount,
+		removedReferences: result.removedReferences
+	});
+	dispatch(tr);
+	return true;
+};
 /**
-* Accept all tracked changes in the document.
+* Accept all tracked changes in the document. Returns `false` while pending
+* suggestions are present because this command cannot restage them.
 */
 function acceptAllChanges() {
-	return (state, dispatch) => acceptChange(0, state.doc.content.size)(state, dispatch);
+	const resolve = resolveAllChanges("accept");
+	return (state, dispatch) => {
+		if (getSuggestions(state).length > 0) return false;
+		return resolve(state, dispatch);
+	};
 }
 /**
 * Reject all tracked changes in the document.
 */
 function rejectAllChanges() {
-	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
+	return resolveAllChanges("reject");
 }
 /**
 * Resolve a complete state synchronously for a headless reader or writer.
 *
-* @internal The replacement transaction is consumed here and never exposed:
-* it is deliberately not an editor command and must not be transported or
-* mapped through concurrent edits.
+* Uses the same single-step resolver as the interactive editor command.
 */
 function resolveAllChangesInHeadlessState(state, mode) {
 	let resolvedState = state;
-	resolveChange(0, state.doc.content.size, mode, void 0, "headless-bulk-inline")(state, (transaction) => {
+	resolveAllChanges(mode)(state, (transaction) => {
 		resolvedState = state.apply(transaction);
 	});
 	return resolvedState;
 }
 /**
-* Resolve through the editor command path when a caller must map a position in
-* the reviewed document back to the tracked source. The bulk resolver is
-* faster, but deliberately replaces inline content without retaining mapping.
+* Resolve a story and retain its position map for callers addressing the tracked source.
 */
 const resolveAllChangesInHeadlessStateWithMapping = (state, mode) => {
 	let resolvedState = state;
 	let mapping = new Mapping();
-	resolveChange(0, state.doc.content.size, mode)(state, (transaction) => {
+	resolveAllChanges(mode)(state, (transaction) => {
 		resolvedState = state.apply(transaction);
 		mapping = transaction.mapping;
 	});
@@ -933,6 +923,18 @@ const readSuggestedParagraphPropertyChange = (change) => {
 		revisionId: change.info.id
 	};
 };
+const readSuggestedParagraphMark = (node) => {
+	if (node.type.name !== "paragraph") return null;
+	const mark = node.attrs["pPrMark"];
+	if (!isPPrMarkAttr(mark)) return null;
+	const { info } = mark;
+	if (!("provenance" in info) || info.provenance !== "suggested" || !("suggestionId" in info) || typeof info.suggestionId !== "string") return null;
+	return {
+		suggestionId: info.suggestionId,
+		revisionId: info.id,
+		kind: paragraphMarkWasAdded(mark.kind) ? "insertion" : "deletion"
+	};
+};
 const readStructuralSuggestion = (node) => {
 	const attrs = node.attrs;
 	const name = node.type.name;
@@ -1006,6 +1008,16 @@ const collectSuggestions = (state) => {
 			entry.revisionIds.add(structural.revisionId);
 		}
 		if (node.type.name === "paragraph") {
+			const paragraphMark = readSuggestedParagraphMark(node);
+			if (paragraphMark) {
+				const entry = entryFor(paragraphMark.suggestionId);
+				entry.segments.push({
+					from: pos,
+					to: pos + node.nodeSize
+				});
+				entry.kinds.add(paragraphMark.kind);
+				entry.revisionIds.add(paragraphMark.revisionId);
+			}
 			const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 			if (Array.isArray(propertyChanges)) for (const change of propertyChanges) {
 				const suggested = readSuggestedParagraphPropertyChange(change);
@@ -1087,6 +1099,11 @@ function getSuggestions(state) {
 	});
 	return suggestions.toSorted((a, b) => (a.ranges[0]?.from ?? 0) - (b.ranges[0]?.from ?? 0));
 }
+/** The suggestion a revision belongs to, or `null` for an ordinary tracked change. */
+function suggestionIdOfRevision(state, revisionId) {
+	for (const [suggestionId, entry] of collectSuggestions(state)) if (entry.revisionIds.has(revisionId)) return suggestionId;
+	return null;
+}
 /**
 * The document range covering every mark belonging to `suggestionId`, plus the
 * revision ids those marks carry. Returns null when the suggestion is absent
@@ -1482,6 +1499,23 @@ const acceptSuggestions = (matchesSuggestion, options) => {
 				...nextAttrs ?? node.attrs,
 				_propertyChanges: propertyChanges
 			};
+			const paragraphMark = readSuggestedParagraphMark(node);
+			if (paragraphMark && matchesSuggestion(paragraphMark.suggestionId)) {
+				const mark = node.attrs["pPrMark"];
+				if (isPPrMarkAttr(mark)) nextAttrs = {
+					...nextAttrs ?? node.attrs,
+					pPrMark: {
+						...mark,
+						info: {
+							...mark.info,
+							author: options.author,
+							date,
+							provenance: "user",
+							suggestionId: null
+						}
+					}
+				};
+			}
 			if (nextAttrs) {
 				tr.setNodeMarkup(pos, void 0, nextAttrs);
 				changed = true;
@@ -1809,4 +1843,4 @@ function findPreviousChange(state, startPos) {
 	return result.value;
 }
 //#endregion
-export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };
+export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping, suggestionIdOfRevision };

package/dist/prosemirror/commands/contentControls.d.ts

@@ -2,8 +2,8 @@ import { document_d_exports } from "../../types/document.js";
 import { ContentControlFilter } from "../../content-controls/findContentControls.js";
 import { SetContentControlContentInput, SetContentControlValueInput } from "../../content-controls/mutateContentControls.js";
 import "../../content-controls/index.js";
-import { EditorState, Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, Transaction } from "prosemirror-state";
 //#region src/prosemirror/commands/contentControls.d.ts
 type ForceOption = {
   force?: boolean;

package/dist/prosemirror/commands/formatPainter.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../../types/document.js";
-import { Command, EditorState } from "prosemirror-state";
 import { Mark } from "prosemirror-model";
+import { Command, EditorState } from "prosemirror-state";
 //#region src/prosemirror/commands/formatPainter.d.ts
 /**
  * Character-formatting marks the painter copies. Structural marks — comments,

package/dist/prosemirror/commands/formatting.d.ts

@@ -3,8 +3,8 @@ import { TextColorAttrs } from "../schema/marks.js";
 import "../schema/index.js";
 import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive } from "../extensions/marks/markUtils.js";
 import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
-import { Command } from "prosemirror-state";
 import { Mark } from "prosemirror-model";
+import { Command } from "prosemirror-state";
 //#region src/prosemirror/commands/formatting.d.ts
 /**
  * textFormattingToMarks — wraps markUtils version to use singleton schema