@stll/folio-core 0.56.0 → 0.58.0

package/dist/controller/canonicalClipboard.js

@@ -1,7 +1,9 @@
 import { createNumberingIdAllocator } from "../docx/numberingIds.js";
+import { copyParagraphIndentationProjection } from "../docx/paragraphPropertySource.js";
 import { visitInlineContentSlots, visitParagraphRuns } from "../docx/paragraphTraversal.js";
 import { captureVerbatimXml } from "../docx/verbatimCapture.js";
 import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, findAttributeByNamespaceUri, getLocalName, parseXml } from "../docx/xmlParser.js";
+import { canonicalSelectionRange } from "../prosemirror/canonicalSelectionRange.js";
 import { proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
 import { completeNumberingForDoc } from "../prosemirror/listInstanceReferences.js";
 import { marksToTextFormatting } from "../prosemirror/runFormattingFromMarks.js";
@@ -173,6 +175,22 @@ const importNumbering = ({ destination, source, paragraphs, mode, sourceKind, ex
 		numIds: nums
 	});
 };
+/** Imported comments and notes require copying their source story parts. */
+const canonicalClipboardStoryPartRefusal = (paragraph) => {
+	let requiresStory = false;
+	visitInlineContentSlots(paragraph, ({ item }) => {
+		if (item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference") requiresStory = true;
+	});
+	visitParagraphRuns(paragraph, (run) => {
+		if (run.content.some((item) => item.type === "footnoteRef" || item.type === "endnoteRef")) requiresStory = true;
+	});
+	if (!requiresStory) return void 0;
+	return new CanonicalSessionError({
+		gap: CANONICAL_GAP.dispatch,
+		reason: "refused",
+		message: "Clipboard comments and note references require importing their source story parts."
+	});
+};
 const prepareCanonicalPaste = ({ session, state, slice, plain = false, moveTarget, pasteTarget, sourceDocument, moveSource }) => {
 	if (session.isComposing) return refuse("Composition must finish before using the clipboard.");
 	if (slice.content.size === 0) return Result.err(new CanonicalSessionError({
@@ -203,12 +221,18 @@ const prepareCanonicalPaste = ({ session, state, slice, plain = false, moveTarge
 	const paragraphs = [];
 	for (const block of converted.value) {
 		if (block.type !== "paragraph") return refuse("The clipboard contains an unsupported block.");
-		paragraphs.push(structuredClone(block));
+		const paragraph = structuredClone(block);
+		copyParagraphIndentationProjection({
+			target: paragraph,
+			source: block
+		});
+		paragraphs.push(paragraph);
 	}
 	if (moveTarget === void 0 && (plain || sourceDocument === void 0)) flattenClipboardStyleReferences(paragraphs);
-	const from = session.projection.addressAt(pasteTarget ?? moveSource?.from ?? state.selection.from);
+	const selectionRange = canonicalSelectionRange(state);
+	const from = session.projection.addressAt(pasteTarget ?? moveSource?.from ?? selectionRange.from);
 	if (from.isErr()) return from;
-	const to = session.projection.addressAt(pasteTarget ?? moveSource?.to ?? state.selection.to);
+	const to = session.projection.addressAt(pasteTarget ?? moveSource?.to ?? selectionRange.to);
 	if (to.isErr()) return to;
 	let styles = session.document.package.styles;
 	let styleIds;
@@ -309,14 +333,8 @@ const prepareCanonicalPaste = ({ session, state, slice, plain = false, moveTarge
 	};
 	for (const paragraph of paragraphs) {
 		if (moveTarget === void 0) {
-			let requiresStory = false;
-			visitInlineContentSlots(paragraph, ({ item }) => {
-				if (item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference") requiresStory = true;
-			});
-			visitParagraphRuns(paragraph, (run) => {
-				if (run.content.some((item) => item.type === "footnoteRef" || item.type === "endnoteRef")) requiresStory = true;
-			});
-			if (requiresStory) return refuse("Clipboard comments and note references require importing their source story parts.");
+			const storyPartRefusal = canonicalClipboardStoryPartRefusal(paragraph);
+			if (storyPartRefusal !== void 0) return Result.err(storyPartRefusal);
 			const links = [];
 			visitInlineContentSlots(paragraph, ({ item }) => {
 				if (item.type === "hyperlink") links.push(item);
@@ -335,7 +353,7 @@ const prepareCanonicalPaste = ({ session, state, slice, plain = false, moveTarge
 		const runs = [];
 		visitParagraphRuns(paragraph, (run) => runs.push(run));
 		for (const item of runs) {
-			if (plain) item.formatting = marksToTextFormatting(state.storedMarks ?? state.doc.resolve(pasteTarget ?? moveSource?.from ?? state.selection.from).marks());
+			if (plain) item.formatting = marksToTextFormatting(state.storedMarks ?? state.doc.resolve(pasteTarget ?? moveSource?.from ?? selectionRange.from).marks());
 			for (const child of item.content) {
 				if (child.type !== "drawing") continue;
 				if (child.rawXmlMode !== void 0) return refuse("Opaque drawings and embedded objects require their source package parts.");
@@ -473,4 +491,4 @@ const prepareCanonicalPaste = ({ session, state, slice, plain = false, moveTarge
 	});
 };
 //#endregion
-export { prepareCanonicalPaste };
+export { canonicalClipboardStoryPartRefusal, prepareCanonicalPaste };

package/dist/controller/canonicalComments.d.ts

@@ -0,0 +1,41 @@
+import { document_d_exports } from "../types/document.js";
+import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
+import { Comment } from "../types/content.js";
+import { CreateCommentOp, DocumentOp } from "@stll/docx-core/ops";
+//#region src/controller/canonicalComments.d.ts
+declare const CanonicalCommentError_base: import("better-result").TaggedErrorClass<"CanonicalCommentError">;
+declare class CanonicalCommentError extends CanonicalCommentError_base<{
+  message: string;
+  gap: typeof CANONICAL_GAP.comments;
+}> {}
+type CanonicalCommentCommand = {
+  type: "create";
+  comment: CreateCommentOp["comment"];
+  anchor: CreateCommentOp["anchor"];
+} | {
+  type: "update";
+  id: number;
+  content: Comment["content"];
+} | {
+  type: "resolve";
+  id: number;
+  status: "open" | "resolved";
+} | {
+  type: "delete";
+  id: number;
+} | {
+  type: "replace";
+  comments: readonly Comment[];
+};
+type CompileCanonicalCommentsOptions = {
+  document: document_d_exports.Document;
+  command: CanonicalCommentCommand;
+};
+declare const compileCanonicalComments: ({ document, command }: CompileCanonicalCommentsOptions) => import("better-result").Err<never, CanonicalCommentError> | import("better-result").Ok<{
+  ops: DocumentOp[];
+  document: document_d_exports.Document;
+  commentId: number | undefined;
+}, never>;
+declare const canonicalCommentBody: (document: document_d_exports.Document, text: string) => Comment["content"];
+//#endregion
+export { CanonicalCommentCommand, CanonicalCommentError, canonicalCommentBody, compileCanonicalComments };

package/dist/controller/canonicalComments.js

@@ -0,0 +1,152 @@
+import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { Result, TaggedError } from "better-result";
+import { DOCUMENT_OP_TYPES, allocateCommentAnchorIds, applyDocumentOps, packageParagraphIds } from "@stll/docx-core/ops";
+//#region src/controller/canonicalComments.ts
+/** The one semantic compiler for canonical sidebar, controlled and public comments. */
+var CanonicalCommentError = class extends TaggedError("CanonicalCommentError") {};
+const refuse = (message) => Result.err(new CanonicalCommentError({
+	message,
+	gap: CANONICAL_GAP.comments
+}));
+const compileCanonicalComments = ({ document, command }) => {
+	const current = document.package.document.comments ?? [];
+	const byId = new Map(current.map((comment) => [comment.id, comment]));
+	const ops = [];
+	let commentId;
+	switch (command.type) {
+		case "create":
+			ops.push({
+				type: DOCUMENT_OP_TYPES.CREATE_COMMENT,
+				comment: command.comment,
+				anchor: command.anchor
+			});
+			commentId = command.comment.id;
+			break;
+		case "update":
+			ops.push({
+				type: DOCUMENT_OP_TYPES.UPDATE_COMMENT_CONTENT,
+				id: command.id,
+				content: command.content
+			});
+			break;
+		case "resolve":
+			ops.push({
+				type: DOCUMENT_OP_TYPES.SET_COMMENT_RESOLUTION,
+				id: command.id,
+				status: command.status
+			});
+			break;
+		case "delete": {
+			const comment = byId.get(command.id);
+			if (!comment) return refuse("The comment no longer exists.");
+			ops.push({
+				type: DOCUMENT_OP_TYPES.DELETE_COMMENT,
+				id: command.id,
+				scope: comment.parentId !== void 0 && byId.has(comment.parentId) ? "reply" : "thread"
+			});
+			break;
+		}
+		case "replace": {
+			const nextById = new Map(command.comments.map((comment) => [comment.id, comment]));
+			if (nextById.size !== command.comments.length) return refuse("Comment ids must be unique.");
+			for (const comment of current) {
+				if (nextById.has(comment.id) && comment.parentId !== void 0 && byId.has(comment.parentId) && !nextById.has(comment.parentId)) return refuse("A retained reply requires its parent thread.");
+				if (nextById.has(comment.id)) continue;
+				if (comment.parentId !== void 0 && !nextById.has(comment.parentId) && byId.has(comment.parentId)) continue;
+				ops.push({
+					type: DOCUMENT_OP_TYPES.DELETE_COMMENT,
+					id: comment.id,
+					scope: comment.parentId !== void 0 && byId.has(comment.parentId) ? "reply" : "thread"
+				});
+			}
+			const pending = command.comments.filter((comment) => !byId.has(comment.id));
+			const available = new Set(current.filter((comment) => nextById.has(comment.id)).map((comment) => comment.id));
+			while (pending.length > 0) {
+				const index = pending.findIndex((comment) => comment.parentId !== void 0 && available.has(comment.parentId));
+				if (index < 0) return refuse("New controlled comments require an existing anchored parent without cycles.");
+				const next = pending.splice(index, 1).at(0);
+				if (next === void 0 || next.parentId === void 0) return refuse("The controlled reply is missing its parent.");
+				const { parentId, ...comment } = next;
+				ops.push({
+					type: DOCUMENT_OP_TYPES.CREATE_COMMENT,
+					comment,
+					anchor: {
+						kind: "reply",
+						parentId
+					}
+				});
+				available.add(next.id);
+			}
+			for (const next of command.comments) {
+				const previous = byId.get(next.id);
+				if (!previous) continue;
+				const { content: priorContent, done: priorDone, author: priorAuthor, initials: priorInitials, date: priorDate, ...priorMetadata } = previous;
+				const { content: nextContent, done: nextDone, author: nextAuthor, initials: nextInitials, date: nextDate, ...nextMetadata } = next;
+				if (canonicalJson(priorMetadata) !== canonicalJson(nextMetadata)) return refuse("Controlled comment identity and opaque metadata cannot be replaced.");
+				const patch = {
+					...priorAuthor === nextAuthor ? {} : { author: nextAuthor },
+					...priorInitials === nextInitials ? {} : { initials: Object.hasOwn(next, "initials") ? nextInitials : null },
+					...priorDate === nextDate ? {} : { date: Object.hasOwn(next, "date") ? nextDate : null }
+				};
+				if (canonicalJson(priorContent) !== canonicalJson(nextContent) || Object.keys(patch).length > 0) ops.push({
+					type: DOCUMENT_OP_TYPES.UPDATE_COMMENT_CONTENT,
+					id: next.id,
+					content: nextContent,
+					patch
+				});
+				if (priorDone !== nextDone) {
+					if (nextDone === void 0) return refuse("Resolution changes must name an open or resolved state.");
+					ops.push({
+						type: DOCUMENT_OP_TYPES.SET_COMMENT_RESOLUTION,
+						id: next.id,
+						status: nextDone ? "resolved" : "open"
+					});
+				}
+			}
+			break;
+		}
+		default: return command;
+	}
+	const compiled = [];
+	let draft = document;
+	for (const op of ops) {
+		const materialized = (() => {
+			if (op.type !== DOCUMENT_OP_TYPES.CREATE_COMMENT) return Result.ok(op);
+			const allocation = allocateCommentAnchorIds(draft, op);
+			if (allocation.isErr()) return Result.err(allocation.error);
+			return Result.ok({
+				...op,
+				newIds: allocation.value
+			});
+		})();
+		if (materialized.isErr()) return refuse(materialized.error.message);
+		const applied = applyDocumentOps(draft, [materialized.value]);
+		if (applied.isErr()) return refuse(applied.error.message);
+		compiled.push(materialized.value);
+		draft = applied.value.document;
+	}
+	return Result.ok({
+		ops: compiled,
+		document: draft,
+		commentId
+	});
+};
+const canonicalCommentBody = (document, text) => {
+	const occupied = new Set(packageParagraphIds(document.package).map((id) => id.toUpperCase()));
+	let id = 1;
+	while (occupied.has(id.toString(16).padStart(8, "0").toUpperCase())) id += 1;
+	return [{
+		type: "paragraph",
+		paraId: id.toString(16).padStart(8, "0").toUpperCase(),
+		content: [{
+			type: "run",
+			content: [{
+				type: "text",
+				text
+			}]
+		}]
+	}];
+};
+//#endregion
+export { CanonicalCommentError, canonicalCommentBody, compileCanonicalComments };

package/dist/controller/canonicalComposition.d.ts

@@ -13,18 +13,27 @@ type CompositionOptions = {
   }) => void;
   refuse: (reason: string) => void;
 };
+type CompositionCompletionEvidence = "provisional" | "explicitFinal";
+type CompositionPhase = {
+  type: "active";
+  completion: CompositionCompletionEvidence;
+} | {
+  type: "ended";
+  data: string | null;
+  completion: CompositionCompletionEvidence;
+};
 type CompositionState = {
   type: "committed";
 } | {
   type: "provisional";
   baseline: EditorState;
   view: EditorView;
-  phase: "active" | "ended";
+  phase: CompositionPhase;
 } | {
   type: "refused";
   baseline: EditorState;
   view: EditorView;
-  phase: "active" | "ended";
+  phase: CompositionPhase;
   text: string | null;
 };
 type CompositionFinish = {
@@ -37,12 +46,16 @@ type CompositionFinish = {
 declare const createCanonicalComposition: (options: CompositionOptions) => {
   readonly status: CompositionState["type"];
   readonly active: boolean;
+  matchesCancellationRange: (view: EditorView, range: {
+    from: number;
+    to: number;
+  }) => boolean;
   start: (view: EditorView) => void;
-  ended: (view: EditorView) => void;
+  ended: (view: EditorView, data: string | null) => void;
   forgetCompleted: () => void;
   readonly pendingFinal: boolean;
   authorizeLateFinal: (view: EditorView, text: string | null) => boolean;
-  authorizeNative: (view: EditorView) => void;
+  authorizeNative: (view: EditorView, completion: CompositionCompletionEvidence) => void;
   flushed: (view: EditorView) => void;
   recover: (view: EditorView) => CompositionFinish;
   cancel: (view: EditorView) => CompositionFinish;

package/dist/controller/canonicalComposition.js

@@ -1,11 +1,52 @@
 import { splitsSurrogatePair } from "../ai-edits/character-boundaries.js";
+import { RUN_IDENTITY_MARK_NAME } from "../prosemirror/runIdentity.js";
 import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
 import { setCanonicalInputTimer } from "./canonicalInputTimer.js";
 import { CanonicalSessionError } from "./canonicalSession.js";
 import { Result } from "better-result";
 import { EditorState, TextSelection } from "prosemirror-state";
 //#region src/controller/canonicalComposition.ts
-const COMPOSITION_FLUSH_DELAY_MS = 25;
+const matchesNativeReplacement = ({ baseline, proposed, from, to, text }) => {
+	const expected = baseline.tr.insertText(text, from, to);
+	if (expected.doc.eq(proposed.doc)) return true;
+	if (!baseline.doc.resolve(from).sameParent(baseline.doc.resolve(to))) return false;
+	if (expected.doc.content.size !== proposed.doc.content.size) return false;
+	const markType = baseline.schema.marks[RUN_IDENTITY_MARK_NAME];
+	if (markType === void 0) return false;
+	const position = expected.doc.resolve(from);
+	const paragraph = position.parent;
+	const start = position.start();
+	const native = proposed.doc.nodeAt(start - 1);
+	if (native === null || native.type !== paragraph.type) return false;
+	let index = 0;
+	let offset = 0;
+	const missing = [];
+	native.forEach((node, nodeOffset) => {
+		const end = nodeOffset + node.nodeSize;
+		let cursor = nodeOffset;
+		while (cursor < end && index < paragraph.childCount) {
+			const authored = paragraph.child(index);
+			const authoredEnd = offset + authored.nodeSize;
+			const overlapEnd = Math.min(end, authoredEnd);
+			if (node.isText && authored.isText && markType.isInSet(authored.marks) !== void 0 && markType.isInSet(node.marks) === void 0) {
+				const previous = missing.at(-1);
+				if (previous?.to === start + cursor) previous.to = start + overlapEnd;
+				else missing.push({
+					type: "omittedRunIdentity",
+					from: start + cursor,
+					to: start + overlapEnd
+				});
+			}
+			cursor = overlapEnd;
+			if (cursor === authoredEnd) {
+				offset = authoredEnd;
+				index += 1;
+			}
+		}
+	});
+	for (const range of missing) expected.removeMark(range.from, range.to, markType);
+	return expected.doc.eq(proposed.doc);
+};
 /** Native IME owns the provisional view; the captured canonical projection stays unchanged. */
 const createCanonicalComposition = (options) => {
 	let state = { type: "committed" };
@@ -26,7 +67,13 @@ const createCanonicalComposition = (options) => {
 	const selectedReplacement = (baseline, proposed) => {
 		const { from, to } = baseline.selection;
 		const text = selectedText(baseline, proposed);
-		if (text === null || !baseline.tr.insertText(text, from, to).doc.eq(proposed.doc)) return null;
+		if (text === null || !matchesNativeReplacement({
+			baseline,
+			proposed,
+			from,
+			to,
+			text
+		})) return null;
 		return {
 			from,
 			to,
@@ -50,24 +97,51 @@ const createCanonicalComposition = (options) => {
 		if (!$from.sameParent($to)) return null;
 		const start = $from.start();
 		const next = proposed.doc.nodeAt(start - 1);
-		if (!next || next.type !== $from.parent.type || next.content.size !== next.textContent.length) return null;
-		const before = $from.parent.textContent;
-		const after = next.textContent;
-		let from = 0;
-		while (from < before.length && from < after.length && before[from] === after[from]) from++;
-		while (splitsSurrogatePair(before, from) || splitsSurrogatePair(after, from)) from--;
-		let oldEnd = before.length;
-		let newEnd = after.length;
+		if (!next || next.type !== $from.parent.type) return null;
+		const previous = $from.parent.content;
+		const changedFrom = previous.findDiffStart(next.content);
+		if (changedFrom === null) {
+			if (!baseline.doc.eq(proposed.doc)) return null;
+			return {
+				from: baseline.selection.from,
+				to: baseline.selection.from,
+				text: "",
+				semantic: "composition"
+			};
+		}
+		const changedEnd = previous.findDiffEnd(next.content);
+		if (changedEnd === null) return null;
+		let from = changedFrom;
+		let oldEnd = changedEnd.a;
+		let newEnd = changedEnd.b;
+		const overlap = from - Math.min(oldEnd, newEnd);
+		if (overlap > 0) {
+			oldEnd += overlap;
+			newEnd += overlap;
+		}
+		const before = previous.textBetween(0, previous.size, "", "");
+		const after = next.content.textBetween(0, next.content.size, "", "");
+		while (from < oldEnd && from < newEnd && before[from] === after[from]) from++;
 		while (oldEnd > from && newEnd > from && before[oldEnd - 1] === after[newEnd - 1]) {
 			oldEnd--;
 			newEnd--;
 		}
+		while (splitsSurrogatePair(before, from) || splitsSurrogatePair(after, from)) from--;
 		while (splitsSurrogatePair(before, oldEnd) || splitsSurrogatePair(after, newEnd)) {
 			oldEnd++;
 			newEnd++;
 		}
-		const text = after.slice(from, newEnd);
-		if (!baseline.tr.insertText(text, start + from, start + oldEnd).doc.eq(proposed.doc)) return null;
+		const removed = previous.cut(from, oldEnd);
+		const inserted = next.content.cut(from, newEnd);
+		const text = inserted.textBetween(0, inserted.size, "", "");
+		if (removed.textBetween(0, removed.size, "", "").length !== removed.size || text.length !== inserted.size) return null;
+		if (!matchesNativeReplacement({
+			baseline,
+			proposed,
+			from: start + from,
+			to: start + oldEnd,
+			text
+		})) return null;
 		return {
 			from: start + from,
 			to: start + oldEnd,
@@ -99,7 +173,7 @@ const createCanonicalComposition = (options) => {
 			view.updateState(pending.baseline);
 		}
 		options.end();
-		if (!commit || view.isDestroyed) return { type: "cancelled" };
+		if (!commit || view.isDestroyed || pending.phase.type === "ended" && pending.phase.data === "" && pending.phase.completion === "provisional" && committedText === "") return { type: "cancelled" };
 		if (pending.type === "refused") return {
 			type: "refused",
 			text: pending.text
@@ -130,7 +204,7 @@ const createCanonicalComposition = (options) => {
 	};
 	const schedule = (view) => {
 		clearTimer();
-		timer = setCanonicalInputTimer(() => finish(view, true), COMPOSITION_FLUSH_DELAY_MS);
+		timer = setCanonicalInputTimer(() => finish(view, true), 25);
 	};
 	return {
 		get status() {
@@ -139,6 +213,18 @@ const createCanonicalComposition = (options) => {
 		get active() {
 			return state.type !== "committed";
 		},
+		matchesCancellationRange: (view, range) => {
+			if (state.type === "committed" || state.view !== view) return false;
+			const text = selectedText(state.baseline, view.state);
+			if (text === null || text.length === 0) return false;
+			const from = state.baseline.selection.from;
+			if (range.from !== from || range.to !== from + text.length) return false;
+			const selection = view.dom.ownerDocument.getSelection();
+			if (!selection || selection.rangeCount !== 1) return false;
+			const selected = selection.getRangeAt(0);
+			if (!view.dom.contains(selected.startContainer) || !view.dom.contains(selected.endContainer)) return false;
+			return view.posAtDOM(selected.startContainer, selected.startOffset) === range.from && view.posAtDOM(selected.endContainer, selected.endOffset) === range.to;
+		},
 		start: (view) => {
 			if (state.type !== "committed") return;
 			if (!options.begin()) return;
@@ -146,10 +232,13 @@ const createCanonicalComposition = (options) => {
 				type: "provisional",
 				baseline: view.state,
 				view,
-				phase: "active"
+				phase: {
+					type: "active",
+					completion: "provisional"
+				}
 			};
 		},
-		ended: (view) => {
+		ended: (view, data) => {
 			if (state.type === "committed") return;
 			switch (state.type) {
 				case "provisional":
@@ -157,7 +246,11 @@ const createCanonicalComposition = (options) => {
 						type: "provisional",
 						baseline: state.baseline,
 						view: state.view,
-						phase: "ended"
+						phase: {
+							type: "ended",
+							data,
+							completion: state.phase.completion
+						}
 					};
 					break;
 				case "refused":
@@ -165,7 +258,11 @@ const createCanonicalComposition = (options) => {
 						type: "refused",
 						baseline: state.baseline,
 						view: state.view,
-						phase: "ended",
+						phase: {
+							type: "ended",
+							data,
+							completion: state.phase.completion
+						},
 						text: state.text
 					};
 					break;
@@ -193,15 +290,23 @@ const createCanonicalComposition = (options) => {
 			};
 			return true;
 		},
-		authorizeNative: (view) => {
+		authorizeNative: (view, completion) => {
 			authorizedNativeState = view.state;
+			if (state.type !== "committed" && completion === "explicitFinal") state.phase = state.phase.type === "active" ? {
+				type: "active",
+				completion
+			} : {
+				type: "ended",
+				data: state.phase.data,
+				completion
+			};
 		},
 		flushed: (view) => {
 			const authorized = authorizedNativeState;
 			queueMicrotask(() => {
 				if (authorizedNativeState === authorized) authorizedNativeState = null;
 			});
-			if (state.type !== "committed" && state.phase === "ended") schedule(view);
+			if (state.type !== "committed" && state.phase.type === "ended") schedule(view);
 		},
 		recover: (view) => finish(view, true),
 		cancel: (view) => finish(view, false),

package/dist/controller/canonicalInlineProjection.d.ts

@@ -106,8 +106,13 @@ type CanonicalInlineProjectionArgs = {
   source: document_d_exports.Paragraph;
   paragraph: Node;
   pairedBookmarkIds: ReadonlySet<number>;
+  commentContext?: {
+    rangedIds: ReadonlySet<number>;
+    pointIds: ReadonlySet<number>;
+    openIds: ReadonlySet<number>;
+  };
 };
 /** Bind rendered gaps to the operation owner's source leaf ordinals, including collapsed pairs. */
-declare const projectCanonicalInline: ({ source, paragraph, pairedBookmarkIds }: CanonicalInlineProjectionArgs) => Result<InlineProjection, InlineProjectionError>;
+declare const projectCanonicalInline: ({ source, paragraph, pairedBookmarkIds, commentContext }: CanonicalInlineProjectionArgs) => Result<InlineProjection, InlineProjectionError>;
 //#endregion
 export { CANONICAL_NATIVE_INLINE_POLICIES, CANONICAL_SOURCE_INLINE_POLICIES, CanonicalInlineGap, canonicalInlineSourceIssue, canonicalNativeCells, projectCanonicalInline };