@stll/folio-core 0.50.0 → 0.52.0

package/dist/docx/selectiveSave.js

@@ -8,12 +8,13 @@ import { isUnsafePackagePath } from "./packageParts.js";
 import { RELATIONSHIP_TYPES } from "./relsParser.js";
 import { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_PART_LOWER, addCommentsExtendedOverride, addCommentsExtendedRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, hasUnmaterializedInlineResources, updateCoreProperties, withoutAttachedTemplate } from "./rezip.js";
 import "./selectiveSaveFlags.js";
-import { buildPatchedDocumentXml, buildPatchedNoteXml, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
+import { buildPatchedDocumentXml, buildPatchedNoteXml, collectAddedNumberingDefs, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
 import { planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
+import { buildStructuralDocumentPatch } from "./structuralXmlPatch.js";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 //#region src/docx/selectiveSave.ts
 /**
@@ -174,7 +175,6 @@ const queueSettingsUpdates = async (zip, updates) => {
 async function attemptSelectiveSave(doc, originalBuffer, options) {
 	const { changedParaIds, structuralChange, hasUntrackedChanges } = options;
 	const maxBytes = options.maxBytes ?? 104857600;
-	if (structuralChange) return null;
 	if (hasUntrackedChanges) return null;
 	if (originalBuffer.byteLength > maxBytes) return null;
 	const content = doc.package.document.content;
@@ -197,22 +197,32 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		const zip = await (await import("jszip")).default.loadAsync(originalBuffer);
 		for (const [path, file] of Object.entries(zip.files)) if (!file.dir && isUnsafePackagePath(path)) return null;
 		const updates = /* @__PURE__ */ new Map();
-		if (changedParaIds.size > 0) {
+		if (changedParaIds.size > 0 || structuralChange) {
 			const docXmlFile = zip.file("word/document.xml");
 			if (!docXmlFile) return null;
 			const originalDocXml = await docXmlFile.async("text");
 			const serializedDocXml = serializeDocument(doc, readRootNamespaceBindings(originalDocXml));
 			const bodyParaIds = collectParaIds(serializedDocXml);
+			const originalBodyParaIds = structuralChange ? collectParaIds(originalDocXml) : void 0;
+			if (structuralChange && doc.package.numbering) {
+				const numberingFile = findZipEntryCaseInsensitive(zip, "word/numbering.xml");
+				const added = collectAddedNumberingDefs(numberingFile ? serializeNumberingXml(parseNumbering(await numberingFile.async("text")).definitions) : "", serializeNumberingXml(doc.package.numbering));
+				if (added.abstractNums.size > 0 || added.nums.size > 0) return null;
+			}
 			const bodyChangedIds = /* @__PURE__ */ new Set();
 			const noteCandidateIds = /* @__PURE__ */ new Set();
-			for (const id of changedParaIds) if (bodyParaIds.has(id)) bodyChangedIds.add(id);
+			for (const id of changedParaIds) if (bodyParaIds.has(id) || originalBodyParaIds?.has(id)) bodyChangedIds.add(id);
 			else noteCandidateIds.add(id);
 			if (noteCandidateIds.size > 0) {
 				const unrouted = await patchNoteParts(zip, doc, noteCandidateIds, updates);
 				if (unrouted === null || unrouted.size > 0) return null;
 			}
-			if (bodyChangedIds.size > 0) {
-				const patchedDocXml = buildPatchedDocumentXml(originalDocXml, serializedDocXml, bodyChangedIds);
+			if (bodyChangedIds.size > 0 || structuralChange) {
+				const patchedDocXml = structuralChange ? buildStructuralDocumentPatch({
+					originalXml: originalDocXml,
+					serializedXml: serializedDocXml,
+					changedIds: bodyChangedIds
+				}) : buildPatchedDocumentXml(originalDocXml, serializedDocXml, bodyChangedIds);
 				if (!patchedDocXml) return null;
 				updates.set("word/document.xml", patchedDocXml);
 			}

package/dist/docx/structuralXmlPatch.d.ts

@@ -0,0 +1,14 @@
+//#region src/docx/structuralXmlPatch.d.ts
+type StructuralPatchOptions = {
+  originalXml: string;
+  serializedXml: string;
+  changedIds: ReadonlySet<string>;
+};
+/**
+ * Insert/delete direct body paragraphs between surviving paragraph/table anchors.
+ * Tables are opaque barriers: their modeled content and order must stay identical.
+ * Id-less sources need an explicit ensureParaIds ingest before structural editing.
+ */
+declare const buildStructuralDocumentPatch: ({ originalXml, serializedXml, changedIds }: StructuralPatchOptions) => string | null;
+//#endregion
+export { buildStructuralDocumentPatch };

package/dist/docx/structuralXmlPatch.js

@@ -0,0 +1,209 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { parseDocumentBody } from "./documentParser.js";
+import { paraIdAttribute } from "./paraIdAttribute.js";
+import { spliceXml } from "./selectiveXmlPatch.js";
+import { readRootNamespaceBindings, serializePartElement } from "./serializer/partNamespaces.js";
+import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/structuralXmlPatch.ts
+/** Conservative body-paragraph splices; source offsets never come from reserialization. */
+const isWordElement = (element, name) => getLocalName(element.name) === name && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "");
+/** Match XML tokens, skipping quoted delimiters, comments, CDATA and processing instructions. */
+const XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(?:"[^"]*"|'[^']*'|[^'">])*>/gu;
+const readBody = (xml) => {
+	const root = parseXmlDocument(xml);
+	if (!root || !isWordElement(root, "document")) return null;
+	if (getNamespaceUri(root) !== NAMESPACES.w) return null;
+	const body = getChildElements(root).find((child) => isWordElement(child, "body"));
+	if (!body) return null;
+	const children = getChildElements(body);
+	const blocks = [];
+	const stack = [];
+	let bodyDepth = -1;
+	let bodyEnd = -1;
+	let start = -1;
+	for (const token of xml.matchAll(XML_TOKEN)) {
+		const tag = token[0];
+		if (tag.startsWith("<!") || tag.startsWith("<?")) continue;
+		const closing = tag.startsWith("</");
+		const name = tag.slice(closing ? 2 : 1).split(/[\s/>]/u).at(0);
+		if (!name) return null;
+		if (closing) {
+			if (stack.pop() !== name) return null;
+			if (stack.length === bodyDepth) {
+				const element = children[blocks.length];
+				if (!element || start < 0) return null;
+				blocks.push({
+					element,
+					start,
+					end: token.index + tag.length
+				});
+				start = -1;
+			}
+			if (name === body.name && stack.length === bodyDepth - 1) bodyEnd = token.index;
+			continue;
+		}
+		if (name === body.name && stack.length === 1) bodyDepth = 2;
+		if (stack.length === bodyDepth) {
+			if (children[blocks.length]?.name !== name) return null;
+			start = token.index;
+			if (tag.endsWith("/>")) {
+				const element = children[blocks.length];
+				if (!element) return null;
+				blocks.push({
+					element,
+					start,
+					end: token.index + tag.length
+				});
+				start = -1;
+			}
+		}
+		if (!tag.endsWith("/>")) stack.push(name);
+	}
+	if (stack.length > 0 || blocks.length !== children.length || bodyEnd < 0) return null;
+	return {
+		root,
+		blocks,
+		bodyEnd
+	};
+};
+function* descendants(element) {
+	yield element;
+	for (const child of getChildElements(element)) yield* descendants(child);
+}
+/** Cross-paragraph ranges require a wider edit contract than paragraph identity. */
+const RANGE_ELEMENTS = /* @__PURE__ */ new Set([
+	"commentRangeStart",
+	"commentRangeEnd",
+	"commentReference",
+	"bookmarkStart",
+	"bookmarkEnd",
+	"permStart",
+	"permEnd",
+	"fldChar",
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd"
+]);
+const DEPENDENT_ELEMENTS = /* @__PURE__ */ new Set([
+	"sectPr",
+	"footnoteReference",
+	"endnoteReference",
+	"drawing",
+	"pict",
+	"object"
+]);
+const paragraphIsSafe = (element, touched) => {
+	for (const child of descendants(element)) {
+		if (!WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "")) continue;
+		const name = getLocalName(child.name);
+		if (touched && DEPENDENT_ELEMENTS.has(name)) return false;
+	}
+	return true;
+};
+const paragraphIds = (root) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const element of descendants(root)) {
+		if (!isWordElement(element, "p")) continue;
+		const id = paraIdAttribute(element);
+		if (!id || !/^[0-9a-f]{8}$/iu.test(id) || /^0+$/u.test(id) || ids.has(id.toUpperCase())) return null;
+		ids.add(id.toUpperCase());
+	}
+	return ids;
+};
+/** Bind fragment prefixes locally: the source root may use entirely different aliases. */
+const paragraphFragment = ({ xml, block, bindings }) => {
+	const fragment = xml.slice(block.start, block.end);
+	const openEnd = fragment.indexOf(">");
+	const name = block.element.name ?? "w:p";
+	const selfClosing = fragment[openEnd - 1] === "/";
+	return serializePartElement({
+		partPath: "word/document.xml",
+		rootName: name,
+		rootAttributes: fragment.slice(name.length + 1, selfClosing ? openEnd - 1 : openEnd).trim(),
+		baselinePrefixes: [],
+		sourceBindings: bindings,
+		body: selfClosing ? "" : fragment.slice(openEnd + 1, fragment.lastIndexOf("</"))
+	});
+};
+/**
+* Insert/delete direct body paragraphs between surviving paragraph/table anchors.
+* Tables are opaque barriers: their modeled content and order must stay identical.
+* Id-less sources need an explicit ensureParaIds ingest before structural editing.
+*/
+const buildStructuralDocumentPatch = ({ originalXml, serializedXml, changedIds }) => {
+	const source = readBody(originalXml);
+	const current = readBody(serializedXml);
+	if (!source || !current) return null;
+	for (const root of [source.root, current.root]) for (const element of descendants(root)) if (WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "") && RANGE_ELEMENTS.has(getLocalName(element.name))) return null;
+	const allSourceIds = paragraphIds(source.root);
+	const allCurrentIds = paragraphIds(current.root);
+	if (!allSourceIds || !allCurrentIds) return null;
+	const changed = new Set([...changedIds].map((id) => id.toUpperCase()));
+	for (const { element } of [...source.blocks, ...current.blocks]) if (isWordElement(element, "p")) {
+		const id = paraIdAttribute(element)?.toUpperCase();
+		if (!id) return null;
+		const touched = changed.has(id) || !allSourceIds.has(id) || !allCurrentIds.has(id);
+		if (!paragraphIsSafe(element, touched)) return null;
+	} else if (!isWordElement(element, "tbl") && !isWordElement(element, "sectPr")) return null;
+	const sourceBody = parseDocumentBody(originalXml);
+	const currentBody = parseDocumentBody(serializedXml);
+	const barriers = (body) => ({
+		blocks: body.content.filter((block) => block.type !== "paragraph"),
+		finalSectionProperties: body.finalSectionProperties,
+		background: body.background
+	});
+	if (canonicalJson(barriers(sourceBody)) !== canonicalJson(barriers(currentBody))) return null;
+	const indexBlocks = (blocks) => {
+		let barrier = 0;
+		const indexed = /* @__PURE__ */ new Map();
+		for (const block of blocks) {
+			const key = isWordElement(block.element, "p") ? `p:${paraIdAttribute(block.element)?.toUpperCase()}` : `barrier:${barrier++}`;
+			indexed.set(key, block);
+		}
+		return indexed;
+	};
+	const before = indexBlocks(source.blocks);
+	const after = indexBlocks(current.blocks);
+	const survivingBefore = [...before.keys()].filter((key) => after.has(key));
+	const survivingAfter = [...after.keys()].filter((key) => before.has(key));
+	if (canonicalJson(survivingBefore) !== canonicalJson(survivingAfter)) return null;
+	const bindings = readRootNamespaceBindings(serializedXml);
+	const fragmentFor = (block) => paragraphFragment({
+		xml: serializedXml,
+		block,
+		bindings
+	});
+	const splices = [];
+	for (const [key, block] of before) if (!after.has(key)) splices.push({
+		start: block.start,
+		end: block.end,
+		newXml: ""
+	});
+	let pending = [];
+	for (const [key, block] of after) {
+		const original = before.get(key);
+		if (!original) {
+			const id = paraIdAttribute(block.element)?.toUpperCase();
+			if (!id || allSourceIds.has(id)) return null;
+			pending.push(fragmentFor(block));
+			continue;
+		}
+		const id = paraIdAttribute(block.element)?.toUpperCase();
+		const replacement = id !== void 0 && changed.has(id) ? fragmentFor(block) : originalXml.slice(original.start, original.end);
+		if (pending.length > 0 || replacement !== originalXml.slice(original.start, original.end)) splices.push({
+			start: original.start,
+			end: original.end,
+			newXml: pending.join("") + replacement
+		});
+		pending = [];
+	}
+	if (pending.length > 0) splices.push({
+		start: source.bodyEnd,
+		end: source.bodyEnd,
+		newXml: pending.join("")
+	});
+	return spliceXml(originalXml, splices);
+};
+//#endregion
+export { buildStructuralDocumentPatch };

