@stll/folio-core 0.35.0 → 0.36.0

package/dist/prosemirror/commands/comments.js

@@ -1,12 +1,13 @@
 import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
-import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
+import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { textFormattingToMarks } from "../conversion/toProseDoc.js";
 import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
 import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { TableMap, removeRow } from "prosemirror-tables";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
@@ -59,6 +60,7 @@ 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 keepType = mode === "accept" ? insertionType : deletionType;
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
@@ -78,16 +80,21 @@ function resolveChange(from, to, mode, revisionIds) {
 					let nextAttrs = null;
 					const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 					if (Array.isArray(propertyChanges) && propertyChanges.length > 0 && boundaryCovered) {
-						const matches = propertyChanges.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
-						if (matches.length > 0) {
-							const remaining = propertyChanges.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
+						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 (mode === "reject") for (const change of matches.toReversed()) {
-								Object.assign(nextAttrs, paragraphRejectAttrPatch(change.previousFormatting));
-								nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(change.previousFormatting, node.attrs["_originalFormatting"]);
+							if (rejection?.type === "restore-previous") {
+								const previousAlignmentFromStyle = styleResolver ? styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting?.alignment : expectParagraphAttrs(node).alignmentFromStyle;
+								Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousAlignmentFromStyle));
+								nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
 							}
 						}
 					}
