@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/commands/comments.js

@@ -4,22 +4,27 @@ 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 { readCommentRangeBoundaryAttrs } from "../commentRangeBoundaryAttrs.js";
+import { addedBreakCarrierBefore, finalParagraphsOf } from "../containerFinalParagraph.js";
 import { enclosingRevisionIds, resolutionRemovesControl, withoutResolvedEnclosures } from "../contentControlRevisions.js";
+import { copyOriginBoundaryAttrsAfterResolution } from "../copyOriginResolution.js";
 import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
 import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
+import { requestDeterministicParaIds } from "../extensions/features/ParaIdAllocatorExtension.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
 import { canonicalFieldNode } from "../fieldRepresentation.js";
+import { isBlockBoundaryNode, normalizeKeptRangeBoundaries, paragraphRemainsOf, removeResolvedSubtree, revisionLayerRemovesContent } from "../keptRangeBoundaries.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { carryParagraphProperties, paragraphLeftAfter } from "../paragraphPropertyCarry.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
 import { resolvedPreservedXmlAttrs } from "../preservedXmlReview.js";
+import { readRangeAnchorAttrs } from "../rangeAnchorAttrs.js";
 import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
-import { commentPoint, resolvedCommentPoints } from "../replacedAnnotations.js";
+import { resolvedCommentPoints } from "../replacedAnnotations.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../runPropertyChangeResolution.js";
@@ -29,7 +34,8 @@ import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.
 import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
 import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
 import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "../trackedRevisionPath.js";
-import { holdsNoContent } from "../zeroWidthAnchors.js";
+import { extractTrackedChanges } from "../utils/extractTrackedChanges.js";
+import { paragraphContentOf } from "../zeroWidthAnchors.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
 import { resolveNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
 import { resolveParagraphChangeAttrs } from "./resolveParagraphProperties.js";
@@ -39,6 +45,7 @@ import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/mo
 import { Fragment } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
+import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Comment and Track Changes Commands
@@ -77,19 +84,7 @@ function removeCommentMark(commentId) {
 		return true;
 	};
 }
