@stll/folio-core 0.35.1 → 0.37.0

package/dist/prosemirror/commands/comments.js

@@ -1,12 +1,19 @@
+import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionResolution.js";
+import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
 import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
-import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
-import { textFormattingToMarks } from "../conversion/toProseDoc.js";
-import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
+import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
+import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
+import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { getFolioNodeRevisionCarriers } 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 { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { hasSerializableParagraphPropertyChange, 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";
@@ -43,6 +50,7 @@ function removeCommentMark(commentId) {
 		return true;
 	};
 }
+const BULK_INLINE_RESOLUTION_THRESHOLD = 256;
 /**
 * Resolve a tracked change: accept or reject.
 * - Accept: keep insertions (remove mark), delete deletions (remove text)
@@ -55,14 +63,16 @@ function removeCommentMark(commentId) {
 * 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) {
+function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 	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);
 		const removeKeptMarksInBulk = revisionSet === null && keepType !== void 0;
+		const canBulkInlineResolution = execution === "headless-bulk-inline" && revisionSet === null && from === 0 && to === state.doc.content.size && stateAllowsHeadlessRevisionResolution(state);
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
@@ -70,6 +80,10 @@ function resolveChange(from, to, mode, revisionIds) {
 			const pPrMarkOps = [];
 			const tableRowStructuralOps = [];
 			const tableCellStructuralOps = [];
+			const deferredRunPropertyChanges = [];
+			let bulkInlineCarrierCount = 0;
+			let removedSectionEndpointCount = 0;
+			const removedSectionReferences = [];
 			state.doc.nodesBetween(from, to, (node, pos) => {
 				if (node.type.name === "paragraph") {
 					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
@@ -78,16 +92,26 @@ 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 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;
 							}
 						}
 					}
@@ -106,7 +130,13 @@ function resolveChange(from, to, mode, revisionIds) {
 							nextAttrs["sectionBreakType"] = sectionBreakTypeFromSectionStart(restored.sectionStart);
 						}
 					}
-					if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
+					if (nextAttrs) if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
+						nextAttrs,
+						paragraphPosition: pos,
+						styleResolver,
+						tr
+					});
+					else tr.setNodeMarkup(pos, void 0, nextAttrs);
 					return true;
 				}
 				if (node.type.name === "tableRow" && rangeCoversNode(from, to, pos, node)) {
@@ -118,7 +148,10 @@ function resolveChange(from, to, mode, revisionIds) {
 				if (tableChangeAttrName !== void 0) {
 					if (rangeCoversNode(from, to, pos, node)) {
 						const nextAttrs = resolveTablePropertyChangeAttrs(node, tableChangeAttrName, mode, revisionSet);
-						if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
+						if (nextAttrs) {
+							tr.setNodeMarkup(pos, void 0, nextAttrs);
+							markStructuralChange(tr);
+						}
 					}
 					return true;
 				}
@@ -127,6 +160,27 @@ function resolveChange(from, to, mode, revisionIds) {
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
+				const resolvesRunPropertyChange = runPropertyChangeMark !== void 0 && expectRunPropertyChangeMarkAttrs(runPropertyChangeMark).changes.length > 0;
+				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
+				const removesKeptMark = keepType !== void 0 && node.marks.some((mark) => mark.type === keepType && matchesRevision(mark));
+				if (canBulkInlineResolution) {
+					if (resolvesRunPropertyChange) deferredRunPropertyChanges.push({
+						tr,
+						node,
+						from: rangeFrom,
+						to: rangeTo,
+						mark: runPropertyChangeMark,
+						mode,
+						revisionSet,
+						styleResolver
+					});
+					if (removesNode) deleteRanges.push({
+						from: rangeFrom,
+						to: rangeTo
+					});
+					if (resolvesRunPropertyChange || removesNode || removesKeptMark) bulkInlineCarrierCount++;
+					return true;
+				}
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -134,9 +188,10 @@ function resolveChange(from, to, mode, revisionIds) {
 					to: rangeTo,
 					mark: runPropertyChangeMark,
 					mode,
-					revisionSet
+					revisionSet,
+					styleResolver
 				});
-				if (removeType && node.marks.some((m) => m.type === removeType && matchesRevision(m))) deleteRanges.push({
+				if (removesNode) deleteRanges.push({
 					from: rangeFrom,
 					to: rangeTo
 				});
@@ -145,24 +200,35 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				return true;
 			});
-			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;
+			let bulkInlineChangeTracking = null;
+			if (canBulkInlineResolution && bulkInlineCarrierCount >= BULK_INLINE_RESOLUTION_THRESHOLD) bulkInlineChangeTracking = appendHeadlessInlineResolution({
+				tr,
+				mode,
+				keepType,
+				removeType,
+				styleResolver
+			});
+			else {
+				for (const deferred of deferredRunPropertyChanges) resolveRunPropertyChange(deferred);
+				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
+						});
 					}
-					coalescedDeleteRanges.push({
-						from: range.from,
-						to: range.to
-					});
+					rangesToDelete = coalescedDeleteRanges;
 				}
-				rangesToDelete = coalescedDeleteRanges;
+				for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
 			}
-			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);
@@ -174,35 +240,34 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				const joinPos = mappedPos + paragraph.nodeSize;
 				const nextNode = joinPos < tr.doc.content.size ? tr.doc.nodeAt(joinPos) : null;
-				if (!(nextNode?.type.name === paragraph.type.name && !(carriesSection(paragraph) && carriesSection(nextNode)))) {
+				if (!(nextNode?.type.name === paragraph.type.name)) {
 					const resolved = tr.doc.resolve(mappedPos);
-					const previous = resolved.nodeBefore;
-					const sectionCanMoveBack = !carriesSection(paragraph) || previous?.type.name === paragraph.type.name && !carriesSection(previous);
 					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
 					const canGo = op.markWasAdded || !endsItsContainer;
-					if (sectionCanMoveBack && holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
-						if (carriesSection(paragraph) && previous) tr.setNodeMarkup(mappedPos - previous.nodeSize, void 0, {
-							...previous.attrs,
-							sectionBreakType: paragraph.attrs["sectionBreakType"],
-							_sectionProperties: paragraph.attrs["_sectionProperties"]
-						});
+					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;
 				}
-				const formattingOwner = holdsNoContent(paragraph) ? nextNode : paragraph;
-				const sectionOwner = carriesSection(paragraph) ? paragraph : nextNode;
 				const joinedAttrs = {
-					...formattingOwner.attrs,
+					...(holdsNoContent(paragraph) ? nextNode : paragraph).attrs,
 					pPrMark: nextNode.attrs["pPrMark"],
-					sectionBreakType: sectionOwner.attrs["sectionBreakType"],
-					_sectionProperties: sectionOwner.attrs["_sectionProperties"]
+					sectionBreakType: nextNode.attrs["sectionBreakType"],
+					_sectionProperties: nextNode.attrs["_sectionProperties"]
 				};
 				try {
 					tr.join(joinPos);
 					tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
+					if (ownsSectionEndpoint(paragraph)) {
+						removedSectionEndpointCount++;
+						removedSectionReferences.push(...sectionReferencesOf(paragraph));
+					}
 				} catch {}
 			}
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
@@ -252,12 +317,18 @@ function resolveChange(from, to, mode, revisionIds) {
 			}
 			if (failedTableCellMergeResolution) return false;
 			if (resolvedTableCellStructure) markStructuralChange(tr);
+			if (bulkInlineChangeTracking) markChangedParagraphRanges(tr, bulkInlineChangeTracking);
+			if (removedSectionEndpointCount > 0) markTrackedSectionEndpointRemoval(tr, {
+				sourceDoc: state.doc,
+				removedEndpointCount: removedSectionEndpointCount,
+				removedReferences: removedSectionReferences
+			});
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
 	};
 }
-const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet }) => {
+const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet, styleResolver }) => {
 	const { changes } = expectRunPropertyChangeMarkAttrs(mark);
 	const matches = changes.filter((change) => revisionSet === null || revisionSet.has(change.info.id));
 	if (matches.length === 0) return;
@@ -266,15 +337,18 @@ const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet
 	if (remaining.length > 0) tr.addMark(from, to, mark.type.create({ changes: remaining }));
 	if (mode === "accept") return;
 	const previousFormatting = matches.at(0)?.previousFormatting;
+	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 previousMark of textFormattingToMarks(previousFormatting)) tr.addMark(from, to, previousMark);
-	if (previousFormatting?.styleId) {
-		const characterStyle = node.type.schema.marks["characterStyle"];
-		if (characterStyle) tr.addMark(from, to, characterStyle.create({
-			styleId: previousFormatting.styleId,
-			_styleRPr: null
-		}));
-	}
+	for (const previousMark of reconstructRejectedRunFormattingMarks({
+		node,
+		paragraphContext: styleContext,
+		previousFormatting,
+		styleResolver
+	})) tr.addMark(from, to, previousMark);
 };
 function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
 	for (const attrName of ["trIns", "trDel"]) {
@@ -369,11 +443,33 @@ function deleteTableCellAt(tr, cellPos) {
 	const resolved = tr.doc.resolve(cellPos);
 	const row = resolved.parent;
 	if (row.type.spec["tableRole"] !== "row") return;
+	const tableDepth = resolved.depth - 1;
+	const table = resolved.node(tableDepth);
+	if (table.type.spec["tableRole"] !== "table") return;
+	const tablePosition = resolved.before(tableDepth);
+	const cellOffset = cellPos - resolved.start(tableDepth);
+	const removedColumn = TableMap.get(table).findCell(cellOffset).left;
 	if (row.childCount > 1) {
 		tr.delete(cellPos, cellPos + cell.nodeSize);
+		reconcileTableGridAfterColumnRemoval({
+			tr,
+			tablePosition,
+			previousTable: table,
+			removedColumn
+		});
+		return;
+	}
+	if (table.childCount === 1) {
+		deleteTableRowAt(tr, resolved.start() - 1);
 		return;
 	}
 	deleteTableRowAt(tr, resolved.start() - 1);
+	reconcileTableGridAfterColumnRemoval({
+		tr,
+		tablePosition,
+		previousTable: table,
+		removedColumn
+	});
 }
 function deleteTableRowAt(tr, rowPos) {
 	const resolved = tr.doc.resolve(rowPos);
@@ -480,15 +576,24 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
-/**
-* Whether the paragraph's mark carries a section's properties.
-*
-* A section break lives on a paragraph mark, so the paragraph is where the
-* section ends. Removing it removes the section: a document that had two ends
-* up with one, and every setting the dropped section carried — page size,
-* margins, its header and footer references — goes with it.
-*/
-const carriesSection = (paragraph) => paragraph.attrs["sectionBreakType"] != null || paragraph.attrs["_sectionProperties"] != null;
+const ownsSectionEndpoint = (paragraph) => {
+	const attrs = expectParagraphAttrs(paragraph);
+	return attrs._sectionProperties !== void 0 || attrs.sectionBreakType !== void 0;
+};
+const sectionReferencesOf = (paragraph) => {
+	const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
+	if (!sectionProperties) return [];
+	return [...(sectionProperties.headerReferences ?? []).map(({ type, rId }) => ({
+		part: "header",
+		type,
+		relationshipId: rId
+	})), ...(sectionProperties.footerReferences ?? []).map(({ type, rId }) => ({
+		part: "footer",
+		type,
+		relationshipId: rId
+	}))];
+};
+const isAddedPPrMarkAttr = (value) => isPPrMarkAttr(value) && (value.kind === "ins" || value.kind === "moveTo");
 function readRevisionInfo(info) {
 	const revision = {};
 	if (typeof info?.author === "string") revision.author = info.author;
@@ -566,6 +671,20 @@ function rejectAllChanges() {
 	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
 }
 /**
+* 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.
+*/
+function resolveAllChangesInHeadlessState(state, mode) {
+	let resolvedState = state;
+	resolveChange(0, state.doc.content.size, mode, void 0, "headless-bulk-inline")(state, (transaction) => {
+		resolvedState = state.apply(transaction);
+	});
+	return resolvedState;
+}
+/**
 * Find the document range covered by all revision carriers with any of the
 * given ids. Returns null when none are present (already accepted/rejected, or
 * never existed). A replace operation typically passes two ids; standalone
@@ -682,6 +801,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 +880,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 +988,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 +1024,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 +1057,266 @@ 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 canReauthorParagraphPropertySuggestions = (doc, matchesSuggestion) => {
+	let valid = true;
+	doc.descendants((node) => {
+		if (!valid || node.type.name !== "paragraph") return;
+		const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+		if (!Array.isArray(propertyChanges)) return;
+		let serializableCount = 0;
+		for (const change of propertyChanges) {
+			const suggested = readSuggestedParagraphPropertyChange(change);
+			if (!suggested || matchesSuggestion(suggested.suggestionId)) serializableCount++;
+		}
+		if (serializableCount > 1) {
+			valid = false;
+			return false;
+		}
+	});
+	return valid;
+};
+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;
+	if (hasSerializableParagraphPropertyChange(existing)) return false;
+	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
@@ -916,21 +1324,43 @@ const convertStructuralSuggestionAttrs = (node, author, date) => {
 */
 const acceptSuggestions = (matchesSuggestion, options) => {
 	return (state, dispatch) => {
+		if (!canReauthorParagraphPropertySuggestions(state.doc, matchesSuggestion)) return false;
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
 		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 +1394,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 +1443,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 +1458,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 +1481,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 +1496,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;
@@ -1214,4 +1678,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 };
+export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState };