@stll/folio-core 0.54.2 → 0.55.0

package/dist/ai-edits/apply.js

@@ -1485,6 +1485,22 @@ const finalParagraphPredecessor = (doc, at) => {
 	}
 	return null;
 };
+/**
+* Whether a sibling between a final carrier's predecessor and the carrier
+* has its break deleted by this batch.
+*/
+const crossesBatchDeletion = ({ doc, from, to, batchRevisionIds }) => {
+	const $to = doc.resolve(to);
+	let position = to;
+	for (let index = $to.index() - 1; index >= 0 && position > from; index--) {
+		const node = $to.parent.child(index);
+		position -= node.nodeSize;
+		const mark = node.attrs["pPrMark"];
+		const revisionId = isPlainDeletedPPrMark(mark) ? addedOrDeletedBreakRevisionId(mark) : null;
+		if (revisionId !== null && batchRevisionIds.has(revisionId)) return true;
+	}
+	return false;
+};
 /** Pending retirements, read after the merge has mapped any inserted separator. */
 const pendingRemovedFinalBreakPositions = (tr, deletions) => {
 	const positions = /* @__PURE__ */ new Set();
@@ -1569,7 +1585,12 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 					date,
 					...revisionExtras
 				},
-				keep: propertiesSetInBatch(emptied, batchRevisionIds)
+				keep: crossesBatchDeletion({
+					doc: tr.doc,
+					from: position + previous.nodeSize,
+					to: at,
+					batchRevisionIds
+				}) ? /* @__PURE__ */ new Set() : propertiesSetInBatch(emptied, batchRevisionIds)
 			});
 			resolvedOperationIds.add(operationId);
 			addedRevisions.push({

package/dist/ai-edits/headless.js

@@ -1895,6 +1895,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const source = story.type === "header" || story.type === "footer" ? this.getHeaderFooterStory(story) : this.getNoteStory(story);
 		if (!source) return null;
 		const conversionOptions = {
+			...this.baseDocument.package.numbering !== void 0 && { numbering: this.baseDocument.package.numbering },
 			...this.baseDocument.package.styles !== void 0 && { styles: this.baseDocument.package.styles },
 			...this.baseDocument.package.theme !== void 0 && { theme: this.baseDocument.package.theme }
 		};

package/dist/compare/content-types.d.ts

@@ -83,14 +83,9 @@ type FolioContentTableLocation = {
  */
 type FolioContentParagraphAlignment = document_d_exports.ParagraphAlignment;
 /** Line-height interpretation understood by the neutral comparison model. */
-type FolioContentLineSpacingRule = "auto" | "exact" | "atLeast";
+type FolioContentLineSpacingRule = NonNullable<document_d_exports.ParagraphFormatting["lineSpacingRule"]>;
 /** The complete modeled attribute set of direct paragraph indentation. */
-type FolioContentParagraphIndentation = {
-  indentLeft?: number;
-  indentRight?: number;
-  indentFirstLine?: number;
-  hangingIndent?: boolean;
-};
+type FolioContentParagraphIndentation = Pick<document_d_exports.ParagraphFormatting, "indentLeft" | "indentRight" | "indentFirstLine" | "hangingIndent">;
 /** A concrete numbering instance and its zero-based level. */
 type FolioContentListReference = {
   numId: number;
@@ -100,14 +95,7 @@ type FolioContentListReference = {
  * The complete modeled attribute set of direct paragraph spacing. Optional
  * fields distinguish an absent attribute from an explicit zero or false value.
  */
-type FolioContentParagraphSpacing = {
-  spaceBefore?: number;
-  spaceAfter?: number;
-  lineSpacing?: number;
-  lineSpacingRule?: FolioContentLineSpacingRule;
-  beforeAutospacing?: boolean;
-  afterAutospacing?: boolean;
-};
+type FolioContentParagraphSpacing = Pick<document_d_exports.ParagraphFormatting, "spaceBefore" | "spaceAfter" | "lineSpacing" | "lineSpacingRule" | "beforeAutospacing" | "afterAutospacing">;
 /** A representation-neutral block in one ordered document story. */
 type FolioContentBlock<Kind extends string = string> = {
   id: string;

package/dist/controller/canonicalComposition.d.ts

@@ -0,0 +1,36 @@
+import { EditorState, Transaction } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+//#region src/controller/canonicalComposition.d.ts
+type CompositionOptions = {
+  begin: () => boolean;
+  end: () => void;
+  replace: (input: {
+    from: number;
+    to: number;
+    text: string;
+    semantic: "composition";
+  }) => void;
+  refuse: (reason: string) => void;
+};
+type CompositionState = {
+  type: "committed";
+} | {
+  type: "provisional" | "refused";
+  baseline: EditorState;
+  phase: "active" | "ended";
+};
+/** Native IME owns the provisional view; the captured canonical projection stays unchanged. */
+declare const createCanonicalComposition: (options: CompositionOptions) => {
+  readonly status: CompositionState["type"];
+  readonly active: boolean;
+  start: (view: EditorView) => void;
+  ended: (view: EditorView) => void;
+  authorizeNative: (view: EditorView) => void;
+  flushed: (view: EditorView) => void;
+  recover: (view: EditorView) => void;
+  cancel: (view: EditorView) => void;
+  reset: () => void;
+  accept: (view: EditorView, transaction: Transaction) => boolean;
+};
+//#endregion
+export { createCanonicalComposition };

package/dist/controller/canonicalComposition.js

@@ -0,0 +1,168 @@
+import { splitsSurrogatePair } from "../ai-edits/character-boundaries.js";
+import { CanonicalSessionError } from "./canonicalSession.js";
+import { Result } from "better-result";
+//#region src/controller/canonicalComposition.ts
+const COMPOSITION_FLUSH_DELAY_MS = 25;
+/** Native IME owns the provisional view; the captured canonical projection stays unchanged. */
+const createCanonicalComposition = (options) => {
+	let state = { type: "committed" };
+	let authorizedNativeState = null;
+	let timer;
+	const clearTimer = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const replacement = (baseline, proposed) => {
+		const { $from, $to } = baseline.selection;
+		if (!$from.parent.isTextblock || !$to.parent.isTextblock) return null;
+		if (!$from.sameParent($to)) {
+			const from = baseline.selection.from;
+			const to = baseline.selection.to;
+			const insertedSize = proposed.doc.content.size - (baseline.doc.content.size - (to - from));
+			if (insertedSize < 0 || from + insertedSize > proposed.doc.content.size) return null;
+			const text = proposed.doc.textBetween(from, from + insertedSize, "", "");
+			if (text.length !== insertedSize) return null;
+			if (!baseline.tr.insertText(text, from, to).doc.eq(proposed.doc)) return null;
+			return {
+				from,
+				to,
+				text,
+				semantic: "composition"
+			};
+		}
+		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;
+		while (oldEnd > from && newEnd > from && before[oldEnd - 1] === after[newEnd - 1]) {
+			oldEnd--;
+			newEnd--;
+		}
+		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;
+		return {
+			from: start + from,
+			to: start + oldEnd,
+			text,
+			semantic: "composition"
+		};
+	};
+	const finish = (view, commit) => {
+		clearTimer();
+		authorizedNativeState = null;
+		const pending = state;
+		if (pending.type === "committed") return;
+		const input = commit && pending.type === "provisional" ? replacement(pending.baseline, view.state) : null;
+		state = { type: "committed" };
+		if (!view.isDestroyed) view.updateState(pending.baseline);
+		options.end();
+		if (!commit || view.isDestroyed || pending.type === "refused") return;
+		if (input?.from === input?.to && input?.text === "") return;
+		if (!input) {
+			options.refuse("Composition changed unsupported content; the canonical document was restored.");
+			return;
+		}
+		options.replace(input);
+	};
+	const schedule = (view) => {
+		clearTimer();
+		timer = setTimeout(() => finish(view, true), COMPOSITION_FLUSH_DELAY_MS);
+	};
+	return {
+		get status() {
+			return state.type;
+		},
+		get active() {
+			return state.type !== "committed";
+		},
+		start: (view) => {
+			if (state.type !== "committed") return;
+			if (!options.begin()) return;
+			state = {
+				type: "provisional",
+				baseline: view.state,
+				phase: "active"
+			};
+		},
+		ended: (view) => {
+			if (state.type === "committed") return;
+			state = {
+				type: state.type,
+				baseline: state.baseline,
+				phase: "ended"
+			};
+			schedule(view);
+		},
+		authorizeNative: (view) => {
+			authorizedNativeState = view.state;
+		},
+		flushed: (view) => {
+			const authorized = authorizedNativeState;
+			queueMicrotask(() => {
+				if (authorizedNativeState === authorized) authorizedNativeState = null;
+			});
+			if (state.type !== "committed" && state.phase === "ended") schedule(view);
+		},
+		recover: (view) => finish(view, true),
+		cancel: (view) => finish(view, false),
+		reset: () => {
+			clearTimer();
+			authorizedNativeState = null;
+			if (state.type !== "committed") options.end();
+			state = { type: "committed" };
+		},
+		accept: (view, transaction) => {
+			if (state.type === "committed") return false;
+			if (state.type === "refused") {
+				view.updateState(state.baseline);
+				return true;
+			}
+			if (typeof transaction.getMeta("composition") !== "number" && authorizedNativeState !== view.state) {
+				options.refuse("Other edits must wait until composition finishes.");
+				return true;
+			}
+			authorizedNativeState = null;
+			const applied = Result.try({
+				try: () => view.state.applyTransaction(transaction),
+				catch: (cause) => new CanonicalSessionError({
+					reason: "refused",
+					message: `Composition projection failed: ${String(cause)}`
+				})
+			});
+			if (applied.isErr()) {
+				view.updateState(state.baseline);
+				state = {
+					type: "refused",
+					baseline: state.baseline,
+					phase: state.phase
+				};
+				options.refuse(applied.error.message);
+				return true;
+			}
+			if (!replacement(state.baseline, applied.value.state)) {
+				view.updateState(state.baseline);
+				state = {
+					type: "refused",
+					baseline: state.baseline,
+					phase: state.phase
+				};
+				options.refuse("Composition changed unsupported content; the canonical document was restored.");
+				return true;
+			}
+			view.updateState(applied.value.state);
+			return true;
+		}
+	};
+};
+//#endregion
+export { createCanonicalComposition };

package/dist/controller/canonicalInput.d.ts

@@ -0,0 +1,45 @@
+import { EditorState, Transaction } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+//#region src/controller/canonicalInput.d.ts
+type ReplaceTextInput = {
+  from: number;
+  to: number;
+  text: string;
+  semantic?: "typing" | "deleteBackward" | "deleteForward" | "composition";
+};
+type CanonicalInputOptions = {
+  replace: (input: ReplaceTextInput) => void;
+  structure?: (type: "split" | "joinBackward" | "joinForward" | "lineBreak" | "pageBreak" | "tab" | "indent" | "outdent") => void;
+  command?: (name: "toggleBold" | "toggleItalic" | "toggleUnderline") => void;
+  breakUndoGroup?: () => void;
+  beginComposition?: () => boolean;
+  endComposition?: () => void;
+  undo: () => boolean;
+  redo: () => boolean;
+  refuse: (reason: string) => void;
+};
+/** Native changes require a preceding, classified input event at the same state. */
+declare const createCanonicalInputBoundary: (options: CanonicalInputOptions) => {
+  reset: () => void;
+  readonly isComposing: boolean;
+  acceptComposition: (view: EditorView, transaction: Transaction) => boolean;
+  handleTextInput: (view: EditorView, from: number, to: number, text: string) => boolean;
+  handleKeyDown: (view: EditorView, event: KeyboardEvent) => boolean;
+  handleDOMEvents: {
+    compositionstart: (view: EditorView) => boolean;
+    compositionend: (view: EditorView) => boolean;
+    mousedown: (view: EditorView) => boolean;
+    blur: (view: EditorView) => boolean;
+    beforeinput: (view: EditorView, event: InputEvent) => boolean;
+    input: (view: EditorView) => boolean;
+    paste: (_view: EditorView, event: Event) => boolean;
+    cut: (_view: EditorView, event: Event) => boolean;
+    drop: (_view: EditorView, event: Event) => boolean;
+  };
+  /** Returns a classified intent only; the proposed PM document is never authoritative. */
+  takeNativeProposal: (state: EditorState, transaction: Transaction) => ReplaceTextInput | null;
+  refuseNativeMutation: (view: EditorView) => void;
+  commitNativeProposal: (view: EditorView, transaction: Transaction) => boolean;
+};
+//#endregion
+export { createCanonicalInputBoundary };

package/dist/controller/canonicalInput.js

@@ -0,0 +1,338 @@
+import { handleEditorBeforeInput } from "../prosemirror/textInput.js";
+import { createCanonicalComposition } from "./canonicalComposition.js";
+import { deletionRange, isCanonicalJoinBoundary } from "./canonicalSession.js";
+import { ReplaceStep } from "prosemirror-transform";
+import { Selection, TextSelection } from "prosemirror-state";
+//#region src/controller/canonicalInput.ts
+/** Native changes require a preceding, classified input event at the same state. */
+const createCanonicalInputBoundary = (options) => {
+	const composition = createCanonicalComposition({
+		begin: () => options.beginComposition?.() ?? true,
+		end: () => options.endComposition?.(),
+		replace: options.replace,
+		refuse: options.refuse
+	});
+	let proposal = { type: "idle" };
+	let authorizedInput = null;
+	let groupClosed = false;
+	const beginGesture = () => {
+		proposal = { type: "idle" };
+		authorizedInput = null;
+		groupClosed = false;
+	};
+	const closeGroup = () => {
+		if (groupClosed) return;
+		groupClosed = true;
+		options.breakUndoGroup?.();
+	};
+	const repaint = (view) => {
+		queueMicrotask(() => {
+			if (!view.isDestroyed) view.updateState(view.state);
+		});
+	};
+	const refuseEvent = (event, reason) => {
+		event.preventDefault();
+		closeGroup();
+		if (!composition.active && proposal.type !== "refused") options.refuse(reason);
+		if (!composition.active) proposal = { type: "refused" };
+		return true;
+	};
+	const refuseNativeMutation = (view) => {
+		if (!composition.active && proposal.type !== "refused") {
+			options.refuse("Unclassified native text is unavailable in this session.");
+			proposal = { type: "refused" };
+		}
+		repaint(view);
+	};
+	const takeNativeProposal = (state, transaction) => {
+		const pending = proposal;
+		if (pending.type !== "replacement") return null;
+		proposal = { type: "idle" };
+		if (pending.state !== state || transaction.steps.length !== 1) return null;
+		const step = transaction.steps.at(0);
+		if (!(step instanceof ReplaceStep) || "structure" in step && step.structure === true || step.from !== pending.input.from || step.to !== pending.input.to) return null;
+		if (step.slice.openStart !== 0 || step.slice.openEnd !== 0) return null;
+		let text = "";
+		let plain = true;
+		step.slice.content.forEach((node) => {
+			if (!node.isText) plain = false;
+			text += node.text ?? "";
+		});
+		if (!plain || text !== pending.input.text) return null;
+		return state.tr.insertText(text, step.from, step.to).doc.eq(transaction.doc) ? pending.input : null;
+	};
+	return {
+		reset: () => {
+			proposal = { type: "idle" };
+			authorizedInput = null;
+			composition.reset();
+		},
+		get isComposing() {
+			return composition.active;
+		},
+		acceptComposition: composition.accept,
+		handleTextInput: (view, from, to, text) => {
+			if (composition.active) return false;
+			const pending = proposal;
+			if (authorizedInput?.view === view && authorizedInput.state === view.state) {
+				options.replace({
+					from,
+					to,
+					text,
+					semantic: "typing"
+				});
+				return true;
+			}
+			if (pending.type === "replacement" && pending.state === view.state && pending.input.from === from && pending.input.to === to && pending.input.text === text) {
+				proposal = { type: "idle" };
+				options.replace(pending.input);
+				return true;
+			}
+			refuseNativeMutation(view);
+			return true;
+		},
+		handleKeyDown: (view, event) => {
+			beginGesture();
+			if (composition.active) {
+				if (event.key === "Escape") {
+					event.preventDefault();
+					composition.cancel(view);
+					return true;
+				}
+				if (event.metaKey || event.ctrlKey) {
+					event.preventDefault();
+					return true;
+				}
+				return false;
+			}
+			const modifier = event.metaKey || event.ctrlKey;
+			if (modifier || event.altKey || /^(?:Arrow|Home$|End$|Page|Escape$|Tab$)/u.test(event.key)) closeGroup();
+			if (modifier && event.key.toLowerCase() === "z") {
+				event.preventDefault();
+				if (event.shiftKey) options.redo();
+				else options.undo();
+				return true;
+			}
+			if (modifier && event.key.toLowerCase() === "y") {
+				event.preventDefault();
+				options.redo();
+				return true;
+			}
+			if (modifier && event.key.toLowerCase() === "a") {
+				event.preventDefault();
+				view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, Selection.atStart(view.state.doc).from, Selection.atEnd(view.state.doc).to)));
+				return true;
+			}
+			if (modifier && (event.key.toLowerCase() === "b" || event.key.toLowerCase() === "i" || event.key.toLowerCase() === "u") && options.command !== void 0) {
+				event.preventDefault();
+				switch (event.key.toLowerCase()) {
+					case "b":
+						options.command("toggleBold");
+						break;
+					case "i":
+						options.command("toggleItalic");
+						break;
+					case "u":
+						options.command("toggleUnderline");
+						break;
+				}
+				return true;
+			}
+			if (event.key === "Enter") {
+				if (view.composing) return refuseEvent(event, "Paragraph structure edits are unavailable during composition.");
+				event.preventDefault();
+				closeGroup();
+				if (options.structure === void 0) return refuseEvent(event, "Paragraph structure edits are unavailable in this session.");
+				if (modifier) options.structure("pageBreak");
+				else options.structure(event.shiftKey ? "lineBreak" : "split");
+				return true;
+			}
+			if (event.key === "Tab" && !modifier && !event.altKey && options.structure !== void 0) {
+				event.preventDefault();
+				if (view.state.selection.$from.parent.attrs["numPr"]?.kind === "reference") options.structure(event.shiftKey ? "outdent" : "indent");
+				else if (!event.shiftKey) options.structure("tab");
+				return true;
+			}
+			if (event.key !== "Backspace" && event.key !== "Delete") return false;
+			event.preventDefault();
+			if (modifier || event.altKey || view.composing || composition.active) {
+				closeGroup();
+				if (!composition.active) options.refuse("Only plain character deletion is available in this session.");
+				return true;
+			}
+			if (view.state.selection.empty && options.structure !== void 0 && isCanonicalJoinBoundary(view.state, event.key === "Backspace" ? "backward" : "forward")) {
+				closeGroup();
+				options.structure(event.key === "Backspace" ? "joinBackward" : "joinForward");
+				return true;
+			}
+			const range = deletionRange(view.state, event.key === "Backspace" ? "backward" : "forward");
+			if (range.isErr()) {
+				closeGroup();
+				options.refuse(range.error.message);
+			} else options.replace({
+				...range.value,
+				text: "",
+				semantic: event.key === "Backspace" ? "deleteBackward" : "deleteForward"
+			});
+			return true;
+		},
+		handleDOMEvents: {
+			compositionstart: (view) => {
+				beginGesture();
+				composition.start(view);
+				return false;
+			},
+			compositionend: (view) => {
+				composition.ended(view);
+				return false;
+			},
+			mousedown: (view) => {
+				composition.recover(view);
+				beginGesture();
+				closeGroup();
+				return false;
+			},
+			blur: (view) => {
+				composition.recover(view);
+				beginGesture();
+				closeGroup();
+				repaint(view);
+				return false;
+			},
+			beforeinput: (view, event) => {
+				beginGesture();
+				if (event.isComposing || event.inputType === "insertCompositionText" || event.inputType === "insertFromComposition" || event.inputType === "deleteCompositionText" || event.inputType === "deleteByComposition") {
+					if (composition.active) {
+						composition.authorizeNative(view);
+						return false;
+					}
+					return refuseEvent(event, "Composition has no captured canonical baseline.");
+				}
+				if (composition.active) {
+					const refusedNativeCommit = composition.status === "refused" && view.composing;
+					composition.recover(view);
+					proposal = { type: "idle" };
+					if (refusedNativeCommit) {
+						event.preventDefault();
+						return true;
+					}
+				}
+				if (event.inputType === "insertText" || event.inputType === "insertReplacementText") {
+					if (event.cancelable) {
+						if (view.composing && event.inputType === "insertText" && event.data !== null) {
+							event.preventDefault();
+							proposal = { type: "idle" };
+							options.replace({
+								from: view.state.selection.from,
+								to: view.state.selection.to,
+								text: event.data,
+								semantic: "typing"
+							});
+							return true;
+						}
+						proposal = { type: "idle" };
+						authorizedInput = {
+							view,
+							state: view.state
+						};
+						try {
+							if (handleEditorBeforeInput(view, event)) return true;
+							return refuseEvent(event, "This native replacement cannot be addressed safely.");
+						} finally {
+							authorizedInput = null;
+						}
+					}
+					if (event.inputType !== "insertText" || event.data === null) return refuseEvent(event, "This native replacement cannot be addressed safely.");
+					proposal = {
+						type: "replacement",
+						state: view.state,
+						input: {
+							from: view.state.selection.from,
+							to: view.state.selection.to,
+							text: event.data,
+							semantic: "typing"
+						}
+					};
+					return false;
+				}
+				if ((event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") && event.cancelable && options.structure !== void 0) {
+					event.preventDefault();
+					closeGroup();
+					options.structure(event.inputType === "insertParagraph" ? "split" : "lineBreak");
+					return true;
+				}
+				if (event.inputType === "deleteContentBackward" || event.inputType === "deleteContentForward") {
+					const selection = view.state.selection;
+					const backward = event.inputType === "deleteContentBackward";
+					if (event.cancelable && selection.empty && options.structure !== void 0 && isCanonicalJoinBoundary(view.state, backward ? "backward" : "forward")) {
+						event.preventDefault();
+						closeGroup();
+						options.structure(backward ? "joinBackward" : "joinForward");
+						return true;
+					}
+					const range = deletionRange(view.state, event.inputType === "deleteContentBackward" ? "backward" : "forward");
+					if (range.isErr()) return refuseEvent(event, range.error.message);
+					const input = {
+						...range.value,
+						text: "",
+						semantic: event.inputType === "deleteContentBackward" ? "deleteBackward" : "deleteForward"
+					};
+					if (event.cancelable) {
+						event.preventDefault();
+						options.replace(input);
+						return true;
+					}
+					proposal = {
+						type: "replacement",
+						state: view.state,
+						input
+					};
+					return false;
+				}
+				if (event.inputType === "historyUndo" || event.inputType === "historyRedo") {
+					event.preventDefault();
+					if (event.inputType === "historyUndo") options.undo();
+					else options.redo();
+					return true;
+				}
+				return refuseEvent(event, `Input ${event.inputType} is unavailable in this session.`);
+			},
+			input: (view) => {
+				if (composition.active) {
+					composition.flushed(view);
+					return false;
+				}
+				const pending = proposal;
+				queueMicrotask(() => {
+					if (view.isDestroyed) return;
+					view.updateState(view.state);
+					if (proposal === pending && !composition.active) proposal = { type: "idle" };
+				});
+				return false;
+			},
+			paste: (_view, event) => {
+				beginGesture();
+				return refuseEvent(event, "Paste is unavailable in this session.");
+			},
+			cut: (_view, event) => {
+				beginGesture();
+				return refuseEvent(event, "Cut is unavailable in this session.");
+			},
+			drop: (_view, event) => {
+				beginGesture();
+				return refuseEvent(event, "Drop is unavailable in this session.");
+			}
+		},
+		/** Returns a classified intent only; the proposed PM document is never authoritative. */
+		takeNativeProposal,
+		refuseNativeMutation,
+		commitNativeProposal: (view, transaction) => {
+			const input = takeNativeProposal(view.state, transaction);
+			if (!input) return false;
+			options.replace(input);
+			return true;
+		}
+	};
+};
+//#endregion
+export { createCanonicalInputBoundary };

package/dist/controller/canonicalOperations.d.ts

@@ -0,0 +1,22 @@
+import { document_d_exports } from "../types/document.js";
+import { CreateHeaderFooterOp, DOCUMENT_OP_TYPES, DocumentOp, FormattingPatch, FormattingPatch as FormattingPatch$1, OpStory, RemoveHeaderFooterOp, SetSectionPropsOp, TextPosition } from "@stll/docx-core/ops";
+//#region src/controller/canonicalOperations.d.ts
+declare const canonicalFinalSectionIndex: (document: document_d_exports.Document) => number;
+declare const withCanonicalParagraphIds: (content: document_d_exports.BlockContent[], document: document_d_exports.Document) => document_d_exports.BlockContent[];
+type CreateCanonicalHeaderFooterOptions = {
+  document: document_d_exports.Document;
+  position: "header" | "footer";
+  referenceType: document_d_exports.HeaderFooterType;
+  sectionIndex?: number;
+};
+declare const createCanonicalHeaderFooterOperation: ({ document, position, referenceType, sectionIndex }: CreateCanonicalHeaderFooterOptions) => CreateHeaderFooterOp;
+type RemoveCanonicalHeaderFooterOptions = {
+  document: document_d_exports.Document;
+  position: "header" | "footer";
+  rId: string;
+};
+/** Remove each explicit binding, leaving inherited sections to inherit the remaining parts. */
+declare const removeCanonicalHeaderFooterOperations: ({ document, position, rId }: RemoveCanonicalHeaderFooterOptions) => RemoveHeaderFooterOp[];
+declare const createCanonicalSectionPropertiesOperation: (document: document_d_exports.Document, patch: FormattingPatch$1<document_d_exports.SectionProperties>) => SetSectionPropsOp;
+//#endregion
+export { DOCUMENT_OP_TYPES, type DocumentOp, type FormattingPatch, type OpStory, type TextPosition, canonicalFinalSectionIndex, createCanonicalHeaderFooterOperation, createCanonicalSectionPropertiesOperation, removeCanonicalHeaderFooterOperations, withCanonicalParagraphIds };