@stll/folio-core 0.53.0 → 0.54.1

package/dist/ai-edits/apply.js

@@ -2,10 +2,12 @@ import { paragraphNumberingReference, paragraphNumberingReferenceId } from "../d
 import { formattingEquals } from "../docx/runConsolidator.js";
 import { isStyleSourcedParagraphNumbering } from "../internal/paragraphFormattingSerialization.js";
 import { deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween } from "../prosemirror/anchoredTextBoxes.js";
-import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.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";
@@ -15,9 +17,11 @@ 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, getDocumentNumberingInstanceIds } from "../prosemirror/plugins/documentNumbering.js";
-import { getDocumentStyleDefinitions, getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.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";
@@ -25,6 +29,7 @@ import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prose
 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";
@@ -35,8 +40,9 @@ import { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers
 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 { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
+import { isEmptyTableCell, mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
 import { planTableMutations } from "./table-mutation-plan.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";
@@ -346,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;
@@ -425,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,
@@ -476,45 +493,25 @@ const applyBlockParagraphProperties = ({ tr, position, node, properties, styleRe
 		tr,
 		revisionIds: []
 	};
-	const styled = bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs);
 	return {
-		tr: (attrs.styleId ?? null) === (nextStyleId ?? null) ? styled : rebaseParagraphRuns({
-			tr: styled,
+		tr: rebaseParagraphRuns({
+			tr: bridgeResult.tr.setNodeMarkup(position, void 0, nextAttrs),
 			position,
 			previous: node,
-			styleResolver
+			styleResolver,
+			storedMarks
 		}),
 		changed: true,
 		revisionId: change?.info.id ?? null,
 		revisionIds: change ? [change.info.id, ...bridgeResult.revisionIds] : []
 	};
 };
-/** Rebuild rendered marks after the paragraph's style cascade changes. */
-const rebaseParagraphRuns = ({ tr, position, previous, target, styleResolver }) => {
-	const paragraph = tr.doc.nodeAt(position);
-	if (!paragraph) return tr;
-	const sourceContext = paragraphRunStyleContext(previous, styleResolver);
-	const targetContext = paragraphRunStyleContext(target ?? paragraph, styleResolver);
-	const representations = selectRunFormattingCarrierRepresentations({
-		doc: tr.doc,
-		from: position + 1,
-		to: position + paragraph.nodeSize - 1
-	});
-	for (const representation of representations) applyMarksToRunFormattingRepresentation({
-		tr,
-		representation,
-		marks: reconcileRunFormattingMarks({
-			authoredFormatting: readAuthoredRunFormatting({
-				context: sourceContext,
-				marks: representation.node.marks,
-				styleResolver
-			}),
-			context: targetContext,
-			node: representation.node,
-			styleResolver
-		})
-	});
-	return tr;
+/** 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 {
@@ -529,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,
@@ -573,13 +571,13 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		tr,
 		revisionIds: []
 	};
-	const styled = bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs);
 	return {
-		tr: (attrs.styleId ?? null) === item.operation.styleId ? styled : rebaseParagraphRuns({
-			tr: styled,
+		tr: rebaseParagraphRuns({
+			tr: bridgeResult.tr.setNodeMarkup(blockPosition, void 0, nextAttrs),
 			position: blockPosition,
 			previous: block,
-			styleResolver
+			styleResolver,
+			storedMarks
 		}),
 		revisionId: change?.info.id ?? null,
 		revisionIds: change ? [change.info.id, ...bridgeResult.revisionIds] : []
@@ -978,6 +976,27 @@ const deletedRowAffectedRanges = ({ doc, deletion, row }) => {
 	}
 	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;
@@ -1028,9 +1047,7 @@ const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
 				type: "deleteBlock",
 				block,
 				end: item.blockTo,
-				keepsParagraph,
-				removesNode: !producesTrackedChanges && !keepsParagraph,
-				direct: !producesTrackedChanges
+				keepsParagraph
 			};
 		}
 		case "insertAfterBlock":
@@ -1090,10 +1107,12 @@ const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
 			let axis = "cell";
 			if (item.operation.type === "insertTableRow") axis = "row";
 			if (item.operation.type === "insertTableColumn") axis = "column";
-			return target.type === "none" ? { type: "unclaimed" } : {
+			if (target.type === "none") return { type: "unclaimed" };
+			return {
 				type: "tableStructure",
 				table: target.tablePosition,
-				axis
+				axis,
+				folded: target.type === "mergeCells" ? foldedBlankCellRanges(doc, target) : []
 			};
 		}
 	}
@@ -1251,6 +1270,21 @@ 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);
@@ -1350,6 +1384,20 @@ const holdsOnlyDeletedContent = (paragraph) => {
 	});
 	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. */
@@ -1380,11 +1428,30 @@ const deletedFinalParagraphAfter = (at, paragraphTypeName) => {
 * 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);
+	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
@@ -1409,6 +1476,43 @@ const finalBreakCarrierBefore = (at, paragraphTypeName, batchRevisionIds) => {
 	}
 	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.spec["tableRole"] === "table" && node.childCount > 0) {
+			let allRowsDeleted = true;
+			node.forEach((row) => {
+				allRowsDeleted &&= expectTableRowAttrs(row).trDel != null;
+			});
+			if (allRowsDeleted) continue;
+		}
+		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.
 *
@@ -1432,7 +1536,7 @@ const finalBreakCarrierBefore = (at, paragraphTypeName, batchRevisionIds) => {
 * 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, appliedIds, batchRevisionIds, revisionSeed, author, date }) => {
+const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appliedIds, batchRevisionIds, revisionSeed, author, date, styleResolver, numbering }) => {
 	let nextRevisionId = revisionSeed;
 	const addedRevisions = [];
 	const retractedRevisionIds = [];
@@ -1444,76 +1548,92 @@ const withRetiredFinalParagraphs = ({ tr, deletions, appliedIds, batchRevisionId
 	for (const { deletion: { operationId, revisionExtras }, at } of located) {
 		const emptied = tr.doc.nodeAt(at);
 		if (emptied?.type.name !== "paragraph") continue;
-		const $emptied = tr.doc.resolve(at);
-		if (!paragraphEndsItsContainer($emptied, emptied.type.name)) continue;
-		let position = at;
-		for (let index = $emptied.index() - 1; index >= 0; index--) {
-			const previous = $emptied.parent.child(index);
-			position -= previous.nodeSize;
-			if (previous.type.name !== emptied.type.name) break;
-			const mark = previous.attrs["pPrMark"];
-			if (mark == null) {
-				const revisionId = nextRevisionId++;
-				tr.setNodeAttribute(position, "pPrMark", {
-					kind: "del",
-					info: {
-						id: revisionId,
-						author,
-						date,
-						...revisionExtras
-					}
-				});
-				resolvedOperationIds.add(operationId);
+		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
 				});
-				break;
 			}
-			if (isPlainDeletedPPrMark(mark)) {
-				if (holdsOnlyDeletedContent(previous)) continue;
-				break;
-			}
-			if (isInsertedPPrMark(mark)) {
-				const following = tr.doc.nodeAt(position + previous.nodeSize);
-				if (following?.type.name !== emptied.type.name) break;
-				const previousFormatting = paragraphPropertiesBeforeBatch(following, batchRevisionIds);
-				const formattingChanges = JSON.stringify(previousFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(previous));
-				const existing = expectParagraphAttrs(previous)._propertyChanges;
-				if (formattingChanges && hasSerializableParagraphPropertyChange(existing)) break;
-				joinAtParagraphMark({
-					tr,
-					paragraphPos: position,
-					paragraph: previous,
-					next: following
-				});
-				resolvedOperationIds.add(operationId);
-				const retracted = addedBreakRevisionId(mark);
-				if (retracted !== null) retractedRevisionIds.push(retracted);
-				const joined = tr.doc.nodeAt(position);
-				if (formattingChanges && joined) {
-					const revisionId = nextRevisionId++;
-					tr.setNodeMarkup(position, void 0, {
-						...joined.attrs,
-						_propertyChanges: [...Array.isArray(existing) ? existing : [], {
-							type: "paragraphPropertyChange",
-							info: {
-								id: revisionId,
-								author,
-								date,
-								...revisionExtras
-							},
-							previousFormatting
-						}]
-					});
-					addedRevisions.push({
-						operationId,
-						revisionId
-					});
-				}
-				break;
-			}
-			break;
+			continue;
 		}
 	}
 	return {
@@ -1545,6 +1665,8 @@ const withRetiredFinalParagraphs = ({ tr, deletions, appliedIds, batchRevisionId
 * 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
@@ -1553,7 +1675,7 @@ const withRetiredFinalParagraphs = ({ tr, deletions, appliedIds, batchRevisionId
 * 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;
@@ -1586,6 +1708,24 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 	};
 	collectSupersededDeletedBreaks(tr.doc, 0);
 	for (const { preceding, inserted, deletedMark, precedingMark } of supersededDeletedBreaks) {
+		const insertionRevisionId = addedBreakRevisionId(precedingMark);
+		if (insertionRevisionId !== null) {
+			const previous = tr.doc.nodeAt(preceding);
+			const current = tr.doc.nodeAt(inserted);
+			if (!previous || !current) panic("A shifted paragraph break lost its carrier");
+			const previousFormatting = paragraphPropertiesOnReject(previous);
+			const existing = expectParagraphAttrs(current)._propertyChanges;
+			if (!hasSerializableParagraphPropertyChange(existing) && JSON.stringify(previousFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(current))) tr.setNodeAttribute(inserted, "_propertyChanges", [...Array.isArray(existing) ? existing : [], {
+				type: "paragraphPropertyChange",
+				info: {
+					id: insertionRevisionId,
+					author,
+					date,
+					...initials ? { initials } : {}
+				},
+				previousFormatting
+			}]);
+		}
 		tr.setNodeAttribute(preceding, "pPrMark", precedingMark);
 		tr.setNodeAttribute(inserted, "pPrMark", deletedMark);
 	}
@@ -1634,7 +1774,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++) {
@@ -1680,7 +1820,7 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 					paragraphPos: previous.position,
 					paragraph: deleted,
 					next: following,
-					firstIsGoing: true
+					styleResolver
 				});
 				retractedRevisionIds.push(ownerRevisionId);
 				const deletedBreakId = addedOrDeletedBreakRevisionId(displacedMark);
@@ -1875,7 +2015,7 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 			...initials ? { initials } : {}
 		};
 		const paragraph = item.blockNode.type.create(attrs, content);
-		const sourceContext = paragraphRunStyleContext(operation.inheritFormatting === false ? item.blockNode.type.create({}) : item.blockNode, styleResolver);
+		const sourceContext = OPERATION_TEXT_CONTEXT;
 		const targetContext = paragraphRunStyleContext(paragraph, styleResolver);
 		const reconciled = [];
 		paragraph.forEach((child) => {
@@ -2125,6 +2265,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 	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;
@@ -2141,6 +2282,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 	};
 	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();
@@ -2671,9 +2813,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				}
 				const revision = structuralRevision;
 				const template = tableTemplates?.get(item.operation.id);
+				const mappedInsertion = mapTableRowInsertion(tr, insertion);
 				const result = applyTableRowInsertion({
 					tr,
-					insertion: mapTableRowInsertion(tr, insertion),
+					insertion: mappedInsertion,
 					cellTexts: item.operation.cellTexts,
 					revision,
 					...template !== void 0 && { template }
@@ -2685,7 +2828,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					continue;
 				}
-				tr = result.transaction;
+				tr = addCommentsOver(result.transaction, mappedInsertion.rowPosition, item.tableRowComments);
 				if (result.revisionId !== null) {
 					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
@@ -2723,11 +2866,9 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					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;
@@ -2747,7 +2888,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					tr,
 					deletion,
 					insertedColumnCount: insertedColumnCounts.get(columnKey) ?? 0,
-					revision
+					revision,
+					emptiedRows
 				});
 				if (result.type === "unsupported") {
 					skipped.push({
@@ -2757,10 +2899,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					continue;
 				}
 				tr = result.transaction;
-				if (result.revisionId !== null) {
-					operationRevisionSeed++;
-					appliedRevisionIds = [result.revisionId];
-				}
+				operationRevisionSeed += result.revisionIds.length;
+				appliedRevisionIds = [...result.revisionIds];
 				break;
 			}
 			case "mergeTableCells": {
@@ -2893,8 +3033,26 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						});
 						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);
+					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) {
@@ -2922,14 +3080,36 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					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"])) joinAtParagraphMark({
-						tr,
-						paragraphPos: markPosition,
-						paragraph: deleted,
-						next: following,
-						firstIsGoing: true
-					});
-					else if (!endsItsContainer && deleted?.attrs["pPrMark"] == null) {
+					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",
@@ -3218,8 +3398,17 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				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) => {
@@ -3253,6 +3442,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						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);
@@ -3280,42 +3470,77 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 							tr,
 							paragraphPos: item.blockFrom,
 							paragraph,
-							next
+							next,
+							styleResolver
 						});
