@stll/folio-core 0.32.1 → 0.33.0

package/dist/ai-edits/apply.js

@@ -1,16 +1,22 @@
-import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { PPR_CHANGE_SCOPED_ATTR_KEYS } from "../prosemirror/commands/propertyChangeScope.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 { 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 { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers } from "./inline-emphasis.js";
-import { hashFolioAIBlockText, normalizeFolioAIBlockText } from "./snapshot.js";
+import { 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 } from "./table-row-column-mutations.js";
-import { findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell } from "./table-targets.js";
+import { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, splitCellParagraphTexts } from "./table-row-column-mutations.js";
+import { findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBoundary, tableRectangleCutsMergedCell } from "./table-targets.js";
 import { diffWordSegments } from "./word-diff.js";
+import { panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
+import { canJoin, canSplit } from "prosemirror-transform";
 //#region src/ai-edits/apply.ts
 /**
 * Operation types applied in `"suggested"` mode. Every produced revision — an
@@ -33,6 +39,106 @@ 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 patch = {};
+	if (properties.styleId !== void 0 && (node.attrs["styleId"] ?? null) !== properties.styleId) patch["styleId"] = properties.styleId;
+	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) {
+			const numId = typeof numPr === "object" && numPr !== null && "numId" in numPr ? numPr.numId : void 0;
+			patch["numPr"] = {
+				...typeof numId === "number" && { numId },
+				ilvl: properties.listLevel
+			};
+		}
+	}
+	return Object.keys(patch).length > 0 ? patch : null;
+};
+const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
+/**
+* Strip insertion and deletion marks from the zero-width anchors the batch
+* touched.
+*
+* An operation marks a RANGE, and a zero-width anchor between two words is
+* inside it. The operation did not create or delete that anchor, so the anchor
+* must keep its existing revision ownership. Marking is by range everywhere;
+* the guard lives here once rather than at every call site.
+*/
+const withoutRevisionsOnZeroWidthAnchors = (tr, batchRevisionIds) => {
+	const anchors = [];
+	tr.doc.descendants((node, pos) => {
+		if (!isZeroWidthAnchor(node)) return true;
+		const marks = node.marks.filter(({ attrs, type }) => REVISION_MARK_NAMES.has(type.name) && batchRevisionIds.has(attrs["revisionId"]));
+		if (marks.length > 0) anchors.push({
+			from: pos,
+			to: pos + node.nodeSize,
+			marks
+		});
+		return false;
+	});
+	for (const { from, to, marks } of anchors) for (const mark of marks) tr = tr.removeMark(from, to, mark);
+	return tr;
+};
+/**
+* The block's non-text inline children a block deletion still has to mark, as
+* positions in `tr.doc`.
+*
+* Skips what is already deleted, so an earlier revision's run is not marked
+* twice, and skips zero-width anchors because the operation did not create or
+* delete them; their existing revision ownership must remain unchanged.
+*/
+const undeletedContentAtomRanges = (tr, blockFrom) => {
+	const position = tr.mapping.map(blockFrom);
+	const block = tr.doc.nodeAt(position);
+	if (!block?.isTextblock) return [];
+	const ranges = [];
+	block.forEach((child, offset) => {
+		if (child.isText || isZeroWidthAnchor(child) || child.marks.some(({ type }) => type.name === "deletion")) return;
+		const from = position + 1 + offset;
+		ranges.push({
+			from,
+			to: from + child.nodeSize
+		});
+	});
+	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;
+};
 const applyReplaceBlockStyleId = ({ item, tr }) => {
 	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return tr;
 	const block = tr.doc.nodeAt(item.blockFrom);
@@ -143,12 +249,31 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 * uniqueness across overlapping calls in the same JS realm.
 */
 let revisionIdCursor = Date.now() * 1e3;
-const nextRevisionSeed = (count) => {
+const nextRevisionSeed = (revisionIdCount) => {
 	const start = revisionIdCursor;
-	revisionIdCursor += Math.max(count, 1) * 4;
+	revisionIdCursor += Math.max(revisionIdCount, 1);
 	return start;
 };
 /**
+* Ids one resolved operation may allocate from the shared revision-id range
+* reserved by `nextRevisionSeed`. Most operation types allocate at most
+* three (delete + insert + background-format clearing); reserving four per
+* operation is a safe cushion above that. A multi-paragraph
+* `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.
+*/
+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);
+	return REVISION_IDS_PER_OPERATION;
+};
+/**
 * Walk the live doc once and bucket every textblock by its
 * normalised text hash. Resolution then maps each snapshot anchor
 * to the live block at the same ordinal among same-hash siblings —
@@ -159,7 +284,8 @@ const nextRevisionSeed = (count) => {
 const collectLiveBlocksByHash = (doc) => {
 	const byHash = /* @__PURE__ */ new Map();
 	doc.descendants((node, pos) => {
-		if (!node.isTextblock) return;
+		if (isHiddenTableRow(node)) return false;
+		if (!node.isTextblock) return true;
 		const cleanText = buildCleanBlockText(node, pos).text;
 		const hash = hashFolioAIBlockText(normalizeFolioAIBlockText(cleanText));
 		const bucket = byHash.get(hash) ?? [];
@@ -169,6 +295,7 @@ const collectLiveBlocksByHash = (doc) => {
 			node
 		});
 		byHash.set(hash, bucket);
+		return false;
 	});
 	return byHash;
 };