-const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
-/**
-* Resolve a tracked change: accept or reject.
-* - Accept: keep insertions (remove mark), delete deletions (remove text)
-* - Reject: keep deletions (remove mark), delete insertions (remove text)
-* - Run formatting: accept the current formatting, or restore the previous formatting
-*
-* Pass `revisionId` to scope the operation to one specific
-* revision — otherwise overlapping marks for other revisions get
-* processed too, silently consuming pending work. Without an id
-* the operation matches every revision mark or property-change entry in the
-* range (the bulk accept-all/reject-all path).
-*/
+const keptIn = (range) => range.removals.flatMap(({ kept }) => kept);
 function resolveChange(from, to, mode, revisionIds) {
 	return (state, dispatch) => {
 		const insertionType = state.schema.marks["insertion"];
@@ -114,7 +109,34 @@ function resolveChange(from, to, mode, revisionIds) {
 			}) : /* @__PURE__ */ new Map();
 			const tr = state.tr;
 			tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
+			/** Content this resolution takes out, and what each removal keeps. */
 			const deleteRanges = [];
+			/** The boundaries removed content left standing, for the range repair. */
+			const keptBoundaries = /* @__PURE__ */ new Set();
+			/** What this resolution resolves, for what removed content keeps. */
+			const selection = {
+				mode,
+				resolves: (revisionId) => revisionSet === null || revisionSet.has(revisionId)
+			};
+			const removeRange = (rangeFrom, rangeTo, removed) => {
+				deleteRanges.push({
+					from: rangeFrom,
+					to: rangeTo,
+					removals: [removed]
+				});
+			};
+			const resolveCopyOriginAttrs = (source, position) => {
+				const current = tr.doc.nodeAt(position);
+				if (!current) return;
+				const attrs = copyOriginBoundaryAttrsAfterResolution({
+					source,
+					current,
+					baseAttrs: current.attrs,
+					selection
+				});
+				if (attrs === null) panic("A copied boundary owner cannot be rejected outside removal.");
+				if (attrs !== current.attrs) tr.setNodeMarkup(position, void 0, attrs);
+			};
 			/** Where resolved inline content began and ended, in `state.doc`. */
 			const resolvedBoundaries = [];
 			const pPrMarkOps = [];
@@ -122,6 +144,13 @@ function resolveChange(from, to, mode, revisionIds) {
 			const tableCellStructuralOps = [];
 			let removedSectionEndpointCount = 0;
 			const removedSectionReferences = [];
+			const countedSectionEndpoints = /* @__PURE__ */ new Set();
+			const countRemovedSectionEndpoint = (paragraph) => {
+				if (!ownsSectionEndpoint(paragraph) || countedSectionEndpoints.has(paragraph)) return;
+				countedSectionEndpoints.add(paragraph);
+				removedSectionEndpointCount++;
+				removedSectionReferences.push(...sectionReferencesOf(paragraph));
+			};
 			const carryRestoredProperties = (position) => {
 				if (mode !== "reject" || revisionSet === null) return;
 				const source = tr.doc.nodeAt(position);
@@ -145,25 +174,22 @@ function resolveChange(from, to, mode, revisionIds) {
 				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);
 					const nextAttrs = resolveParagraphChangeAttrs({
 						node,
-						boundaryCovered: rangeCoversParagraphBoundary(from, to, pos, node),
+						boundaryCovered,
 						mode,
 						revisionSet,
 						styleResolver,
 						numbering
 					});
 					if (nextAttrs) {
+						if (nextAttrs["_sectionProperties"] == null) countRemovedSectionEndpoint(node);
 						if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
 							nextAttrs,
 							paragraphPosition: pos,
 							styleResolver,
-							tr,
-							...mode === "reject" && { shouldRebase: (inline) => {
-								const deleted = inline.marks.some(({ type }) => type.name === "deletion");
-								const direct = inline.marks.some(({ type }) => type.name === "runFormattingOverride");
-								return !deleted || !direct;
-							} }
+							tr
 						});
 						else tr.setNodeMarkup(pos, void 0, nextAttrs);
 						carryRestoredProperties(pos);
@@ -203,10 +229,7 @@ function resolveChange(from, to, mode, revisionIds) {
 						removeType,
 						resolves: resolvesRevision
 					})) {
-						deleteRanges.push({
-							from: pos,
-							to: nodeEnd
-						});
+						removeRange(pos, nodeEnd, removeResolvedSubtree(node, selection));
 						return false;
 					}
 					const released = withoutResolvedEnclosures(node, resolvesRevision);
@@ -243,33 +266,39 @@ function resolveChange(from, to, mode, revisionIds) {
 				if (nestedMark) {
 					const path = trackedRevisionPathOf(nestedMark);
 					const selected = (layer) => revisionSet === null || revisionSet.has(layer.revisionId);
-					if (path.some(selected)) if (path.some((layer) => selected(layer) && revisionLayerRemovesContent(layer, mode))) deleteRanges.push({
-						from: rangeFrom,
-						to: rangeTo
-					});
-					else {
-						tr.removeMark(rangeFrom, rangeTo, nestedMark);
-						const retained = retainedTrackedRevisionMark(nestedMark, (layer) => !selected(layer));
-						if (retained) tr.addMark(rangeFrom, rangeTo, retained);
+					let nestedContentRemoved = false;
+					if (path.some(selected)) {
+						if (path.some((layer) => selected(layer) && revisionLayerRemovesContent(layer, mode))) {
+							removeRange(rangeFrom, rangeTo, removeResolvedSubtree(node, selection));
+							nestedContentRemoved = true;
+							if (!node.isLeaf) return false;
+						} else {
+							tr.removeMark(rangeFrom, rangeTo, nestedMark);
+							const retained = retainedTrackedRevisionMark(nestedMark, (layer) => !selected(layer));
+							if (retained) tr.addMark(rangeFrom, rangeTo, retained);
+						}
 					}
 					const current = tr.doc.nodeAt(pos);
 					if (current) {
 						const attrs = resolvedPreservedXmlAttrs(node, current.marks);
 						if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
 					}
+					if (!nestedContentRemoved) resolveCopyOriginAttrs(node, pos);
 					return true;
 				}
-				if (removesNode) deleteRanges.push({
-					from: rangeFrom,
-					to: rangeTo
-				});
+				if (removesNode) {
+					removeRange(rangeFrom, rangeTo, removeResolvedSubtree(node, selection));
+					if (!node.isLeaf) return false;
+				}
 				if (!removesNode && keepType && node.marks.some((mark) => mark.type === keepType && matchesRevision(mark))) {
-					const attrs = resolvedPreservedXmlAttrs(node, node.marks.filter((mark) => !(mark.type === keepType && matchesRevision(mark))));
+					const retained = node.marks.filter((mark) => !(mark.type === keepType && matchesRevision(mark)));
+					const attrs = resolvedPreservedXmlAttrs(node, retained);
 					if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
 				}
 				if (!removeKeptMarksInBulk) {
 					for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
 				}
+				if (!removesNode) resolveCopyOriginAttrs(node, pos);
 				return true;
 			});
 			if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