-						const previousFormatting = paragraphPropertiesSnapshot(next);
-						const existing = expectParagraphAttrs(paragraph)._propertyChanges;
-						if (holdsOnlyInsertedContent(paragraph) && !hasSerializableParagraphPropertyChange(existing) && JSON.stringify(paragraphPropertiesSnapshot(paragraph)) !== JSON.stringify(previousFormatting)) tr = tr.setNodeAttribute(item.blockFrom, "_propertyChanges", [...Array.isArray(existing) ? existing : [], {
-							type: "paragraphPropertyChange",
+						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
-							},
-							previousFormatting
-						}]);
-						else 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,
@@ -3325,6 +3550,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					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":
@@ -3373,6 +3602,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			...suggestionId !== null && { suggestionId }
 		});
 	}
+	removeRowsWithoutCellsAfterBatch(tr, emptiedRows);
 	if (tr.docChanged || deferredNoopFinalDeletions.size > 0) {
 		const batchRevisionIds = new Set(applied.flatMap(({ revisionIds }) => revisionIds ?? []));
 		tr = withoutRevisionsOnZeroWidthAnchors(tr, batchRevisionIds, deletedTextBoxAnchorIds);
@@ -3384,18 +3614,22 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			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
+			date,
+			styleResolver,
+			numbering
 		});
 		revisionSeed = retired.nextRevisionId;
 		for (const operationId of deferredNoopFinalDeletions) {
@@ -3447,6 +3681,19 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				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)}`);
 		if (tr.docChanged) view.dispatch(tr);
@@ -4409,7 +4656,8 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 				blockFrom,
 				blockTo,
 				blockNode,
-				tableRowInsertion: insertion
+				tableRowInsertion: insertion,
+				tableRowComments: commentsAcrossBlockBoundary(doc, insertion.rowPosition)
 			}
 		};
 	}
@@ -4457,7 +4705,8 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 				blockFrom,
 				blockTo,
 				blockNode,
-				tableColumnInsertion
+				tableColumnInsertion,
+				tableColumnComments: commentsAcrossTable(doc, tableColumnInsertion.tablePosition)
 			}
 		};
 	}