@stll/folio-core 0.52.0 → 0.54.0

package/dist/ai-edits/apply.js

@@ -1,38 +1,55 @@
 import { paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { formattingEquals } from "../docx/runConsolidator.js";
-import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { isStyleSourcedParagraphNumbering } from "../internal/paragraphFormattingSerialization.js";
+import { deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween } from "../prosemirror/anchoredTextBoxes.js";
+import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs, expectTableRowAttrs } from "../prosemirror/attrs/index.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "../prosemirror/commands/propertyChangeScope.js";
+import { resolveParagraphChangeAttrs } from "../prosemirror/commands/resolveParagraphProperties.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../prosemirror/containerFinalParagraph.js";
 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/TextBoxAnchorExtension.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../prosemirror/listMarker.js";
-import { paragraphNumberingAttr, readParagraphNumberingAttr } from "../prosemirror/numberingAttr.js";
+import { paragraphNumberingAttr, readParagraphNumberingAttr, removedNumberingAttr } from "../prosemirror/numberingAttr.js";
 import { directParagraphAlignment } from "../prosemirror/paragraphAlignment.js";
+import { styleResolvedParagraphFormatting } from "../prosemirror/paragraphFormattingProvenance.js";
 import { directParagraphIndentation, paragraphIndentationAttrPatch, paragraphIndentationEqual, paragraphIndentationFromFormatting, withDirectParagraphIndentation } from "../prosemirror/paragraphIndentation.js";
+import { joinAtParagraphMark } from "../prosemirror/paragraphMarkJoin.js";
+import { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties } from "../prosemirror/paragraphPropertyCarry.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqual, paragraphSpacingFromFormatting, withDirectParagraphSpacing } from "../prosemirror/paragraphSpacing.js";
-import { getDocumentNumbering } from "../prosemirror/plugins/documentNumbering.js";
-import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
-import { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, surveyReplacedAnnotations } from "../prosemirror/replacedAnnotations.js";
+import { getDocumentNumbering, getDocumentNumberingInstanceIds } from "../prosemirror/plugins/documentNumbering.js";
+import { getDocumentStyleDefinitions, getDocumentStyleResolver } from "../prosemirror/plugins/documentStyleState.js";
+import { rebaseParagraphRuns } from "../prosemirror/rebaseParagraphRuns.js";
+import { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, 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, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
-import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
-import { listLevelAttrPatch } from "../prosemirror/styles/resolvedStyleAttrs.js";
+import { paragraphRunStyleContext, paragraphRunStyleContextAt, resolveParagraphBodyRunFormatting } from "../prosemirror/runStyleFormatting.js";
+import { sectionPropertiesOf } from "../prosemirror/sectionCarrier.js";
+import { listAttrsFromNumbering, listLevelAttrPatch } from "../prosemirror/styles/resolvedStyleAttrs.js";
+import { removeRowsWithoutCellsAfterBatch } from "../prosemirror/tableGridMutation.js";
 import { isZeroWidthAnchor } from "../prosemirror/zeroWidthAnchors.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.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, planTextChanges, widenChangesToAtomicSpans } from "./minimal-replacement.js";
-import { hashFolioAIBlockStructuralBoundaries, hashFolioAIBlockText, isHiddenTableRow, normalizeFolioAIBlockText } from "./snapshot.js";
-import { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
+import { applyTextChanges, changesFromSegments, keepAtomicSpans, planTextChanges, widenChangesToAtomicSpans } from "./minimal-replacement.js";
+import { concreteListReference, resolveNewListOperations } from "./newListNumbering.js";
+import { cutsIntoNoteReference, noteReferenceEditsAllowed, noteReferenceOf, noteReferenceSpansWithin, planChangesAroundNoteReferences, segmentsAroundNoteReferences } from "./note-references.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";
 import { planTableMutations } from "./table-mutation-plan.js";
-import { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, markTableRowContent, splitCellParagraphTexts } from "./table-row-column-mutations.js";
+import { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, describeUnplacedCellTexts, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, markTableRowContent, splitCellParagraphTexts } from "./table-row-column-mutations.js";
 import { findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBoundary, tableRectangleCutsMergedCell } from "./table-targets.js";
 import { tableFromTemplate } from "./table-template.js";
 import { wordDiffSessionFromOptions } from "./word-diff.js";
 import { panic } from "better-result";
-import { Fragment } from "prosemirror-model";
+import { Fragment, Mark } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { canJoin, canSplit } from "prosemirror-transform";
 //#region src/ai-edits/apply.ts
@@ -109,6 +126,12 @@ const SUGGESTED_SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
 	"insertTableColumn",
 	"deleteTableColumn"
 ]);