@@ -280,25 +309,26 @@ function resolveChange(from, to, mode, revisionIds) {
 					const previous = coalescedDeleteRanges.at(-1);
 					if (previous && range.from <= previous.to) {
 						previous.to = Math.max(previous.to, range.to);
+						previous.removals = [...previous.removals, ...range.removals];
 						continue;
 					}
-					coalescedDeleteRanges.push({
-						from: range.from,
-						to: range.to
-					});
+					coalescedDeleteRanges.push({ ...range });
 				}
 				rangesToDelete = coalescedDeleteRanges;
 			}
 			for (const range of rangesToDelete.toReversed()) {
 				const start = tr.doc.resolve(range.from);
 				const field = start.parent;
-				if (field.type.name === "structuredField" && start.parentOffset === 0 && range.to === start.end()) {
+				if (keptIn(range).length === 0 && field.type.name === "structuredField" && start.parentOffset === 0 && range.to === start.end()) {
 					const position = start.before();
 					const empty = canonicalFieldNode(field.copy(Fragment.empty));
 					tr.replaceWith(position, position + field.nodeSize, empty);
 					continue;
 				}
-				tr.delete(range.from, range.to);
+				const kept = keptIn(range);
+				for (const boundary of kept) keptBoundaries.add(boundary);
+				if (kept.length === 0) tr.delete(range.from, range.to);
+				else tr.replaceWith(range.from, range.to, kept);
 			}
 			if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(state.doc, tr.doc))) markStructuralChange(tr);
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
@@ -375,13 +405,38 @@ function resolveChange(from, to, mode, revisionIds) {
 				const boundaries = [];
 				while (nextPos < tr.doc.content.size) {
 					const boundary = tr.doc.nodeAt(nextPos);
-					if (boundary?.type.name !== "blockBookmarkBoundary") break;
+					if (boundary === null || !isBlockBoundaryNode(boundary)) break;
 					boundaries.push(boundary);
 					nextPos += boundary.nodeSize;
 				}
 				const nextNode = nextPos < tr.doc.content.size ? tr.doc.nodeAt(nextPos) : null;
 				const joinable = nextNode?.type.name === paragraph.type.name;
-				const ranIn = nextNode?.type.spec["tableRole"] === "table" && boundaries.length === 0 && !pendingTables.some((position) => tr.mapping.map(position) === nextPos) ? runParagraphIntoTable({
+				let follows = "nothing";
+				if (joinable) follows = "paragraph";
+				else if (nextNode?.type.spec["tableRole"] === "table") follows = "table";
+				const resolved = tr.doc.resolve(mappedPos);
+				const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
+				const preceding = resolved.parent.maybeChild(resolved.index() - 1);
+				const precedingProperties = preceding?.type.name === "paragraph" ? expectParagraphAttrs(preceding)._sectionProperties : void 0;
+				let precedingSectionOwner = "unavailable";
+				if (preceding?.type.name === "paragraph") {
+					if (precedingProperties == null) precedingSectionOwner = "available";
+					else if (JSON.stringify(precedingProperties) === JSON.stringify(sectionProperties)) precedingSectionOwner = "same";
+					else precedingSectionOwner = "occupied";
+				}
+				const retainedBoundaries = paragraphRemainsOf(paragraph);
+				const outcome = paragraphMarkOutcome({
+					follows,
+					holdsContent: paragraphContentOf(paragraph),
+					markWasAdded: op.markWasAdded,
+					containerStillEndsWithParagraph: resolved.parent.maybeChild(resolved.index() - 1)?.type.name === "paragraph",
+					followingTableCanReceiveRunIn: follows === "table" && boundaries.length === 0 && !pendingTables.some((position) => tr.mapping.map(position) === nextPos) && !ownsSectionEndpoint(paragraph),
+					needsFollowingCommentHost: follows === "table" && preceding?.type.name !== "paragraph" && retainedBoundaries.blocks.length === 0 && retainedBoundaries.comments.length > 0,
+					removedSectionProperties: op.markWasAdded && sectionProperties != null,
+					precedingSectionOwner,
+					followingHasSectionProperties: nextNode?.type.name === "paragraph" && ownsSectionEndpoint(nextNode)
+				});
+				const ranIn = outcome.kind === "run-in" ? runParagraphIntoTable({
 					tr,
 					paragraphPos: mappedPos,
 					styleResolver
@@ -392,36 +447,37 @@ function resolveChange(from, to, mode, revisionIds) {
 					continue;
 				}
 				if (!joinable) {
-					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);
+					const remains = outcome.kind === "remove" ? paragraphRemainsOf(paragraph) : null;
+					const between = follows === "table" ? remains?.blocks ?? [] : [];
+					const toPrevious = follows === "table" ? remains?.comments ?? [] : remains?.inline ?? [];
+					if (remains !== null && (toPrevious.length === 0 || preceding?.type.name === "paragraph")) {
+						if (outcome.sectionDestination === "preceding" && preceding?.type.name === "paragraph") tr.setNodeAttribute(mappedPos - preceding.nodeSize, "_sectionProperties", sectionProperties);
+						countRemovedSectionEndpoint(paragraph);
+						tr.replaceWith(mappedPos, mappedPos + paragraph.nodeSize, between);
+						if (toPrevious.length > 0) tr.insert(mappedPos - 1, toPrevious);
 						continue;
 					}
 					tr.setNodeAttribute(mappedPos, "pPrMark", null);
 					continue;
 				}
 				try {
+					if (outcome.sectionDestination === "preceding" && preceding?.type.name === "paragraph") {
+						const precedingPos = mappedPos - preceding.nodeSize;
+						tr.setNodeAttribute(precedingPos, "_sectionProperties", sectionProperties);
+					} else if (outcome.sectionDestination === "following") tr.setNodeAttribute(nextPos, "_sectionProperties", sectionProperties);
+					const destination = tr.doc.nodeAt(nextPos);
 					joinAtParagraphMark({
 						tr,
 						paragraphPos: mappedPos,
 						paragraph,
-						next: nextNode,
+						next: destination?.type.name === "paragraph" ? destination : nextNode,
 						styleResolver
 					});
 					joinSeams.push({
 						position: mappedPos + 1 + paragraph.content.size,
 						step: tr.steps.length
 					});
-					if (ownsSectionEndpoint(paragraph)) {
-						removedSectionEndpointCount++;
-						removedSectionReferences.push(...sectionReferencesOf(paragraph));
-					}
+					countRemovedSectionEndpoint(paragraph);
 				} catch {
 					continue;
 				}
@@ -453,7 +509,42 @@ function resolveChange(from, to, mode, revisionIds) {
 				if (field.type === node.type) tr.setNodeMarkup(position, void 0, node.attrs, node.marks);
 				else tr.replaceWith(position, position + field.nodeSize, node);
 			}
-			for (const [id, position] of [...points].toReversed()) tr.insert(tr.mapping.map(position, -1), commentPoint(tr.doc.type.schema, id));
+			if (points.size > 0) {
+				const doomed = new Set(points.keys());
+				const carriers = [];
+				tr.doc.descendants((node, position) => {
+					if (node.type.name === "commentReference" && doomed.has(node.attrs["commentId"])) {
+						carriers.push({
+							position,
+							size: node.nodeSize
+						});
+						return false;
+					}
+					if (node.type.name === "commentRangeBoundary") {
+						const attrs = readCommentRangeBoundaryAttrs(node);
+						if (attrs.ok && doomed.has(attrs.value.marker.id)) {
+							carriers.push({
+								position,
+								size: node.nodeSize
+							});
+							return false;
+						}
+						return true;
+					}
+					if (node.type.name !== "rangeAnchor") return true;
+					const attrs = readRangeAnchorAttrs(node);
+					if (attrs.ok && attrs.value.start.type === "commentRangeStart" && doomed.has(attrs.value.start.id)) {
+						carriers.push({
+							position,
+							size: node.nodeSize
+						});
+						return false;
+					}
+					return true;
+				});
+				for (const carrier of carriers.toReversed()) tr.delete(carrier.position, carrier.position + carrier.size);
+			}
+			normalizeKeptRangeBoundaries(tr, keptBoundaries);
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
@@ -600,20 +691,22 @@ function clearTableRowContentMarks({ tr, rowPos, markType, revision }) {
 function collectTableCellStructuralOps(node, cellPos, mode, revisionSet) {
 	const operations = [];
 	const marker = node.attrs["cellMarker"];
-	if (isTableCellRevisionAttr(marker) && (revisionSet === null || revisionSet.has(marker.info.revisionId))) if (marker.kind === "merge") operations.push({
-		type: "merge",
-		cellPos,
-		source: "visible",
-		mode,
-		revisionSet
-	});
-	else {
-		const view = mode === "accept" ? "final" : "original";
-		operations.push({
-			type: "membership",
+	if (isTableCellRevisionAttr(marker) && (revisionSet === null || revisionSet.has(marker.info.revisionId))) {
+		if (marker.kind === "merge") operations.push({
+			type: "merge",
 			cellPos,
-			action: isTableCellRetainedInReviewView(marker.kind, view) ? "clear" : "remove"
+			source: "visible",
+			mode,
+			revisionSet
 		});
+		else {
+			const view = mode === "accept" ? "final" : "original";
+			operations.push({
+				type: "membership",
+				cellPos,
+				action: isTableCellRetainedInReviewView(marker.kind, view) ? "clear" : "remove"
+			});
+		}
 	}
 	if (hasMatchingCollapsedTableCellMerge(node, revisionSet)) operations.push({
 		type: "merge",
@@ -733,7 +826,7 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
-const ownsSectionEndpoint = (paragraph) => expectParagraphAttrs(paragraph)._sectionProperties !== void 0;
+const ownsSectionEndpoint = (paragraph) => expectParagraphAttrs(paragraph)._sectionProperties != null;
 const sectionReferencesOf = (paragraph) => {
 	const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
 	if (!sectionProperties) return [];
@@ -759,7 +852,8 @@ function getListPropertyChangeType(node, change) {
 	const previousFormatting = change.previousFormatting;
 	if (previousFormatting == null || !Object.hasOwn(previousFormatting, "numPr")) return null;
 	const current = expectParagraphAttrs(node).numPr;
-	if (sameStatedParagraphNumbering$1(previousFormatting["numPr"] ?? void 0, current)) return null;
+	const previous = previousFormatting["numPr"] ?? void 0;
+	if (sameStatedParagraphNumbering$1(previous, current)) return null;
 	return current === void 0 ? "deletion" : "insertion";
 }
 function toParagraphBoundaryChange(node, pos, type, info) {
@@ -812,9 +906,12 @@ const resolveAllChanges = (mode) => (state, dispatch) => {
 		steps: result.steps,
 		positionMap: result.positionMap
 	}));
+	const resolvedAt = tr.steps.length;
+	normalizeKeptRangeBoundaries(tr, result.keptBoundaries);
+	requestDeterministicParaIds(tr, `resolve-all:${mode}`);
 	markChangedParagraphRanges(tr, {
 		ranges: finalRevisionParagraphRanges(result),
-		mappingFrom: tr.steps.length,
+		mappingFrom: resolvedAt,
 		replacesStepMapAt: 0
 	});
 	markParagraphPropertySourceTransfers(tr, result.transfers);
@@ -1464,13 +1561,16 @@ const shiftAddedParagraphBreakBefore = ({ tr, paragraphPosition, mark, fallbackA
 	return false;
 };
 /**
-* Place an accepted paragraph's break when a following accepted insertion has
-* already rotated its own break onto that paragraph.
+* Place an accepted paragraph's break when its own break slot is taken: a
+* following accepted insertion has rotated its break onto the paragraph, or
+* the paragraph carries the break of the one it was inserted after, pending
+* deletion. Either way that boundary stays, and the accepted break goes on
+* the preceding free carrier.
 */
 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;
+	if (!paragraph || paragraph.type.name !== "paragraph" || !isPPrMarkAttr(displaced)) return false;
 	return shiftAddedParagraphBreakBefore({
 		tr,
 		paragraphPosition,
@@ -1748,6 +1848,33 @@ function rejectAllSuggestions() {
 		return true;
 	};
 }
+const pairedReplacementRangesByDoc = /* @__PURE__ */ new WeakMap();
+const pairedReplacementRanges = (state) => {
+	const cached = pairedReplacementRangesByDoc.get(state.doc);
+	if (cached) return cached;
+	const ranges = [];
+	const { entries } = extractTrackedChanges(state);
+	for (const entry of entries) {
+		if (entry.type !== "replacement" || entry.insertionRevisionId === void 0) continue;
+		ranges.push({
+			from: entry.from,
+			to: entry.to
+		});
+	}
+	pairedReplacementRangesByDoc.set(state.doc, ranges);
+	return ranges;
+};
+const pairedReplacementRangeAt = ({ ranges, from, to }) => {
+	let low = 0;
+	let high = ranges.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		if (ranges[middle].from <= from) low = middle + 1;
+		else high = middle;
+	}
+	const candidate = ranges[low - 1];
+	return candidate && from >= candidate.from && to <= candidate.to ? candidate : void 0;
+};
 /**
 * Find the tracked change mark range at a given cursor position.
 * If the cursor is inside a tracked change, returns the full extent
@@ -1872,13 +1999,18 @@ function findNextChange(state, startPos) {
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
 	if (!insertionType && !deletionType) return null;
+	const replacementRanges = pairedReplacementRanges(state);
 	const result = { value: null };
 	state.doc.descendants((node, pos) => {
 		if (result.value) return false;
 		if (!node.isInline) return;
 		if (pos + node.nodeSize <= startPos) return;
 		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
-			const expanded = expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
+			const expanded = pairedReplacementRangeAt({
+				ranges: replacementRanges,
+				from: pos,
+				to: pos + node.nodeSize
+			}) ?? expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
 			result.value = {
 				from: expanded.from,
 				to: expanded.to,
@@ -1899,6 +2031,7 @@ function findPreviousChange(state, startPos) {
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
 	if (!insertionType && !deletionType) return null;
+	const replacementRanges = pairedReplacementRanges(state);
 	const result = { value: null };
 	let resultMark = null;
 	state.doc.descendants((node, pos) => {
@@ -1906,7 +2039,11 @@ function findPreviousChange(state, startPos) {
 		if (pos >= startPos) return false;
 		if (result.value && resultMark && pos < result.value.to && node.marks.every((m) => m.type !== insertionType && m.type !== deletionType || m.eq(resultMark))) return;
 		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
-			const expanded = expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
+			const expanded = pairedReplacementRangeAt({
+				ranges: replacementRanges,
+				from: pos,
+				to: pos + node.nodeSize
+			}) ?? expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
 			result.value = {
 				from: expanded.from,
 				to: expanded.to,

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

@@ -8,7 +8,7 @@ import { EditorState, Transaction } from "prosemirror-state";
 type ForceOption = {
   force?: boolean;
 };
-type BlockSdtPMMatch = {
+export type BlockSdtPMMatch = {
   node: Node;
   /** Absolute PM position of the blockSdt's open tag. */
   pos: number;
@@ -16,9 +16,9 @@ type BlockSdtPMMatch = {
   path: number[];
 };
 /** All blockSdt nodes in `doc` matching `filter`. Outer→inner traversal. */
-declare function findBlockSdtMatches(doc: Node, filter?: ContentControlFilter): BlockSdtPMMatch[];
+export declare function findBlockSdtMatches(doc: Node, filter?: ContentControlFilter): BlockSdtPMMatch[];
 /** First match or null — convenience for editor-ref callers. */
-declare function findBlockSdtMatch(doc: Node, filter: ContentControlFilter): BlockSdtPMMatch | null;
+export declare function findBlockSdtMatch(doc: Node, filter: ContentControlFilter): BlockSdtPMMatch | null;
 /**
  * Project a `blockSdt` PM node's attrs onto the full modeled `SdtProperties`
  * shape so the editor-ref `getContentControls` and lock-error messages
@@ -26,22 +26,22 @@ declare function findBlockSdtMatch(doc: Node, filter: ContentControlFilter): Blo
  * dateFormat, listItems, checked, etc.). Raw XML payloads are not exposed —
  * those are for serializer replay, not for callers.
  */
-declare function blockSdtAttrsToSdtProperties(node: Node): document_d_exports.SdtProperties;
+export declare function blockSdtAttrsToSdtProperties(node: Node): document_d_exports.SdtProperties;
 /**
  * Replace a control's children with plain text (one paragraph) or
  * pre-built PM blocks. Returns null when no match is present.
  */
-declare function setContentControlContentTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlContentInput, options?: ForceOption): Transaction | null;
+export declare function setContentControlContentTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlContentInput, options?: ForceOption): Transaction | null;
 /**
  * Internal helper for the block-content fill variant. Lives in this module
  * so callers reuse the same lock-check and `replaceWith` shape; the
  * conversion-aware `setContentControlContentBlocksTr` in
  * `./contentControlsBlockFill.ts` wraps it.
  */
-declare function replaceBlockSdtChildrenForFill(state: EditorState, filter: ContentControlFilter, children: readonly Node[], options?: ForceOption): Transaction | null;
-declare function setContentControlValueTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlValueInput, options?: ForceOption): Transaction | null;
-declare function removeContentControlTr(state: EditorState, filter: ContentControlFilter, options?: ForceOption & {
+export declare function replaceBlockSdtChildrenForFill(state: EditorState, filter: ContentControlFilter, children: readonly Node[], options?: ForceOption): Transaction | null;
+export declare function setContentControlValueTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlValueInput, options?: ForceOption): Transaction | null;
+export declare function removeContentControlTr(state: EditorState, filter: ContentControlFilter, options?: ForceOption & {
   keepContent?: boolean;
 }): Transaction | null;
 //#endregion
-export { BlockSdtPMMatch, blockSdtAttrsToSdtProperties, findBlockSdtMatch, findBlockSdtMatches, removeContentControlTr, replaceBlockSdtChildrenForFill, setContentControlContentTr, setContentControlValueTr };
+export {};

package/dist/prosemirror/commands/contentControls.js

@@ -1,5 +1,6 @@
 import { checkboxDisplayContent } from "../../content-controls/checkboxDisplay.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
+import { isContentLocked } from "../../content-controls/mutateContentControls.js";
 import { formatDate } from "../../docx/fieldParser.js";
 import { preservedSdtChild, withoutPreservedSdtChild } from "../../docx/sdtProperties.js";
 import { expectBlockSdtAttrs } from "../attrs/index.js";
@@ -102,7 +103,7 @@ function throwLockedNode(node, lock) {
 function ensureContentNotLocked(node, options) {
 	if (options.force) return;
 	const lock = node.attrs["lock"];
-	if (lock === "contentLocked" || lock === "sdtContentLocked") throwLockedNode(node, lock);
+	if (isContentLocked(lock)) throwLockedNode(node, lock);
 }
 /**
 * Per OOXML §17.5.2.16: `sdtLocked` and `sdtContentLocked` block container

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

@@ -8,8 +8,7 @@ import { EditorState, Transaction } from "prosemirror-state";
  * PM-converted form of `blocks`. Locked controls throw
  * `ContentControlLockedError` unless `{ force: true }` is passed.
  */
-declare function setContentControlContentBlocksTr(state: EditorState, filter: ContentControlFilter, blocks: document_d_exports.BlockContent[], options?: {
+export declare function setContentControlContentBlocksTr(state: EditorState, filter: ContentControlFilter, blocks: document_d_exports.BlockContent[], options?: {
   force?: boolean;
 }): Transaction | null;
-//#endregion
-export { setContentControlContentBlocksTr };
+//#endregion

package/dist/prosemirror/commands/contentControlsBlockFill.js

@@ -13,7 +13,8 @@ function blockContentToPMChildren(blocks) {
 * `ContentControlLockedError` unless `{ force: true }` is passed.
 */
 function setContentControlContentBlocksTr(state, filter, blocks, options = {}) {
-	return replaceBlockSdtChildrenForFill(state, filter, blockContentToPMChildren(blocks), options);
+	const children = blockContentToPMChildren(blocks);
+	return replaceBlockSdtChildrenForFill(state, filter, children, options);
 }
 //#endregion
 export { setContentControlContentBlocksTr };