@stll/folio-core 0.54.2 → 0.56.0

package/dist/controller/hiddenEditorManager.js

@@ -1,30 +1,33 @@
 import { recordHiddenEditorPhase, recordHiddenEditorStateCreate } from "../layout-engine/layoutInstrumentation.js";
 import { suppressHiddenEditorScrollToSelection } from "../paged-layout/hiddenEditorScroll.js";
 import { isReadOnlyEditKey } from "../paged-layout/readOnlyEditAttempt.js";
+import { getCanonicalCommandIntents } from "../prosemirror/canonicalCommands.js";
+import { registerClipboardIntentHandler } from "../prosemirror/clipboardIntent.js";
+import { pasteWithoutFormatting } from "../prosemirror/commands/pastePlainText.js";
 import { createEmptyDoc, toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { registerEditorCommandOwner } from "../prosemirror/executeEditorCommand.js";
 import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
 import { ensureParaIdsInDoc, ensureParaIdsInState } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
+import { createParagraphChangeTrackerPlugin, markPackageChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { toggleMarkForAllScripts, toggleUnderlineMark } from "../prosemirror/extensions/marks/markUtils.js";
 import { createDocumentNumberingPlugin } from "../prosemirror/plugins/documentNumbering.js";
 import { createDocumentStylesPlugin } from "../prosemirror/plugins/documentStyles.js";
 import { schema } from "../prosemirror/schema/index.js";
 import { createTextInputPlugin } from "../prosemirror/textInput.js";
 import { applyAttrSchemaMigrations, proseDocumentParagraphSourceContract, readYjsAttrSchemaVersion, readYjsParagraphSourceContract, withParagraphSourceContract, writeYjsDocumentMetadata } from "../prosemirror/yjsDocumentMetadata.js";
+import { CANONICAL_GAP, usesCanonicalSession } from "../types/canonicalCapabilities.js";
+import { prepareCanonicalPaste } from "./canonicalClipboard.js";
+import { createCanonicalInputBoundary } from "./canonicalInput.js";
+import { CanonicalPublicOperations } from "./canonicalPublicOperations.js";
+import { createCanonicalSession, publishCanonicalProjection } from "./canonicalSession.js";
+import { prepareCanonicalAutoformat, prepareCanonicalCommands } from "./canonicalStructure.js";
 import { createHiddenEditorApi } from "./hiddenEditorApi.js";
-import { panic } from "better-result";
-import { EditorState } from "prosemirror-state";
+import { Result, TaggedError, panic } from "better-result";
+import { OP_STORIES } from "@stll/docx-core/ops";
+import { EditorState, Plugin } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/hiddenEditorManager.ts
-/**
-* Hidden-editor view lifecycle manager
-*
-* Framework-agnostic owner of the off-screen ProseMirror EditorView. Holds the
-* view plus the bookkeeping that decides when an incoming document is a truly
-* external change (vs. an internal edit echoed back through props), builds the
-* editor state and `editorProps`, and composes the slice-2a imperative API so
-* the API and the lifecycle share one view owner. The React adapter
-* (`HiddenProseMirror`) keeps the input refs and its effects (which decide
-* *when* to act) and drives this manager through the methods below.
-*/
+var CanonicalSessionRefusalError = class extends TaggedError("CanonicalSessionRefusalError") {};
 const normalizeSeedState = (state) => ensureBaseDirectionInState(ensureParaIdsInState(state));
 const normalizeLocalSeedState = (state) => ensureBaseDirectionInState(state);
 const isObjectRecord = (value) => typeof value === "object" && value !== null;
@@ -201,6 +204,318 @@ const createHiddenEditorClipboardHandlers = (deps) => ({
 });
 const createHiddenEditorManager = (deps) => {
 	let view = null;
+	let releaseCommandOwner;
+	let editorSession = { type: "prosemirror" };
+	let modeOverride = null;
+	const syncCanonicalMode = () => {
+		if (editorSession.type !== "canonical") return;
+		editorSession.session.setMode(modeOverride ?? (deps.getEditingMode?.() === "suggesting" ? {
+			type: "suggesting",
+			author: deps.getSuggestionAuthor?.() ?? "User"
+		} : { type: "editing" }));
+	};
+	const refuse = (reason, gap = CANONICAL_GAP.dispatch) => {
+		const message = reason;
+		if (deps.onSessionRefusal) deps.onSessionRefusal(message, gap);
+		else throw new CanonicalSessionRefusalError({
+			gap,
+			message
+		});
+	};
+	const seedSession = (document) => {
+		if (!usesCanonicalSession(deps.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting)) {
+			editorSession = { type: "prosemirror" };
+			return true;
+		}
+		const documentIdentity = deps.getDocumentIdentity();
+		if (editorSession.type === "refused" && editorSession.documentIdentity === documentIdentity) return false;
+		if (deps.getCollaboration() || !document) {
+			const reason = deps.getCollaboration() ? "Canonical sessions do not support collaboration." : "Canonical sessions require a loaded Document.";
+			editorSession = {
+				type: "refused",
+				reason,
+				documentIdentity
+			};
+			refuse(reason, CANONICAL_GAP.collaboration);
+			return false;
+		}
+		const result = createCanonicalSession(document, deps.getStyles());
+		if (result.isErr()) {
+			editorSession = {
+				type: "refused",
+				reason: result.error.message,
+				documentIdentity
+			};
+			refuse(result.error.message, result.error.gap);
+			return false;
+		}
+		editorSession = {
+			type: "canonical",
+			session: result.value
+		};
+		modeOverride = null;
+		syncCanonicalMode();
+		return true;
+	};
+	const canonicalState = (session) => EditorState.create({
+		doc: session.projection.doc,
+		plugins: [
+			createParagraphChangeTrackerPlugin(),
+			createDocumentStylesPlugin(deps.getStyles() ?? session.document.package.styles),
+			createDocumentNumberingPlugin(session.document.package.numbering),
+			...[...deps.getExtensionManager()?.getPlugins() ?? [], ...deps.getExternalPlugins()].flatMap(({ props }) => props.transformPastedHTML === void 0 && props.transformPasted === void 0 && props.transformCopied === void 0 && props.clipboardTextSerializer === void 0 ? [] : [new Plugin({ props: {
+				...props.transformCopied === void 0 ? {} : { transformCopied: props.transformCopied },
+				...props.clipboardTextSerializer === void 0 ? {} : { clipboardTextSerializer: props.clipboardTextSerializer },
+				...props.transformPastedHTML === void 0 ? {} : { transformPastedHTML: props.transformPastedHTML },
+				...props.transformPasted === void 0 ? {} : { transformPasted: props.transformPasted }
+			} })])
+		]
+	});
+	const publishCommit = (commit) => {
+		if (!view || deps.getReadOnly() || editorSession.type !== "canonical") return false;
+		const session = editorSession.session;
+		const result = publishCanonicalProjection({
+			state: view.state,
+			commit,
+			session
+		});
+		if (result.isErr()) {
+			refuse(result.error.message, result.error.gap);
+			return false;
+		}
+		const staged = result.value;
+		view.updateState(staged.state);
+		deps.onTransaction({
+			transactions: staged.transactions,
+			newState: staged.state,
+			docChanged: true
+		});
+		deps.onSelectionChange(staged.state);
+		return true;
+	};
+	const history = (direction) => {
+		if (!view || deps.getReadOnly() || editorSession.type !== "canonical") return false;
+		const session = editorSession.session;
+		if (direction === "undo" ? !session.canUndo : !session.canRedo) return false;
+		const prepared = direction === "undo" ? session.prepareUndo(view.state) : session.prepareRedo(view.state);
+		if (prepared.isErr()) {
+			if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+			return false;
+		}
+		return publishCommit(prepared.value);
+	};
+	const executeCanonicalCommand = (command) => {
+		if (!view || editorSession.type !== "canonical") return void 0;
+		if (deps.getReadOnly()) return false;
+		if (command === pasteWithoutFormatting) return command(view.state, (transaction) => view?.dispatch(transaction), view);
+		if (editorSession.session.isComposing) {
+			refuse("Composition must finish before formatting.");
+			return false;
+		}
+		const intents = getCanonicalCommandIntents(command, view.state);
+		if (intents === void 0) return void 0;
+		syncCanonicalMode();
+		editorSession.session.breakUndoGroup();
+		if (intents.length > 0 && intents.every((intent) => intent.type === "formatRun" && intent.from === intent.to)) return command(view.state, (transaction) => {
+			if (view !== null) view.dispatch(view.state.tr.setStoredMarks(transaction.storedMarks));
+		}, view);
+		const prepared = prepareCanonicalCommands(editorSession.session, view.state, intents);
+		if (prepared.isErr()) {
+			if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+			return false;
+		}
+		return publishCommit(prepared.value);
+	};
+	let clipboardDrag = { type: "idle" };
+	let lastInputRule;
+	const canonicalStructuralInput = {
+		command: (name) => {
+			if (!view) return;
+			let command = deps.getExtensionManager()?.getCommand(name)?.();
+			if (command === void 0) {
+				const mark = view.state.schema.marks[{
+					toggleBold: "bold",
+					toggleItalic: "italic",
+					toggleUnderline: "underline"
+				}[name]];
+				if (mark !== void 0) command = name === "toggleUnderline" ? toggleUnderlineMark(mark) : toggleMarkForAllScripts(mark, name === "toggleBold" ? "bold" : "italic");
+			}
+			if (command === void 0) {
+				refuse("The formatting command is unavailable.", CANONICAL_GAP.commands);
+				return;
+			}
+			if (executeCanonicalCommand(command) === void 0) command(view.state, (transaction) => view?.dispatch(transaction), view);
+		},
+		structure: (type) => {
+			if (!view || deps.getReadOnly() || editorSession.type !== "canonical") return;
+			syncCanonicalMode();
+			const session = editorSession.session;
+			const state = view.state;
+			const selection = session.projection.selectionAt(state);
+			if (selection.isErr()) {
+				refuse(selection.error.message, selection.error.gap);
+				return;
+			}
+			let prepared;
+			switch (type) {
+				case "split":
+					prepared = (session.projection.paragraph(selection.value.head.blockId)?.source)?.formatting?.numPr?.kind === "reference" && state.selection.$from.parent.content.size === 0 ? prepareCanonicalCommands(session, state, [{ type: "removeList" }]) : session.prepareSplit(state);
+					break;
+				case "joinBackward": {
+					if (lastInputRule?.session === session && lastInputRule.version === session.version && lastInputRule.caret === state.selection.head) {
+						lastInputRule = void 0;
+						history("undo");
+						return;
+					}
+					const paragraph = session.projection.paragraph(selection.value.head.blockId)?.source;
+					if (paragraph?.formatting?.numPr?.kind === "reference") {
+						prepared = prepareCanonicalCommands(session, state, [{ type: "removeList" }]);
+						break;
+					}
+					if ((paragraph?.formatting?.indentLeft ?? 0) > 0 || (paragraph?.formatting?.indentFirstLine ?? 0) > 0) {
+						prepared = session.prepareIntent(state, {
+							type: "formatParagraph",
+							at: selection.value.head,
+							patch: {
+								indentLeft: null,
+								indentFirstLine: null,
+								hangingIndent: null
+							}
+						});
+						break;
+					}
+					prepared = session.prepareJoin(state, "backward");
+					break;
+				}
+				case "joinForward":
+					prepared = session.prepareJoin(state, "forward");
+					break;
+				case "indent":
+				case "outdent":
+					prepared = prepareCanonicalCommands(session, state, [{
+						type: "changeListLevel",
+						direction: type === "indent" ? "increase" : "decrease"
+					}]);
+					break;
+				case "tab":
+				case "lineBreak":
+				case "pageBreak": {
+					const from = session.projection.addressAt(state.selection.from);
+					const to = session.projection.addressAt(state.selection.to);
+					if (from.isErr()) {
+						refuse(from.error.message, from.error.gap);
+						return;
+					}
+					if (to.isErr()) {
+						refuse(to.error.message, to.error.gap);
+						return;
+					}
+					prepared = session.prepareIntent(state, {
+						type: "insertAtom",
+						from: from.value,
+						to: to.value,
+						atom: type === "tab" ? { type: "tab" } : {
+							type: "break",
+							breakType: type === "pageBreak" ? "page" : "textWrapping"
+						}
+					});
+					break;
+				}
+				default: return type;
+			}
+			if (prepared.isErr()) {
+				if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+				return;
+			}
+			publishCommit(prepared.value);
+		}
+	};
+	const canonicalInputLifecycle = {
+		breakUndoGroup: () => {
+			if (editorSession.type === "canonical") editorSession.session.breakUndoGroup();
+		},
+		beginComposition: () => {
+			if (deps.getReadOnly() || editorSession.type !== "canonical") return false;
+			const begun = editorSession.session.beginComposition();
+			if (begun.isErr()) {
+				refuse(begun.error.message, begun.error.gap);
+				return false;
+			}
+			return true;
+		},
+		endComposition: () => {
+			if (editorSession.type === "canonical") editorSession.session.endComposition();
+		}
+	};
+	const input = createCanonicalInputBoundary({
+		pastePlainText: (pmView) => {
+			if (deps.getReadOnly()) {
+				deps.onReadOnlyEditAttempt();
+				return;
+			}
+			pasteWithoutFormatting(pmView.state, (transaction) => pmView.dispatch(transaction), pmView);
+		},
+		cut: (pmView, event) => {
+			event.preventDefault();
+			if (deps.getReadOnly()) {
+				deps.onReadOnlyEditAttempt();
+				return true;
+			}
+			if (editorSession.type !== "canonical" || pmView.state.selection.empty) return true;
+			if (event.clipboardData === null) {
+				refuse("The clipboard cannot receive the cut content.");
+				return true;
+			}
+			syncCanonicalMode();
+			const session = editorSession.session;
+			const { from, to } = pmView.state.selection;
+			const prepared = session.prepareReplace(pmView.state, {
+				from,
+				to,
+				text: "",
+				semantic: "replacement"
+			});
+			if (prepared.isErr()) {
+				refuse(prepared.error.message, prepared.error.gap);
+				return true;
+			}
+			const copied = Result.try({
+				try: () => {
+					const serialized = pmView.serializeForClipboard(pmView.state.selection.content());
+					event.clipboardData?.setData("text/html", serialized.dom.innerHTML);
+					event.clipboardData?.setData("text/plain", serialized.text);
+				},
+				catch: () => new CanonicalSessionRefusalError({
+					gap: CANONICAL_GAP.dispatch,
+					message: "The clipboard could not receive the cut content."
+				})
+			});
+			if (copied.isErr()) refuse(copied.error.message, copied.error.gap);
+			else publishCommit(prepared.value);
+			return true;
+		},
+		...canonicalInputLifecycle,
+		...canonicalStructuralInput,
+		replace: (intent) => {
+			if (!view || deps.getReadOnly() || editorSession.type !== "canonical") return;
+			syncCanonicalMode();
+			const rule = prepareCanonicalAutoformat(editorSession.session, view.state, intent);
+			const prepared = rule ?? editorSession.session.prepareReplace(view.state, intent);
+			if (prepared.isErr()) {
+				if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+				return;
+			}
+			const session = editorSession.session;
+			if (publishCommit(prepared.value) && rule !== void 0 && view !== null) lastInputRule = {
+				session,
+				version: session.version,
+				caret: view.state.selection.head
+			};
+		},
+		undo: () => history("undo"),
+		redo: () => history("redo"),
+		refuse
+	});
 	let isDestroying = false;
 	let requested = false;
 	let isInitialized = false;
@@ -212,31 +527,52 @@ const createHiddenEditorManager = (deps) => {
 		if (!host) return;
 		const collaboration = deps.getCollaboration();
 		const collaborationModules = deps.getCollaborationModules();
-		if (collaboration && !collaborationModules) return;
+		if (collaboration && !collaborationModules && !usesCanonicalSession(deps.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting)) return;
 		const precomputedInitialState = deps.getPrecomputedInitialState();
 		const document = deps.getDocument();
 		const styles = deps.getStyles();
 		const extensionManager = deps.getExtensionManager();
 		const externalPlugins = deps.getExternalPlugins();
+		input.reset();
+		if (!seedSession(document)) return;
 		const editorProps = {
-			state: precomputedInitialState && !collaboration ? precomputedInitialState : createHiddenEditorState({
-				document,
-				styles,
-				manager: extensionManager,
-				externalPlugins,
-				collaboration,
-				collaborationModules,
-				reason: "mount"
-			}),
+			state: (() => {
+				if (editorSession.type === "canonical") return canonicalState(editorSession.session);
+				if (precomputedInitialState && !collaboration) return precomputedInitialState;
+				return createHiddenEditorState({
+					document,
+					styles,
+					manager: extensionManager,
+					externalPlugins,
+					collaboration,
+					collaborationModules,
+					reason: "mount"
+				});
+			})(),
 			attributes: HIDDEN_EDITOR_ATTRIBUTES,
-			editable: () => !deps.getReadOnly(),
+			editable: () => !deps.getReadOnly() && editorSession.type !== "refused",
 			dispatchTransaction: (transaction) => {
 				if (!view || isDestroying) return;
 				if (deps.getReadOnly() && transaction.docChanged) {
 					deps.onReadOnlyEditAttempt();
 					return;
 				}
+				if (editorSession.type === "refused") return;
+				if (editorSession.type === "canonical" && transaction.docChanged) {
+					if (input.acceptComposition(view, transaction)) return;
+					if (!input.commitNativeProposal(view, transaction)) input.refuseNativeMutation(view);
+					view.updateState(view.state);
+					return;
+				}
+				if (editorSession.type === "canonical" && transaction.selectionSet && !input.isComposing) {
+					lastInputRule = void 0;
+					editorSession.session.breakUndoGroup();
+				}
 				const applied = view.state.applyTransaction(transaction);
+				if (editorSession.type === "canonical" && !applied.state.doc.eq(view.state.doc)) {
+					refuse("A plugin attempted an unclassified canonical document mutation.");
+					return;
+				}
 				view.updateState(applied.state);
 				const docChanged = applied.transactions.some((appliedTransaction) => appliedTransaction.docChanged);
 				const selectionChanged = applied.transactions.some((appliedTransaction) => appliedTransaction.selectionSet || appliedTransaction.docChanged);
@@ -256,20 +592,107 @@ const createHiddenEditorManager = (deps) => {
 					event.preventDefault();
 					return true;
 				}
+				if (editorSession.type === "canonical" && input.handleKeyDown(pmView, event)) return true;
 				return deps.onKeyDown(pmView, event);
 			},
+			handleTextInput: (pmView, from, to, text) => editorSession.type === "canonical" ? input.handleTextInput(pmView, from, to, text) : false,
+			handlePaste: (pmView, _event, slice) => {
+				if (editorSession.type !== "canonical") return false;
+				if (deps.getReadOnly()) {
+					deps.onReadOnlyEditAttempt();
+					return true;
+				}
+				syncCanonicalMode();
+				const prepared = prepareCanonicalPaste({
+					session: editorSession.session,
+					state: pmView.state,
+					slice
+				});
+				if (prepared.isErr()) {
+					if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+				} else publishCommit(prepared.value);
+				return true;
+			},
+			handleDrop: (pmView, event, slice, moved) => {
+				if (editorSession.type !== "canonical") return false;
+				if (deps.getReadOnly()) {
+					deps.onReadOnlyEditAttempt();
+					return true;
+				}
+				const target = pmView.posAtCoords({
+					left: event.clientX,
+					top: event.clientY
+				})?.pos;
+				if (target === void 0) {
+					refuse("The drop has no document destination.");
+					return true;
+				}
+				const captured = clipboardDrag;
+				clipboardDrag = { type: "idle" };
+				if (moved && (captured.type !== "dragging" || captured.session !== editorSession.session || captured.version !== editorSession.session.version)) {
+					refuse("The dragged content changed or has no captured source.");
+					return true;
+				}
+				const source = captured.type === "dragging" ? {
+					from: captured.from,
+					to: captured.to
+				} : pmView.state.selection;
+				if (moved && target >= source.from && target <= source.to) return true;
+				syncCanonicalMode();
+				const prepared = prepareCanonicalPaste({
+					session: editorSession.session,
+					state: pmView.state,
+					slice,
+					...moved ? {
+						moveTarget: target,
+						moveSource: {
+							from: source.from,
+							to: source.to
+						}
+					} : { pasteTarget: target }
+				});
+				if (prepared.isErr()) {
+					if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+				} else publishCommit(prepared.value);
+				return true;
+			},
 			handleScrollToSelection: suppressHiddenEditorScrollToSelection,
 			handleDOMEvents: {
+				keydown: (pmView, event) => editorSession.type === "canonical" ? input.handleDOMEvents.keydown(pmView, event) : false,
 				focus: () => false,
-				blur: () => false,
+				blur: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.blur(pmView) : false,
 				...createHiddenEditorClipboardHandlers(deps),
+				compositionstart: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.compositionstart(pmView) : false,
+				compositionend: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.compositionend(pmView) : false,
+				input: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.input(pmView) : false,
+				paste: (pmView, event) => {
+					if (editorSession.type === "canonical" && !deps.getReadOnly()) return input.handleDOMEvents.paste(pmView, event);
+					return createHiddenEditorClipboardHandlers(deps).paste(pmView, event);
+				},
+				cut: (pmView, event) => editorSession.type === "canonical" ? input.handleDOMEvents.cut(pmView, event) : createHiddenEditorClipboardHandlers(deps).cut(pmView, event),
 				beforeinput: (_view, event) => {
+					if (editorSession.type === "canonical" && !deps.getReadOnly()) return input.handleDOMEvents.beforeinput(_view, event);
 					if (!deps.getReadOnly()) return false;
 					deps.onReadOnlyEditAttempt();
 					event.preventDefault();
 					return true;
 				},
+				dragstart: (pmView) => {
+					if (editorSession.type === "canonical") clipboardDrag = {
+						type: "dragging",
+						session: editorSession.session,
+						version: editorSession.session.version,
+						from: pmView.state.selection.from,
+						to: pmView.state.selection.to
+					};
+					return false;
+				},
+				dragend: () => {
+					clipboardDrag = { type: "idle" };
+					return false;
+				},
 				drop: (_view, event) => {
+					if (editorSession.type === "canonical" && !deps.getReadOnly()) return input.handleDOMEvents.drop(_view, event);
 					if (!deps.getReadOnly()) return false;
 					deps.onReadOnlyEditAttempt();
 					event.preventDefault();
@@ -279,6 +702,26 @@ const createHiddenEditorManager = (deps) => {
 		};
 		const viewStartedAt = performance.now();
 		view = new EditorView(host, editorProps);
+		if (editorSession.type === "canonical") registerClipboardIntentHandler(view, (slice, plain) => {
+			if (!view || editorSession.type !== "canonical") return false;
+			if (deps.getReadOnly()) {
+				deps.onReadOnlyEditAttempt();
+				return false;
+			}
+			syncCanonicalMode();
+			const prepared = prepareCanonicalPaste({
+				session: editorSession.session,
+				state: view.state,
+				slice,
+				plain
+			});
+			if (prepared.isErr()) {
+				if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+				return false;
+			}
+			return publishCommit(prepared.value);
+		});
+		releaseCommandOwner = registerEditorCommandOwner(view, executeCanonicalCommand);
 		recordHiddenEditorPhase("mount", "editor-view", performance.now() - viewStartedAt);
 		syncHiddenEditorAccessibility(view, deps.getReadOnly());
 		isInitialized = true;
@@ -298,8 +741,11 @@ const createHiddenEditorManager = (deps) => {
 		if (view && !isDestroying) {
 			isDestroying = true;
 			deps.onEditorViewDestroy();
+			releaseCommandOwner?.();
+			releaseCommandOwner = void 0;
 			view.destroy();
 			view = null;
+			input.reset();
 			isDestroying = false;
 		}
 	};
@@ -307,17 +753,23 @@ const createHiddenEditorManager = (deps) => {
 		if (!view || isDestroying) return;
 		const collaboration = deps.getCollaboration();
 		const collaborationModules = deps.getCollaborationModules();
-		if (collaboration && !collaborationModules) return;
+		if (collaboration && !collaborationModules && !usesCanonicalSession(deps.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting)) return;
 		const document = deps.getDocument();
 		const currentDocId = deps.getDocumentIdentity();
 		const currentCollaborationFragment = collaboration?.yXmlFragment ?? null;
 		const collaborationSourceChanged = currentCollaborationFragment !== lastCollaborationFragment;
-		if (collaboration && !collaborationSourceChanged) return;
-		if (isInitialized && currentDocId === lastDocumentId && !collaborationSourceChanged) return;
+		const sessionChanged = editorSession.type !== "prosemirror" !== usesCanonicalSession(deps.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting);
+		if (collaboration && !collaborationSourceChanged && !sessionChanged) return;
+		if (isInitialized && currentDocId === lastDocumentId && !collaborationSourceChanged && !sessionChanged) return;
+		input.reset();
+		if (!seedSession(document)) {
+			destroyView();
+			return;
+		}
 		isInitialized = true;
 		lastDocumentId = currentDocId;
 		lastCollaborationFragment = currentCollaborationFragment;
-		const newState = createHiddenEditorState({
+		const newState = editorSession.type === "canonical" ? canonicalState(editorSession.session) : createHiddenEditorState({
 			document,
 			styles: deps.getStyles(),
 			manager: deps.getExtensionManager(),
@@ -336,6 +788,57 @@ const createHiddenEditorManager = (deps) => {
 		if (!view) return;
 		syncHiddenEditorAccessibility(view, deps.getReadOnly());
 	};
+	const publishStoryCommit = (storyView, commit) => {
+		if (!view || editorSession.type !== "canonical") return false;
+		if (deps.getEditingMode?.() === "suggesting") {
+			refuse("Suggesting is unavailable in the experimental canonical session.", CANONICAL_GAP.suggesting);
+			return false;
+		}
+		const session = editorSession.session;
+		const bodyTransaction = view.state.tr;
+		if (!bodyTransaction.doc.eq(commit.bodyProjection.doc)) bodyTransaction.replaceWith(0, bodyTransaction.doc.content.size, commit.bodyProjection.doc.content);
+		markPackageChange(bodyTransaction);
+		bodyTransaction.setMeta("addToHistory", false);
+		const bodyStaged = Result.try(() => view?.state.applyTransaction(bodyTransaction));
+		if (bodyStaged.isErr() || !bodyStaged.value || !bodyStaged.value.transactions.includes(bodyTransaction) || !bodyStaged.value.state.doc.eq(commit.bodyProjection.doc) || bodyStaged.value.transactions.some((transaction) => transaction !== bodyTransaction && transaction.docChanged)) {
+			refuse("A plugin refused or changed the canonical body projection.");
+			return false;
+		}
+		const staged = publishCanonicalProjection({
+			state: storyView.state,
+			commit,
+			session
+		});
+		if (staged.isErr()) {
+			refuse(staged.error.message, staged.error.gap);
+			return false;
+		}
+		storyView.updateState(staged.value.state);
+		view.updateState(bodyStaged.value.state);
+		deps.onTransaction({
+			transactions: staged.value.transactions,
+			newState: view.state,
+			docChanged: true
+		});
+		deps.onSelectionChange(view.state);
+		return true;
+	};
+	let publicOperations = null;
+	const getPublicOperations = () => {
+		if (editorSession.type !== "canonical") return null;
+		const session = editorSession.session;
+		if (publicOperations?.session === session) return publicOperations.executor;
+		const executor = new CanonicalPublicOperations({
+			session,
+			getState: (story) => story === OP_STORIES.MAIN && !deps.getReadOnly() && !isDestroying ? view?.state ?? null : null,
+			publish: publishCommit
+		});
+		publicOperations = {
+			session,
+			executor
+		};
+		return executor;
+	};
 	return {
 		ensureView,
 		retryViewCreation,
@@ -347,7 +850,112 @@ const createHiddenEditorManager = (deps) => {
 		isInitialized: () => isInitialized,
 		api: createHiddenEditorApi({
 			getView: () => view,
-			getDocumentContext: deps.getDocumentContext,
+			getDocumentContext: () => editorSession.type === "refused" ? null : deps.getDocumentContext(),
+			isCanonicalSaveCurrent: (version) => editorSession.type === "canonical" && !editorSession.session.isComposing && editorSession.session.version === version,
+			captureCanonicalSave: () => editorSession.type === "canonical" ? editorSession.session.captureSaveSnapshot() : null,
+			getCanonicalDocument: () => editorSession.type === "canonical" ? editorSession.session.document : null,
+			setCanonicalMode: (mode) => {
+				if (editorSession.type !== "canonical") return false;
+				modeOverride = mode;
+				syncCanonicalMode();
+				return true;
+			},
+			resolveCanonicalRevisions: (revisionIds, resolution) => {
+				if (!view || deps.getReadOnly() || editorSession.type !== "canonical") return false;
+				const prepared = editorSession.session.prepareResolve(view.state, {
+					revisionIds,
+					resolution
+				});
+				if (prepared.isErr()) {
+					if (prepared.error.reason !== "noChange") refuse(prepared.error.message, prepared.error.gap);
+					return false;
+				}
+				return publishCommit(prepared.value);
+			},
+			executeCanonicalCommand,
+			getCanonicalHistory: () => editorSession.type === "canonical" ? {
+				undo: () => history("undo"),
+				redo: () => history("redo"),
+				canUndo: () => editorSession.type === "canonical" && editorSession.session.canUndo,
+				canRedo: () => editorSession.type === "canonical" && editorSession.session.canRedo
+			} : null,
+			canonicalOperations: {
+				applyCanonicalDocumentOperations: (options) => {
+					ensureView();
+					return getPublicOperations()?.apply(options) ?? null;
+				},
+				undoCanonicalDocumentOperations: (handle) => getPublicOperations()?.undo(handle) ?? null,
+				updateCanonicalInputLifecycle: (action) => {
+					if (editorSession.type !== "canonical") return false;
+					switch (action) {
+						case "beginComposition": return canonicalInputLifecycle.beginComposition();
+						case "endComposition":
+							canonicalInputLifecycle.endComposition();
+							return true;
+						case "breakUndoGroup":
+							canonicalInputLifecycle.breakUndoGroup();
+							return true;
+					}
+				},
+				getCanonicalStorySelection: (story) => {
+					if (editorSession.type !== "canonical") return null;
+					const session = editorSession.session;
+					const selection = session.selection;
+					if (!selection) return null;
+					const projection = session.projectStory(story);
+					if (projection.isErr()) return null;
+					const anchor = projection.value.positionAt(selection.anchor);
+					const head = projection.value.positionAt(selection.head);
+					return anchor.isOk() && head.isOk() ? {
+						anchor: anchor.value,
+						head: head.value
+					} : null;
+				},
+				applyCanonicalStoryHistory: ({ view: storyView, story, direction }) => {
+					if (story === OP_STORIES.MAIN && storyView === view) return history(direction);
+					if (!view || editorSession.type !== "canonical" || deps.getReadOnly()) return false;
+					const session = editorSession.session;
+					if (direction === "undo" ? !session.canUndo : !session.canRedo) return false;
+					const prepared = direction === "undo" ? session.prepareUndo(storyView.state, story) : session.prepareRedo(storyView.state, story);
+					if (prepared.isErr()) {
+						refuse(prepared.error.message, prepared.error.gap);
+						return false;
+					}
+					return publishStoryCommit(storyView, prepared.value);
+				},
+				applyCanonicalOperations: (ops) => {
+					ensureView();
+					if (!view || editorSession.type !== "canonical" || deps.getReadOnly()) return false;
+					const prepared = editorSession.session.prepareOperations(view.state, ops);
+					if (prepared.isErr()) {
+						refuse(prepared.error.message, prepared.error.gap);
+						return false;
+					}
+					return publishCommit(prepared.value);
+				},
+				getCanonicalStoryProjection: (story) => {
+					if (usesCanonicalSession(deps.getExperimentalSession?.(), CANONICAL_GAP.authorityRouting)) ensureView();
+					if (editorSession.type !== "canonical" || editorSession.session.isComposing) return null;
+					const result = editorSession.session.projectStory(story);
+					if (result.isErr()) {
+						refuse(result.error.message, result.error.gap);
+						return null;
+					}
+					return result.value.doc;
+				},
+				replaceCanonicalStoryText: ({ view: storyView, story, intent }) => {
+					if (!view || editorSession.type !== "canonical" || deps.getReadOnly()) return false;
+					const prepared = editorSession.session.prepareReplace(storyView.state, {
+						...intent,
+						story
+					});
+					if (prepared.isErr()) {
+						refuse(prepared.error.message, prepared.error.gap);
+						return false;
+					}
+					return publishStoryCommit(storyView, prepared.value);
+				}
+			},
 			isDestroying: () => isDestroying,
 			ensureView,
 			isViewRequested
@@ -355,4 +963,4 @@ const createHiddenEditorManager = (deps) => {
 	};
 };
 //#endregion
-export { collectRemoteSelections, createHiddenEditorClipboardHandlers, createHiddenEditorManager, createHiddenEditorState };
+export { CanonicalSessionRefusalError, collectRemoteSelections, createHiddenEditorClipboardHandlers, createHiddenEditorManager, createHiddenEditorState };