@@ -183,14 +310,16 @@ const collectLiveBlocksByHash = (doc) => {
 const collectLiveBlocksByParaId = (doc) => {
 	const byParaId = /* @__PURE__ */ new Map();
 	doc.descendants((node, pos) => {
-		if (!node.isTextblock) return;
+		if (isHiddenTableRow(node)) return false;
+		if (!node.isTextblock) return true;
 		const paraId = node.attrs["paraId"];
-		if (typeof paraId !== "string" || paraId.length === 0) return;
+		if (typeof paraId !== "string" || paraId.length === 0) return false;
 		if (!byParaId.has(paraId)) byParaId.set(paraId, {
 			from: pos,
 			to: pos + node.nodeSize,
 			node
 		});
+		return false;
 	});
 	return byParaId;
 };
@@ -234,6 +363,21 @@ const ordinalAmongSameHash = (snapshot, blockId) => {
 */
 const SIGNATURE_LINE = "_".repeat(28);
 /**
+* A plain table from a grid of cell texts, `null` when the schema has no
+* tables. In tracked mode every row carries `trIns`, which is how Word says
+* "this table is new": there is no whole-table insertion element, only rows
+* that were inserted.
+*/
+const buildTableNode = ({ schema, rows, revision }) => {
+	const paragraphType = schema.nodes["paragraph"];
+	const cellType = schema.nodes["tableCell"];
+	const rowType = schema.nodes["tableRow"];
+	const tableType = schema.nodes["table"];
+	if (!paragraphType || !cellType || !rowType || !tableType || rows.length === 0) return null;
+	const rowNodes = rows.map((cells) => rowType.create(revision ? { trIns: revision } : null, cells.map((text) => cellType.create(null, splitCellParagraphTexts(text).map((line) => paragraphType.create(null, line.length > 0 ? schema.text(line) : null))))));
+	return tableType.create(null, rowNodes);
+};
+/**
 * Build a borderless PM table mirroring docx-core's
 * `signatureTable` helper: one row, one cell per party, each cell
 * containing party name (bold), two spacer paragraphs, a signature
@@ -279,6 +423,22 @@ const buildSignatureTableNode = ({ schema, parties }) => {
 	const row = rowType.create({}, cells);
 	return tableType.create({}, row);
 };
+const LINE_BREAK_PATTERN = /\r\n|\r|\n/;
+/**
+* Split `insertAfterBlock` / `insertBeforeBlock` text on line breaks into one
+* string per paragraph the operation should produce. A model routinely sends
+* a whole clause — heading plus body — as one `text` with embedded newlines;
+* Word has no such thing as a paragraph containing a line break, so each line
+* becomes its own paragraph instead of literal newline characters inside one.
+* Blank (whitespace-only) lines are dropped rather than becoming empty
+* paragraphs, so a trailing/leading newline collapses away. Falls back to a
+* single empty string when every line is blank, so callers never get zero
+* paragraphs out of non-empty input.
+*/
+const splitInsertParagraphTexts = (text) => {
+	const nonBlankLines = text.split(LINE_BREAK_PATTERN).filter((line) => line.trim().length > 0);
+	return nonBlankLines.length > 0 ? nonBlankLines : [""];
+};
 /**
 * Build the inline content for an inserted or replaced block, promoting the
 * model's `**bold**` / `***bold italic***` markdown into real Word marks (the
@@ -302,9 +462,99 @@ const buildEmphasisInlineContent = (schema, text, baseMarks) => {
 	}
 	return nodes.length > 0 ? nodes : [schema.text(text, [...baseMarks])];
 };
-const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionIdSeed }) => {
+const isBatchableParagraphInsertion = (item, mode) => {
+	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") 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 buildInsertedParagraphs = ({ item, schema, mode, author, date, initials, commentMark, suggestionId, revisionSeed, isPairedMove }) => {
+	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"];
+	const producesTrackedChanges = mode !== "direct";
+	const isSuggested = mode === "suggested";
+	const trackedRevisionExtras = {
+		...initials ? { initials } : {},
+		...suggestionId !== null ? {
+			provenance: "suggested",
+			suggestionId
+		} : {}
+	};
+	const baseAttrs = operation.inheritFormatting === false ? {} : stripBlockIdentityAttrs(item.blockNode.attrs);
+	const insertTexts = item.insertTexts ?? [""];
+	const revisionIds = [];
+	const nodes = [];
+	let nextRevisionId = revisionSeed;
+	for (const [paragraphIndex, text] of insertTexts.entries()) {
+		const isFirstParagraph = paragraphIndex === 0;
+		const marks = [];
+		let paragraphRevisionId = null;
+		if (producesTrackedChanges && insertionType) {
+			paragraphRevisionId = nextRevisionId++;
+			marks.push(insertionType.create({
+				revisionId: paragraphRevisionId,
+				author,
+				date,
+				...isPairedMove(operation.moveId) && { moveKind: "moveTo" },
+				...trackedRevisionExtras
+			}));
+			revisionIds.push(paragraphRevisionId);
+		}
+		if (commentMark) marks.push(commentMark);
+		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) {
+			attrs["numPr"] = null;
+			Object.assign(attrs, CLEARED_LIST_MARKER_ATTRS);
+		} else if (isFirstParagraph && operation.listLevel !== void 0) {
+			const anchorNumPr = 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 (isFirstParagraph && operation.styleId !== void 0) {
+			attrs["styleId"] = operation.styleId;
+			if (operation.inheritFormatting !== false && operation.styleId !== null) Object.assign(attrs, CLEARED_LIST_MARKER_ATTRS);
+		}
+		if (isSuggested && suggestionId !== null && paragraphRevisionId !== null) attrs["_suggestedInsert"] = {
+			suggestionId,
+			revisionId: paragraphRevisionId,
+			author,
+			date,
+			...initials ? { initials } : {}
+		};
+		nodes.push(item.blockNode.type.create(attrs, content));
+	}
+	if (producesTrackedChanges && !isSuggested) for (const [index, node] of nodes.entries()) {
+		const revisionId = nextRevisionId++;
+		nodes[index] = node.type.create({
+			...node.attrs,
+			pPrMark: {
+				kind: isPairedMove(operation.moveId) ? "moveTo" : "ins",
+				info: {
+					id: revisionId,
+					author,
+					date,
+					...trackedRevisionExtras
+				}
+			}
+		}, node.content);
+		revisionIds.push(revisionId);
+	}
+	return {
+		nodes,
+		revisionIds,
+		nextRevisionId
+	};
+};
+const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff }) => {
 	const applied = [];
 	const skipped = [];
+	const normalizations = [];
 	const resolved = [];
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
@@ -318,7 +568,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		skipped: operations.map((operation) => ({
 			id: operation.id,
 			reason: "unsupportedBlock"
-		}))
+		})),
+		nextRevisionId: revisionIdSeed ?? revisionStamp?.idSeed ?? revisionIdCursor
 	};
 	const liveBlocks = collectLiveBlocksByHash(view.state.doc);
 	const liveBlocksByParaId = collectLiveBlocksByParaId(view.state.doc);
@@ -369,6 +620,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			}
 			claimedTableColumns.add(columnKey);
 		}
+		if ((operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock") && LINE_BREAK_PATTERN.test(operation.text)) normalizations.push({
+			id: operation.id,
+			code: "splitMultilineText",
+			paragraphCount: resolution.operation.insertTexts?.length ?? 1
+		});
 		const commentId = commentText !== void 0 ? createCommentId?.(commentText) : void 0;
 		resolved.push({
 			...resolution.operation,
@@ -385,13 +641,41 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	const executableResolved = tablePlan.executable;
 	if (executableResolved.length === 0) return {
 		applied,
-		skipped
+		skipped,
+		...normalizations.length > 0 && { normalizations },
+		nextRevisionId: revisionIdSeed ?? revisionStamp?.idSeed ?? revisionIdCursor
+	};
+	const moveSideCounts = /* @__PURE__ */ new Map();
+	for (const { operation } of executableResolved) {
+		const moveId = operation.type === "deleteBlock" || operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock" ? operation.moveId : void 0;
+		if (moveId === void 0) continue;
+		const counts = moveSideCounts.get(moveId) ?? {
+			from: 0,
+			to: 0
+		};
+		if (operation.type === "deleteBlock") counts.from += 1;
+		else counts.to += 1;
+		moveSideCounts.set(moveId, counts);
+	}
+	const isPairedMove = (moveId) => {
+		if (moveId === void 0) return false;
+		const counts = moveSideCounts.get(moveId);
+		return counts?.from === 1 && counts.to === 1;
 	};
+	for (const { operation } of executableResolved) {
+		const moveId = operation.type === "deleteBlock" || operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock" ? operation.moveId : void 0;
+		if (moveId !== void 0 && !isPairedMove(moveId)) normalizations.push({
+			id: operation.id,
+			code: "unpairedMove",
+			moveId
+		});
+	}
 	let tr = view.state.tr;
-	let revisionSeed = revisionIdSeed ?? nextRevisionSeed(executableResolved.length);
-	const date = (/* @__PURE__ */ new Date()).toISOString();
+	const revisionIdReservation = executableResolved.reduce((total, item) => total + estimateRevisionIdReservation(item), 0);
+	let revisionSeed = revisionIdSeed ?? revisionStamp?.idSeed ?? nextRevisionSeed(revisionIdReservation);
+	const date = revisionStamp?.date ?? (/* @__PURE__ */ new Date()).toISOString();
 	const insertedColumnCounts = /* @__PURE__ */ new Map();
-	for (const item of executableResolved.toSorted((left, right) => {
+	const executionOrder = executableResolved.toSorted((left, right) => {
 		const leftCellShape = left.tableCellMerge ?? left.tableCellSplit;
 		const rightCellShape = right.tableCellMerge ?? right.tableCellSplit;
 		if (!leftCellShape && rightCellShape) return -1;
@@ -415,7 +699,55 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 		}
 		if (left.from !== right.from) return right.from - left.from;
 		return right.originalIndex - left.originalIndex;
-	})) {
+	});
+	for (let executionIndex = 0; executionIndex < executionOrder.length; executionIndex++) {
+		const item = executionOrder[executionIndex];
+		if (!item) panic("The operation execution index exceeded the resolved plan", { executionIndex });
+		if (isBatchableParagraphInsertion(item, mode)) {
+			const insertionRun = [item];
+			for (let lookahead = executionIndex + 1; lookahead < executionOrder.length; lookahead++) {
+				const candidate = executionOrder[lookahead];
+				if (!candidate || candidate.from !== item.from || !isBatchableParagraphInsertion(candidate, mode)) break;
+				insertionRun.push(candidate);
+			}
+			if (insertionRun.length > 1) {
+				const nodeGroups = [];
+				const runApplied = [];
+				for (const insertion of insertionRun) {
+					const insertionSuggestionId = isSuggested ? insertion.operation.suggestionId ?? insertion.operation.id : null;
+					const insertionCommentMark = insertion.commentId !== void 0 && commentType ? commentType.create({ commentId: insertion.commentId }) : null;
+					const built = buildInsertedParagraphs({
+						item: insertion,
+						schema: view.state.schema,
+						mode,
+						author,
+						date,
+						initials,
+						commentMark: insertionCommentMark,
+						suggestionId: insertionSuggestionId,
+						revisionSeed,
+						isPairedMove
+					});
+					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
+						},
+						...insertionSuggestionId !== null && { suggestionId: insertionSuggestionId }
+					});
+				}
+				const nodes = [];
+				for (const group of nodeGroups.toReversed()) for (const node of group) nodes.push(node);
+				tr = tr.insert(item.from, nodes);
+				applied.push(...runApplied);
+				executionIndex += insertionRun.length - 1;
+				continue;
+			}
+		}
 		const commentMark = item.commentId !== void 0 && commentType ? commentType.create({ commentId: item.commentId }) : null;
 		const stepsBefore = tr.steps.length;
 		let appliedRevisionIds;
