@stll/folio-core 0.54.1 → 0.55.0

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 };

package/dist/controller/canonicalOperations.js

@@ -0,0 +1,85 @@
+import { visitDocxParagraphs } from "../docx/paragraphTraversal.js";
+import { generateHexId, isValidHexId } from "../utils/hexId.js";
+import { DOCUMENT_OP_TYPES, DOCUMENT_OP_TYPES as DOCUMENT_OP_TYPES$1 } from "@stll/docx-core/ops";
+//#region src/controller/canonicalOperations.ts
+/** Adapter command boundaries allocate identities; journaled operations remain deterministic. */
+const canonicalFinalSectionIndex = (document) => document.package.document.content.filter((block) => block.type === "paragraph" && block.sectionProperties !== void 0).length;
+const withCanonicalParagraphIds = (content, document) => {
+	const taken = /* @__PURE__ */ new Set();
+	const { document: documentBody, headers, footers, footnotes, endnotes } = document.package;
+	visitDocxParagraphs({
+		documentBody,
+		headers,
+		footers,
+		footnotes,
+		endnotes
+	}, (paragraph) => {
+		if (paragraph.paraId) taken.add(paragraph.paraId.toUpperCase());
+	});
+	const owned = structuredClone(content);
+	visitDocxParagraphs({ documentBody: { content: owned } }, (paragraph) => {
+		if (paragraph.paraId && isValidHexId(paragraph.paraId) && Number.parseInt(paragraph.paraId, 16) > 0 && Number.parseInt(paragraph.paraId, 16) < 2147483647 && !taken.has(paragraph.paraId.toUpperCase())) {
+			taken.add(paragraph.paraId.toUpperCase());
+			return;
+		}
+		let paraId = generateHexId();
+		while (taken.has(paraId)) paraId = generateHexId();
+		taken.add(paraId);
+		paragraph.paraId = paraId;
+	});
+	return owned;
+};
+const createCanonicalHeaderFooterOperation = ({ document, position, referenceType, sectionIndex = canonicalFinalSectionIndex(document) }) => {
+	const occupied = /* @__PURE__ */ new Set([
+		...document.package.headers?.keys() ?? [],
+		...document.package.footers?.keys() ?? [],
+		...document.package.relationships?.keys() ?? []
+	]);
+	const base = `rId_new_${position}_${referenceType}`;
+	let rId = base;
+	let suffix = 2;
+	while (occupied.has(rId)) rId = `${base}_${suffix++}`;
+	return {
+		type: DOCUMENT_OP_TYPES$1.CREATE_HEADER_FOOTER,
+		sectionIndex,
+		story: {
+			kind: position,
+			rId
+		},
+		referenceType,
+		content: withCanonicalParagraphIds([{
+			type: "paragraph",
+			content: []
+		}], document)
+	};
+};
+/** Remove each explicit binding, leaving inherited sections to inherit the remaining parts. */
+const removeCanonicalHeaderFooterOperations = ({ document, position, rId }) => {
+	const properties = [];
+	for (const block of document.package.document.content) if (block.type === "paragraph" && block.sectionProperties) properties.push(block.sectionProperties);
+	properties.push(document.package.document.finalSectionProperties ?? {});
+	const operations = [];
+	for (const [sectionIndex, section] of properties.entries()) {
+		const references = position === "header" ? section.headerReferences : section.footerReferences;
+		for (const reference of references ?? []) {
+			if (reference.rId !== rId) continue;
+			operations.push({
+				type: DOCUMENT_OP_TYPES$1.REMOVE_HEADER_FOOTER,
+				sectionIndex,
+				story: {
+					kind: position,
+					rId
+				},
+				referenceType: reference.type
+			});
+		}
+	}
+	return operations;
+};
+const createCanonicalSectionPropertiesOperation = (document, patch) => ({
+	type: DOCUMENT_OP_TYPES$1.SET_SECTION_PROPS,
+	sectionIndex: canonicalFinalSectionIndex(document),
+	patch
+});
+//#endregion
+export { DOCUMENT_OP_TYPES, canonicalFinalSectionIndex, createCanonicalHeaderFooterOperation, createCanonicalSectionPropertiesOperation, removeCanonicalHeaderFooterOperations, withCanonicalParagraphIds };

package/dist/controller/canonicalReview.d.ts

@@ -0,0 +1,12 @@
+import { FolioEditor } from "./folioEditor.js";
+//#region src/controller/canonicalReview.d.ts
+type ResolveCanonicalReviewRangeOptions = {
+  editor: Pick<FolioEditor, "getCanonicalDocument" | "getState" | "resolveCanonicalRevisions"> | null | undefined;
+  from: number;
+  to: number;
+  resolution: "accept" | "reject";
+};
+/** Null delegates to the default session's ProseMirror review commands. */
+declare const resolveCanonicalReviewRange: ({ editor, from, to, resolution }: ResolveCanonicalReviewRangeOptions) => boolean | null;
+//#endregion
+export { resolveCanonicalReviewRange };