@stll/folio-core 0.62.0 → 0.63.1

package/dist/ai-edits/apply.js

@@ -1,3 +1,4 @@
+import { isNumberingReference } from "../docx/numberingReference.js";
 import { formattingEquals } from "../docx/runConsolidator.js";
 import { isStyleSourcedParagraphNumbering } from "../internal/paragraphFormattingSerialization.js";
 import { addTrackedDeletionMark } from "../prosemirror/addTrackedDeletionMark.js";
@@ -11,8 +12,8 @@ import { encloseWholeControls } from "../prosemirror/contentControlRevisions.js"
 import { JOINED_RUNS_RESTYLED_META } from "../prosemirror/extensions/features/JoinedRunStyleExtension.js";
 import { requestDeterministicParaIds } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
 import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
-import "../prosemirror/extensions/nodes/RangeAnchorExtension.js";
 import "../prosemirror/extensions/nodes/TextBoxAnchorExtension.js";
+import { blockBoundariesOf, carriesCommentAnchor, inlineBoundariesOf, isBlockBoundaryNode, removeResolvedSubtree } from "../prosemirror/keptRangeBoundaries.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../prosemirror/listMarker.js";
 import { effectiveParagraphNumbering, paragraphNumberingAttr, paragraphNumberingSourcesFromBoundary, readParagraphNumberingAttr, removedNumberingAttr } from "../prosemirror/numberingAttr.js";
 import { directParagraphAlignment } from "../prosemirror/paragraphAlignment.js";
@@ -24,9 +25,8 @@ import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqua
 import { getDocumentNumbering, getDocumentNumberingInstanceIds } from "../prosemirror/plugins/documentNumbering.js";
 import { getDocumentStyleDefinitions, getDocumentStyleResolver } from "../prosemirror/plugins/documentStyleState.js";
 import { claimRevisionIds, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, seedRevisionIdsFromDoc } from "../prosemirror/plugins/revisionIds.js";
-import { readRangeAnchorAttrs } from "../prosemirror/rangeAnchorAttrs.js";
 import { rebaseParagraphRuns } from "../prosemirror/rebaseParagraphRuns.js";