@@ -470,7 +802,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					revisionIdInsert,
 					commentMark,
 					suggestionId,
-					initials
+					initials,
+					granularity: wordDiff?.granularity ?? "word"
 				});
 				if (producesTrackedChanges) appliedRevisionIds = [
 					revisionIdDelete,
@@ -556,7 +889,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					revisionIdInsert,
 					commentMark,
 					suggestionId,
-					initials
+					initials,
+					granularity: wordDiff?.granularity ?? "word"
 				});
 				tr = applyReplaceBlockStyleId({
 					item,
@@ -571,50 +905,30 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			}
 			case "insertAfterBlock":
 			case "insertBeforeBlock": {
-				if (mode === "tracked-changes" && item.operation.pageBreakBefore === true && (!item.insertText || item.insertText.length === 0)) {
+				const insertTexts = item.insertTexts ?? [""];
+				const isEmptyInsert = insertTexts.length === 1 && insertTexts[0]?.length === 0;
+				if (mode === "tracked-changes" && item.operation.pageBreakBefore === true && isEmptyInsert) {
 					skipped.push({
 						id: item.operation.id,
 						reason: "unsupportedMode"
 					});
 					continue;
 				}
-				const marks = [];
-				let insertedBlockRevisionId = null;
-				if (producesTrackedChanges && insertionType) {
-					const revisionId = revisionSeed++;
-					insertedBlockRevisionId = revisionId;
-					marks.push(insertionType.create({
-						revisionId,
-						author,
-						date,
-						...trackedRevisionExtras
-					}));
-					appliedRevisionIds = [revisionId];
-				}
-				if (commentMark) marks.push(commentMark);
-				const content = item.insertText && item.insertText.length > 0 ? buildEmphasisInlineContent(view.state.schema, item.insertText, marks) : null;
-				const attrs = { ...item.operation.inheritFormatting === false ? {} : stripBlockIdentityAttrs(item.blockNode.attrs) };
-				if (item.operation.pageBreakBefore === true) attrs["pageBreakBefore"] = true;
-				if (item.operation.styleId !== void 0) {
-					attrs["styleId"] = item.operation.styleId;
-					if (item.operation.inheritFormatting !== false) {
-						attrs["listMarker"] = null;
-						attrs["listMarkerHidden"] = null;
-						attrs["listLevelNumFmts"] = null;
-						attrs["listLevelStarts"] = null;
-						attrs["listAbstractNumId"] = null;
-						attrs["listStartOverride"] = null;
-					}
-				}
-				if (isSuggested && suggestionId !== null && insertedBlockRevisionId !== null) attrs["_suggestedInsert"] = {
-					suggestionId,
-					revisionId: insertedBlockRevisionId,
+				const built = buildInsertedParagraphs({
+					item,
+					schema: view.state.schema,
+					mode,
 					author,
 					date,
-					...initials ? { initials } : {}
-				};
-				const node = item.blockNode.type.create(attrs, content);
-				tr = tr.insert(item.from, node);
+					initials,
+					commentMark,
+					suggestionId,
+					revisionSeed,
+					isPairedMove
+				});
+				revisionSeed = built.nextRevisionId;
+				if (built.revisionIds.length > 0) appliedRevisionIds = built.revisionIds;
+				tr = tr.insert(item.from, built.nodes);
 				break;
 			}
 			case "insertSignatureTable": {
@@ -862,16 +1176,213 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				if (deletionType) {
 					const revisionId = revisionSeed++;
-					tr = tr.addMark(item.from, item.to, deletionType.create({
+					const deletionMark = deletionType.create({
 						revisionId,
 						author,
 						date,
+						...isPairedMove(item.operation.moveId) && { moveKind: "moveFrom" },
 						...trackedRevisionExtras
-					}));
-					appliedRevisionIds = [revisionId];
+					});
+					tr = tr.addMark(item.from, item.to, deletionMark);
+					const atomRanges = undeletedContentAtomRanges(tr, item.blockFrom);
+					for (const { from, to } of atomRanges) tr = tr.addMark(from, to, deletionMark);
+					const inlineRevisionApplied = item.from < item.to || atomRanges.length > 0;
+					appliedRevisionIds = inlineRevisionApplied ? [revisionId] : [];
+					const markPosition = tr.mapping.map(item.blockFrom);
+					if (tr.doc.resolve(markPosition).parent.childCount > 1 && tr.doc.nodeAt(markPosition)?.attrs["pPrMark"] == null) {
+						const markRevisionId = revisionSeed++;
+						tr = tr.setNodeAttribute(markPosition, "pPrMark", {
+							kind: isPairedMove(item.operation.moveId) ? "moveFrom" : "del",
+							info: {
+								id: markRevisionId,
+								author,
+								date,
+								...trackedRevisionExtras
+							}
+						});
+						appliedRevisionIds = inlineRevisionApplied ? [revisionId, markRevisionId] : [markRevisionId];
+					}
 				}
 				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				break;
+			case "insertTable": {
+				const table = buildTableNode({
+					schema: view.state.schema,
+					rows: item.operation.rows,
+					...producesTrackedChanges && { revision: {
+						revisionId: revisionSeed,
+						author,
+						date,
+						...trackedRevisionExtras
+					} }
+				});
+				if (!table) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				if (producesTrackedChanges) appliedRevisionIds = [revisionSeed++];
+				tr = tr.insert(item.from, table);
+				markStructuralChange(tr);
+				break;
+			}
+			case "deleteTable": {
+				const deleted = item.deletedTable;
+				if (!deleted) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				if (mode === "direct") {
+					const position = tr.mapping.map(deleted.position, 1);
+					const live = tr.doc.nodeAt(position);
+					if (!live || live.type.spec["tableRole"] !== "table") {
+						skipped.push({
+							id: item.operation.id,
+							reason: "unsupportedBlock"
+						});
+						continue;
+					}
+					tr = tr.delete(position, position + live.nodeSize);
+					markStructuralChange(tr);
+					break;
+				}
+				const livePosition = tr.mapping.map(deleted.position, 1);
+				const liveTable = tr.doc.nodeAt(livePosition);
+				if (!liveTable || liveTable.type.spec["tableRole"] !== "table") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revision = {
+					revisionId: revisionSeed++,
+					author,
+					date,
+					...trackedRevisionExtras
+				};
+				const rowPositions = [];
+				let rowOffset = livePosition + 1;
+				liveTable.forEach((row) => {
+					if (row.type.spec["tableRole"] === "row" && row.attrs["trDel"] == null) rowPositions.push(rowOffset);
+					rowOffset += row.nodeSize;
+				});
+				if (rowPositions.length === 0) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "noopOperation"
+					});
+					continue;
+				}
+				for (const rowPosition of rowPositions.toReversed()) tr = tr.setNodeAttribute(rowPosition, "trDel", revision);
+				appliedRevisionIds = [revision.revisionId];
+				markStructuralChange(tr);
+				break;
+			}
+			case "setBlockParagraphProperties": {
+				const patch = paragraphPropertiesPatch(item.blockNode, item.operation.properties);
+				if (patch === null) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "noopOperation"
+					});
+					continue;
+				}
+				if (mode === "direct") {
+					tr = tr.setNodeMarkup(item.blockFrom, void 0, {
+						...item.blockNode.attrs,
+						...patch
+					});
+					break;
+				}
+				const revisionId = revisionSeed++;
+				const change = {
+					type: "paragraphPropertyChange",
+					info: {
+						id: revisionId,
+						author,
+						date,
+						...initials ? { initials } : {}
+					},
+					previousFormatting: paragraphPropertiesSnapshot(item.blockNode)
+				};
+				const existing = expectParagraphAttrs(item.blockNode)._propertyChanges;
+				tr = tr.setNodeMarkup(item.blockFrom, void 0, {
+					...item.blockNode.attrs,
+					...patch,
+					_propertyChanges: [...Array.isArray(existing) ? existing : [], change]
+				});
+				appliedRevisionIds = [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,
+						author,
+						date,
+						...trackedRevisionExtras
+					}));
+					appliedRevisionIds = [revisionIdMark, revisionIdSeparator];
+				}
+				tr = tr.split(item.from);
+				tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
+					kind: "ins",
+					info
+				});
+				break;
+			}
+			case "mergeBlockWithNext": {
+				const separator = item.operation.separator ?? "";
+				const insertAt = item.blockTo - 1;
+				if (mode === "direct") {
+					if (separator.length > 0) tr = tr.insertText(separator, insertAt);
+					tr = tr.join(item.blockTo + separator.length);
+					break;
+				}
+				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];
+				}
+				tr = tr.setNodeAttribute(item.blockFrom, "pPrMark", {
+					kind: "del",
+					info: {
+						id: revisionIdMark,
+						author,
+						date,
+						...trackedRevisionExtras
+					}
+				});
+				break;
+			}
 			case "commentOnBlock":
 				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				break;
