@stll/folio-core 0.11.0 → 0.13.0

package/dist/ai-edits/apply.js

@@ -1,27 +1,38 @@
+import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.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 { planTableMutations } from "./table-mutation-plan.js";
+import { findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell } from "./table-targets.js";
+import { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
+import { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey } from "./table-row-column-mutations.js";
 import { diffWordSegments } from "./word-diff.js";
+import { TableMap } from "prosemirror-tables";
 //#region src/ai-edits/apply.ts
 /**
-* Block attrs that identify a block instance (Word's
-* `w14:paraId` / `w14:textId`, future tracked-change identifiers).
-* Reuse during inheritFormatting would create duplicate IDs, so
-* we strip them when synthesising a sibling.
+* Operation types applied in `"suggested"` mode. Every produced revision — an
+* inline mark, a whole-node `_suggestedInsert` marker, or a suggested
+* `trIns`/`trDel`/`cellMarker` — is stripped from serialized DOCX until
+* accepted. Cell merge/split (not row/column ops) and comment ops stay
+* `unsupportedMode`.
 */
-const IDENTITY_BLOCK_ATTRS = /* @__PURE__ */ new Set(["paraId", "textId"]);
-const stripIdentityAttrs = (attrs) => {
-	const next = {};
-	for (const [key, value] of Object.entries(attrs)) {
-		if (IDENTITY_BLOCK_ATTRS.has(key)) {
-			next[key] = null;
-			continue;
-		}
-		next[key] = value;
-	}
-	return next;
-};
+const SUGGESTED_SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
+	"replaceInBlock",
+	"replaceRange",
+	"formatRange",
+	"replaceBlock",
+	"deleteBlock",
+	"insertAfterBlock",
+	"insertBeforeBlock",
+	"insertSignatureTable",
+	"insertTableRow",
+	"deleteTableRow",
+	"insertTableColumn",
+	"deleteTableColumn"
+]);
 const applyReplaceBlockStyleId = ({ item, tr }) => {
 	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return tr;
 	const block = tr.doc.nodeAt(item.blockFrom);
@@ -31,6 +42,69 @@ const applyReplaceBlockStyleId = ({ item, tr }) => {
 		styleId: item.operation.styleId
 	});
 };