+/** Operations that only add marks: they move no position of the document. */
+const ANNOTATION_OPERATION_TYPES = /* @__PURE__ */ new Set([
+	"formatRange",
+	"commentOnRange",
+	"commentOnBlock"
+]);
 const REPLACE_BLOCK_IMPACT = {
 	text: {
 		changesStyle: false,
@@ -167,6 +190,7 @@ const paragraphPropertiesPatch = ({ node, properties, resolvedFormattingFromStyl
 	const styleChanged = nextStyleId !== void 0 && (attrs.styleId ?? null) !== nextStyleId;
 	if (styleChanged) {
 		patch["styleId"] = nextStyleId;
+		patch["_resolvedFormatting"] = styleResolvedParagraphFormatting(resolvedFormattingFromStyle);
 		patch["alignmentFromStyle"] = resolvedFormattingFromStyle?.alignment;
 		if (properties.alignment === void 0) patch["alignment"] = currentDirectAlignment ?? resolvedFormattingFromStyle?.alignment ?? null;
 		if (properties.spacing === void 0) Object.assign(patch, paragraphSpacingAttrPatch({
@@ -182,25 +206,42 @@ const paragraphPropertiesPatch = ({ node, properties, resolvedFormattingFromStyl
 		else originalFormatting.styleId = nextStyleId;
 		if (currentDirectAlignment !== void 0) originalFormatting.alignment = currentDirectAlignment;
 		originalFormattingChanged = true;
+		patch["outlineLevel"] = attrs._originalFormatting?.outlineLevel ?? resolvedFormattingFromStyle?.outlineLevel ?? null;
+		Object.assign(patch, restyledListAttrs({
+			attrs: { ...attrs },
+			styleNumbering: resolvedFormattingFromStyle?.numPr,
+			removesNumbering: false,
+			numbering
+		}));
+	}
+	if (properties.outlineLevel !== void 0) {
+		const directOutlineLevel = properties.outlineLevel ?? void 0;
+		originalFormatting ??= {};
+		if (directOutlineLevel === void 0) Reflect.deleteProperty(originalFormatting, "outlineLevel");
+		else originalFormatting.outlineLevel = directOutlineLevel;
+		patch["outlineLevel"] = directOutlineLevel ?? resolvedFormattingFromStyle?.outlineLevel ?? null;
+		originalFormattingChanged = true;
 	}
+	const numPrFromStyle = styleChanged ? readParagraphNumberingAttr(patch["numPrFromStyle"]) : attrs.numPrFromStyle;
 	if (properties.numbering !== void 0) if (properties.numbering === null) {
-		patch["numPr"] = null;
+		patch["numPr"] = removedNumberingAttr(numPrFromStyle);
 		Object.assign(patch, CLEARED_LIST_RENDERING_ATTRS);
 	} else {
+		const listReference = concreteListReference(properties.numbering);
 		Object.assign(patch, listLevelAttrPatch(attrs, {
-			numId: properties.numbering.numId,
-			ilvl: properties.numbering.level
+			numId: listReference.numId,
+			ilvl: listReference.level
 		}, numbering));
 		if (properties.listLevel === null) {
-			patch["numPr"] = paragraphNumberingAttr(paragraphNumberingReference({ numId: properties.numbering.numId }));
+			patch["numPr"] = paragraphNumberingAttr(paragraphNumberingReference({ numId: listReference.numId }));
 			patch["numPrFromStyle"] = null;
 		}
 	}
 	else if (properties.listLevel !== void 0) if (properties.listLevel === null) {
-		patch["numPr"] = null;
+		patch["numPr"] = removedNumberingAttr(numPrFromStyle);
 		Object.assign(patch, CLEARED_LIST_RENDERING_ATTRS);
 	} else {
-		const numId = paragraphNumberingReferenceId(readParagraphNumberingAttr(node.attrs["numPr"]) ?? void 0);
+		const numId = paragraphNumberingReferenceId(readParagraphNumberingAttr(styleChanged ? patch["numPr"] : node.attrs["numPr"]) ?? void 0);
 		if (numId === void 0) {
 			patch["numPr"] = paragraphNumberingAttr({
 				kind: "levelOnly",
@@ -242,6 +283,24 @@ const paragraphPropertiesPatch = ({ node, properties, resolvedFormattingFromStyl
 	return Object.keys(patch).length > 0 ? patch : null;
 };
 const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
+const hasOrdinaryTextRevision = (block) => {
+	let found = false;
+	block.descendants((node) => {
+		if (node.marks.some((mark) => REVISION_MARK_NAMES.has(mark.type.name) && mark.attrs["provenance"] !== "suggested")) {
+			found = true;
+			return false;
+		}
+		return true;
+	});
+	return found;
+};
+const hasOrdinaryParagraphMarkRevision = (block) => {
+	const mark = block.attrs["pPrMark"];
+	if (typeof mark !== "object" || mark === null || !("info" in mark)) return false;
+	const info = mark.info;
+	if (typeof info !== "object" || info === null) return false;
+	return !("provenance" in info) || info.provenance !== "suggested";
+};
 /**
 * Strip insertion and deletion marks from the zero-width anchors the batch
 * touched.
@@ -251,10 +310,12 @@ const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
 * must keep its existing revision ownership. Marking is by range everywhere;
 * the guard lives here once rather than at every call site.
 */
-const withoutRevisionsOnZeroWidthAnchors = (tr, batchRevisionIds) => {
+const withoutRevisionsOnZeroWidthAnchors = (tr, batchRevisionIds, deletedTextBoxAnchorIds) => {
 	const anchors = [];
 	tr.doc.descendants((node, pos) => {
 		if (!isZeroWidthAnchor(node)) return true;
+		const textBoxAnchorId = textBoxAnchorIdOf(node);
+		if (textBoxAnchorId !== void 0 && deletedTextBoxAnchorIds.has(textBoxAnchorId)) return false;
 		const marks = node.marks.filter(({ attrs, type }) => REVISION_MARK_NAMES.has(type.name) && batchRevisionIds.has(attrs["revisionId"]));
 		if (marks.length > 0) anchors.push({
 			from: pos,
@@ -272,7 +333,9 @@ const withoutRevisionsOnZeroWidthAnchors = (tr, batchRevisionIds) => {
 *
 * Skips what is already deleted, so an earlier revision's run is not marked
 * twice, and skips zero-width anchors because the operation did not create or
-* delete them; their existing revision ownership must remain unchanged.
+* delete them; their existing revision ownership must remain unchanged. A
+* text box's anchor is the exception: it stands for the box's drawing run,
+* which is the paragraph's content, and the box follows it.
 */
 const undeletedContentAtomRanges = (tr, blockFrom) => {
 	const position = tr.mapping.map(blockFrom);
@@ -280,7 +343,7 @@ const undeletedContentAtomRanges = (tr, blockFrom) => {
 	if (!block?.isTextblock) return [];
 	const ranges = [];
 	block.forEach((child, offset) => {
-		if (child.isText || isZeroWidthAnchor(child) || child.marks.some(({ type }) => type.name === "deletion")) return;
+		if (child.isText || isZeroWidthAnchor(child) && child.type.name !== "textBoxAnchor" || child.marks.some(({ type }) => type.name === "deletion")) return;
 		const from = position + 1 + offset;
 		ranges.push({
 			from,
@@ -289,13 +352,23 @@ const undeletedContentAtomRanges = (tr, blockFrom) => {
 	});
 	return ranges;
 };
-/** The carrier pPr before this batch changed it, for final-mark rotation. */
-const paragraphPropertiesBeforeBatch = (node, batchRevisionIds) => {
+/**
+* The carrier pPr before any pending change to it, for final-mark rotation.
+*
+* A paragraph added after the carrier copies its pending property change, as
+* a break typed at a paragraph's end does: rejecting the addition leaves the
+* added paragraph (its mark is the one that stays), so that change is what
+* gives the carrier's words back the properties they had.
+*/
+const paragraphPropertiesBeforePendingChanges = (node) => {
 	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
-	if (!Array.isArray(propertyChanges)) return paragraphPropertiesSnapshot(node);
-	const earliestBatchChange = propertyChanges.find(({ info }) => batchRevisionIds.has(info.id));
-	if (!earliestBatchChange) return paragraphPropertiesSnapshot(node);
-	return earliestBatchChange.previousFormatting ?? {};
+	const earliest = Array.isArray(propertyChanges) ? propertyChanges[0] : void 0;
+	return earliest === void 0 ? paragraphPropertiesSnapshot(node) : earliest.previousFormatting ?? {};
+};
+/** The pPr rejecting every pending change of a paragraph's properties leaves. */
+const paragraphPropertiesOnReject = (node) => {
+	const [earliest] = expectParagraphAttrs(node)._propertyChanges ?? [];
+	return earliest ? earliest.previousFormatting ?? {} : paragraphPropertiesSnapshot(node);
 };
 const resolveFormattingFromStyle = ({ attrs, styleId, styleResolver }) => {
 	const resolved = styleResolver?.resolveParagraphStyle(styleId).paragraphFormatting;
@@ -368,6 +441,7 @@ const preserveRunFormattingAcrossTrackedStyleChange = ({ allocateRevisionInfo, n
 * the change left alone from one it explicitly cleared when rejecting it.
 */
 const applyBlockParagraphProperties = ({ tr, position, node, properties, styleResolver, numbering = null, revisionInfo }) => {
+	const storedMarks = tr.storedMarks ?? tr.selection.$from.marks();
 	const attrs = expectParagraphAttrs(node);
 	const resolvedFormattingFromStyle = properties.styleId === void 0 ? resolveFormattingFromStyle({
 		attrs,
@@ -390,6 +464,12 @@ const applyBlockParagraphProperties = ({ tr, position, node, properties, styleRe
 		revisionId: null,
 		revisionIds: []
 	};
+	const nextStyleId = properties.styleId === void 0 ? attrs.styleId : properties.styleId;
+	if ((attrs.styleId ?? null) !== (nextStyleId ?? null)) patch["defaultTextFormatting"] = resolveParagraphBodyRunFormatting({
+		styleId: properties.styleId ?? void 0,
+		tableRunFormatting: attrs._tableRunFormatting,
+		styleResolver
+	}).defaultFormatting ?? null;
 	const changeInfo = revisionInfo?.();
 	const change = changeInfo ? {
 		type: "paragraphPropertyChange",
@@ -414,12 +494,25 @@ const applyBlockParagraphProperties = ({ tr, position, node, properties, styleRe
 		revisionIds: []
 	};
 	return {
-		tr: bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs),
+		tr: rebaseParagraphRuns({
+			tr: bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs),
+			position,
+			previous: node,
+			styleResolver,
+			storedMarks
+		}),
 		changed: true,
 		revisionId: change?.info.id ?? null,
 		revisionIds: change ? [change.info.id, ...bridgeResult.revisionIds] : []
 	};
 };
+/** No inherited formatting: every run-formatting mark reads as authored. */
+const OPERATION_TEXT_CONTEXT = {
+	baseParagraphFormatting: void 0,
+	paragraphFormatting: void 0,
+	paragraphMarkFormatting: void 0,
+	paragraphMarkPrecedesStyle: false
+};
 const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) => {
 	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return {
 		tr,
@@ -433,6 +526,7 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		revisionId: null,
 		revisionIds: []
 	};
+	const storedMarks = tr.storedMarks ?? tr.selection.$from.marks();
 	const attrs = expectParagraphAttrs(block);
 	const resolvedFormattingFromStyle = resolveFormattingFromStyle({
 		attrs,
@@ -449,6 +543,11 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		revisionId: null,
 		revisionIds: []
 	};
+	if ((attrs.styleId ?? null) !== item.operation.styleId) patch["defaultTextFormatting"] = resolveParagraphBodyRunFormatting({
+		styleId: item.operation.styleId ?? void 0,
+		tableRunFormatting: attrs._tableRunFormatting,
+		styleResolver
+	}).defaultFormatting ?? null;
 	const existing = attrs._propertyChanges;
 	const changeInfo = revisionInfo?.();
 	const change = changeInfo ? {
@@ -473,7 +572,13 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		revisionIds: []
 	};
 	return {
-		tr: bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs),
+		tr: rebaseParagraphRuns({
+			tr: bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs),
+			position: blockPosition,
+			previous: block,
+			styleResolver,
+			storedMarks
+		}),
 		revisionId: change?.info.id ?? null,
 		revisionIds: change ? [change.info.id, ...bridgeResult.revisionIds] : []
 	};
@@ -747,10 +852,14 @@ let revisionIdCursor = Date.now() * 1e3;
 */
 const collectLiveBlocksByHash = (doc) => {
 	const byHash = /* @__PURE__ */ new Map();
+	const noteReferences = collectNoteReferenceLabels(doc);
 	doc.descendants((node, pos) => {
 		if (isHiddenTableRow(node)) return false;
 		if (!node.isTextblock) return true;
-		const cleanText = buildCleanBlockText(node, pos).text;
+		const cleanText = buildCleanBlockText(node, pos, {
+			fieldResults: "text",
+			noteReferences
+		}).text;
 		const hash = hashFolioAIBlockText(normalizeFolioAIBlockText(cleanText));
 		const bucket = byHash.get(hash) ?? [];
 		bucket.push({
@@ -804,6 +913,211 @@ const getTableMutationPlanTarget = (item) => {
 	return { type: "none" };
 };
 /**
+* `insertion`, resolved against the document as it was read, placed through
+* what `tr` has already changed. The batch runs from the end backwards, so
+* nothing it has applied yet sits before the new row; mapped all the same, so
+* that stays true of the positions the row is written at and not only of the
+* order they are visited in. A row another operation of the batch inserted
+* at the same boundary is the later one in input order, so the new row goes
+* before it.
+*/
+const mapTableRowInsertion = (tr, insertion) => {
+	const tableStart = tr.mapping.map(insertion.tableStart, -1);
+	return {
+		...insertion,
+		tableStart,
+		rowPosition: tr.mapping.map(insertion.rowPosition, -1),
+		rowspanUpdates: insertion.rowspanUpdates.map((update) => tr.mapping.map(insertion.tableStart + update, 1) - tableStart)
+	};
+};
+/** The cells a column deletion removes: every cell standing in that column alone. */
+const deletedColumnCellRanges = (doc, { tablePosition, columnIndex }) => {
+	const table = doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return [];
+	const map = TableMap.get(table);
+	const tableStart = tablePosition + 1;
+	const ranges = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let row = 0; row < map.height; row++) {
+		const relative = map.map[row * map.width + columnIndex];
+		if (relative === void 0 || seen.has(relative)) continue;
+		seen.add(relative);
+		const rectangle = map.findCell(relative);
+		const cell = table.nodeAt(relative);
+		if (!cell || rectangle.left !== columnIndex || rectangle.right !== columnIndex + 1) continue;
+		ranges.push({
+			from: tableStart + relative,
+			to: tableStart + relative + cell.nodeSize
+		});
+	}
+	return ranges;
+};
+/** A row deletion also changes cells whose vertical merge began above it. */
+const deletedRowAffectedRanges = ({ doc, deletion, row }) => {
+	const ranges = [{
+		from: deletion.rowPosition,
+		to: deletion.rowPosition + row.nodeSize
+	}];
+	const table = doc.nodeAt(deletion.tablePosition);
+	if (table?.type.spec["tableRole"] !== "table") return panic("A resolved row deletion lost its table", { position: deletion.tablePosition });
+	const map = TableMap.get(table);
+	const seen = /* @__PURE__ */ new Set();
+	for (let column = 0; column < map.width; column++) {
+		const relative = map.map[deletion.rowIndex * map.width + column];
+		if (relative === void 0 || seen.has(relative)) continue;
+		seen.add(relative);
+		const position = deletion.tableStart + relative;
+		if (position >= deletion.rowPosition) continue;
+		const cell = table.nodeAt(relative);
+		if (cell) ranges.push({
+			from: position,
+			to: position + cell.nodeSize
+		});
+	}
+	return ranges;
+};
+/**
+* The blank cells a merge folds into the first cell of its rectangle. Only a
+* blank cell can fold away tracked, so an edit that fills one decides whether
+* the merge applies in one mode and not the other; see `batch-claims.ts`. A
+* cell with content folds directly and is refused tracked whatever the batch
+* does inside it.
+*/
+const foldedBlankCellRanges = (doc, { tablePosition, rectangle }) => {
+	const table = doc.nodeAt(tablePosition);
+	if (table?.type.spec["tableRole"] !== "table") return panic("A resolved cell merge lost its table", { position: tablePosition });
+	const map = TableMap.get(table);
+	const tableStart = tablePosition + 1;
+	const kept = map.map[rectangle.top * map.width + rectangle.left];
+	return map.cellsInRect(rectangle).flatMap((relative) => {
+		const cell = relative === kept ? null : table.nodeAt(relative);
+		return cell && isEmptyTableCell(cell) ? [{
+			from: tableStart + relative,
+			to: tableStart + relative + cell.nodeSize
+		}] : [];
+	});
+};
+/** What `item` claims of the document its batch resolved against; see `batch-claims.ts`. */
+const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
+	const block = item.blockFrom;
+	switch (item.operation.type) {
+		case "replaceInBlock":
+		case "replaceRange": return {
+			type: "text",
+			block,
+			from: item.from,
+			to: item.to
+		};
+		case "formatRange":
+		case "commentOnRange":
+		case "commentOnBlock": return {
+			type: "annotation",
+			block,
+			from: item.from,
+			to: item.to
+		};
+		case "splitBlock": return {
+			type: "split",
+			block,
+			from: item.from,
+			to: item.to
+		};
+		case "replaceBlock": return item.replaceBlockImpact === "style" ? {
+			type: "paragraphProperties",
+			block
+		} : {
+			type: "rewriteBlock",
+			block
+		};
+		case "setBlockParagraphProperties": return {
+			type: "paragraphProperties",
+			block
+		};
+		case "mergeBlockWithNext": return {
+			type: "merge",
+			block,
+			next: item.blockTo,
+			joinsNow: !producesTrackedChanges
+		};
+		case "deleteBlock": {
+			const at = doc.resolve(block);
+			const endsItsContainer = paragraphEndsItsContainer(at, item.blockNode.type.name);
+			const keepsParagraph = producesTrackedChanges ? endsItsContainer : endsItsContainer && at.nodeBefore?.type.name !== item.blockNode.type.name;
+			return {
+				type: "deleteBlock",
+				block,
+				end: item.blockTo,
+				keepsParagraph
+			};
+		}
+		case "insertAfterBlock":
+		case "insertBeforeBlock":
+		case "insertSignatureTable":
+		case "insertTable": return {
+			type: "insertion",
+			at: item.from
+		};
+		case "deleteTable": {
+			const deleted = item.deletedTable;
+			return deleted ? {
+				type: "tableRemoval",
+				table: deleted.position,
+				wholeTable: true,
+				axis: "table",
+				ranges: [{
+					from: deleted.position,
+					to: deleted.position + deleted.node.nodeSize
+				}]
+			} : { type: "unclaimed" };
+		}
+		case "deleteTableRow": {
+			const deletion = item.tableRowDeletion;
+			const row = deletion ? doc.nodeAt(deletion.rowPosition) : null;
+			const table = deletion ? doc.nodeAt(deletion.tablePosition) : null;
+			return deletion && row && table?.type.spec["tableRole"] === "table" ? {
+				type: "tableRemoval",
+				table: deletion.tablePosition,
+				wholeTable: table.childCount === 1,
+				axis: "row",
+				ranges: table.childCount === 1 ? [{
+					from: deletion.tablePosition,
+					to: deletion.tablePosition + table.nodeSize
+				}] : deletedRowAffectedRanges({
+					doc,
+					deletion,
+					row
+				})
+			} : { type: "unclaimed" };
+		}
+		case "deleteTableColumn": {
+			const deletion = item.tableColumnDeletion;
+			return deletion ? {
+				type: "tableRemoval",
+				table: deletion.tablePosition,
+				wholeTable: false,
+				axis: "column",
+				ranges: deletedColumnCellRanges(doc, deletion)
+			} : { type: "unclaimed" };
+		}
+		case "insertTableRow":
+		case "insertTableColumn":
+		case "mergeTableCells":
+		case "splitTableCell": {
+			const target = getTableMutationPlanTarget(item);
+			let axis = "cell";
+			if (item.operation.type === "insertTableRow") axis = "row";
+			if (item.operation.type === "insertTableColumn") axis = "column";
+			if (target.type === "none") return { type: "unclaimed" };
+			return {
+				type: "tableStructure",
+				table: target.tablePosition,
+				axis,
+				folded: target.type === "mergeCells" ? foldedBlankCellRanges(doc, target) : []
+			};
+		}
+	}
+};
+/**
 * The snapshot recorded an `hashOccurrenceCount` per anchor but
 * not which ordinal within that bucket the block was — recompute
 * on demand from the snapshot's anchor map. Stable iteration
@@ -956,6 +1270,94 @@ const isBatchableParagraphInsertion = (item, mode) => {
 	const isEmptyInsert = insertTexts.length === 1 && insertTexts[0]?.length === 0;
 	return !(mode === "tracked-changes" && item.operation.pageBreakBefore === true && isEmptyInsert);
 };
+/** The comments running across both edges of the table at `tablePosition`: over all of it. */
+const commentsAcrossTable = (doc, tablePosition) => {
+	const table = doc.nodeAt(tablePosition);
+	if (!table) return [];
+	const atEnd = commentsAcrossBlockBoundary(doc, tablePosition + table.nodeSize);
+	return commentsAcrossBlockBoundary(doc, tablePosition).filter((comment) => comment.isInSet(atEnd));
+};
+/** `comments` over the inline content of the node at `position`, which an insertion just placed. */
+const addCommentsOver = (tr, position, comments) => {
+	const node = tr.doc.nodeAt(position);
+	if (!node || !comments) return tr;
+	let next = tr;
+	for (const comment of comments) next = next.addMark(position + 1, position + node.nodeSize - 1, comment);
+	return next;
+};
+const insertBlocksInsideComments = ({ tr, at, blocks, carriedComments }) => {
+	const spanning = carriedComments ?? commentsAcrossBlockBoundary(tr.doc, at);
+	const fragment = Fragment.from(blocks);
+	let next = tr.insert(at, fragment);
+	for (const comment of spanning) next = next.addMark(at, at + fragment.size, comment);
+	return next;
+};
+/** A paragraph mark that is a pending insertion (not a relocation's end). */
+const isInsertedPPrMark = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "ins";
+const isSuggestedParagraphInsert = (paragraph) => typeof paragraph.attrs["_suggestedInsert"] === "object" && paragraph.attrs["_suggestedInsert"] !== null;
+/** A paragraph mark that is a pending deletion, or a relocation's source. */
+const isDeletedPPrMark = (value) => typeof value === "object" && value !== null && "kind" in value && (value.kind === "del" || value.kind === "moveFrom");
+const hasRevisionMarker = (value) => typeof value === "object" && value !== null && "revisionId" in value;
+const isDeletedCell = (cell) => {
+	const marker = cell.attrs["cellMarker"];
+	return typeof marker === "object" && marker !== null && "kind" in marker && marker.kind === "del";
+};
+/**
+* Whether accepting every change removes the paragraph at `blockFrom` whole:
+* its paragraph mark and all of its text pending deletion (`cleanText`, the
+* accepted reading, is empty), or the table row or cell holding it pending
+* deletion. A reader lists such a paragraph as a blank block.
+*
+* Word keeps a paragraph whose mark is deleted joined to the next one: text
+* typed into it stays inserted there, and accepting runs it into the next
+* paragraph (or, in a deleted row, takes it away with the row). An operation
+* that asks for the paragraph to read something cannot get that without
+* rejecting the deletion, which is the reviewer's call, not a side effect.
+*/
+const isPendingDeletion = (doc, blockFrom, paragraph, cleanText) => {
+	if (cleanText.length === 0 && isDeletedPPrMark(paragraph.attrs["pPrMark"])) return true;
+	const $block = doc.resolve(blockFrom);
+	for (let depth = $block.depth; depth > 0; depth -= 1) {
+		const ancestor = $block.node(depth);
+		const name = ancestor.type.name;
+		if (name === "tableRow" && hasRevisionMarker(ancestor.attrs["trDel"])) return true;
+		if ((name === "tableCell" || name === "tableHeader") && isDeletedCell(ancestor)) return true;
+	}
+	return false;
+};
+/** Whether every piece of the paragraph's content is pending inserted text. */
+const holdsOnlyInsertedContent = (paragraph) => {
+	let whollyInserted = true;
+	paragraph.descendants((node) => {
+		if (!whollyInserted) return false;
+		if (!node.isInline || isZeroWidthAnchor(node)) return true;
+		whollyInserted = node.marks.some((mark) => mark.type.name === "insertion" && mark.attrs["moveKind"] !== "moveTo");
+		return false;
+	});
+	return whollyInserted;
+};
+/**
+* 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:
+* accepting and rejecting both leave it out.
+*
+* The inserted break is the paragraph's own (an `ins` mark, or a suggested
+* whole-paragraph insert), except on the paragraph that ends its container:
+* that one keeps the container's original mark and the inserted break was
+* rotated onto the paragraph before it, whose `ins` mark then goes too.
+*/
+const pendingParagraphRetraction = (doc, position) => {
+	const paragraph = doc.nodeAt(position);
+	if (paragraph?.type.name !== "paragraph" || !holdsOnlyInsertedContent(paragraph)) return null;
+	const at = doc.resolve(position);
+	const before = at.nodeBefore;
+	const endsItsContainer = paragraphEndsItsContainer(at, paragraph.type.name);
+	if (at.parent.childCount < 2 || endsItsContainer && before?.type.name !== paragraph.type.name) return null;
+	if (isInsertedPPrMark(paragraph.attrs["pPrMark"]) || isSuggestedParagraphInsert(paragraph)) return { clearBreakAt: null };
+	if (endsItsContainer && before && paragraph.attrs["pPrMark"] == null) return isInsertedPPrMark(before.attrs["pPrMark"]) ? { clearBreakAt: position - before.nodeSize } : null;
+	return null;
+};
 const addedBreakRevisionId = (value) => {
 	if (typeof value !== "object" || value === null || !("kind" in value) || !("info" in value)) return null;
 	if (value.kind !== "ins" && value.kind !== "moveTo") return null;
@@ -963,6 +1365,277 @@ const addedBreakRevisionId = (value) => {
 	if (typeof info !== "object" || info === null || !("id" in info)) return null;
 	return typeof info.id === "number" ? info.id : null;
 };
+/** The revision id of a paragraph mark that says its break was added or deleted. */
+const addedOrDeletedBreakRevisionId = (value) => {
+	if (typeof value !== "object" || value === null || !("kind" in value) || !("info" in value)) return null;
+	if (value.kind !== "del") return addedBreakRevisionId(value);
+	const info = value.info;
+	if (typeof info !== "object" || info === null || !("id" in info)) return null;
+	return typeof info.id === "number" ? info.id : null;
+};
+/** Whether every piece of the paragraph's content is pending deleted text (or it has none). */
+const holdsOnlyDeletedContent = (paragraph) => {
+	let whollyDeleted = true;
+	paragraph.descendants((node) => {
+		if (!whollyDeleted) return false;
+		if (!node.isInline || isZeroWidthAnchor(node)) return true;
+		whollyDeleted = node.marks.some((mark) => mark.type.name === "deletion");
+		return false;
+	});
+	return whollyDeleted;
+};
+/**
+* Whether everything after `position` in its container is paragraphs pending
+* deletion: a join there, once accepted, has no words after it.
+*/
+const followedOnlyByDeletedParagraphs = (doc, position) => {
+	const at = doc.resolve(position);
+	let deletes = false;
+	for (let index = at.index(); index < at.parent.childCount; index++) {
+		const node = at.parent.child(index);
+		if (node.type.name !== "paragraph" || !holdsOnlyDeletedContent(node)) return false;
+		deletes ||= node.content.size > 0 || isPlainDeletedPPrMark(node.attrs["pPrMark"]);
+	}
+	return deletes;
+};
+/** A paragraph mark that is a plain pending deletion (not a relocation's source). */
+const isPlainDeletedPPrMark = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "del";
+/** An emptied paragraph still carries deleted content, rather than being an original blank. */
+const hasDeletedContent = (paragraph) => {
+	let found = false;
+	paragraph.descendants((node) => {
+		if (node.isInline && node.marks.some((mark) => mark.type.name === "deletion")) {
+			found = true;
+			return false;
+		}
+		return !found;
+	});
+	return found;
+};
+/** The final paragraph reached by a chain of wholly deleted paragraphs. */
+const deletedFinalParagraphAfter = (at, paragraphTypeName) => {
+	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 (index === at.parent.childCount - 1) return paragraph.attrs["pPrMark"] == null && hasDeletedContent(paragraph) ? position : null;
+		if (!isPlainDeletedPPrMark(paragraph.attrs["pPrMark"])) return null;
+		position += paragraph.nodeSize;
+	}
+	return null;
+};
+/**
+* Where the added break of the final paragraph at `at` rotates to: the free
+* mark `addedBreakCarrierBefore` finds, or else a paragraph the batch deletes
+* whole, whose deleted break the added one cancels (`cancelsDeletedBreak`).
+* A table whose rows all share one insertion revision from this batch is not
+* a barrier: rejecting that table removes it before the paragraphs join.
+* Existing and partially inserted tables remain barriers.
+* The cancelling paragraph must be followed directly by the paragraph its
+* words run into.
+*/
+const finalBreakCarrierBefore = (at, paragraphTypeName, batchRevisionIds) => {
+	const free = addedBreakCarrierBefore({
+		at,
+		paragraphTypeName,
+		canCrossTable: (table) => {
+			if (table.childCount === 0) return false;
+			let revisionId;
+			for (let index = 0; index < table.childCount; index++) {
+				const row = table.child(index);
+				if (row.type.spec["tableRole"] !== "row") return false;
+				const { trIns, trDel } = expectTableRowAttrs(row);
+				if (!trIns || trDel || !batchRevisionIds.has(trIns.revisionId)) return false;
+				revisionId ??= trIns.revisionId;
+				if (trIns.revisionId !== revisionId) return false;
+			}
+			return true;
+		}
+	});
+	if (free) return {
+		...free,
+		cancelsDeletedBreak: false
+	};
+	let position = at.pos;
+	for (let index = at.index() - 1; index >= 0; index--) {
+		const sibling = at.parent.child(index);
+		position -= sibling.nodeSize;
+		if (sibling.type.name !== paragraphTypeName) {
+			if (sibling.type.spec["tableRole"] === "table") return null;
+			continue;
+		}
+		const mark = sibling.attrs["pPrMark"];
+		const revisionId = addedBreakRevisionId(mark);
+		if (revisionId !== null && batchRevisionIds.has(revisionId)) continue;
+		const deletedBreakId = isPlainDeletedPPrMark(mark) ? addedOrDeletedBreakRevisionId(mark) : null;
+		return deletedBreakId !== null && batchRevisionIds.has(deletedBreakId) && holdsOnlyDeletedContent(sibling) && at.parent.maybeChild(index + 1)?.type.name === paragraphTypeName ? {
+			position,
+			node: sibling,
+			cancelsDeletedBreak: true
+		} : null;
+	}
+	return null;
+};
+/** The preceding paragraph whose break a final deletion can retire. */
+const finalParagraphPredecessor = (doc, at) => {
+	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 position = at;
+	for (let index = $emptied.index() - 1; index >= 0; index--) {
+		const node = $emptied.parent.child(index);
+		position -= node.nodeSize;
+		if (node.type !== emptied.type) return null;
+		if (isPlainDeletedPPrMark(node.attrs["pPrMark"]) && holdsOnlyDeletedContent(node)) continue;
+		return {
+			node,
+			position
+		};
+	}
+	return null;
+};
+/** Pending retirements, read after the merge has mapped any inserted separator. */
+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);
+		if (!predecessor || predecessor.node.attrs["pPrMark"] != null) continue;
+		positions.add(predecessor.position);
+	}
+	return positions;
+};
+/**
+* Finish the tracked deletion of every paragraph a container ends with.
+*
+* Its own mark cannot be deleted (see `paragraphEndsItsContainer`), so the
+* deletion emptied it and left the mark. Applied directly, the paragraph goes
+* whenever a paragraph precedes it, which becomes the container's last; only
+* a container that would be left empty or ending in a table keeps an empty
+* paragraph. Tracked resolves to the same: the preceding paragraph's mark is
+* deleted, and accepting runs that paragraph into the emptied one, keeping
+* its own properties since it holds the words.
+*
+* A paragraph with a break pending deletion already runs into this one. If
+* its content is also wholly deleted, look past it for the surviving carrier;
+* otherwise another final-break revision would depend on batch boundaries.
+* A preceding break that is itself a pending insertion is
+* retracted instead of deleted: the paragraph joins the emptied one now, and
+* records the emptied one's properties as `w:pPrChange` where they differ,
+* which is what rejecting reads to put them back.
+*
+* This runs once over the finished batch: which paragraph precedes the
+* emptied one is settled only then, since the batch runs backwards and an
+* insertion or deletion before it lands after it.
+*/
+const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appliedIds, batchRevisionIds, revisionSeed, author, date, styleResolver, numbering }) => {
+	let nextRevisionId = revisionSeed;
+	const addedRevisions = [];
+	const retractedRevisionIds = [];
+	const resolvedOperationIds = /* @__PURE__ */ new Set();
+	const located = deletions.filter(({ operationId }) => appliedIds.has(operationId)).map((deletion) => ({
+		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) {
+		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 mark = previous.attrs["pPrMark"];
+		if (mark == null) {
+			const revisionId = nextRevisionId++;
+			tr.setNodeAttribute(position, "pPrMark", {
+				kind: "del",
+				info: {
+					id: revisionId,
+					author,
+					date,
+					...revisionExtras
+				}
+			});
+			const beforeBatch = resolveParagraphChangeAttrs({
+				node: previous,
+				mode: "reject",
+				boundaryCovered: true,
+				revisionSet: batchRevisionIds,
+				styleResolver,
+				numbering
+			});
+			if (!mergedPropertyTargets.some(({ position: target, mappedFrom }) => {
+				const mapped = tr.mapping.slice(mappedFrom).mapResult(target);
+				return !mapped.deleted && mapped.pos === at;
+			})) carryParagraphProperties({
+				tr,
+				position: at,
+				source: beforeBatch ? previous.type.create(beforeBatch, previous.content, previous.marks) : previous,
+				styleResolver,
+				numbering,
+				revision: {
+					id: revisionId,
+					author,
+					date,
+					...revisionExtras
+				},
+				keep: propertiesSetInBatch(emptied, batchRevisionIds)
+			});
+			resolvedOperationIds.add(operationId);
+			addedRevisions.push({
+				operationId,
+				revisionId
+			});
+			continue;
+		}
+		if (isInsertedPPrMark(mark)) {
+			const following = tr.doc.nodeAt(position + previous.nodeSize);
+			if (following?.type.name !== emptied.type.name) continue;
+			const previousFormatting = paragraphPropertiesBeforePendingChanges(following);
+			const formattingChanges = JSON.stringify(previousFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(previous));
+			const existing = expectParagraphAttrs(previous)._propertyChanges;
+			if (formattingChanges && hasSerializableParagraphPropertyChange(existing)) continue;
+			joinAtParagraphMark({
+				tr,
+				paragraphPos: position,
+				paragraph: previous,
+				next: following,
+				styleResolver
+			});
+			resolvedOperationIds.add(operationId);
+			const retracted = addedBreakRevisionId(mark);
+			if (retracted !== null) retractedRevisionIds.push(retracted);
+			const revisionId = nextRevisionId;
+			if (carryParagraphProperties({
+				tr,
+				position,
+				source: previous,
+				styleResolver,
+				numbering,
+				revision: {
+					id: revisionId,
+					author,
+					date,
+					...revisionExtras
+				},
+				keep: propertiesSetInBatch(following, batchRevisionIds)
+			}).tracked) {
+				nextRevisionId++;
+				addedRevisions.push({
+					operationId,
+					revisionId
+				});
+			}
+			continue;
+		}
+	}
+	return {
+		nextRevisionId,
+		resolvedOperationIds,
+		addedRevisions,
+		retractedRevisionIds
+	};
+};
 /**
 * Move an ADDED paragraph break off every paragraph its container ends with.
 *
@@ -985,8 +1658,52 @@ const addedBreakRevisionId = (value) => {
 * which paragraph ends a container is only settled when the batch is, and an
 * insertion that looked final was undone by the next operation writing a table
 * after it.
+* A wholly inserted table from this batch can be crossed to reach the carrier;
+* its removal on reject exposes that same paragraph boundary again.
+*
+* The paragraph the run was appended after may be one the same batch deletes:
+* the insertion landed first, so the deletion took that paragraph's mark as
+* well. The break rotating onto it then cancels the deleted one, as deleting a
+* paragraph whose break is inserted does one operation at a time: the deleted
+* paragraph's words run into the one after it, which ends with the free mark,
+* and neither break is left to resolve.
 */
-const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, author, date, initials }) => {
+const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, author, date, initials, styleResolver }) => {
+	const supersededDeletedBreaks = [];
+	const collectSupersededDeletedBreaks = (parent, contentStart) => {
+		let previous = null;
+		parent.forEach((node, offset) => {
+			const position = contentStart + offset;
+			if (node.type.name !== "paragraph") {
+				previous = null;
+				if (!node.isTextblock && node.childCount > 0) collectSupersededDeletedBreaks(node, position + 1);
+				return;
+			}
+			if (previous) {
+				const deletedMark = 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)) supersededDeletedBreaks.push({
+					preceding: previous.position,
+					inserted: position,
+					deletedMark,
+					precedingMark: trackedInsertion ? insertedMark : null
+				});
+			}
+			previous = {
+				node,
+				position
+			};
+		});
+	};
+	collectSupersededDeletedBreaks(tr.doc, 0);
+	for (const { preceding, inserted, deletedMark, precedingMark } of supersededDeletedBreaks) {
+		tr.setNodeAttribute(preceding, "pPrMark", precedingMark);
+		tr.setNodeAttribute(inserted, "pPrMark", deletedMark);
+	}
 	const paragraphTypeName = tr.doc.type.schema.nodes["paragraph"]?.name ?? "paragraph";
 	const rotations = finalParagraphsOf(tr.doc, paragraphTypeName).flatMap(({ node, position }) => {
 		const mark = node.attrs["pPrMark"];
@@ -997,13 +1714,14 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 			ownerRevisionId: revisionId,
 			position
 		}] : [];
-	});
+	}).toSorted((left, right) => right.position - left.position);
 	let next = tr;
 	let nextRevisionId = revisionSeed;
 	const synthesizedRevisions = [];
+	const retractedRevisionIds = [];
 	for (const { position: finalPosition, node: final, mark: finalMark } of rotations) {
 		const resolved = next.doc.resolve(finalPosition);
-		const carrier = addedBreakCarrierBefore(resolved, final.type.name);
+		const carrier = finalBreakCarrierBefore(resolved, final.type.name, batchRevisionIds);
 		if (!carrier) {
 			next = next.setNodeAttribute(finalPosition, "pPrMark", null);
 			continue;
@@ -1031,7 +1749,7 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 			const revisionId = addedBreakRevisionId(node.attrs["pPrMark"]);
 			return revisionId === null || !batchRevisionIds.has(revisionId);
 		})) continue;
-		const previousFormatting = paragraphPropertiesBeforeBatch(carrier.node, batchRevisionIds);
+		const previousFormatting = paragraphPropertiesBeforePendingChanges(carrier.node);
 		next = next.setNodeAttribute(finalPosition, "pPrMark", null);
 		let carriedMark = finalMark;
 		for (let index = 1; index < path.length; index++) {
@@ -1041,7 +1759,8 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 			const ownerRevisionId = addedBreakRevisionId(carriedMark);
 			if (ownerRevisionId === null || !batchRevisionIds.has(ownerRevisionId)) panic("A final-mark rotation crossed a break outside its operation batch", { ownerRevisionId });
 			const displacedMark = previous.node.attrs["pPrMark"];
-			next = next.setNodeAttribute(previous.position, "pPrMark", carriedMark);
+			const cancels = carrier.cancelsDeletedBreak && previous.position === carrier.position;
+			if (!cancels) next = next.setNodeAttribute(previous.position, "pPrMark", carriedMark);
 			const currentFormatting = paragraphPropertiesSnapshot(current.node);
 			if (JSON.stringify(previousFormatting) !== JSON.stringify(currentFormatting)) {
 				const liveCurrent = next.doc.nodeAt(current.position);
@@ -1067,6 +1786,22 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 					revisionId
 				});
 			}
+			if (cancels) {
+				const deleted = next.doc.nodeAt(previous.position);
+				const following = next.doc.nodeAt(current.position);
+				if (!deleted || !following) panic("A cancelled final-mark rotation lost its paragraphs", { position: previous.position });
+				joinAtParagraphMark({
+					tr: next,
+					paragraphPos: previous.position,
+					paragraph: deleted,
+					next: following,
+					styleResolver
+				});
+				retractedRevisionIds.push(ownerRevisionId);
+				const deletedBreakId = addedOrDeletedBreakRevisionId(displacedMark);
+				if (deletedBreakId !== null) retractedRevisionIds.push(deletedBreakId);
+				break;
+			}
 			if (displacedMark == null) break;
 			carriedMark = displacedMark;
 		}
@@ -1074,10 +1809,26 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 	return {
 		transaction: next,
 		nextRevisionId,
-		synthesizedRevisions
+		synthesizedRevisions,
+		retractedRevisionIds
 	};
 };
-const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove, numbering }) => {
+const restyledListAttrs = ({ attrs, styleNumbering, removesNumbering, numbering }) => {
+	const stated = readParagraphNumberingAttr(attrs["numPr"]);
+	const statedByOldStyle = isStyleSourcedParagraphNumbering(stated, readParagraphNumberingAttr(attrs["numPrFromStyle"]));
+	const fromStyle = styleNumbering === void 0 ? null : paragraphNumberingAttr(styleNumbering);
+	const numPr = removesNumbering ? removedNumberingAttr(fromStyle) : stated !== null && !statedByOldStyle ? stated : fromStyle;
+	return {
+		...CLEARED_LIST_RENDERING_ATTRS,
+		...numPr?.kind === "reference" && listAttrsFromNumbering({
+			numId: numPr.numId,
+			ilvl: numPr.ilvl ?? 0
+		}, numbering),
+		numPr,
+		numPrFromStyle: fromStyle
+	};
+};
+const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove, numbering, styleResolver }) => {
 	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"];
@@ -1131,11 +1882,11 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 		}) : buildEmphasisInlineContent(schema, text, marks);
 		const attrs = formatsParagraph ? { ...baseAttrs } : {};
 		if (isFirstParagraph && operation.pageBreakBefore === true) attrs["pageBreakBefore"] = true;
-		const explicitNumbering = operation.numbering;
+		const explicitNumbering = operation.numbering === void 0 || operation.numbering === null ? operation.numbering : concreteListReference(operation.numbering);
 		const listLevel = operation.listLevel;
 		if (formatsParagraph) {
 			if (explicitNumbering === null) {
-				attrs["numPr"] = null;
+				attrs["numPr"] = removedNumberingAttr(readParagraphNumberingAttr(attrs["numPrFromStyle"]));
 				Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
 			} else if (explicitNumbering !== void 0) {
 				Object.assign(attrs, listLevelAttrPatch(operation.inheritFormatting === false ? {} : expectParagraphAttrs(item.blockNode), {
@@ -1147,7 +1898,7 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 					attrs["numPrFromStyle"] = null;
 				}
 			} else if (listLevel === null) {
-				attrs["numPr"] = null;
+				attrs["numPr"] = removedNumberingAttr(readParagraphNumberingAttr(attrs["numPrFromStyle"]));
 				Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
 			} else if (typeof listLevel === "number") {
 				const numId = paragraphNumberingReferenceId(readParagraphNumberingAttr(Reflect.get(baseAttrs, "numPr")) ?? void 0);
@@ -1165,9 +1916,24 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 		}
 		if (formatsParagraph && operation.styleId !== void 0) {
 			attrs["styleId"] = operation.styleId;
-			if (operation.inheritFormatting !== false && operation.styleId !== null) Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
+			attrs["_resolvedFormatting"] = styleResolvedParagraphFormatting(formattingFromStyle);
+			attrs["defaultTextFormatting"] = resolveParagraphBodyRunFormatting({
+				styleId: operation.styleId ?? void 0,
+				tableRunFormatting: expectParagraphAttrs(item.blockNode)._tableRunFormatting,
+				styleResolver
+			}).defaultFormatting ?? null;
+			if (operation.inheritFormatting !== false && operation.styleId !== null) {
+				Object.assign(attrs, restyledListAttrs({
+					attrs,
+					styleNumbering: formattingFromStyle?.numPr,
+					removesNumbering: explicitNumbering === null || explicitNumbering === void 0 && listLevel === null,
+					numbering
+				}));
+				attrs["outlineLevel"] = attrs["_originalFormatting"]?.outlineLevel ?? formattingFromStyle?.outlineLevel ?? null;
+			}
 		}
-		if (formatsParagraph && (operation.styleId !== void 0 || operation.alignment !== void 0 || operation.spacing !== void 0 || operation.indentation !== void 0)) {
+		if (formatsParagraph && operation.outlineLevel !== void 0) attrs["outlineLevel"] = operation.outlineLevel ?? formattingFromStyle?.outlineLevel ?? null;
+		if (formatsParagraph && (operation.styleId !== void 0 || operation.outlineLevel !== void 0 || operation.alignment !== void 0 || operation.spacing !== void 0 || operation.indentation !== void 0)) {
 			const inheritedDirectAlignment = operation.inheritFormatting === false ? void 0 : directParagraphAlignment(expectParagraphAttrs(item.blockNode));
 			const inheritedDirectSpacing = operation.inheritFormatting === false ? void 0 : directParagraphSpacing(expectParagraphAttrs(item.blockNode));
 			const inheritedDirectIndentation = operation.inheritFormatting === false ? void 0 : directParagraphIndentation(expectParagraphAttrs(item.blockNode));
@@ -1183,6 +1949,11 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 				if (operation.styleId === null) Reflect.deleteProperty(originalFormatting, "styleId");
 				else originalFormatting.styleId = operation.styleId;
 			}
+			if (operation.outlineLevel !== void 0) {
+				originalFormatting ??= {};
+				if (operation.outlineLevel === null) Reflect.deleteProperty(originalFormatting, "outlineLevel");
+				else originalFormatting.outlineLevel = operation.outlineLevel;
+			}
 			if (operation.alignment !== void 0 || inheritedDirectAlignment !== void 0) {
 				originalFormatting ??= {};
 				if (directAlignment === void 0) Reflect.deleteProperty(originalFormatting, "alignment");
@@ -1200,6 +1971,17 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 			}));
 			attrs["_originalFormatting"] = originalFormatting && Object.keys(originalFormatting).length > 0 ? originalFormatting : null;
 		}
+		if (formatsParagraph && operation.styleId !== void 0 && formattingFromStyle?.numPr?.kind === "reference" && operation.numbering === void 0 && operation.listLevel === void 0) {
+			const { numId, ilvl = 0 } = formattingFromStyle.numPr;
+			const levelIndentation = numbering?.getLevel(numId, ilvl)?.pPr;
+			if (levelIndentation && operation.indentation === void 0) {
+				const direct = attrs["_originalFormatting"];
+				const directIndentLeft = typeof direct === "object" && direct !== null && "indentLeft" in direct ? direct.indentLeft : void 0;
+				const directIndentFirstLine = typeof direct === "object" && direct !== null && "indentFirstLine" in direct ? direct.indentFirstLine : void 0;
+				if (directIndentLeft === void 0 && formattingFromStyle.indentLeft === void 0) attrs["indentLeft"] = levelIndentation.indentLeft ?? attrs["indentLeft"];
+				if (directIndentFirstLine === void 0 && formattingFromStyle.indentFirstLine === void 0) attrs["indentFirstLine"] = levelIndentation.indentFirstLine ?? attrs["indentFirstLine"];
+			}
+		}
 		if (isSuggested && suggestionId !== null && paragraphRevisionId !== null) attrs["_suggestedInsert"] = {
 			suggestionId,
 			revisionId: paragraphRevisionId,
@@ -1207,7 +1989,28 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 			date,
 			...initials ? { initials } : {}
 		};
-		nodes.push(item.blockNode.type.create(attrs, content));
+		const paragraph = item.blockNode.type.create(attrs, content);
+		const sourceContext = OPERATION_TEXT_CONTEXT;
+		const targetContext = paragraphRunStyleContext(paragraph, styleResolver);
+		const reconciled = [];
+		paragraph.forEach((child) => {
+			if (!child.isInline) {
+				reconciled.push(child);
+				return;
+			}
+			const reconciledMarks = reconcileRunFormattingMarks({
+				authoredFormatting: readAuthoredRunFormatting({
+					context: sourceContext,
+					marks: child.marks,
+					styleResolver
+				}),
+				context: targetContext,
+				node: child,
+				styleResolver
+			});
+			reconciled.push(child.mark(reconciledMarks));
+		});
+		nodes.push(paragraph.copy(Fragment.fromArray(reconciled)));
 	}
 	if (producesTrackedChanges && !isSuggested) for (const [index, node] of nodes.entries()) {
 		const revisionId = nextRevisionId++;
@@ -1231,7 +2034,7 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 		nextRevisionId
 	};
 };
-const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, wordDiffMode = "bounded", tableTemplates, replacementBackground = "clear" }) => {
+const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: requestedOperations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, wordDiffMode = "bounded", tableTemplates, replacementBackground = "clear", undefinedStyles = "refuse" }) => {
 	const applied = [];
 	const skipped = [];
 	const normalizations = [];
@@ -1263,7 +2066,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		return id;
 	};
 	const styleResolver = getDocumentStyleResolver(view.state);
-	const numbering = getDocumentNumbering(view.state);
+	const styleDefinitions = undefinedStyles === "keep" ? null : getDocumentStyleDefinitions(view.state);
+	const { operations, numbering } = resolveNewListOperations(requestedOperations, getDocumentNumbering(view.state));
 	const formattingFromStyleForInsertion = (item) => {
 		if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return;
 		const anchorAttrs = expectParagraphAttrs(item.blockNode);
@@ -1277,6 +2081,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	};
 	const claimedTableRows = /* @__PURE__ */ new Set();
 	const claimedTableColumns = /* @__PURE__ */ new Set();
+	const batchClaims = new BatchClaims();
 	const diffText = wordDiffMode === "coarse" ? coarseWordDiff : wordDiffSessionFromOptions(wordDiff).diff;
 	const producesTrackedChanges = mode !== "direct";
 	const isSuggested = mode === "suggested";
@@ -1290,6 +2095,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	};
 	const liveBlocks = collectLiveBlocksByHash(view.state.doc);
 	const liveBlocksByParaId = collectLiveBlocksByParaId(view.state.doc);
+	const noteReferences = collectNoteReferenceLabels(view.state.doc);
+	const numberingInstanceIds = getDocumentNumberingInstanceIds(view.state) === null ? null : new Set(numbering?.definitions.nums.map(({ numId }) => numId) ?? []);
 	for (const [index, operation] of operations.entries()) {
 		const commentText = getOperationCommentText(operation);
 		if (commentText !== void 0 && (!commentType || createCommentId === void 0)) {
@@ -1304,12 +2111,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			operation,
 			liveBlocks,
 			liveBlocksByParaId,
+			noteReferences,
 			doc: view.state.doc
 		});
 		if (resolution.type === "skip") {
 			skipped.push({
 				id: operation.id,
-				reason: resolution.reason
+				reason: resolution.reason,
+				...resolution.message !== void 0 && { message: resolution.message }
 			});
 			continue;
 		}
@@ -1320,6 +2129,24 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			});
 			continue;
 		}
+		const undefinedStyle = findUndefinedParagraphStyleReference(operation, styleDefinitions);
+		if (undefinedStyle !== void 0) {
+			skipped.push({
+				id: operation.id,
+				reason: "missingStyle",
+				message: describeUndefinedParagraphStyle(undefinedStyle, styleDefinitions)
+			});
+			continue;
+		}
+		const undefinedNumbering = findUndefinedNumberingReference(operation, numberingInstanceIds);
+		if (undefinedNumbering !== void 0) {
+			skipped.push({
+				id: operation.id,
+				reason: "missingNumbering",
+				message: describeUndefinedNumbering(undefinedNumbering, numberingInstanceIds)
+			});
+			continue;
+		}
 		const deletion = resolution.operation.tableRowDeletion;
 		if (deletion) {
 			const rowKey = `${deletion.tablePosition}:${deletion.rowIndex}`;
@@ -1330,7 +2157,6 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				});
 				continue;
 			}
-			claimedTableRows.add(rowKey);
 		}
 		const columnDeletion = resolution.operation.tableColumnDeletion;
 		if (columnDeletion) {
@@ -1342,8 +2168,24 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				});
 				continue;
 			}
-			claimedTableColumns.add(columnKey);
 		}
+		const claim = batchClaimOf({
+			item: resolution.operation,
+			doc: view.state.doc,
+			producesTrackedChanges
+		});
+		const claimedBy = batchClaims.conflictOf(claim);
+		if (claimedBy !== null) {
+			skipped.push({
+				id: operation.id,
+				reason: "overlappingOperation",
+				message: `operation ${JSON.stringify(claimedBy)}, earlier in this batch, already claims its target.`
+			});
+			continue;
+		}
+		batchClaims.add(operation.id, claim);
+		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({
 			id: operation.id,
 			code: "splitMultilineText",
@@ -1394,6 +2236,12 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		});
 	}
 	let tr = view.state.tr;
