@stll/folio-core 0.11.0 → 0.13.0

package/dist/prosemirror/commands/comments.js

@@ -1,4 +1,11 @@
+import { expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
+import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { textFormattingToMarks } from "../conversion/toProseDoc.js";
+import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
+import { TableMap, removeRow } from "prosemirror-tables";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -36,18 +43,18 @@ function removeCommentMark(commentId) {
 * Resolve a tracked change: accept or reject.
 * - Accept: keep insertions (remove mark), delete deletions (remove text)
 * - Reject: keep deletions (remove mark), delete insertions (remove text)
+* - Run formatting: accept the current formatting, or restore the previous formatting
 *
 * Pass `revisionId` to scope the operation to one specific
 * revision — otherwise overlapping marks for other revisions get
 * processed too, silently consuming pending work. Without an id
-* the operation matches every insertion/deletion mark in the
+* the operation matches every revision mark or property-change entry in the
 * range (the bulk accept-all/reject-all path).
 */
 function resolveChange(from, to, mode, revisionIds) {
 	return (state, dispatch) => {
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
-		if (!insertionType && !deletionType) return false;
 		const keepType = mode === "accept" ? insertionType : deletionType;
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
@@ -56,6 +63,8 @@ function resolveChange(from, to, mode, revisionIds) {
 			const tr = state.tr;
 			const deleteRanges = [];
 			const pPrMarkOps = [];
+			const tableRowStructuralOps = [];
+			const tableCellStructuralOps = [];
 			state.doc.nodesBetween(from, to, (node, pos) => {
 				if (node.type.name === "paragraph") {
 					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
@@ -95,6 +104,11 @@ function resolveChange(from, to, mode, revisionIds) {
 					if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
 					return true;
 				}
+				if (node.type.name === "tableRow" && rangeCoversNode(from, to, pos, node)) {
+					const op = collectTableRowStructuralOp(node, pos, mode, revisionSet);
+					if (op) tableRowStructuralOps.push(op);
+				}
+				if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && rangeCoversNode(from, to, pos, node)) tableCellStructuralOps.push(...collectTableCellStructuralOps(node, pos, mode, revisionSet));
 				const tableChangeAttrName = TABLE_PROPERTY_CHANGE_ATTR_BY_NODE[node.type.name];
 				if (tableChangeAttrName !== void 0) {
 					if (rangeCoversNode(from, to, pos, node)) {
@@ -107,6 +121,16 @@ function resolveChange(from, to, mode, revisionIds) {
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
+				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
+				if (runPropertyChangeMark) resolveRunPropertyChange({
+					tr,
+					node,
+					from: rangeFrom,
+					to: rangeTo,
+					mark: runPropertyChangeMark,
+					mode,
+					revisionSet
+				});
 				if (removeType && node.marks.some((m) => m.type === removeType && matchesRevision(m))) deleteRanges.push({
 					from: rangeFrom,
 					to: rangeTo
@@ -131,11 +155,162 @@ function resolveChange(from, to, mode, revisionIds) {
 					tr.setNodeAttribute(mappedPos, "pPrMark", null);
 				} catch {}
 			}
+			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
+			let resolvedTableRowStructure = false;
+			for (const op of tableRowStructuralOps) {
+				const mappedPos = tr.mapping.map(op.rowPos);
+				const row = tr.doc.nodeAt(mappedPos);
+				if (!row || row.type.name !== "tableRow") continue;
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, op.attrName, null);
+					resolvedTableRowStructure = true;
+					continue;
+				}
+				deleteTableRowAt(tr, mappedPos);
+				resolvedTableRowStructure = true;
+			}
+			if (resolvedTableRowStructure) markStructuralChange(tr);
+			tableCellStructuralOps.sort((left, right) => right.cellPos - left.cellPos);
+			let resolvedTableCellStructure = false;
+			let failedTableCellMergeResolution = false;
+			for (const op of tableCellStructuralOps) {
+				const mappedPos = tr.mapping.map(op.cellPos);
+				const cell = tr.doc.nodeAt(mappedPos);
+				if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") continue;
+				if (op.type === "merge") {
+					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge(tr, mappedPos, op.mode);
+					if (!resolved) {
+						failedTableCellMergeResolution = true;
+						break;
+					}
+					resolvedTableCellStructure ||= resolved;
+					continue;
+				}
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, "cellMarker", null);
+					resolvedTableCellStructure = true;
+					continue;
+				}
+				deleteTableCellAt(tr, mappedPos);
+				resolvedTableCellStructure = true;
+			}
+			if (failedTableCellMergeResolution) return false;
+			if (resolvedTableCellStructure) markStructuralChange(tr);
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
 	};
 }
+const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet }) => {
+	const { changes } = expectRunPropertyChangeMarkAttrs(mark);
+	const matches = changes.filter((change) => revisionSet === null || revisionSet.has(change.info.id));
+	if (matches.length === 0) return;
+	tr.removeMark(from, to, mark);
+	const remaining = changes.filter((change) => revisionSet !== null && !revisionSet.has(change.info.id));
+	if (remaining.length > 0) tr.addMark(from, to, mark.type.create({ changes: remaining }));
+	if (mode === "accept") return;
+	const previousFormatting = matches.at(0)?.previousFormatting;
+	for (const currentMark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(currentMark.type.name)) tr.removeMark(from, to, currentMark.type);
+	for (const previousMark of textFormattingToMarks(previousFormatting)) tr.addMark(from, to, previousMark);
+	if (previousFormatting?.styleId) {
+		const characterStyle = node.type.schema.marks["characterStyle"];
+		if (characterStyle) tr.addMark(from, to, characterStyle.create({
+			styleId: previousFormatting.styleId,
+			_styleRPr: null
+		}));
+	}
+};
+function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
+	for (const attrName of ["trIns", "trDel"]) {
+		const marker = node.attrs[attrName];
+		if (!isTableRowRevisionAttr(marker)) continue;
+		if (revisionSet !== null && !revisionSet.has(marker.revisionId)) continue;
+		return {
+			rowPos,
+			attrName,
+			action: attrName === "trIns" === (mode === "accept") ? "clear" : "remove"
+		};
+	}
+	return null;
+}
+function isTableRowRevisionAttr(value) {
+	return typeof value === "object" && value !== null && "revisionId" in value && typeof value.revisionId === "number";
+}
+function collectTableCellStructuralOps(node, cellPos, mode, revisionSet) {
+	const operations = [];
+	const marker = node.attrs["cellMarker"];
+	if (isTableCellRevisionAttr(marker) && (revisionSet === null || revisionSet.has(marker.info.revisionId))) if (marker.kind === "merge") operations.push({
+		type: "merge",
+		cellPos,
+		source: "visible",
+		mode,
+		revisionSet
+	});
+	else {
+		const keepsCell = marker.kind === "ins" === (mode === "accept");
+		operations.push({
+			type: "membership",
+			cellPos,
+			action: keepsCell ? "clear" : "remove"
+		});
+	}
+	if (hasMatchingCollapsedTableCellMerge(node, revisionSet)) operations.push({
+		type: "merge",
+		cellPos,
+		source: "collapsed",
+		mode,
+		revisionSet
+	});
+	return operations;
+}
+function isTableCellRevisionAttr(value) {
+	if (typeof value !== "object" || value === null || !("kind" in value) || !("info" in value)) return false;
+	if (value.kind !== "ins" && value.kind !== "del" && value.kind !== "merge") return false;
+	const info = value.info;
+	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
+}
+function deleteTableCellAt(tr, cellPos) {
+	const cell = tr.doc.nodeAt(cellPos);
+	if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") return;
+	const resolved = tr.doc.resolve(cellPos);
+	const row = resolved.parent;
+	if (row.type.spec["tableRole"] !== "row") return;
+	if (row.childCount > 1) {
+		tr.delete(cellPos, cellPos + cell.nodeSize);
+		return;
+	}
+	deleteTableRowAt(tr, resolved.start() - 1);
+}
+function deleteTableRowAt(tr, rowPos) {
+	const resolved = tr.doc.resolve(rowPos);
+	const table = resolved.parent;
+	if (table.type.spec["tableRole"] !== "table") return;
+	const rowIndex = resolved.index();
+	if (table.childCount > 1) {
+		const map = TableMap.get(table);
+		removeRow(tr, {
+			map,
+			table,
+			tableStart: resolved.start(),
+			left: 0,
+			top: rowIndex,
+			right: map.width,
+			bottom: rowIndex + 1
+		}, rowIndex);
+		return;
+	}
+	const tablePosition = resolved.start() - 1;
+	const tableEnd = tablePosition + table.nodeSize;
+	const outerResolved = tr.doc.resolve(tablePosition);
+	const parent = outerResolved.parent;
+	const tableIndex = outerResolved.index();
+	if (parent.canReplace(tableIndex, tableIndex + 1)) {
+		tr.delete(tablePosition, tableEnd);
+		return;
+	}
+	const emptyParagraph = tr.doc.type.schema.nodes["paragraph"]?.createAndFill();
+	if (emptyParagraph && parent.canReplaceWith(tableIndex, tableIndex + 1, emptyParagraph.type, emptyParagraph.marks)) tr.replaceWith(tablePosition, tableEnd, emptyParagraph);
+}
 function collectPPrMarkOp(node, pos, from, to, mode, revisionSet) {
 	if (!rangeCoversParagraphBoundary(from, to, pos, node)) return null;
 	const pPrMark = node.attrs["pPrMark"];
@@ -279,30 +454,65 @@ function rejectAllChanges() {
 	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
 }
 /**
-* Find the document range covered by all insertion/deletion marks
+* Find the document range covered by all inline revision marks
 * carrying any of the given AI-edit `revisionIds`. Returns null when
 * none of those marks are present (already accepted/rejected, or
 * never existed). A replace operation typically passes two ids (one
 * for its deletion side, one for its insertion side); inserts and
-* standalone deletions pass a single id.
+* standalone deletions and formatting changes pass a single id.
 */
 function findAIEditRevisionRange(state, revisionIds) {
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
-	if (!insertionType && !deletionType) return null;
+	const runPropertyChangeType = state.schema.marks["runPropertyChange"];
 	const idSet = new Set(typeof revisionIds === "number" ? [revisionIds] : revisionIds);
 	const range = {
 		from: null,
 		to: null
 	};
 	state.doc.descendants((node, pos) => {
+		if (node.type.name === "tableRow") for (const attrName of ["trIns", "trDel"]) {
+			const marker = node.attrs[attrName];
+			if (isTableRowRevisionAttr(marker) && idSet.has(marker.revisionId)) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				return false;
+			}
+		}
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+			const marker = node.attrs["cellMarker"];
+			const hasDirectRevision = isTableCellRevisionAttr(marker) && idSet.has(marker.info.revisionId);
+			const continuationCells = node.attrs["_docxVMergeContinuationCells"];
+			const hasCollapsedRevision = Array.isArray(continuationCells) && continuationCells.some((cell) => {
+				const change = getTableCellMergeChange(cell);
+				return change !== null && idSet.has(change.info.id);
+			});
+			if (hasDirectRevision || hasCollapsedRevision) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				return false;
+			}
+		}
 		if (!node.isInline) return;
-		for (const mark of node.marks) if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
-			const start = pos;
-			const end = pos + node.nodeSize;
-			if (range.from === null || start < range.from) range.from = start;
-			if (range.to === null || end > range.to) range.to = end;
-			break;
+		for (const mark of node.marks) {
+			if (mark.type === runPropertyChangeType && expectRunPropertyChangeMarkAttrs(mark).changes.some((change) => idSet.has(change.info.id))) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				break;
+			}
+			if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				break;
+			}
 		}
 	});
 	if (range.from === null || range.to === null) return null;
@@ -313,7 +523,7 @@ function findAIEditRevisionRange(state, revisionIds) {
 }
 /**
 * Accept the tracked-change marks belonging to an AI-edit operation.
-* Pass a single revisionId for inserts/standalone deletions, or the
+* Pass a single revisionId for inserts, standalone deletions, or formatting changes; or the
 * full id list for a replace (one id per side). Returns false when
 * none of the ids match anything in the doc.
 */
@@ -338,6 +548,405 @@ function rejectAIEditRevision(revisionIds) {
 	};
 }
 /**
+* Suggestion (AI-proposed tracked change) commands.
+*
+* A suggestion is a set of `insertion` / `deletion` / `runPropertyChange` marks
+* sharing one `suggestionId` and carrying `provenance: "suggested"`. Accepting
+* rewrites those marks to normal (`"user"`) tracked changes authored by the
+* accepting user; rejecting inverse-applies them like `rejectChange`, reusing
+* the same {@link resolveChange} machinery scoped to the suggestion's revision
+* ids. All three operate as ordinary PM transactions, so they sync via collab
+* and are undoable.
+*/
+const SUGGESTION_MARK_NAMES = /* @__PURE__ */ new Set([
+	"insertion",
+	"deletion",
+	"runPropertyChange"
+]);
+const isSuggestionMark = (mark) => mark.attrs["provenance"] === "suggested" && SUGGESTION_MARK_NAMES.has(mark.type.name);
+const suggestionKindOf = (mark) => {
+	if (mark.type.name === "insertion") return "insertion";
+	if (mark.type.name === "deletion") return "deletion";
+	return "formatting";
+};
+const readSuggestedMarker = (marker) => {
+	if (typeof marker !== "object" || marker === null || marker.provenance !== "suggested") return null;
+	const suggestionId = marker.suggestionId;
+	const revisionId = marker.revisionId;
+	if (typeof suggestionId !== "string" || typeof revisionId !== "number") return null;
+	return {
+		suggestionId,
+		revisionId
+	};
+};
+const readStructuralSuggestion = (node) => {
+	const attrs = node.attrs;
+	const name = node.type.name;
+	const insertMarker = attrs["_suggestedInsert"];
+	if ((name === "paragraph" || name === "table") && typeof insertMarker === "object" && insertMarker !== null) {
+		const suggestionId = insertMarker.suggestionId;
+		const revisionId = insertMarker.revisionId;
+		if (typeof suggestionId === "string" && typeof revisionId === "number") return {
+			suggestionId,
+			revisionId,
+			kind: name === "table" ? "insertTable" : "insertBlock",
+			isNodeInsert: true
+		};
+	}
+	if (node.type.name === "tableRow") {
+		const ins = readSuggestedMarker(attrs["trIns"]);
+		if (ins) return {
+			...ins,
+			kind: "insertRow",
+			isNodeInsert: false
+		};
+		const del = readSuggestedMarker(attrs["trDel"]);
+		if (del) return {
+			...del,
+			kind: "deleteRow",
+			isNodeInsert: false
+		};
+	}
+	if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+		const cellMarker = attrs["cellMarker"];
+		if (typeof cellMarker === "object" && cellMarker !== null) {
+			const markerKind = cellMarker.kind;
+			if (markerKind === "ins" || markerKind === "del") {
+				const marker = readSuggestedMarker(cellMarker.info);
+				if (marker) {
+					const kind = markerKind === "del" ? "deleteColumn" : "insertColumn";
+					return {
+						...marker,
+						kind,
+						isNodeInsert: false
+					};
+				}
+			}
+		}
+	}
+	return null;
+};
+const collectSuggestions = (state) => {
+	const runPropertyChangeType = state.schema.marks["runPropertyChange"];
+	const bySuggestion = /* @__PURE__ */ new Map();
+	const entryFor = (suggestionId) => {
+		const existing = bySuggestion.get(suggestionId);
+		if (existing) return existing;
+		const created = {
+			segments: [],
+			kinds: /* @__PURE__ */ new Set(),
+			revisionIds: /* @__PURE__ */ new Set()
+		};
+		bySuggestion.set(suggestionId, created);
+		return created;
+	};
+	state.doc.descendants((node, pos) => {
+		const structural = readStructuralSuggestion(node);
+		if (structural) {
+			const entry = entryFor(structural.suggestionId);
+			entry.segments.push({
+				from: pos,
+				to: pos + node.nodeSize
+			});
+			entry.kinds.add(structural.kind);
+			entry.revisionIds.add(structural.revisionId);
+		}
+		if (!node.isInline) return;
+		for (const mark of node.marks) {
+			if (!isSuggestionMark(mark)) continue;
+			const suggestionId = mark.attrs["suggestionId"];
+			if (typeof suggestionId !== "string" || suggestionId.length === 0) continue;
+			const entry = entryFor(suggestionId);
+			entry.segments.push({
+				from: pos,
+				to: pos + node.nodeSize
+			});
+			entry.kinds.add(suggestionKindOf(mark));
+			if (mark.type === runPropertyChangeType) for (const change of expectRunPropertyChangeMarkAttrs(mark).changes) entry.revisionIds.add(change.info.id);
+			else if (typeof mark.attrs["revisionId"] === "number") entry.revisionIds.add(mark.attrs["revisionId"]);
+		}
+	});
+	return bySuggestion;
+};
+/**
+* A whole inserted table (`insertTable`) has no OOXML tracked representation and
+* accepts directly; every other kind accepts as a tracked change. A group that
+* mixes a table insert with any other kind (a caller stamping heterogeneous
+* operations with one `suggestionId`) is `"mixed"`.
+*/
+const suggestionAppliedAs = (kinds) => {
+	if (!kinds.has("insertTable")) return "tracked";
+	return [...kinds].some((kind) => kind !== "insertTable") ? "mixed" : "direct";
+};
+/** Merge sorted, possibly adjacent/overlapping segments into contiguous ranges. */
+const mergeSegments = (segments) => {
+	const sorted = [...segments].toSorted((a, b) => a.from - b.from || a.to - b.to);
+	const merged = [];
+	for (const segment of sorted) {
+		const last = merged.at(-1);
+		if (last && segment.from <= last.to) {
+			last.to = Math.max(last.to, segment.to);
+			continue;
+		}
+		merged.push({ ...segment });
+	}
+	return merged;
+};
+const SUGGESTION_KIND_ORDER = [
+	"insertion",
+	"deletion",
+	"formatting",
+	"insertBlock",
+	"insertTable",
+	"insertRow",
+	"deleteRow",
+	"insertColumn",
+	"deleteColumn"
+];
+/**
+* List every suggestion in the document for host consumption: its id, the
+* contiguous ranges it covers, which kinds of change it contains, and how
+* accepting it applies (tracked vs direct).
+*/
+function getSuggestions(state) {
+	const bySuggestion = collectSuggestions(state);
+	const suggestions = [];
+	for (const [suggestionId, entry] of bySuggestion) suggestions.push({
+		suggestionId,
+		ranges: mergeSegments(entry.segments),
+		kinds: SUGGESTION_KIND_ORDER.filter((kind) => entry.kinds.has(kind)),
+		appliedAs: suggestionAppliedAs(entry.kinds)
+	});
+	return suggestions.toSorted((a, b) => (a.ranges[0]?.from ?? 0) - (b.ranges[0]?.from ?? 0));
+}
+/**
+* The document range covering every mark belonging to `suggestionId`, plus the
+* revision ids those marks carry. Returns null when the suggestion is absent
+* (already accepted/rejected, or never existed).
+*/
+function findSuggestionRange(state, suggestionId) {
+	const entry = collectSuggestions(state).get(suggestionId);
+	if (!entry || entry.segments.length === 0) return null;
+	const ranges = mergeSegments(entry.segments);
+	const from = ranges[0]?.from ?? 0;
+	return {
+		from,
+		to: ranges.at(-1)?.to ?? from,
+		revisionIds: [...entry.revisionIds]
+	};
+}
+/**
+* Normalize an optional acceptance date to a canonical ISO 8601 string. Absent
+* or unparseable input falls back to the current time — a malformed `w:date`
+* must never reach the serialized document (fail-safe boundary validation).
+*/
+const normalizeAcceptDate = (date) => {
+	if (date === void 0) return (/* @__PURE__ */ new Date()).toISOString();
+	const parsed = new Date(date);
+	return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : parsed.toISOString();
+};
+/**
+* The node-attr patch that converts a suggested block/table revision into a
+* normal (`"user"`) one authored by the accepting user. Returns `null` when the
+* node carries no matching suggested revision. Position-stable (attr writes
+* only), so callers can apply it during a single descendants walk.
+*/
+const convertStructuralSuggestionAttrs = (node, author, date) => {
+	const attrs = node.attrs;
+	const userInfo = (marker) => {
+		const source = marker.info ?? marker;
+		return {
+			revisionId: source.revisionId,
+			author,
+			date,
+			...typeof source.initials === "string" ? { initials: source.initials } : {}
+		};
+	};
+	const name = node.type.name;
+	const insertMarker = attrs["_suggestedInsert"];
+	if ((name === "paragraph" || name === "table") && typeof insertMarker === "object" && insertMarker !== null) {
+		const marker = insertMarker;
+		if (name === "table") return {
+			...attrs,
+			_suggestedInsert: null
+		};
+		if (typeof marker.revisionId === "number") return {
+			...attrs,
+			_suggestedInsert: null,
+			pPrMark: {
+				kind: "ins",
+				info: {
+					id: marker.revisionId,
+					author,
+					date,
+					...typeof marker.initials === "string" ? { initials: marker.initials } : {}
+				}
+			}
+		};
+	}
+	if (node.type.name === "tableRow") {
+		if (readSuggestedMarker(attrs["trIns"])) return {
+			...attrs,
+			trIns: userInfo(attrs["trIns"])
+		};
+		if (readSuggestedMarker(attrs["trDel"])) return {
+			...attrs,
+			trDel: userInfo(attrs["trDel"])
+		};
+	}
+	if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+		const cellMarker = attrs["cellMarker"];
+		if (cellMarker && (cellMarker.kind === "ins" || cellMarker.kind === "del") && readSuggestedMarker(cellMarker.info)) return {
+			...attrs,
+			cellMarker: {
+				kind: cellMarker.kind,
+				info: userInfo(cellMarker)
+			}
+		};
+	}
+	return null;
+};
+/**
+* Convert suggested marks AND block/table node revisions to normal (`"user"`)
+* tracked changes. `matchesSuggestion(id)` selects which suggestion to convert
+* (one id, or all).
+*/
+const acceptSuggestions = (matchesSuggestion, options) => {
+	return (state, dispatch) => {
+		const insertionType = state.schema.marks["insertion"];
+		const deletionType = state.schema.marks["deletion"];
+		const runPropertyChangeType = state.schema.marks["runPropertyChange"];
+		const date = normalizeAcceptDate(options.date);
+		const tr = state.tr;
+		let changed = false;
+		state.doc.descendants((node, pos) => {
+			const structural = readStructuralSuggestion(node);
+			if (structural && matchesSuggestion(structural.suggestionId)) {
+				const nextAttrs = convertStructuralSuggestionAttrs(node, options.author, date);
+				if (nextAttrs) {
+					tr.setNodeMarkup(pos, void 0, nextAttrs);
+					changed = true;
+				}
+			}
+			if (!node.isInline) return;
+			const from = pos;
+			const to = pos + node.nodeSize;
+			for (const mark of node.marks) {
+				if (!isSuggestionMark(mark) || typeof mark.attrs["suggestionId"] !== "string" || !matchesSuggestion(mark.attrs["suggestionId"])) continue;
+				changed = true;
+				tr.removeMark(from, to, mark);
+				if (mark.type === runPropertyChangeType) {
+					const nextChanges = [];
+					for (const change of expectRunPropertyChangeMarkAttrs(mark).changes) nextChanges.push({
+						...change,
+						info: {
+							...change.info,
+							author: options.author,
+							date
+						}
+					});
+					tr.addMark(from, to, mark.type.create({
+						changes: nextChanges,
+						provenance: "user",
+						suggestionId: null
+					}));
+					continue;
+				}
+				if (mark.type === insertionType || mark.type === deletionType) tr.addMark(from, to, mark.type.create({
+					...mark.attrs,
+					author: options.author,
+					date,
+					provenance: "user",
+					suggestionId: null
+				}));
+			}
+		});
+		if (!changed) return false;
+		if (dispatch) dispatch(tr);
+		return true;
+	};
+};
+/**
+* Accept one suggestion: convert its inline marks and block/table node
+* revisions into normal tracked changes authored by `author`, keeping revision
+* ids. A whole inserted table (which OOXML cannot track) is applied directly;
+* everything else becomes a tracked change. See {@link getSuggestions} for the
+* per-suggestion `appliedAs`.
+*/
+function acceptSuggestion(suggestionId, options) {
+	return acceptSuggestions((id) => id === suggestionId, options);
+}
+/** Accept every suggestion in the document. */
+function acceptAllSuggestions(options) {
+	return acceptSuggestions(() => true, options);
+}
+/**
+* Reject one suggestion: inverse-apply it in a single transaction. Runs BOTH
+* phases so a heterogeneous group (one `suggestionId` spanning whole-node
+* inserts AND other edits) is fully resolved:
+*  1. inline marks and suggested `trIns`/`trDel`/`cellMarker` revisions are
+*     inverse-applied through {@link resolveChange} (delete suggested-inserted
+*     text/rows/cells, drop suggested deletions/formatting);
+*  2. any remaining whole-node inserts (paragraph/table) are then deleted,
+*     mapped through the accumulated transaction so positions stay valid.
+*
+* A paragraph whole-node insert carries inline marks with the same revision id,
+* so phase 1 empties its text and phase 2 removes the now-empty node; a whole
+* inserted table has no matching revision, so only phase 2 removes it.
+*/
+function rejectSuggestion(suggestionId) {
+	return (state, dispatch) => {
+		const entry = collectSuggestions(state).get(suggestionId);
+		if (!entry) return false;
+		let tr = null;
+		if (entry.revisionIds.size > 0) {
+			const ranges = mergeSegments(entry.segments);
+			const from = ranges[0]?.from ?? 0;
+			resolveChange(from, ranges.at(-1)?.to ?? from, "reject", [...entry.revisionIds])(state, (resolved) => {
+				tr = resolved;
+			});
+		}
+		const workingTr = tr ?? state.tr;
+		const positions = [];
+		workingTr.doc.descendants((node, pos) => {
+			const structural = readStructuralSuggestion(node);
+			if (structural?.isNodeInsert && structural.suggestionId === suggestionId) positions.push(pos);
+		});
+		for (const pos of positions.toSorted((a, b) => b - a)) {
+			const node = workingTr.doc.nodeAt(pos);
+			if (node) workingTr.delete(pos, pos + node.nodeSize);
+		}
+		if (workingTr.steps.length === 0) return false;
+		if (dispatch) dispatch(workingTr);
+		return true;
+	};
+}
+/** Reject every suggestion in the document. */
+function rejectAllSuggestions() {
+	return (state, dispatch) => {
+		const bySuggestion = collectSuggestions(state);
+		if (bySuggestion.size === 0) return false;
+		const revisionIds = /* @__PURE__ */ new Set();
+		for (const entry of bySuggestion.values()) for (const id of entry.revisionIds) revisionIds.add(id);
+		let tr = null;
+		if (revisionIds.size > 0) resolveChange(0, state.doc.content.size, "reject", [...revisionIds])(state, (resolved) => {
+			tr = resolved;
+		});
+		const workingTr = tr ?? state.tr;
+		const positions = [];
+		workingTr.doc.descendants((node, pos) => {
+			if (readStructuralSuggestion(node)?.isNodeInsert) positions.push(pos);
+		});
+		for (const pos of positions.toSorted((a, b) => b - a)) {
+			const node = workingTr.doc.nodeAt(pos);
+			if (node) workingTr.delete(pos, pos + node.nodeSize);
+		}
+		if (workingTr.steps.length === 0) return false;
+		if (dispatch) dispatch(workingTr);
+		return true;
+	};
+}
+/**
 * Find the tracked change mark range at a given cursor position.
 * If the cursor is inside a tracked change, returns the full extent
 * of that mark (expanding to cover all adjacent nodes with the same
@@ -502,4 +1111,4 @@ function findPreviousChange(state, startPos) {
 	return result.value;
 }
 //#endregion
-export { acceptAIEditRevision, acceptAllChanges, acceptChange, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, rejectAIEditRevision, rejectAllChanges, rejectChange, removeCommentMark };
+export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark };