@stll/folio-core 0.36.0 → 0.37.1

package/dist/ai-edits/apply.js

@@ -1,17 +1,23 @@
-import { expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
-import { paragraphPropertiesSnapshot } 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";
@@ -19,6 +25,7 @@ import { findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBounda
 import { tableFromTemplate } from "./table-template.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
@@ -43,6 +50,36 @@ const coarseWordDiff = (before, after) => {
 		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
@@ -65,21 +102,6 @@ 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
-});
 const REPLACE_BLOCK_IMPACT = {
 	text: {
 		changesStyle: false,
@@ -95,14 +117,40 @@ const REPLACE_BLOCK_IMPACT = {
 	}
 };
 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) => {
+	if (item.operation.type === "setBlockParagraphProperties") return true;
+	if (item.operation.type === "splitBlock") return item.operation.firstParagraphProperties !== void 0 || item.operation.secondParagraphProperties !== void 0;
+	if (item.operation.type === "mergeBlockWithNext") return item.operation.mergedParagraphProperties !== void 0;
+	return 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, resolvedAlignmentFromStyle }) => {
+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 = {};
 	let originalFormatting = attrs._originalFormatting === void 0 || attrs._originalFormatting === null ? void 0 : { ...attrs._originalFormatting };
 	let originalFormattingChanged = false;
@@ -110,8 +158,12 @@ const paragraphPropertiesPatch = ({ node, properties, resolvedAlignmentFromStyle
 	const styleChanged = nextStyleId !== void 0 && (attrs.styleId ?? null) !== nextStyleId;
 	if (styleChanged) {
 		patch["styleId"] = nextStyleId;
-		patch["alignmentFromStyle"] = resolvedAlignmentFromStyle;
-		if (properties.alignment === void 0) patch["alignment"] = currentDirectAlignment ?? resolvedAlignmentFromStyle ?? null;
+		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;
@@ -120,29 +172,39 @@ const paragraphPropertiesPatch = ({ node, properties, resolvedAlignmentFromStyle
 	}
 	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 : resolvedAlignmentFromStyle;
+		const alignmentFromStyle = properties.styleId === void 0 ? attrs.alignmentFromStyle : resolvedFormattingFromStyle?.alignment;
 		patch["alignment"] = properties.alignment ?? alignmentFromStyle ?? null;
 		originalFormattingChanged = true;
 	}
-	if (originalFormattingChanged && originalFormatting !== void 0) patch["_originalFormatting"] = Object.keys(originalFormatting).length > 0 ? originalFormatting : null;
+	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"]);
@@ -201,7 +263,58 @@ const paragraphPropertiesBeforeBatch = (node, batchRevisionIds) => {
 	if (!earliestBatchChange) return paragraphPropertiesSnapshot(node);
 	return earliestBatchChange.previousFormatting ?? {};
 };
-const resolveAlignmentFromStyle = ({ attrs, styleId, styleResolver }) => styleResolver?.resolveParagraphStyle(styleId).paragraphFormatting?.alignment ?? ((styleId ?? void 0) === (attrs.styleId ?? void 0) ? attrs.alignmentFromStyle : void 0);
+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;
+};
+/**
+* Apply one paragraph-property patch to a live node. A tracked patch stores
+* the complete previous pPr: a partial snapshot cannot distinguish a property
+* the change left alone from one it explicitly cleared when rejecting it.
+*/
+const applyBlockParagraphProperties = ({ tr, position, node, properties, styleResolver, numbering = null, revisionInfo }) => {
+	const attrs = expectParagraphAttrs(node);
+	const resolvedFormattingFromStyle = properties.styleId === void 0 ? resolveFormattingFromStyle({
+		attrs,
+		styleId: attrs.styleId,
+		styleResolver
+	}) : resolveFormattingFromStyle({
+		attrs,
+		styleId: properties.styleId,
+		styleResolver
+	});
+	const patch = paragraphPropertiesPatch({
+		node,
+		properties,
+		resolvedFormattingFromStyle,
+		numbering
+	});
+	if (patch === null) return {
+		tr,
+		changed: false,
+		revisionId: null
+	};
+	const changeInfo = revisionInfo?.();
+	const change = changeInfo ? {
+		type: "paragraphPropertyChange",
+		info: changeInfo,
+		previousFormatting: paragraphPropertiesSnapshot(node)
+	} : null;
+	const existing = attrs._propertyChanges;
+	return {
+		tr: tr.setNodeMarkup(position, void 0, {
+			...node.attrs,
+			...patch,
+			...change ? { _propertyChanges: [...Array.isArray(existing) ? existing : [], change] } : {}
+		}),
+		changed: true,
+		revisionId: change?.info.id ?? null
+	};
+};
 const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) => {
 	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return {
 		tr,
@@ -214,7 +327,7 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		revisionId: null
 	};
 	const attrs = expectParagraphAttrs(block);
-	const resolvedAlignmentFromStyle = resolveAlignmentFromStyle({
+	const resolvedFormattingFromStyle = resolveFormattingFromStyle({
 		attrs,
 		styleId: item.operation.styleId,
 		styleResolver
@@ -222,7 +335,7 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 	const patch = paragraphPropertiesPatch({
 		node: block,
 		properties: { styleId: item.operation.styleId },
-		resolvedAlignmentFromStyle
+		resolvedFormattingFromStyle
 	});
 	if (patch === null) return {
 		tr,
@@ -247,141 +360,134 @@ 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,
@@ -389,26 +495,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: {
@@ -417,35 +582,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.
@@ -686,6 +840,7 @@ 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);
@@ -781,6 +936,7 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 				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,
@@ -810,7 +966,7 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 		synthesizedRevisions
 	};
 };
-const buildInsertedParagraphs = ({ item, schema, alignmentFromStyle, 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"];
@@ -823,7 +979,12 @@ const buildInsertedParagraphs = ({ item, schema, alignmentFromStyle, mode, autho
 			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 = [];
@@ -847,33 +1008,51 @@ const buildInsertedParagraphs = ({ item, schema, alignmentFromStyle, mode, autho
 		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)) {
+		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;
-			attrs["alignmentFromStyle"] = alignmentFromStyle;
-			attrs["alignment"] = directAlignment ?? alignmentFromStyle ?? null;
+			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"];
-			const originalFormatting = typeof sourceFormatting === "object" && sourceFormatting !== null ? { ...sourceFormatting } : {};
-			if (operation.styleId !== void 0) if (operation.styleId === null) Reflect.deleteProperty(originalFormatting, "styleId");
-			else originalFormatting.styleId = operation.styleId;
-			if (operation.alignment !== void 0 || inheritedDirectAlignment !== void 0) if (directAlignment === void 0) Reflect.deleteProperty(originalFormatting, "alignment");
-			else originalFormatting.alignment = directAlignment;
-			attrs["_originalFormatting"] = Object.keys(originalFormatting).length > 0 ? originalFormatting : null;
+			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,
@@ -914,13 +1093,37 @@ 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 alignmentFromStyleForInsertion = (item) => {
+	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 resolveAlignmentFromStyle({
+		return resolveFormattingFromStyle({
 			attrs: anchorAttrs,
 			styleId,
 			styleResolver
@@ -964,6 +1167,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}`;
@@ -993,11 +1203,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) => ({
@@ -1040,6 +1249,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();
@@ -1071,6 +1281,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++) {
@@ -1083,25 +1304,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,
-						alignmentFromStyle: alignmentFromStyleForInsertion(insertion),
+						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
@@ -1117,9 +1337,10 @@ 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;
+		let appliedRevisionIds = [];
 		if (isSuggested && !SUGGESTED_SUPPORTED_OPERATION_TYPES.has(item.operation.type)) {
 			skipped.push({
 				id: item.operation.id,
@@ -1135,8 +1356,9 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				suggestionId
 			} : {}
 		};
+		let operationRevisionSeed = revisionSeed;
 		const structuralRevision = producesTrackedChanges ? {
-			revisionId: revisionSeed,
+			revisionId: operationRevisionSeed,
 			author,
 			date,
 			...trackedRevisionExtras
@@ -1144,22 +1366,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,
@@ -1177,7 +1409,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				if (producesTrackedChanges) appliedRevisionIds = [
 					revisionIdDelete,
 					revisionIdInsert,
-					...clearedBackground ? [revisionIdBackground] : []
+					...clearedBackground ? backgroundResult.revisionIds : []
 				];
 				break;
 			}
@@ -1186,44 +1418,52 @@ 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": {
 				if (!isResolvedReplaceBlockOperation(item)) panic("Resolved replaceBlock operation lost its impact discriminator");
 				const { changesStyle, changesText } = REPLACE_BLOCK_IMPACT[item.replaceBlockImpact];
-				const revisionIdDelete = revisionSeed;
-				const revisionIdInsert = changesText ? revisionSeed + 1 : revisionSeed;
-				const revisionIdBackground = changesText ? revisionSeed + 2 : revisionSeed;
-				if (changesText) revisionSeed += 3;
-				const revisionIdParagraph = producesTrackedChanges && changesStyle ? revisionSeed++ : null;
+				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 node = paragraphType.create(null, 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,
@@ -1244,21 +1484,33 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					break;
 				}
 				let clearedBackground = false;
+				let backgroundRevisionIds = [];
 				if (changesText) {
 					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;
 					clearedBackground = tr.steps.length > stepsBeforeBackgroundClear;
+					backgroundRevisionIds = backgroundResult.revisionIds;
 					tr = applyTextReplacement({
 						tr,
 						item,
@@ -1273,6 +1525,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 						diffText
 					});
 				}
+				const revisionIdParagraph = producesTrackedChanges && changesStyle ? operationRevisionSeed++ : null;
 				const styleResult = applyReplaceBlockStyleId({
 					item,
 					tr,
@@ -1285,9 +1538,10 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					} } : {}
 				});
 				tr = styleResult.tr;
+				if (!changesText && commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				if (producesTrackedChanges) appliedRevisionIds = [
 					...changesText ? [revisionIdDelete, revisionIdInsert] : [],
-					...clearedBackground ? [revisionIdBackground] : [],
+					...clearedBackground ? backgroundRevisionIds : [],
 					...styleResult.revisionId === null ? [] : [styleResult.revisionId]
 				];
 				break;
@@ -1306,17 +1560,18 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				const built = buildInsertedParagraphs({
 					item,
 					schema: view.state.schema,
-					alignmentFromStyle: alignmentFromStyleForInsertion(item),
+					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;
@@ -1342,7 +1597,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: {
@@ -1385,7 +1640,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1415,7 +1670,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				const columnKey = getTableColumnCoordinateKey(insertion);
@@ -1448,7 +1703,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1464,7 +1719,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,
@@ -1488,7 +1743,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = nextTr;
 				if (revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [revisionId];
 				}
 				break;
@@ -1504,7 +1759,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,
@@ -1528,7 +1783,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = nextTr;
 				if (revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [revisionId];
 				}
 				break;
@@ -1556,7 +1811,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				tr = result.transaction;
 				if (result.revisionId !== null) {
-					revisionSeed++;
+					operationRevisionSeed++;
 					appliedRevisionIds = [result.revisionId];
 				}
 				break;
@@ -1568,7 +1823,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					break;
 				}
 				if (deletionType) {
-					const revisionId = revisionSeed++;
+					const revisionId = operationRevisionSeed++;
 					const deletionMark = deletionType.create({
 						revisionId,
 						author,
@@ -1583,7 +1838,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: {
@@ -1600,7 +1855,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				break;
 			case "insertTable": {
 				const revision = {
-					revisionId: revisionSeed,
+					revisionId: operationRevisionSeed,
 					author,
 					date,
 					...trackedRevisionExtras
@@ -1622,7 +1877,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;
@@ -1660,7 +1915,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					continue;
 				}
 				const revision = {
-					revisionId: revisionSeed++,
+					revisionId: operationRevisionSeed++,
 					author,
 					date,
 					...trackedRevisionExtras
@@ -1694,80 +1949,89 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			case "setBlockParagraphProperties": {
 				const blockPosition = tr.mapping.map(item.blockFrom);
 				const liveBlock = tr.doc.nodeAt(blockPosition) ?? item.blockNode;
-				const liveAttrs = expectParagraphAttrs(liveBlock);
-				const resolvedAlignmentFromStyle = item.operation.properties.styleId === void 0 ? void 0 : resolveAlignmentFromStyle({
-					attrs: liveAttrs,
-					styleId: item.operation.properties.styleId,
-					styleResolver
-				});
-				const patch = paragraphPropertiesPatch({
+				const appliedProperties = applyBlockParagraphProperties({
+					tr,
+					position: blockPosition,
 					node: liveBlock,
 					properties: item.operation.properties,
-					resolvedAlignmentFromStyle
+					styleResolver,
+					numbering,
+					...mode === "direct" ? {} : { revisionInfo: () => ({
+						id: operationRevisionSeed++,
+						author,
+						date,
+						...trackedRevisionExtras
+					}) }
 				});
-				if (patch === null) {
+				if (!appliedProperties.changed) {
 					skipped.push({
 						id: item.operation.id,
 						reason: "noopOperation"
 					});
 					continue;
 				}
-				if (mode === "direct") {
-					tr = tr.setNodeMarkup(blockPosition, void 0, {
-						...liveBlock.attrs,
-						...patch
-					});
-					break;
-				}
-				const revisionId = revisionSeed++;
-				const change = {
-					type: "paragraphPropertyChange",
-					info: {
-						id: revisionId,
-						author,
-						date,
-						...trackedRevisionExtras
-					},
-					previousFormatting: paragraphPropertiesSnapshot(liveBlock)
-				};
-				const existing = expectParagraphAttrs(liveBlock)._propertyChanges;
-				tr = tr.setNodeMarkup(blockPosition, void 0, {
-					...liveBlock.attrs,
-					...patch,
-					_propertyChanges: [...Array.isArray(existing) ? existing : [], change]
-				});
-				appliedRevisionIds = [revisionId];
+				tr = appliedProperties.tr;
+				if (appliedProperties.revisionId !== null) appliedRevisionIds = [appliedProperties.revisionId];
 				break;
 			}
 			case "splitBlock": {
 				if (mode === "direct") {
 					if (item.to > item.from) tr = tr.delete(item.from, item.to);
 					tr = tr.split(item.from);
-					break;
-				}
-				const revisionIdMark = revisionSeed++;
-				const info = {
-					id: revisionIdMark,
-					author,
-					date,
-					...trackedRevisionExtras
-				};
-				appliedRevisionIds = [revisionIdMark];
-				if (item.to > item.from && deletionType) {
-					const revisionIdSeparator = revisionSeed++;
-					tr = tr.addMark(item.from, item.to, deletionType.create({
-						revisionId: revisionIdSeparator,
+				} else {
+					const revisionIdMark = operationRevisionSeed++;
+					const info = {
+						id: revisionIdMark,
 						author,
 						date,
 						...trackedRevisionExtras
-					}));
-					appliedRevisionIds = [revisionIdMark, revisionIdSeparator];
+					};
+					appliedRevisionIds = [revisionIdMark];
+					if (item.to > item.from && deletionType) {
+						const revisionIdSeparator = operationRevisionSeed++;
+						tr = tr.addMark(item.from, item.to, deletionType.create({
+							revisionId: revisionIdSeparator,
+							author,
+							date,
+							...trackedRevisionExtras
+						}));
+						appliedRevisionIds.push(revisionIdSeparator);
+					}
+					tr = tr.split(item.from);
+					tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
+						kind: "ins",
+						info
+					});
 				}
-				tr = tr.split(item.from);
-				tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
-					kind: "ins",
-					info
+				const allocateSplitParagraphPropertyRevisionInfo = () => ({
+					id: operationRevisionSeed++,
+					author,
+					date,
+					...trackedRevisionExtras
 				});
+				const paragraphPropertyTargets = [{
+					position: item.blockFrom,
+					properties: item.operation.firstParagraphProperties
+				}, {
+					position: item.from + 1,
+					properties: item.operation.secondParagraphProperties
+				}];
+				for (const { position, properties } of paragraphPropertyTargets) {
+					if (!properties) continue;
+					const paragraph = tr.doc.nodeAt(position);
+					if (!paragraph) panic("A resolved split did not produce two paragraphs");
+					const appliedProperties = applyBlockParagraphProperties({
+						tr,
+						position,
+						node: paragraph,
+						properties,
+						styleResolver,
+						numbering,
+						...mode === "direct" ? {} : { revisionInfo: allocateSplitParagraphPropertyRevisionInfo }
+					});
+					tr = appliedProperties.tr;
+					if (appliedProperties.revisionId !== null) appliedRevisionIds.push(appliedProperties.revisionId);
+				}
 				break;
 			}
 			case "mergeBlockWithNext": {
@@ -1776,30 +2040,50 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				if (mode === "direct") {
 					if (separator.length > 0) tr = tr.insertText(separator, insertAt);
 					tr = tr.join(item.blockTo + separator.length);
-					break;
+				} else {
+					const revisionIdMark = operationRevisionSeed++;
+					appliedRevisionIds = [revisionIdMark];
+					if (separator.length > 0 && insertionType) {
+						const revisionIdSeparator = operationRevisionSeed++;
+						tr = tr.insertText(separator, insertAt);
+						tr = tr.addMark(insertAt, insertAt + separator.length, insertionType.create({
+							revisionId: revisionIdSeparator,
+							author,
+							date,
+							...trackedRevisionExtras
+						}));
+						appliedRevisionIds.push(revisionIdSeparator);
+					}
+					tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
+						kind: "del",
+						info: {
+							id: revisionIdMark,
+							author,
+							date,
+							...trackedRevisionExtras
+						}
+					});
 				}
-				const revisionIdMark = revisionSeed++;
-				appliedRevisionIds = [revisionIdMark];
-				if (separator.length > 0 && insertionType) {
-					const revisionIdSeparator = revisionSeed++;
-					tr = tr.insertText(separator, insertAt);
-					tr = tr.addMark(insertAt, insertAt + separator.length, insertionType.create({
-						revisionId: revisionIdSeparator,
-						author,
-						date,
-						...trackedRevisionExtras
-					}));
-					appliedRevisionIds = [revisionIdMark, revisionIdSeparator];
+				if (item.operation.mergedParagraphProperties) {
+					const mergedParagraph = tr.doc.nodeAt(item.blockFrom);
+					if (!mergedParagraph) panic("A resolved merge did not produce a paragraph");
+					const appliedProperties = applyBlockParagraphProperties({
+						tr,
+						position: item.blockFrom,
+						node: mergedParagraph,
+						properties: item.operation.mergedParagraphProperties,
+						styleResolver,
+						numbering,
+						...mode === "direct" ? {} : { revisionInfo: () => ({
+							id: operationRevisionSeed++,
+							author,
+							date,
+							...trackedRevisionExtras
+						}) }
+					});
+					tr = appliedProperties.tr;
+					if (appliedProperties.revisionId !== null) appliedRevisionIds.push(appliedProperties.revisionId);
 				}
-				tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
-					kind: "del",
-					info: {
-						id: revisionIdMark,
-						author,
-						date,
-						...trackedRevisionExtras
-					}
-				});
 				break;
 			}
 			case "commentOnBlock":
@@ -1814,10 +2098,25 @@ 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 },
-			...appliedRevisionIds !== void 0 && appliedRevisionIds[0] !== void 0 && {
+			...committedCommentId !== void 0 && { commentId: committedCommentId },
+			...appliedRevisionIds[0] !== void 0 && {
 				revisionId: appliedRevisionIds[0],
 				revisionIds: appliedRevisionIds
 			},
@@ -1851,6 +2150,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				revisionIds: [...receipt.revisionIds, revisionId]
 			};
 		}
+		if (ownsSharedRevisionIdCursor) revisionIdCursor = Math.max(revisionIdCursor, revisionSeed);
 		if (revisionStamp) requestDeterministicParaIds(tr, `${revisionStamp.date}:${String(revisionStamp.idSeed)}`);
 		view.dispatch(tr);
 	}
@@ -2032,7 +2332,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"
 	};
@@ -2062,9 +2363,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"
 		};
@@ -2073,6 +2372,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"
@@ -2081,8 +2389,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "resolved",
 			operation: {
 				operation,
-				from,
-				to,
+				from: range.from,
+				to: range.to,
 				blockFrom,
 				blockTo,
 				blockNode
@@ -2385,8 +2693,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"
@@ -2395,7 +2705,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"
 		};
@@ -2403,8 +2718,8 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			type: "resolved",
 			operation: {
 				operation,
-				from: at,
-				to: after,
+				from: range.from,
+				to: range.to,
 				blockFrom,
 				blockTo,
 				blockNode
@@ -2429,7 +2744,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);
@@ -2451,7 +2771,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 					blockTo,
 					blockNode,
 					replaceBlockImpact: resolveReplaceBlockImpact({
-						changesText: operation.text !== currentText,
+						changesText: replaceChangesText,
 						changesStyle: replaceChangesStyle
 					})
 				}
@@ -2484,7 +2804,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				blockTo,
 				blockNode,
 				replaceBlockImpact: resolveReplaceBlockImpact({
-					changesText: operation.text !== currentText,
+					changesText: replaceChangesText,
 					changesStyle: replaceChangesStyle
 				})
 			}
@@ -2525,7 +2845,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",
@@ -2535,16 +2855,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) => {