@@ -894,10 +1405,17 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			...suggestionId !== null && { suggestionId }
 		});
 	}
-	if (tr.docChanged) view.dispatch(tr);
+	if (tr.docChanged) {
+		const batchRevisionIds = new Set(applied.flatMap(({ revisionIds }) => revisionIds ?? []));
+		tr = withoutRevisionsOnZeroWidthAnchors(tr, batchRevisionIds);
+		if (revisionStamp) requestDeterministicParaIds(tr, `${revisionStamp.date}:${String(revisionStamp.idSeed)}`);
+		view.dispatch(tr);
+	}
 	return {
 		applied,
-		skipped
+		skipped,
+		...normalizations.length > 0 && { normalizations },
+		nextRevisionId: revisionSeed
 	};
 };
 const applyFolioAIEditOperations = (options) => applyFolioAIEditOperationsInternal(options);
@@ -918,10 +1436,12 @@ const previewFolioAIEditOperations = (options) => {
 	});
 	return {
 		applied: result.applied.map(({ id }) => ({ id })),
-		skipped: result.skipped
+		skipped: result.skipped,
+		...result.normalizations !== void 0 && { normalizations: result.normalizations },
+		nextRevisionId: options.revisionStamp?.idSeed ?? revisionIdCursor
 	};
 };