+	/** Text boxes a tracked block deletion deletes, by anchor. */
+	const deletedTextBoxAnchorIds = /* @__PURE__ */ new Set();
+	/** Container-ending paragraphs a tracked `deleteBlock` emptied: see `withRetiredFinalParagraphs`. */
+	const deletedFinalParagraphs = [];
+	const mergedPropertyTargets = [];
+	const deferredNoopFinalDeletions = /* @__PURE__ */ new Set();
 	const ownsSharedRevisionIdCursor = revisionIdSeed === void 0 && revisionStamp === void 0;
 	let revisionSeed = revisionIdSeed ?? revisionStamp?.idSeed ?? revisionIdCursor;
 	/**
@@ -1409,7 +2257,31 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	};
 	const date = revisionStamp?.date ?? (/* @__PURE__ */ new Date()).toISOString();
 	const insertedColumnCounts = /* @__PURE__ */ new Map();
+	const emptiedRows = { pending: false };
+	const tableAfterDeletedSplit = /* @__PURE__ */ new Map();
+	if (mode === "tracked-changes") {
+		const afterTables = /* @__PURE__ */ new Map();
+		for (const item of executableResolved) {
+			if (item.operation.type !== "insertTable" || item.operation.position === "before") continue;
+			const boundaries = afterTables.get(item.blockFrom) ?? /* @__PURE__ */ new Set();
+			boundaries.add(item.from);
+			afterTables.set(item.blockFrom, boundaries);
+		}
+		for (const item of executableResolved) {
+			if (item.operation.type !== "deleteBlock") continue;
+			if (!isInsertedPPrMark(item.blockNode.attrs["pPrMark"])) continue;
+			const at = view.state.doc.resolve(item.blockFrom);
+			if (at.parent.maybeChild(at.index() + 1)?.type !== item.blockNode.type) continue;
+			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;
@@ -1473,7 +2345,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 						suggestionId: insertionSuggestionId,
 						revisionSeed,
 						isPairedMove,
-						numbering
+						numbering,
+						styleResolver
 					});
 					revisionSeed = built.nextRevisionId;
 					claimSharedRevisionIds(revisionSeed);