-import { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, placeTrackedInsertion, surveyReplacedAnnotations } from "../prosemirror/replacedAnnotations.js";
+import { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, joinCommentStretches, placeTrackedInsertion, surveyReplacedAnnotations } from "../prosemirror/replacedAnnotations.js";
 import { applyMarksToRunFormattingRepresentation, runFormattingInlineControlNodeName, selectRunFormattingCarrierRepresentations } from "../prosemirror/runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../prosemirror/runFormattingMarkNames.js";
 import { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
@@ -37,15 +37,16 @@ import { removeRowsWithoutCellsAfterBatch } from "../prosemirror/tableGridMutati
 import { isZeroWidthAnchor } from "../prosemirror/zeroWidthAnchors.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.js";
 import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
-import { BatchClaims, compareBatchTieOrder } from "./batch-claims.js";
+import { BatchClaims } from "./batch-claims.js";
 import { stripBlockIdentityAttrs } from "./block-identity.js";
 import { describeCharacterSplit } from "./character-boundaries.js";
 import { buildCleanBlockText, resolveCleanTextRange } from "./clean-text.js";
 import { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers } from "./inline-emphasis.js";
 import { applyTextChanges, changesFromSegments, keepAtomicSpans, planTextChanges, widenChangesToAtomicSpans } from "./minimal-replacement.js";
-import { resolveNewListOperations } from "./newListNumbering.js";
+import { assertNewListsAllocated, resolveNewListOperations, stageNewListOperations } from "./newListNumbering.js";
 import { cutsIntoNoteReference, noteReferenceEditsAllowed, noteReferenceOf, noteReferenceSpansWithin, planChangesAroundNoteReferences, segmentsAroundNoteReferences } from "./note-references.js";
 import { classifyResourceReference } from "./referenceClassification.js";
+import { getFolioDocumentOperationRemovedBlockIds, getTrackedFolioDocumentOperationCarrierBlockId, getTrackedFolioDocumentOperationRemovedBlockIds } from "./removed-blocks.js";
 import { separateRevisionStretches } from "./revisionStretches.js";
 import { collectNoteReferenceLabels, hashFolioAIBlockStructuralBoundaries, hashFolioAIBlockText, isHiddenTableRow, normalizeFolioAIBlockText } from "./snapshot.js";
 import { isEmptyTableCell, mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
@@ -58,6 +59,7 @@ import { panic } from "better-result";
 import { Fragment, Mark } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { canSplit } from "prosemirror-transform";
+import { contentRank, groupInsertionRuns, orderBatchOperations } from "@stll/docx-core/ops";
 //#region src/ai-edits/apply.ts
 const coarseWordDiff = (before, after) => {
 	if (before === after) return before.length === 0 ? [] : [{
@@ -428,7 +430,8 @@ const preserveRunFormattingAcrossTrackedStyleChange = ({ allocateRevisionInfo, n
 		revisionIds: []
 	};
 	const previousContext = paragraphRunStyleContext(paragraph, styleResolver);
-	const nextContext = paragraphRunStyleContext(paragraph.type.create(nextParagraphAttrs, paragraph.content, paragraph.marks), styleResolver);
+	const nextParagraph = paragraph.type.create(nextParagraphAttrs, paragraph.content, paragraph.marks);
+	const nextContext = paragraphRunStyleContext(nextParagraph, styleResolver);
 	const representations = selectRunFormattingCarrierRepresentations({
 		doc: tr.doc,
 		from: paragraphPosition + 1,
@@ -444,27 +447,29 @@ const preserveRunFormattingAcrossTrackedStyleChange = ({ allocateRevisionInfo, n
 			marks: representation.node.marks,
 			styleResolver
 		});
-		if (formattingEquals(previousFormatting, readAuthoredRunFormatting({
+		const nextFormatting = readAuthoredRunFormatting({
 			context: nextContext,
 			marks: representation.node.marks,
 			styleResolver
-		}))) continue;
+		});
+		if (formattingEquals(previousFormatting, nextFormatting)) continue;
 		const info = allocateRevisionInfo();
 		const suggestionAttrs = info.provenance === "suggested" && info.suggestionId !== void 0 && info.suggestionId !== null ? {
 			provenance: "suggested",
 			suggestionId: info.suggestionId
 		} : {};
+		const propertyChange = propertyChangeType.create({
+			changes: [{
+				type: "runPropertyChange",
+				info,
+				...Object.keys(previousFormatting).length > 0 && { previousFormatting }
+			}],
+			...suggestionAttrs
+		});
 		applyMarksToRunFormattingRepresentation({
 			tr,
 			representation,
-			marks: propertyChangeType.create({
-				changes: [{
-					type: "runPropertyChange",
-					info,
-					...Object.keys(previousFormatting).length > 0 && { previousFormatting }
-				}],
-				...suggestionAttrs
-			}).addToSet(representation.node.marks)
+			marks: propertyChange.addToSet(representation.node.marks)
 		});
 		revisionIds.push(info.id);
 	}
@@ -535,9 +540,10 @@ const applyBlockParagraphProperties = ({ tr, position, node, properties, styleRe
 		tr,
 		revisionIds: []
 	};
+	const styled = bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs);
 	return {
 		tr: rebaseParagraphRuns({
-			tr: bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs),
+			tr: styled,
 			position,
 			previous: node,
 			styleResolver,
@@ -613,9 +619,10 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		tr,
 		revisionIds: []
 	};
+	const styled = bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs);
 	return {
 		tr: rebaseParagraphRuns({
-			tr: bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs),
+			tr: styled,
 			position: blockPosition,
 			previous: block,
 			styleResolver,
@@ -638,22 +645,30 @@ const patchAuthoredRunFormatting = ({ authoredFormatting, formatting, includedPr
 		if (value === null) Reflect.deleteProperty(next, property);
 		else next[property] = value;
 	}
-	if (formatting.underline !== void 0 && includedFormattingProperty(includedProperties, "underline")) if (formatting.underline === null) delete next.underline;
-	else next.underline = { style: formatting.underline ? "single" : "none" };
+	if (formatting.underline !== void 0 && includedFormattingProperty(includedProperties, "underline")) {
+		if (formatting.underline === null) delete next.underline;
+		else next.underline = { style: formatting.underline ? "single" : "none" };
+	}
 	if (formatting.strike !== void 0 && includedFormattingProperty(includedProperties, "strike")) {
 		delete next.doubleStrike;
 		if (formatting.strike === null) delete next.strike;
 		else next.strike = formatting.strike;
 	}
-	if (formatting.fontFamily !== void 0 && includedFormattingProperty(includedProperties, "fontFamily")) if (formatting.fontFamily === null) delete next.fontFamily;
-	else next.fontFamily = {
-		ascii: formatting.fontFamily,
-		hAnsi: formatting.fontFamily
-	};
-	if (formatting.fontSizePt !== void 0 && includedFormattingProperty(includedProperties, "fontSizePt")) if (formatting.fontSizePt === null) delete next.fontSize;
-	else next.fontSize = formatting.fontSizePt * 2;
-	if (formatting.color !== void 0 && includedFormattingProperty(includedProperties, "color")) if (formatting.color === null) delete next.color;
-	else next.color = { rgb: formatting.color.replace(/^#/u, "").toUpperCase() };
+	if (formatting.fontFamily !== void 0 && includedFormattingProperty(includedProperties, "fontFamily")) {
+		if (formatting.fontFamily === null) delete next.fontFamily;
+		else next.fontFamily = {
+			ascii: formatting.fontFamily,
+			hAnsi: formatting.fontFamily
+		};
+	}
+	if (formatting.fontSizePt !== void 0 && includedFormattingProperty(includedProperties, "fontSizePt")) {
+		if (formatting.fontSizePt === null) delete next.fontSize;
+		else next.fontSize = formatting.fontSizePt * 2;
+	}
+	if (formatting.color !== void 0 && includedFormattingProperty(includedProperties, "color")) {
+		if (formatting.color === null) delete next.color;
+		else next.color = { rgb: formatting.color.replace(/^#/u, "").toUpperCase() };
+	}
 	if (formatting.highlight === false && includedFormattingProperty(includedProperties, "highlight")) delete next.highlight;
 	if (formatting.runShading === false && includedFormattingProperty(includedProperties, "runShading")) delete next.shading;
 	return next;
@@ -675,19 +690,21 @@ const applyInlineFormatting = ({ tr, from, to, formatting, includedProperties, s
 			marks: representation.node.marks,
 			...styleResolver !== void 0 ? { styleResolver } : {}
 		});
+		const nextAuthoredFormatting = patchAuthoredRunFormatting({
+			authoredFormatting,
+			formatting,
+			...includedProperties !== void 0 ? { includedProperties } : {}
+		});
+		const marks = reconcileRunFormattingMarks({
+			authoredFormatting: nextAuthoredFormatting,
+			context: styleContext,
+			node: representation.node,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
 		applyMarksToRunFormattingRepresentation({
 			tr,
 			representation,
-			marks: reconcileRunFormattingMarks({
-				authoredFormatting: patchAuthoredRunFormatting({
-					authoredFormatting,
-					formatting,
-					...includedProperties !== void 0 ? { includedProperties } : {}
-				}),
-				context: styleContext,
-				node: representation.node,
-				...styleResolver !== void 0 ? { styleResolver } : {}
-			})
+			marks
 		});
 	}
 	return tr;
@@ -802,12 +819,13 @@ const applyTrackedInlineFormattingToRanges = ({ tr, schema, doc = tr.doc, ranges
 			hasPendingRunPropertyChange = true;
 			continue;
 		}
+		const nextAuthoredFormatting = patchAuthoredRunFormatting({
+			authoredFormatting: previousFormatting ?? {},
+			formatting,
+			includedProperties
+		});
 		const formattingMarks = reconcileRunFormattingMarks({
-			authoredFormatting: patchAuthoredRunFormatting({
-				authoredFormatting: previousFormatting ?? {},
-				formatting,
-				includedProperties
-			}),
+			authoredFormatting: nextAuthoredFormatting,
 			context: styleContext,
 			node,
 			...styleResolver !== void 0 ? { styleResolver } : {}
@@ -1061,7 +1079,8 @@ const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
 			type: "merge",
 			block,
 			next: item.blockTo,
-			joinsNow: !producesTrackedChanges
+			joinsNow: !producesTrackedChanges,
+			setsProperties: item.operation.mergedParagraphProperties !== void 0
 		};
 		case "deleteBlock": {
 			const at = doc.resolve(block);
@@ -1294,6 +1313,17 @@ const isBatchableParagraphInsertion = (item, mode) => {
 	const isEmptyInsert = insertTexts.length === 1 && insertTexts[0]?.length === 0;
 	return !(mode === "tracked-changes" && item.operation.pageBreakBefore === true && isEmptyInsert);
 };
+const insertionWithLiveAnchor = (item, tr) => {
+	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") panic("Only paragraph insertions have insertion anchors", { operationId: item.operation.id });
+	const mapped = tr.mapping.mapResult(item.blockFrom, 1);
+	const anchor = mapped.deletedAcross ? null : tr.doc.nodeAt(mapped.pos);
+	const paraId = item.blockNode.attrs["paraId"];
+	if (!anchor?.isTextblock || anchor.type !== item.blockNode.type || typeof paraId === "string" && anchor.attrs["paraId"] !== paraId) return null;
+	return {
+		...item,
+		blockNode: anchor
+	};
+};
 /** The comments running across both edges of the table at `tablePosition`: over all of it. */
 const commentsAcrossTable = (doc, tablePosition) => {
 	const table = doc.nodeAt(tablePosition);
@@ -1366,6 +1396,57 @@ const holdsOnlyInsertedContent = (paragraph, revisions) => {
 	return whollyInserted;
 };
 /**
+* Remove the paragraph between `from` and `to`, its content with it but not
+* the range boundaries it holds: those stay where it was, as rejecting a
+* pending paragraph or accepting a deleted one leaves them. With a paragraph
+* after it they open that paragraph, where the joined break leaves them,
+* with any standing between the two; before a table they stand between
+* blocks; ending its container, they close the paragraph before it.
+*/
+const removeParagraph = (tr, from, to) => {
+	const paragraph = tr.doc.nodeAt(from);
+	const kept = paragraph === null ? [] : removeResolvedSubtree(paragraph, {
+		mode: "reject",
+		resolves: () => true
+	}).kept;
+	if (kept.length === 0) return tr.delete(from, to);
+	const at = tr.doc.resolve(from);
+	let followingIndex = at.index() + 1;
+	while (isBlockBoundaryNode(at.parent.maybeChild(followingIndex))) followingIndex++;
+	const following = at.parent.maybeChild(followingIndex);
+	if (following?.type.name === "paragraph") {
+		const between = [];
+		let opening = to;
+		for (let index = at.index() + 1; index < followingIndex; index++) {
+			between.push(at.parent.child(index));
+			opening += at.parent.child(index).nodeSize;
+		}
+		const joined = inlineBoundariesOf(between);
+		if (joined === null) return tr.delete(from, to);
+		return tr.insert(opening + 1, [...kept, ...joined]).delete(from, opening);
+	}
+	if (following !== null) {
+		const comments = kept.filter(carriesCommentAnchor);
+		const between = blockBoundariesOf(kept.filter((node) => !carriesCommentAnchor(node)));
+		if (comments.length === 0) return tr.replaceWith(from, to, between);
+		if (at.nodeBefore?.type.name !== "paragraph") return tr.replaceWith(from + 1, to - 1, kept).setNodeAttribute(from, "pPrMark", null);
+		return tr.replaceWith(from, to, between).insert(from - 1, comments);
+	}
+	return tr.delete(from, to).insert(from - 1, kept);
+};
+/**
+* Empty the paragraph between `from` and `to`, which ends its container and
+* so stays: its content goes, the range boundaries it holds stay in it.
+*/
+const emptyParagraph = (tr, from, to) => {
+	const paragraph = tr.doc.nodeAt(from);
+	const kept = paragraph === null ? [] : removeResolvedSubtree(paragraph, {
+		mode: "reject",
+		resolves: () => true
+	}).kept;
+	return kept.length === 0 ? tr.delete(from + 1, to - 1) : tr.replaceWith(from + 1, to - 1, kept);
+};
+/**
 * How to take back the paragraph at `position` when it is wholly a pending
 * insertion (the break that introduced it inserted, and everything in it
 * inserted text), or `null` when it is not. Such a paragraph goes outright:
@@ -1384,7 +1465,7 @@ const pendingParagraphRetraction = (doc, position) => {
 	const endsItsContainer = paragraphEndsItsContainer(at, paragraph.type.name);
 	if (at.parent.childCount < 2 || endsItsContainer && before?.type.name !== paragraph.type.name) return null;
 	let followingIndex = at.index() + 1;
-	while (at.parent.maybeChild(followingIndex)?.type.name === "blockBookmarkBoundary") followingIndex++;
+	while (isBlockBoundaryNode(at.parent.maybeChild(followingIndex))) followingIndex++;
 	const following = at.parent.maybeChild(followingIndex);
 	if (expectParagraphAttrs(paragraph).pPrMark?.kind === "moveTo" && following?.type.spec["tableRole"] === "table" && holdsOnlyInsertedContent(paragraph, "including-moves")) return { clearBreakAt: null };
 	if (!holdsOnlyInsertedContent(paragraph, "ordinary")) return null;
@@ -1419,6 +1500,60 @@ const holdsOnlyDeletedContent = (paragraph) => {
 	return whollyDeleted;
 };
 /**
+* Where the paragraph at `position` runs on into the next paragraph when its
+* added break is retracted, across the tables between them: the next
+* paragraph's position, or null when no table stands between or one cannot
+* be crossed.
+*
+* Retracting the break puts the paragraph's words in the next paragraph, so
+* a table between them changes sides of those words. That reads the same
+* only when, in each resolution, either the words or the table are gone:
+* words that stay on accepting may cross only a wholly deleted table, and
+* words that stay on rejecting only a wholly inserted one.
+*/
+const paragraphAcrossVanishingTables = (doc, position) => {
+	const paragraph = doc.nodeAt(position);
+	if (paragraph?.type.name !== "paragraph") return null;
+	const $at = doc.resolve(position);
+	const staysOnAccept = !holdsOnlyDeletedContent(paragraph);
+	const staysOnReject = !holdsOnlyInsertedContent(paragraph, "including-moves");
+	let next = position + paragraph.nodeSize;
+	let crossed = false;
+	for (let index = $at.index() + 1; index < $at.parent.childCount; index++) {
+		const node = $at.parent.child(index);
+		if (node.type === paragraph.type) return crossed ? next : null;
+		if (node.type.spec["tableRole"] !== "table" || node.childCount === 0) return null;
+		let deleted = true;
+		let inserted = true;
+		node.forEach((row) => {
+			const { trIns, trDel } = expectTableRowAttrs(row);
+			deleted &&= trDel != null;
+			inserted &&= trIns != null;
+		});
+		if (staysOnAccept && !deleted || staysOnReject && !inserted) return null;
+		next += node.nodeSize;
+		crossed = true;
+	}
+	return null;
+};
+/** The paragraph a retracted added break on `predecessor` runs it into. */
+const retractedBreakTargetPosition = (doc, predecessor) => {
+	const adjacent = predecessor.position + predecessor.node.nodeSize;
+	return paragraphAcrossVanishingTables(doc, predecessor.position) ?? adjacent;
+};
+/**
+* Move the paragraph at `from` to just before `before`, past the tables
+* `paragraphAcrossVanishingTables` found it may cross; returns where it
+* now starts.
+*/
+const moveParagraphPastTables = (tr, from, before) => {
+	const paragraph = tr.doc.nodeAt(from);
+	if (!paragraph) return panic("A paragraph moved past tables vanished", { from });
+	const target = before - paragraph.nodeSize;
+	tr.delete(from, from + paragraph.nodeSize).insert(target, paragraph);
+	return target;
+};
+/**
 * Whether everything after `position` in its container is paragraphs pending
 * deletion: a join there, once accepted, has no words after it.
 */
@@ -1446,12 +1581,22 @@ const hasDeletedContent = (paragraph) => {
 	});
 	return found;
 };
-/** The final paragraph reached by a chain of wholly deleted paragraphs. */
-const deletedFinalParagraphAfter = (at, paragraphTypeName) => {
+/**
+* The final paragraph reached by a chain of wholly deleted paragraphs, and of
+* paragraphs wholly inserted under `insertedBy` (revisions of the running
+* batch) when given.
+*/
+const deletedFinalParagraphAfter = (at, paragraphTypeName, insertedBy) => {
 	let position = at.pos;
 	for (let index = at.index(); index < at.parent.childCount; index++) {
 		const paragraph = at.parent.child(index);
-		if (paragraph.type.name !== paragraphTypeName || !holdsOnlyDeletedContent(paragraph)) return null;
+		if (paragraph.type.name !== paragraphTypeName) return null;
+		const insertedBreak = addedBreakRevisionId(paragraph.attrs["pPrMark"]);
+		if (index < at.parent.childCount - 1 && insertedBreak !== null && insertedBy?.has(insertedBreak) === true && holdsOnlyInsertedContent(paragraph, "ordinary")) {
+			position += paragraph.nodeSize;
+			continue;
+		}
+		if (!holdsOnlyDeletedContent(paragraph)) return null;
 		if (index === at.parent.childCount - 1) return paragraph.attrs["pPrMark"] == null && hasDeletedContent(paragraph) ? position : null;
 		if (!isPlainDeletedPPrMark(paragraph.attrs["pPrMark"])) return null;
 		position += paragraph.nodeSize;
@@ -1537,6 +1682,60 @@ const finalParagraphPredecessor = (doc, at) => {
 	return null;
 };
 /**
+* The paragraph whose break a recorded final deletion retires, if any. A
+* deletion that nothing preceded when it ran keeps its paragraph emptied, as
+* the deletion alone does: a paragraph the batch places before it afterwards
+* (an insertion after a table, a deleted table's predecessor) lands after the
+* deletion and keeps its own break.
+*/
+const retiredFinalBreak = (doc, at, deletion) => deletion.precededWhenDeleted ? finalParagraphPredecessor(doc, at) : null;
+/**
+* The paragraph a direct replay leaves at a container's end when the batch
+* deletes every paragraph back to the container's start or a table.
+*
+* Applied directly, the batch runs right to left: each deleted paragraph that
+* a paragraph precedes goes, and the leftmost of the run is the one emptied
+* and kept, with its own properties. Tracked, the run's breaks are deleted
+* and the container's own last mark stays on the emptied final paragraph, so
+* that paragraph must take the leftmost one's properties for accepting to
+* read the same. Paragraphs and tables an earlier batch deleted are absent
+* from the direct document and are looked past; a table this batch deletes
+* still stands when the run collapses, so the run starts after it.
+*
+* Null when a surviving paragraph precedes the run (its break retires
+* instead) or the run is the emptied paragraph alone.
+*/
+const collapsedFinalRunSource = (doc, at, batchRevisionIds) => {
+	const emptied = doc.nodeAt(at);
+	if (emptied?.type.name !== "paragraph") return null;
+	const $emptied = doc.resolve(at);
+	if (!paragraphEndsItsContainer($emptied, emptied.type.name)) return null;
+	let source = null;
+	let position = at;
+	for (let index = $emptied.index() - 1; index >= 0; index--) {
+		const node = $emptied.parent.child(index);
+		position -= node.nodeSize;
+		if (node.type.spec["tableRole"] === "table") {
+			let deletedEarlier = node.childCount > 0;
+			node.forEach((row) => {
+				const { trDel } = expectTableRowAttrs(row);
+				deletedEarlier &&= trDel != null && !batchRevisionIds.has(trDel.revisionId);
+			});
+			if (deletedEarlier) continue;
+			return source;
+		}
+		if (node.type !== emptied.type) return source;
+		const mark = node.attrs["pPrMark"];
+		if (!isPlainDeletedPPrMark(mark) || !holdsOnlyDeletedContent(node)) return null;
+		const revisionId = addedOrDeletedBreakRevisionId(mark);
+		if (revisionId !== null && batchRevisionIds.has(revisionId)) source = {
+			node,
+			position
+		};
+	}
+	return source;
+};
+/**
 * Whether a sibling between a final carrier's predecessor and the carrier
 * has its break deleted by this batch.
 */
@@ -1561,7 +1760,7 @@ const pendingRemovedFinalBreakPositions = (tr, deletions) => {
 	const positions = /* @__PURE__ */ new Set();
 	for (const deletion of deletions) {
 		const at = tr.mapping.slice(deletion.mappedFrom).map(deletion.position);
-		const predecessor = finalParagraphPredecessor(tr.doc, at);
+		const predecessor = retiredFinalBreak(tr.doc, at, deletion);
 		if (!predecessor || predecessor.node.attrs["pPrMark"] != null) continue;
 		positions.add(predecessor.position);
 	}
@@ -1594,14 +1793,14 @@ const hasDeferredParagraphPropertyWrite = ({ tr, deletions, targets, mergedPrope
 		const at = tr.mapping.slice(deletion.mappedFrom).map(deletion.position);
 		const target = tr.doc.nodeAt(at);
 		if (!target) continue;
-		const predecessor = finalParagraphPredecessor(tr.doc, at);
+		const predecessor = retiredFinalBreak(tr.doc, at, deletion);
 		if (!predecessor) continue;
 		const mark = predecessor.node.attrs["pPrMark"];
 		if (mark == null && mergedPropertyTargets.some(({ position, mappedFrom }) => {
 			const mapped = tr.mapping.slice(mappedFrom).mapResult(position);
 			return !mapped.deleted && mapped.pos === at;
 		})) continue;
-		const writeTarget = mark == null ? target : tr.doc.nodeAt(predecessor.position + predecessor.node.nodeSize);
+		const writeTarget = mark == null ? target : tr.doc.nodeAt(retractedBreakTargetPosition(tr.doc, predecessor));
 		if (!writeTarget || !targets.includes(writeTarget)) continue;
 		if (mark != null && !(addedBreakRevisionId(mark) !== null && canRetractFinalBreak({
 			predecessor: predecessor.node,
@@ -1635,9 +1834,9 @@ const paragraphPropertyRevisionTargets = ({ item, tr, deletedFinalParagraphs })
 	const removedBreakPositions = pendingRemovedFinalBreakPositions(tr, deletedFinalParagraphs);
 	for (const deletion of deletedFinalParagraphs) {
 		const at = tr.mapping.slice(deletion.mappedFrom).map(deletion.position);
-		const predecessor = finalParagraphPredecessor(tr.doc, at);
+		const predecessor = retiredFinalBreak(tr.doc, at, deletion);
 		if (!predecessor || addedBreakRevisionId(predecessor.node.attrs["pPrMark"]) === null) continue;
-		const target = tr.doc.nodeAt(predecessor.position + predecessor.node.nodeSize);
+		const target = tr.doc.nodeAt(retractedBreakTargetPosition(tr.doc, predecessor));
 		if (!target) continue;
 		if (canRetractFinalBreak({
 			predecessor: predecessor.node,
@@ -1685,12 +1884,41 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 		deletion,
 		at: tr.mapping.slice(deletion.mappedFrom).map(deletion.position)
 	})).toSorted((left, right) => right.at - left.at);
-	for (const { deletion: { operationId, revisionExtras }, at } of located) {
+	for (const { deletion, at } of located) {
+		const { operationId, revisionExtras } = deletion;
 		const emptied = tr.doc.nodeAt(at);
 		if (emptied?.type.name !== "paragraph") continue;
-		const predecessor = finalParagraphPredecessor(tr.doc, at);
-		if (!predecessor) continue;
-		const { node: previous, position } = predecessor;
+		const predecessor = retiredFinalBreak(tr.doc, at, deletion);
+		if (!predecessor) {
+			const source = deletion.precededWhenDeleted ? collapsedFinalRunSource(tr.doc, at, batchRevisionIds) : null;
+			if (!source) continue;
+			const revisionId = nextRevisionId;
+			const carried = carryParagraphProperties({
+				tr,
+				position: at,
+				source: source.node,
+				styleResolver,
+				numbering,
+				revision: {
+					id: revisionId,
+					author,
+					date,
+					...revisionExtras
+				},
+				keep: /* @__PURE__ */ new Set()
+			});
+			if (carried.tracked) {
+				nextRevisionId++;
+				addedRevisions.push({
+					operationId,
+					revisionId
+				});
+			}
+			if (carried.changed) resolvedOperationIds.add(operationId);
+			continue;
+		}
+		const { node: previous } = predecessor;
+		let { position } = predecessor;
 		const mark = previous.attrs["pPrMark"];
 		if (mark == null) {
 			const revisionId = nextRevisionId++;
@@ -1735,11 +1963,13 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 			continue;
 		}
 		if (addedBreakRevisionId(mark) !== null) {
-			const following = tr.doc.nodeAt(position + previous.nodeSize);
+			const targetPosition = retractedBreakTargetPosition(tr.doc, predecessor);
+			const following = tr.doc.nodeAt(targetPosition);
 			if (!following || !canRetractFinalBreak({
 				predecessor: previous,
 				target: following
 			})) continue;
+			if (targetPosition !== position + previous.nodeSize) position = moveParagraphPastTables(tr, position, targetPosition);
 			joinAtParagraphMark({
 				tr,
 				paragraphPos: position,
@@ -1750,10 +1980,15 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 			resolvedOperationIds.add(operationId);
 			const retracted = addedBreakRevisionId(mark);
 			if (retracted !== null) retractedRevisionIds.push(retracted);
+			const carryPosition = isDeletedPPrMark(tr.doc.nodeAt(position)?.attrs["pPrMark"]) ? paragraphLeftAfter({
+				doc: tr.doc,
+				paragraphPos: position
+			}) ?? position : position;
+			const carryTarget = tr.doc.nodeAt(carryPosition) ?? following;
 			const revisionId = nextRevisionId;
 			if (carryParagraphProperties({
 				tr,
-				position,
+				position: carryPosition,
 				source: previous,
 				styleResolver,
 				numbering,
@@ -1763,7 +1998,7 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 					date,
 					...revisionExtras
 				},
-				keep: propertiesSetInBatch(following, batchRevisionIds)
+				keep: propertiesSetInBatch(carryTarget, batchRevisionIds)
 			}).tracked) {
 				nextRevisionId++;
 				addedRevisions.push({
@@ -1819,26 +2054,38 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 	const supersededDeletedBreaks = [];
 	const collectSupersededDeletedBreaks = (parent, contentStart) => {
 		let previous = null;
+		let carriedDeletedMark = null;
+		let carriedDeletedFormatting = null;
 		parent.forEach((node, offset) => {
 			const position = contentStart + offset;
 			if (node.type.name !== "paragraph") {
 				previous = null;
+				carriedDeletedMark = null;
+				carriedDeletedFormatting = null;
 				if (!node.isTextblock && node.childCount > 0) collectSupersededDeletedBreaks(node, position + 1);
 				return;
 			}
 			if (previous) {
-				const deletedMark = previous.node.attrs["pPrMark"];
+				const deletedMark = carriedDeletedMark ?? previous.node.attrs["pPrMark"];
 				const insertedMark = node.attrs["pPrMark"];
 				const insertedRevisionId = addedBreakRevisionId(insertedMark);
 				const trackedInsertion = insertedRevisionId !== null && batchRevisionIds.has(insertedRevisionId);
 				const suggestedInsertion = isSuggestedParagraphInsert(node);
 				const deletedBreakRevisionId = addedOrDeletedBreakRevisionId(deletedMark);
-				if (isPlainDeletedPPrMark(deletedMark) && deletedBreakRevisionId !== null && !batchRevisionIds.has(deletedBreakRevisionId) && !holdsOnlyDeletedContent(previous.node) && (trackedInsertion || suggestedInsertion) && holdsOnlyInsertedContent(node, "ordinary")) supersededDeletedBreaks.push({
-					preceding: previous.position,
-					inserted: position,
-					deletedMark,
-					precedingMark: trackedInsertion ? insertedMark : null
-				});
+				if (isPlainDeletedPPrMark(deletedMark) && deletedBreakRevisionId !== null && !batchRevisionIds.has(deletedBreakRevisionId) && !holdsOnlyDeletedContent(previous.node) && (trackedInsertion || suggestedInsertion) && holdsOnlyInsertedContent(node, "ordinary")) {
+					supersededDeletedBreaks.push({
+						preceding: previous.position,
+						inserted: position,
+						deletedMark,
+						precedingMark: trackedInsertion ? insertedMark : null,
+						precedingFormatting: carriedDeletedFormatting ?? paragraphPropertiesOnReject(previous.node)
+					});
+					carriedDeletedMark = deletedMark;
+					carriedDeletedFormatting ??= paragraphPropertiesOnReject(previous.node);
+				} else {
+					carriedDeletedMark = null;
+					carriedDeletedFormatting = null;
+				}
 			}
 			previous = {
 				node,
@@ -1847,24 +2094,26 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 		});
 	};
 	collectSupersededDeletedBreaks(tr.doc, 0);
-	for (const { preceding, inserted, deletedMark, precedingMark } of supersededDeletedBreaks) {
+	for (const { preceding, inserted, deletedMark, precedingMark, precedingFormatting } of supersededDeletedBreaks) {
 		const insertionRevisionId = addedBreakRevisionId(precedingMark);
 		if (insertionRevisionId !== null) {
 			const previous = tr.doc.nodeAt(preceding);
 			const current = tr.doc.nodeAt(inserted);
 			if (!previous || !current) panic("A shifted paragraph break lost its carrier");
-			const previousFormatting = paragraphPropertiesOnReject(previous);
 			const existing = expectParagraphAttrs(current)._propertyChanges;
-			if (!hasSerializableParagraphPropertyChange(existing) && JSON.stringify(previousFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(current))) tr.setNodeAttribute(inserted, "_propertyChanges", [...Array.isArray(existing) ? existing : [], {
-				type: "paragraphPropertyChange",
-				info: {
-					id: insertionRevisionId,
-					author,
-					date,
-					...initials ? { initials } : {}
-				},
-				previousFormatting
-			}]);
+			if (hasSerializableParagraphPropertyChange(existing) || JSON.stringify(precedingFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(current))) {
+				const inverse = {
+					type: "paragraphPropertyChange",
+					info: {
+						id: insertionRevisionId,
+						author,
+						date,
+						...initials ? { initials } : {}
+					},
+					previousFormatting: precedingFormatting
+				};
+				tr.setNodeAttribute(inserted, "_propertyChanges", [inverse]);
+			}
 		}
 		tr.setNodeAttribute(preceding, "pPrMark", precedingMark);
 		tr.setNodeAttribute(inserted, "pPrMark", deletedMark);
@@ -2020,6 +2269,7 @@ const restyledListAttrs = ({ attrs, styleNumbering, removesNumbering, numbering
 	};
 };
 const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove, numbering, styleResolver }) => {
+	assertNewListsAllocated(item.operation);
 	const operation = item.operation;
 	if (operation.type !== "insertAfterBlock" && operation.type !== "insertBeforeBlock") panic("Only paragraph insertions can build inserted paragraphs", { type: operation.type });
 	const insertionType = schema.marks["insertion"];
@@ -2035,6 +2285,7 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 	const formatsEveryParagraph = operation.formattingScope === "allParagraphs";
 	const baseAttrs = operation.inheritFormatting === false ? {} : {
 		...stripBlockIdentityAttrs(item.blockNode.attrs),
+		_preservedAttributes: null,
 		_propertyChanges: null,
 		pPrMark: null,
 		_suggestedInsert: null
@@ -2189,12 +2440,13 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 				reconciled.push(child);
 				return;
 			}
+			const authoredFormatting = readAuthoredRunFormatting({
+				context: sourceContext,
+				marks: child.marks,
+				styleResolver
+			});
 			const reconciledMarks = reconcileRunFormattingMarks({
-				authoredFormatting: readAuthoredRunFormatting({
-					context: sourceContext,
-					marks: child.marks,
-					styleResolver
-				}),
+				authoredFormatting,
 				context: targetContext,
 				node: child,
 				styleResolver
@@ -2259,7 +2511,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 	};
 	const styleResolver = getDocumentStyleResolver(view.state);
 	const styleDefinitions = getDocumentStyleDefinitions(view.state);
-	const { operations, numbering } = resolveNewListOperations(requestedOperations, getDocumentNumbering(view.state));
+	const operations = stageNewListOperations(requestedOperations);
+	let numbering = getDocumentNumbering(view.state);
 	const formattingFromStyleForInsertion = (item) => {
 		if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return;
 		const anchorAttrs = expectParagraphAttrs(item.blockNode);
@@ -2274,6 +2527,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 	const claimedTableRows = /* @__PURE__ */ new Set();
 	const claimedTableColumns = /* @__PURE__ */ new Set();
 	const batchClaims = new BatchClaims();
+	const removedBlocksBy = /* @__PURE__ */ new Map();
 	const diffText = wordDiffMode === "coarse" ? coarseWordDiff : wordDiffSessionFromOptions(wordDiff).diff;
 	const producesTrackedChanges = mode !== "direct";
 	const isSuggested = mode === "suggested";
@@ -2370,6 +2624,29 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				continue;
 			}
 		}
+		const targetBlockId = "range" in operation ? operation.range.blockId : operation.blockId;
+		const removedBy = ![
+			"insertAfterBlock",
+			"insertBeforeBlock",
+			"insertSignatureTable",
+			"insertTable",
+			"deleteTable",
+			"insertTableRow",
+			"deleteTableRow",
+			"insertTableColumn",
+			"deleteTableColumn",
+			"mergeTableCells",
+			"splitTableCell"
+		].includes(operation.type) ? removedBlocksBy.get(targetBlockId) : void 0;
+		const continuesMergeChain = operation.type === "mergeBlockWithNext" && removedBy?.type === "mergeBlockWithNext";
+		if (removedBy !== void 0 && !continuesMergeChain) {
+			skipped.push({
+				id: operation.id,
+				reason: "overlappingOperation",
+				message: `operation ${JSON.stringify(removedBy.id)}, earlier in this batch, already claims its target.`
+			});
+			continue;
+		}
 		const claim = batchClaimOf({
 			item: resolution.operation,
 			doc: view.state.doc,
@@ -2385,6 +2662,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			continue;
 		}
 		batchClaims.add(operation.id, claim);
+		const carrierBlockId = producesTrackedChanges ? getTrackedFolioDocumentOperationCarrierBlockId(snapshot.blocks, requestedOperations[index] ?? panic("A planned operation lost its input", { index }), removedBlocksBy) : void 0;
+		const getRemovedBlockIds = producesTrackedChanges ? getTrackedFolioDocumentOperationRemovedBlockIds : getFolioDocumentOperationRemovedBlockIds;
+		const requestedOperation = requestedOperations[index] ?? panic("A planned operation lost its input", { index });
+		for (const removedBlockId of getRemovedBlockIds(snapshot.blocks, requestedOperation)) if (!removedBlocksBy.has(removedBlockId)) removedBlocksBy.set(removedBlockId, {
+			id: operation.id,
+			type: operation.type
+		});
+		if (carrierBlockId !== void 0) removedBlocksBy.delete(carrierBlockId);
 		if (deletion) claimedTableRows.add(`${deletion.tablePosition}:${deletion.rowIndex}`);
 		if (columnDeletion) claimedTableColumns.add(getTableColumnCoordinateKey(columnDeletion));
 		if ((operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock") && operation.lineBreakMode !== "inline" && LINE_BREAK_PATTERN.test(operation.text)) normalizations.push({
@@ -2423,8 +2708,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 		else counts.to += 1;
 		moveSideCounts.set(moveId, counts);
 	}
+	const refusedMoveIds = /* @__PURE__ */ new Set();
+	if (isSuggested) for (const candidate of executableResolved) {
+		if (candidate.operation.type !== "insertBeforeBlock" || candidate.operation.moveId === void 0) continue;
+		const moveId = candidate.operation.moveId;
+		if (executableResolved.some(({ operation, blockFrom }) => operation.type === "deleteBlock" && operation.moveId === moveId && blockFrom === candidate.blockFrom)) refusedMoveIds.add(moveId);
+	}
 	const isPairedMove = (moveId) => {
-		if (moveId === void 0) return false;
+		if (moveId === void 0 || refusedMoveIds.has(moveId)) return false;
 		const counts = moveSideCounts.get(moveId);
 		return counts?.from === 1 && counts.to === 1;
 	};
@@ -2479,40 +2770,76 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			if (afterTables.get(item.blockFrom)?.has(item.blockTo)) tableAfterDeletedSplit.set(item.blockFrom, commentsAcrossBlockBoundary(view.state.doc, item.blockTo));
 		}
 	}
-	const executionOrder = executableResolved.toSorted((left, right) => {
-		if (left.blockFrom === right.blockFrom && tableAfterDeletedSplit.has(left.blockFrom)) {
-			if (left.operation.type === "deleteBlock" && right.operation.type === "insertTable" && right.from === left.blockTo) return -1;
-			if (left.operation.type === "insertTable" && right.operation.type === "deleteBlock" && left.from === right.blockTo) return 1;
-		}
-		const leftAnnotates = ANNOTATION_OPERATION_TYPES.has(left.operation.type);
-		if (leftAnnotates !== ANNOTATION_OPERATION_TYPES.has(right.operation.type)) return leftAnnotates ? -1 : 1;
-		const leftCellShape = left.tableCellMerge ?? left.tableCellSplit;
-		const rightCellShape = right.tableCellMerge ?? right.tableCellSplit;
-		if (!leftCellShape && rightCellShape) return -1;
-		if (leftCellShape && !rightCellShape) return 1;
-		if (leftCellShape && rightCellShape) {
-			if (leftCellShape.tablePosition !== rightCellShape.tablePosition) return rightCellShape.tablePosition - leftCellShape.tablePosition;
-			if (leftCellShape.rectangle.bottom !== rightCellShape.rectangle.bottom) return rightCellShape.rectangle.bottom - leftCellShape.rectangle.bottom;
-			if (leftCellShape.rectangle.right !== rightCellShape.rectangle.right) return rightCellShape.rectangle.right - leftCellShape.rectangle.right;
-			return compareBatchTieOrder(left.originalIndex, right.originalIndex);
-		}
-		const leftColumn = left.tableColumnInsertion ?? left.tableColumnDeletion;
-		const rightColumn = right.tableColumnInsertion ?? right.tableColumnDeletion;
-		if (!leftColumn && rightColumn) return -1;
-		if (leftColumn && !rightColumn) return 1;
-		if (leftColumn && rightColumn) {
-			if (leftColumn.tablePosition !== rightColumn.tablePosition) return rightColumn.tablePosition - leftColumn.tablePosition;
-			if (leftColumn.columnIndex !== rightColumn.columnIndex) return rightColumn.columnIndex - leftColumn.columnIndex;
-			const leftIsInsertion = left.tableColumnInsertion !== void 0;
-			if (leftIsInsertion !== (right.tableColumnInsertion !== void 0)) return leftIsInsertion ? -1 : 1;
-			return compareBatchTieOrder(left.originalIndex, right.originalIndex);
-		}
-		if (left.from !== right.from) return right.from - left.from;
-		return compareBatchTieOrder(left.originalIndex, right.originalIndex);
-	});
-	for (let executionIndex = 0; executionIndex < executionOrder.length; executionIndex++) {
-		const item = executionOrder[executionIndex];
-		if (!item) panic("The operation execution index exceeded the resolved plan", { executionIndex });
+	const batchAddress = (item) => {
+		const cell = item.tableCellMerge ?? item.tableCellSplit;
+		if (cell) return {
+			type: "cell",
+			tablePosition: cell.tablePosition,
+			bottom: cell.rectangle.bottom,
+			right: cell.rectangle.right,
+			inputIndex: item.originalIndex
+		};
+		const column = item.tableColumnInsertion ?? item.tableColumnDeletion;
+		if (column) return {
+			type: "column",
+			tablePosition: column.tablePosition,
+			columnIndex: column.columnIndex,
+			insertion: item.tableColumnInsertion !== void 0,
+			inputIndex: item.originalIndex
+		};
+		if (ANNOTATION_OPERATION_TYPES.has(item.operation.type)) return {
+			type: "annotation",
+			position: item.from,
+			inputIndex: item.originalIndex
+		};
+		const hasDeletedSplit = tableAfterDeletedSplit.has(item.blockFrom);
+		return {
+			type: "content",
+			position: hasDeletedSplit && item.operation.type === "deleteBlock" ? item.blockTo : item.from,
+			rank: contentRank(item.operation, { hasDeletedSplit }),
+			inputIndex: item.originalIndex
+		};
+	};
+	const executionOrder = orderBatchOperations(executableResolved, batchAddress);
+	const allocateNewLists = ({ items }) => {
+		const allocated = resolveNewListOperations(items.map(({ operation }) => operation), numbering);
+		numbering = allocated.numbering;
+		for (const [index, candidate] of items.entries()) candidate.operation = allocated.operations[index] ?? panic("A will-apply operation lost its new-list allocation", { id: candidate.operation.id });
+	};
+	const executionGroups = groupInsertionRuns(executionOrder, (candidate) => isBatchableParagraphInsertion(candidate, mode) ? candidate.from : null, (candidate) => candidate.operation.type === "setBlockParagraphProperties");
+	for (const executionGroup of executionGroups) {
+		const insertionState = tr;
+		const insertionRun = executionGroup.flatMap((candidate) => {
+			if (candidate.operation.type !== "insertAfterBlock" && candidate.operation.type !== "insertBeforeBlock") return [candidate];
+			const liveCandidate = insertionWithLiveAnchor(candidate, insertionState);
+			if (!liveCandidate) {
+				if (!isSuggested) return [candidate];
+				if (candidate.operation.moveId !== void 0) refusedMoveIds.add(candidate.operation.moveId);
+				skipped.push({
+					id: candidate.operation.id,
+					reason: isSuggested ? "pendingDeletion" : "missingBlock"
+				});
+				return [];
+			}
+			if (isSuggested) {
+				const blockFrom = insertionState.mapping.map(candidate.blockFrom, 1);
+				if (isPendingDeletion(insertionState.doc, blockFrom, liveCandidate.blockNode, buildCleanBlockText(liveCandidate.blockNode, blockFrom, {
+					fieldResults: "text",
+					noteReferences
+				}).text)) {
+					if (candidate.operation.moveId !== void 0) refusedMoveIds.add(candidate.operation.moveId);
+					skipped.push({
+						id: candidate.operation.id,
+						reason: "pendingDeletion"
+					});
+					return [];
+				}
+			}
+			return [liveCandidate];
+		});
+		if (insertionRun.length === 0) continue;
+		const item = insertionRun.at(0);
+		if (!item) panic("The operation execution group was empty");
 		continueSharedRevisionIds();
 		if (mode === "tracked-changes" && writesParagraphPropertyChange(item)) {
 			const appliedIds = new Set(applied.map(({ id }) => id));
@@ -2538,52 +2865,47 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				continue;
 			}
 		}
-		if (isBatchableParagraphInsertion(item, mode)) {
-			const insertionRun = [item];
-			for (let lookahead = executionIndex + 1; lookahead < executionOrder.length; lookahead++) {
-				const candidate = executionOrder[lookahead];
-				if (!candidate || candidate.from !== item.from || !isBatchableParagraphInsertion(candidate, mode)) break;
-				insertionRun.push(candidate);
-			}
-			if (insertionRun.length > 1) {
-				const nodeGroups = [];
-				const runApplied = [];
-				for (const insertion of insertionRun) {
-					const insertionSuggestionId = isSuggested ? insertion.operation.suggestionId ?? insertion.operation.id : null;
-					const built = buildInsertedParagraphs({
-						item: insertion,
-						schema: view.state.schema,
-						formattingFromStyle: formattingFromStyleForInsertion(insertion),
-						mode,
-						author,
-						date,
-						initials,
-						commentMark: null,
-						suggestionId: insertionSuggestionId,
-						revisionSeed,
-						isPairedMove,
-						numbering,
-						styleResolver
-					});
-					revisionSeed = built.nextRevisionId;
-					claimSharedRevisionIds(revisionSeed);
-					nodeGroups.push(built.nodes);
-					runApplied.push({
-						id: insertion.operation.id,
-						...built.revisionIds[0] !== void 0 && {
-							revisionId: built.revisionIds[0],
-							revisionIds: built.revisionIds
-						},
-						...insertionSuggestionId !== null && { suggestionId: insertionSuggestionId }
-					});
-				}
-				const nodes = [];
-				for (const group of nodeGroups.toReversed()) for (const node of group) nodes.push(node);
-				tr = tr.insert(item.from, nodes);
-				applied.push(...runApplied);
-				executionIndex += insertionRun.length - 1;
-				continue;
+		if (insertionRun.length > 1) {
+			allocateNewLists({
+				status: "willApply",
+				items: insertionRun
+			});
+			const nodeGroups = [];
+			const runApplied = [];
+			for (const insertion of insertionRun) {
+				const insertionSuggestionId = isSuggested ? insertion.operation.suggestionId ?? insertion.operation.id : null;
+				const built = buildInsertedParagraphs({
+					item: insertion,
+					schema: view.state.schema,
+					formattingFromStyle: formattingFromStyleForInsertion(insertion),
+					mode,
+					author,
+					date,
+					initials,
+					commentMark: null,
+					suggestionId: insertionSuggestionId,
+					revisionSeed,
+					isPairedMove,
+					numbering,
+					styleResolver
+				});
+				revisionSeed = built.nextRevisionId;
+				claimSharedRevisionIds(revisionSeed);
+				nodeGroups.push(built.nodes);
+				runApplied.push({
+					id: insertion.operation.id,
+					...built.revisionIds[0] !== void 0 && {
+						revisionId: built.revisionIds[0],
+						revisionIds: built.revisionIds
+					},
+					...insertionSuggestionId !== null && { suggestionId: insertionSuggestionId }
+				});
 			}
+			const nodes = [];
+			for (const group of nodeGroups.toReversed()) for (const node of group) nodes.push(node);
+			tr = tr.insert(item.from, nodes);
+			applied.push(...runApplied);
+			continue;
 		}
 		const provisionalCommentId = item.commentText !== void 0 ? reserveProvisionalCommentId() : void 0;
 		const commentMark = provisionalCommentId !== void 0 && commentType ? commentType.create({ commentId: provisionalCommentId }) : null;
@@ -2941,16 +3263,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			}
 			case "insertAfterBlock":
 			case "insertBeforeBlock": {
-				if (isSuggested && isPendingDeletion(tr.doc, item.blockFrom, item.blockNode, buildCleanBlockText(item.blockNode, item.blockFrom, {
-					fieldResults: "text",
-					noteReferences
-				}).text)) {
-					skipped.push({
-						id: item.operation.id,
-						reason: "pendingDeletion"
-					});
-					continue;
-				}
+				allocateNewLists({
+					status: "willApply",
+					items: [item]
+				});
+				assertNewListsAllocated(item.operation);
 				const built = buildInsertedParagraphs({
 					item,
 					schema: view.state.schema,
@@ -3231,7 +3548,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				}
 				if (mode === "direct") {
 					const at = tr.doc.resolve(item.blockFrom);
-					tr = !paragraphEndsItsContainer(at, item.blockNode.type.name) || at.nodeBefore?.type.name === item.blockNode.type.name ? tr.delete(item.blockFrom, item.blockTo) : tr.delete(item.blockFrom + 1, item.blockTo - 1);
+					tr = !paragraphEndsItsContainer(at, item.blockNode.type.name) || at.nodeBefore?.type.name === item.blockNode.type.name ? removeParagraph(tr, item.blockFrom, item.blockTo) : emptyParagraph(tr, item.blockFrom, item.blockTo);
 					break;
 				}
 				const retraction = isPairedMove(item.operation.moveId) ? null : pendingParagraphRetraction(tr.doc, item.blockFrom);
@@ -3244,7 +3561,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						continue;
 					}
 					const retracted = tr.doc.nodeAt(item.blockFrom);
-					tr = tr.delete(item.blockFrom, item.blockTo);
+					tr = removeParagraph(tr, item.blockFrom, item.blockTo);
 					if (retraction.clearBreakAt !== null) {
 						tr = tr.setNodeAttribute(retraction.clearBreakAt, "pPrMark", null);
 						const revisionIdProperties = operationRevisionSeed;
@@ -3298,8 +3615,12 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					const inlineRevisionApplied = item.from < item.to || atomRanges.length > 0;
 					appliedRevisionIds = inlineRevisionApplied ? [revisionId] : [];
-					const markPosition = tr.mapping.map(item.blockFrom);
-					const endsItsContainer = paragraphEndsItsContainer(tr.doc.resolve(markPosition), item.blockNode.type.name);
+					let markPosition = tr.mapping.map(item.blockFrom);
+					const markOwner = tr.doc.nodeAt(markPosition);
+					const across = markOwner && !isPairedMove(item.operation.moveId) && addedBreakRevisionId(markOwner.attrs["pPrMark"]) !== null ? paragraphAcrossVanishingTables(tr.doc, markPosition) : null;
+					if (across !== null) markPosition = moveParagraphPastTables(tr, markPosition, across);
+					const markPlace = tr.doc.resolve(markPosition);
+					const endsItsContainer = paragraphEndsItsContainer(markPlace, item.blockNode.type.name);
 					const deleted = tr.doc.nodeAt(markPosition);
 					const following = deleted && paragraphJoinAfter(tr.doc, markPosition + deleted.nodeSize)?.next;
 					if (deleted && following?.type === deleted.type && !isPairedMove(item.operation.moveId) && addedBreakRevisionId(deleted.attrs["pPrMark"]) !== null) {
@@ -3345,14 +3666,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						appliedRevisionIds = inlineRevisionApplied ? [revisionId, markRevisionId] : [markRevisionId];
 					} else if (endsItsContainer && !isPairedMove(item.operation.moveId)) deletedFinalParagraphs.push({
 						operationId: item.operation.id,
+						precededWhenDeleted: finalParagraphPredecessor(tr.doc, markPosition) !== null,
 						position: markPosition,
 						mappedFrom: tr.mapping.maps.length,
 						revisionExtras: trackedRevisionExtras
 					});
 					else if (deleted && !isPairedMove(item.operation.moveId) && isPlainDeletedPPrMark(deleted.attrs["pPrMark"]) && holdsOnlyDeletedContent(deleted)) {
-						const finalPosition = deletedFinalParagraphAfter(tr.doc.resolve(markPosition), deleted.type.name);
+						const finalPosition = deletedFinalParagraphAfter(tr.doc.resolve(markPosition), deleted.type.name, new Set(applied.flatMap(({ revisionIds }) => revisionIds ?? [])));
 						if (finalPosition !== null) deletedFinalParagraphs.push({
 							operationId: item.operation.id,
+							precededWhenDeleted: true,
 							position: finalPosition,
 							mappedFrom: tr.mapping.maps.length,
 							revisionExtras: trackedRevisionExtras
@@ -3533,6 +3856,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					continue;
 				}
+				allocateNewLists({
+					status: "willApply",
+					items: [item]
+				});
+				assertNewListsAllocated(item.operation);
 				const appliedProperties = applyBlockParagraphProperties({
 					tr,
 					position: blockPosition,
@@ -3560,16 +3888,22 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			}
 			case "splitBlock": {
 				const splitsFromItsTextBoxes = textBoxAnchorIdsBetween(tr.doc, item.blockFrom, item.from).size > 0 && endOfParagraphWithItsTextBoxes(tr.doc, item.blockFrom) > item.blockTo;
-				if (mode === "direct") {
-					if (item.to > item.from) tr = tr.delete(item.from, item.to);
-					tr = tr.split(item.from);
-					if (splitsFromItsTextBoxes) gatherTextBoxesAfterParagraph(tr, item.blockFrom);
-				} else if (splitsFromItsTextBoxes) {
+				if (mode !== "direct" && splitsFromItsTextBoxes) {
 					skipped.push({
 						id: item.operation.id,
 						reason: "unsupportedBlock"
 					});
 					continue;
+				}
+				allocateNewLists({
+					status: "willApply",
+					items: [item]
+				});
+				assertNewListsAllocated(item.operation);
+				if (mode === "direct") {
+					if (item.to > item.from) tr = tr.delete(item.from, item.to);
+					tr = tr.split(item.from);
+					if (splitsFromItsTextBoxes) gatherTextBoxesAfterParagraph(tr, item.blockFrom);
 				} else {
 					const revisionIdMark = operationRevisionSeed++;
 					const info = {
@@ -3653,10 +3987,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					continue;
 				}
+				allocateNewLists({
+					status: "willApply",
+					items: [item]
+				});
+				assertNewListsAllocated(item.operation);
 				const separator = followedOnlyByDeletedParagraphs(tr.doc, blockTo) ? "" : item.operation.separator ?? "";
 				const insertAt = blockTo - 1;
 				let mergedPropertiesAt = blockFrom;
 				let mergedPropertiesRecorded = false;
+				let mergedPropertiesApplied = false;
 				const second = join.next;
 				const spanningComments = commentsAcrossBlockBoundary(tr.doc, blockTo);
 				const withSeparator = (transaction) => {
@@ -3699,6 +4039,18 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					if (joined && sectionPropertiesOf(joined) !== secondSection) tr = tr.setNodeAttribute(blockFrom, "_sectionProperties", secondSection);
 					const endingMark = second ? expectParagraphAttrs(second).pPrMark : null;
 					if (joined && (endingMark?.kind === "del" || endingMark?.kind === "moveFrom")) {
+						if (item.operation.mergedParagraphProperties) {
+							const ending = tr.doc.nodeAt(blockFrom) ?? joined;
+							tr = applyBlockParagraphProperties({
+								tr,
+								position: blockFrom,
+								node: ending,
+								properties: item.operation.mergedParagraphProperties,
+								styleResolver,
+								numbering
+							}).tr;
+							mergedPropertiesApplied = true;
+						}
 						const survivor = paragraphLeftAfter({
 							doc: tr.doc,
 							paragraphPos: blockFrom
@@ -3706,7 +4058,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						if (survivor !== null) tr = carryParagraphProperties({
 							tr,
 							position: survivor,
-							source: joined,
+							source: tr.doc.nodeAt(blockFrom) ?? joined,
 							styleResolver,
 							numbering,
 							revision: endingMark.info
@@ -3795,7 +4147,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						mergedPropertiesAt = survivorPos;
 					}
 				}
-				if (item.operation.mergedParagraphProperties) {
+				if (item.operation.mergedParagraphProperties && !mergedPropertiesApplied) {
 					const mergedParagraph = tr.doc.nodeAt(mergedPropertiesAt);
 					if (!mergedParagraph) panic("A resolved merge did not produce a paragraph");
 					const appliedProperties = applyBlockParagraphProperties({
@@ -3821,10 +4173,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				});
 				break;
 			}
-			case "commentOnBlock":
-				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
-				break;
-			default: break;
+			case "commentOnBlock": if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 		}
 		if (commentPlan !== null) tr = applyAlignedReplacementComments({
 			tr,
@@ -4043,18 +4392,27 @@ const insertCleanText = ({ tr, from, to, text, standsInFor, keepsReplacedText =
 	const annotations = surveyReplacedAnnotations(tr.doc, from, to);
 	const carried = standsInFor ? surveyReplacedAnnotations(tr.doc, standsInFor.from, standsInFor.to).carried : [];
 	const replaced = keepsReplacedText ? commentsForTrackedInsertion(tr.doc, from, [carried])[0] ?? [] : carried;
-	if (!hasReplacedAnnotations(annotations) && replaced.length === 0 && !hasCleanTextControls(text)) return {
-		transaction: tr.insertText(text, from, to),
-		start: from,
-		end: from + text.length
-	};
+	const baseMarks = (tr.selection.from === from && tr.selection.to === to ? tr.storedMarks : null) ?? inheritedReplacementMarks(tr.doc, from, to);
+	if (!hasReplacedAnnotations(annotations) && replaced.length === 0 && !hasCleanTextControls(text)) {
+		if (text.length === 0) return {
+			transaction: tr.delete(from, to),
+			start: from,
+			end: from
+		};
+		const replacement = tr.doc.type.schema.text(text, baseMarks);
+		return {
+			transaction: tr.replaceWith(from, to, replacement),
+			start: from,
+			end: from + text.length
+		};
+	}
 	const schema = tr.doc.type.schema;
 	const { fragment, leadingSize, contentSize } = annotatedReplacement({
 		annotations,
 		content: Fragment.fromArray(cleanTextInlineNodes({
 			schema,
 			text,
-			marks: addCarriedMarks(inheritedReplacementMarks(tr.doc, from, to), replaced)
+			marks: addCarriedMarks(baseMarks, replaced)
 		}))
 	});
 	const start = from + leadingSize;
@@ -4436,23 +4794,6 @@ const applyAlignedReplacementComments = ({ tr, source, item, plan, stepsBefore,
 		for (const comment of comments) if (comment.isInSet(expected)) tr.addMark(from, from + 1, comment);
 		else tr.removeMark(from, from + 1, comment);
 	}
-	const visible = /* @__PURE__ */ new Set();
-	const points = /* @__PURE__ */ new Set();
-	tr.doc.descendants((node) => {
-		if (node.type.name === "rangeAnchor") {
-			const attrs = readRangeAnchorAttrs(node);
-			if (attrs.ok && attrs.value.start.type === "commentRangeStart") points.add(attrs.value.start.id);
-		}
-		if (!node.isInline || isZeroWidthAnchor(node) || node.marks.some((mark) => mark.type.name === "deletion")) return;
-		for (const mark of node.marks) if (mark.type.name === "comment") visible.add(mark.attrs["commentId"]);
-	});
-	const at = clean.offsets[plan.spanStart];
-	if (at === void 0) panic("Replacement lost its start gap");
-	for (const comment of comments) {
-		const id = comment.attrs["commentId"];
-		if (visible.has(id) || points.has(id)) continue;
-		tr.insert(at, commentPoint(tr.doc.type.schema, id));
-	}
 	return tr;
 };
 /**
@@ -4715,6 +5056,7 @@ const applyMinimalTrackedReplacement = ({ tr, item, noteReferences, replacement,
 			nextTr = nextTr.addMark(run.at, end, insertion);
 			if (commentMark) nextTr = nextTr.addMark(run.at, end, commentMark);
 		}
+		if (removedFrom !== null) nextTr = joinCommentStretches(nextTr, removedFrom);
 	}
 	return {
 		type: "applied",
@@ -4970,10 +5312,11 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 		};
 	}
 	if (operation.type === "insertTableRow") {
+		const position = operation.position ?? "after";
 		const insertion = findTableRowInsertion({
 			doc,
 			blockFrom,
-			position: operation.position ?? "after"
+			position
 		});
 		if (!insertion) return {
 			type: "skip",
@@ -5028,10 +5371,11 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 		};
 	}
 	if (operation.type === "insertTableColumn") {
+		const position = operation.position ?? "after";
 		const insertion = findTableColumnInsertion({
 			doc,
 			blockFrom,
-			position: operation.position ?? "after"
+			position
 		});
 		if (!insertion) return {
 			type: "skip",
@@ -5523,7 +5867,7 @@ const describeUndefinedParagraphStyle = ({ path, styleId, definedAs }, definitio
 	return `${path} "${styleId}" ${definedAs === void 0 ? "names no style in this document" : `names a ${definedAs} style, not a paragraph style`} (${available}).`;
 };
 /** The `w:num` id a stated numbering names, when it names one. */
-const statedNumberingInstance = (numbering) => numbering?.kind === "reference" ? numbering.numId : void 0;
+const statedNumberingInstance = (numbering) => numbering?.kind === "reference" && isNumberingReference(numbering.numId) ? numbering.numId : void 0;
 /**
 * Every numbering instance an operation names, with the field that names it.
 * Only reference variants name an instance; inheritance, cancellation and level-only do not.
@@ -5582,4 +5926,4 @@ const getOperationQuote = (operation) => {
 	if (operation.type === "commentOnBlock") return operation.quote;
 };
 //#endregion
-export { applyFolioAIEditOperations, previewFolioAIEditOperations, previewFolioAIEditOperationsWithResult };
+export { applyFolioAIEditOperations, insertCleanText, previewFolioAIEditOperations, previewFolioAIEditOperationsWithResult };