-const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials }) => {
+const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials, granularity }) => {
 	let nextTr = tr;
 	const replacement = stripInlineEmphasisMarkers((() => {
 		if (item.operation.type === "replaceInBlock" || item.operation.type === "replaceRange") return item.operation.replace;
@@ -975,7 +1495,7 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 		}
 	}
 	if (sourceText !== null && cleanBlock !== null) {
-		const segments = diffWordSegments(sourceText, replacement);
+		const segments = diffWordSegments(sourceText, replacement, { granularity });
 		const offsets = cleanBlock.offsets;
 		const offsetAt = (cleanOffset) => offsets[cleanOffset] ?? null;
 		const steps = [];
@@ -1126,15 +1646,12 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		};
 	}
 	if (operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock") {
-		if (operation.text.length === 0 && operation.pageBreakBefore !== true) return {
-			type: "skip",
-			reason: "emptyOperation"
-		};
-		const tableBoundary = findEnclosingTableBoundary(doc, blockFrom);
+		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
 		const isInsertAfter = operation.type === "insertAfterBlock";
 		let insertFrom;
 		if (tableBoundary) insertFrom = isInsertAfter ? tableBoundary.after : tableBoundary.before;
 		else insertFrom = isInsertAfter ? blockTo : blockFrom;
+		const insertTexts = LINE_BREAK_PATTERN.test(operation.text) ? splitInsertParagraphTexts(operation.text) : [operation.text];
 		return {
 			type: "resolved",
 			operation: {
@@ -1144,7 +1661,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 				blockFrom,
 				blockTo,
 				blockNode,
-				insertText: operation.text
+				insertTexts
 			}
 		};
 	}
@@ -1154,7 +1671,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			reason: "emptyOperation"
 		};
 		const position = operation.position ?? "after";
