@stll/folio-core 0.54.1 → 0.54.2

package/dist/prosemirror/plugins/revisionIds.d.ts

@@ -1,31 +1,35 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/plugins/revisionIds.d.ts
+declare const RevisionIdAllocationError_base: import("better-result").TaggedErrorClass<"RevisionIdAllocationError">;
+declare class RevisionIdAllocationError extends RevisionIdAllocationError_base<{
+  message: string;
+  first: number;
+  next: number;
+}> {}
+/** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
+declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
+/** The next free id, including after the signed 32-bit boundary wraps. */
+declare const nextRevisionId: () => number;
 /**
- * Mint the next tracked-revision id (`w:id`). Strictly monotonic per realm,
- * and always inside the range serialized `w:id` may occupy.
+ * A shared batch increments its seed locally, so a single free id is not
+ * enough: start in the largest free interval. Every contiguous batch that
+ * can fit anywhere fits here, including after loaded ids shorten the tail.
+ * Continue within this interval until another producer changes the cursor.
  */
+declare const nextRevisionIdRange: () => number;
+/** Reserve a deterministic batch without changing its caller-supplied ids. */
+declare const reserveRevisionIds: (first: number, next: number) => void;
+/** Shared producers must never cross a loaded or already issued id on wrap. */
+declare const claimRevisionIds: (first: number, next: number) => void;
+/** Mint a bounded id without reusing loaded or previously issued ids. */
 declare function mintRevisionId(): number;
-/**
- * Raise the counter above `maxId` so freshly minted ids cannot collide with
- * ids already present in a loaded document. Only ever raises.
- *
- * `maxId` is derived from file content, so it is untrusted: a malformed or
- * out-of-range value is ignored outright rather than folded into range.
- */
+/** Reserve a valid loaded id and prefer the range above it. */
 declare function seedRevisionIdsAbove(maxId: number): void;
-/**
- * The highest id in `doc` from any part of the annotation space.
- *
- * A revision, a comment and a bookmark draw their `w:id` from one space, so a
- * counter seeded above its own kind alone still mints over another kind's id.
- * Both allocators seed from this, and the save-time normalization avoids the
- * same space, so the three agree on what is taken.
- */
-declare function maxAnnotationIdInDoc(doc: Node): number;
+declare const maxAnnotationIdInDoc: (doc: Node) => number;
 /**
  * Raise the counter above every annotation id already present in `doc`.
  * Called from the suggestion-mode plugin's `state.init`.
  */
 declare function seedRevisionIdsFromDoc(doc: Node): void;
 //#endregion
-export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/plugins/revisionIds.js

@@ -1,3 +1,4 @@
+import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/plugins/revisionIds.ts
 /**
@@ -9,23 +10,98 @@ import { MAX_REVISION_ID } from "@stll/docx-core/model";
 * int consumers read `w:id` into.
 */
 let counter = 1;
+const occupiedIds = /* @__PURE__ */ new Set();
+var RevisionIdAllocationError = class extends TaggedError("RevisionIdAllocationError") {};
+/** Batches use contiguous ids; on rollover prefer the largest unused interval. */
+const largestFreeIntervalStart = (reservedIds) => {
+	let first = 1;
+	let bestFirst = 1;
+	let bestSize = 0;
+	const boundaries = [...reservedIds].filter((id) => id > 0).toSorted((a, b) => a - b);
+	boundaries.push(MAX_REVISION_ID + 1);
+	for (const boundary of boundaries) {
+		const size = boundary - first;
+		if (size > bestSize) {
+			bestFirst = first;
+			bestSize = size;
+		}
+		first = boundary + 1;
+	}
+	if (bestSize === 0) throw new RevisionIdAllocationError({
+		message: "Revision id space exhausted",
+		first: 1,
+		next: 1
+	});
+	return bestFirst;
+};
+/** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
+const revisionIdSeedAbove = (existingIds) => {
+	const reservedIds = /* @__PURE__ */ new Set();
+	let maxId = 0;
+	for (const id of existingIds) {
+		if (!Number.isInteger(id) || id < 0 || id > MAX_REVISION_ID) continue;
+		reservedIds.add(id);
+		maxId = Math.max(maxId, id);
+	}
+	return maxId < MAX_REVISION_ID ? maxId + 1 : largestFreeIntervalStart(reservedIds);
+};
+/** The next free id, including after the signed 32-bit boundary wraps. */
+const nextRevisionId = () => {
+	if (counter > MAX_REVISION_ID) counter = largestFreeIntervalStart(occupiedIds);
+	while (occupiedIds.has(counter)) {
+		counter += 1;
+		if (counter > MAX_REVISION_ID) counter = largestFreeIntervalStart(occupiedIds);
+		if (occupiedIds.size >= MAX_REVISION_ID) throw new RevisionIdAllocationError({
+			message: "Revision id space exhausted",
+			first: counter,
+			next: counter
+		});
+	}
+	return counter;
+};
 /**
-* Mint the next tracked-revision id (`w:id`). Strictly monotonic per realm,
-* and always inside the range serialized `w:id` may occupy.
+* A shared batch increments its seed locally, so a single free id is not
+* enough: start in the largest free interval. Every contiguous batch that
+* can fit anywhere fits here, including after loaded ids shorten the tail.
+* Continue within this interval until another producer changes the cursor.
 */