@@ -480,6 +487,7 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
+const isAddedPPrMarkAttr = (value) => isPPrMarkAttr(value) && (value.kind === "ins" || value.kind === "moveTo");
 /**
 * Whether the paragraph's mark carries a section's properties.
 *
@@ -682,6 +690,13 @@ const readSuggestedMarker = (marker) => {
 		revisionId
 	};
 };
+const readSuggestedParagraphPropertyChange = (change) => {
+	if (change.info.provenance !== "suggested" || typeof change.info.suggestionId !== "string") return null;
+	return {
+		suggestionId: change.info.suggestionId,
+		revisionId: change.info.id
+	};
+};
 const readStructuralSuggestion = (node) => {
 	const attrs = node.attrs;
 	const name = node.type.name;
@@ -754,6 +769,20 @@ const collectSuggestions = (state) => {
 			entry.kinds.add(structural.kind);
 			entry.revisionIds.add(structural.revisionId);
 		}
+		if (node.type.name === "paragraph") {
+			const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+			if (Array.isArray(propertyChanges)) for (const change of propertyChanges) {
+				const suggested = readSuggestedParagraphPropertyChange(change);
+				if (!suggested) continue;
+				const entry = entryFor(suggested.suggestionId);
+				entry.segments.push({
+					from: pos,
+					to: pos + node.nodeSize
+				});
+				entry.kinds.add("formatting");
+				entry.revisionIds.add(suggested.revisionId);
+			}
+		}
 		if (!node.isInline) return;
 		for (const mark of node.marks) {
 			if (!isSuggestionMark(mark)) continue;
@@ -848,6 +877,22 @@ const normalizeAcceptDate = (date) => {
 	const parsed = new Date(date);
 	return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : parsed.toISOString();
 };
+const acceptedParagraphMark = (node, author, date) => {
+	if (node.type.name !== "paragraph") return null;
+	const marker = node.attrs["_suggestedInsert"];
+	if (typeof marker !== "object" || marker === null || !("revisionId" in marker)) return null;
+	if (typeof marker.revisionId !== "number") return null;
+	const initials = "initials" in marker ? marker.initials : void 0;
+	return {
+		kind: "ins",
+		info: {
+			id: marker.revisionId,
+			author,
+			date,
+			...typeof initials === "string" ? { initials } : {}
+		}
+	};
+};
 /**
 * The node-attr patch that converts a suggested block/table revision into a
 * normal (`"user"`) one authored by the accepting user. Returns `null` when the
@@ -868,23 +913,15 @@ const convertStructuralSuggestionAttrs = (node, author, date) => {
 	const name = node.type.name;
 	const insertMarker = attrs["_suggestedInsert"];
 	if ((name === "paragraph" || name === "table") && typeof insertMarker === "object" && insertMarker !== null) {
-		const marker = insertMarker;
 		if (name === "table") return {
 			...attrs,
 			_suggestedInsert: null
 		};
-		if (typeof marker.revisionId === "number") return {
+		const paragraphMark = acceptedParagraphMark(node, author, date);
+		if (paragraphMark) return {
 			...attrs,
 			_suggestedInsert: null,
-			pPrMark: {
-				kind: "ins",
-				info: {
-					id: marker.revisionId,
-					author,
-					date,
-					...typeof marker.initials === "string" ? { initials: marker.initials } : {}
-				}
-			}
+			pPrMark: attrs["pPrMark"] ?? paragraphMark
 		};
 	}
 	if (node.type.name === "tableRow") {
@@ -909,6 +946,247 @@ const convertStructuralSuggestionAttrs = (node, author, date) => {
 	}
 	return null;
 };
+const reauthorParagraphPropertySuggestions = ({ node, matchesSuggestion, author, date }) => {
+	if (node.type.name !== "paragraph") return null;
+	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+	if (!Array.isArray(propertyChanges)) return null;
+	let changed = false;
+	const next = propertyChanges.map((change) => {
+		const suggested = readSuggestedParagraphPropertyChange(change);
+		if (!suggested || !matchesSuggestion(suggested.suggestionId)) return change;
+		changed = true;
+		return Object.assign({}, change, { info: {
+			...change.info,
+			author,
+			date,
+			provenance: "user",
+			suggestionId: null
+		} });
+	});
+	return changed ? next : null;
+};
+const appendRotatedParagraphPropertyChange = ({ tr, currentPosition, previous, mark, fallbackAuthor }) => {
+	const current = tr.doc.nodeAt(currentPosition);
+	if (!current || current.type.name !== "paragraph") return false;
+	const author = typeof mark.info.author === "string" ? mark.info.author : fallbackAuthor;
+	if (author === void 0) return false;
+	const existing = expectParagraphAttrs(current)._propertyChanges;
+	tr.setNodeMarkup(currentPosition, void 0, {
+		...current.attrs,
+		_propertyChanges: [...Array.isArray(existing) ? existing : [], {
+			type: "paragraphPropertyChange",
+			info: {
+				id: mark.info.id,
+				author,
+				...typeof mark.info.date === "string" ? { date: mark.info.date } : {},
+				...typeof mark.info.initials === "string" ? { initials: mark.info.initials } : {}
+			},
+			previousFormatting: paragraphPropertiesSnapshot(previous)
+		}]
+	});
+	return true;
+};
+/**
+* Shift a final run of inserted paragraph marks one paragraph to the left.
+* The container-final paragraph stays markless, while every inserted
+* paragraph keeps a same-revision property snapshot that makes targeted
+* rejection restore the paragraph whose mark now carries its break.
+*/
+const rotateAddedFinalParagraphBreaks = ({ tr, shouldRotate, fallbackAuthor }) => {
+	const paragraphTypeName = tr.doc.type.schema.nodes["paragraph"]?.name ?? "paragraph";
+	const finals = finalParagraphsOf(tr.doc, paragraphTypeName).filter(({ node, position }) => shouldRotate(node, position));
+	for (const { position: finalPosition } of finals) {
+		const final = tr.doc.nodeAt(finalPosition);
+		const finalMark = final?.attrs["pPrMark"];
+		if (!final || !isAddedPPrMarkAttr(finalMark)) continue;
+		tr.setNodeAttribute(finalPosition, "pPrMark", null);
+		if (!shiftAddedParagraphBreakBefore({
+			tr,
+			paragraphPosition: finalPosition,
+			mark: finalMark,
+			...fallbackAuthor !== void 0 && { fallbackAuthor }
+		})) return false;
+	}
+	return true;
+};
+const rebaseRotatedParagraphPropertyChange = ({ tr, currentPosition, previous, revisionId }) => {
+	const current = tr.doc.nodeAt(currentPosition);
+	if (!current || current.type.name !== "paragraph") return false;
+	const existing = expectParagraphAttrs(current)._propertyChanges;
+	if (!Array.isArray(existing)) return false;
+	if (existing.filter(({ info }) => info.id === revisionId).length !== 1) return false;
+	tr.setNodeMarkup(currentPosition, void 0, {
+		...current.attrs,
+		_propertyChanges: existing.map((change) => change.info.id === revisionId ? Object.assign({}, change, { previousFormatting: paragraphPropertiesSnapshot(previous) }) : change)
+	});
+	return true;
+};
+/**
+* Rebase every property change in one rotated paragraph-break chain to the
+* formatting of its original, leftmost carrier. A later targeted suggestion
+* may extend an already-rotated chain, so normalizing only the newly shifted
+* prefix would leave the serialized history dependent on acceptance order.
+*/
+const rebaseAddedParagraphBreakChain = ({ tr, carrierPosition, previous }) => {
+	const carrier = tr.doc.nodeAt(carrierPosition);
+	if (!carrier || carrier.type.name !== "paragraph") return false;
+	const resolved = tr.doc.resolve(carrierPosition);
+	let current = carrier;
+	let nextPosition = carrierPosition + carrier.nodeSize;
+	for (let index = resolved.index() + 1; index < resolved.parent.childCount; index++) {
+		const currentMark = current.attrs["pPrMark"];
+		if (!isAddedPPrMarkAttr(currentMark)) return true;
+		const sibling = resolved.parent.child(index);
+		if (sibling.type.name !== carrier.type.name) {
+			if (sibling.type.spec["tableRole"] === "table") return false;
+			nextPosition += sibling.nodeSize;
+			continue;
+		}
+		if (!rebaseRotatedParagraphPropertyChange({
+			tr,
+			currentPosition: nextPosition,
+			previous,
+			revisionId: currentMark.info.id
+		})) return false;
+		const next = tr.doc.nodeAt(nextPosition);
+		if (!next || next.type.name !== carrier.type.name) return false;
+		current = next;
+		nextPosition += sibling.nodeSize;
+	}
+	return !isAddedPPrMarkAttr(current.attrs["pPrMark"]);
+};
+/**
+* Insert an added paragraph break immediately before `paragraphPosition`.
+* Existing added marks shift left as one chain until the first free carrier;
+* each shifted mark keeps a property snapshot on the paragraph to its right.
+*/
+const shiftAddedParagraphBreakBefore = ({ tr, paragraphPosition, mark, fallbackAuthor, firstPropertyChange = { type: "append" } }) => {
+	const paragraph = tr.doc.nodeAt(paragraphPosition);
+	if (!paragraph || paragraph.type.name !== "paragraph") return false;
+	const resolved = tr.doc.resolve(paragraphPosition);
+	const carrier = addedBreakCarrierBefore(resolved, paragraph.type.name);
+	if (!carrier) return false;
+	const path = [{
+		node: paragraph,
+		position: paragraphPosition
+	}];
+	let position = paragraphPosition;
+	for (let index = resolved.index() - 1; index >= 0; index--) {
+		const sibling = resolved.parent.child(index);
+		position -= sibling.nodeSize;
+		if (sibling.type.name !== paragraph.type.name) {
+			if (sibling.type.spec["tableRole"] === "table") break;
+			continue;
+		}
+		path.push({
+			node: sibling,
+			position
+		});
+		if (position === carrier.position) break;
+	}
+	if (path.at(-1)?.position !== carrier.position) return false;
+	const propertyChangeBaseline = carrier.node;
+	let carriedMark = mark;
+	for (let index = 1; index < path.length; index++) {
+		const current = path[index - 1];
+		const previous = path[index];
+		if (!current || !previous) return false;
+		const displacedMark = previous.node.attrs["pPrMark"];
+		tr.setNodeAttribute(previous.position, "pPrMark", carriedMark);
+		if (!(index === 1 && firstPropertyChange.type === "rebase" ? rebaseRotatedParagraphPropertyChange({
+			tr,
+			currentPosition: current.position,
+			previous: propertyChangeBaseline,
+			revisionId: firstPropertyChange.revisionId
+		}) : appendRotatedParagraphPropertyChange({
+			tr,
+			currentPosition: current.position,
+			previous: propertyChangeBaseline,
+			mark: carriedMark,
+			...fallbackAuthor !== void 0 && { fallbackAuthor }
+		}))) return false;
+		if (displacedMark == null) return rebaseAddedParagraphBreakChain({
+			tr,
+			carrierPosition: carrier.position,
+			previous: propertyChangeBaseline
+		});
+		if (!isAddedPPrMarkAttr(displacedMark)) return false;
+		carriedMark = displacedMark;
+	}
+	return false;
+};
+/**
+* Place an accepted paragraph's break when a following accepted insertion has
+* already rotated its own break onto that paragraph.
+*/
+const placeAcceptedParagraphBreakBefore = ({ tr, paragraphPosition, mark, fallbackAuthor }) => {
+	const paragraph = tr.doc.nodeAt(paragraphPosition);
+	const displaced = paragraph?.attrs["pPrMark"];
+	if (!paragraph || paragraph.type.name !== "paragraph" || !isPPrMarkAttr(displaced) || !paragraphMarkWasAdded(displaced.kind)) return false;
+	return shiftAddedParagraphBreakBefore({
+		tr,
+		paragraphPosition,
+		mark,
+		fallbackAuthor
+	});
+};
+/**
+* Remember non-final added breaks before suggested nodes are removed. If one
+* becomes final because of those removals, it must rotate with its own
+* revision rather than remain as an unresolvable final mark.
+*/
+const collectAddedBreakRotationCandidates = (doc) => {
+	const paragraphTypeName = doc.type.schema.nodes["paragraph"]?.name ?? "paragraph";
+	const finalPositions = new Set(finalParagraphsOf(doc, paragraphTypeName).map(({ position }) => position));
+	const candidates = [];
+	doc.descendants((node, position) => {
+		if (node.type.name !== paragraphTypeName || finalPositions.has(position)) return;
+		const mark = node.attrs["pPrMark"];
+		if (isPPrMarkAttr(mark) && paragraphMarkWasAdded(mark.kind)) candidates.push({
+			position,
+			revisionId: mark.info.id
+		});
+	});
+	return candidates;
+};
+const mappedRotationCandidatePredicate = ({ candidates, tr }) => {
+	const revisionIdsByPosition = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const mapped = tr.mapping.mapResult(candidate.position, 1);
+		if (mapped.deleted) continue;
+		const mappedPosition = mapped.pos;
+		const revisionIds = revisionIdsByPosition.get(mappedPosition) ?? /* @__PURE__ */ new Set();
+		revisionIds.add(candidate.revisionId);
+		revisionIdsByPosition.set(mappedPosition, revisionIds);
+	}
+	return (node, position) => {
+		const mark = node.attrs["pPrMark"];
+		return isPPrMarkAttr(mark) && paragraphMarkWasAdded(mark.kind) && revisionIdsByPosition.get(position)?.has(mark.info.id) === true;
+	};
+};
+/**
+* Remove suggested nodes without deleting a following accepted insertion's
+* paragraph break that has rotated onto one of them.
+*/
+const removeSuggestedInsertNodes = ({ tr, positions, resolvedRevisionIds }) => {
+	for (const position of positions.toSorted((left, right) => right - left)) {
+		const node = tr.doc.nodeAt(position);
+		if (!node) continue;
+		const mark = node.attrs["pPrMark"];
+		const followingBreak = node.type.name === "paragraph" && isAddedPPrMarkAttr(mark) && !resolvedRevisionIds.has(mark.info.id) ? mark : null;
+		tr.delete(position, position + node.nodeSize);
+		if (followingBreak && !shiftAddedParagraphBreakBefore({
+			tr,
+			paragraphPosition: position,
+			mark: followingBreak,
+			firstPropertyChange: {
+				type: "rebase",
+				revisionId: followingBreak.info.id
+			}
+		})) return false;
+	}
+	return true;
+};
 /**
 * Convert suggested marks AND block/table node revisions to normal (`"user"`)
 * tracked changes. `matchesSuggestion(id)` selects which suggestion to convert
@@ -921,16 +1199,37 @@ const acceptSuggestions = (matchesSuggestion, options) => {
 		const runPropertyChangeType = state.schema.marks["runPropertyChange"];
 		const date = normalizeAcceptDate(options.date);
 		const tr = state.tr;
+		const acceptedParagraphBreaks = [];
 		let changed = false;
 		state.doc.descendants((node, pos) => {
 			const structural = readStructuralSuggestion(node);
+			let nextAttrs = null;
 			if (structural && matchesSuggestion(structural.suggestionId)) {
-				const nextAttrs = convertStructuralSuggestionAttrs(node, options.author, date);
-				if (nextAttrs) {
-					tr.setNodeMarkup(pos, void 0, nextAttrs);
-					changed = true;
+				nextAttrs = convertStructuralSuggestionAttrs(node, options.author, date);
+				if (structural.kind === "insertBlock") {
+					const mark = acceptedParagraphMark(node, options.author, date);
+					if (!mark) return;
+					acceptedParagraphBreaks.push({
+						position: pos,
+						mark,
+						hadBreak: node.attrs["pPrMark"] != null
+					});
 				}
 			}
+			const propertyChanges = reauthorParagraphPropertySuggestions({
+				node,
+				matchesSuggestion,
+				author: options.author,
+				date
+			});
+			if (propertyChanges) nextAttrs = {
+				...nextAttrs ?? node.attrs,
+				_propertyChanges: propertyChanges
+			};
+			if (nextAttrs) {
+				tr.setNodeMarkup(pos, void 0, nextAttrs);
+				changed = true;
+			}
 			if (!node.isInline) return;
 			const from = pos;
 			const to = pos + node.nodeSize;
@@ -964,6 +1263,18 @@ const acceptSuggestions = (matchesSuggestion, options) => {
 				}));
 			}
 		});
+		for (const accepted of acceptedParagraphBreaks) if (accepted.hadBreak && !placeAcceptedParagraphBreakBefore({
+			tr,
+			paragraphPosition: accepted.position,
+			mark: accepted.mark,
+			fallbackAuthor: options.author
+		})) return false;
+		const directlyMarkedParagraphPositions = new Set(acceptedParagraphBreaks.filter(({ hadBreak }) => !hadBreak).map(({ position }) => position));
+		if (directlyMarkedParagraphPositions.size > 0 && !rotateAddedFinalParagraphBreaks({
+			tr,
+			shouldRotate: (_node, position) => directlyMarkedParagraphPositions.has(position),
+			fallbackAuthor: options.author
+		})) return false;
 		if (!changed) return false;
 		if (dispatch) dispatch(tr);
 		return true;
@@ -1001,6 +1312,7 @@ function rejectSuggestion(suggestionId) {
 	return (state, dispatch) => {
 		const entry = collectSuggestions(state).get(suggestionId);
 		if (!entry) return false;
+		const rotationCandidates = entry.kinds.has("insertBlock") || entry.kinds.has("insertTable") ? collectAddedBreakRotationCandidates(state.doc) : [];
 		let tr = null;
 		if (entry.revisionIds.size > 0) {
 			const ranges = mergeSegments(entry.segments);
@@ -1015,10 +1327,18 @@ function rejectSuggestion(suggestionId) {
 			const structural = readStructuralSuggestion(node);
 			if (structural?.isNodeInsert && structural.suggestionId === suggestionId) positions.push(pos);
 		});
-		for (const pos of positions.toSorted((a, b) => b - a)) {
-			const node = workingTr.doc.nodeAt(pos);
-			if (node) workingTr.delete(pos, pos + node.nodeSize);
-		}
+		if (!removeSuggestedInsertNodes({
+			tr: workingTr,
+			positions,
+			resolvedRevisionIds: entry.revisionIds
+		})) return false;
+		if (positions.length > 0 && rotationCandidates.length > 0 && !rotateAddedFinalParagraphBreaks({
+			tr: workingTr,
+			shouldRotate: mappedRotationCandidatePredicate({
+				candidates: rotationCandidates,
+				tr: workingTr
+			})
+		})) return false;
 		if (workingTr.steps.length === 0) return false;
 		if (dispatch) dispatch(workingTr);
 		return true;
@@ -1030,7 +1350,12 @@ function rejectAllSuggestions() {
 		const bySuggestion = collectSuggestions(state);
 		if (bySuggestion.size === 0) return false;
 		const revisionIds = /* @__PURE__ */ new Set();