package/dist/generated/text_shaper.js

@@ -1,6 +1,32 @@
 // @ts-nocheck -- generated and verified by build-shaper-wasm.ts
 /* @ts-self-types="./text_shaper.d.ts" */
 
+/**
+ * Resolve the bidirectional levels and visual order of one line.
+ *
+ * `right_to_left` is the paragraph direction, or `None` for rules P2 and P3.
+ * Returns `[paragraphLevel, charCount, level * charCount, visualIndex *
+ * charCount]`, counting characters as Unicode scalar values.
+ * @param {string} text
+ * @param {boolean | null} [right_to_left]
+ * @returns {Int32Array}
+ */
+export function resolveBidi(text, right_to_left) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.resolveBidi(retptr, ptr0, len0, isLikeNone(right_to_left) ? 0xFFFFFF : right_to_left ? 1 : 0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v2 = getArrayI32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export3(r0, r1 * 4, 4);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Shape one run of text with one face.
  *

package/dist/managers/editorShortcuts.d.ts

@@ -1,3 +1,4 @@
+import { HistoryShortcutOwner } from "../prosemirror/extensions/core/HistoryExtension.js";
 import { EditorState, Transaction } from "prosemirror-state";
 //#region src/managers/editorShortcuts.d.ts
 declare function isMacPlatform(): boolean;
@@ -17,19 +18,31 @@ type EditorKeydownIntent = {
 } | {
   type: "none";
 };
+/**
+ * An editor shortcut the host binds itself. The editor leaves its keys alone,
+ * so the host's binding (an IDE's undo stack, its own print command) is the
+ * only one that runs.
+ *  - `"history"`: undo and redo (Mod-z, Mod-y, Mod-Shift-z).
+ *  - `"print"`: Cmd/Ctrl+P.
+ */
+type HostShortcut = "history" | "print";
+/** Who answers the undo and redo keys when the host owns `hostShortcuts`. */
+declare const historyShortcutOwner: (hostShortcuts: readonly HostShortcut[]) => HistoryShortcutOwner;
 type ClassifyEditorKeydownOptions = {
   /** Whether the platform uses Cmd (Mac) rather than Ctrl as the primary modifier. */
   isMac: boolean;
   /** Whether focus is in a non-editor input/textarea/contenteditable. */
   isInputLike: boolean;
+  /** Shortcuts the host binds itself; their keys map to `none`. */
+  hostShortcuts: readonly HostShortcut[];
 };
 /**
  * Map a keydown to an editor intent:
  *  - Cmd/Ctrl+F or Cmd/Ctrl+H → open find
- *  - Cmd/Ctrl+P (no auto-repeat) → custom print
+ *  - Cmd/Ctrl+P (no auto-repeat) → custom print, unless the host owns print
  *  - Delete/Backspace (no modifiers, focus not in an input) → delete selected table
  */
-declare function classifyEditorKeydown(e: KeyboardEvent, { isMac, isInputLike }: ClassifyEditorKeydownOptions): EditorKeydownIntent;
+declare function classifyEditorKeydown(e: Pick<KeyboardEvent, "key" | "metaKey" | "ctrlKey" | "shiftKey" | "altKey" | "repeat">, { isMac, isInputLike, hostShortcuts }: ClassifyEditorKeydownOptions): EditorKeydownIntent;
 /**
  * Which key presses the editor's page-level shortcuts answer.
  *  - `"document"`: every press on the page.
@@ -69,4 +82,4 @@ declare function isKeydownInShortcutScope(event: {
  */
 declare function deleteSelectedTable(state: EditorState, dispatch: (tr: Transaction) => void): boolean;
 //#endregion
-export { ClassifyEditorKeydownOptions, EditorKeydownIntent, IsKeydownInShortcutScopeOptions, KeyboardShortcutScope, ShortcutScopeRoot, classifyEditorKeydown, deleteSelectedTable, isFocusInInputLike, isKeydownInShortcutScope, isMacPlatform };
+export { ClassifyEditorKeydownOptions, EditorKeydownIntent, HostShortcut, IsKeydownInShortcutScopeOptions, KeyboardShortcutScope, ShortcutScopeRoot, classifyEditorKeydown, deleteSelectedTable, historyShortcutOwner, isFocusInInputLike, isKeydownInShortcutScope, isMacPlatform };

package/dist/managers/editorShortcuts.js

@@ -16,19 +16,21 @@ function isFocusInInputLike(target, editorDom) {
 	if (target.isContentEditable && target !== editorDom) return true;
 	return false;
 }
+/** Who answers the undo and redo keys when the host owns `hostShortcuts`. */
+const historyShortcutOwner = (hostShortcuts) => hostShortcuts.includes("history") ? "host" : "editor";
 /**
 * Map a keydown to an editor intent:
 *  - Cmd/Ctrl+F or Cmd/Ctrl+H → open find
-*  - Cmd/Ctrl+P (no auto-repeat) → custom print
+*  - Cmd/Ctrl+P (no auto-repeat) → custom print, unless the host owns print
 *  - Delete/Backspace (no modifiers, focus not in an input) → delete selected table
 */
-function classifyEditorKeydown(e, { isMac, isInputLike }) {
+function classifyEditorKeydown(e, { isMac, isInputLike, hostShortcuts }) {
 	const cmdOrCtrl = isMac ? e.metaKey : e.ctrlKey;
 	if (!cmdOrCtrl && !e.shiftKey && !e.altKey && (e.key === "Delete" || e.key === "Backspace") && !isInputLike) return { type: "deleteSelectedTable" };
 	if (cmdOrCtrl && !e.shiftKey && !e.altKey) {
 		const key = e.key.toLowerCase();
 		if (key === "f" || key === "h") return { type: "openFind" };
-		if (key === "p" && !e.repeat) return { type: "print" };
+		if (key === "p" && !e.repeat && !hostShortcuts.includes("print")) return { type: "print" };
 	}
 	return { type: "none" };
 }
@@ -76,4 +78,4 @@ function deleteSelectedTable(state, dispatch) {
 	return false;
 }
 //#endregion
-export { classifyEditorKeydown, deleteSelectedTable, isFocusInInputLike, isKeydownInShortcutScope, isMacPlatform };
+export { classifyEditorKeydown, deleteSelectedTable, historyShortcutOwner, isFocusInInputLike, isKeydownInShortcutScope, isMacPlatform };

package/dist/prosemirror/extensions/StarterKit.d.ts

@@ -1,4 +1,5 @@
 import { AnyExtension } from "./types.js";
+import { HistoryShortcutOwner } from "./core/HistoryExtension.js";
 import { SelectionChangeCallback } from "../plugins/selectionTracker.js";
 //#region src/prosemirror/extensions/StarterKit.d.ts
 type StarterKitOptions = {
@@ -8,6 +9,8 @@ type StarterKitOptions = {
   historyDepth?: number;
   /** History new group delay (default: 500) */
   historyNewGroupDelay?: number;
+  /** Who answers the undo and redo keys (default: `"editor"`). */
+  historyShortcuts?: HistoryShortcutOwner;
   /** Selection change callback */
   onSelectionChange?: SelectionChangeCallback;
 };

package/dist/prosemirror/extensions/StarterKit.js

@@ -61,7 +61,8 @@ function createStarterKit(options = {}) {
 	add("paragraph", ParagraphExtension());
 	add("history", HistoryExtension({
 		...options.historyDepth !== void 0 ? { depth: options.historyDepth } : {},
-		...options.historyNewGroupDelay !== void 0 ? { newGroupDelay: options.historyNewGroupDelay } : {}
+		...options.historyNewGroupDelay !== void 0 ? { newGroupDelay: options.historyNewGroupDelay } : {},
+		...options.historyShortcuts !== void 0 ? { shortcuts: options.historyShortcuts } : {}
 	}));
 	for (const name of MARK_NESTING_ORDER) add(name, MARK_EXTENSIONS[name]());
 	add("bookmarkBoundary", BookmarkBoundaryExtension({ getInternalClipboardToken }));

package/dist/prosemirror/extensions/core/HistoryExtension.d.ts

@@ -3,10 +3,18 @@ import { Extension } from "../types.js";
 /**
  * History Extension — undo/redo via prosemirror-history
  */
+/**
+ * Who answers the undo and redo keys (Mod-z, Mod-y, Mod-Shift-z).
+ *  - `"editor"`: the extension binds them. Default.
+ *  - `"host"`: nothing binds them. The host keeps its own undo stack and runs
+ *    the `undo` / `redo` commands itself, so one press never undoes twice.
+ */
+type HistoryShortcutOwner = "editor" | "host";
 type HistoryOptions = {
   depth: number;
   newGroupDelay: number;
+  shortcuts: HistoryShortcutOwner;
 };
 declare const HistoryExtension: (options?: Partial<HistoryOptions> | undefined) => Extension;
 //#endregion
-export { HistoryExtension };
+export { HistoryExtension, HistoryShortcutOwner };

package/dist/prosemirror/extensions/core/HistoryExtension.js

@@ -4,7 +4,8 @@ const HistoryExtension = createExtension({
 	name: "history",
 	defaultOptions: {
 		depth: 100,
-		newGroupDelay: 500
+		newGroupDelay: 500,
+		shortcuts: "editor"
 	},
 	onSchemaReady(_ctx, options) {
 		return {
@@ -16,11 +17,11 @@ const HistoryExtension = createExtension({
 				undo: () => undo,
 				redo: () => redo
 			},
-			keyboardShortcuts: {
+			...options.shortcuts === "editor" && { keyboardShortcuts: {
 				"Mod-z": undo,
 				"Mod-y": redo,
 				"Mod-Shift-z": redo
-			}
+			} }
 		};
 	}
 });

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts

@@ -3,15 +3,15 @@ import { RemovedSectionReference, TrackedSectionEndpointRemoval } from "../../..
 import { EditorState, PluginKey, Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts
-declare const paragraphChangeTrackerKey: PluginKey<ParagraphChangeTrackerState>;
+declare const paragraphChangeTrackerKey: PluginKey<InternalParagraphChangeTrackerState>;
 type ParagraphChangeTrackerState = {
   /** Set of paraIds that were modified since last clear */
   changedParaIds: Set<string>;
-  /** Whether paragraphs were added or deleted (structural change) */
+  /** Whether paragraph order, membership, or block structure changed. */
   structuralChange: boolean;
-  /** Whether any edited paragraph lacked a paraId */
+  /** Whether edited paragraphs still lack IDs or source identity was unavailable. */
   hasUntrackedChanges: boolean;
-  /** Cached paragraph count to avoid full doc traversal on every transaction */
+  /** Paragraph count in the current tracked document. */
   paragraphCount: number;
   /** Cached section-endpoint count used to invalidate stale save authorization. */
   sectionEndpointCount: number;
@@ -20,6 +20,13 @@ type ParagraphChangeTrackerState = {
   /** Exact tracked-resolution transition that may reduce the saved section count. */
   sectionEndpointRemoval: TrackedSectionEndpointRemoval | null;
 };
+type InternalParagraphChangeTrackerState = ParagraphChangeTrackerState & {
+  /** Edited paragraph positions retained across allocator-only transactions. */
+  affectedParagraphPositions: Set<number>;
+  /** Editing an already unidentified source paragraph cannot become selective. */
+  hasUntrackedSourceChanges: boolean;
+  blockStructureFingerprint: string;
+};
 /**
  * Get the change tracker state from an EditorState
  */
@@ -29,7 +36,7 @@ declare function getChangeTrackerState(state: EditorState): ParagraphChangeTrack
  */
 declare function getChangedParagraphIds(state: EditorState): Set<string>;
 /**
- * Check if structural changes (paragraph add/delete) occurred
+ * Check if paragraph membership, order, or block structure changed
  */
 declare function hasStructuralChanges(state: EditorState): boolean;
 /**