@stll/folio-core 0.49.0 → 0.51.0

package/dist/layout-engine/textBoxLayout.js

@@ -0,0 +1,137 @@
+import { emuToPixels } from "../utils/units.js";
+import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
+import { floatingTextBoxReservesBand } from "./types.js";
+//#region src/layout-engine/textBoxLayout.ts
+/**
+* Places text boxes onto pages: inline and anchored placement, page-pinned
+* wrap bands, and host-paragraph line offsets.
+*/
+const TEXT_BOX_ANCHOR_BLOCK_ID = Symbol.for("stll.textBoxAnchorBlockId");
+const readTextBoxAnchorBlockId = (block) => Reflect.get(block, TEXT_BOX_ANCHOR_BLOCK_ID);
+/**
+* Layout a text box block onto pages.
+*/
+function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPageHeight, sectionMarginBottom }) {
+	if (isPagePinnedBandTextBox(block)) {
+		const state = paginator.getCurrentState();
+		const bandTop = bandTopContentY(block.position?.vertical, {
+			pageHeight: sectionPageHeight,
+			marginTop: sectionMarginTop,
+			marginBottom: sectionMarginBottom,
+			boxHeight: measure.height
+		});
+		const x = bandFragmentX(block.position?.horizontal, {
+			pageWidth: state.page.size.w,
+			marginLeft: state.page.margins.left,
+			marginRight: state.page.margins.right,
+			activeColumnLeft: paginator.getColumnX(state.columnIndex),
+			activeColumnWidth: paginator.columnWidth,
+			boxWidth: measure.width
+		});
+		const fragment = {
+			kind: "textBox",
+			blockId: block.id,
+			x,
+			y: block.position?.vertical?.relativeTo === "page" ? sectionMarginTop + bandTop : state.topMargin + bandTop,
+			width: measure.width,
+			height: measure.height,
+			isPositioned: true,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+		};
+		paginator.addUnflowedFragment(fragment);
+		return;
+	}
+	if (block.position !== void 0) {
+		const state = paginator.getCurrentState();
+		const x = bandFragmentX(block.position.horizontal, {
+			pageWidth: state.page.size.w,
+			marginLeft: state.page.margins.left,
+			marginRight: state.page.margins.right,
+			activeColumnLeft: paginator.getColumnX(state.columnIndex),
+			activeColumnWidth: paginator.columnWidth,
+			boxWidth: measure.width
+		});
+		const vertical = block.position.vertical;
+		const anchorBlockId = readTextBoxAnchorBlockId(block);
+		const anchorParagraph = vertical?.relativeTo === "paragraph" && typeof anchorBlockId === "string" ? state.page.fragments.find((fragment) => fragment.kind === "paragraph" && fragment.blockId === anchorBlockId) : void 0;
+		const bandGeometry = {
+			pageHeight: sectionPageHeight,
+			marginTop: sectionMarginTop,
+			marginBottom: sectionMarginBottom,
+			boxHeight: measure.height
+		};
+		let y;
+		if (vertical?.relativeTo === "page") y = sectionMarginTop + bandTopContentY(vertical, bandGeometry);
+		else if (isPageFrameRelativeAnchor(vertical?.relativeTo)) y = state.topMargin + bandTopContentY(vertical, {
+			pageHeight: sectionPageHeight,
+			marginTop: sectionMarginTop,
+			marginBottom: sectionMarginBottom,
+			boxHeight: measure.height
+		});
+		else y = (anchorParagraph?.y ?? state.cursorY) + emuToPixels(vertical?.posOffset ?? 0);
+		const fragment = {
+			kind: "textBox",
+			blockId: block.id,
+			x,
+			y,
+			width: measure.width,
+			height: measure.height,
+			isPositioned: true,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+		};
+		paginator.addUnflowedFragment(fragment);
+		return;
+	}
+	const effect = block.effectExtent;
+	const occupiedHeight = measure.height + (effect?.top ?? 0) + (effect?.bottom ?? 0);
+	const occupiedWidth = measure.width + (effect?.left ?? 0) + (effect?.right ?? 0);
+	const host = block.hostParagraph;
+	const fragment = {
+		kind: "textBox",
+		blockId: block.id,
+		x: 0,
+		y: 0,
+		width: measure.width,
+		height: measure.height,
+		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+	};
+	const result = paginator.addFragment(fragment, occupiedHeight, host?.spacing?.before ?? 0, host?.spacing?.after ?? 0);
+	fragment.x = result.x + hostParagraphLineOffset(host, paginator.columnWidth, occupiedWidth) + (effect?.left ?? 0);
+	fragment.y = result.y + (effect?.top ?? 0);
+}
+/**
+* Where a line holding only an object of `width` starts within a column:
+* after the host paragraph's start and first-line indents, then aligned in
+* what remains before its end indent.
+*/
+function hostParagraphLineOffset(host, columnWidth, width) {
+	if (!host) return 0;
+	const indent = host.indent;
+	const start = (indent?.left ?? 0) + (indent?.firstLine ?? 0) - (indent?.hanging ?? 0);
+	const slack = Math.max(0, columnWidth - start - (indent?.right ?? 0) - width);
+	switch (host.alignment) {
+		case "center": return start + slack / 2;
+		case "right": return start + slack;
+		case "left":
+		case "justify":
+		case void 0: return start;
+		default:
+			host.alignment;
+			return start;
+	}
+}
+/**
+* A topAndBottom text box whose vertical anchor pins it to the page frame
+* (page/margin/margin-strip) — it floats to a fixed page position rather than
+* flowing in document order. Must agree with the measure pass's band extraction
+* (extractFloatingZones), which uses the same predicate. eigenpal #694.
+*/
+function isPagePinnedBandTextBox(block) {
+	if (!floatingTextBoxReservesBand(block)) return false;
+	return isPageFrameRelativeAnchor(block.position?.vertical?.relativeTo);
+}
+//#endregion
+export { layoutTextBox };