@@ -1499,6 +2372,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		const commentMark = provisionalCommentId !== void 0 && commentType ? commentType.create({ commentId: provisionalCommentId }) : null;
 		const stepsBefore = tr.steps.length;
 		let appliedRevisionIds = [];
+		let unifiedFormatting = false;
 		if (isSuggested && !SUGGESTED_SUPPORTED_OPERATION_TYPES.has(item.operation.type)) {
 			skipped.push({
 				id: item.operation.id,
@@ -1528,13 +2402,15 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					const minimal = applyMinimalDirectReplacement({
 						tr,
 						item,
+						noteReferences,
 						replacement: item.operation.replace,
 						commentMark,
 						replacementBackground,
 						...styleResolver !== void 0 ? { styleResolver } : {}
 					});
 					if (minimal !== null) {
-						tr = minimal;
+						tr = minimal.transaction;
+						unifiedFormatting = minimal.unifiesFormatting;
 						break;
 					}
 				}
@@ -1545,6 +2421,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					const tracked = applyMinimalTrackedReplacement({
 						tr,
 						item,
+						noteReferences,
 						replacement: stripInlineEmphasisMarkers(item.operation.replace),
 						commentMark,
 						replacementBackground,
@@ -1568,6 +2445,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					if (tracked) {
 						tr = tracked.transaction;
 						operationRevisionSeed = tracked.nextRevisionId;
+						unifiedFormatting = tracked.unifiesFormatting;
 						appliedRevisionIds = [
 							revisionIdDelete,
 							revisionIdInsert,
@@ -1576,6 +2454,13 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 						break;
 					}
 				}
+				if (rangeHoldsNoteReference(item)) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "protectedReference"
+					});
+					continue;
+				}
 				const stepsBeforeBackgroundClear = tr.steps.length;
 				const backgroundResult = clearReplacementBackground({
 					tr,
@@ -1705,6 +2590,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				const minimal = changesText && mode === "direct" ? applyMinimalDirectReplacement({
 					tr,
 					item,
+					noteReferences,
 					replacement: item.operation.text,
 					commentMark,
 					replacementBackground,
@@ -1713,6 +2599,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				const tracked = changesText && producesTrackedChanges ? applyMinimalTrackedReplacement({
 					tr,
 					item,
+					noteReferences,
 					replacement: stripInlineEmphasisMarkers(item.operation.text),
 					commentMark,
 					replacementBackground,
@@ -1733,13 +2620,30 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				if (minimal !== null) tr = minimal;
-				else if (tracked !== null) {
+				if (minimal !== null) {
+					tr = minimal.transaction;
+					unifiedFormatting = minimal.unifiesFormatting;
+				} else if (tracked !== null) {
 					tr = tracked.transaction;
 					operationRevisionSeed = tracked.nextRevisionId;
+					unifiedFormatting = tracked.unifiesFormatting;
 					clearedBackground = tracked.backgroundRevisionIds.length > 0;
 					backgroundRevisionIds = tracked.backgroundRevisionIds;
 				} else if (changesText) {
+					if (rangeHoldsNoteReference(item)) {
+						skipped.push({
+							id: item.operation.id,
+							reason: "protectedReference"
+						});
+						continue;
+					}
+					if (buildCleanBlockText(item.blockNode, item.blockFrom).structuralBoundaries.length > 0) {
+						skipped.push({
+							id: item.operation.id,
+							reason: "unsupportedBlock"
+						});
+						continue;
+					}
 					const stepsBeforeBackgroundClear = tr.steps.length;
 					const backgroundResult = clearReplacementBackground({
 						tr,
@@ -1802,6 +2706,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			}
 			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;
+				}
 				const built = buildInsertedParagraphs({
 					item,
 					schema: view.state.schema,
@@ -1814,11 +2728,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					suggestionId,
 					revisionSeed: operationRevisionSeed,
 					isPairedMove,
-					numbering
+					numbering,
+					styleResolver
 				});
 				operationRevisionSeed = built.nextRevisionId;
 				if (built.revisionIds.length > 0) appliedRevisionIds = built.revisionIds;
-				tr = tr.insert(item.from, built.nodes);
+				tr = insertBlocksInsideComments({
+					tr,
+					at: item.from,
+					blocks: built.nodes
+				});
 				break;
 			}
 			case "insertSignatureTable": {
@@ -1869,9 +2788,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				const revision = structuralRevision;
 				const template = tableTemplates?.get(item.operation.id);
+				const mappedInsertion = mapTableRowInsertion(tr, insertion);
 				const result = applyTableRowInsertion({
 					tr,
-					insertion,
+					insertion: mappedInsertion,
 					cellTexts: item.operation.cellTexts,
 					revision,
 					...template !== void 0 && { template }
@@ -1883,7 +2803,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				tr = result.transaction;
+				tr = addCommentsOver(result.transaction, mappedInsertion.rowPosition, item.tableRowComments);
 				if (result.revisionId !== null) {
 					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
@@ -1906,6 +2826,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					cellTexts: item.operation.cellTexts,
 					revision
 				});
+				if (result.type === "payloadDoesNotFit") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "payloadDoesNotFit",
+						message: result.message
+					});
+					continue;
+				}
 				if (result.type === "unsupported") {
 					skipped.push({
 						id: item.operation.id,
@@ -1913,11 +2841,9 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				tr = result.transaction;
-				if (result.revisionId !== null) {
-					operationRevisionSeed++;
-					appliedRevisionIds = [result.revisionId];
-				}
+				tr = addCommentsOver(result.transaction, tr.mapping.map(insertion.tablePosition, 1), item.tableColumnComments);
+				operationRevisionSeed += result.revisionIds.length;
+				appliedRevisionIds = [...result.revisionIds];
 				const columnKey = getTableColumnCoordinateKey(insertion);
 				insertedColumnCounts.set(columnKey, (insertedColumnCounts.get(columnKey) ?? 0) + 1);
 				break;
@@ -1937,7 +2863,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr,
 					deletion,
 					insertedColumnCount: insertedColumnCounts.get(columnKey) ?? 0,
-					revision
+					revision,
+					emptiedRows
 				});
 				if (result.type === "unsupported") {
 					skipped.push({
@@ -1947,10 +2874,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					continue;
 				}
 				tr = result.transaction;
-				if (result.revisionId !== null) {
-					operationRevisionSeed++;
-					appliedRevisionIds = [result.revisionId];
-				}
+				operationRevisionSeed += result.revisionIds.length;
+				appliedRevisionIds = [...result.revisionIds];
 				break;
 			}
 			case "mergeTableCells": {
@@ -2061,12 +2986,50 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				break;
 			}
-			case "deleteBlock":
+			case "deleteBlock": {
+				if (isSuggested && (hasOrdinaryTextRevision(item.blockNode) || hasOrdinaryParagraphMarkRevision(item.blockNode))) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedMode"
+					});
+					continue;
+				}
 				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);
 					break;
 				}
+				const retraction = isPairedMove(item.operation.moveId) ? null : pendingParagraphRetraction(tr.doc, item.blockFrom);
+				if (retraction) {
+					if (isSuggested && !isSuggestedParagraphInsert(item.blockNode)) {
+						skipped.push({
+							id: item.operation.id,
+							reason: "unsupportedMode"
+						});
+						continue;
+					}
+					const retracted = tr.doc.nodeAt(item.blockFrom);
+					tr = tr.delete(item.blockFrom, item.blockTo);
+					if (retraction.clearBreakAt !== null) {
+						tr = tr.setNodeAttribute(retraction.clearBreakAt, "pPrMark", null);
+						const revisionIdProperties = operationRevisionSeed;
+						if (retracted && recordReplacedParagraphProperties({
+							tr,
+							position: retraction.clearBreakAt,
+							replaced: retracted,
+							revision: {
+								id: revisionIdProperties,
+								author,
+								date,
+								...trackedRevisionExtras
+							}
+						})) {
+							operationRevisionSeed++;
+							appliedRevisionIds = [revisionIdProperties];
+						}
+					}
+					break;
+				}
 				if (deletionType) {
 					const revisionId = operationRevisionSeed++;
 					const deletionMark = deletionType.create({
@@ -2079,6 +3042,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr = tr.addMark(item.from, item.to, deletionMark);
 					const atomRanges = undeletedContentAtomRanges(tr, item.blockFrom);
 					for (const { from, to } of atomRanges) tr = tr.addMark(from, to, deletionMark);
+					for (const anchorId of textBoxAnchorIdsBetween(tr.doc, tr.mapping.map(item.blockFrom), tr.mapping.map(item.blockTo))) deletedTextBoxAnchorIds.add(anchorId);
 					encloseWholeControls({
 						tr,
 						from: item.blockFrom,
@@ -2088,7 +3052,39 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					const inlineRevisionApplied = item.from < item.to || atomRanges.length > 0;
 					appliedRevisionIds = inlineRevisionApplied ? [revisionId] : [];
 					const markPosition = tr.mapping.map(item.blockFrom);
-					if (!paragraphEndsItsContainer(tr.doc.resolve(markPosition), item.blockNode.type.name) && tr.doc.nodeAt(markPosition)?.attrs["pPrMark"] == null) {
+					const endsItsContainer = paragraphEndsItsContainer(tr.doc.resolve(markPosition), item.blockNode.type.name);
+					const deleted = tr.doc.nodeAt(markPosition);
+					const following = deleted && tr.doc.nodeAt(markPosition + deleted.nodeSize);
+					if (deleted && following?.type === deleted.type && !isPairedMove(item.operation.moveId) && isInsertedPPrMark(deleted.attrs["pPrMark"])) {
+						const restored = paragraphPropertiesOnReject(deleted);
+						const followingChanges = expectParagraphAttrs(following)._propertyChanges;
+						const recordsRestored = isInsertedPPrMark(following.attrs["pPrMark"]) && !hasSerializableParagraphPropertyChange(followingChanges) && JSON.stringify(restored) !== JSON.stringify(paragraphPropertiesSnapshot(following));
+						joinAtParagraphMark({
+							tr,
+							paragraphPos: markPosition,
+							paragraph: deleted,
+							next: following,
+							styleResolver: styleResolver ?? null
+						});
+						const joined = tr.doc.nodeAt(markPosition);
+						if (recordsRestored && joined) {
+							const propertyRevisionId = operationRevisionSeed++;
+							tr = tr.setNodeMarkup(markPosition, void 0, {
+								...joined.attrs,
+								_propertyChanges: [...Array.isArray(followingChanges) ? followingChanges : [], {
+									type: "paragraphPropertyChange",
+									info: {
+										id: propertyRevisionId,
+										author,
+										date,
+										...trackedRevisionExtras
+									},
+									previousFormatting: restored
+								}]
+							});
+							appliedRevisionIds = [...appliedRevisionIds, propertyRevisionId];
+						}
+					} else if (!endsItsContainer && deleted?.attrs["pPrMark"] == null) {
 						const markRevisionId = operationRevisionSeed++;
 						tr = tr.setNodeAttribute(markPosition, "pPrMark", {
 							kind: isPairedMove(item.operation.moveId) ? "moveFrom" : "del",
@@ -2100,10 +3096,25 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 							}
 						});
 						appliedRevisionIds = inlineRevisionApplied ? [revisionId, markRevisionId] : [markRevisionId];
+					} else if (endsItsContainer && !isPairedMove(item.operation.moveId)) deletedFinalParagraphs.push({
+						operationId: item.operation.id,
+						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);
+						if (finalPosition !== null) deletedFinalParagraphs.push({
+							operationId: item.operation.id,
+							position: finalPosition,
+							mappedFrom: tr.mapping.maps.length,
+							revisionExtras: trackedRevisionExtras
+						});
 					}
 				}
 				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				break;
+			}
 			case "insertTable": {
 				const revision = {
 					revisionId: operationRevisionSeed,
@@ -2129,7 +3140,55 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					continue;
 				}
 				if (producesTrackedChanges) appliedRevisionIds = [operationRevisionSeed++];
-				tr = tr.insert(item.from, table);
+				const carriedComments = tableAfterDeletedSplit.get(item.blockFrom);
+				const usesRetractedSplit = carriedComments !== void 0 && item.from === item.blockTo;
+				let at = usesRetractedSplit ? tr.mapping.map(item.blockFrom, -1) : item.from;
+				let insertionComments = carriedComments;
+				if (!usesRetractedSplit) {
+					const boundary = tr.doc.resolve(at);
+					const before = boundary.nodeBefore;
+					const finalDeleted = deletedFinalParagraphAfter(boundary, "paragraph");
+					const mapping = tr.mapping;
+					const pendingIndex = finalDeleted === null ? -1 : deletedFinalParagraphs.findIndex(({ position, mappedFrom }) => mapping.slice(mappedFrom).map(position) === finalDeleted);
+					const pending = pendingIndex < 0 ? void 0 : deletedFinalParagraphs.at(pendingIndex);
+					if (before?.type.name === "paragraph" && finalDeleted !== null && (pending !== void 0 || isPlainDeletedPPrMark(before.attrs["pPrMark"]) && !holdsOnlyDeletedContent(before))) {
+						insertionComments = commentsAcrossBlockBoundary(tr.doc, at);
+						const final = tr.doc.nodeAt(finalDeleted);
+						if (!final) panic("A deleted final paragraph vanished before table insertion", { finalDeleted });
+						if (pending) {
+							const receiptIndex = applied.findIndex(({ id }) => id === pending.operationId);
+							const receipt = receiptIndex < 0 ? void 0 : applied.at(receiptIndex);
+							if (receipt === void 0) panic("A deleted final paragraph lost its operation receipt", { operationId: pending.operationId });
+							const revisionId = operationRevisionSeed++;
+							tr.setNodeAttribute(finalDeleted, "pPrMark", {
+								kind: "del",
+								info: {
+									id: revisionId,
+									author,
+									date,
+									...pending.revisionExtras
+								}
+							});
+							applied[receiptIndex] = {
+								...receipt,
+								revisionId: receipt.revisionId ?? revisionId,
+								revisionIds: [...receipt.revisionIds ?? [], revisionId]
+							};
+							deletedFinalParagraphs.splice(pendingIndex, 1);
+							deferredNoopFinalDeletions.delete(pending.operationId);
+						} else {
+							tr.setNodeAttribute(at - before.nodeSize, "pPrMark", null);
+							tr.setNodeAttribute(finalDeleted, "pPrMark", before.attrs["pPrMark"]);
+						}
+						at = finalDeleted + final.nodeSize;
+					}
+				}
+				tr = insertBlocksInsideComments({
+					tr,
+					at,
+					blocks: table,
+					...insertionComments !== void 0 && { carriedComments: insertionComments }
+				});
 				markStructuralChange(tr);
 				break;
 			}
@@ -2173,10 +3232,21 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				};
 				const rowPositions = [];
 				let rowOffset = livePosition + 1;
+				let holdsPendingInsertedRow = false;
 				liveTable.forEach((row) => {
-					if (row.type.spec["tableRole"] === "row" && row.attrs["trDel"] == null) rowPositions.push(rowOffset);
+					if (row.type.spec["tableRole"] === "row" && row.attrs["trDel"] == null) {
+						rowPositions.push(rowOffset);
+						holdsPendingInsertedRow ||= row.attrs["trIns"] != null;
+					}
 					rowOffset += row.nodeSize;
 				});
+				if (holdsPendingInsertedRow) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
 				if (rowPositions.length === 0) {
 					skipped.push({
 						id: item.operation.id,
@@ -2198,8 +3268,17 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			}
 			case "setBlockParagraphProperties": {
-				const blockPosition = tr.mapping.map(item.blockFrom);
-				const liveBlock = tr.doc.nodeAt(blockPosition) ?? item.blockNode;
+				const mapped = tr.mapping.mapResult(item.blockFrom);
+				const liveBlock = mapped.deletedAcross ? null : tr.doc.nodeAt(mapped.pos);
+				const paraId = item.blockNode.attrs["paraId"];
+				if (!liveBlock || liveBlock.type !== item.blockNode.type || typeof paraId === "string" && liveBlock.attrs["paraId"] !== paraId) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "missingBlock"
+					});
+					continue;
+				}
+				const blockPosition = mapped.pos;
 				const appliedProperties = applyBlockParagraphProperties({
 					tr,
 					position: blockPosition,
@@ -2226,9 +3305,17 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			}
 			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) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
 				} else {
 					const revisionIdMark = operationRevisionSeed++;
 					const info = {
@@ -2286,17 +3373,61 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			}
 			case "mergeBlockWithNext": {
-				const separator = item.operation.separator ?? "";
+				if (mode === "direct" && !canJoin(tr.doc, item.blockTo)) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const separator = followedOnlyByDeletedParagraphs(tr.doc, item.blockTo) ? "" : item.operation.separator ?? "";
 				const insertAt = item.blockTo - 1;
+				let mergedPropertiesAt = item.blockFrom;
+				let mergedPropertiesRecorded = false;
+				const second = tr.doc.nodeAt(item.blockTo);
+				const spanningComments = commentsAcrossBlockBoundary(tr.doc, item.blockTo);
+				const withSeparator = (transaction) => {
+					const paragraph = transaction.doc.nodeAt(item.blockFrom);
+					const sourceMarks = paragraph?.lastChild?.marks.filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)) ?? [];
+					const sourceNode = view.state.schema.text(separator, sourceMarks);
+					const context = paragraph && paragraphRunStyleContext(paragraph, styleResolver);
+					const marks = context ? reconcileRunFormattingMarks({
+						authoredFormatting: readAuthoredRunFormatting({
+							context,
+							marks: sourceMarks,
+							styleResolver
+						}),
+						context,
+						node: sourceNode,
+						styleResolver
+					}) : sourceMarks;
+					let next = transaction.replaceWith(insertAt, insertAt, view.state.schema.text(separator, marks));
+					for (const comment of spanningComments) next = next.addMark(insertAt, insertAt + separator.length, comment);
+					return next;
+				};
 				if (mode === "direct") {
-					if (separator.length > 0) tr = tr.insertText(separator, insertAt);
+					if (separator.length > 0) tr = withSeparator(tr);
+					const nextPosition = item.blockTo + separator.length;
+					const next = tr.doc.nodeAt(nextPosition);
+					const paragraph = tr.doc.nodeAt(item.blockFrom);
+					if (next && paragraph) tr = rebaseParagraphRuns({
+						tr,
+						position: nextPosition,
+						previous: next,
+						target: paragraph,
+						styleResolver
+					});
+					tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 					tr = tr.join(item.blockTo + separator.length);
+					const secondSection = second ? sectionPropertiesOf(second) : null;
+					const joined = tr.doc.nodeAt(item.blockFrom);
+					if (joined && sectionPropertiesOf(joined) !== secondSection) tr = tr.setNodeAttribute(item.blockFrom, "_sectionProperties", secondSection);
 				} else {
 					const revisionIdMark = operationRevisionSeed++;
 					appliedRevisionIds = [revisionIdMark];
 					if (separator.length > 0 && insertionType) {
 						const revisionIdSeparator = operationRevisionSeed++;
-						tr = tr.insertText(separator, insertAt);
+						tr = withSeparator(tr);
 						tr = tr.addMark(insertAt, insertAt + separator.length, insertionType.create({
 							revisionId: revisionIdSeparator,
 							author,
@@ -2305,27 +3436,86 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 						}));
 						appliedRevisionIds.push(revisionIdSeparator);
 					}
-					tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
-						kind: "del",
-						info: {
-							id: revisionIdMark,
-							author,
-							date,
-							...trackedRevisionExtras
-						}
-					});
+					const paragraph = tr.doc.nodeAt(item.blockFrom);
+					const joinPos = item.blockTo + separator.length;
+					const next = tr.doc.nodeAt(joinPos);
+					if (!paragraph || !next) panic("A resolved merge lost its paragraphs");
+					if (isInsertedPPrMark(paragraph.attrs["pPrMark"])) {
+						joinAtParagraphMark({
+							tr,
+							paragraphPos: item.blockFrom,
+							paragraph,
+							next,
+							styleResolver
+						});
+						const joinedMark = tr.doc.nodeAt(item.blockFrom)?.attrs["pPrMark"];
+						const removedBreakPositions = pendingRemovedFinalBreakPositions(tr, deletedFinalParagraphs);
+						const carryPos = isDeletedPPrMark(joinedMark) || removedBreakPositions.has(item.blockFrom) ? paragraphLeftAfter({
+							doc: tr.doc,
+							paragraphPos: item.blockFrom,
+							removedBreakPositions
+						}) ?? item.blockFrom : item.blockFrom;
+						const carried = carryParagraphProperties({
+							tr,
+							position: carryPos,
+							source: paragraph,
+							styleResolver,
+							numbering,
+							revision: {
+								id: revisionIdMark,
+								author,
+								date,
+								...trackedRevisionExtras
+							}
+						});
+						mergedPropertiesAt = carryPos;
+						tr = carried.tr;
+						mergedPropertiesRecorded = carried.tracked;
+						if (!carried.tracked) appliedRevisionIds = appliedRevisionIds.filter((id) => id !== revisionIdMark);
+					} else {
+						tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
+							kind: "del",
+							info: {
+								id: revisionIdMark,
+								author,
+								date,
+								...trackedRevisionExtras
+							}
+						});
+						const survivorPos = paragraphLeftAfter({
+							doc: tr.doc,
+							paragraphPos: item.blockFrom,
+							removedBreakPositions: pendingRemovedFinalBreakPositions(tr, deletedFinalParagraphs)
+						}) ?? joinPos;
+						const carried = carryParagraphProperties({
+							tr,
+							position: survivorPos,
+							source: paragraph,
+							styleResolver,
+							numbering,
+							revision: {
+								id: revisionIdMark,
+								author,
+								date,
+								...trackedRevisionExtras
+							}
+						});
+						tr = carried.tr;
+						mergedPropertiesRecorded = carried.tracked;
+						mergedPropertiesAt = survivorPos;
+					}
 				}
 				if (item.operation.mergedParagraphProperties) {
-					const mergedParagraph = tr.doc.nodeAt(item.blockFrom);
+					const mergedParagraph = tr.doc.nodeAt(mergedPropertiesAt);
 					if (!mergedParagraph) panic("A resolved merge did not produce a paragraph");
 					const appliedProperties = applyBlockParagraphProperties({
 						tr,
-						position: item.blockFrom,
+						position: mergedPropertiesAt,
 						node: mergedParagraph,
 						properties: item.operation.mergedParagraphProperties,
 						styleResolver,
 						numbering,
-						...mode === "direct" ? {} : { revisionInfo: () => ({
+						...mode === "direct" || mergedPropertiesRecorded ? {} : { revisionInfo: () => ({
 							id: operationRevisionSeed++,
 							author,
 							date,
@@ -2335,6 +3525,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr = appliedProperties.tr;
 					if (appliedProperties.revisionIds.length > 0) appliedRevisionIds.push(...appliedProperties.revisionIds);
 				}
+				if (mode !== "direct") mergedPropertyTargets.push({
+					position: mergedPropertiesAt,
+					mappedFrom: tr.mapping.maps.length
+				});
 				break;
 			}
 			case "commentOnBlock":
@@ -2343,11 +3537,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			default: break;
 		}
 		if (tr.steps.length === stepsBefore) {
-			skipped.push({
-				id: item.operation.id,
-				reason: "noopOperation"
-			});
-			continue;
+			if (!deletedFinalParagraphs.some(({ operationId }) => operationId === item.operation.id)) {
+				skipped.push({
+					id: item.operation.id,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			deferredNoopFinalDeletions.add(item.operation.id);
 		}
 		let committedCommentId;
 		if (item.commentText !== void 0) {
@@ -2366,6 +3563,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		}
 		revisionSeed = operationRevisionSeed;
 		claimSharedRevisionIds(revisionSeed);
+		if (unifiedFormatting) normalizations.push({
+			id: item.operation.id,
+			code: "uniformReplacementFormatting"
+		});
 		applied.push({
 			id: item.operation.id,
 			...committedCommentId !== void 0 && { commentId: committedCommentId },
@@ -2376,9 +3577,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			...suggestionId !== null && { suggestionId }
 		});
 	}
-	if (tr.docChanged) {
+	removeRowsWithoutCellsAfterBatch(tr, emptiedRows);
+	if (tr.docChanged || deferredNoopFinalDeletions.size > 0) {
 		const batchRevisionIds = new Set(applied.flatMap(({ revisionIds }) => revisionIds ?? []));
-		tr = withoutRevisionsOnZeroWidthAnchors(tr, batchRevisionIds);
+		tr = withoutRevisionsOnZeroWidthAnchors(tr, batchRevisionIds, deletedTextBoxAnchorIds);
+		if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(view.state.doc, tr.doc))) markStructuralChange(tr);
 		continueSharedRevisionIds();
 		const rotated = withRotatedAddedFinalBreaks({
 			tr,
@@ -2386,10 +3589,33 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			revisionSeed,
 			author,
 			date,
-			initials
+			initials,
+			styleResolver: styleResolver ?? null
 		});
 		tr = rotated.transaction;
 		revisionSeed = rotated.nextRevisionId;
+		const retired = withRetiredFinalParagraphs({
+			tr,
+			deletions: deletedFinalParagraphs,
+			mergedPropertyTargets,
+			appliedIds: new Set(applied.map(({ id }) => id)),
+			batchRevisionIds,
+			revisionSeed,
+			author,
+			date,
+			styleResolver,
+			numbering
+		});
+		revisionSeed = retired.nextRevisionId;
+		for (const operationId of deferredNoopFinalDeletions) {
+			if (retired.resolvedOperationIds.has(operationId)) continue;
+			const receiptIndex = applied.findIndex(({ id }) => id === operationId);
+			if (receiptIndex >= 0) applied.splice(receiptIndex, 1);
+			skipped.push({
+				id: operationId,
+				reason: "noopOperation"
+			});
+		}
 		const receiptIndexByRevisionId = /* @__PURE__ */ new Map();
 		for (const [receiptIndex, receipt] of applied.entries()) for (const revisionId of receipt.revisionIds ?? []) receiptIndexByRevisionId.set(revisionId, receiptIndex);
 		for (const { ownerRevisionId, revisionId } of rotated.synthesizedRevisions) {
@@ -2404,9 +3630,48 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				revisionIds: [...receipt.revisionIds, revisionId]
 			};
 		}
+		for (const { operationId, revisionId } of retired.addedRevisions) {
+			const receiptIndex = applied.findIndex(({ id }) => id === operationId);
+			const receipt = applied.at(receiptIndex);
+			if (receiptIndex < 0 || !receipt) panic("A retired final-mark revision lost its operation receipt", {
+				operationId,
+				revisionId
+			});
+			const revisionIds = [...receipt.revisionIds ?? [], revisionId];
+			applied[receiptIndex] = {
+				...receipt,
+				revisionId: receipt.revisionId ?? revisionId,
+				revisionIds
+			};
+		}
+		const retractedRevisionIds = /* @__PURE__ */ new Set([...rotated.retractedRevisionIds, ...retired.retractedRevisionIds]);
+		if (retractedRevisionIds.size > 0) for (const [receiptIndex, receipt] of applied.entries()) {
+			const revisionIds = receipt.revisionIds?.filter((id) => !retractedRevisionIds.has(id));
+			if (revisionIds === void 0) continue;
+			const { revisionId: _oldRevisionId, revisionIds: _oldRevisionIds, ...withoutRevisions } = receipt;
+			const firstRevisionId = revisionIds.at(0);
+			applied[receiptIndex] = firstRevisionId === void 0 ? withoutRevisions : {
+				...withoutRevisions,
+				revisionId: firstRevisionId,
+				revisionIds
+			};
+		}
+		const separated = separateRevisionStretches({
+			tr,
+			revisionSeed
+		});
+		revisionSeed = separated.nextRevisionId;
+		for (const { revisionId, from } of separated.minted) {
+			const receiptIndex = applied.findIndex(({ revisionIds }) => revisionIds?.includes(from));
+			const receipt = applied.at(receiptIndex);
+			if (receiptIndex >= 0 && receipt?.revisionIds) applied[receiptIndex] = {
+				...receipt,
+				revisionIds: [...receipt.revisionIds, revisionId]
+			};
+		}
 		claimSharedRevisionIds(revisionSeed);
 		if (revisionStamp) requestDeterministicParaIds(tr, `${revisionStamp.date}:${String(revisionStamp.idSeed)}`);
-		view.dispatch(tr);
+		if (tr.docChanged) view.dispatch(tr);
 	}
 	return {
 		applied,
@@ -2416,9 +3681,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	};
 };
 const applyFolioAIEditOperations = (options) => applyFolioAIEditOperationsInternal(options);
-const previewFolioAIEditOperations = (options) => {
+const previewFolioAIEditOperations = (options) => previewFolioAIEditOperationsWithResult(options).outcome;
+/**
+* A preview together with the document it would leave and the provisional
+* comment ids it placed, for a caller that checks the result before reporting
+* it. Internal: not re-exported from the package entry points.
+*/
+const previewFolioAIEditOperationsWithResult = (options) => {
 	const { view, createCommentId, ...applyOptions } = options;
 	let previewCommentId = -1;
+	const commentIds = [];
 	const previewView = {
 		state: view.state,
 		dispatch: (transaction) => {
@@ -2428,15 +3700,23 @@ const previewFolioAIEditOperations = (options) => {
 	const result = applyFolioAIEditOperationsInternal({
 		...applyOptions,
 		view: previewView,
-		...createCommentId !== void 0 && { createCommentId: () => previewCommentId-- },
+		...createCommentId !== void 0 && { createCommentId: () => {
+			const id = previewCommentId--;
+			commentIds.push(id);
+			return id;
+		} },
 		revisionIdSeed: -1e9,
 		wordDiffMode: "coarse"
 	});
 	return {
-		applied: result.applied.map(({ id }) => ({ id })),
-		skipped: result.skipped,
-		...result.normalizations !== void 0 && { normalizations: result.normalizations },
-		nextRevisionId: options.revisionStamp?.idSeed ?? revisionIdCursor
+		outcome: {
+			applied: result.applied.map(({ id }) => ({ id })),
+			skipped: result.skipped,
+			...result.normalizations !== void 0 && { normalizations: result.normalizations },
+			nextRevisionId: options.revisionStamp?.idSeed ?? revisionIdCursor
+		},
+		doc: previewView.state.doc,
+		commentIds
 	};
 };
 const CLEAN_TEXT_CONTROL_PATTERN = /[\t\n]/gu;
@@ -2460,9 +3740,10 @@ const cleanTextInlineNodes = ({ schema, text, marks = [] }) => {
 	if (trailing.length > 0) nodes.push(schema.text(trailing, marks));
 	return nodes;
 };
-const insertCleanText = ({ tr, from, to, text, standsInFor }) => {
+const insertCleanText = ({ tr, from, to, text, standsInFor, keepsReplacedText = false }) => {
 	const annotations = surveyReplacedAnnotations(tr.doc, from, to);
-	const replaced = standsInFor ? surveyReplacedAnnotations(tr.doc, standsInFor.from, standsInFor.to).carried : [];
+	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,
@@ -2539,7 +3820,8 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 			standsInFor: {
 				from: item.from,
 				to: item.to
-			}
+			},
+			keepsReplacedText: true
 		});
 		nextTr = inserted.transaction;
 		nextTr = nextTr.addMark(inserted.start, inserted.end, insertionType.create(insAttrs));
@@ -2551,6 +3833,17 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 	}
 	return nextTr;
 };
+/** Whether the resolved range covers a footnote or endnote reference. */
+const rangeHoldsNoteReference = ({ blockNode, blockFrom, from, to }) => {
+	let holds = false;
+	blockNode.descendants((node, pos) => {
+		if (holds) return false;
+		const start = blockFrom + 1 + pos;
+		if (noteReferenceOf(node) !== null && start < to && start + node.nodeSize > from) holds = true;
+		return !holds;
+	});
+	return holds;
+};
 /**
 * The clean-text span a text replacement matched: where it starts in the
 * block's clean text and what it says. `null` when the operation does not
@@ -2592,17 +3885,27 @@ const isCarriedMark = (mark) => NON_INCLUSIVE_MARK_DISPOSITION[mark.type.name] =
 * document character by character, or the changes do not produce the
 * replacement.
 */
-const planDocumentReplacement = ({ doc, item, replacement, planChanges }) => {
-	const cleanBlock = buildCleanBlockText(item.blockNode, item.blockFrom);
+const planDocumentReplacement = ({ doc, item, replacement, noteReferences, planChanges, keepFieldsOf }) => {
+	const cleanBlock = buildCleanBlockText(item.blockNode, item.blockFrom, {
+		fieldResults: "text",
+		noteReferences
+	});
 	const span = replacedCleanSpan(item, cleanBlock);
 	if (span === null) return null;
 	const spanStart = span.start;
 	const spanEnd = span.start + span.text.length;
-	const atomicSpans = cleanBlock.structuralBoundaries.flatMap((boundary) => boundary.type === "field" ? [{
+	const noteReferenceSpans = noteReferenceSpansWithin(cleanBlock, spanStart, spanEnd);
+	const editsReferences = !(segmentsAroundNoteReferences(span.text, replacement, noteReferenceSpans) !== null) && noteReferenceEditsAllowed();
+	const atomicSpans = cleanBlock.structuralBoundaries.flatMap((boundary) => boundary.type === "field" || editsReferences && boundary.type === "noteReference" ? [{
 		offset: boundary.offset - spanStart,
 		length: boundary.length
 	}] : []);
-	const changes = widenChangesToAtomicSpans(span.text, planChanges(span.text), atomicSpans);
+	const planPieces = (plan) => editsReferences ? [...plan(span.text, replacement)] : planChangesAroundNoteReferences(span.text, replacement, noteReferenceSpans, plan);
+	const pieceChanges = planPieces(planChanges);
+	if (pieceChanges === null) return null;
+	const widened = widenChangesToAtomicSpans(span.text, pieceChanges, atomicSpans);
+	const keptPieces = keepFieldsOf === void 0 ? null : planPieces(keepFieldsOf);
+	const changes = keptPieces === null ? widened : keepAtomicSpans(span.text, replacement, widened, widenChangesToAtomicSpans(span.text, keptPieces, atomicSpans), atomicSpans);
 	if (applyTextChanges(span.text, changes) !== replacement) return null;
 	const unitAt = (index) => {
 		const from = cleanBlock.offsets[index];
@@ -2610,7 +3913,7 @@ const planDocumentReplacement = ({ doc, item, replacement, planChanges }) => {
 		if (from === void 0 || !node) return null;
 		return {
 			from,
-			to: node.isText ? from + 1 : from + node.nodeSize
+			to: !node.isText || noteReferenceOf(node) !== null ? from + node.nodeSize : from + 1
 		};
 	};
 	const matchedFrom = item.from;
@@ -2730,6 +4033,72 @@ const planDocumentReplacement = ({ doc, item, replacement, planChanges }) => {
 		replacementStyleSource
 	};
 };
+/** The marks that present a character: its formatting, and the links and comments over it. */
+const presentationMarks = (marks) => marks.filter((mark) => isFormattingMark(mark) || isCarriedMark(mark));
+/**
+* Whether a change of `plan` replaces characters that do not all present
+* alike. Its new text takes one formatting, the first replaced character's,
+* and every link and comment over the stretch, so the others' formatting ends
+* where the replaced text did. That is the rule for every mode, and the
+* receipt says it was applied (`uniformReplacementFormatting`).
+*/
+const replacementUnifiesFormatting = (doc, plan) => plan.planned.some(({ change, pieces }) => {
+	if (pieces.length === 0 || change.text.length === 0) return false;
+	let first = null;
+	for (let index = change.start; index < change.end; index++) {
+		const unit = plan.unitAt(plan.spanStart + index);
+		const marks = presentationMarks((unit ? doc.nodeAt(unit.from)?.marks : null) ?? Mark.none);
+		if (first === null) first = marks;
+		else if (!Mark.sameSet(first, marks)) return true;
+	}
+	return false;
+});
+/**
+* The marks each UTF-16 unit of `replacement` carries once a direct
+* replacement has written it (see {@link applyMinimalDirectReplacement}): a
+* character the direct plan keeps keeps its own, and one it writes takes the
+* marks that plan gives its change. Background cleared from a touched stretch
+* is left off either way.
+*
+* A tracked replacement writes its insertions with these marks, so accepting
+* it leaves exactly the text and formatting the direct edit writes, although
+* its redline cuts the text into coarser, readable changes than the direct
+* edit does.
+*/
+const directReplacementMarks = ({ doc, plan, replacementBackground }) => {
+	const clearsBackground = replacementBackground === "clear";
+	const touched = clearsBackground ? touchedBackgroundIndices({
+		doc,
+		plan
+	}) : /* @__PURE__ */ new Set();
+	const withoutBackground = (marks) => marks.filter((mark) => !BACKGROUND_MARK_NAMES.has(mark.type.name));
+	const allocated = [];
+	let cursor = 0;
+	const keepUntil = (end) => {
+		for (; cursor < end; cursor++) {
+			const index = plan.spanStart + cursor;
+			const unit = plan.unitAt(index);
+			const marks = (unit ? doc.nodeAt(unit.from)?.marks : null) ?? Mark.none;
+			allocated.push(touched.has(index) ? withoutBackground(marks) : marks);
+		}
+	};
+	for (const { change, pieces, insertion } of plan.planned) {
+		keepUntil(change.start);
+		cursor = change.end;
+		let marks;
+		if (insertion !== void 0) marks = insertion.marks(doc);
+		else {
+			const first = pieces.at(0);
+			const last = pieces.at(-1);
+			if (first === void 0 || last === void 0) panic("A planned replacement lost the characters it removes");
+			marks = addCarriedMarks(inheritedReplacementMarks(doc, first.from, first.to), surveyReplacedAnnotations(doc, first.from, last.to).carried);
+		}
+		const written = clearsBackground ? withoutBackground(marks) : marks;
+		for (let offset = 0; offset < change.text.length; offset++) allocated.push(written);
+	}
+	keepUntil(plan.spanEnd - plan.spanStart);
+	return allocated;
+};
 /**
 * Apply a direct-mode text replacement as the difference between the matched
 * text and its replacement; `minimal-replacement.ts` states the contract.
@@ -2738,15 +4107,17 @@ const planDocumentReplacement = ({ doc, item, replacement, planChanges }) => {
 * cannot be mapped onto the document character by character. The caller then
 * replaces the matched span whole, as it always did.
 */
-const applyMinimalDirectReplacement = ({ tr, item, replacement, commentMark, replacementBackground, styleResolver }) => {
+const applyMinimalDirectReplacement = ({ tr, item, noteReferences, replacement, commentMark, replacementBackground, styleResolver }) => {
 	const plan = planDocumentReplacement({
 		doc: tr.doc,
 		item,
 		replacement,
-		planChanges: (source) => planTextChanges(source, replacement)
+		noteReferences,
+		planChanges: planTextChanges
 	});
 	if (plan === null || plan.changes.length === 0) return null;
 	const { planned, matchedFrom, matchedTo } = plan;
+	const unifiesFormatting = replacementUnifiesFormatting(tr.doc, plan);
 	let nextTr = tr;
 	if (replacementBackground === "clear") nextTr = clearTouchedBackground({
 		tr: nextTr,
@@ -2810,7 +4181,10 @@ const applyMinimalDirectReplacement = ({ tr, item, replacement, commentMark, rep
 		}
 		if (to > from) nextTr = nextTr.addMark(from, to, commentMark);
 	}
-	return nextTr;
+	return {
+		transaction: nextTr,
+		unifiesFormatting
+	};
 };
 /**
 * Apply a tracked-changes or suggested text replacement as its redline: each
@@ -2825,7 +4199,7 @@ const applyMinimalDirectReplacement = ({ tr, item, replacement, commentMark, rep
 * cannot be mapped onto the document character by character; the caller then
 * marks the whole match as replaced, as it always did.
 */
-const applyMinimalTrackedReplacement = ({ tr, item, replacement, commentMark, replacementBackground, styleResolver, diffText, revisionIdDelete, revisionIdInsert, revisionIdBackgroundSeed, author, date, initials, suggestionId }) => {
+const applyMinimalTrackedReplacement = ({ tr, item, noteReferences, replacement, commentMark, replacementBackground, styleResolver, diffText, revisionIdDelete, revisionIdInsert, revisionIdBackgroundSeed, author, date, initials, suggestionId }) => {
 	const schema = tr.doc.type.schema;
 	const insertionType = schema.marks["insertion"];
 	const deletionType = schema.marks["deletion"];
@@ -2834,9 +4208,24 @@ const applyMinimalTrackedReplacement = ({ tr, item, replacement, commentMark, re
 		doc: tr.doc,
 		item,
 		replacement,
-		planChanges: (source) => changesFromSegments(diffText(source, replacement))
+		noteReferences,
+		planChanges: (source, target) => changesFromSegments(diffText(source, target)),
+		keepFieldsOf: planTextChanges
 	});
 	if (plan === null) return null;
+	const directPlan = planDocumentReplacement({
+		doc: tr.doc,
+		item,
+		replacement,
+		noteReferences,
+		planChanges: planTextChanges
+	});
+	const allocatedMarks = directPlan === null ? null : directReplacementMarks({
+		doc: tr.doc,
+		plan: directPlan,
+		replacementBackground
+	});
+	const unifiesFormatting = directPlan === null ? false : replacementUnifiesFormatting(tr.doc, directPlan);
 	let nextTr = tr;
 	let backgroundRevisionIds = [];
 	let nextRevisionId = revisionIdBackgroundSeed;
@@ -2886,10 +4275,39 @@ const applyMinimalTrackedReplacement = ({ tr, item, replacement, commentMark, re
 		...revisionAttrs
 	});
 	const insertedMarks = (marks) => marks.filter((mark) => !REVISION_MARK_NAMES.has(mark.type.name) && mark.type.name !== "runPropertyChange" && !(clearsBackground && BACKGROUND_MARK_NAMES.has(mark.type.name)));
-	for (const change of plan.planned.toReversed()) {
+	const replacementStarts = [];
+	let replacementShift = 0;
+	for (const { change } of plan.planned) {
+		replacementStarts.push(change.start + replacementShift);
+		replacementShift += change.text.length - (change.end - change.start);
+	}
+	const insertedNodes = (text, replacementStart, fallback) => {
+		if (allocatedMarks?.length !== replacement.length) return cleanTextInlineNodes({
+			schema,
+			text,
+			marks: insertedMarks(fallback)
+		});
+		const marksAt = (offset) => allocatedMarks[replacementStart + offset] ?? fallback;
+		const nodes = [];
+		let groupStart = 0;
+		for (let offset = 1; offset <= text.length; offset++) {
+			if (offset < text.length && Mark.sameSet(marksAt(offset), marksAt(groupStart))) continue;
+			nodes.push(...cleanTextInlineNodes({
+				schema,
+				text: text.slice(groupStart, offset),
+				marks: insertedMarks(marksAt(groupStart))
+			}));
+			groupStart = offset;
+		}
+		return nodes;
+	};
+	for (let plannedIndex = plan.planned.length - 1; plannedIndex >= 0; plannedIndex--) {
+		const change = plan.planned[plannedIndex];
+		if (change === void 0) panic("A planned replacement change went missing", { plannedIndex });
 		const doc = nextTr.doc;
 		let at;
 		let marks;
+		let removedFrom = null;
 		if (change.insertion !== void 0) {
 			at = change.insertion.at;
 			marks = change.insertion.marks(doc);
@@ -2899,6 +4317,7 @@ const applyMinimalTrackedReplacement = ({ tr, item, replacement, commentMark, re
 			const styleSource = plan.replacementStyleSource(change.change);
 			if (first === void 0 || last === void 0 || styleSource === null) panic("A planned replacement lost the characters it removes");
 			at = last.to;
+			removedFrom = first.from;
 			marks = addCarriedMarks(inheritedReplacementMarks(doc, styleSource.from, styleSource.to), surveyReplacedAnnotations(doc, first.from, last.to).carried);
 			for (const piece of change.pieces) {
 				nextTr = nextTr.addMark(piece.from, piece.to, deletion);
@@ -2906,21 +4325,36 @@ const applyMinimalTrackedReplacement = ({ tr, item, replacement, commentMark, re
 			}
 		}
 		if (change.text.length === 0) continue;
-		const nodes = cleanTextInlineNodes({
-			schema,
-			text: change.text,
-			marks: insertedMarks(marks)
-		});
-		nextTr = nextTr.insert(at, nodes);
-		const end = at + Fragment.fromArray(nodes).size;
-		nextTr = nextTr.addMark(at, end, insertion);
-		if (commentMark) nextTr = nextTr.addMark(at, end, commentMark);
+		const pieces = insertedNodes(change.text, replacementStarts[plannedIndex] ?? 0, marks);
+		const positions = removedFrom === null ? pieces.map(() => at) : placeTrackedInsertion(nextTr.doc, removedFrom, at, pieces.map((node) => node.marks));
+		const runs = [];
+		for (const [index, piece] of pieces.entries()) {
+			const position = positions[index] ?? at;
+			const run = runs.at(-1);
+			if (run?.at === position) run.pieces.push(piece);
+			else runs.push({
+				at: position,
+				pieces: [piece]
+			});
+		}
+		for (const run of runs.toReversed()) {
+			let nodes = run.pieces;
+			if (removedFrom === null) {
+				const pieceMarks = commentsForTrackedInsertion(nextTr.doc, run.at, run.pieces.map((node) => node.marks));
+				nodes = run.pieces.map((node, index) => node.mark(pieceMarks[index] ?? node.marks));
+			}
+			nextTr = nextTr.insert(run.at, nodes);
+			const end = run.at + Fragment.fromArray(nodes).size;
+			nextTr = nextTr.addMark(run.at, end, insertion);
+			if (commentMark) nextTr = nextTr.addMark(run.at, end, commentMark);
+		}
 	}
 	return {
 		type: "applied",
 		transaction: nextTr,
 		backgroundRevisionIds,
-		nextRevisionId
+		nextRevisionId,
+		unifiesFormatting
 	};
 };
 /**
@@ -2980,7 +4414,7 @@ const clearTouchedBackground = ({ tr, ranges, styleResolver }) => {
 	});
 	return nextTr;
 };
-const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId }) => {
+const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId, noteReferences }) => {
 	const anchor = snapshot.anchors[blockId];
 	if (!anchor) return {
 		type: "skip",
@@ -3006,7 +4440,10 @@ const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId
 		type: "skip",
 		reason: "changedBlock"
 	};
-	const cleanBlock = buildCleanBlockText(live.node, live.from);
+	const cleanBlock = buildCleanBlockText(live.node, live.from, {
+		fieldResults: "text",
+		noteReferences
+	});
 	const currentText = cleanBlock.text;
 	const currentTextHash = hashFolioAIBlockText(normalizeFolioAIBlockText(currentText));
 	const structuralBoundaryHash = hashFolioAIBlockStructuralBoundaries(cleanBlock);
@@ -3024,13 +4461,52 @@ const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId
 		currentTextHash
 	};
 };
-const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, doc }) => {
+const resolveOperation = (args) => {
+	const resolution = resolveOperationTarget(args);
+	if (resolution.type === "skip") return resolution;
+	return (noteReferenceEditsAllowed() ? null : refuseNoteReferenceEdit(resolution.operation, args.noteReferences)) ?? resolution;
+};
+/**
+* A text change may rewrite the prose around a footnote or endnote reference
+* but never the reference: its marker is structure the clean text shows, not
+* characters it holds. The replacement has to keep every marker its match
+* covers, in order, and may not write a marker-shaped string of its own; the
+* replacement's inline emphasis would rebuild the match whole, reference
+* included, so it cannot carry one either. Checked before anything is applied,
+* so direct and tracked mode refuse the same operations.
+*/
+const refuseNoteReferenceEdit = (item, noteReferences) => {
+	const { operation } = item;
+	let replacement;
+	if (operation.type === "replaceInBlock" || operation.type === "replaceRange") replacement = operation.replace;
+	else if (operation.type === "replaceBlock") replacement = operation.text;
+	else return null;
+	const cleanBlock = buildCleanBlockText(item.blockNode, item.blockFrom, {
+		fieldResults: "text",
+		noteReferences
+	});
+	const span = replacedCleanSpan({ operation }, cleanBlock);
+	if (span === null) return null;
+	const spans = noteReferenceSpansWithin(cleanBlock, span.start, span.start + span.text.length);
+	const rebuildsBlock = operation.type === "replaceBlock" && operation.preserveFormatting === false;
+	if (spans.length > 0 && (hasInlineEmphasis(replacement) || rebuildsBlock)) return {
+		type: "skip",
+		reason: "protectedReference"
+	};
+	if (operation.type === "replaceBlock" && replacement === span.text) return null;
+	return segmentsAroundNoteReferences(span.text, stripInlineEmphasisMarkers(replacement), spans) === null ? {
+		type: "skip",
+		reason: "protectedReference"
+	} : null;
+};
+const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, noteReferences, doc }) => {
 	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
 	const primaryBlock = resolveStableBlock({
 		snapshot,
 		blockId,
 		liveBlocks,
-		liveBlocksByParaId
+		liveBlocksByParaId,
+		noteReferences
 	});
 	if (primaryBlock.type === "skip") return primaryBlock;
 	const { blockNode, blockFrom, blockTo, cleanBlock, currentText, currentTextHash } = primaryBlock;
@@ -3049,6 +4525,16 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "skip",
 			reason: "staleRange"
 		};
+		const characterSplit = describeCharacterSplit(currentText, [startOffset, endOffset], operation.type === "replaceRange" ? "grapheme" : "codePoint");
+		if (characterSplit !== null) return {
+			type: "skip",
+			reason: "splitsCharacter",
+			message: characterSplit
+		};
+		if (cutsIntoNoteReference(cleanBlock, startOffset, endOffset)) return {
+			type: "skip",
+			reason: "protectedReference"
+		};
 		const range = resolveCleanTextRange({
 			cleanBlock,
 			startOffset,
@@ -3079,7 +4565,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		const isInsertAfter = operation.type === "insertAfterBlock";
 		let insertFrom;
 		if (tableBoundary) insertFrom = isInsertAfter ? tableBoundary.after : tableBoundary.before;
-		else insertFrom = isInsertAfter ? blockTo : blockFrom;
+		else insertFrom = isInsertAfter ? endOfParagraphWithItsTextBoxes(doc, blockFrom) : blockFrom;
 		const insertTexts = operation.lineBreakMode !== "inline" && LINE_BREAK_PATTERN.test(operation.text) ? splitInsertParagraphTexts(operation.text) : [operation.text];
 		return {
 			type: "resolved",
@@ -3103,7 +4589,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
 		let insertFrom;
 		if (tableBoundary) insertFrom = position === "after" ? tableBoundary.after : tableBoundary.before;
-		else insertFrom = position === "after" ? blockTo : blockFrom;
+		else insertFrom = position === "after" ? endOfParagraphWithItsTextBoxes(doc, blockFrom) : blockFrom;
 		return {
 			type: "resolved",
 			operation: {
@@ -3122,10 +4608,20 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			blockFrom,
 			position: operation.position ?? "after"
 		});
-		if (!insertion || (operation.cellTexts?.length ?? 0) > insertion.columnCount) return {
+		if (!insertion) return {
 			type: "skip",
 			reason: "unsupportedBlock"
 		};
+		const overflow = describeUnplacedCellTexts({
+			cellTexts: operation.cellTexts,
+			capacity: insertion.cells.length,
+			target: "row"
+		});
+		if (overflow !== null) return {
+			type: "skip",
+			reason: "payloadDoesNotFit",
+			message: overflow
+		};
 		return {
 			type: "resolved",
 			operation: {
@@ -3135,7 +4631,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				blockFrom,
 				blockTo,
 				blockNode,
-				tableRowInsertion: insertion
+				tableRowInsertion: insertion,
+				tableRowComments: commentsAcrossBlockBoundary(doc, insertion.rowPosition)
 			}
 		};
 	}
@@ -3183,7 +4680,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				blockFrom,
 				blockTo,
 				blockNode,
-				tableColumnInsertion
+				tableColumnInsertion,
+				tableColumnComments: commentsAcrossTable(doc, tableColumnInsertion.tablePosition)
 			}
 		};
 	}
@@ -3248,7 +4746,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				snapshot,
 				blockId: operation.endBlockId,
 				liveBlocks,
-				liveBlocksByParaId
+				liveBlocksByParaId,
+				noteReferences
 			});
 			if (endTarget.type === "skip") return endTarget;
 			const endCell = findEnclosingTableCell(doc, endTarget.blockFrom);
@@ -3320,7 +4819,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 	if (operation.type === "insertTable") {
 		const boundary = findOutermostTableBoundary(doc, blockFrom) ?? {
 			before: blockFrom,
-			after: blockTo
+			after: endOfParagraphWithItsTextBoxes(doc, blockFrom)
 		};
 		const insertFrom = (operation.position ?? "after") === "after" ? boundary.after : boundary.before;
 		return {
@@ -3382,6 +4881,12 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "skip",
 			reason: "staleRange"
 		};
+		const characterSplit = describeCharacterSplit(currentText, [startOffset, endOffset], "grapheme");
+		if (characterSplit !== null) return {
+			type: "skip",
+			reason: "splitsCharacter",
+			message: characterSplit
+		};
 		const range = resolveCleanTextRange({
 			cleanBlock,
 			startOffset,
@@ -3420,10 +4925,14 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			}
 		};
 	}
+	if (operation.type === "replaceBlock" && isPendingDeletion(doc, blockFrom, blockNode, currentText)) return {
+		type: "skip",
+		reason: "pendingDeletion"
+	};
 	if (operation.type === "deleteBlock" || operation.type === "replaceBlock") {
 		const replaceChangesText = operation.type === "replaceBlock" && operation.text !== currentText;
 		const replaceChangesStyle = operation.type === "replaceBlock" && operation.styleId !== void 0 && operation.styleId !== (expectParagraphAttrs(blockNode).styleId ?? null);
-		if (replaceChangesText && cleanBlock.structuralBoundaries.length > 0) return {
+		if (replaceChangesText && cleanBlock.structuralBoundaries.some((boundary) => boundary.type !== "field" && boundary.type !== "noteReference")) return {
 			type: "skip",
 			reason: "unsupportedBlock"
 		};
@@ -3503,7 +5012,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		reason: "noopOperation"
 	};
 	const quote = getOperationQuote(operation);
-	const range = resolveTextInCleanBlock(cleanBlock, quote || currentText);
+	const range = resolveTextInCleanBlock(cleanBlock, quote || currentText, operation.type === "replaceInBlock" ? "grapheme" : "codePoint");
 	if (range.type !== "resolved") return range;
 	return {
 		type: "resolved",
@@ -3517,7 +5026,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		}
 	};
 };
-const resolveTextInCleanBlock = (cleanBlock, find) => {
+const resolveTextInCleanBlock = (cleanBlock, find, strictness) => {
 	if (find.length === 0) return {
 		type: "skip",
 		reason: "emptyOperation"
@@ -3532,6 +5041,16 @@ const resolveTextInCleanBlock = (cleanBlock, find) => {
 		type: "skip",
 		reason: "ambiguousFind"
 	};
+	const characterSplit = describeCharacterSplit(text, [firstIndex, firstIndex + find.length], strictness);
+	if (characterSplit !== null) return {
+		type: "skip",
+		reason: "splitsCharacter",
+		message: `the match's ${characterSplit}`
+	};
+	if (cutsIntoNoteReference(cleanBlock, firstIndex, firstIndex + find.length)) return {
+		type: "skip",
+		reason: "protectedReference"
+	};
 	const range = resolveCleanTextRange({
 		cleanBlock,
 		startOffset: firstIndex,
@@ -3557,9 +5076,128 @@ const getTextRangeFromCleanBlock = (cleanBlock) => {
 	};
 };
 const getOperationCommentText = (operation) => "comment" in operation ? operation.comment?.text : void 0;
+/**
+* Every paragraph style an operation names, with the field that names it.
+* `null` clears the style and names none; an omitted one keeps the style the
+* paragraph or its anchor already carries, which the document holds by
+* construction.
+*/
+const operationParagraphStyleReferences = (operation) => {
+	switch (operation.type) {
+		case "insertAfterBlock":
+		case "insertBeforeBlock":
+		case "replaceBlock": return [{
+			path: "styleId",
+			styleId: operation.styleId
+		}];
+		case "setBlockParagraphProperties": return [{
+			path: "properties.styleId",
+			styleId: operation.properties.styleId
+		}];
+		case "splitBlock": return [{
+			path: "firstParagraphProperties.styleId",
+			styleId: operation.firstParagraphProperties?.styleId
+		}, {
+			path: "secondParagraphProperties.styleId",
+			styleId: operation.secondParagraphProperties?.styleId
+		}];
+		case "mergeBlockWithNext": return [{
+			path: "mergedParagraphProperties.styleId",
+			styleId: operation.mergedParagraphProperties?.styleId
+		}];
+		default: return [];
+	}
+};
+/**
+* The first paragraph style the operation names that the document does not
+* define as a paragraph style. A `w:pStyle` naming no definition, or a table
+* or character style, confers no formatting: the paragraph keeps its body
+* look while the operation reports a restyle. Refused here, before anything
+* is applied, the way an undefined block id is. `null` definitions (a state
+* without the styles plugin) cannot say what is defined, and check nothing.
+*/
+const findUndefinedParagraphStyleReference = (operation, definitions) => {
+	if (definitions === null) return;
+	for (const { path, styleId } of operationParagraphStyleReferences(operation)) {
+		if (styleId === null || styleId === void 0) continue;
+		const definition = definitions.get(styleId);
+		if (definition?.type !== "paragraph") return {
+			path,
+			styleId,
+			definedAs: definition?.type
+		};
+	}
+};
+const MAX_LISTED_PARAGRAPH_STYLES = 12;
+const describeUndefinedParagraphStyle = ({ path, styleId, definedAs }, definitions) => {
+	const defined = (definitions?.paragraphStyles() ?? []).map((style) => style.styleId);
+	let available = "it defines no visible paragraph styles";
+	if (defined.length > 0) available = `its paragraph styles include ${defined.slice(0, MAX_LISTED_PARAGRAPH_STYLES).join(", ")}${defined.length > MAX_LISTED_PARAGRAPH_STYLES ? ", …" : ""}`;
+	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) => {
+	if (numbering === null || numbering === void 0) return;
+	const numId = Reflect.get(numbering, "numId");
+	return typeof numId === "number" ? numId : void 0;
+};
+/**
+* Every numbering instance an operation names, with the field that names it.
+* `listLevel` is not among them: it keeps the instance the paragraph or its
+* anchor already references, which the document holds by construction.
+*/
+const operationNumberingReferences = (operation) => {
+	switch (operation.type) {
+		case "insertAfterBlock":
+		case "insertBeforeBlock": return [{
+			path: "numbering",
+			numbering: operation.numbering
+		}];
+		case "setBlockParagraphProperties": return [{
+			path: "properties.numbering",
+			numbering: operation.properties.numbering
+		}];
+		case "splitBlock": return [{
+			path: "firstParagraphProperties.numbering",
+			numbering: operation.firstParagraphProperties?.numbering
+		}, {
+			path: "secondParagraphProperties.numbering",
+			numbering: operation.secondParagraphProperties?.numbering
+		}];
+		case "mergeBlockWithNext": return [{
+			path: "mergedParagraphProperties.numbering",
+			numbering: operation.mergedParagraphProperties?.numbering
+		}];
+		default: return [];
+	}
+};
+/**
+* The first numbering instance the operation names that the document does not
+* define. A paragraph referencing a missing `w:num` is a model no save can
+* write, so it is refused here, before anything is applied, the way a block id
+* naming no block is. `null` instance ids (a state without the numbering
+* plugin) cannot say what is defined, and check nothing.
+*/
+const findUndefinedNumberingReference = (operation, instanceIds) => {
+	if (instanceIds === null) return;
+	for (const { path, numbering } of operationNumberingReferences(operation)) {
+		const numId = statedNumberingInstance(numbering);
+		if (numId !== void 0 && !instanceIds.has(numId)) return {
+			path,
+			numId
+		};
+	}
+};
+const MAX_LISTED_NUMBERING_INSTANCES = 12;
+const describeUndefinedNumbering = ({ path, numId }, instanceIds) => {
+	const defined = [...instanceIds ?? []].sort((left, right) => left - right);
+	let available = "it defines none";
+	if (defined.length > 0) available = `it defines ${defined.slice(0, MAX_LISTED_NUMBERING_INSTANCES).join(", ")}${defined.length > MAX_LISTED_NUMBERING_INSTANCES ? ", …" : ""}`;
+	return `${path}.numId ${String(numId)} names no numbering instance in this document (${available}).`;
+};
 const getOperationQuote = (operation) => {
 	if (operation.type === "replaceInBlock") return operation.find;
 	if (operation.type === "commentOnBlock") return operation.quote;
 };
 //#endregion
-export { applyFolioAIEditOperations, previewFolioAIEditOperations };
+export { applyFolioAIEditOperations, previewFolioAIEditOperations, previewFolioAIEditOperationsWithResult };