@stll/folio-core 0.55.0 → 0.57.0

package/dist/controller/canonicalPublicOperations.js

@@ -0,0 +1,648 @@
+import { splitsGraphemeCluster, splitsSurrogatePair } from "../ai-edits/character-boundaries.js";
+import { buildCleanBlockText, resolveCleanTextRange } from "../ai-edits/clean-text.js";
+import { stripInlineEmphasisMarkers } from "../ai-edits/inline-emphasis.js";
+import { collectNoteReferenceLabels, hashFolioAIBlockText } from "../ai-edits/snapshot.js";
+import { wordDiffSessionFromOptions } from "../ai-edits/word-diff.js";
+import { getFolioDocumentOperationIssues, getFolioDocumentOperationReceiptsForStory, parseFolioDocumentOperationBatch } from "../document-operations.js";
+import { maxAnnotationIdInDoc } from "../prosemirror/plugins/revisionIds.js";
+import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
+import { canonicalCommentBody, compileCanonicalComments } from "./canonicalComments.js";
+import { Result, TaggedError, panic } from "better-result";
+import { Mark } from "prosemirror-model";
+import { OP_STORIES, applyDocumentOps, compileEditorIntent, createEditorIntentIdAllocator, documentStories, findStoryBody, freshCommentId, paragraphLength } from "@stll/docx-core/ops";
+//#region src/controller/canonicalPublicOperations.ts
+/** Public batches compile against the read projection; only the canonical journal publishes. */
+/** A new public kind cannot bypass a canonical compiler/refusal decision. */
+const CANONICAL_PUBLIC_OPERATION_DISPOSITIONS = {
+	replaceInBlock: "compile",
+	replaceRange: "compile",
+	replaceBlock: "compile",
+	splitBlock: "compile",
+	formatRange: "compile",
+	mergeBlockWithNext: "compile",
+	setBlockParagraphProperties: CANONICAL_GAP.publicUnsupportedInline,
+	insertAfterBlock: CANONICAL_GAP.publicUnsupportedInline,
+	insertBeforeBlock: CANONICAL_GAP.publicUnsupportedInline,
+	deleteBlock: CANONICAL_GAP.publicUnsupportedInline,
+	commentOnBlock: "compile",
+	commentOnRange: "compile",
+	insertTable: CANONICAL_GAP.publicTableProjection,
+	insertSignatureTable: CANONICAL_GAP.publicTableProjection,
+	deleteTable: CANONICAL_GAP.publicTableProjection,
+	insertTableRow: CANONICAL_GAP.publicTableProjection,
+	deleteTableRow: CANONICAL_GAP.publicTableProjection,
+	insertTableColumn: CANONICAL_GAP.publicTableProjection,
+	deleteTableColumn: CANONICAL_GAP.publicTableProjection,
+	mergeTableCells: CANONICAL_GAP.publicTableProjection,
+	splitTableCell: CANONICAL_GAP.publicTableProjection
+};
+const resolveComment = ({ operation, from, to }) => {
+	if ("comment" in operation && operation.comment !== void 0) return {
+		type: "commented",
+		operation,
+		comment: {
+			text: operation.comment.text,
+			from,
+			to
+		}
+	};
+	return {
+		type: "plain",
+		operation
+	};
+};
+const compilePublicIntents = ({ document, intents, mode, author, date, nextRevisionId, allocate }) => {
+	const ops = [];
+	const revisions = [];
+	for (const sourceIntent of intents) {
+		const ids = allocate(document, sourceIntent);
+		const intent = sourceIntent.type === "splitParagraph" ? {
+			type: "splitParagraph",
+			at: sourceIntent.at,
+			...sourceIntent.to === void 0 ? {} : { to: sourceIntent.to },
+			newBlockId: ids.newBlockId
+		} : sourceIntent;
+		const firstRevisionId = nextRevisionId;
+		const compiled = compileEditorIntent(document, {
+			intent,
+			mode: mode === "direct" ? {
+				type: "editing",
+				newIds: ids.newIds
+			} : {
+				type: "suggesting",
+				revision: {
+					id: firstRevisionId,
+					author,
+					date
+				},
+				newIds: {
+					control: ids.newIds.control,
+					revision: ids.newIds.revision.map((_, index) => firstRevisionId + index + 1)
+				}
+			}
+		});
+		if (compiled.isErr()) return Result.err(compiled.error);
+		const applied = applyDocumentOps(document, compiled.value.ops);
+		if (applied.isErr()) return Result.err(applied.error);
+		document = applied.value.document;
+		ops.push(...compiled.value.ops);
+		revisions.push(...applied.value.revisions);
+		for (const id of applied.value.revisions) nextRevisionId = Math.max(nextRevisionId, id + 1);
+	}
+	return Result.ok({
+		document,
+		ops,
+		revisions,
+		nextRevisionId
+	});
+};
+var CanonicalPublicOperationResolutionError = class extends TaggedError("CanonicalPublicOperationResolutionError") {};
+const canonicalPublicStory = (story) => {
+	if (story === "main") return story;
+	switch (story.type) {
+		case "header":
+		case "footer": return {
+			kind: story.type,
+			rId: story.relationshipId
+		};
+		case "footnote":
+		case "endnote": return {
+			kind: story.type,
+			id: story.noteId
+		};
+		default: return panic(`Unknown public operation story ${story}`);
+	}
+};
+const batchStatus = (batch, skippedCount) => {
+	if (batch.dryRun) return "previewed";
+	if (batch.atomic && skippedCount > 0) return "rejected";
+	return "committed";
+};
+/** Handles address isolated journal groups; no second document or PM history is retained. */
+var CanonicalPublicOperations = class {
+	options;
+	handles = [];
+	nextHandle = 1;
+	handleNamespace = crypto.randomUUID();
+	constructor(options) {
+		this.options = options;
+	}
+	apply(options) {
+		const batch = parseFolioDocumentOperationBatch(options.batch);
+		const { session } = this.options;
+		const publicStory = options.story ?? "main";
+		const story = canonicalPublicStory(publicStory);
+		const state = this.options.getState(story);
+		const projected = session.projectStory(story);
+		const skipped = [];
+		const normalizations = [];
+		const refusals = /* @__PURE__ */ new Map();
+		const resolved = [];
+		const { diff } = wordDiffSessionFromOptions(options.wordDiff);
+		let nextRevisionId = options.revisionStamp?.idSeed ?? 1;
+		if (!session.isComposing && options.revisionStamp === void 0) for (const currentStory of documentStories(session.document)) {
+			const currentProjection = session.projectStory(currentStory);
+			if (currentProjection.isOk()) nextRevisionId = Math.max(nextRevisionId, maxAnnotationIdInDoc(currentProjection.value.doc) + 1);
+		}
+		const skip = (id, reason, message) => {
+			skipped.push({
+				id,
+				reason,
+				...message === void 0 ? {} : { message }
+			});
+		};
+		const result = (applied, undoHandle) => {
+			const failures = new Map(skipped.map((item) => [item.id, item]));
+			const ordered = batch.operations.flatMap(({ id }) => {
+				const failure = failures.get(id);
+				if (!failure) return [];
+				const canonicalRefusal = refusals.get(id);
+				return [canonicalRefusal ? {
+					...failure,
+					canonicalRefusal
+				} : failure];
+			});
+			return {
+				version: 1,
+				status: batchStatus(batch, ordered.length),
+				applied,
+				skipped: ordered,
+				issues: getFolioDocumentOperationIssues(batch.operations, ordered),
+				receipts: getFolioDocumentOperationReceiptsForStory({
+					operations: batch.operations,
+					applied,
+					story: publicStory
+				}),
+				undoHandle,
+				nextRevisionId,
+				...normalizations.length === 0 ? {} : { normalizations }
+			};
+		};
+		for (const operation of batch.operations) {
+			if (story !== OP_STORIES.MAIN) {
+				refusals.set(operation.id, { gap: CANONICAL_GAP.publicSecondaryStories });
+				skip(operation.id, "unsupportedBlock", "Canonical public secondary-story routing is unavailable.");
+				continue;
+			}
+			if (!state || projected.isErr() || session.isComposing) {
+				skip(operation.id, "documentNotEditable");
+				continue;
+			}
+			if (batch.mode === "suggested") {
+				refusals.set(operation.id, { gap: CANONICAL_GAP.publicSuggestedMode });
+				skip(operation.id, "unsupportedMode", "Canonical pending suggestions are unavailable.");
+				continue;
+			}
+			if (options.tableTemplates !== void 0 || options.undefinedStyles === "keep") {
+				refusals.set(operation.id, { gap: CANONICAL_GAP.publicUnsupportedInline });
+				skip(operation.id, "unsupportedBlock", "This canonical compiler does not support the supplied execution options.");
+				continue;
+			}
+			const disposition = CANONICAL_PUBLIC_OPERATION_DISPOSITIONS[operation.type];
+			if (disposition !== "compile") {
+				refusals.set(operation.id, { gap: disposition });
+				skip(operation.id, "unsupportedBlock");
+				continue;
+			}
+			const compiled = this.resolve({
+				operation,
+				options,
+				state,
+				story,
+				diff
+			});
+			if (compiled.isErr()) {
+				if (compiled.error.reason === "unsupportedBlock") refusals.set(operation.id, { gap: CANONICAL_GAP.publicUnsupportedInline });
+				skip(operation.id, compiled.error.reason, compiled.error.message);
+				continue;
+			}
+			if (resolved.some(({ from, to }) => compiled.value.from < to && compiled.value.to > from || from === to && compiled.value.from <= from && compiled.value.to >= from || compiled.value.from === compiled.value.to && compiled.value.from >= from && compiled.value.from <= to)) {
+				skip(operation.id, "overlappingOperation");
+				continue;
+			}
+			resolved.push(compiled.value);
+		}
+		if (batch.atomic && skipped.length > 0) {
+			for (const { operation } of resolved) skip(operation.id, "atomicBatchRejected");
+			return result([], null);
+		}
+		if (!state || projected.isErr() || session.isComposing) return result([], null);
+		resolved.sort((left, right) => right.from - left.from);
+		let document = session.document;
+		const ops = [];
+		const appliedById = /* @__PURE__ */ new Map();
+		const allocate = createEditorIntentIdAllocator();
+		const date = options.revisionStamp?.date ?? (/* @__PURE__ */ new Date()).toISOString();
+		for (const resolvedOperation of resolved) {
+			const { operation, intents, normalizations: adjustments } = resolvedOperation;
+			const compiled = compilePublicIntents({
+				document,
+				intents,
+				allocate,
+				nextRevisionId,
+				mode: batch.mode === "direct" ? "direct" : "tracked-changes",
+				author: options.author ?? "AI",
+				date
+			});
+			if (compiled.isErr()) {
+				refusals.set(operation.id, { gap: CANONICAL_GAP.publicUnsupportedInline });
+				skip(operation.id, "unsupportedBlock", compiled.error.message);
+				continue;
+			}
+			let nextDocument = compiled.value.document;
+			const operationOps = [...compiled.value.ops];
+			let commentId;
+			switch (resolvedOperation.type) {
+				case "plain": break;
+				case "commented": {
+					const { comment } = resolvedOperation;
+					const id = freshCommentId(nextDocument);
+					const before = findStoryBody(document, story)?.content.find((block) => block.type === "paragraph" && block.paraId === comment.from.blockId);
+					const after = findStoryBody(nextDocument, story)?.content.find((block) => block.type === "paragraph" && block.paraId === comment.from.blockId);
+					if (id.isErr() || before?.type !== "paragraph" || after?.type !== "paragraph") {
+						refusals.set(operation.id, { gap: CANONICAL_GAP.publicComments });
+						skip(operation.id, "unsupportedBlock", id.isErr() ? id.error.message : "The comment anchor no longer exists.");
+						continue;
+					}
+					const to = {
+						...comment.to,
+						offset: comment.to.offset + paragraphLength(after) - paragraphLength(before)
+					};
+					const commented = compileCanonicalComments({
+						document: nextDocument,
+						command: {
+							type: "create",
+							comment: {
+								id: id.value,
+								author: options.author ?? "AI",
+								date,
+								done: false,
+								content: canonicalCommentBody(nextDocument, comment.text)
+							},
+							anchor: to.offset === comment.from.offset ? {
+								kind: "point",
+								at: comment.from
+							} : {
+								kind: "range",
+								from: comment.from,
+								to
+							}
+						}
+					});
+					if (commented.isErr()) {
+						refusals.set(operation.id, { gap: CANONICAL_GAP.publicComments });
+						skip(operation.id, "unsupportedBlock", commented.error.message);
+						continue;
+					}
+					nextDocument = commented.value.document;
+					operationOps.push(...commented.value.ops);
+					commentId = id.value;
+					break;
+				}
+				default: panic(`Unknown resolved operation ${resolvedOperation}`);
+			}
+			if (operationOps.length === 0) {
+				skip(operation.id, "noopOperation");
+				continue;
+			}
+			normalizations.push(...adjustments);
+			document = nextDocument;
+			ops.push(...operationOps);
+			nextRevisionId = Math.max(compiled.value.nextRevisionId, (commentId ?? -1) + 1);
+			const revisionIds = compiled.value.revisions;
+			const revisionId = revisionIds.at(0);
+			appliedById.set(operation.id, {
+				id: operation.id,
+				...commentId === void 0 ? {} : { commentId },
+				...revisionId === void 0 ? {} : {
+					revisionId,
+					revisionIds
+				}
+			});
+		}
+		if (batch.atomic && skipped.length > 0) {
+			for (const { id } of appliedById.values()) skip(id, "atomicBatchRejected");
+			return result([], null);
+		}
+		if (ops.length === 0) return result([], null);
+		const selection = projected.value.selectionAt(state);
+		const prepared = selection.isErr() ? selection : session.prepareOps(state, ops, selection.value);
+		if (prepared.isErr()) {
+			for (const { id } of appliedById.values()) {
+				refusals.set(id, { gap: CANONICAL_GAP.publicUnsupportedInline });
+				skip(id, prepared.error.reason === "noChange" ? "noopOperation" : "unsupportedBlock", prepared.error.message);
+			}
+			return result([], null);
+		}
+		const applied = batch.operations.flatMap(({ id }) => {
+			const entry = appliedById.get(id);
+			return entry ? [batch.dryRun ? { id } : entry] : [];
+		});
+		if (batch.dryRun) return result(applied, null);
+		if (!this.options.publish(prepared.value)) {
+			for (const { id } of applied) skip(id, "documentNotEditable");
+			return result([], null);
+		}
+		const handle = {
+			type: "documentOperationUndo",
+			id: `canonical-${this.handleNamespace}-${String(this.nextHandle++)}`
+		};
+		this.handles.push({
+			handle,
+			version: session.version,
+			story
+		});
+		return result(applied, handle);
+	}
+	undo(handle) {
+		const index = this.handles.findIndex(({ handle: existing }) => existing.id === handle.id && existing.type === handle.type);
+		if (index < 0) return {
+			status: "rejected",
+			undoHandle: handle,
+			reason: "unknownHandle"
+		};
+		if (index !== this.handles.length - 1) return {
+			status: "rejected",
+			undoHandle: handle,
+			reason: "notLatest"
+		};
+		const entry = this.handles.at(-1);
+		const { session } = this.options;
+		if (!entry || entry.version !== session.version) return {
+			status: "rejected",
+			undoHandle: handle,
+			reason: "documentChanged"
+		};
+		const state = this.options.getState(entry.story);
+		if (!state) return {
+			status: "rejected",
+			undoHandle: handle,
+			reason: "documentChanged"
+		};
+		const prepared = session.prepareUndo(state, entry.story);
+		if (prepared.isErr() || !this.options.publish(prepared.value)) return {
+			status: "rejected",
+			undoHandle: handle,
+			reason: "documentChanged"
+		};
+		this.handles.pop();
+		const previous = this.handles.at(-1);
+		if (previous && previous.version === entry.version - 1) previous.version = session.version;
+		return {
+			status: "undone",
+			undoHandle: handle
+		};
+	}
+	resolve({ operation, options, state, story, diff }) {
+		const refusal = (reason, message) => Result.err(new CanonicalPublicOperationResolutionError({
+			reason,
+			message: message ?? `The operation was refused: ${reason}.`
+		}));
+		switch (operation.type) {
+			case "replaceInBlock":
+			case "replaceRange":
+			case "replaceBlock":
+			case "splitBlock":
+			case "formatRange":
+			case "mergeBlockWithNext":
+			case "commentOnRange":
+			case "commentOnBlock": break;
+			default: return refusal("unsupportedBlock", `Canonical public operation ${operation.type} is unavailable.`);
+		}
+		const blockId = operation.type === "replaceRange" || operation.type === "formatRange" || operation.type === "commentOnRange" ? operation.range.blockId : operation.blockId;
+		const anchor = Object.hasOwn(options.snapshot.anchors, blockId) ? options.snapshot.anchors[blockId] : void 0;
+		const projection = this.options.session.projectStory(story);
+		if (!anchor || projection.isErr()) return refusal("missingBlock");
+		const paragraph = projection.value.paragraph(blockId);
+		if (!paragraph) return refusal("missingBlock");
+		if (paragraph.source.pPrMark?.kind === "del" || paragraph.source.pPrMark?.kind === "moveFrom") return refusal("pendingDeletion");
+		const clean = buildCleanBlockText(paragraph.node, paragraph.start - 1, {
+			fieldResults: "text",
+			noteReferences: collectNoteReferenceLabels(state.doc)
+		});
+		const hash = hashFolioAIBlockText(clean.text);
+		if (operation.precondition && hash !== operation.precondition.blockTextHash) return refusal("preconditionFailed");
+		if (hash !== anchor.textHash) return refusal("changedBlock");
+		let start = 0;
+		let end = clean.text.length;
+		let text = "";
+		switch (operation.type) {
+			case "replaceInBlock":
+				if (operation.find === "") return refusal("emptyOperation");
+				start = clean.text.indexOf(operation.find);
+				if (start < 0) return refusal("missingFind");
+				if (clean.text.indexOf(operation.find, start + 1) >= 0) return refusal("ambiguousFind");
+				end = start + operation.find.length;
+				text = operation.replace;
+				break;
+			case "commentOnBlock":
+				if (operation.quote !== void 0) {
+					start = clean.text.indexOf(operation.quote);
+					if (start < 0) return refusal("missingFind");
+					if (clean.text.indexOf(operation.quote, start + 1) >= 0) return refusal("ambiguousFind");
+					end = start + operation.quote.length;
+				}
+				break;
+			case "replaceRange":
+			case "formatRange":
+			case "commentOnRange":
+				start = operation.range.startOffset;
+				end = operation.range.endOffset;
+				if (hashFolioAIBlockText(clean.text.slice(start, end)) !== operation.range.selectedTextHash) return refusal("staleRange");
+				text = operation.type === "replaceRange" ? operation.replace : "";
+				break;
+			case "replaceBlock":
+				if (operation.styleId !== void 0 || operation.preserveFormatting === false) return refusal("unsupportedBlock", "Canonical replacement paragraph properties are unavailable.");
+				text = operation.text;
+				break;
+			case "splitBlock":
+				if (operation.firstParagraphProperties || operation.secondParagraphProperties) return refusal("unsupportedBlock", "Canonical split paragraph properties are unavailable.");
+				start = operation.offset;
+				end = start + (operation.separator?.length ?? 0);
+				if (start <= 0 || start >= clean.text.length || clean.text.slice(start, end) !== (operation.separator ?? "")) return refusal("staleRange");
+				break;
+			case "mergeBlockWithNext":
+				if (operation.mergedParagraphProperties || operation.separator) return refusal("unsupportedBlock", "Canonical public join properties and separators are unavailable.");
+				start = clean.text.length;
+				end = start;
+				break;
+			default: return operation;
+		}
+		if ([start, end].some((offset) => splitsSurrogatePair(clean.text, offset) || splitsGraphemeCluster(clean.text, offset))) return refusal("splitsCharacter");
+		if (clean.structuralBoundaries.some((boundary) => boundary.type === "noteReference" && start < boundary.offset + boundary.length && end > boundary.offset)) return refusal("protectedReference");
+		if (stripInlineEmphasisMarkers(text) !== text) return refusal("unsupportedBlock", "Canonical public emphasis replacements are unavailable.");
+		if (/\[\^(?:e)?\d+\]/u.test(text) || /[\t\r\n]/u.test(text)) return refusal("unsupportedBlock", "Canonical public replacements require plain text.");
+		const range = resolveCleanTextRange({
+			cleanBlock: clean,
+			startOffset: start,
+			endOffset: end
+		});
+		if (!range) return refusal("staleRange");
+		const from = projection.value.addressAt(range.from);
+		const to = projection.value.addressAt(range.to);
+		if (from.isErr() || to.isErr()) return refusal("unsupportedBlock");
+		const resolvedComment = resolveComment({
+			operation,
+			from: from.value,
+			to: to.value
+		});
+		if (operation.type === "commentOnBlock" || operation.type === "commentOnRange") return Result.ok({
+			...resolvedComment,
+			intents: [],
+			normalizations: [],
+			from: range.from,
+			to: range.to
+		});
+		if (resolvedComment.type === "plain" && operation.type !== "splitBlock" && operation.type !== "formatRange" && operation.type !== "mergeBlockWithNext" && clean.text.slice(start, end) === text) return refusal("noopOperation");
+		let intent;
+		switch (operation.type) {
+			case "splitBlock":
+				intent = {
+					type: "splitParagraph",
+					at: from.value,
+					to: to.value,
+					newBlockId: createEditorIntentIdAllocator()(this.options.session.document, {
+						type: "splitParagraph",
+						at: from.value,
+						to: to.value
+					}).newBlockId
+				};
+				break;
+			case "mergeBlockWithNext": {
+				const body = this.options.session.document.package.document.content;
+				if (story !== "main") return refusal("unsupportedBlock", "Canonical public joins currently require the main story.");
+				const next = body.at(body.findIndex((block) => block.type === "paragraph" && block.paraId === blockId) + 1);
+				if (next?.type !== "paragraph" || !next.paraId) return refusal("missingBlock");
+				intent = {
+					type: "joinParagraphs",
+					story,
+					blockId,
+					nextBlockId: next.paraId
+				};
+				break;
+			}
+			case "formatRange": {
+				const formatting = operation.formatting;
+				const patch = {
+					...formatting.bold === void 0 ? {} : { bold: formatting.bold },
+					...formatting.italic === void 0 ? {} : { italic: formatting.italic },
+					...formatting.underline === void 0 ? {} : { underline: formatting.underline === null ? null : { style: formatting.underline ? "single" : "none" } },
+					...formatting.strike === void 0 ? {} : {
+						strike: formatting.strike,
+						doubleStrike: null
+					},
+					...formatting.fontSizePt === void 0 ? {} : { fontSize: formatting.fontSizePt === null ? null : formatting.fontSizePt * 2 },
+					...formatting.fontFamily === void 0 ? {} : { fontFamily: formatting.fontFamily === null ? null : {
+						ascii: formatting.fontFamily,
+						hAnsi: formatting.fontFamily
+					} },
+					...formatting.color === void 0 ? {} : { color: formatting.color === null ? null : { rgb: formatting.color.replace(/^#/u, "").toUpperCase() } }
+				};
+				intent = {
+					type: "formatRun",
+					from: from.value,
+					to: to.value,
+					patch
+				};
+				break;
+			}
+			case "replaceInBlock":
+			case "replaceRange":
+			case "replaceBlock":
+				intent = {
+					type: "replaceText",
+					from: from.value,
+					to: to.value,
+					text,
+					...options.replacementBackground === "keep" ? {} : { runPropsPatch: {
+						highlight: null,
+						shading: null
+					} }
+				};
+				break;
+			default: return panic(`Unknown canonical public operation ${operation}`);
+		}
+		const intents = [];
+		const normalizations = [];
+		if (intent.type === "replaceText") {
+			let offset = start;
+			let pending = null;
+			const changes = [];
+			for (const segment of diff(clean.text.slice(start, end), text)) switch (segment.type) {
+				case "equal":
+					if (pending) changes.push(pending);
+					pending = null;
+					offset += segment.text.length;
+					break;
+				case "del":
+					pending ??= {
+						start: offset,
+						end: offset,
+						text: ""
+					};
+					offset += segment.text.length;
+					pending.end = offset;
+					break;
+				case "ins":
+					pending ??= {
+						start: offset,
+						end: offset,
+						text: ""
+					};
+					pending.text += segment.text;
+					break;
+				default: {
+					const unreachable = segment.type;
+					return panic(`Unknown replacement diff ${unreachable}`);
+				}
+			}
+			if (pending) changes.push(pending);
+			for (const change of changes.toReversed()) {
+				const gap = resolveCleanTextRange({
+					cleanBlock: clean,
+					startOffset: change.start,
+					endOffset: change.end
+				});
+				if (!gap) return refusal("unsupportedBlock");
+				if (change.text.length > 0 && gap.from < gap.to) {
+					let first = null;
+					let uniform = true;
+					paragraph.node.nodesBetween(gap.from - paragraph.start, gap.to - paragraph.start, (node) => {
+						if (!node.isText || node.marks.some((mark) => mark.type.name === "deletion")) return;
+						const marks = node.marks.filter((mark) => mark.type.name !== "insertion");
+						if (first === null) first = marks;
+						else if (!Mark.sameSet(first, marks)) uniform = false;
+					});
+					if (!uniform && normalizations.length === 0) normalizations.push({
+						id: operation.id,
+						code: "uniformReplacementFormatting"
+					});
+				}
+				const changeFrom = projection.value.addressAt(gap.from);
+				const changeTo = projection.value.addressAt(gap.to);
+				if (changeFrom.isErr() || changeTo.isErr()) return refusal("unsupportedBlock");
+				intents.push({
+					type: "replaceText",
+					from: changeFrom.value,
+					to: changeTo.value,
+					text: change.text,
+					...intent.runPropsPatch === void 0 ? {} : { runPropsPatch: intent.runPropsPatch }
+				});
+			}
+		} else intents.push(intent);
+		const structural = operation.type === "splitBlock" || operation.type === "mergeBlockWithNext";
+		const nextParagraph = operation.type === "mergeBlockWithNext" && intent.type === "joinParagraphs" ? projection.value.paragraph(intent.nextBlockId) : void 0;
+		let claimedTo = range.to;
+		if (structural) claimedTo = paragraph.start + paragraph.node.content.size;
+		if (nextParagraph) claimedTo = nextParagraph.start + nextParagraph.node.content.size;
+		return Result.ok({
+			...resolvedComment,
+			intents,
+			normalizations,
+			from: structural ? paragraph.start : range.from,
+			to: claimedTo
+		});
+	}
+};
+//#endregion
+export { CANONICAL_PUBLIC_OPERATION_DISPOSITIONS, CanonicalPublicOperations };

package/dist/controller/canonicalSelection.d.ts

@@ -0,0 +1,18 @@
+import { CanonicalProjection, CanonicalSelection } from "./canonicalSession.js";
+import { Transaction } from "prosemirror-state";
+//#region src/controller/canonicalSelection.d.ts
+type RestoreCanonicalSelectionOptions = {
+  transaction: Transaction;
+  projection: CanonicalProjection;
+  selection: CanonicalSelection;
+  unavailable: {
+    type: "refuse";
+  } | {
+    type: "near";
+    anchor: number;
+  };
+};
+/** Restore the admitted selection kind after a canonical projection changes. */
+declare const restoreCanonicalSelection: ({ transaction, projection, selection, unavailable }: RestoreCanonicalSelectionOptions) => boolean;
+//#endregion
+export { restoreCanonicalSelection };

package/dist/controller/canonicalSelection.js

@@ -0,0 +1,32 @@
+import { panic } from "better-result";
+import { AllSelection, TextSelection } from "prosemirror-state";
+//#region src/controller/canonicalSelection.ts
+/** Restore the admitted selection kind after a canonical projection changes. */
+const restoreCanonicalSelection = ({ transaction, projection, selection, unavailable }) => {
+	switch (selection.type) {
+		case "all":
+			transaction.setSelection(new AllSelection(transaction.doc));
+			return true;
+		case "text": {
+			const anchor = projection.positionAt(selection.anchor);
+			const head = projection.positionAt(selection.head);
+			if (anchor.isOk() && head.isOk()) {
+				transaction.setSelection(TextSelection.create(transaction.doc, anchor.value, head.value));
+				return true;
+			}
+			switch (unavailable.type) {
+				case "refuse": return false;
+				case "near":
+					transaction.setSelection(TextSelection.near(transaction.doc.resolve(Math.min(unavailable.anchor, transaction.doc.content.size))));
+					return true;
+				default: return panic(`Unknown selection restoration policy: ${unavailable}`);
+			}
+		}
+		default: {
+			const exhaustive = selection.type;
+			return panic(`Unknown canonical selection type: ${exhaustive}`);
+		}
+	}
+};
+//#endregion
+export { restoreCanonicalSelection };