+const nextRevisionIdRange = () => {
+	counter = largestFreeIntervalStart(occupiedIds);
+	return counter;
+};
+const validateRevisionIdRange = (first, next) => {
+	if (!Number.isInteger(first) || !Number.isInteger(next) || first < 0 || next < first || next > MAX_REVISION_ID + 1) throw new RevisionIdAllocationError({
+		message: "Revision id range exceeds the OOXML limit",
+		first,
+		next
+	});
+};
+/** Reserve a deterministic batch without changing its caller-supplied ids. */
+const reserveRevisionIds = (first, next) => {
+	validateRevisionIdRange(first, next);
+	for (let id = first; id < next; id += 1) occupiedIds.add(id);
+	if (next > counter) counter = next;
+};
+/** Shared producers must never cross a loaded or already issued id on wrap. */
+const claimRevisionIds = (first, next) => {
+	validateRevisionIdRange(first, next);
+	for (let id = first; id < next && id <= MAX_REVISION_ID; id += 1) if (occupiedIds.has(id)) throw new RevisionIdAllocationError({
+		message: "Revision id range overlaps an occupied id",
+		first,
+		next
+	});
+	reserveRevisionIds(first, next);
+};
+/** Mint a bounded id without reusing loaded or previously issued ids. */
 function mintRevisionId() {
-	if (counter > MAX_REVISION_ID) counter = 1;
-	return counter++;
+	const id = nextRevisionId();
+	claimRevisionIds(id, id + 1);
+	return id;
 }
-/**
-* Raise the counter above `maxId` so freshly minted ids cannot collide with
-* ids already present in a loaded document. Only ever raises.
-*
-* `maxId` is derived from file content, so it is untrusted: a malformed or
-* out-of-range value is ignored outright rather than folded into range.
-*/
+/** Reserve a valid loaded id and prefer the range above it. */
 function seedRevisionIdsAbove(maxId) {
-	if (!Number.isInteger(maxId) || maxId < 0 || maxId >= MAX_REVISION_ID) return;
+	if (!Number.isInteger(maxId) || maxId < 0 || maxId > MAX_REVISION_ID) return;
+	occupiedIds.add(maxId);
 	if (maxId >= counter) counter = maxId + 1;
 }
 /** Node attrs that carry a revision id directly (`revisionId` field). */
@@ -33,40 +109,45 @@ const DIRECT_REVISION_ATTR_KEYS = ["trIns", "trDel"];
 /**
 * The highest id in `doc` from any part of the annotation space.
 *
-* A revision, a comment and a bookmark draw their `w:id` from one space, so a
-* counter seeded above its own kind alone still mints over another kind's id.
-* Both allocators seed from this, and the save-time normalization avoids the
-* same space, so the three agree on what is taken.
+* Preserve the editor's conservative annotation seeding: revisions reserve
+* comment and bookmark ids too, although OOXML defines separate id spaces.
 */
-function maxAnnotationIdInDoc(doc) {
+const visitAnnotationIds = (doc, visit) => {
 	let max = 0;
 	const consider = (id) => {
-		if (typeof id === "number" && Number.isInteger(id) && id > max && id <= MAX_REVISION_ID) max = id;
+		if (typeof id === "number" && Number.isInteger(id) && id >= 0 && id <= MAX_REVISION_ID) {
+			visit(id);
+			max = Math.max(max, id);
+		}
+	};
+	const considerMetadata = (value) => {
+		if (typeof value !== "object" || value === null) return;
+		for (const [key, child] of Object.entries(value)) if (key === "id" || key === "revisionId" || key === "commentId") consider(child);
+		else considerMetadata(child);
 	};
 	doc.descendants((node) => {
 		for (const mark of node.marks) {
 			consider(mark.attrs["revisionId"]);
 			consider(mark.attrs["commentId"]);
+			considerMetadata(mark.attrs["_docxRevisionAncestors"]);
+			considerMetadata(mark.attrs["changes"]);
 		}
 		if (node.type.name === "bookmarkBoundary") consider(node.attrs["id"]);
 		const attrs = node.attrs;
-		const pPrMark = attrs["pPrMark"];
-		if (pPrMark?.info) consider(pPrMark.info.id);
-		for (const key of DIRECT_REVISION_ATTR_KEYS) {
-			const value = attrs[key];
-			if (value) consider(value.revisionId);
-		}
-		const cellMarker = attrs["cellMarker"];
-		if (cellMarker?.info) consider(cellMarker.info.revisionId);
+		considerMetadata(attrs["_propertyChanges"]);
+		considerMetadata(attrs["pPrMark"]);
+		for (const key of DIRECT_REVISION_ATTR_KEYS) considerMetadata(attrs[key]);
+		considerMetadata(attrs["cellMarker"]);
 	});
 	return max;
-}
+};
+const maxAnnotationIdInDoc = (doc) => visitAnnotationIds(doc, () => {});
 /**
 * Raise the counter above every annotation id already present in `doc`.
 * Called from the suggestion-mode plugin's `state.init`.
 */
 function seedRevisionIdsFromDoc(doc) {
-	seedRevisionIdsAbove(maxAnnotationIdInDoc(doc));
+	visitAnnotationIds(doc, seedRevisionIdsAbove);
 }
 //#endregion
-export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/plugins/suggestionMode.d.ts

@@ -66,8 +66,8 @@ declare function handleSuggestionEnter(view: EditorView, pluginState: Suggestion
  * - Delete-at-paragraph-end     → current paragraph.
  *
  * Returns `null` when there is no adjacent sibling paragraph (the join would
- * not produce paragraph-mark merging — e.g. doc start, doc end, or sibling
- * is a table). The default merge path then runs unchanged.
+ * not produce paragraph-mark merging, e.g. doc start, doc end, or a table).
+ * Bookmark markers at an edge do not hide the adjacent paragraph break.
  */
 declare function paragraphBoundaryTarget(state: EditorState, direction: "backward" | "forward"): number | null;
 /** Apply the editor's selected-content deletion path for a host cut action. */

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,4 +1,5 @@
 import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
+import { clearIndentOnBackspace } from "../commands/clearParagraphIndent.js";
 import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
 import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { encloseWholeControls } from "../contentControlRevisions.js";
@@ -10,14 +11,16 @@ import { rebaseParagraphRuns } from "../rebaseParagraphRunFormatting.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { paragraphRunStyleContext } from "../runStyleFormatting.js";
 import { cellPasteRange, pasteTableCells } from "../tableCellPaste.js";