+const applyInlineFormatting = ({ tr, schema, from, to, formatting }) => {
+	for (const [name, enabled] of Object.entries(formatting)) {
+		const markType = schema.marks[name];
+		if (!markType) continue;
+		if (enabled) {
+			tr.addMark(from, to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
+			continue;
+		}
+		tr.removeMark(from, to, markType);
+	}
+	return tr;
+};
+const formattingWouldChange = (marks, formatting) => Object.entries(formatting).some(([name, enabled]) => {
+	const mark = marks.find((candidate) => candidate.type.name === name);
+	if (!enabled) return mark !== void 0;
+	if (name === "underline") return mark?.attrs["style"] !== "single";
+	return mark === void 0;
+});
+const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, revisionId, author, date, initials, suggestionId = null }) => {
+	const propertyChangeType = schema.marks["runPropertyChange"];
+	if (!propertyChangeType) return tr;
+	const segments = [];
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isText || !formattingWouldChange(node.marks, formatting)) return;
+		const segmentFrom = Math.max(from, pos);
+		const segmentTo = Math.min(to, pos + node.nodeSize);
+		const previousFormatting = marksToTextFormatting(node.marks);
+		const existingMark = node.marks.find((mark) => mark.type === propertyChangeType);
+		const existingChanges = existingMark ? expectRunPropertyChangeMarkAttrs(existingMark).changes : [];
+		const change = {
+			type: "runPropertyChange",
+			info: {
+				id: revisionId,
+				author,
+				date,
+				...initials ? { initials } : {}
+			},
+			...Object.keys(previousFormatting).length > 0 ? { previousFormatting } : {}
+		};
+		segments.push({
+			from: segmentFrom,
+			to: segmentTo,
+			changes: [...existingChanges, change]
+		});
+	});
+	if (segments.length === 0) return tr;
+	const suggestionAttrs = suggestionId === null ? {} : {
+		provenance: "suggested",
+		suggestionId
+	};
+	applyInlineFormatting({
+		tr,
+		schema,
+		from,
+		to,
+		formatting
+	});
+	for (const segment of segments) tr.addMark(segment.from, segment.to, propertyChangeType.create({
+		changes: segment.changes,
+		...suggestionAttrs
+	}));
+	return tr;
+};
 /**
 * Module-scoped monotonic counter for tracked-change revision ids.
 * Seeded once from `Date.now()` so ids are roughly time-ordered for
@@ -93,13 +167,21 @@ const collectLiveBlocksByParaId = (doc) => {
 	});
 	return byParaId;
 };
-const findEnclosingTableBoundary = (doc, blockFrom) => {
-	const resolved = doc.resolve(blockFrom);
-	for (let depth = resolved.depth; depth > 0; depth--) if (resolved.node(depth).type.name === "table") return {
-		before: resolved.before(depth),
-		after: resolved.after(depth)
+const getTableMutationPlanTarget = (item) => {
+	if (item.tableCellMerge) return {
+		type: "mergeCells",
+		...item.tableCellMerge
 	};
-	return null;
+	if (item.tableCellSplit) return {
+		type: "splitCell",
+		...item.tableCellSplit
+	};
+	const tablePosition = item.tableRowInsertion?.tableStart !== void 0 ? item.tableRowInsertion.tableStart - 1 : item.tableRowDeletion?.tablePosition ?? item.tableColumnInsertion?.tablePosition ?? item.tableColumnDeletion?.tablePosition;
+	if (tablePosition !== void 0) return {
+		type: "tableStructure",
+		tablePosition
+	};
+	return { type: "none" };
 };
 /**
 * The snapshot recorded an `hashOccurrenceCount` per anchor but
@@ -193,14 +275,18 @@ const buildEmphasisInlineContent = (schema, text, baseMarks) => {
 	}
 	return nodes.length > 0 ? nodes : [schema.text(text, [...baseMarks])];
 };
-const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", createCommentId, revisionIdSeed }) => {
+const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionIdSeed }) => {
 	const applied = [];
 	const skipped = [];
 	const resolved = [];
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	const commentType = view.state.schema.marks["comment"];
-	if (mode === "tracked-changes" && (!insertionType || !deletionType)) return {
+	const claimedTableRows = /* @__PURE__ */ new Set();
+	const claimedTableColumns = /* @__PURE__ */ new Set();
+	const producesTrackedChanges = mode !== "direct";
+	const isSuggested = mode === "suggested";
+	if (producesTrackedChanges && (!insertionType || !deletionType)) return {
 		applied,
 		skipped: operations.map((operation) => ({
 			id: operation.id,
@@ -210,13 +296,6 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	const liveBlocks = collectLiveBlocksByHash(view.state.doc);
 	const liveBlocksByParaId = collectLiveBlocksByParaId(view.state.doc);
 	for (const [index, operation] of operations.entries()) {
-		if (mode === "tracked-changes" && operation.type === "formatRange") {
-			skipped.push({
-				id: operation.id,
-				reason: "unsupportedMode"
-			});
-			continue;
-		}
 		const commentText = getOperationCommentText(operation);
 		if (commentText !== void 0 && (!commentType || createCommentId === void 0)) {
 			skipped.push({
@@ -239,6 +318,30 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			});
 			continue;
 		}
+		const deletion = resolution.operation.tableRowDeletion;
+		if (deletion) {
+			const rowKey = `${deletion.tablePosition}:${deletion.rowIndex}`;
+			if (claimedTableRows.has(rowKey)) {
+				skipped.push({
+					id: operation.id,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			claimedTableRows.add(rowKey);
+		}
+		const columnDeletion = resolution.operation.tableColumnDeletion;
+		if (columnDeletion) {
+			const columnKey = getTableColumnCoordinateKey(columnDeletion);
+			if (claimedTableColumns.has(columnKey)) {
+				skipped.push({
+					id: operation.id,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			claimedTableColumns.add(columnKey);
+		}
 		const commentId = commentText !== void 0 ? createCommentId?.(commentText) : void 0;
 		resolved.push({
 			...resolution.operation,
@@ -246,20 +349,70 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			...commentId !== void 0 && { commentId }
 		});
 	}
-	if (resolved.length === 0) return {
+	const tablePlan = planTableMutations(resolved.map((item) => ({
+		item,
+		operationId: item.operation.id,
+		target: getTableMutationPlanTarget(item)
+	})));
+	skipped.push(...tablePlan.skipped);
+	const executableResolved = tablePlan.executable;
+	if (executableResolved.length === 0) return {
 		applied,
 		skipped
 	};
 	let tr = view.state.tr;
-	let revisionSeed = revisionIdSeed ?? nextRevisionSeed(resolved.length);
+	let revisionSeed = revisionIdSeed ?? nextRevisionSeed(executableResolved.length);
 	const date = (/* @__PURE__ */ new Date()).toISOString();
-	for (const item of resolved.toSorted((left, right) => {
+	const insertedColumnCounts = /* @__PURE__ */ new Map();
+	for (const item of executableResolved.toSorted((left, right) => {
+		const leftCellShape = left.tableCellMerge ?? left.tableCellSplit;
+		const rightCellShape = right.tableCellMerge ?? right.tableCellSplit;
+		if (!leftCellShape && rightCellShape) return -1;
+		if (leftCellShape && !rightCellShape) return 1;
+		if (leftCellShape && rightCellShape) {
+			if (leftCellShape.tablePosition !== rightCellShape.tablePosition) return rightCellShape.tablePosition - leftCellShape.tablePosition;
+			if (leftCellShape.rectangle.bottom !== rightCellShape.rectangle.bottom) return rightCellShape.rectangle.bottom - leftCellShape.rectangle.bottom;
+			if (leftCellShape.rectangle.right !== rightCellShape.rectangle.right) return rightCellShape.rectangle.right - leftCellShape.rectangle.right;
+			return right.originalIndex - left.originalIndex;
+		}
+		const leftColumn = left.tableColumnInsertion ?? left.tableColumnDeletion;
+		const rightColumn = right.tableColumnInsertion ?? right.tableColumnDeletion;
+		if (!leftColumn && rightColumn) return -1;
+		if (leftColumn && !rightColumn) return 1;
+		if (leftColumn && rightColumn) {
+			if (leftColumn.tablePosition !== rightColumn.tablePosition) return rightColumn.tablePosition - leftColumn.tablePosition;
+			if (leftColumn.columnIndex !== rightColumn.columnIndex) return rightColumn.columnIndex - leftColumn.columnIndex;
+			const leftIsInsertion = left.tableColumnInsertion !== void 0;
+			if (leftIsInsertion !== (right.tableColumnInsertion !== void 0)) return leftIsInsertion ? -1 : 1;
+			return right.originalIndex - left.originalIndex;
+		}
 		if (left.from !== right.from) return right.from - left.from;
 		return right.originalIndex - left.originalIndex;
 	})) {
 		const commentMark = item.commentId !== void 0 && commentType ? commentType.create({ commentId: item.commentId }) : null;
 		const stepsBefore = tr.steps.length;
 		let appliedRevisionIds;
+		if (isSuggested && !SUGGESTED_SUPPORTED_OPERATION_TYPES.has(item.operation.type)) {
+			skipped.push({
+				id: item.operation.id,
+				reason: "unsupportedMode"
+			});
+			continue;
+		}
+		const suggestionId = isSuggested ? item.operation.suggestionId ?? item.operation.id : null;
+		const trackedRevisionExtras = {
+			...initials ? { initials } : {},
+			...suggestionId !== null ? {
+				provenance: "suggested",
+				suggestionId
+			} : {}
+		};
+		const structuralRevision = producesTrackedChanges ? {
+			revisionId: revisionSeed,
+			author,
+			date,
+			...trackedRevisionExtras
+		} : null;
 		switch (item.operation.type) {
 			case "replaceInBlock":
 			case "replaceRange": {
@@ -273,21 +426,42 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					date,
 					revisionIdDelete,
 					revisionIdInsert,
-					commentMark
+					commentMark,
+					suggestionId,
+					initials
 				});
-				if (mode === "tracked-changes") appliedRevisionIds = [revisionIdDelete, revisionIdInsert];
+				if (producesTrackedChanges) appliedRevisionIds = [revisionIdDelete, revisionIdInsert];
 				break;
 			}
 			case "commentOnRange":
 				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				break;
 			case "formatRange":
-				for (const [name, enabled] of Object.entries(item.operation.formatting)) {
-					const markType = view.state.schema.marks[name];
-					if (!markType) continue;
-					if (enabled) tr = tr.addMark(item.from, item.to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
-					else tr = tr.removeMark(item.from, item.to, markType);
+				if (producesTrackedChanges) {
+					const revisionId = revisionSeed++;
+					tr = applyTrackedInlineFormatting({
+						tr,
+						schema: view.state.schema,
+						doc: tr.doc,
+						from: item.from,
+						to: item.to,
+						formatting: item.operation.formatting,
+						revisionId,
+						author,
+						date,
+						initials,
+						suggestionId
+					});
+					appliedRevisionIds = [revisionId];
+					break;
 				}
+				tr = applyInlineFormatting({
+					tr,
+					schema: view.state.schema,
+					from: item.from,
+					to: item.to,
+					formatting: item.operation.formatting
+				});
 				break;
 			case "replaceBlock": {
 				const revisionIdDelete = revisionSeed++;
@@ -319,13 +493,15 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					date,
 					revisionIdDelete,
 					revisionIdInsert,
-					commentMark
+					commentMark,
+					suggestionId,
+					initials
 				});
 				tr = applyReplaceBlockStyleId({
 					item,
 					tr
 				});
-				if (mode === "tracked-changes") appliedRevisionIds = [revisionIdDelete, revisionIdInsert];
+				if (producesTrackedChanges) appliedRevisionIds = [revisionIdDelete, revisionIdInsert];
 				break;
 			}
 			case "insertAfterBlock":
@@ -338,18 +514,21 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					continue;
 				}
 				const marks = [];
-				if (mode === "tracked-changes" && insertionType) {
+				let insertedBlockRevisionId = null;
+				if (producesTrackedChanges && insertionType) {
 					const revisionId = revisionSeed++;
+					insertedBlockRevisionId = revisionId;
 					marks.push(insertionType.create({
 						revisionId,
 						author,
-						date
+						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 ? {} : stripIdentityAttrs(item.blockNode.attrs) };
+				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;
@@ -362,6 +541,13 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 						attrs["listStartOverride"] = null;
 					}
 				}
+				if (isSuggested && suggestionId !== null && insertedBlockRevisionId !== null) attrs["_suggestedInsert"] = {
+					suggestionId,
+					revisionId: insertedBlockRevisionId,
+					author,
+					date,
+					...initials ? { initials } : {}
+				};
 				const node = item.blockNode.type.create(attrs, content);
 				tr = tr.insert(item.from, node);
 				break;
@@ -374,20 +560,236 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					});
 					continue;
 				}
-				const node = buildSignatureTableNode({
+				const signatureTable = buildSignatureTableNode({
 					schema: view.state.schema,
 					parties: item.operation.parties
 				});
-				if (!node) {
+				if (!signatureTable) {
 					skipped.push({
 						id: item.operation.id,
 						reason: "unsupportedBlock"
 					});
 					continue;
 				}
+				let node = signatureTable;
+				if (isSuggested && suggestionId !== null) {
+					const revisionId = revisionSeed++;
+					node = signatureTable.type.create({
+						...signatureTable.attrs,
+						_suggestedInsert: {
+							suggestionId,
+							revisionId,
+							author,
+							date,
+							...initials ? { initials } : {}
+						}
+					}, signatureTable.content, signatureTable.marks);
+					appliedRevisionIds = [revisionId];
+				}
 				tr = tr.insert(item.from, node);
 				break;
 			}
+			case "insertTableRow": {
+				const insertion = item.tableRowInsertion;
+				if (!insertion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revision = structuralRevision;
+				const result = applyTableRowInsertion({
+					tr,
+					insertion,
+					cellTexts: item.operation.cellTexts,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
+			case "insertTableColumn": {
+				const insertion = item.tableColumnInsertion;
+				if (!insertion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revision = structuralRevision;
+				const result = applyTableColumnInsertion({
+					tr,
+					insertion,
+					cellTexts: item.operation.cellTexts,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				const columnKey = getTableColumnCoordinateKey(insertion);
+				insertedColumnCounts.set(columnKey, (insertedColumnCounts.get(columnKey) ?? 0) + 1);
+				break;
+			}
+			case "deleteTableColumn": {
+				const deletion = item.tableColumnDeletion;
+				if (!deletion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const columnKey = getTableColumnCoordinateKey(deletion);
+				const revision = structuralRevision;
+				const result = applyTableColumnDeletion({
+					tr,
+					deletion,
+					insertedColumnCount: insertedColumnCounts.get(columnKey) ?? 0,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
+			case "mergeTableCells": {
+				const merge = item.tableCellMerge;
+				const tablePosition = merge ? tr.mapping.map(merge.tablePosition, 1) : null;
+				const table = tablePosition === null ? null : tr.doc.nodeAt(tablePosition);
+				if (!merge || tablePosition === null || !table || table.type.spec["tableRole"] !== "table") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const nextTr = revisionId === null ? mergeTableRectangle({
+					tr,
+					tablePosition,
+					table,
+					rectangle: merge.rectangle
+				}) : mergeTrackedVerticalTableCells({
+					tr,
+					tablePosition,
+					table,
+					rectangle: merge.rectangle,
+					revisionId,
+					author,
+					date
+				});
+				if (!nextTr) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = nextTr;
+				if (revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [revisionId];
+				}
+				break;
+			}
+			case "splitTableCell": {
+				const split = item.tableCellSplit;
+				const tablePosition = split ? tr.mapping.map(split.tablePosition, 1) : null;
+				const table = tablePosition === null ? null : tr.doc.nodeAt(tablePosition);
+				if (!split || tablePosition === null || !table || table.type.spec["tableRole"] !== "table") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const nextTr = revisionId === null ? splitTableRectangle({
+					tr,
+					tablePosition,
+					table,
+					rectangle: split.rectangle
+				}) : splitTrackedVerticalTableCell({
+					tr,
+					tablePosition,
+					table,
+					rectangle: split.rectangle,
+					revisionId,
+					author,
+					date
+				});
+				if (!nextTr) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = nextTr;
+				if (revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [revisionId];
+				}
+				break;
+			}
+			case "deleteTableRow": {
+				const deletion = item.tableRowDeletion;
+				if (!deletion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const result = applyTableRowDeletion({
+					tr,
+					deletion,
+					revision: structuralRevision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
 			case "deleteBlock":
 				if (mode === "direct") {
 					tr = tr.delete(item.blockFrom, item.blockTo);
@@ -398,7 +800,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					tr = tr.addMark(item.from, item.to, deletionType.create({
 						revisionId,
 						author,
-						date
+						date,
+						...trackedRevisionExtras
 					}));
 					appliedRevisionIds = [revisionId];
 				}
@@ -422,7 +825,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			...appliedRevisionIds !== void 0 && appliedRevisionIds[0] !== void 0 && {
 				revisionId: appliedRevisionIds[0],
 				revisionIds: appliedRevisionIds
-			}
+			},
+			...suggestionId !== null && { suggestionId }
 		});
 	}
 	if (tr.docChanged) view.dispatch(tr);
@@ -452,7 +856,7 @@ const previewFolioAIEditOperations = (options) => {
 		skipped: result.skipped
 	};
 };
-const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark }) => {
+const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials }) => {
 	let nextTr = tr;
 	const replacement = stripInlineEmphasisMarkers((() => {
 		if (item.operation.type === "replaceInBlock" || item.operation.type === "replaceRange") return item.operation.replace;
@@ -470,15 +874,24 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 	}
 	const insertionType = nextTr.doc.type.schema.marks["insertion"];
 	const deletionType = nextTr.doc.type.schema.marks["deletion"];
+	const suggestionAttrs = suggestionId === null ? {} : {
+		provenance: "suggested",
+		suggestionId
+	};
+	const initialsAttr = initials ? { initials } : {};
 	const delAttrs = {
 		revisionId: revisionIdDelete,
 		author,
-		date
+		date,
+		...initialsAttr,
+		...suggestionAttrs
 	};
 	const insAttrs = {
 		revisionId: revisionIdInsert,
 		author,
-		date
+		date,
+		...initialsAttr,
+		...suggestionAttrs
 	};
 	const cleanBlock = item.blockNode.content.size === item.blockNode.textContent.length ? buildCleanBlockText(item.blockNode, item.blockFrom) : null;
 	let sourceText = null;
@@ -561,8 +974,7 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 	}
 	return nextTr;
 };
-const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, doc }) => {
-	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
+const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId }) => {
 	const anchor = snapshot.anchors[blockId];
 	if (!anchor) return {
 		type: "skip",
@@ -588,20 +1000,37 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		type: "skip",
 		reason: "changedBlock"
 	};
-	const blockNode = live.node;
-	const blockFrom = live.from;
-	const blockTo = live.to;
-	const cleanBlock = buildCleanBlockText(blockNode, blockFrom);
+	const cleanBlock = buildCleanBlockText(live.node, live.from);
 	const currentText = cleanBlock.text;
 	const currentTextHash = hashFolioAIBlockText(normalizeFolioAIBlockText(currentText));
-	if (operation.precondition !== void 0 && currentTextHash !== operation.precondition.blockTextHash) return {
-		type: "skip",
-		reason: "preconditionFailed"
-	};
 	if (currentTextHash !== anchor.textHash) return {
 		type: "skip",
 		reason: "changedBlock"
 	};
+	return {
+		type: "resolved",
+		blockNode: live.node,
+		blockFrom: live.from,
+		blockTo: live.to,
+		cleanBlock,
+		currentText,
+		currentTextHash
+	};
+};
+const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, doc }) => {
+	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
+	const primaryBlock = resolveStableBlock({
+		snapshot,
+		blockId,
+		liveBlocks,
+		liveBlocksByParaId
+	});
+	if (primaryBlock.type === "skip") return primaryBlock;
+	const { blockNode, blockFrom, blockTo, cleanBlock, currentText, currentTextHash } = primaryBlock;
+	if (operation.precondition !== void 0 && currentTextHash !== operation.precondition.blockTextHash) return {
+		type: "skip",
+		reason: "preconditionFailed"
+	};
 	if (operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange") {
 		const { startOffset, endOffset, selectedTextHash } = operation.range;
 		const from = cleanBlock.offsets[startOffset];
@@ -676,6 +1105,207 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			}
 		};
 	}
+	if (operation.type === "insertTableRow") {
+		const insertion = findTableRowInsertion({
+			doc,
+			blockFrom,
+			position: operation.position ?? "after"
+		});
+		if (!insertion || (operation.cellTexts?.length ?? 0) > insertion.cells.length) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: insertion.rowPosition,
+				to: insertion.rowPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableRowInsertion: insertion
+			}
+		};
+	}
+	if (operation.type === "deleteTableRow") {
+		const target = findEnclosingTableRow(doc, blockFrom);
+		if (!target) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: target.rowPosition,
+				to: target.rowPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableRowDeletion: {
+					tableStart: target.tableStart,
+					tablePosition: target.tablePosition,
+					rowIndex: target.rowIndex,
+					rowPosition: target.rowPosition
+				}
+			}
+		};
+	}
+	if (operation.type === "insertTableColumn") {
+		const insertion = findTableColumnInsertion({
+			doc,
+			blockFrom,
+			position: operation.position ?? "after"
+		});
+		if (!insertion) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const { boundaryPosition, ...tableColumnInsertion } = insertion;
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: boundaryPosition,
+				to: boundaryPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableColumnInsertion
+			}
+		};
+	}
+	if (operation.type === "deleteTableColumn") {
+		const target = findEnclosingTableCell(doc, blockFrom);
+		if (!target) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: target.cellPosition,
+				to: target.cellPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableColumnDeletion: {
+					tablePosition: target.tablePosition,
+					columnIndex: target.leftColumnIndex
+				}
+			}
+		};
+	}
+	if (operation.type === "mergeTableCells") {
+		const startCell = findEnclosingTableCell(doc, blockFrom);
+		if (!startCell) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const table = doc.nodeAt(startCell.tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table") return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const map = TableMap.get(table);
+		let rectangle;
+		let endCellPosition;
+		let endCellEndPosition;
+		if (operation.rowCount !== void 0) {
+			rectangle = {
+				left: startCell.leftColumnIndex,
+				top: startCell.topRowIndex,
+				right: startCell.rightColumnIndex,
+				bottom: startCell.topRowIndex + operation.rowCount
+			};
+			if (rectangle.right - rectangle.left !== 1 || rectangle.bottom > map.height || operation.rowCount < 2) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			const endRelativePosition = map.map[(rectangle.bottom - 1) * map.width + rectangle.left];
+			const endCell = endRelativePosition === void 0 ? null : table.nodeAt(endRelativePosition);
+			if (!endCell || endRelativePosition === void 0) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			endCellPosition = startCell.tablePosition + 1 + endRelativePosition;
+			endCellEndPosition = endCellPosition + endCell.nodeSize;
+		} else {
+			const endTarget = resolveStableBlock({
+				snapshot,
+				blockId: operation.endBlockId,
+				liveBlocks,
+				liveBlocksByParaId
+			});
+			if (endTarget.type === "skip") return endTarget;
+			const endCell = findEnclosingTableCell(doc, endTarget.blockFrom);
+			if (!endCell || startCell.tablePosition !== endCell.tablePosition) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			rectangle = {
+				left: Math.min(startCell.leftColumnIndex, endCell.leftColumnIndex),
+				top: Math.min(startCell.topRowIndex, endCell.topRowIndex),
+				right: Math.max(startCell.rightColumnIndex, endCell.rightColumnIndex),
+				bottom: Math.max(startCell.bottomRowIndex, endCell.bottomRowIndex)
+			};
+			endCellPosition = endCell.cellPosition;
+			endCellEndPosition = endCell.cellEndPosition;
+		}
+		if (rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1 || tableRectangleCutsMergedCell(map, rectangle)) return {
+			type: "skip",
+			reason: rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1 ? "noopOperation" : "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: Math.min(startCell.cellPosition, endCellPosition),
+				to: Math.max(startCell.cellEndPosition, endCellEndPosition),
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableCellMerge: {
+					tablePosition: startCell.tablePosition,
+					rectangle
+				}
+			}
+		};
+	}
+	if (operation.type === "splitTableCell") {
+		const cell = findEnclosingTableCell(doc, blockFrom);
+		if (!cell) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const rectangle = {
+			left: cell.leftColumnIndex,
+			top: cell.topRowIndex,
+			right: cell.rightColumnIndex,
+			bottom: cell.bottomRowIndex
+		};
+		if (rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1) return {
+			type: "skip",
+			reason: "noopOperation"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: cell.cellPosition,
+				to: cell.cellEndPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableCellSplit: {
+					tablePosition: cell.tablePosition,
+					rectangle
+				}
+			}
+		};
+	}
 	if (operation.type === "deleteBlock" || operation.type === "replaceBlock") {
 		const range = getTextRangeFromCleanBlock(cleanBlock);
 		if (!range) {