-		const tableBoundary = findEnclosingTableBoundary(doc, blockFrom);
+		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
 		let insertFrom;
 		if (tableBoundary) insertFrom = position === "after" ? tableBoundary.after : tableBoundary.before;
 		else insertFrom = position === "after" ? blockTo : blockFrom;
@@ -1176,7 +1693,7 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			blockFrom,
 			position: operation.position ?? "after"
 		});
-		if (!insertion || (operation.cellTexts?.length ?? 0) > insertion.cells.length) return {
+		if (!insertion || (operation.cellTexts?.length ?? 0) > insertion.columnCount) return {
 			type: "skip",
 			reason: "unsupportedBlock"
 		};
@@ -1371,11 +1888,115 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			}
 		};
 	}
+	if (operation.type === "insertTable") {
+		const boundary = findOutermostTableBoundary(doc, blockFrom) ?? {
+			before: blockFrom,
+			after: blockTo
+		};
+		const insertFrom = (operation.position ?? "after") === "after" ? boundary.after : boundary.before;
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: insertFrom,
+				to: insertFrom,
+				blockFrom,
+				blockTo,
+				blockNode
+			}
+		};
+	}
+	if (operation.type === "deleteTable") {
+		const target = findEnclosingTableRow(doc, blockFrom);
+		if (!target) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: target.tablePosition,
+				to: target.tablePosition + target.table.nodeSize,
+				blockFrom,
+				blockTo,
+				blockNode,
+				deletedTable: {
+					position: target.tablePosition,
+					node: target.table
+				}
+			}
+		};
+	}
+	if (operation.type === "setBlockParagraphProperties") return {
+		type: "resolved",
+		operation: {
+			operation,
+			from: blockFrom,
+			to: blockTo,
+			blockFrom,
+			blockTo,
+			blockNode
+		}
+	};
+	if (operation.type === "splitBlock") {
+		const separator = operation.separator ?? "";
+		const at = cleanBlock.offsets[operation.offset];
+		const after = cleanBlock.offsets[operation.offset + separator.length];
+		if (at === void 0 || after === void 0 || operation.offset === 0 || operation.offset + separator.length >= currentText.length) return {
+			type: "skip",
+			reason: "staleRange"
+		};
+		if (currentText.slice(operation.offset, operation.offset + separator.length) !== separator) return {
+			type: "skip",
+			reason: "staleRange"
+		};
+		if (!canSplit(doc, at)) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: at,
+				to: after,
+				blockFrom,
+				blockTo,
+				blockNode
+			}
+		};
+	}
+	if (operation.type === "mergeBlockWithNext") {
+		if (!canJoin(doc, blockTo)) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: blockTo,
+				to: blockTo,
+				blockFrom,
+				blockTo,
+				blockNode
+			}
+		};
+	}
 	if (operation.type === "deleteBlock" || operation.type === "replaceBlock") {
 		const range = getTextRangeFromCleanBlock(cleanBlock);
 		if (!range) {
 			const insertionPoint = cleanBlock.offsets.at(0);
-			if (operation.type === "replaceBlock" && currentText.length === 0 && operation.text.length > 0 && insertionPoint !== void 0) return {
+			if (insertionPoint === void 0) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			if (!(operation.type === "deleteBlock" ? true : currentText.length === 0 && operation.text.length > 0)) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			return {
 				type: "resolved",
 				operation: {
 					operation,
@@ -1386,10 +2007,6 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 					blockNode
 				}
 			};
-			return {
-				type: "skip",
-				reason: "unsupportedBlock"
-			};
 		}
 		if (operation.type === "replaceBlock" && operation.text === currentText) return {
 			type: "skip",