-import { handleEditorBeforeInput } from "../textInput.js";
+import { afterNativeCompositionFlush, handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
 import { getDocumentNumbering } from "./documentNumbering.js";
-import { getDocumentStyleResolver } from "./documentStyleState.js";
+import { documentStylesKey, getDocumentStyleResolver } from "./documentStyleState.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
 import { Slice } from "prosemirror-model";
+import { CellSelection } from "prosemirror-tables";
 import { Mapping, ReplaceStep } from "prosemirror-transform";
-import { AllSelection, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
+import { AllSelection, EditorState, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
+import { joinBackward, joinForward, selectNodeBackward, selectNodeForward } from "prosemirror-commands";
 import { isHistoryTransaction } from "prosemirror-history";
 import { undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/plugins/suggestionMode.ts
@@ -241,10 +244,44 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 function handleSuggestionPaste(view, slice, pluginState) {
 	const { selection } = view.state;
 	const selectsAll = selection instanceof AllSelection;
-	if (!(selection instanceof TextSelection || selectsAll) || selection.empty) return false;
+	if (!(selection instanceof TextSelection || selectsAll)) return false;
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return false;
+	if (selection.empty) {
+		const { $from } = selection;
+		const closedTable = slice.openStart === 0 && slice.openEnd === 0 && slice.content.firstChild?.type.name === "table" && slice.content.lastChild?.type.name === "table";
+		const prefix = $from.parent.content.cut(0, $from.parentOffset);
+		let deletedPrefix = prefix.size > 0;
+		prefix.forEach((node) => {
+			if (!node.marks.some((mark) => mark.type === deletionType)) deletedPrefix = false;
+		});
+		if (!closedTable || $from.parent.type.name !== "paragraph" || !deletedPrefix) return false;
+		const suffix = $from.parent.content.cut($from.parentOffset);
+		let deletedSuffix = true;
+		suffix.forEach((node) => {
+			if (!node.marks.some((mark) => mark.type === deletionType)) deletedSuffix = false;
+		});
+		const tr = view.state.tr.setMeta(SUGGESTION_META, true).setMeta("paste", true);
+		const at = $from.before();
+		tr.replaceRange(at, at, slice);
+		const revision = makeMarkAttrs(pluginState);
+		const end = tr.mapping.map(at, 1);
+		enclosePastedRunRevisions({
+			tr,
+			from: at,
+			to: end,
+			revision
+		});
+		markRangeAsInserted(tr, tr.doc, at, end, insertionType, deletionType, revision);
+		if (deletedSuffix && $from.parent.attrs["pPrMark"] == null && !paragraphEndsItsContainer($from.doc.resolve($from.before()), "paragraph")) tr.setNodeAttribute(tr.mapping.map($from.before()), "pPrMark", {
+			kind: "del",
+			info: makeParagraphMarkInfo(pluginState)
+		});
+		tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(selection.from)));
+		view.dispatch(tr.scrollIntoView());
+		return true;
+	}
 	if (selectsAll && (slice.openStart > 0 || slice.openEnd > 0)) slice = new Slice(view.state.tr.replaceSelection(slice).doc.content, 0, 0);
 	const { from, to } = selectsAll ? {
 		from: Selection.atStart(view.state.doc).from,
@@ -372,16 +409,54 @@ function handleSuggestionTableCellPaste(view, slice, pluginState) {
 			const insertFrom = tr.mapping.slice(mapFrom).map(to);
 			const sizeBefore = tr.doc.content.size;
 			tr.replaceRange(insertFrom, insertFrom, content);
-			const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			let insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			let pastedFrom = insertFrom;
+			const finalParagraph = cell.lastChild;
+			const $pasteFrom = tr.doc.resolve(pastedFrom);
+			const $pasteTo = tr.doc.resolve(insertTo);
+			if (content.openStart > 0 && content.openEnd > 0 && finalParagraph?.type.name === "paragraph" && $pasteFrom.parent.type.name === "paragraph" && $pasteTo.parent.type.name === "paragraph" && $pasteFrom.before() !== $pasteTo.before()) {
+				tr.setNodeAttribute($pasteFrom.before(), "pPrMark", {
+					kind: "ins",
+					info: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+				tr.setNodeAttribute($pasteTo.before(), "pPrMark", finalParagraph.attrs["pPrMark"]);
+				recordReplacedParagraphProperties({
+					tr,
+					position: $pasteTo.before(),
+					replaced: finalParagraph,
+					revision: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+			}
+			const emptyInsertions = [];
+			tr.doc.nodeAt(cellPos)?.forEach((node, offset) => {
+				const pos = cellPos + 1 + offset;
+				if (pos < pastedFrom && node.type.name === "paragraph" && node.content.size === 0 && isCurrentAuthorParagraphInsertion(node.attrs["pPrMark"], pluginState.author)) emptyInsertions.push({
+					from: pos,
+					to: pos + node.nodeSize
+				});
+			});
+			const retraction = tr.mapping.maps.length;
+			for (const range of emptyInsertions.toReversed()) tr.delete(range.from, range.to);
+			const retracted = tr.mapping.slice(retraction);
+			pastedFrom = retracted.map(pastedFrom);
+			insertTo = retracted.map(insertTo);
 			enclosePastedRunRevisions({
 				tr,
-				from: insertFrom,
+				from: pastedFrom,
 				to: insertTo,
 				revision
 			});
-			markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, revision);
-			tr.doc.nodesBetween(insertFrom, insertTo, (node, pos) => {
-				if (node.type.name === "paragraph" && pos >= insertFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+			markRangeAsInserted(tr, tr.doc, pastedFrom, insertTo, insertionType, deletionType, revision);
+			tr.doc.nodesBetween(pastedFrom, insertTo, (node, pos) => {
+				if (node.type.name === "paragraph" && pos >= pastedFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
 					kind: "ins",
 					info: {
 						id: revision.revisionId,
@@ -533,15 +608,38 @@ function suggestRangeDeletion(state, tr, from, to) {
 * prior author's revision must not be silently overwritten.
 */
 function handleSuggestionEnter(view, pluginState) {
-	const { $from } = view.state.selection;
-	if ($from.parent.type.name !== "paragraph") return false;
+	const state = view.state;
+	if (state.selection.$from.parent.type.name !== "paragraph") return false;
+	const replacement = { tr: null };
+	let splitState = state;
+	if (state.selection instanceof TextSelection && !state.selection.empty) {
+		if (!handleSuggestionDelete(state, (tr) => {
+			replacement.tr = tr;
+			const styles = documentStylesKey.get(state);
+			const plugins = [];
+			if (styles) {
+				const spec = { ...styles.spec };
+				delete spec.appendTransaction;
+				delete spec.filterTransaction;
+				plugins.push(new Plugin(spec));
+			}
+			splitState = state.reconfigure({ plugins }).apply(tr);
+		}, "forward")) return false;
+	}
+	const { $from } = splitState.selection;
 	const sourcePos = $from.before();
 	const sourceAttrs = $from.parent.attrs;
 	const captured = { tr: null };
-	if (!splitBlockClearBorders(view.state, (tr) => {
+	if (!splitBlockClearBorders(splitState, (tr) => {
 		captured.tr = tr;
 	}, view) || !captured.tr) return false;
-	const tr = captured.tr;
+	const tr = replacement.tr ?? captured.tr;
+	if (replacement.tr) {
+		for (const step of captured.tr.steps) tr.step(step);
+		tr.setSelection(captured.tr.selection.getBookmark().resolve(tr.doc));
+		tr.setStoredMarks(captured.tr.storedMarks);
+	}
+	tr.setMeta(SUGGESTION_META, true);
 	if (sourceAttrs["pPrMark"] == null) {
 		if (tr.doc.nodeAt(sourcePos)?.type.name === "paragraph") {
 			const markInfo = {
@@ -561,6 +659,24 @@ function handleSuggestionEnter(view, pluginState) {
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
+/** Find the adjacent visible unit without consuming a bookmark range marker. */
+function caretDeleteTarget(state, direction) {
+	const { $from } = state.selection;
+	const backward = direction === "backward";
+	let from = backward ? $from.pos - 1 : $from.pos;
+	let to = backward ? $from.pos : $from.pos + 1;
+	while (from >= $from.start() && to <= $from.end()) {
+		const adjacent = state.doc.resolve(from).nodeAfter;
+		if (adjacent?.type.name !== "bookmarkBoundary") return {
+			type: "inlineUnit",
+			from,
+			to
+		};
+		from += backward ? -adjacent.nodeSize : adjacent.nodeSize;
+		to += backward ? -adjacent.nodeSize : adjacent.nodeSize;
+	}
+	return { type: "paragraphEdge" };
+}
 /**
 * Detect a caret-at-paragraph-boundary scenario where Backspace/Delete should
 * record a tracked paragraph-mark deletion instead of joining paragraphs.
@@ -572,8 +688,8 @@ function handleSuggestionEnter(view, pluginState) {
 * - Delete-at-paragraph-end     → current paragraph.
 *
 * Returns `null` when there is no adjacent sibling paragraph (the join would
-* not produce paragraph-mark merging — e.g. doc start, doc end, or sibling
-* is a table). The default merge path then runs unchanged.
+* not produce paragraph-mark merging, e.g. doc start, doc end, or a table).
+* Bookmark markers at an edge do not hide the adjacent paragraph break.
 */
 function paragraphBoundaryTarget(state, direction) {
 	const { $from, empty } = state.selection;
@@ -581,14 +697,13 @@ function paragraphBoundaryTarget(state, direction) {
 	if ($from.parent.type.name !== "paragraph") return null;
 	const paragraphStart = $from.before();
 	const paragraphEnd = $from.after();
+	if (caretDeleteTarget(state, direction).type !== "paragraphEdge") return null;
 	if (direction === "backward") {
-		if ($from.parentOffset !== 0) return null;
 		if (paragraphStart === 0) return null;
 		const prev = state.doc.resolve(paragraphStart).nodeBefore;
 		if (!prev || prev.type.name !== "paragraph") return null;
 		return paragraphStart - prev.nodeSize;
 	}
-	if ($from.parentOffset !== $from.parent.content.size) return null;
 	if (paragraphEnd >= state.doc.content.size) return null;
 	const next = state.doc.resolve(paragraphEnd).nodeAfter;
 	if (!next || next.type.name !== "paragraph") return null;
@@ -612,7 +727,13 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		const joined = view.state.doc.nodeAt(joinPos);
 		try {
 			tr.join(joinPos);
-			tr.setNodeAttribute(targetParagraphPos, "pPrMark", null);
+			tr.setNodeAttribute(targetParagraphPos, "pPrMark", joined?.type === targetNode.type ? expectParagraphAttrs(joined).pPrMark : null);
+			if (joined?.type === targetNode.type) recordReplacedParagraphProperties({
+				tr,
+				position: targetParagraphPos,
+				replaced: joined,
+				revision: existingMark.info
+			});
 			const styleResolver = getDocumentStyleResolver(view.state);
 			if (styleResolver && joined?.type === targetNode.type && joined.content.size > 0) rebaseParagraphRuns({
 				previousContext: paragraphRunStyleContext(joined, styleResolver),
@@ -671,15 +792,28 @@ function handleSuggestionDelete(state, dispatch, direction) {
 			to: rangeTo.pos
 		}).sort((a, b) => b.from - a.from);
 		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState, state);
-		const cursorPos = tr.mapping.map($to.pos);
-		tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
+		if (state.selection instanceof CellSelection) tr.setSelection(state.selection.map(tr.doc, tr.mapping));
+		else {
+			const cursorPos = tr.mapping.map($to.pos);
+			tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
+		}
 		dispatch(tr.scrollIntoView());
 		return true;
 	}
 	const isBackward = direction === "backward";
-	const deletePos = isBackward ? $from.pos - 1 : $from.pos;
-	const deleteEnd = isBackward ? $from.pos : $from.pos + 1;
-	if (deletePos < 0 || deleteEnd > state.doc.content.size) return true;
+	const target = caretDeleteTarget(state, direction);
+	if (target.type === "paragraphEdge") {
+		const edge = isBackward ? $from.start() : $from.end();
+		if ($from.pos === edge) return false;
+		const virtual = EditorState.create({
+			doc: state.doc,
+			selection: TextSelection.create(state.doc, edge)
+		});
+		if ((isBackward ? joinBackward : joinForward)(virtual, dispatch)) return true;
+		return (isBackward ? selectNodeBackward : selectNodeForward)(virtual, dispatch);
+	}
+	const deletePos = target.from;
+	const deleteEnd = target.to;
 	const noteRange = expandNoteReferenceDeletionRange(state.doc, deletePos, deleteEnd);
 	const rangeFrom = noteRange?.from ?? deletePos;
 	const rangeTo = noteRange?.to ?? deleteEnd;
@@ -701,19 +835,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 }
 /** Apply the editor's selected-content deletion path for a host cut action. */
 const deleteSelectionAsSuggestion = (state, dispatch) => state.selection.empty ? false : handleSuggestionDelete(state, dispatch, "forward");
-/**
-* Mark the text committed by an IME composition as a tracked insertion.
-*
-* Invoked from `compositionend` (deferred to a microtask) rather than from the
-* `appendTransaction` catch-all. ProseMirror commits composed text as part of
-* its own composition-end flush; adding the insertion mark *synchronously*
-* during that flush re-wraps the very text node the IME just finalized, which
-* corrupts CJK (Japanese / Chinese / Korean) input — characters duplicate or
-* garble. Running one tick later, after the composition has settled, wraps the
-* committed range safely. `markRangeAsInserted` skips nodes that already carry a
-* tracked-change mark, so this is idempotent. eigenpal/docx-editor#938.
-*/
-function markComposedAsInsertion(view, from, pluginState, replaced) {
+function markComposedAsInsertion({ view, from, pluginState, replaced, compositionId }) {
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return;
@@ -721,9 +843,16 @@ function markComposedAsInsertion(view, from, pluginState, replaced) {
 	if (to <= from && !replaced) return;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
+	if (compositionId !== null) tr.setMeta("composition", compositionId);
 	if (replaced) {
-		tr.insert(from, replaced.content);
-		markRangeAsDeleted(tr, tr.doc, from, from + replaced.content.size, insertionType, deletionType, pluginState);
+		tr.replaceRange(from, from, replaced);
+		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), insertionType, deletionType, pluginState);
+		const restoredEnd = tr.doc.resolve(tr.mapping.map(from, 1));
+		const restoredStart = tr.doc.resolve(from);
+		if (restoredStart.parent.type.name === "paragraph" && restoredEnd.parent.type.name === "paragraph" && restoredStart.parent !== restoredEnd.parent) {
+			const mark = expectParagraphAttrs(restoredStart.parent).pPrMark;
+			if (mark?.kind === "del") carryIntoParagraphLeft(view.state, tr, view.state.doc.resolve(from).parent, restoredEnd.before(), mark.info);
+		}
 	}
 	const insertionFrom = tr.mapping.map(from, 1);
 	const insertionTo = tr.mapping.map(to, 1);
@@ -773,6 +902,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 	let composing = false;
 	let compositionFrom = null;
 	let compositionReplaced = null;
+	let compositionId = null;
 	return new Plugin({
 		key: suggestionModeKey,
 		state: {
@@ -784,6 +914,8 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 				};
 			},
 			apply(tr, state) {
+				const nativeCompositionId = tr.getMeta("composition");
+				if (composing && tr.docChanged && typeof nativeCompositionId === "number") compositionId = nativeCompositionId;
 				const meta = tr.getMeta(suggestionModeKey);
 				if (meta) return {
 					...state,
@@ -809,6 +941,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					if (!suggestionModeKey.getState(view.state)?.active) return false;
 					if (composing) return false;
 					composing = true;
+					compositionId = null;
 					const { from, to } = view.state.selection;
 					compositionFrom = from;
 					compositionReplaced = from === to ? null : view.state.doc.slice(from, to);
@@ -822,14 +955,23 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					compositionReplaced = null;
 					if (!pluginState?.active || from == null) {
 						composing = false;
+						compositionId = null;
 						return false;
 					}
-					queueMicrotask(() => {
+					afterNativeCompositionFlush(() => {
 						try {
 							const current = suggestionModeKey.getState(view.state);
-							if (current?.active) markComposedAsInsertion(view, from, current, replaced);
+							const nativeCompositionId = compositionId;
+							if (current?.active) markComposedAsInsertion({
+								view,
+								from,
+								pluginState: current,
+								replaced,
+								compositionId: nativeCompositionId
+							});
 						} finally {
 							composing = false;
+							compositionId = null;
 						}
 					});
 					return false;
@@ -851,6 +993,20 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 				if (event.key === "Backspace" || event.key === "Delete") {
 					const { $from, empty } = view.state.selection;
 					if (event.key === "Backspace" && empty && $from.parentOffset === 0 && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
+					if (event.key === "Backspace" && clearIndentOnBackspace(view.state, (tr) => {
+						const revision = makeMarkAttrs(pluginState);
+						recordReplacedParagraphProperties({
+							tr,
+							position: $from.before(),
+							replaced: $from.parent,
+							revision: {
+								id: revision.revisionId,
+								author: revision.author,
+								date: revision.date
+							}
+						});
+						view.dispatch(tr.setMeta("suggestionModeApplied", true));
+					})) return true;
 					const boundaryTarget = paragraphBoundaryTarget(view.state, event.key === "Backspace" ? "backward" : "forward");
 					if (boundaryTarget !== null) return applyPPrDel(view, boundaryTarget, pluginState);
 					const direction = event.key === "Backspace" ? "backward" : "forward";