@stll/folio-core 0.54.2 → 0.55.0

package/dist/controller/hiddenEditorManager.js

@@ -1,30 +1,28 @@
 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 { 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 { createCanonicalInputBoundary } from "./canonicalInput.js";
+import { createCanonicalSession, publishCanonicalProjection } from "./canonicalSession.js";
+import { prepareCanonicalAutoformat, prepareCanonicalCommands } from "./canonicalStructure.js";
 import { createHiddenEditorApi } from "./hiddenEditorApi.js";
-import { panic } from "better-result";
+import { Result, TaggedError, panic } from "better-result";
+import { OP_STORIES } from "@stll/docx-core/ops";
 import { EditorState } 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 +199,260 @@ 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) => {
+		if (deps.onSessionRefusal) deps.onSessionRefusal(reason);
+		else throw new CanonicalSessionRefusalError({ message: reason });
+	};
+	const seedSession = (document) => {
+		if (deps.getExperimentalSession?.() !== "canonical") {
+			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);
+			return false;
+		}
+		const result = createCanonicalSession(document, deps.getStyles());
+		if (result.isErr()) {
+			editorSession = {
+				type: "refused",
+				reason: result.error.message,
+				documentIdentity
+			};
+			refuse(result.error.message);
+			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)
+		]
+	});
+	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);
+			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);
+			return false;
+		}
+		return publishCommit(prepared.value);
+	};
+	const executeCanonicalCommand = (command) => {
+		if (!view || editorSession.type !== "canonical") return void 0;
+		if (deps.getReadOnly()) return false;
+		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);
+			return false;
+		}
+		return publishCommit(prepared.value);
+	};
+	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.");
+				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);
+				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);
+						return;
+					}
+					if (to.isErr()) {
+						refuse(to.error.message);
+						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);
+				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);
+				return false;
+			}
+			return true;
+		},
+		endComposition: () => {
+			if (editorSession.type === "canonical") editorSession.session.endComposition();
+		}
+	};
+	const input = createCanonicalInputBoundary({
+		...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);
+				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 +464,52 @@ const createHiddenEditorManager = (deps) => {
 		if (!host) return;
 		const collaboration = deps.getCollaboration();
 		const collaborationModules = deps.getCollaborationModules();
-		if (collaboration && !collaborationModules) return;
+		if (collaboration && !collaborationModules && deps.getExperimentalSession?.() !== "canonical") return;
 		const precomputedInitialState = deps.getPrecomputedInitialState();
 		const document = deps.getDocument();
 		const styles = deps.getStyles();
 		const extensionManager = deps.getExtensionManager();
 		const externalPlugins = deps.getExternalPlugins();
+		if (!seedSession(document)) return;
+		input.reset();
 		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 +529,30 @@ 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,
 			handleScrollToSelection: suppressHiddenEditorScrollToSelection,
 			handleDOMEvents: {
 				focus: () => false,
-				blur: () => false,
+				blur: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.blur(pmView) : false,
 				...createHiddenEditorClipboardHandlers(deps),
+				mousedown: (pmView) => editorSession.type === "canonical" ? input.handleDOMEvents.mousedown(pmView) : false,
+				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) => editorSession.type === "canonical" ? input.handleDOMEvents.paste(pmView, event) : 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;
 				},
 				drop: (_view, event) => {
+					if (editorSession.type === "canonical") return input.handleDOMEvents.drop(_view, event);
 					if (!deps.getReadOnly()) return false;
 					deps.onReadOnlyEditAttempt();
 					event.preventDefault();
@@ -279,6 +562,7 @@ const createHiddenEditorManager = (deps) => {
 		};
 		const viewStartedAt = performance.now();
 		view = new EditorView(host, editorProps);
+		releaseCommandOwner = registerEditorCommandOwner(view, executeCanonicalCommand);
 		recordHiddenEditorPhase("mount", "editor-view", performance.now() - viewStartedAt);
 		syncHiddenEditorAccessibility(view, deps.getReadOnly());
 		isInitialized = true;
@@ -298,8 +582,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 +594,23 @@ const createHiddenEditorManager = (deps) => {
 		if (!view || isDestroying) return;
 		const collaboration = deps.getCollaboration();
 		const collaborationModules = deps.getCollaborationModules();
-		if (collaboration && !collaborationModules) return;
+		if (collaboration && !collaborationModules && deps.getExperimentalSession?.() !== "canonical") 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" !== (deps.getExperimentalSession?.() === "canonical");
+		if (collaboration && !collaborationSourceChanged && !sessionChanged) return;
+		if (isInitialized && currentDocId === lastDocumentId && !collaborationSourceChanged && !sessionChanged) return;
+		if (!seedSession(document)) {
+			destroyView();
+			return;
+		}
+		input.reset();
 		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 +629,41 @@ 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.");
+			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);
+			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;
+	};
 	return {
 		ensureView,
 		retryViewCreation,
@@ -347,7 +675,105 @@ const createHiddenEditorManager = (deps) => {
 		isInitialized: () => isInitialized,
 		api: createHiddenEditorApi({
 			getView: () => view,
-			getDocumentContext: deps.getDocumentContext,
+			getDocumentContext: () => editorSession.type === "refused" ? null : deps.getDocumentContext(),
+			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);
+					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: {
+				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);
+						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);
+						return false;
+					}
+					return publishCommit(prepared.value);
+				},
+				getCanonicalStoryProjection: (story) => {
+					if (deps.getExperimentalSession?.() === "canonical") ensureView();
+					if (editorSession.type !== "canonical" || editorSession.session.isComposing) return null;
+					const result = editorSession.session.projectStory(story);
+					if (result.isErr()) {
+						refuse(result.error.message);
+						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);
+						return false;
+					}
+					return publishStoryCommit(storyView, prepared.value);
+				}
+			},
 			isDestroying: () => isDestroying,
 			ensureView,
 			isViewRequested
@@ -355,4 +781,4 @@ const createHiddenEditorManager = (deps) => {
 	};
 };
 //#endregion
-export { collectRemoteSelections, createHiddenEditorClipboardHandlers, createHiddenEditorManager, createHiddenEditorState };
+export { CanonicalSessionRefusalError, collectRemoteSelections, createHiddenEditorClipboardHandlers, createHiddenEditorManager, createHiddenEditorState };

package/dist/controller/layoutPipeline.d.ts

@@ -1,9 +1,9 @@
 import { document_d_exports } from "../types/document.js";
 import { TemplatePreviewEntry, TemplatePreviewHiddenRange } from "../prosemirror/plugins/templatePreviewValues.js";
 import { ColumnLayout, FlowBlock, FootnoteContent, HeaderFooterContent, Layout, Measure, PageHeaderFooterRefs, PageMargins } from "../layout-engine/types.js";
+import { LayoutRunOptions } from "./layoutRunOptions.js";
 import { DisplayMode } from "../managers/EditorModeManager.js";
 import { LayoutSession } from "./layoutSession.js";
-import { LayoutRunOptions } from "./layoutRunOptions.js";
 import { HyphenationReadiness } from "./hyphenationReadiness.js";
 import { ConvertHeaderFooterOptions, HeaderFooterMetrics } from "../layout-bridge/convert/headerFooterLayout.js";
 import "../layout-engine/index.js";

package/dist/controller/layoutPipeline.js

@@ -244,6 +244,7 @@ function runLayoutPipelineMeasured(deps, state, options) {
 			const hfMeasureBlocks = (hfBlocks, hfWidth) => measureBlocks(hfBlocks, hfWidth, void 0, void 0, buildHeaderFooterFieldValues(hfBlocks, pageCount, hfClock, fieldInputs), { allowEndTabOverflow: true });
 			return {
 				...flowOpts.styles ? { styles: flowOpts.styles } : {},
+				...document?.package.numbering === void 0 ? {} : { numbering: document.package.numbering },
 				...flowOpts.defaultSize === void 0 ? {} : { defaultSize: flowOpts.defaultSize },
 				..._theme !== void 0 ? { theme: _theme } : {},
 				fontAlternates,
@@ -377,6 +378,7 @@ function runLayoutPipelineMeasured(deps, state, options) {
 			if (flowOpts.styles) noteOptions.styles = flowOpts.styles;
 			if (flowOpts.defaultSize !== void 0) noteOptions.defaultSize = flowOpts.defaultSize;
 			if (_theme !== void 0) noteOptions.theme = _theme;
+			if (document?.package.numbering !== void 0) noteOptions.numbering = document.package.numbering;
 			noteOptions.fontAlternates = fontAlternates;
 			if (defaultTabStop !== void 0) noteOptions.defaultTabStopTwips = defaultTabStop;
 			if (flowOpts.lineBreakRules) noteOptions.lineBreakRules = flowOpts.lineBreakRules;

package/dist/controller/noteEditorManager.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../types/document.js";
+import { HiddenEditorApi } from "./hiddenEditorApi.js";
 import { NoteStoryKey } from "../types/editor-story.js";
 import { Plugin } from "prosemirror-state";
 import { DirectEditorProps, EditorView } from "prosemirror-view";
@@ -12,6 +13,9 @@ type NoteEditorTransaction = NoteStoryKey & {
 type NoteEditorManagerDeps = {
   createView?: ((mountNode: HTMLElement, props: DirectEditorProps) => EditorView) | undefined;
   getDocument: () => document_d_exports.Document | null;
+  getCanonicalApi?: (() => HiddenEditorApi | null) | undefined;
+  getExperimentalSession?: (() => "canonical" | undefined) | undefined;
+  onSessionRefusal?: ((reason: string) => void) | undefined;
   getHost: () => HTMLElement | null;
   getPlugins?: (() => Plugin[]) | undefined;
   getStyles: () => document_d_exports.StyleDefinitions | null | undefined;