@stll/folio-core 0.35.1 → 0.37.0

package/dist/ai-edits/apply.js

@@ -1,25 +1,85 @@
-import { expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
-import { PPR_CHANGE_SCOPED_ATTR_KEYS } from "../prosemirror/commands/propertyChangeScope.js";
+import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "../prosemirror/commands/propertyChangeScope.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../prosemirror/containerFinalParagraph.js";
-import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.js";
 import { requestDeterministicParaIds } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
 import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { CLEARED_LIST_RENDERING_ATTRS } from "../prosemirror/listMarker.js";
+import { directParagraphAlignment } from "../prosemirror/paragraphAlignment.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 { selectRunFormattingCarrierRepresentations } from "../prosemirror/runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
+import { listLevelAttrPatch } from "../prosemirror/styles/resolvedStyleAttrs.js";
 import { isZeroWidthAnchor } from "../prosemirror/zeroWidthAnchors.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.js";
 import { stripBlockIdentityAttrs } from "./block-identity.js";
-import { buildCleanBlockText } from "./clean-text.js";
+import { buildCleanBlockText, resolveCleanTextRange } from "./clean-text.js";
 import { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers } from "./inline-emphasis.js";
-import { hashFolioAIBlockText, isHiddenTableRow, normalizeFolioAIBlockText } from "./snapshot.js";
+import { hashFolioAIBlockStructuralBoundaries, hashFolioAIBlockText, isHiddenTableRow, normalizeFolioAIBlockText } from "./snapshot.js";
 import { 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 { findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBoundary, tableRectangleCutsMergedCell } from "./table-targets.js";
 import { tableFromTemplate } from "./table-template.js";
-import { diffWordSegments } from "./word-diff.js";
+import { wordDiffSessionFromOptions } from "./word-diff.js";
 import { panic } from "better-result";
+import { Mark } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { canJoin, canSplit } from "prosemirror-transform";
 //#region src/ai-edits/apply.ts
+const coarseWordDiff = (before, after) => {
+	if (before === after) return before.length === 0 ? [] : [{
+		type: "equal",
+		text: before
+	}];
+	if (before.length === 0) return [{
+		type: "ins",
+		text: after
+	}];
+	if (after.length === 0) return [{
+		type: "del",
+		text: before
+	}];
+	return [{
+		type: "del",
+		text: before
+	}, {
+		type: "ins",
+		text: after
+	}];
+};
+const commentMarkRanges = (doc, commentType, commentId) => {
+	const ranges = [];
+	doc.descendants((node, position) => {
+		for (const mark of node.marks) if (mark.type === commentType && mark.attrs["commentId"] === commentId) ranges.push({
+			from: position,
+			to: position + node.nodeSize,
+			mark
+		});
+	});
+	return ranges;
+};
+/**
+* Replace an operation-local comment id only after its edit has succeeded.
+* The provisional mark lives solely in the undispatched transaction, so an
+* operation that refuses or produces no anchor has no external comment side
+* effect and cannot leave an orphan comments.xml entry behind.
+*/
+const commitProvisionalComment = ({ tr, commentType, provisionalId, committedId }) => {
+	const ranges = commentMarkRanges(tr.doc, commentType, provisionalId);
+	if (ranges.length === 0) panic("A commented operation changed the document without producing a comment anchor");
+	if (provisionalId === committedId) return tr;
+	for (const { from, to, mark } of ranges) {
+		tr = tr.removeMark(from, to, mark);
+		tr = tr.addMark(from, to, commentType.create({
+			...mark.attrs,
+			commentId: committedId
+		}));
+	}
+	return tr;
+};
 /**
 * Operation types applied in `"suggested"` mode. Every produced revision — an
 * inline mark, a whole-node `_suggestedInsert` marker, or a suggested
@@ -31,6 +91,7 @@ const SUGGESTED_SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
 	"replaceInBlock",
 	"replaceRange",
 	"formatRange",
+	"setBlockParagraphProperties",
 	"replaceBlock",
 	"deleteBlock",
 	"insertAfterBlock",
@@ -41,47 +102,104 @@ const SUGGESTED_SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
 	"insertTableColumn",
 	"deleteTableColumn"
 ]);
-/**
-* The attrs that render a list label, cleared together whenever a paragraph
-* stops being a list item. `w:numPr` alone is not enough: the marker attrs the
-* editor caches would keep drawing a label on a paragraph that is no longer in
-* the list. One frozen record rather than a list repeated at each call site,
-* because a list repeated is a list that drifts.
-*/
-const CLEARED_LIST_MARKER_ATTRS = Object.freeze({
-	listMarker: null,
-	listMarkerHidden: null,
-	listLevelNumFmts: null,
-	listLevelStarts: null,
-	listAbstractNumId: null,
-	listStartOverride: null
-});
-/**
-* The attrs one `setBlockParagraphProperties` writes, or `null` when the
-* block already holds them. `styleId: null` clears the style; `listLevel`
-* moves `w:numPr/w:ilvl` and leaves `w:numId` alone, because a demoted item
-* stays in the same list; `listLevel: null` drops `w:numPr` entirely, which
-* is a paragraph that stopped being a list item.
-*/
-const paragraphPropertiesPatch = (node, properties) => {
+const REPLACE_BLOCK_IMPACT = {
+	text: {
+		changesStyle: false,
+		changesText: true
+	},
+	style: {
+		changesStyle: true,
+		changesText: false
+	},
+	textAndStyle: {
+		changesStyle: true,
+		changesText: true
+	}
+};
+const isResolvedReplaceBlockOperation = (item) => item.operation.type === "replaceBlock";
+const isResolvedBaseReplaceBlockOperation = (item) => item.operation.type === "replaceBlock";
+const hasRepresentableCommentAnchor = (item, mode) => {
+	switch (item.operation.type) {
+		case "insertAfterBlock":
+		case "insertBeforeBlock": return (item.insertTexts ?? [""]).some((text) => stripInlineEmphasisMarkers(text).length > 0);
+		case "insertSignatureTable": return false;
+		case "replaceInBlock":
+		case "replaceRange": return stripInlineEmphasisMarkers(item.operation.replace).length > 0 || mode !== "direct" && item.from < item.to;
+		case "replaceBlock": {
+			if (!isResolvedBaseReplaceBlockOperation(item)) panic("Resolved replaceBlock operation lost its impact discriminator");
+			const { changesText } = REPLACE_BLOCK_IMPACT[item.replaceBlockImpact];
+			if (!changesText) return item.from < item.to;
+			return stripInlineEmphasisMarkers(item.operation.text).length > 0 || mode !== "direct" && item.from < item.to;
+		}
+		case "deleteBlock": return mode !== "direct" && item.from < item.to;
+		default: return item.from < item.to;
+	}
+};
+const writesParagraphPropertyChange = (item) => item.operation.type === "setBlockParagraphProperties" || isResolvedReplaceBlockOperation(item) && REPLACE_BLOCK_IMPACT[item.replaceBlockImpact].changesStyle;
+const resolveReplaceBlockImpact = ({ changesText, changesStyle }) => {
+	if (changesText) return changesStyle ? "textAndStyle" : "text";
+	if (changesStyle) return "style";
+	return panic("Cannot resolve a replaceBlock that changes neither text nor style");
+};
+const paragraphPropertiesPatch = ({ node, properties, resolvedFormattingFromStyle, numbering = null }) => {
+	const attrs = expectParagraphAttrs(node);
+	const currentDirectAlignment = directParagraphAlignment(attrs);
+	const currentDirectSpacing = directParagraphSpacing(attrs);
+	const resolvedSpacingFromStyle = paragraphSpacingFromFormatting(resolvedFormattingFromStyle);
 	const patch = {};
-	if (properties.styleId !== void 0 && (node.attrs["styleId"] ?? null) !== properties.styleId) patch["styleId"] = properties.styleId;
+	let originalFormatting = attrs._originalFormatting === void 0 || attrs._originalFormatting === null ? void 0 : { ...attrs._originalFormatting };
+	let originalFormattingChanged = false;
+	const nextStyleId = properties.styleId;
+	const styleChanged = nextStyleId !== void 0 && (attrs.styleId ?? null) !== nextStyleId;
+	if (styleChanged) {
+		patch["styleId"] = nextStyleId;
+		patch["alignmentFromStyle"] = resolvedFormattingFromStyle?.alignment;
+		if (properties.alignment === void 0) patch["alignment"] = currentDirectAlignment ?? resolvedFormattingFromStyle?.alignment ?? null;
+		if (properties.spacing === void 0) Object.assign(patch, paragraphSpacingAttrPatch({
+			direct: currentDirectSpacing,
+			inherited: resolvedSpacingFromStyle
+		}));
+		originalFormatting ??= {};
+		if (nextStyleId === null) Reflect.deleteProperty(originalFormatting, "styleId");
+		else originalFormatting.styleId = nextStyleId;
+		if (currentDirectAlignment !== void 0) originalFormatting.alignment = currentDirectAlignment;
+		originalFormattingChanged = true;
+	}
 	if (properties.listLevel !== void 0) {
 		const numPr = node.attrs["numPr"];
-		const current = typeof numPr === "object" && numPr !== null && "ilvl" in numPr ? numPr.ilvl : void 0;
 		if (properties.listLevel === null) {
-			if (numPr !== null && numPr !== void 0) {
-				patch["numPr"] = null;
-				Object.assign(patch, CLEARED_LIST_MARKER_ATTRS);
-			}
-		} else if (current !== properties.listLevel) {
+			patch["numPr"] = null;
+			Object.assign(patch, CLEARED_LIST_RENDERING_ATTRS);
+		} else {
 			const numId = typeof numPr === "object" && numPr !== null && "numId" in numPr ? numPr.numId : void 0;
-			patch["numPr"] = {
-				...typeof numId === "number" && { numId },
+			if (typeof numId === "number") Object.assign(patch, listLevelAttrPatch(attrs, {
+				numId,
 				ilvl: properties.listLevel
-			};
+			}, numbering));
+			else {
+				patch["numPr"] = { ilvl: properties.listLevel };
+				Object.assign(patch, CLEARED_LIST_RENDERING_ATTRS);
+			}
 		}
 	}
+	if (properties.alignment !== void 0 && (styleChanged || (currentDirectAlignment ?? null) !== properties.alignment)) {
+		originalFormatting ??= {};
+		if (properties.alignment === null) Reflect.deleteProperty(originalFormatting, "alignment");
+		else originalFormatting.alignment = properties.alignment;
+		const alignmentFromStyle = properties.styleId === void 0 ? attrs.alignmentFromStyle : resolvedFormattingFromStyle?.alignment;
+		patch["alignment"] = properties.alignment ?? alignmentFromStyle ?? null;
+		originalFormattingChanged = true;
+	}
+	if (properties.spacing !== void 0 && (styleChanged || !paragraphSpacingEqual(currentDirectSpacing, properties.spacing))) {
+		const directSpacing = properties.spacing ?? void 0;
+		originalFormatting = withDirectParagraphSpacing(originalFormatting, directSpacing);
+		Object.assign(patch, paragraphSpacingAttrPatch({
+			direct: directSpacing,
+			inherited: resolvedSpacingFromStyle
+		}));
+		originalFormattingChanged = true;
+	}
+	if (originalFormattingChanged) patch["_originalFormatting"] = originalFormatting && Object.keys(originalFormatting).length > 0 ? originalFormatting : null;
 	return Object.keys(patch).length > 0 ? patch : null;
 };
 const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
@@ -132,163 +250,195 @@ const undeletedContentAtomRanges = (tr, blockFrom) => {
 	});
 	return ranges;
 };
-/** The in-scope paragraph properties as they stand, for a `w:pPrChange` record. */
-const paragraphPropertiesSnapshot = (node) => {
-	const snapshot = {};
-	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
-		const value = node.attrs[key];
-		if (value !== null && value !== void 0) snapshot[key] = value;
-	}
-	return snapshot;
+/** The carrier pPr before this batch changed it, for final-mark rotation. */
+const paragraphPropertiesBeforeBatch = (node, batchRevisionIds) => {
+	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 resolveFormattingFromStyle = ({ attrs, styleId, styleResolver }) => {
+	const resolved = styleResolver?.resolveParagraphStyle(styleId).paragraphFormatting;
+	if (resolved !== void 0) return resolved;
+	if ((styleId ?? void 0) !== (attrs.styleId ?? void 0)) return;
+	const fallback = {};
+	if (attrs.alignmentFromStyle !== void 0) fallback.alignment = attrs.alignmentFromStyle;
+	return Object.keys(fallback).length > 0 ? fallback : void 0;
 };
-const applyReplaceBlockStyleId = ({ item, tr }) => {
-	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return tr;
-	const block = tr.doc.nodeAt(item.blockFrom);
-	if (!block) return tr;
-	return tr.setNodeMarkup(item.blockFrom, void 0, {
-		...block.attrs,
-		styleId: item.operation.styleId
+const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) => {
+	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return {
+		tr,
+		revisionId: null
+	};
+	const blockPosition = tr.mapping.map(item.blockFrom, -1);
+	const block = tr.doc.nodeAt(blockPosition);
+	if (!block) return {
+		tr,
+		revisionId: null
+	};
+	const attrs = expectParagraphAttrs(block);
+	const resolvedFormattingFromStyle = resolveFormattingFromStyle({
+		attrs,
+		styleId: item.operation.styleId,
+		styleResolver
+	});
+	const patch = paragraphPropertiesPatch({
+		node: block,
+		properties: { styleId: item.operation.styleId },
+		resolvedFormattingFromStyle
 	});
+	if (patch === null) return {
+		tr,
+		revisionId: null
+	};
+	const existing = attrs._propertyChanges;
+	const change = revisionInfo ? {
+		type: "paragraphPropertyChange",
+		info: revisionInfo,
+		previousFormatting: paragraphPropertiesSnapshot(block)
+	} : null;
+	return {
+		tr: tr.setNodeMarkup(blockPosition, void 0, {
+			...block.attrs,
+			...patch,
+			...change ? { _propertyChanges: [...Array.isArray(existing) ? existing : [], change] } : {}
+		}),
+		revisionId: change?.info.id ?? null
+	};
 };
 const REPLACEMENT_BACKGROUND_CLEAR_FORMATTING = {
 	highlight: false,
 	runShading: false
 };
-const INLINE_FORMATTING_MARK_NAMES = {
-	bold: "bold",
-	italic: "italic",
-	underline: "underline",
-	strike: "strike",
-	fontFamily: "fontFamily",
-	fontSizePt: "fontSize",
-	color: "textColor",
-	highlight: "highlight",
-	runShading: "runShading"
-};
-const DIRECT_FONT_PROPERTIES = [
-	"fontFamily",
-	"fontSize",
-	"color"
-];
-const formattingMarkName = (property) => {
-	if (!Object.hasOwn(INLINE_FORMATTING_MARK_NAMES, property)) return null;
-	const name = Reflect.get(INLINE_FORMATTING_MARK_NAMES, property);
-	return typeof name === "string" ? name : null;
-};
-const formattingMarkAttrs = (property, value) => {
-	switch (property) {
-		case "underline": return { style: "single" };
-		case "fontFamily": return typeof value === "string" ? {
-			ascii: value,
-			hAnsi: value
-		} : null;
-		case "fontSizePt": return typeof value === "number" ? { size: value * 2 } : null;
-		case "color": return typeof value === "string" ? { rgb: value.replace(/^#/u, "").toUpperCase() } : null;
-		default: return {};
+const includedFormattingProperty = (includedProperties, property) => includedProperties === void 0 || includedProperties.includes(property);
+const patchAuthoredRunFormatting = ({ authoredFormatting, formatting, includedProperties }) => {
+	const next = { ...authoredFormatting };
+	for (const property of ["bold", "italic"]) {
+		const value = formatting[property];
+		if (value === void 0 || !includedFormattingProperty(includedProperties, property)) continue;
+		if (value === null) Reflect.deleteProperty(next, property);
+		else next[property] = value;
 	}
-};
-const applyInlineFormatting = ({ tr, schema, from, to, formatting, includedProperties }) => {
-	for (const [property, value] of Object.entries(formatting)) {
-		if (includedProperties && !includedProperties.includes(property)) continue;
-		const markName = formattingMarkName(property);
-		const markType = markName ? schema.marks[markName] : void 0;
-		if (!markType) continue;
-		if (value !== false && value !== null) {
-			const attrs = formattingMarkAttrs(property, value);
-			if (attrs) tr.addMark(from, to, markType.create(attrs));
-			continue;
-		}
-		tr.removeMark(from, to, markType);
+	if (formatting.underline !== void 0 && includedFormattingProperty(includedProperties, "underline")) if (formatting.underline === null) delete next.underline;
+	else next.underline = { style: formatting.underline ? "single" : "none" };
+	if (formatting.strike !== void 0 && includedFormattingProperty(includedProperties, "strike")) {
+		delete next.doubleStrike;
+		if (formatting.strike === null) delete next.strike;
+		else next.strike = formatting.strike;
 	}
-	applyDirectFontProvenance({
-		tr,
-		schema,
+	if (formatting.fontFamily !== void 0 && includedFormattingProperty(includedProperties, "fontFamily")) if (formatting.fontFamily === null) delete next.fontFamily;
+	else next.fontFamily = {
+		ascii: formatting.fontFamily,
+		hAnsi: formatting.fontFamily
+	};
+	if (formatting.fontSizePt !== void 0 && includedFormattingProperty(includedProperties, "fontSizePt")) if (formatting.fontSizePt === null) delete next.fontSize;
+	else next.fontSize = formatting.fontSizePt * 2;
+	if (formatting.color !== void 0 && includedFormattingProperty(includedProperties, "color")) if (formatting.color === null) delete next.color;
+	else next.color = { rgb: formatting.color.replace(/^#/u, "").toUpperCase() };
+	if (formatting.highlight === false && includedFormattingProperty(includedProperties, "highlight")) delete next.highlight;
+	if (formatting.runShading === false && includedFormattingProperty(includedProperties, "runShading")) delete next.shading;
+	return next;
+};
+const applyInlineFormatting = ({ tr, from, to, formatting, includedProperties, styleResolver }) => {
+	const representations = selectRunFormattingCarrierRepresentations({
+		doc: tr.doc,
 		from,
-		to,
-		formatting,
-		...includedProperties ? { includedProperties } : {}
+		to
 	});
+	for (const representation of representations) {
+		const styleContext = paragraphRunStyleContextAt({
+			doc: tr.doc,
+			pos: representation.from,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		const authoredFormatting = readAuthoredRunFormatting({
+			context: styleContext,
+			marks: representation.node.marks,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		const marks = reconcileRunFormattingMarks({
+			authoredFormatting: patchAuthoredRunFormatting({
+				authoredFormatting,
+				formatting,
+				...includedProperties !== void 0 ? { includedProperties } : {}
+			}),
+			context: styleContext,
+			node: representation.node,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		applyMarksToRunFormattingRepresentation({
+			tr,
+			representation,
+			marks
+		});
+	}
 	return tr;
 };
-const applyDirectFontProvenance = ({ tr, schema, from, to, formatting, includedProperties }) => {
-	if ("highlight" in formatting) return;
-	const changed = [
-		[
-			"fontFamily",
-			"fontFamily",
-			formatting.fontFamily
-		],
-		[
-			"fontSize",
-			"fontSizePt",
-			formatting.fontSizePt
-		],
-		[
-			"color",
-			"color",
-			formatting.color
-		]
-	].filter(([, inputProperty, value]) => value !== void 0 && (!includedProperties || includedProperties.includes(inputProperty)));
-	const markType = schema.marks["runFormattingOverride"];
-	if (!markType || changed.length === 0) return;
-	tr.doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText) return;
-		const segmentFrom = Math.max(from, pos);
-		const segmentTo = Math.min(to, pos + node.nodeSize);
-		const existing = node.marks.find((mark) => mark.type === markType);
-		const attrs = existing ? expectRunFormattingOverrideMarkAttrs(existing) : {};
-		const directFontProperties = new Set(attrs.directFontProperties);
-		for (const [property, , value] of changed) if (value === null) directFontProperties.delete(property);
-		else directFontProperties.add(property);
-		tr.removeMark(segmentFrom, segmentTo, markType);
-		const nextAttrs = {
-			...attrs,
-			directFontProperties: DIRECT_FONT_PROPERTIES.filter((property) => directFontProperties.has(property))
-		};
-		if (Object.entries(nextAttrs).some(([key, value]) => key === "directFontProperties" ? Array.isArray(value) && value.length > 0 : value !== null && value !== void 0)) tr.addMark(segmentFrom, segmentTo, markType.create(nextAttrs));
-	});
-};
-const directFontPropertyForFormattingProperty = (property) => {
-	switch (property) {
-		case "fontFamily": return "fontFamily";
-		case "fontSizePt": return "fontSize";
-		case "color": return "color";
-		default: return null;
+const applyMarksToRunFormattingRepresentation = ({ tr, representation, marks }) => {
+	const { node, position, from, to } = representation;
+	if (Mark.sameSet(node.marks, marks)) return;
+	if (!node.isText) {
+		tr.setNodeMarkup(position, void 0, node.attrs, marks);
+		return;
 	}
+	for (const current of node.marks) if (!marks.some((candidate) => candidate.eq(current))) tr.removeMark(from, to, current.type);
+	for (const next of marks) if (!node.marks.some((candidate) => candidate.eq(next))) tr.addMark(from, to, next);
 };
-const formattingPropertyWouldChange = (marks, property, value) => {
-	const markName = formattingMarkName(property);
-	const mark = marks.find((candidate) => candidate.type.name === markName);
-	const directFontProperty = directFontPropertyForFormattingProperty(property);
-	if (directFontProperty) {
-		const overrideMark = marks.find((candidate) => candidate.type.name === "runFormattingOverride");
-		const isDirect = overrideMark ? (expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties ?? []).includes(directFontProperty) : false;
-		if (value === false || value === null) return isDirect;
-		if (!isDirect) return true;
-	} else if (value === false || value === null) return mark !== void 0;
-	if (property === "underline") return mark?.attrs["style"] !== "single";
-	if (property === "fontFamily") return mark?.attrs["ascii"] !== value || mark?.attrs["hAnsi"] !== value;
-	if (property === "fontSizePt") return Number(mark?.attrs["size"]) !== Number(value) * 2;
-	if (property === "color") {
-		const current = mark?.attrs["rgb"];
-		return (typeof current === "string" ? current.replace(/^#/u, "").toUpperCase() : null) !== String(value).replace(/^#/u, "").toUpperCase();
+const sameDefinedFormattingValue = (left, right) => {
+	if (left === right) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((value, index) => sameDefinedFormattingValue(value, right.at(index)));
 	}
-	return mark === void 0;
+	const leftEntries = Object.entries(left).filter(([, value]) => value !== void 0);
+	const rightEntries = Object.entries(right).filter(([, value]) => value !== void 0);
+	if (leftEntries.length !== rightEntries.length) return false;
+	return leftEntries.every(([property, value]) => Object.hasOwn(right, property) && sameDefinedFormattingValue(value, Reflect.get(right, property)));
 };
-const formattingChangesForMarks = (marks, formatting) => {
+const formattingChangesForAuthoredFormatting = (authoredFormatting, formatting) => {
 	const changes = [];
-	for (const [property, value] of Object.entries(formatting)) if (formattingPropertyWouldChange(marks, property, value)) changes.push(property);
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike",
+		"fontFamily",
+		"fontSizePt",
+		"color",
+		"highlight",
+		"runShading"
+	]) {
+		if (formatting[property] === void 0) continue;
+		const next = patchAuthoredRunFormatting({
+			authoredFormatting,
+			formatting,
+			includedProperties: [property]
+		});
+		if (!sameDefinedFormattingValue(authoredFormatting, next)) changes.push(property);
+	}
 	return changes;
 };
-const clearReplacementBackground = ({ tr, schema, from, to, mode, revisionId, author, date, initials, suggestionId = null }) => {
-	if (![schema.marks["highlight"], schema.marks["runShading"]].some((markType) => markType !== void 0 && tr.doc.rangeHasMark(from, to, markType))) return tr;
-	if (mode === "direct") return applyInlineFormatting({
-		tr,
-		schema,
-		from,
-		to,
-		formatting: REPLACEMENT_BACKGROUND_CLEAR_FORMATTING
-	});
+const clearReplacementBackground = ({ tr, schema, from, to, mode, revisionIdSeed, author, date, initials, suggestionId = null, styleResolver }) => {
+	if (![schema.marks["highlight"], schema.marks["runShading"]].some((markType) => markType !== void 0 && tr.doc.rangeHasMark(from, to, markType))) return {
+		type: "applied",
+		transaction: tr,
+		revisionIds: [],
+		nextRevisionId: revisionIdSeed
+	};
+	if (mode === "direct") return {
+		type: "applied",
+		transaction: applyInlineFormatting({
+			tr,
+			from,
+			to,
+			formatting: REPLACEMENT_BACKGROUND_CLEAR_FORMATTING,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		}),
+		revisionIds: [],
+		nextRevisionId: revisionIdSeed
+	};
 	return applyTrackedInlineFormatting({
 		tr,
 		schema,
@@ -296,26 +446,85 @@ const clearReplacementBackground = ({ tr, schema, from, to, mode, revisionId, au
 		from,
 		to,
 		formatting: REPLACEMENT_BACKGROUND_CLEAR_FORMATTING,
-		revisionId,
+		revisionIdSeed,
 		author,
 		date,
 		initials,
-		suggestionId
+		suggestionId,
+		...styleResolver !== void 0 ? { styleResolver } : {}
 	});
 };
-const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, revisionId, author, date, initials, suggestionId = null }) => {
+const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, revisionIdSeed, author, date, initials, suggestionId = null, styleResolver }) => {
 	const propertyChangeType = schema.marks["runPropertyChange"];
-	if (!propertyChangeType) return tr;
+	if (!propertyChangeType) return {
+		type: "applied",
+		transaction: tr,
+		revisionIds: [],
+		nextRevisionId: revisionIdSeed
+	};
 	const segments = [];
-	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText) return;
-		const includedProperties = formattingChangesForMarks(node.marks, formatting);
-		if (includedProperties.length === 0) return;
-		const segmentFrom = Math.max(from, pos);
-		const segmentTo = Math.min(to, pos + node.nodeSize);
-		const previousFormatting = marksToTextFormatting(node.marks);
+	let hasPendingRunPropertyChange = false;
+	const representations = selectRunFormattingCarrierRepresentations({
+		doc,
+		from,
+		to
+	});
+	for (const representation of representations) {
+		const { node } = representation;
+		const styleContext = paragraphRunStyleContextAt({
+			doc,
+			pos: representation.from,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		const previousFormatting = readAuthoredRunFormatting({
+			context: styleContext,
+			marks: node.marks,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		const includedProperties = formattingChangesForAuthoredFormatting(previousFormatting, formatting);
+		if (includedProperties.length === 0) continue;
 		const existingMark = node.marks.find((mark) => mark.type === propertyChangeType);
-		const existingChanges = existingMark ? expectRunPropertyChangeMarkAttrs(existingMark).changes : [];
+		if (existingMark && expectRunPropertyChangeMarkAttrs(existingMark).changes.length > 0) {
+			hasPendingRunPropertyChange = true;
+			continue;
+		}
+		const formattingMarks = reconcileRunFormattingMarks({
+			authoredFormatting: patchAuthoredRunFormatting({
+				authoredFormatting: previousFormatting,
+				formatting,
+				includedProperties
+			}),
+			context: styleContext,
+			node,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		});
+		segments.push({
+			formattingMarks,
+			representation,
+			includedProperties,
+			previousFormatting
+		});
+	}
+	if (hasPendingRunPropertyChange) return {
+		type: "pendingRunPropertyChange",
+		transaction: tr,
+		revisionIds: [],
+		nextRevisionId: revisionIdSeed
+	};
+	if (segments.length === 0) return {
+		type: "applied",
+		transaction: tr,
+		revisionIds: [],
+		nextRevisionId: revisionIdSeed
+	};
+	const suggestionAttrs = suggestionId === null ? {} : {
+		provenance: "suggested",
+		suggestionId
+	};
+	const revisionIds = [];
+	for (const segment of segments) {
+		const revisionId = revisionIdSeed + revisionIds.length;
+		revisionIds.push(revisionId);
 		const change = {
 			type: "runPropertyChange",
 			info: {
@@ -324,35 +533,24 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 				date,
 				...initials ? { initials } : {}
 			},
-			...Object.keys(previousFormatting).length > 0 ? { previousFormatting } : {}
+			...Object.keys(segment.previousFormatting).length > 0 ? { previousFormatting: segment.previousFormatting } : {}
 		};
-		segments.push({
-			from: segmentFrom,
-			to: segmentTo,
-			includedProperties,
-			changes: [...existingChanges, change]
-		});
-	});
-	if (segments.length === 0) return tr;
-	const suggestionAttrs = suggestionId === null ? {} : {
-		provenance: "suggested",
-		suggestionId
-	};
-	for (const segment of segments) {
-		applyInlineFormatting({
+		const marks = propertyChangeType.create({
+			changes: [change],
+			...suggestionAttrs
+		}).addToSet(segment.formattingMarks);
+		applyMarksToRunFormattingRepresentation({
 			tr,
-			schema,
-			from: segment.from,
-			to: segment.to,
-			formatting,
-			includedProperties: segment.includedProperties
+			representation: segment.representation,
+			marks
 		});
-		tr.addMark(segment.from, segment.to, propertyChangeType.create({
-			changes: segment.changes,
-			...suggestionAttrs
-		}));
 	}
-	return tr;
+	return {
+		type: "applied",
+		transaction: tr,
+		revisionIds,
+		nextRevisionId: revisionIdSeed + revisionIds.length
+	};
 };
 /**
 * Module-scoped monotonic counter for tracked-change revision ids.
@@ -378,15 +576,17 @@ const nextRevisionSeed = (revisionIdCount) => {
 * `insertAfterBlock` / `insertBeforeBlock` (`text` split on line breaks,
 * see `splitInsertParagraphTexts`) allocates one id per paragraph in
 * tracked-changes mode plus one for each paragraph MARK it brings, so it
-* needs more than four once split into more than two paragraphs — reserving
-* less than that would let a later `nextRevisionSeed` call reuse an id this
-* operation already stamped on the document.
+* needs more than four once split into more than two paragraphs. Rotating a
+* terminal run can add one paragraph-property revision per inserted paragraph;
+* reserving less than that would let a later `nextRevisionSeed` call reuse an
+* id this operation already stamped on the document.
 */
 const REVISION_IDS_PER_OPERATION = 4;
-/** Ids one inserted paragraph allocates: its runs, and its paragraph mark. */
-const REVISION_IDS_PER_INSERTED_PARAGRAPH = 2;
 const estimateRevisionIdReservation = (item) => {
-	if (item.operation.type === "insertAfterBlock" || item.operation.type === "insertBeforeBlock") return Math.max((item.insertTexts?.length ?? 1) * REVISION_IDS_PER_INSERTED_PARAGRAPH, REVISION_IDS_PER_OPERATION);
+	if (item.operation.type === "insertAfterBlock" || item.operation.type === "insertBeforeBlock") {
+		const paragraphCount = item.insertTexts?.length ?? 1;
+		return Math.max(paragraphCount * 3, REVISION_IDS_PER_OPERATION);
+	}
 	return REVISION_IDS_PER_OPERATION;
 };
 /**
@@ -591,10 +791,18 @@ const buildEmphasisInlineContent = (schema, text, baseMarks) => {
 };
 const isBatchableParagraphInsertion = (item, mode) => {
 	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return false;
+	if (item.commentText !== void 0) return false;
 	const insertTexts = item.insertTexts ?? [""];
 	const isEmptyInsert = insertTexts.length === 1 && insertTexts[0]?.length === 0;
 	return !(mode === "tracked-changes" && item.operation.pageBreakBefore === true && isEmptyInsert);
 };
+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;
+	const info = value.info;
+	if (typeof info !== "object" || info === null || !("id" in info)) return null;
+	return typeof info.id === "number" ? info.id : null;
+};
 /**
 * Move an ADDED paragraph break off every paragraph its container ends with.
 *
@@ -604,11 +812,10 @@ const isBatchableParagraphInsertion = (item, mode) => {
 * revision neither accepting nor rejecting everything can clear.
 *
 * Appending at a container's end therefore rotates exactly as removing from it
-* does. The break that was added sits between the paragraph the run was
-* appended after and the first appended one, so THAT paragraph's mark is the
-* inserted one, each appended paragraph but the last keeps an inserted mark of
-* its own, and the paragraph the container now ends with takes the free mark
-* the run was appended after. Only which paragraph is left markless changes.
+* does. The first inserted break moves onto the paragraph the run was appended
+* after, every later break moves one paragraph left, and the paragraph the
+* container now ends with takes the free mark. Only which paragraph is left
+* markless changes; the order and ownership of the breaks do not.
 *
 * A paragraph's properties live on its mark, so the paragraph that inherits
 * the free one records the other's as `w:pPrChange` — what a rejection reads
@@ -621,50 +828,96 @@ const isBatchableParagraphInsertion = (item, mode) => {
 */
 const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, author, date, initials }) => {
 	const paragraphTypeName = tr.doc.type.schema.nodes["paragraph"]?.name ?? "paragraph";
-	const rotations = finalParagraphsOf(tr.doc, paragraphTypeName).filter(({ node }) => {
+	const rotations = finalParagraphsOf(tr.doc, paragraphTypeName).flatMap(({ node, position }) => {
 		const mark = node.attrs["pPrMark"];
-		if (typeof mark !== "object" || mark === null || !("kind" in mark)) return false;
-		if (mark.kind !== "ins" && mark.kind !== "moveTo") return false;
-		const info = "info" in mark ? mark.info : void 0;
-		const revisionId = typeof info === "object" && info !== null && "id" in info ? info.id : void 0;
-		return typeof revisionId === "number" && batchRevisionIds.has(revisionId);
+		const revisionId = addedBreakRevisionId(mark);
+		return revisionId !== null && batchRevisionIds.has(revisionId) ? [{
+			mark,
+			node,
+			ownerRevisionId: revisionId,
+			position
+		}] : [];
 	});
 	let next = tr;
 	let nextRevisionId = revisionSeed;
-	for (const { position: finalPosition, node: final } of rotations) {
-		const carrier = addedBreakCarrierBefore(next.doc.resolve(finalPosition), final.type.name);
+	const synthesizedRevisions = [];
+	for (const { position: finalPosition, node: final, mark: finalMark } of rotations) {
+		const resolved = next.doc.resolve(finalPosition);
+		const carrier = addedBreakCarrierBefore(resolved, final.type.name);
 		if (!carrier) {
 			next = next.setNodeAttribute(finalPosition, "pPrMark", null);
 			continue;
 		}
-		next = next.setNodeAttribute(carrier.position, "pPrMark", final.attrs["pPrMark"]);
-		const previousFormatting = paragraphPropertiesSnapshot(carrier.node);
-		if (JSON.stringify(previousFormatting) === JSON.stringify(paragraphPropertiesSnapshot(final))) {
+		const path = [{
+			node: final,
+			position: finalPosition
+		}];
+		let position = finalPosition;
+		for (let index = resolved.index() - 1; index >= 0; index--) {
+			const sibling = resolved.parent.child(index);
+			position -= sibling.nodeSize;
+			if (sibling.type.name !== final.type.name) continue;
+			path.push({
+				node: sibling,
+				position
+			});
+			if (position === carrier.position) break;
+		}
+		if (path.at(-1)?.position !== carrier.position) {
 			next = next.setNodeAttribute(finalPosition, "pPrMark", null);
 			continue;
 		}
-		const existing = expectParagraphAttrs(final)._propertyChanges;
-		next = next.setNodeMarkup(finalPosition, void 0, {
-			...final.attrs,
-			pPrMark: null,
-			_propertyChanges: [...Array.isArray(existing) ? existing : [], {
-				type: "paragraphPropertyChange",
-				info: {
-					id: nextRevisionId++,
-					author,
-					date,
-					...initials ? { initials } : {}
-				},
-				previousFormatting
-			}]
-		});
+		if (path.slice(0, -1).some(({ node }) => {
+			const revisionId = addedBreakRevisionId(node.attrs["pPrMark"]);
+			return revisionId === null || !batchRevisionIds.has(revisionId);
+		})) continue;
+		const previousFormatting = paragraphPropertiesBeforeBatch(carrier.node, batchRevisionIds);
+		next = next.setNodeAttribute(finalPosition, "pPrMark", null);
+		let carriedMark = finalMark;
+		for (let index = 1; index < path.length; index++) {
+			const current = path[index - 1];
+			const previous = path[index];
+			if (!current || !previous) panic("A final-mark rotation exceeded its paragraph path", { index });
+			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 currentFormatting = paragraphPropertiesSnapshot(current.node);
+			if (JSON.stringify(previousFormatting) !== JSON.stringify(currentFormatting)) {
+				const liveCurrent = next.doc.nodeAt(current.position);
+				if (!liveCurrent || liveCurrent.type.name !== final.type.name) panic("A final-mark rotation lost its paragraph", { position: current.position });
+				const existing = expectParagraphAttrs(liveCurrent)._propertyChanges;
+				if (hasSerializableParagraphPropertyChange(existing)) panic("A final-mark rotation cannot append a second w:pPrChange", { position: current.position });
+				const revisionId = nextRevisionId++;
+				next = next.setNodeMarkup(current.position, void 0, {
+					...liveCurrent.attrs,
+					_propertyChanges: [...Array.isArray(existing) ? existing : [], {
+						type: "paragraphPropertyChange",
+						info: {
+							id: revisionId,
+							author,
+							date,
+							...initials ? { initials } : {}
+						},
+						previousFormatting
+					}]
+				});
+				synthesizedRevisions.push({
+					ownerRevisionId,
+					revisionId
+				});
+			}
+			if (displacedMark == null) break;
+			carriedMark = displacedMark;
+		}
 	}
 	return {
 		transaction: next,
-		nextRevisionId
+		nextRevisionId,
+		synthesizedRevisions
 	};
 };
-const buildInsertedParagraphs = ({ item, schema, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove }) => {
+const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove, numbering }) => {
 	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"];
@@ -677,7 +930,12 @@ const buildInsertedParagraphs = ({ item, schema, mode, author, date, initials, c
 			suggestionId
 		} : {}
 	};
-	const baseAttrs = operation.inheritFormatting === false ? {} : stripBlockIdentityAttrs(item.blockNode.attrs);
+	const baseAttrs = operation.inheritFormatting === false ? {} : {
+		...stripBlockIdentityAttrs(item.blockNode.attrs),
+		_propertyChanges: null,
+		pPrMark: null,
+		_suggestedInsert: null
+	};
 	const insertTexts = item.insertTexts ?? [""];
 	const revisionIds = [];
 	const nodes = [];
@@ -701,20 +959,51 @@ const buildInsertedParagraphs = ({ item, schema, mode, author, date, initials, c
 		const content = text.length > 0 ? buildEmphasisInlineContent(schema, text, marks) : null;
 		const attrs = isFirstParagraph ? { ...baseAttrs } : {};
 		if (isFirstParagraph && operation.pageBreakBefore === true) attrs["pageBreakBefore"] = true;
-		if (isFirstParagraph && operation.listLevel === null) {
+		const listLevel = operation.listLevel;
+		if (isFirstParagraph && listLevel === null) {
 			attrs["numPr"] = null;
-			Object.assign(attrs, CLEARED_LIST_MARKER_ATTRS);
-		} else if (isFirstParagraph && operation.listLevel !== void 0) {
-			const anchorNumPr = baseAttrs["numPr"];
+			Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
+		} else if (isFirstParagraph && typeof listLevel === "number") {
+			const anchorNumPr = Reflect.get(baseAttrs, "numPr");
 			const numId = typeof anchorNumPr === "object" && anchorNumPr !== null && "numId" in anchorNumPr ? anchorNumPr.numId : void 0;
-			attrs["numPr"] = {
-				...typeof numId === "number" && { numId },
-				ilvl: operation.listLevel
-			};
+			if (typeof numId === "number") Object.assign(attrs, listLevelAttrPatch(operation.inheritFormatting === false ? {} : expectParagraphAttrs(item.blockNode), {
+				numId,
+				ilvl: listLevel
+			}, numbering));
+			else {
+				attrs["numPr"] = { ilvl: listLevel };
+				Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
+			}
 		}
 		if (isFirstParagraph && operation.styleId !== void 0) {
 			attrs["styleId"] = operation.styleId;
-			if (operation.inheritFormatting !== false && operation.styleId !== null) Object.assign(attrs, CLEARED_LIST_MARKER_ATTRS);
+			if (operation.inheritFormatting !== false && operation.styleId !== null) Object.assign(attrs, CLEARED_LIST_RENDERING_ATTRS);
+		}
+		if (isFirstParagraph && (operation.styleId !== void 0 || operation.alignment !== void 0 || operation.spacing !== 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 directAlignment = operation.alignment === void 0 ? inheritedDirectAlignment : operation.alignment ?? void 0;
+			const directSpacing = operation.spacing === void 0 ? inheritedDirectSpacing : operation.spacing ?? void 0;
+			attrs["alignmentFromStyle"] = formattingFromStyle?.alignment;
+			attrs["alignment"] = directAlignment ?? formattingFromStyle?.alignment ?? null;
+			const sourceFormatting = attrs["_originalFormatting"];
+			let originalFormatting = typeof sourceFormatting === "object" && sourceFormatting !== null ? { ...sourceFormatting } : void 0;
+			if (operation.styleId !== void 0) {
+				originalFormatting ??= {};
+				if (operation.styleId === null) Reflect.deleteProperty(originalFormatting, "styleId");
+				else originalFormatting.styleId = operation.styleId;
+			}
+			if (operation.alignment !== void 0 || inheritedDirectAlignment !== void 0) {
+				originalFormatting ??= {};
+				if (directAlignment === void 0) Reflect.deleteProperty(originalFormatting, "alignment");
+				else originalFormatting.alignment = directAlignment;
+			}
+			if (operation.spacing !== void 0) originalFormatting = withDirectParagraphSpacing(originalFormatting, directSpacing);
+			if (operation.styleId !== void 0 || operation.spacing !== void 0) Object.assign(attrs, paragraphSpacingAttrPatch({
+				direct: directSpacing,
+				inherited: paragraphSpacingFromFormatting(formattingFromStyle)
+			}));
+			attrs["_originalFormatting"] = originalFormatting && Object.keys(originalFormatting).length > 0 ? originalFormatting : null;
 		}
 		if (isSuggested && suggestionId !== null && paragraphRevisionId !== null) attrs["_suggestedInsert"] = {
 			suggestionId,
@@ -747,7 +1036,7 @@ const buildInsertedParagraphs = ({ item, schema, mode, author, date, initials, c
 		nextRevisionId
 	};
 };
-const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, tableTemplates }) => {
+const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, wordDiffMode = "bounded", tableTemplates }) => {
 	const applied = [];
 	const skipped = [];
 	const normalizations = [];
@@ -755,8 +1044,45 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	const commentType = view.state.schema.marks["comment"];
+	const occupiedCommentIds = /* @__PURE__ */ new Set();
+	if (commentType) view.state.doc.descendants((node) => {
+		for (const mark of node.marks) {
+			if (mark.type !== commentType) continue;
+			const commentId = mark.attrs["commentId"];
+			if (typeof commentId === "number") occupiedCommentIds.add(commentId);
+		}
+	});
+	let provisionalCommentIdCursor = Number.MIN_SAFE_INTEGER;
+	const reserveProvisionalCommentId = () => {
+		while (occupiedCommentIds.has(provisionalCommentIdCursor)) provisionalCommentIdCursor += 1;
+		const id = provisionalCommentIdCursor;
+		provisionalCommentIdCursor += 1;
+		occupiedCommentIds.add(id);
+		return id;
+	};
+	const allocateCommittedCommentId = (text) => {
+		if (createCommentId === void 0) panic("A resolved comment operation lost its comment-id allocator");
+		const id = createCommentId(text);
+		if (!Number.isSafeInteger(id) || occupiedCommentIds.has(id)) panic("A comment-id allocator returned an invalid or duplicate id", { id });
+		occupiedCommentIds.add(id);
+		return id;
+	};
+	const styleResolver = getDocumentStyleResolver(view.state);
+	const numbering = getDocumentNumbering(view.state);
+	const formattingFromStyleForInsertion = (item) => {
+		if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return;
+		const anchorAttrs = expectParagraphAttrs(item.blockNode);
+		const inheritedStyleId = item.operation.inheritFormatting === false ? null : anchorAttrs.styleId;
+		const styleId = item.operation.styleId !== void 0 ? item.operation.styleId : inheritedStyleId;
+		return resolveFormattingFromStyle({
+			attrs: anchorAttrs,
+			styleId,
+			styleResolver
+		});
+	};
 	const claimedTableRows = /* @__PURE__ */ new Set();
 	const claimedTableColumns = /* @__PURE__ */ new Set();
+	const diffText = wordDiffMode === "coarse" ? coarseWordDiff : wordDiffSessionFromOptions(wordDiff).diff;
 	const producesTrackedChanges = mode !== "direct";
 	const isSuggested = mode === "suggested";
 	if (producesTrackedChanges && (!insertionType || !deletionType)) return {
@@ -792,6 +1118,13 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			});
 			continue;
 		}
+		if (commentText !== void 0 && !hasRepresentableCommentAnchor(resolution.operation, mode)) {
+			skipped.push({
+				id: operation.id,
+				reason: "unsupportedBlock"
+			});
+			continue;
+		}
 		const deletion = resolution.operation.tableRowDeletion;
 		if (deletion) {
 			const rowKey = `${deletion.tablePosition}:${deletion.rowIndex}`;
@@ -821,11 +1154,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			code: "splitMultilineText",
 			paragraphCount: resolution.operation.insertTexts?.length ?? 1
 		});
-		const commentId = commentText !== void 0 ? createCommentId?.(commentText) : void 0;
 		resolved.push({
 			...resolution.operation,
 			originalIndex: index,
-			...commentId !== void 0 && { commentId }
+			...commentText !== void 0 && { commentText }
 		});
 	}
 	const tablePlan = planTableMutations(resolved.map((item) => ({
@@ -868,6 +1200,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	}
 	let tr = view.state.tr;
 	const revisionIdReservation = executableResolved.reduce((total, item) => total + estimateRevisionIdReservation(item), 0);
+	const ownsSharedRevisionIdCursor = revisionIdSeed === void 0 && revisionStamp === void 0;
 	let revisionSeed = revisionIdSeed ?? revisionStamp?.idSeed ?? nextRevisionSeed(revisionIdReservation);
 	const date = revisionStamp?.date ?? (/* @__PURE__ */ new Date()).toISOString();
 	const insertedColumnCounts = /* @__PURE__ */ new Map();
@@ -899,6 +1232,17 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	for (let executionIndex = 0; executionIndex < executionOrder.length; executionIndex++) {
 		const item = executionOrder[executionIndex];
 		if (!item) panic("The operation execution index exceeded the resolved plan", { executionIndex });
+		if (mode === "tracked-changes" && writesParagraphPropertyChange(item)) {
+			const livePosition = tr.mapping.map(item.blockFrom);
+			const liveBlock = tr.doc.nodeAt(livePosition) ?? item.blockNode;
+			if (hasSerializableParagraphPropertyChange(liveBlock.type.name === "paragraph" ? expectParagraphAttrs(liveBlock)._propertyChanges : void 0)) {
+				skipped.push({
+					id: item.operation.id,
+					reason: "pendingParagraphPropertyChange"
+				});
+				continue;
+			}
+		}
 		if (isBatchableParagraphInsertion(item, mode)) {
 			const insertionRun = [item];
 			for (let lookahead = executionIndex + 1; lookahead < executionOrder.length; lookahead++) {
@@ -911,24 +1255,24 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				const runApplied = [];
 				for (const insertion of insertionRun) {
 					const insertionSuggestionId = isSuggested ? insertion.operation.suggestionId ?? insertion.operation.id : null;
-					const insertionCommentMark = insertion.commentId !== void 0 && commentType ? commentType.create({ commentId: insertion.commentId }) : null;
 					const built = buildInsertedParagraphs({
 						item: insertion,
 						schema: view.state.schema,
+						formattingFromStyle: formattingFromStyleForInsertion(insertion),
 						mode,
 						author,
 						date,
 						initials,
-						commentMark: insertionCommentMark,
+						commentMark: null,
 						suggestionId: insertionSuggestionId,
 						revisionSeed,
-						isPairedMove
+						isPairedMove,
+						numbering
 					});
 					revisionSeed = built.nextRevisionId;
 					nodeGroups.push(built.nodes);
 					runApplied.push({
 						id: insertion.operation.id,
-						...insertion.commentId !== void 0 && { commentId: insertion.commentId },
 						...built.revisionIds[0] !== void 0 && {
 							revisionId: built.revisionIds[0],
 							revisionIds: built.revisionIds
@@ -944,7 +1288,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				continue;
 			}
 		}
-		const commentMark = item.commentId !== void 0 && commentType ? commentType.create({ commentId: item.commentId }) : null;
+		const provisionalCommentId = item.commentText !== void 0 ? reserveProvisionalCommentId() : void 0;
+		const commentMark = provisionalCommentId !== void 0 && commentType ? commentType.create({ commentId: provisionalCommentId }) : null;
 		const stepsBefore = tr.steps.length;
 		let appliedRevisionIds;
 		if (isSuggested && !SUGGESTED_SUPPORTED_OPERATION_TYPES.has(item.operation.type)) {
@@ -962,8 +1307,9 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				suggestionId
 			} : {}
 		};
+		let operationRevisionSeed = revisionSeed;
 		const structuralRevision = producesTrackedChanges ? {
-			revisionId: revisionSeed,
+			revisionId: operationRevisionSeed,
 			author,
 			date,
 			...trackedRevisionExtras
@@ -971,22 +1317,32 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		switch (item.operation.type) {
 			case "replaceInBlock":
 			case "replaceRange": {
-				const revisionIdDelete = revisionSeed++;
-				const revisionIdInsert = revisionSeed++;
-				const revisionIdBackground = revisionSeed++;
+				const revisionIdDelete = operationRevisionSeed;
+				const revisionIdInsert = producesTrackedChanges ? operationRevisionSeed + 1 : operationRevisionSeed;
+				const revisionIdBackgroundSeed = producesTrackedChanges ? operationRevisionSeed + 2 : operationRevisionSeed;
 				const stepsBeforeBackgroundClear = tr.steps.length;
-				tr = clearReplacementBackground({
+				const backgroundResult = clearReplacementBackground({
 					tr,
 					schema: view.state.schema,
 					from: item.from,
 					to: item.to,
 					mode,
-					revisionId: revisionIdBackground,
+					revisionIdSeed: revisionIdBackgroundSeed,
 					author,
 					date,
 					initials,
-					suggestionId
+					suggestionId,
+					styleResolver
 				});
+				if (backgroundResult.type === "pendingRunPropertyChange") {
+					skipped.push({
+						id: item.operation.id,
+						reason: backgroundResult.type
+					});
+					continue;
+				}
+				tr = backgroundResult.transaction;
+				operationRevisionSeed = backgroundResult.nextRevisionId;
 				const clearedBackground = tr.steps.length > stepsBeforeBackgroundClear;
 				tr = applyTextReplacement({
 					tr,
@@ -999,12 +1355,12 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					commentMark,
 					suggestionId,
 					initials,
-					granularity: wordDiff?.granularity ?? "word"
+					diffText
 				});
 				if (producesTrackedChanges) appliedRevisionIds = [
 					revisionIdDelete,
 					revisionIdInsert,
-					...clearedBackground ? [revisionIdBackground] : []
+					...clearedBackground ? backgroundResult.revisionIds : []
 				];
 				break;
 			}
@@ -1013,89 +1369,131 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			case "formatRange":
 				if (producesTrackedChanges) {
-					const revisionId = revisionSeed++;
-					tr = applyTrackedInlineFormatting({
+					const formattingResult = applyTrackedInlineFormatting({
 						tr,
 						schema: view.state.schema,
 						doc: tr.doc,
 						from: item.from,
 						to: item.to,
 						formatting: item.operation.formatting,
-						revisionId,
+						revisionIdSeed: operationRevisionSeed,
 						author,
 						date,
 						initials,
-						suggestionId
+						suggestionId,
+						styleResolver
 					});
-					appliedRevisionIds = [revisionId];
+					if (formattingResult.type === "pendingRunPropertyChange") {
+						skipped.push({
+							id: item.operation.id,
+							reason: formattingResult.type
+						});
+						continue;
+					}
+					tr = formattingResult.transaction;
+					operationRevisionSeed = formattingResult.nextRevisionId;
+					appliedRevisionIds = [...formattingResult.revisionIds];
 					break;
 				}
 				tr = applyInlineFormatting({
 					tr,
-					schema: view.state.schema,
 					from: item.from,
 					to: item.to,
-					formatting: item.operation.formatting
+					formatting: item.operation.formatting,
+					...styleResolver !== void 0 ? { styleResolver } : {}
 				});
 				break;
 			case "replaceBlock": {
-				const revisionIdDelete = revisionSeed++;
-				const revisionIdInsert = revisionSeed++;
-				const revisionIdBackground = revisionSeed++;
+				if (!isResolvedReplaceBlockOperation(item)) panic("Resolved replaceBlock operation lost its impact discriminator");
+				const { changesStyle, changesText } = REPLACE_BLOCK_IMPACT[item.replaceBlockImpact];
+				const revisionIdDelete = operationRevisionSeed;
+				const revisionIdInsert = changesText ? operationRevisionSeed + 1 : operationRevisionSeed;
+				const revisionIdBackgroundSeed = changesText ? operationRevisionSeed + 2 : operationRevisionSeed;
+				if (producesTrackedChanges && changesText) operationRevisionSeed = revisionIdBackgroundSeed;
 				if (item.operation.preserveFormatting === false && mode === "direct") {
 					const replacement = item.operation.text;
 					const paragraphType = view.state.schema.nodes["paragraph"];
 					if (paragraphType) {
-						const replaceAttrs = item.operation.styleId !== void 0 ? { styleId: item.operation.styleId } : null;
-						const node = paragraphType.create(replaceAttrs, replacement.length === 0 ? null : buildEmphasisInlineContent(view.state.schema, replacement, []));
+						const node = paragraphType.create(null, replacement.length === 0 ? null : buildEmphasisInlineContent(view.state.schema, replacement, commentMark ? [commentMark] : []));
 						tr = tr.replaceWith(item.blockFrom, item.blockTo, node);
+						tr = applyReplaceBlockStyleId({
+							item,
+							tr,
+							styleResolver
+						}).tr;
 						break;
 					}
 				}
 				if (mode === "direct" && hasInlineEmphasis(item.operation.text)) {
-					const attrs = item.operation.styleId !== void 0 ? {
-						...item.blockNode.attrs,
-						styleId: item.operation.styleId
-					} : { ...item.blockNode.attrs };
-					const node = item.blockNode.type.create(attrs, buildEmphasisInlineContent(view.state.schema, item.operation.text, commentMark ? [commentMark] : []));
+					const node = item.blockNode.type.create({ ...item.blockNode.attrs }, buildEmphasisInlineContent(view.state.schema, item.operation.text, commentMark ? [commentMark] : []));
 					tr = tr.replaceWith(item.blockFrom, item.blockTo, node);
+					tr = applyReplaceBlockStyleId({
+						item,
+						tr,
+						styleResolver
+					}).tr;
 					break;
 				}
-				const stepsBeforeBackgroundClear = tr.steps.length;
-				tr = clearReplacementBackground({
-					tr,
-					schema: view.state.schema,
-					from: item.from,
-					to: item.to,
-					mode,
-					revisionId: revisionIdBackground,
-					author,
-					date,
-					initials,
-					suggestionId
-				});
-				const clearedBackground = tr.steps.length > stepsBeforeBackgroundClear;
-				tr = applyTextReplacement({
-					tr,
-					item,
-					mode,
-					author,
-					date,
-					revisionIdDelete,
-					revisionIdInsert,
-					commentMark,
-					suggestionId,
-					initials,
-					granularity: wordDiff?.granularity ?? "word"
-				});
-				tr = applyReplaceBlockStyleId({
+				let clearedBackground = false;
+				let backgroundRevisionIds = [];
+				if (changesText) {
+					const stepsBeforeBackgroundClear = tr.steps.length;
+					const backgroundResult = clearReplacementBackground({
+						tr,
+						schema: view.state.schema,
+						from: item.from,
+						to: item.to,
+						mode,
+						revisionIdSeed: revisionIdBackgroundSeed,
+						author,
+						date,
+						initials,
+						suggestionId,
+						styleResolver
+					});
+					if (backgroundResult.type === "pendingRunPropertyChange") {
+						skipped.push({
+							id: item.operation.id,
+							reason: backgroundResult.type
+						});
+						continue;
+					}
+					tr = backgroundResult.transaction;
+					operationRevisionSeed = backgroundResult.nextRevisionId;
+					clearedBackground = tr.steps.length > stepsBeforeBackgroundClear;
+					backgroundRevisionIds = backgroundResult.revisionIds;
+					tr = applyTextReplacement({
+						tr,
+						item,
+						mode,
+						author,
+						date,
+						revisionIdDelete,
+						revisionIdInsert,
+						commentMark,
+						suggestionId,
+						initials,
+						diffText
+					});
+				}
+				const revisionIdParagraph = producesTrackedChanges && changesStyle ? operationRevisionSeed++ : null;
+				const styleResult = applyReplaceBlockStyleId({
 					item,
-					tr
+					tr,
+					styleResolver,
+					...revisionIdParagraph !== null ? { revisionInfo: {
+						id: revisionIdParagraph,
+						author,
+						date,
+						...trackedRevisionExtras
+					} } : {}
 				});
+				tr = styleResult.tr;
+				if (!changesText && commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				if (producesTrackedChanges) appliedRevisionIds = [
-					revisionIdDelete,
-					revisionIdInsert,
-					...clearedBackground ? [revisionIdBackground] : []
+					...changesText ? [revisionIdDelete, revisionIdInsert] : [],
+					...clearedBackground ? backgroundRevisionIds : [],
+					...styleResult.revisionId === null ? [] : [styleResult.revisionId]
 				];
 				break;
 			}
@@ -1113,16 +1511,18 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				const built = buildInsertedParagraphs({
 					item,
 					schema: view.state.schema,
+					formattingFromStyle: formattingFromStyleForInsertion(item),
 					mode,
 					author,
 					date,
 					initials,
 					commentMark,
 					suggestionId,
-					revisionSeed,
-					isPairedMove
+					revisionSeed: operationRevisionSeed,
+					isPairedMove,
+					numbering
 				});
-				revisionSeed = built.nextRevisionId;
+				operationRevisionSeed = built.nextRevisionId;
 				if (built.revisionIds.length > 0) appliedRevisionIds = built.revisionIds;
 				tr = tr.insert(item.from, built.nodes);
 				break;
@@ -1148,7 +1548,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				let node = signatureTable;
 				if (isSuggested && suggestionId !== null) {
-					const revisionId = revisionSeed++;
+					const revisionId = operationRevisionSeed++;
 					node = signatureTable.type.create({
 						...signatureTable.attrs,
 						_suggestedInsert: {
@@ -1191,7 +1591,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1221,7 +1621,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				const columnKey = getTableColumnCoordinateKey(insertion);
@@ -1254,7 +1654,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1270,7 +1670,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const revisionId = mode === "tracked-changes" ? operationRevisionSeed : null;
 				const nextTr = revisionId === null ? mergeTableRectangle({
 					tr,
 					tablePosition,
@@ -1294,7 +1694,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = nextTr;
 				if (revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [revisionId];
 				}
 				break;
@@ -1310,7 +1710,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const revisionId = mode === "tracked-changes" ? operationRevisionSeed : null;
 				const nextTr = revisionId === null ? splitTableRectangle({
 					tr,
 					tablePosition,
@@ -1334,7 +1734,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = nextTr;
 				if (revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [revisionId];
 				}
 				break;
@@ -1362,7 +1762,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1374,7 +1774,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					break;
 				}
 				if (deletionType) {
-					const revisionId = revisionSeed++;
+					const revisionId = operationRevisionSeed++;
 					const deletionMark = deletionType.create({
 						revisionId,
 						author,
@@ -1389,7 +1789,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					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 markRevisionId = revisionSeed++;
+						const markRevisionId = operationRevisionSeed++;
 						tr = tr.setNodeAttribute(markPosition, "pPrMark", {
 							kind: isPairedMove(item.operation.moveId) ? "moveFrom" : "del",
 							info: {
@@ -1406,7 +1806,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			case "insertTable": {
 				const revision = {
-					revisionId: revisionSeed,
+					revisionId: operationRevisionSeed,
 					author,
 					date,
 					...trackedRevisionExtras
@@ -1428,7 +1828,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				if (producesTrackedChanges) appliedRevisionIds = [revisionSeed++];
+				if (producesTrackedChanges) appliedRevisionIds = [operationRevisionSeed++];
 				tr = tr.insert(item.from, table);
 				markStructuralChange(tr);
 				break;
@@ -1466,7 +1866,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					continue;
 				}
 				const revision = {
-					revisionId: revisionSeed++,
+					revisionId: operationRevisionSeed++,
 					author,
 					date,
 					...trackedRevisionExtras
@@ -1500,7 +1900,22 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			case "setBlockParagraphProperties": {
 				const blockPosition = tr.mapping.map(item.blockFrom);
 				const liveBlock = tr.doc.nodeAt(blockPosition) ?? item.blockNode;
-				const patch = paragraphPropertiesPatch(liveBlock, item.operation.properties);
+				const liveAttrs = expectParagraphAttrs(liveBlock);
+				const resolvedFormattingFromStyle = item.operation.properties.styleId === void 0 ? resolveFormattingFromStyle({
+					attrs: liveAttrs,
+					styleId: liveAttrs.styleId,
+					styleResolver
+				}) : resolveFormattingFromStyle({
+					attrs: liveAttrs,
+					styleId: item.operation.properties.styleId,
+					styleResolver
+				});
+				const patch = paragraphPropertiesPatch({
+					node: liveBlock,
+					properties: item.operation.properties,
+					resolvedFormattingFromStyle,
+					numbering
+				});
 				if (patch === null) {
 					skipped.push({
 						id: item.operation.id,
@@ -1515,14 +1930,14 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					break;
 				}
-				const revisionId = revisionSeed++;
+				const revisionId = operationRevisionSeed++;
 				const change = {
 					type: "paragraphPropertyChange",
 					info: {
 						id: revisionId,
 						author,
 						date,
-						...initials ? { initials } : {}
+						...trackedRevisionExtras
 					},
 					previousFormatting: paragraphPropertiesSnapshot(liveBlock)
 				};
@@ -1541,7 +1956,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr = tr.split(item.from);
 					break;
 				}
-				const revisionIdMark = revisionSeed++;
+				const revisionIdMark = operationRevisionSeed++;
 				const info = {
 					id: revisionIdMark,
 					author,
@@ -1550,7 +1965,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				};
 				appliedRevisionIds = [revisionIdMark];
 				if (item.to > item.from && deletionType) {
-					const revisionIdSeparator = revisionSeed++;
+					const revisionIdSeparator = operationRevisionSeed++;
 					tr = tr.addMark(item.from, item.to, deletionType.create({
 						revisionId: revisionIdSeparator,
 						author,
@@ -1574,10 +1989,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr = tr.join(item.blockTo + separator.length);
 					break;
 				}
-				const revisionIdMark = revisionSeed++;
+				const revisionIdMark = operationRevisionSeed++;
 				appliedRevisionIds = [revisionIdMark];
 				if (separator.length > 0 && insertionType) {
-					const revisionIdSeparator = revisionSeed++;
+					const revisionIdSeparator = operationRevisionSeed++;
 					tr = tr.insertText(separator, insertAt);
 					tr = tr.addMark(insertAt, insertAt + separator.length, insertionType.create({
 						revisionId: revisionIdSeparator,
@@ -1610,9 +2025,24 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			});
 			continue;
 		}
+		let committedCommentId;
+		if (item.commentText !== void 0) {
+			if (commentType === void 0 || provisionalCommentId === void 0 || commentMarkRanges(tr.doc, commentType, provisionalCommentId).length === 0) panic("A commented operation changed the document without producing a comment anchor", {
+				operationId: item.operation.id,
+				operationType: item.operation.type
+			});
+			committedCommentId = allocateCommittedCommentId(item.commentText);
+			tr = commitProvisionalComment({
+				tr,
+				commentType,
+				provisionalId: provisionalCommentId,
+				committedId: committedCommentId
+			});
+		}
+		revisionSeed = operationRevisionSeed;
 		applied.push({
 			id: item.operation.id,
-			...item.commentId !== void 0 && { commentId: item.commentId },
+			...committedCommentId !== void 0 && { commentId: committedCommentId },
 			...appliedRevisionIds !== void 0 && appliedRevisionIds[0] !== void 0 && {
 				revisionId: appliedRevisionIds[0],
 				revisionIds: appliedRevisionIds
@@ -1633,6 +2063,21 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		});
 		tr = rotated.transaction;
 		revisionSeed = rotated.nextRevisionId;
+		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) {
+			const receiptIndex = receiptIndexByRevisionId.get(ownerRevisionId);
+			const receipt = receiptIndex === void 0 ? void 0 : applied.at(receiptIndex);
+			if (receiptIndex === void 0 || !receipt?.revisionIds) panic("A synthesized final-mark revision lost its operation receipt", {
+				ownerRevisionId,
+				revisionId
+			});
+			applied[receiptIndex] = {
+				...receipt,
+				revisionIds: [...receipt.revisionIds, revisionId]
+			};
+		}
+		if (ownsSharedRevisionIdCursor) revisionIdCursor = Math.max(revisionIdCursor, revisionSeed);
 		if (revisionStamp) requestDeterministicParaIds(tr, `${revisionStamp.date}:${String(revisionStamp.idSeed)}`);
 		view.dispatch(tr);
 	}
@@ -1657,7 +2102,8 @@ const previewFolioAIEditOperations = (options) => {
 		...applyOptions,
 		view: previewView,
 		...createCommentId !== void 0 && { createCommentId: () => previewCommentId-- },
-		revisionIdSeed: -1e9
+		revisionIdSeed: -1e9,
+		wordDiffMode: "coarse"
 	});
 	return {
 		applied: result.applied.map(({ id }) => ({ id })),
@@ -1666,7 +2112,7 @@ const previewFolioAIEditOperations = (options) => {
 		nextRevisionId: options.revisionStamp?.idSeed ?? revisionIdCursor
 	};
 };
-const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials, granularity }) => {
+const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials, diffText }) => {
 	let nextTr = tr;
 	const replacement = stripInlineEmphasisMarkers((() => {
 		if (item.operation.type === "replaceInBlock" || item.operation.type === "replaceRange") return item.operation.replace;
@@ -1720,7 +2166,7 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 		}
 	}
 	if (sourceText !== null && cleanBlock !== null) {
-		const segments = diffWordSegments(sourceText, replacement, { granularity });
+		const segments = diffText(sourceText, replacement);
 		const offsets = cleanBlock.offsets;
 		const offsetAt = (cleanOffset) => offsets[cleanOffset] ?? null;
 		const steps = [];
@@ -1813,7 +2259,8 @@ const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId
 	const cleanBlock = buildCleanBlockText(live.node, live.from);
 	const currentText = cleanBlock.text;
 	const currentTextHash = hashFolioAIBlockText(normalizeFolioAIBlockText(currentText));
-	if (currentTextHash !== anchor.textHash) return {
+	const structuralBoundaryHash = hashFolioAIBlockStructuralBoundaries(cleanBlock);
+	if (currentTextHash !== anchor.textHash || structuralBoundaryHash !== anchor.structuralBoundaryHash) return {
 		type: "skip",
 		reason: "changedBlock"
 	};
@@ -1843,9 +2290,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 	};
 	if (operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange") {
 		const { startOffset, endOffset, selectedTextHash } = operation.range;
-		const from = cleanBlock.offsets[startOffset];
-		const to = cleanBlock.offsets[endOffset];
-		if (from === void 0 || to === void 0) return {
+		if (cleanBlock.offsets[startOffset] === void 0 || cleanBlock.offsets[endOffset] === void 0) return {
 			type: "skip",
 			reason: "staleRange"
 		};
@@ -1854,6 +2299,15 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "skip",
 			reason: "staleRange"
 		};
+		const range = resolveCleanTextRange({
+			cleanBlock,
+			startOffset,
+			endOffset
+		});
+		if (range === null) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
 		if (operation.type === "replaceRange" && selectedText === operation.replace) return {
 			type: "skip",
 			reason: "noopOperation"
@@ -1862,8 +2316,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "resolved",
 			operation: {
 				operation,
-				from,
-				to,
+				from: range.from,
+				to: range.to,
 				blockFrom,
 				blockTo,
 				blockNode
@@ -2166,8 +2620,10 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 	};
 	if (operation.type === "splitBlock") {
 		const separator = operation.separator ?? "";
-		const at = cleanBlock.offsets[operation.offset];
-		const after = cleanBlock.offsets[operation.offset + separator.length];
+		const startOffset = operation.offset;
+		const endOffset = operation.offset + separator.length;
+		const at = cleanBlock.offsets[startOffset];
+		const after = cleanBlock.offsets[endOffset];
 		if (at === void 0 || after === void 0 || operation.offset === 0 || operation.offset + separator.length >= currentText.length) return {
 			type: "skip",
 			reason: "staleRange"
@@ -2176,7 +2632,12 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "skip",
 			reason: "staleRange"
 		};
-		if (!canSplit(doc, at)) return {
+		const range = resolveCleanTextRange({
+			cleanBlock,
+			startOffset,
+			endOffset
+		});
+		if (range === null || !canSplit(doc, range.from)) return {
 			type: "skip",
 			reason: "unsupportedBlock"
 		};
@@ -2184,8 +2645,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "resolved",
 			operation: {
 				operation,
-				from: at,
-				to: after,
+				from: range.from,
+				to: range.to,
 				blockFrom,
 				blockTo,
 				blockNode
@@ -2210,6 +2671,12 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		};
 	}
 	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 {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
 		const range = getTextRangeFromCleanBlock(cleanBlock);
 		if (!range) {
 			const insertionPoint = cleanBlock.offsets.at(0);
@@ -2217,10 +2684,25 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				type: "skip",
 				reason: "unsupportedBlock"
 			};
-			if (!(operation.type === "deleteBlock" ? true : currentText.length === 0 && operation.text.length > 0)) return {
+			if (!(operation.type === "deleteBlock" ? true : currentText.length === 0 && (operation.text.length > 0 || replaceChangesStyle))) return {
 				type: "skip",
 				reason: "unsupportedBlock"
 			};
+			if (operation.type === "replaceBlock") return {
+				type: "resolved",
+				operation: {
+					operation,
+					from: insertionPoint,
+					to: insertionPoint,
+					blockFrom,
+					blockTo,
+					blockNode,
+					replaceBlockImpact: resolveReplaceBlockImpact({
+						changesText: replaceChangesText,
+						changesStyle: replaceChangesStyle
+					})
+				}
+			};
 			return {
 				type: "resolved",
 				operation: {
@@ -2233,9 +2715,26 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				}
 			};
 		}
-		if (operation.type === "replaceBlock" && operation.text === currentText) return {
-			type: "skip",
-			reason: "noopOperation"
+		if (operation.type === "replaceBlock" && operation.text === currentText) {
+			if (!replaceChangesStyle) return {
+				type: "skip",
+				reason: "noopOperation"
+			};
+		}
+		if (operation.type === "replaceBlock") return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: range.from,
+				to: range.to,
+				blockFrom,
+				blockTo,
+				blockNode,
+				replaceBlockImpact: resolveReplaceBlockImpact({
+					changesText: replaceChangesText,
+					changesStyle: replaceChangesStyle
+				})
+			}
 		};
 		return {
 			type: "resolved",
@@ -2273,7 +2772,7 @@ const resolveTextInCleanBlock = (cleanBlock, find) => {
 		type: "skip",
 		reason: "emptyOperation"
 	};
-	const { text, offsets } = cleanBlock;
+	const { text } = cleanBlock;
 	const firstIndex = text.indexOf(find);
 	if (firstIndex === -1) return {
 		type: "skip",
@@ -2283,16 +2782,18 @@ const resolveTextInCleanBlock = (cleanBlock, find) => {
 		type: "skip",
 		reason: "ambiguousFind"
 	};
-	const from = offsets[firstIndex];
-	const to = offsets[firstIndex + find.length];
-	if (from === void 0 || to === void 0) return {
+	const range = resolveCleanTextRange({
+		cleanBlock,
+		startOffset: firstIndex,
+		endOffset: firstIndex + find.length
+	});
+	if (range === null) return {
 		type: "skip",
 		reason: "unsupportedBlock"
 	};
 	return {
 		type: "resolved",
-		from,
-		to
+		...range
 	};
 };
 const getTextRangeFromCleanBlock = (cleanBlock) => {