package/dist/layout-painter/renderPage.js

@@ -1,3 +1,4 @@
+import "../layout-engine/measure/floatingLineClearance.js";
 import { resolveFloatingTableX } from "../layout-engine/measure/floatingTablePosition.js";
 import { rectsToFloatingZones } from "../layout-engine/measure/floatingZones.js";
 import { DEFAULT_FONT_FAMILY } from "../layout-engine/measure/measureHelpers.js";

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/paged-layout/sectionBlockWidths.d.ts

@@ -1,6 +1,7 @@
 import { FlowBlock } from "../layout-engine/types.js";
 import { SectionStartAdvance } from "../layout-engine/section-breaks.js";
-import { SectionLayoutConfig } from "../layout-engine/index.js";
+import { SectionLayoutConfig } from "../layout-engine/sectionLayout.js";
+import "../layout-engine/index.js";
 //#region src/paged-layout/sectionBlockWidths.d.ts
 type ComputePerBlockMeasureInput = {
   blocks: FlowBlock[];

package/dist/paged-layout/sectionBlockWidths.js

@@ -1,7 +1,7 @@
-import { collectSectionConfigs } from "../layout-engine/index.js";
 import { hasPageBreakBefore } from "../layout-engine/keep-together.js";
 import { calculateColumnLefts, calculateColumnWidths } from "../layout-engine/paginator.js";
 import { physicalColumnRegionIsShared, sectionStartAdvanceOf } from "../layout-engine/section-breaks.js";
+import { collectSectionConfigs } from "../layout-engine/sectionLayout.js";
 //#region src/paged-layout/sectionBlockWidths.ts
 function resolvePreBlockPageTransition(block, config) {
 	if (!hasPageBreakBefore(block)) return { type: "none" };

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;
 /**

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.js

@@ -18,9 +18,20 @@ const isTrackedSectionEndpointRemovalMeta = (value) => typeof value === "object"
 function countDocumentStructure(doc) {
 	let paragraphs = 0;
 	let sectionEndpoints = 0;
+	const blockRecords = [];
 	const endpointRecords = [];
 	const visit = (parent, parentPath) => {
 		parent.forEach((node, _offset, index) => {
+			const path = parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`;
+			blockRecords.push(node.type.name === "paragraph" ? [
+				path,
+				node.type.name,
+				node.attrs["paraId"] ?? null
+			] : [
+				path,
+				node.type.name,
+				canonicalJson(node.attrs)
+			]);
 			if (node.type.name === "paragraph") {
 				paragraphs++;
 				const sectionProperties = sectionPropertiesOf(node);
@@ -34,34 +45,36 @@ function countDocumentStructure(doc) {
 				}
 				return;
 			}
-			if (node.childCount > 0) {
-				const path = parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`;
-				visit(node, path);
-			}
+			if (node.childCount > 0) visit(node, path);
 		});
 	};
 	visit(doc, "");
 	return {
+		blockStructureFingerprint: JSON.stringify(blockRecords),
 		paragraphs,
 		sectionEndpoints,
 		sectionEndpointFingerprint: canonicalJson(endpointRecords)
 	};
 }
+const isUsableParaId = (value) => typeof value === "string" && value.length > 0 && value !== "00000000";
 /**
 * Collect paraIds of all paragraphs that overlap with the given range
 */
 function collectAffectedParaIds(doc, from, to) {
 	const ids = /* @__PURE__ */ new Set();
+	const positions = /* @__PURE__ */ new Set();
 	let hasUntracked = false;
-	doc.nodesBetween(from, to, (node) => {
+	doc.nodesBetween(from, to, (node, pos) => {
 		if (node.type.name === "paragraph") {
+			positions.add(pos);
 			const paraId = node.attrs["paraId"];
-			if (paraId) ids.add(paraId);
+			if (isUsableParaId(paraId)) ids.add(paraId);
 			else hasUntracked = true;
 		}
 	});
 	return {
 		ids,
+		positions,
 		hasUntracked
 	};
 }
@@ -75,28 +88,40 @@ function collectAffectedParaIdsFromMarkLikeStep(doc, from, to) {
 	const hi = Math.max(from, to);
 	const primary = collectAffectedParaIds(doc, lo, hi > lo ? hi : lo + 1);
 	if (primary.ids.size > 0 || primary.hasUntracked) return primary;
-	try {
-		const $p = doc.resolve(lo);
-		for (let d = $p.depth; d >= 0; d--) {
-			const n = $p.node(d);
-			if (n.type.name === "paragraph") {
-				const paraId = n.attrs["paraId"];
-				if (paraId) return {
-					ids: /* @__PURE__ */ new Set([paraId]),
-					hasUntracked: false
-				};
-				return {
-					ids: /* @__PURE__ */ new Set(),
-					hasUntracked: true
-				};
-			}
+	const $p = doc.resolve(lo);
+	for (let depth = $p.depth; depth > 0; depth--) {
+		const node = $p.node(depth);
+		if (node.type.name === "paragraph") {
+			const paraId = node.attrs["paraId"];
+			return {
+				ids: new Set(isUsableParaId(paraId) ? [paraId] : []),
+				positions: /* @__PURE__ */ new Set([$p.before(depth)]),
+				hasUntracked: !isUsableParaId(paraId)
+			};
 		}
-	} catch {}
+	}
 	return {
 		ids: /* @__PURE__ */ new Set(),
+		positions: /* @__PURE__ */ new Set(),
 		hasUntracked: false
 	};
 }
+/** Map an edited paragraph's interior so markup replacement retains its ownership. */
+const mapParagraphPosition = (tr, position) => {
+	const mapped = tr.mapping.mapResult(position + 1, 1);
+	if (mapped.deletedAcross) return null;
+	const $position = tr.doc.resolve(mapped.pos);
+	for (let depth = $position.depth; depth > 0; depth--) if ($position.node(depth).type.name === "paragraph") return $position.before(depth);
+	return null;
+};
+const mapAffectedParagraphPositions = (tr, positions) => {
+	const mappedPositions = /* @__PURE__ */ new Set();
+	for (const position of positions) {
+		const mapped = mapParagraphPosition(tr, position);
+		if (mapped !== null) mappedPositions.add(mapped);
+	}
+	return mappedPositions;
+};
 function mapStepPosition(remap, pos, assoc) {
 	return remap.map(pos, assoc);
 }
@@ -107,6 +132,9 @@ function createParagraphChangeTrackerPlugin() {
 			init(_config, state) {
 				const counts = countDocumentStructure(state.doc);
 				return {
+					affectedParagraphPositions: /* @__PURE__ */ new Set(),
+					hasUntrackedSourceChanges: false,
+					blockStructureFingerprint: counts.blockStructureFingerprint,
 					changedParaIds: /* @__PURE__ */ new Set(),
 					structuralChange: false,
 					hasUntrackedChanges: false,
@@ -123,6 +151,9 @@ function createParagraphChangeTrackerPlugin() {
 				if (meta === CLEAR_META) {
 					const counts = countDocumentStructure(tr.doc);
 					return {
+						affectedParagraphPositions: /* @__PURE__ */ new Set(),
+						hasUntrackedSourceChanges: false,
+						blockStructureFingerprint: counts.blockStructureFingerprint,
 						changedParaIds: /* @__PURE__ */ new Set(),
 						structuralChange: false,
 						hasUntrackedChanges: false,
@@ -133,13 +164,22 @@ function createParagraphChangeTrackerPlugin() {
 					};
 				}
 				if (meta === IGNORE_META) {
-					const counts = tr.docChanged ? countDocumentStructure(tr.doc) : {
-						paragraphs: prevState.paragraphCount,
-						sectionEndpoints: prevState.sectionEndpointCount,
-						sectionEndpointFingerprint: prevState.sectionEndpointFingerprint
-					};
+					if (!tr.docChanged) return prevState;
+					const counts = countDocumentStructure(tr.doc);
+					const affectedParagraphPositions = mapAffectedParagraphPositions(tr, prevState.affectedParagraphPositions);
+					const changedParaIds = /* @__PURE__ */ new Set();
+					let unresolvedChanges = prevState.hasUntrackedSourceChanges;
+					for (const position of affectedParagraphPositions) {
+						const paraId = tr.doc.nodeAt(position)?.attrs["paraId"];
+						if (isUsableParaId(paraId)) changedParaIds.add(paraId);
+						else unresolvedChanges = true;
+					}
 					return {
 						...prevState,
+						affectedParagraphPositions,
+						changedParaIds,
+						hasUntrackedChanges: unresolvedChanges,
+						blockStructureFingerprint: counts.blockStructureFingerprint,
 						paragraphCount: counts.paragraphs,
 						sectionEndpointCount: counts.sectionEndpoints,
 						sectionEndpointRemoval: counts.sectionEndpointFingerprint === prevState.sectionEndpointFingerprint ? prevState.sectionEndpointRemoval : null,
@@ -162,6 +202,9 @@ function createParagraphChangeTrackerPlugin() {
 					};
 				} else sectionEndpointRemoval = null;
 				const newState = {
+					affectedParagraphPositions: mapAffectedParagraphPositions(tr, prevState.affectedParagraphPositions),
+					hasUntrackedSourceChanges: prevState.hasUntrackedSourceChanges,
+					blockStructureFingerprint: counts.blockStructureFingerprint,
 					changedParaIds: new Set(prevState.changedParaIds),
 					structuralChange: prevState.structuralChange || meta === STRUCTURAL_META,
 					hasUntrackedChanges: prevState.hasUntrackedChanges,
@@ -176,12 +219,13 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, range.from, 1);
 						const to = mapStepPosition(remap, range.to, -1);
 						if (to <= from) continue;
-						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 					}
 				}
-				if (prevState.paragraphCount !== newCount) newState.structuralChange = true;
+				if (prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) newState.structuralChange = true;
 				for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
 					const step = tr.steps[stepIndex];
 					const remap = tr.mapping.slice(stepIndex + 1);
@@ -189,7 +233,8 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, step.from, 1);
 						const to = mapStepPosition(remap, step.to, -1);
 						if (to <= from) continue;
-						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 						continue;
@@ -199,7 +244,8 @@ function createParagraphChangeTrackerPlugin() {
 						const node = tr.doc.nodeAt(pos);
 						if (!node) continue;
 						const end = pos + node.nodeSize;
-						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
+						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 						continue;
@@ -208,11 +254,23 @@ function createParagraphChangeTrackerPlugin() {
 						const from = mapStepPosition(remap, newStart, 1);
 						const to = mapStepPosition(remap, newEnd, -1);
 						if (to < from) return;
-						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
+						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
+						for (const position of positions) newState.affectedParagraphPositions.add(position);
 						for (const id of ids) newState.changedParaIds.add(id);
 						if (hasUntracked) newState.hasUntrackedChanges = true;
 					});
 				}
+				if (newState.hasUntrackedChanges || prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) tr.before.descendants((node, position) => {
+					if (node.type.name !== "paragraph") return true;
+					if (!isUsableParaId(node.attrs["paraId"])) {
+						const mapped = mapParagraphPosition(tr, position);
+						if (mapped === null || newState.affectedParagraphPositions.has(mapped)) {
+							newState.hasUntrackedSourceChanges = true;
+							newState.hasUntrackedChanges = true;
+						}
+					}
+					return false;
+				});
 				return newState;
 			}
 		}
@@ -231,7 +289,7 @@ function getChangedParagraphIds(state) {
 	return getChangeTrackerState(state)?.changedParaIds ?? /* @__PURE__ */ new Set();
 }
 /**
-* Check if structural changes (paragraph add/delete) occurred
+* Check if paragraph membership, order, or block structure changed
 */
 function hasStructuralChanges(state) {
 	return getChangeTrackerState(state)?.structuralChange ?? false;