-		for (const entry of bySuggestion.values()) for (const id of entry.revisionIds) revisionIds.add(id);
+		let removesWholeNode = false;
+		for (const entry of bySuggestion.values()) {
+			removesWholeNode ||= entry.kinds.has("insertBlock") || entry.kinds.has("insertTable");
+			for (const id of entry.revisionIds) revisionIds.add(id);
+		}
+		const rotationCandidates = removesWholeNode ? collectAddedBreakRotationCandidates(state.doc) : [];
 		let tr = null;
 		if (revisionIds.size > 0) resolveChange(0, state.doc.content.size, "reject", [...revisionIds])(state, (resolved) => {
 			tr = resolved;
@@ -1040,10 +1365,18 @@ function rejectAllSuggestions() {
 		workingTr.doc.descendants((node, pos) => {
 			if (readStructuralSuggestion(node)?.isNodeInsert) positions.push(pos);
 		});
-		for (const pos of positions.toSorted((a, b) => b - a)) {
-			const node = workingTr.doc.nodeAt(pos);
-			if (node) workingTr.delete(pos, pos + node.nodeSize);
-		}
+		if (!removeSuggestedInsertNodes({
+			tr: workingTr,
+			positions,
+			resolvedRevisionIds: revisionIds
+		})) return false;
+		if (positions.length > 0 && rotationCandidates.length > 0 && !rotateAddedFinalParagraphBreaks({
+			tr: workingTr,
+			shouldRotate: mappedRotationCandidatePredicate({
+				candidates: rotationCandidates,
+				tr: workingTr
+			})
+		})) return false;
 		if (workingTr.steps.length === 0) return false;
 		if (dispatch) dispatch(workingTr);
 		return true;

package/dist/prosemirror/commands/pageBreak.js

@@ -1,5 +1,5 @@
-import { Fragment } from "prosemirror-model";
 import { TextSelection } from "prosemirror-state";
+import { Fragment } from "prosemirror-model";
 //#region src/prosemirror/commands/pageBreak.ts
 /**
 * Page Break Commands

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

@@ -1,8 +1,27 @@
 import { document_d_exports } from "../../types/document.js";
-import { ParagraphPropertyChangeAttrs } from "../schema/nodes.js";
+import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "../schema/nodes.js";
+import { Node } from "prosemirror-model";
 //#region src/prosemirror/commands/propertyChangeScope.d.ts
 type AttrPatch = Record<string, unknown>;
 type ParagraphPropertySnapshot = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
+type ParagraphPropertyChangeRemoval = {
+  type: "unchanged";
+} | {
+  type: "keep-live";
+  remaining: ParagraphPropertyChangeAttrs[];
+} | {
+  type: "restore-previous";
+  remaining: ParagraphPropertyChangeAttrs[];
+  previousFormatting: ParagraphPropertyChangeAttrs["previousFormatting"];
+};
+/**
+ * Remove selected entries from an oldest-to-newest paragraph-property chain.
+ * A retained entry immediately after a removed run inherits that run's
+ * earliest previous snapshot. Only a removed trailing run restores the live
+ * paragraph properties. This makes repeated scoped rejection independent of
+ * the order in which revisions are resolved.
+ */
+declare const removeParagraphPropertyChanges: (changes: readonly ParagraphPropertyChangeAttrs[], shouldRemove: (change: ParagraphPropertyChangeAttrs) => boolean) => ParagraphPropertyChangeRemoval;
 /**
  * Paragraph attrs governed by a `w:pPrChange` — the attrs
  * `paragraphFormattingToAttrs` (conversion/toProseDoc.ts) can produce from a
@@ -19,9 +38,12 @@ type ParagraphPropertySnapshot = NonNullable<ParagraphPropertyChangeAttrs["previ
  *   `runInWithNext` (`w:specVanish` lives in that rPr)
  * - load-time style/numbering bookkeeping the command layer cannot recompute
  *   without a style resolver: `numPrFromStyle`, the `list*` rendering attrs,
- *   `spacingFromDocDefaults`, `spacingFromImplicitDefaultStyle`
+ *   `alignmentFromStyle`, `spacingFromDocDefaults`,
+ *   `spacingFromImplicitDefaultStyle`
  */
 declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "lineSpacingExplicit", "snapToGrid", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
+/** The in-scope paragraph properties as they stand, for a `w:pPrChange` record. */
+declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnapshot;
 /**
  * Build the attr patch that rejecting one pPrChange applies to a paragraph:
  * every in-scope key set to the stored previous value, or reset to `null`
@@ -29,7 +51,7 @@ declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignm
  * the scoped set (editor-created list suggestions snapshot list-rendering
  * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
  */
-declare function paragraphRejectAttrPatch(previousFormatting: ParagraphPropertySnapshot | null | undefined): AttrPatch;
+declare function paragraphRejectAttrPatch(previousFormatting: ParagraphPropertySnapshot | null | undefined, alignmentFromStyle?: ParagraphAttrs["alignmentFromStyle"]): AttrPatch;
 /**
  * Rebuild the paragraph's `_originalFormatting` (the serializer's pPr source)
  * after a reject: the stored old pPr wholesale within CT_PPrBase scope, with
@@ -66,4 +88,4 @@ declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.
  */
 declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };