@stll/folio-core 0.55.0 → 0.56.0

package/dist/controller/canonicalInlineProjection.js

@@ -0,0 +1,393 @@
+import { readNoteMarkerAttrs } from "../internal/noteMarkerAttrs.js";
+import { readFootnoteRefMarkAttrs, readPreservedXmlAttrs } from "../prosemirror/attrs/index.js";
+import { bookmarkMarkerFromAttrs, readBookmarkBoundaryAttrs } from "../prosemirror/bookmarkBoundaryAttrs.js";
+import { HYPHEN_TEXT_CARRIERS } from "../prosemirror/conversion/hyphenTextCarriers.js";
+import { readMoveRangeBoundaryAttrs } from "../prosemirror/moveRangeBoundaryAttrs.js";
+import { readRangeAnchorAttrs } from "../prosemirror/rangeAnchorAttrs.js";
+import { PRESERVED_XML_LEVELS } from "../prosemirror/schema/nodes.js";
+import { Result, TaggedError, panic } from "better-result";
+import { hasIllegalXmlCharacters } from "@stll/docx-core";
+import { inlineLeafSpans, paragraphLogicalText } from "@stll/docx-core/ops";
+//#region src/controller/canonicalInlineProjection.ts
+const CANONICAL_SOURCE_INLINE_POLICIES = {
+	run: "container",
+	hyperlink: "container",
+	insertion: "container",
+	deletion: "container",
+	moveFrom: "container",
+	moveTo: "container",
+	inlineWrapper: "container",
+	inlineSdt: "control",
+	simpleField: "leaf",
+	complexField: "leaf",
+	mathEquation: "leaf",
+	preservedInline: "leaf",
+	bookmarkStart: "leaf",
+	bookmarkEnd: "leaf",
+	commentRangeStart: "leaf",
+	commentRangeEnd: "leaf",
+	commentReference: "leaf",
+	moveFromRangeStart: "leaf",
+	moveFromRangeEnd: "leaf",
+	moveToRangeStart: "leaf",
+	moveToRangeEnd: "leaf",
+	text: "text",
+	tab: "leaf",
+	break: "leaf",
+	symbol: "leaf",
+	footnoteRef: "leaf",
+	endnoteRef: "leaf",
+	noteMarker: "leaf",
+	fieldChar: "rawField",
+	instrText: "rawField",
+	softHyphen: "leaf",
+	noBreakHyphen: "leaf",
+	renderedPageBreak: "layout",
+	preservedXml: "leaf",
+	drawing: "leaf",
+	shape: "leaf"
+};
+const CANONICAL_NATIVE_INLINE_POLICIES = {
+	text: "text",
+	bookmarkBoundary: "markers",
+	moveRangeBoundary: "markers",
+	rangeAnchor: "markers",
+	noteMarker: "noteMarker",
+	preservedXml: "capture",
+	field: "unit",
+	structuredField: "unit",
+	hardBreak: "unit",
+	image: "unit",
+	math: "unit",
+	pageBreakRun: "unit",
+	shape: "unit",
+	symbol: "unit",
+	tab: "unit",
+	textBoxAnchor: "unit",
+	commentReference: "unit",
+	renderedPageBreak: "refused",
+	sdt: "refused"
+};
+const nativePolicies = new Map(Object.entries(CANONICAL_NATIVE_INLINE_POLICIES));
+var InlineProjectionError = class extends TaggedError("InlineProjectionError") {};
+const refuse = (message) => Result.err(new InlineProjectionError({ message }));
+/** Every source variant makes a decision before conversion can discard its positions. */
+const canonicalInlineSourceIssue = (items, context = "paragraph") => {
+	for (const item of items) switch (CANONICAL_SOURCE_INLINE_POLICIES[item.type]) {
+		case "control":
+			if (context === "fieldPayload" && item.type === "inlineSdt") {
+				const issue = canonicalInlineSourceIssue(item.content, context);
+				if (issue !== null) return issue;
+				break;
+			}
+			return "Canonical editing cannot preserve inline content-control boundary positions.";
+		case "rawField":
+			if (context === "fieldPayload") break;
+			return "Canonical editing cannot preserve unstructured field instructions; a structured field is required.";
+		case "layout": return "Canonical editing cannot preserve cached rendered page-break positions.";
+		case "text":
+			if (item.type === "text" && (hasIllegalXmlCharacters(item.text) || /[\t\r\n]/u.test(item.text))) return "Canonical text requires valid XML characters and explicit tab or break elements.";
+			break;
+		case "container": {
+			if ((item.type === "insertion" || item.type === "deletion") && item.resolutionJoins !== void 0 && item.content.some((child) => child.type === "hyperlink")) return "Canonical editing cannot preserve hyperlink wrapper review provenance.";
+			const children = sourceContainerChildren(item);
+			const issue = canonicalInlineSourceIssue(children, context);
+			if (issue !== null) return issue;
+			break;
+		}
+		case "leaf": {
+			let children = [];
+			if (item.type === "simpleField") children = item.content;
+			if (item.type === "complexField") children = [...item.fieldCode, ...item.fieldResult];
+			const issue = canonicalInlineSourceIssue(children, "fieldPayload");
+			if (issue !== null) return issue;
+			break;
+		}
+		default:
+	}
+	return null;
+};
+const sourceContainerChildren = (item) => {
+	switch (item.type) {
+		case "hyperlink": return item.children;
+		case "run":
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo":
+		case "inlineWrapper": return item.content;
+		default: return panic(`Source policy incorrectly classified ${item.type} as a container.`);
+	}
+};
+/** Native positions and deletion geometry read the same inline-cell classification. */
+const canonicalNativeCells = (paragraph) => {
+	const cells = [];
+	let issue;
+	paragraph.forEach((node, from) => {
+		if (issue !== void 0) return;
+		const to = from + node.nodeSize;
+		switch (nativePolicies.get(node.type.name)) {
+			case "text": {
+				const reference = node.marks.find(({ type }) => type.name === "footnoteRef");
+				if (!reference) {
+					cells.push({
+						type: "text",
+						text: node.text ?? "",
+						from,
+						to,
+						node
+					});
+					return;
+				}
+				const attrs = readFootnoteRefMarkAttrs(reference);
+				if (!attrs.ok) {
+					issue = "Canonical editing requires valid note-reference mark attributes.";
+					return;
+				}
+				const label = String(attrs.value.id);
+				const text = node.text ?? "";
+				if (label.length === 0 || text.length % label.length !== 0 || text !== label.repeat(text.length / label.length)) {
+					issue = "Canonical editing cannot map the rendered note-reference labels.";
+					return;
+				}
+				for (let offset = 0; offset < text.length; offset += label.length) cells.push({
+					type: "markedUnit",
+					sourceType: attrs.value.noteType === "endnote" ? "endnoteRef" : "footnoteRef",
+					label,
+					from: from + offset,
+					to: from + offset + label.length,
+					node
+				});
+				return;
+			}
+			case "unit":
+				cells.push({
+					type: "unit",
+					from,
+					to,
+					node
+				});
+				return;
+			case "markers":
+				if (node.type.name === "bookmarkBoundary") {
+					const attrs = readBookmarkBoundaryAttrs(node);
+					if (!attrs.ok) {
+						issue = "Canonical editing requires valid bookmark boundary attributes.";
+						return;
+					}
+					cells.push({
+						type: "zeroWidth",
+						sources: [bookmarkMarkerFromAttrs(attrs.value)],
+						from,
+						to,
+						node
+					});
+				} else if (node.type.name === "moveRangeBoundary") {
+					const attrs = readMoveRangeBoundaryAttrs(node);
+					if (!attrs.ok) {
+						issue = "Canonical editing requires valid move-range boundary attributes.";
+						return;
+					}
+					cells.push({
+						type: "zeroWidth",
+						sources: [attrs.value],
+						from,
+						to,
+						node
+					});
+				} else {
+					const attrs = readRangeAnchorAttrs(node);
+					if (!attrs.ok) {
+						issue = "Canonical editing requires a valid collapsed range anchor.";
+						return;
+					}
+					cells.push({
+						type: "zeroWidth",
+						sources: [attrs.value.start, attrs.value.end],
+						from,
+						to,
+						node
+					});
+				}
+				return;
+			case "noteMarker": {
+				const attrs = readNoteMarkerAttrs(node);
+				if (!attrs.ok) {
+					issue = "Canonical editing requires a valid automatic note marker.";
+					return;
+				}
+				cells.push({
+					type: "zeroWidth",
+					sources: [{
+						type: "noteMarker",
+						kind: attrs.value.kind
+					}],
+					from,
+					to,
+					node
+				});
+				return;
+			}
+			case "capture": {
+				const attrs = readPreservedXmlAttrs(node);
+				if (!attrs.ok) {
+					issue = "Canonical editing requires valid preserved inline markup.";
+					return;
+				}
+				if (attrs.value.level === PRESERVED_XML_LEVELS.inline && attrs.value.text === "") cells.push({
+					type: "zeroWidth",
+					sources: [{
+						type: "preservedInline",
+						xml: attrs.value.xml,
+						text: ""
+					}],
+					from,
+					to,
+					node
+				});
+				else cells.push({
+					type: "unit",
+					from,
+					to,
+					node
+				});
+				return;
+			}
+			case "refused":
+				issue = `Canonical editing cannot preserve ${node.type.name} boundary positions.`;
+				return;
+			case void 0:
+				issue = `Canonical editing has no position mapping for inline ${node.type.name}.`;
+				return;
+			default:
+		}
+	});
+	return issue === void 0 ? Result.ok(cells) : refuse(issue);
+};
+const sameSourceMarker = (left, right) => {
+	switch (left.type) {
+		case "bookmarkStart":
+		case "bookmarkEnd":
+		case "commentRangeStart":
+		case "commentRangeEnd":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd": return right.type === left.type && left.id === right.id;
+		case "noteMarker": return right.type === "noteMarker" && left.kind === right.kind;
+		case "preservedInline": return right.type === "preservedInline" && left.xml === right.xml && left.text === right.text;
+		default: return false;
+	}
+};
+/** Bind rendered gaps to the operation owner's source leaf ordinals, including collapsed pairs. */
+const projectCanonicalInline = ({ source, paragraph, pairedBookmarkIds }) => {
+	const native = canonicalNativeCells(paragraph);
+	if (native.isErr()) return native;
+	const spans = inlineLeafSpans(source.content);
+	const erasedBookmarks = /* @__PURE__ */ new Set();
+	const collectErasedBookmarks = (items, context) => {
+		for (const item of items) {
+			if (item.type === "bookmarkStart" || item.type === "bookmarkEnd") {
+				if (context === "paragraph" && !pairedBookmarkIds.has(item.id)) erasedBookmarks.add(item);
+				continue;
+			}
+			if (CANONICAL_SOURCE_INLINE_POLICIES[item.type] !== "container") continue;
+			collectErasedBookmarks(sourceContainerChildren(item), item.type === "run" || item.type === "inlineWrapper" ? context : "nested");
+		}
+	};
+	collectErasedBookmarks(source.content, "paragraph");
+	const text = paragraphLogicalText(source);
+	const boundaries = Array.from({ length: text.length + 1 }, () => []);
+	let index = 0;
+	let consumed = 0;
+	const addGap = (position, gap) => {
+		const gaps = boundaries.at(gap.offset);
+		if (!gaps) panic(`Source leaf offset ${gap.offset} exceeds paragraph ${source.paraId}.`);
+		const existing = gaps.findIndex((entry) => entry.position === position);
+		const entry = {
+			position,
+			zeroWidthBefore: gap.zeroWidthBefore
+		};
+		if (existing < 0) gaps.push(entry);
+		else gaps[existing] = entry;
+	};
+	const consumeErasedLeaves = (position) => {
+		while (consumed === 0) {
+			const span = spans.at(index);
+			if (!span || span.before.offset !== span.after.offset || !(erasedBookmarks.has(span.node) || CANONICAL_SOURCE_INLINE_POLICIES[span.node.type] === "container" && sourceContainerChildren(span.node).length === 0)) break;
+			index += 1;
+			if (position !== null) addGap(position, span.after);
+		}
+	};
+	addGap(0, {
+		offset: 0,
+		zeroWidthBefore: 0
+	});
+	for (const cell of native.value) {
+		consumeErasedLeaves(cell.from);
+		let span = spans.at(index);
+		if (!span) return refuse(`Canonical editing cannot map native ${cell.node.type.name} to a source leaf.`);
+		addGap(cell.from, consumed === 0 ? span.before : {
+			offset: span.before.offset + consumed,
+			zeroWidthBefore: 0
+		});
+		switch (cell.type) {
+			case "zeroWidth":
+				for (const marker of cell.sources) {
+					consumeErasedLeaves(null);
+					span = spans.at(index);
+					if (!span || consumed !== 0 || span.before.offset !== span.after.offset || !sameSourceMarker(span.node, marker)) return refuse(`Canonical editing cannot preserve ${marker.type} source boundary positions.`);
+					index += 1;
+				}
+				if (!span) return refuse("Canonical editing lost a source range boundary.");
+				addGap(cell.to, span.after);
+				break;
+			case "unit":
+			case "markedUnit":
+				if (cell.type === "markedUnit" && (span.node.type !== "footnoteRef" && span.node.type !== "endnoteRef" || span.node.type !== cell.sourceType || String(span.node.id) !== cell.label)) return refuse("Canonical editing cannot preserve note-reference identity.");
+				if (consumed !== 0 || span.node.type === "text" || span.after.offset - span.before.offset !== 1) return refuse(`Canonical editing cannot map ${span.node.type} to one native inline unit.`);
+				index += 1;
+				addGap(cell.to, span.after);
+				break;
+			case "text":
+				for (let unit = 0; unit < cell.text.length; unit += 1) {
+					consumeErasedLeaves(cell.from + unit);
+					span = spans.at(index);
+					if (!span) return refuse("Canonical editing cannot map missing source text to native text positions.");
+					let value;
+					switch (span.node.type) {
+						case "text":
+							value = span.node.text;
+							break;
+						case "softHyphen":
+						case "noBreakHyphen":
+							value = HYPHEN_TEXT_CARRIERS[span.node.type];
+							break;
+						default: return refuse(`Canonical editing cannot map ${span.node.type} to native text positions.`);
+					}
+					if (value.charAt(consumed) !== cell.text.charAt(unit)) return refuse("Canonical editing cannot preserve the source text carrier.");
+					consumed += 1;
+					addGap(cell.from + unit + 1, {
+						offset: span.before.offset + consumed,
+						zeroWidthBefore: 0
+					});
+					if (consumed === value.length) {
+						index += 1;
+						consumed = 0;
+					}
+				}
+				break;
+			default:
+		}
+	}
+	consumeErasedLeaves(paragraph.content.size);
+	const missing = spans.at(index);
+	if (missing || consumed !== 0) return refuse(`Canonical editing cannot display the source positions of ${missing?.node.type ?? "incomplete text"}.`);
+	if (boundaries.some((gaps) => gaps.length === 0)) return refuse("Canonical editing lost a source character boundary.");
+	return Result.ok({
+		text,
+		boundaries
+	});
+};
+//#endregion
+export { CANONICAL_NATIVE_INLINE_POLICIES, CANONICAL_SOURCE_INLINE_POLICIES, canonicalInlineSourceIssue, canonicalNativeCells, projectCanonicalInline };

package/dist/controller/canonicalInput.d.ts

@@ -1,12 +1,18 @@
 import { EditorState, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/canonicalInput.d.ts
+declare const CANONICAL_COMPOSITION_INPUT_TYPES: readonly ["insertCompositionText", "insertFromComposition", "deleteCompositionText", "deleteByComposition"];
 type ReplaceTextInput = {
   from: number;
   to: number;
   text: string;
-  semantic?: "typing" | "deleteBackward" | "deleteForward" | "composition";
-};
+} & ({
+  semantic: "composition";
+  compositionPhase?: "correction";
+} | {
+  semantic?: "typing" | "deleteBackward" | "deleteForward";
+  compositionPhase?: never;
+});
 type CanonicalInputOptions = {
   replace: (input: ReplaceTextInput) => void;
   structure?: (type: "split" | "joinBackward" | "joinForward" | "lineBreak" | "pageBreak" | "tab" | "indent" | "outdent") => void;
@@ -14,6 +20,8 @@ type CanonicalInputOptions = {
   breakUndoGroup?: () => void;
   beginComposition?: () => boolean;
   endComposition?: () => void;
+  pastePlainText?: (view: EditorView) => void;
+  cut?: (view: EditorView, event: ClipboardEvent) => boolean;
   undo: () => boolean;
   redo: () => boolean;
   refuse: (reason: string) => void;
@@ -26,6 +34,7 @@ declare const createCanonicalInputBoundary: (options: CanonicalInputOptions) =>
   handleTextInput: (view: EditorView, from: number, to: number, text: string) => boolean;
   handleKeyDown: (view: EditorView, event: KeyboardEvent) => boolean;
   handleDOMEvents: {
+    keydown: (view: EditorView, event: KeyboardEvent) => boolean;
     compositionstart: (view: EditorView) => boolean;
     compositionend: (view: EditorView) => boolean;
     mousedown: (view: EditorView) => boolean;
@@ -33,7 +42,7 @@ declare const createCanonicalInputBoundary: (options: CanonicalInputOptions) =>
     beforeinput: (view: EditorView, event: InputEvent) => boolean;
     input: (view: EditorView) => boolean;
     paste: (_view: EditorView, event: Event) => boolean;
-    cut: (_view: EditorView, event: Event) => boolean;
+    cut: (view: EditorView, event: ClipboardEvent) => boolean;
     drop: (_view: EditorView, event: Event) => boolean;
   };
   /** Returns a classified intent only; the proposed PM document is never authoritative. */
@@ -42,4 +51,4 @@ declare const createCanonicalInputBoundary: (options: CanonicalInputOptions) =>
   commitNativeProposal: (view: EditorView, transaction: Transaction) => boolean;
 };
 //#endregion
-export { createCanonicalInputBoundary };
+export { CANONICAL_COMPOSITION_INPUT_TYPES, createCanonicalInputBoundary };

package/dist/controller/canonicalInput.js

@@ -4,6 +4,12 @@ import { deletionRange, isCanonicalJoinBoundary } from "./canonicalSession.js";
 import { ReplaceStep } from "prosemirror-transform";
 import { Selection, TextSelection } from "prosemirror-state";
 //#region src/controller/canonicalInput.ts
+const CANONICAL_COMPOSITION_INPUT_TYPES = [
+	"insertCompositionText",
+	"insertFromComposition",
+	"deleteCompositionText",
+	"deleteByComposition"
+];
 /** Native changes require a preceding, classified input event at the same state. */
 const createCanonicalInputBoundary = (options) => {
 	const composition = createCanonicalComposition({
@@ -15,7 +21,8 @@ const createCanonicalInputBoundary = (options) => {
 	let proposal = { type: "idle" };
 	let authorizedInput = null;
 	let groupClosed = false;
-	const beginGesture = () => {
+	const beginGesture = (lifecycle = "new") => {
+		if (lifecycle === "new") composition.forgetCompleted();
 		proposal = { type: "idle" };
 		authorizedInput = null;
 		groupClosed = false;
@@ -37,6 +44,12 @@ const createCanonicalInputBoundary = (options) => {
 		if (!composition.active) proposal = { type: "refused" };
 		return true;
 	};
+	const refuseClipboardGesture = (event, reason) => {
+		event.preventDefault();
+		closeGroup();
+		options.refuse(reason);
+		return true;
+	};
 	const refuseNativeMutation = (view) => {
 		if (!composition.active && proposal.type !== "refused") {
 			options.refuse("Unclassified native text is unavailable in this session.");
@@ -72,7 +85,7 @@ const createCanonicalInputBoundary = (options) => {
 		},
 		acceptComposition: composition.accept,
 		handleTextInput: (view, from, to, text) => {
-			if (composition.active) return false;
+			if (composition.active || composition.pendingFinal) return false;
 			const pending = proposal;
 			if (authorizedInput?.view === view && authorizedInput.state === view.state) {
 				options.replace({
@@ -92,6 +105,7 @@ const createCanonicalInputBoundary = (options) => {
 			return true;
 		},
 		handleKeyDown: (view, event) => {
+			if (event.isComposing || event.keyCode === 229) return false;
 			beginGesture();
 			if (composition.active) {
 				if (event.key === "Escape") {
@@ -138,6 +152,12 @@ const createCanonicalInputBoundary = (options) => {
 				}
 				return true;
 			}
+			if (modifier && event.altKey && event.key.toLowerCase() === "v" && options.pastePlainText) {
+				event.preventDefault();
+				closeGroup();
+				options.pastePlainText(view);
+				return true;
+			}
 			if (event.key === "Enter") {
 				if (view.composing) return refuseEvent(event, "Paragraph structure edits are unavailable during composition.");
 				event.preventDefault();
@@ -177,6 +197,13 @@ const createCanonicalInputBoundary = (options) => {
 			return true;
 		},
 		handleDOMEvents: {
+			keydown: (view, event) => {
+				if (event.isComposing || event.keyCode === 229) return true;
+				if (!composition.active || event.key !== "Escape") return false;
+				event.preventDefault();
+				composition.cancel(view);
+				return true;
+			},
 			compositionstart: (view) => {
 				beginGesture();
 				composition.start(view);
@@ -200,19 +227,22 @@ const createCanonicalInputBoundary = (options) => {
 				return false;
 			},
 			beforeinput: (view, event) => {
-				beginGesture();
-				if (event.isComposing || event.inputType === "insertCompositionText" || event.inputType === "insertFromComposition" || event.inputType === "deleteCompositionText" || event.inputType === "deleteByComposition") {
+				beginGesture(event.inputType === "insertFromComposition" ? "compositionFinal" : "new");
+				if (event.isComposing || CANONICAL_COMPOSITION_INPUT_TYPES.some((inputType) => inputType === event.inputType)) {
 					if (composition.active) {
 						composition.authorizeNative(view);
 						return false;
 					}
+					if (event.inputType === "insertFromComposition" && composition.authorizeLateFinal(view, event.data)) return false;
 					return refuseEvent(event, "Composition has no captured canonical baseline.");
 				}
 				if (composition.active) {
-					const refusedNativeCommit = composition.status === "refused" && view.composing;
-					composition.recover(view);
+					const nativeFinal = view.composing && (event.inputType === "insertText" || event.inputType === "insertReplacementText");
+					const nativeStillComposing = view.composing;
+					const recovered = composition.recover(view);
+					composition.forgetCompleted();
 					proposal = { type: "idle" };
-					if (refusedNativeCommit) {
+					if (nativeFinal && (recovered.type === "refused" && nativeStillComposing || (recovered.type === "committed" || recovered.type === "refused") && recovered.text !== null && recovered.text === event.data)) {
 						event.preventDefault();
 						return true;
 					}
@@ -298,7 +328,7 @@ const createCanonicalInputBoundary = (options) => {
 				return refuseEvent(event, `Input ${event.inputType} is unavailable in this session.`);
 			},
 			input: (view) => {
-				if (composition.active) {
+				if (composition.active || composition.pendingFinal) {
 					composition.flushed(view);
 					return false;
 				}
@@ -312,15 +342,24 @@ const createCanonicalInputBoundary = (options) => {
 			},
 			paste: (_view, event) => {
 				beginGesture();
-				return refuseEvent(event, "Paste is unavailable in this session.");
+				closeGroup();
+				if (composition.active) return refuseClipboardGesture(event, "Composition must finish before pasting.");
+				return false;
 			},
-			cut: (_view, event) => {
+			cut: (view, event) => {
 				beginGesture();
-				return refuseEvent(event, "Cut is unavailable in this session.");
+				if (composition.active) return refuseClipboardGesture(event, "Composition must finish before cutting.");
+				if (options.cut !== void 0) {
+					closeGroup();
+					return options.cut(view, event);
+				}
+				return refuseEvent(event, "The canonical clipboard owner is unavailable.");
 			},
 			drop: (_view, event) => {
 				beginGesture();
-				return refuseEvent(event, "Drop is unavailable in this session.");
+				closeGroup();
+				if (composition.active) return refuseClipboardGesture(event, "Composition must finish before dropping.");
+				return false;
 			}
 		},
 		/** Returns a classified intent only; the proposed PM document is never authoritative. */
@@ -335,4 +374,4 @@ const createCanonicalInputBoundary = (options) => {
 	};
 };
 //#endregion
-export { createCanonicalInputBoundary };
+export { CANONICAL_COMPOSITION_INPUT_TYPES, createCanonicalInputBoundary };

package/dist/controller/canonicalInputTimer.d.ts

@@ -0,0 +1,7 @@
+//#region src/controller/canonicalInputTimer.d.ts
+/** Shared by timer producers and browser diagnostics, regardless of bundling. */
+declare const CANONICAL_INPUT_TIMER_OWNER = "folio.canonical-input-timer";
+/** Mark the scheduled wrapper, never the caller's potentially shared callback. */
+declare const setCanonicalInputTimer: (callback: () => void, delay: number) => NodeJS.Timeout;
+//#endregion
+export { CANONICAL_INPUT_TIMER_OWNER, setCanonicalInputTimer };

package/dist/controller/canonicalInputTimer.js

@@ -0,0 +1,11 @@
+//#region src/controller/canonicalInputTimer.ts
+/** Shared by timer producers and browser diagnostics, regardless of bundling. */
+const CANONICAL_INPUT_TIMER_OWNER = "folio.canonical-input-timer";
+/** Mark the scheduled wrapper, never the caller's potentially shared callback. */
+const setCanonicalInputTimer = (callback, delay) => {
+	const ownedCallback = () => callback();
+	Object.defineProperty(ownedCallback, Symbol.for(CANONICAL_INPUT_TIMER_OWNER), { value: true });
+	return setTimeout(ownedCallback, delay);
+};
+//#endregion
+export { CANONICAL_INPUT_TIMER_OWNER, setCanonicalInputTimer };

package/dist/controller/canonicalPublicOperations.d.ts

@@ -0,0 +1,48 @@
+import { ApplyFolioDocumentOperationsOptions, FolioDocumentOperationResult, FolioDocumentOperationUndoHandle, FolioDocumentOperationUndoResult } from "../document-operations.js";
+import { CanonicalCommit, CanonicalSession } from "./canonicalSession.js";
+import { EditorState } from "prosemirror-state";
+import { OpStory } from "@stll/docx-core/ops";
+//#region src/controller/canonicalPublicOperations.d.ts
+/** A new public kind cannot bypass a canonical compiler/refusal decision. */
+declare const CANONICAL_PUBLIC_OPERATION_DISPOSITIONS: {
+  readonly replaceInBlock: "compile";
+  readonly replaceRange: "compile";
+  readonly replaceBlock: "compile";
+  readonly splitBlock: "compile";
+  readonly formatRange: "compile";
+  readonly mergeBlockWithNext: "compile";
+  readonly setBlockParagraphProperties: "publicOps.unsupportedInline";
+  readonly insertAfterBlock: "publicOps.unsupportedInline";
+  readonly insertBeforeBlock: "publicOps.unsupportedInline";
+  readonly deleteBlock: "publicOps.unsupportedInline";
+  readonly commentOnBlock: "publicOps.comments";
+  readonly commentOnRange: "publicOps.comments";
+  readonly insertTable: "publicOps.tableProjection";
+  readonly insertSignatureTable: "publicOps.tableProjection";
+  readonly deleteTable: "publicOps.tableProjection";
+  readonly insertTableRow: "publicOps.tableProjection";
+  readonly deleteTableRow: "publicOps.tableProjection";
+  readonly insertTableColumn: "publicOps.tableProjection";
+  readonly deleteTableColumn: "publicOps.tableProjection";
+  readonly mergeTableCells: "publicOps.tableProjection";
+  readonly splitTableCell: "publicOps.tableProjection";
+};
+type CanonicalPublicOperationOptions = Omit<ApplyFolioDocumentOperationsOptions, "view" | "createUndoHandle" | "createCommentId">;
+type CanonicalPublicOperationsOptions = {
+  session: CanonicalSession;
+  getState: (story: OpStory) => EditorState | null;
+  publish: (commit: CanonicalCommit) => boolean;
+};
+/** Handles address isolated journal groups; no second document or PM history is retained. */
+declare class CanonicalPublicOperations {
+  private readonly options;
+  private readonly handles;
+  private nextHandle;
+  private readonly handleNamespace;
+  constructor(options: CanonicalPublicOperationsOptions);
+  apply(options: CanonicalPublicOperationOptions): FolioDocumentOperationResult;
+  undo(handle: FolioDocumentOperationUndoHandle): FolioDocumentOperationUndoResult;
+  private resolve;
+}
+//#endregion
+export { CANONICAL_PUBLIC_OPERATION_DISPOSITIONS, CanonicalPublicOperationOptions, CanonicalPublicOperations };