@stll/folio-core 0.1.3 → 0.3.0

package/dist/prosemirror/commands/sectionBreak.js

@@ -0,0 +1,54 @@
+import { TextSelection } from "prosemirror-state";
+//#region src/prosemirror/commands/sectionBreak.ts
+/**
+* Insert a section break at the current cursor position.
+*
+* In OOXML a section break is the `sectPr` carried by the *last* paragraph of a
+* section. So we split the current paragraph at the cursor, mark the first half
+* with `sectionBreakType` (it becomes the section end), and leave the cursor in
+* the second half (the first paragraph of the new section). Content after the
+* cursor therefore flows into the new section — onto a new page for `nextPage`,
+* or in place for `continuous`.
+*/
+function insertSectionBreakAtCursor(breakType) {
+	return (state, dispatch) => {
+		const { schema } = state;
+		const paragraphType = schema.nodes["paragraph"];
+		if (!paragraphType) return false;
+		const { $from } = state.selection;
+		if (!($from.parent.isTextblock ? state.doc.resolve($from.before()).depth === 0 : $from.depth === 0)) return false;
+		if (dispatch) {
+			const tr = state.tr;
+			let cursorPos;
+			if ($from.parent.isTextblock) {
+				const paraPos = $from.before();
+				tr.split($from.pos);
+				const firstPara = tr.doc.nodeAt(paraPos);
+				if (firstPara) tr.setNodeMarkup(paraPos, void 0, {
+					...firstPara.attrs,
+					sectionBreakType: breakType
+				});
+				cursorPos = tr.mapping.map($from.pos);
+			} else {
+				const pos = $from.pos;
+				tr.insert(pos, paragraphType.create({ sectionBreakType: breakType }));
+				cursorPos = pos + 1;
+			}
+			tr.setSelection(TextSelection.create(tr.doc, cursorPos));
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+/**
+* Insert a "next page" section break at the cursor — starts a new section on a
+* new page.
+*/
+const insertSectionBreakNextPage = insertSectionBreakAtCursor("nextPage");
+/**
+* Insert a "continuous" section break at the cursor — starts a new section on
+* the same page.
+*/
+const insertSectionBreakContinuous = insertSectionBreakAtCursor("continuous");
+//#endregion
+export { insertSectionBreakContinuous, insertSectionBreakNextPage };

package/dist/prosemirror/commentIdAllocator.d.ts

@@ -0,0 +1,32 @@
+import { Comment } from "../types/content.js";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/commentIdAllocator.d.ts
+/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
+declare const PENDING_COMMENT_ID = -1;
+type CommentIdAllocator = {
+  /** Allocate the next ID and advance the counter. */next(): number;
+  /**
+   * On document load, bump the counter above the highest ID found in the
+   * loaded comments and tracked-change marks so subsequent allocations don't
+   * collide with already-present IDs.
+   */
+  seedAbove(maxId: number): void;
+};
+/**
+ * Create an instance-scoped monotonic comment/revision ID allocator. IDs are
+ * never reused (deleting a comment does not free its ID), and the counter is
+ * private to this allocator — multiple editors get independent ID spaces.
+ */
+declare function createCommentIdAllocator(): CommentIdAllocator;
+/**
+ * Seed an allocator above every comment/revision ID currently in the document
+ * — comment objects (including replies, which carry no mark) plus
+ * tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
+ * counter, this is safe to call on load (React) or before each allocation
+ * (Vue): new IDs never collide with or reuse an existing one, and the comment
+ * and revision ID spaces stay unified.
+ */
+declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: EditorView | null): void;
+//#endregion
+export { CommentIdAllocator, PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };

package/dist/prosemirror/commentIdAllocator.js

@@ -0,0 +1,35 @@
+//#region src/prosemirror/commentIdAllocator.ts
+/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
+const PENDING_COMMENT_ID = -1;
+/**
+* Create an instance-scoped monotonic comment/revision ID allocator. IDs are
+* never reused (deleting a comment does not free its ID), and the counter is
+* private to this allocator — multiple editors get independent ID spaces.
+*/
+function createCommentIdAllocator() {
+	let nextId = 1;
+	return {
+		next: () => nextId++,
+		seedAbove(maxId) {
+			if (maxId >= nextId) nextId = maxId + 1;
+		}
+	};
+}
+/**
+* Seed an allocator above every comment/revision ID currently in the document
+* — comment objects (including replies, which carry no mark) plus
+* tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
+* counter, this is safe to call on load (React) or before each allocation
+* (Vue): new IDs never collide with or reuse an existing one, and the comment
+* and revision ID spaces stay unified.
+*/
+function seedCommentAllocator(allocator, comments, view) {
+	let max = 0;
+	for (const comment of comments ?? []) max = Math.max(max, comment.id);
+	if (view) view.state.doc.descendants((node) => {
+		for (const mark of node.marks) if (mark.attrs["revisionId"] != null) max = Math.max(max, mark.attrs["revisionId"]);
+	});
+	allocator.seedAbove(max);
+}
+//#endregion
+export { PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };

package/dist/prosemirror/commentOps.d.ts

@@ -0,0 +1,35 @@
+import { Comment } from "../types/content.js";
+import { CommentIdAllocator } from "./commentIdAllocator.js";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/commentOps.d.ts
+/** Build a Comment object with a freshly-allocated ID. */
+declare function createComment(allocator: CommentIdAllocator, text: string, authorName: string, parentId?: number): Comment;
+type AddCommentOptions = {
+  paraId: string;
+  text: string;
+  author: string;
+  search?: string;
+};
+/**
+ * Locate the comment range (paragraph, narrowed by `search`), add the comment
+ * mark, dispatch, and return the created Comment. Returns null when the schema
+ * lacks a comment mark or the range can't be resolved. The caller owns adding
+ * the comment to its own state and showing the sidebar.
+ */
+declare function addCommentToRange(view: EditorView, options: AddCommentOptions, allocator: CommentIdAllocator): Comment | null;
+type ProposeChangeOptions = {
+  paraId: string;
+  search: string;
+  replaceWith: string;
+  author: string;
+};
+/**
+ * Apply a tracked change (insertion / deletion / replace) to the located range.
+ * `search === ''` means a pure insertion at the paragraph end; `replaceWith ===
+ * ''` means a pure deletion. Refuses to layer onto an existing tracked change.
+ * Returns true when a change was dispatched, false otherwise.
+ */
+declare function applyProposedChange(view: EditorView, options: ProposeChangeOptions, allocator: CommentIdAllocator): boolean;
+//#endregion
+export { AddCommentOptions, ProposeChangeOptions, addCommentToRange, applyProposedChange, createComment };

package/dist/prosemirror/commentOps.js

@@ -0,0 +1,104 @@
+import { findParagraphByParaId } from "./utils/findParagraphByParaId.js";
+import { findTextInPmParagraph } from "./paraText.js";
+//#region src/prosemirror/commentOps.ts
+/** Build a Comment object with a freshly-allocated ID. */
+function createComment(allocator, text, authorName, parentId) {
+	return {
+		id: allocator.next(),
+		author: authorName,
+		date: (/* @__PURE__ */ new Date()).toISOString(),
+		content: [{
+			type: "paragraph",
+			formatting: {},
+			content: [{
+				type: "run",
+				formatting: {},
+				content: [{
+					type: "text",
+					text
+				}]
+			}]
+		}],
+		...parentId !== void 0 && { parentId }
+	};
+}
+/**
+* Locate the comment range (paragraph, narrowed by `search`), add the comment
+* mark, dispatch, and return the created Comment. Returns null when the schema
+* lacks a comment mark or the range can't be resolved. The caller owns adding
+* the comment to its own state and showing the sidebar.
+*/
+function addCommentToRange(view, options, allocator) {
+	const { schema } = view.state;
+	if (!schema.marks["comment"]) return null;
+	const range = findParagraphByParaId(view.state.doc, options.paraId);
+	if (!range) return null;
+	let from = range.from + 1;
+	let to = range.to - 1;
+	if (options.search) {
+		const textRange = findTextInPmParagraph(view.state.doc, range.from, range.to, options.search);
+		if (!textRange) return null;
+		from = textRange.from;
+		to = textRange.to;
+	}
+	if (from >= to) return null;
+	const comment = createComment(allocator, options.text, options.author);
+	view.dispatch(view.state.tr.addMark(from, to, schema.marks["comment"].create({ commentId: comment.id })));
+	return comment;
+}
+/**
+* Apply a tracked change (insertion / deletion / replace) to the located range.
+* `search === ''` means a pure insertion at the paragraph end; `replaceWith ===
+* ''` means a pure deletion. Refuses to layer onto an existing tracked change.
+* Returns true when a change was dispatched, false otherwise.
+*/
+function applyProposedChange(view, options, allocator) {
+	const { schema } = view.state;
+	if (!schema.marks["deletion"] || !schema.marks["insertion"]) return false;
+	const range = findParagraphByParaId(view.state.doc, options.paraId);
+	if (!range) return false;
+	const isInsertion = options.search === "";
+	const isDeletion = options.replaceWith === "";
+	if (isInsertion && isDeletion) return false;
+	let textFrom;
+	let textTo;
+	if (isInsertion) {
+		textFrom = range.to - 1;
+		textTo = range.to - 1;
+	} else {
+		const textRange = findTextInPmParagraph(view.state.doc, range.from, range.to, options.search);
+		if (!textRange) return false;
+		textFrom = textRange.from;
+		textTo = textRange.to;
+	}
+	if (textFrom < textTo) {
+		let overlaps = false;
+		view.state.doc.nodesBetween(textFrom, textTo, (node) => {
+			for (const m of node.marks) if (m.type === schema.marks["insertion"] || m.type === schema.marks["deletion"]) {
+				overlaps = true;
+				return false;
+			}
+			return true;
+		});
+		if (overlaps) return false;
+	}
+	const revisionId = allocator.next();
+	const date = (/* @__PURE__ */ new Date()).toISOString();
+	const deletionMark = schema.marks["deletion"].create({
+		revisionId,
+		author: options.author,
+		date
+	});
+	const insertionMark = schema.marks["insertion"].create({
+		revisionId,
+		author: options.author,
+		date
+	});
+	let tr = view.state.tr;
+	if (!isInsertion) tr = tr.addMark(textFrom, textTo, deletionMark);
+	if (!isDeletion) tr = tr.insert(textTo, schema.text(options.replaceWith, [insertionMark]));
+	view.dispatch(tr);
+	return true;
+}
+//#endregion
+export { addCommentToRange, applyProposedChange, createComment };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -5,6 +5,7 @@ import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
 import { marksToTextFormatting } from "./fromProseDoc.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
@@ -77,8 +78,8 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 * Resolves style-based text formatting and passes it to runs so that
 * paragraph styles (like Heading1) apply their font size, color, etc.
 */
-function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting) {
-	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver);
+function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting, tableParagraphOverlay) {
+	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
 	const inlineNodes = [];
 	let inlineOffset = 0;
 	let bookmarksArr;
@@ -202,7 +203,7 @@ function canCarryTrackedRunMark(node, markType) {
 * If a styleResolver is provided, resolves style-based formatting and merges
 * with inline formatting. Inline formatting takes precedence.
 */
-function paragraphFormattingToAttrs(paragraph, styleResolver) {
+function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay) {
 	const formatting = paragraph.formatting;
 	const styleId = formatting?.styleId;
 	const attrs = {};
@@ -233,7 +234,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver) {
 	};
 	let stylePpr;
 	if (styleResolver) {
-		stylePpr = styleResolver.resolveParagraphStyle(styleId).paragraphFormatting;
+		stylePpr = styleResolver.resolveParagraphStyleInTable(styleId, tableParagraphOverlay).paragraphFormatting;
 		set("alignment", formatting?.alignment ?? stylePpr?.alignment);
 		set("spaceBefore", formatting?.spaceBefore ?? stylePpr?.spaceBefore);
 		set("spaceAfter", formatting?.spaceAfter ?? stylePpr?.spaceAfter);
@@ -299,6 +300,22 @@ function paragraphFormattingToAttrs(paragraph, styleResolver) {
 	return attrs;
 }
 /**
+* Pick the paragraph-spacing fields out of a table style's (or conditional
+* region's) `w:pPr` for use as the cell-paragraph cascade overlay. Narrower
+* than the full `ParagraphFormatting` bag — see
+* {@link TableCellParagraphSpacingOverlay}.
+*/
+function extractTableParagraphSpacingOverlay(pPr) {
+	if (!pPr) return;
+	const overlay = {};
+	if (pPr.spaceBefore !== void 0) overlay.spaceBefore = pPr.spaceBefore;
+	if (pPr.spaceAfter !== void 0) overlay.spaceAfter = pPr.spaceAfter;
+	if (pPr.lineSpacing !== void 0) overlay.lineSpacing = pPr.lineSpacing;
+	if (pPr.lineSpacingRule !== void 0) overlay.lineSpacingRule = pPr.lineSpacingRule;
+	if (pPr.contextualSpacing !== void 0) overlay.contextualSpacing = pPr.contextualSpacing;
+	return Object.keys(overlay).length > 0 ? overlay : void 0;
+}
+/**
 * Resolve table style conditional formatting
 */
 function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType) {
@@ -308,9 +325,11 @@ function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType
 	const conditional = style.tblStylePr.find((p) => p.type === conditionType);
 	if (!conditional) return;
 	const mergedRunProps = mergeTextFormatting(conditional.pPr?.runProperties ? resolveTextFormatting(conditional.pPr.runProperties, styleResolver) : void 0, conditional.rPr ? resolveTextFormatting(conditional.rPr, styleResolver) : void 0);
+	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(conditional.pPr);
 	const result = {};
 	if (conditional.tcPr) result.tcPr = conditional.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
+	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
 	return result;
 }
 function resolveTableBaseStyle(styleResolver, tableStyleId) {
@@ -318,10 +337,12 @@ function resolveTableBaseStyle(styleResolver, tableStyleId) {
 	const style = styleResolver.getStyle(tableStyleId);
 	if (!style) return;
 	const mergedRunProps = mergeTextFormatting(style.pPr?.runProperties ? resolveTextFormatting(style.pPr.runProperties, styleResolver) : void 0, style.rPr ? resolveTextFormatting(style.rPr, styleResolver) : void 0);
+	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(style.pPr);
 	const result = {};
 	if (style.tcPr) result.tcPr = style.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
-	return result.tcPr || result.rPr ? result : void 0;
+	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
+	return result.tcPr || result.rPr || result.pPr ? result : void 0;
 }
 function mergeConditionalStyles(base, override) {
 	if (!base && !override) return;
@@ -351,6 +372,8 @@ function mergeConditionalStyles(base, override) {
 	}
 	const mergedRPr = mergeTextFormatting(base.rPr, override.rPr);
 	if (mergedRPr) merged.rPr = mergedRPr;
+	const mergedPPr = mergeParagraphFormatting(base.pPr, override.pPr);
+	if (mergedPPr) merged.pPr = mergedPPr;
 	return merged;
 }
 function hasDirectRunFormatting(formatting) {
@@ -725,7 +748,7 @@ function convertTableCell(cell, styleResolver, isHeader, gridWidthPercent, condi
 	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
 	if (vMergeContinuationCells && vMergeContinuationCells.length > 0) attrs._docxVMergeContinuationCells = vMergeContinuationCells;
 	const contentNodes = [];
-	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(convertParagraph(content, styleResolver, void 0, conditionalStyle?.rPr));
+	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(convertParagraph(content, styleResolver, void 0, conditionalStyle?.rPr, conditionalStyle?.pPr));
 	else contentNodes.push(convertTable(content, styleResolver, theme));
 	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
 	const nodeType = isHeader ? "tableHeader" : "tableCell";

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

@@ -0,0 +1,3 @@
+import { ExtensionManager } from "./ExtensionManager.js";
+import { StarterKitOptions, createStarterKit } from "./StarterKit.js";
+export { ExtensionManager, type StarterKitOptions, createStarterKit };

package/dist/prosemirror/extensions/index.js

@@ -0,0 +1,3 @@
+import { ExtensionManager } from "./ExtensionManager.js";
+import { createStarterKit } from "./StarterKit.js";
+export { ExtensionManager, createStarterKit };

package/dist/prosemirror/imageCommit.d.ts

@@ -0,0 +1,42 @@
+import { Node } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/imageCommit.d.ts
+/**
+ * An image resize handle: the 4 corners ('nw'/'ne'/'se'/'sw') resize both axes
+ * and keep the aspect ratio; the 4 edge midpoints ('n'/'s'/'e'/'w') resize a
+ * single axis so the user can deliberately stretch the image (break aspect).
+ */
+type ImageResizeHandle = "nw" | "ne" | "se" | "sw" | "n" | "s" | "e" | "w";
+/**
+ * New image dimensions for a resize drag, shared by the React and Vue overlays
+ * (issue #266). Corner handles drive both axes (aspect-locked unless
+ * `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
+ * never lock. The non-driven axis is returned unchanged. Driven axes are
+ * clamped to a sane pixel range.
+ */
+declare function calculateResizedImageDimensions(handle: ImageResizeHandle, deltaX: number, deltaY: number, startWidth: number, startHeight: number, lockAspect: boolean): {
+  width: number;
+  height: number;
+};
+/** True when the image is floating (anchored) rather than inline. */
+declare function isFloatingImage(node: Node): boolean;
+/**
+ * Resize commit: set the image node's `width`/`height`. Returns `pmPos` to
+ * re-select, or null if the position no longer holds an image.
+ */
+declare function commitImageResize(view: EditorView, pmPos: number, newWidth: number, newHeight: number): number | null;
+/**
+ * Floating drag commit: rewrite the anchor's margin-relative `position`
+ * offsets (in EMU) so the image lands at the drop point while staying
+ * floating. Returns `pmPos` to re-select, or null on no-op / failure.
+ */
+declare function commitImageFloatMove(view: EditorView, pmPos: number, hOffsetEmu: number, vOffsetEmu: number): number | null;
+/**
+ * Inline drag commit: move the image node to `dropPos` via a delete + insert
+ * pair. Returns the PM position to re-select, or null when the drop is a
+ * no-op (same slot) or fails.
+ */
+declare function commitImageInlineMove(view: EditorView, pmPos: number, dropPos: number): number | null;
+//#endregion
+export { ImageResizeHandle, calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };

package/dist/prosemirror/imageCommit.js

@@ -0,0 +1,118 @@
+//#region src/prosemirror/imageCommit.ts
+const MIN_IMAGE_PX = 20;
+const MAX_IMAGE_PX = 2e3;
+/**
+* New image dimensions for a resize drag, shared by the React and Vue overlays
+* (issue #266). Corner handles drive both axes (aspect-locked unless
+* `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
+* never lock. The non-driven axis is returned unchanged. Driven axes are
+* clamped to a sane pixel range.
+*/
+function calculateResizedImageDimensions(handle, deltaX, deltaY, startWidth, startHeight, lockAspect) {
+	const drivesWidth = handle.includes("w") || handle.includes("e");
+	const drivesHeight = handle.includes("n") || handle.includes("s");
+	const isCorner = drivesWidth && drivesHeight;
+	const signX = handle.includes("w") ? -1 : 1;
+	const signY = handle.includes("n") ? -1 : 1;
+	let newWidth = drivesWidth ? startWidth + deltaX * signX : startWidth;
+	let newHeight = drivesHeight ? startHeight + deltaY * signY : startHeight;
+	if (isCorner && lockAspect) {
+		const scale = Math.max(newWidth / startWidth, newHeight / startHeight);
+		newWidth = startWidth * scale;
+		newHeight = startHeight * scale;
+	}
+	const clamp = (n) => Math.max(MIN_IMAGE_PX, Math.min(MAX_IMAGE_PX, n));
+	return {
+		width: drivesWidth ? clamp(newWidth) : startWidth,
+		height: drivesHeight ? clamp(newHeight) : startHeight
+	};
+}
+/** True when the image is floating (anchored) rather than inline. */
+function isFloatingImage(node) {
+	const wrapType = node.attrs["wrapType"];
+	return node.attrs["displayMode"] === "float" || (wrapType ? [
+		"square",
+		"tight",
+		"through"
+	].includes(wrapType) : false);
+}
+/** Resolve the image node at `pmPos`, or null if it isn't an image. */
+function imageNodeAt(view, pmPos) {
+	const node = view.state.doc.nodeAt(pmPos);
+	if (!node || node.type.name !== "image") return null;
+	return node;
+}
+/**
+* Resize commit: set the image node's `width`/`height`. Returns `pmPos` to
+* re-select, or null if the position no longer holds an image.
+*/
+function commitImageResize(view, pmPos, newWidth, newHeight) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		view.dispatch(view.state.tr.setNodeMarkup(pmPos, void 0, {
+			...node.attrs,
+			width: newWidth,
+			height: newHeight
+		}));
+		return pmPos;
+	} catch {
+		return null;
+	}
+}
+/**
+* Floating drag commit: rewrite the anchor's margin-relative `position`
+* offsets (in EMU) so the image lands at the drop point while staying
+* floating. Returns `pmPos` to re-select, or null on no-op / failure.
+*/
+function commitImageFloatMove(view, pmPos, hOffsetEmu, vOffsetEmu) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		const newPosition = {
+			horizontal: {
+				posOffset: hOffsetEmu,
+				relativeTo: "margin"
+			},
+			vertical: {
+				posOffset: vOffsetEmu,
+				relativeTo: "margin"
+			}
+		};
+		view.dispatch(view.state.tr.setNodeMarkup(pmPos, void 0, {
+			...node.attrs,
+			position: newPosition
+		}));
+		return pmPos;
+	} catch {
+		return null;
+	}
+}
+/**
+* Inline drag commit: move the image node to `dropPos` via a delete + insert
+* pair. Returns the PM position to re-select, or null when the drop is a
+* no-op (same slot) or fails.
+*/
+function commitImageInlineMove(view, pmPos, dropPos) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		if (dropPos === pmPos || dropPos === pmPos + 1) return null;
+		let tr = view.state.tr;
+		if (dropPos <= pmPos) {
+			tr = tr.delete(pmPos, pmPos + node.nodeSize);
+			tr = tr.insert(dropPos, node);
+			view.dispatch(tr);
+			return dropPos;
+		}
+		tr = tr.delete(pmPos, pmPos + node.nodeSize);
+		const adjusted = Math.min(dropPos - node.nodeSize, tr.doc.content.size);
+		tr = tr.insert(adjusted, node);
+		view.dispatch(tr);
+		return Math.min(adjusted, view.state.doc.content.size - 1);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };

package/dist/prosemirror/paraText.d.ts

@@ -0,0 +1,26 @@
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/paraText.d.ts
+/** Text of a single PM node (typically a paragraph), vanilla view. */
+declare function getVanillaNodeText(node: Node): string;
+/** Text between two doc positions, vanilla view. */
+declare function getVanillaTextBetween(doc: Node, from: number, to: number): string;
+/**
+ * Find `searchText` within a PM paragraph range and return its position.
+ *
+ * Returns null if:
+ *   - searchText is empty
+ *   - searchText is not found
+ *   - searchText appears more than once (ambiguous; caller disambiguates)
+ *
+ * The fullText is built from PM text nodes only and matches the vanilla
+ * view the agent reads via `read_document`: tracked insertions are
+ * excluded (not in the doc yet), tracked deletions are included (still
+ * in the doc until accepted), and comment markers are stripped.
+ */
+declare function findTextInPmParagraph(doc: Node, paragraphFrom: number, paragraphTo: number, searchText: string): {
+  from: number;
+  to: number;
+} | null;
+//#endregion
+export { findTextInPmParagraph, getVanillaNodeText, getVanillaTextBetween };

package/dist/prosemirror/paraText.js

@@ -0,0 +1,73 @@
+//#region src/prosemirror/paraText.ts
+/** Text of a single PM node (typically a paragraph), vanilla view. */
+function getVanillaNodeText(node) {
+	const parts = [];
+	node.descendants((child) => {
+		if (!child.isText || !child.text) return true;
+		if (child.marks.some((m) => m.type.name === "insertion")) return false;
+		parts.push(child.text);
+		return true;
+	});
+	return parts.join("");
+}
+/** Text between two doc positions, vanilla view. */
+function getVanillaTextBetween(doc, from, to) {
+	if (from >= to) return "";
+	const parts = [];
+	doc.nodesBetween(from, to, (child, pos) => {
+		if (!child.isText || !child.text) return;
+		if (child.marks.some((m) => m.type.name === "insertion")) return;
+		const start = Math.max(from, pos);
+		const end = Math.min(to, pos + child.text.length);
+		if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+	});
+	return parts.join("");
+}
+/**
+* Find `searchText` within a PM paragraph range and return its position.
+*
+* Returns null if:
+*   - searchText is empty
+*   - searchText is not found
+*   - searchText appears more than once (ambiguous; caller disambiguates)
+*
+* The fullText is built from PM text nodes only and matches the vanilla
+* view the agent reads via `read_document`: tracked insertions are
+* excluded (not in the doc yet), tracked deletions are included (still
+* in the doc until accepted), and comment markers are stripped.
+*/
+function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
+	if (!searchText) return null;
+	let fullText = "";
+	const textPositions = [];
+	doc.nodesBetween(paragraphFrom, paragraphTo, (node, pos) => {
+		if (!node.isText || !node.text) return;
+		if (node.marks.some((m) => m.type.name === "insertion")) return;
+		textPositions.push({
+			pos,
+			len: node.text.length
+		});
+		fullText += node.text;
+	});
+	const firstMatch = fullText.indexOf(searchText);
+	if (firstMatch === -1) return null;
+	if (fullText.indexOf(searchText, firstMatch + 1) !== -1) return null;
+	let charOffset = 0;
+	let fromPos = paragraphFrom;
+	let toPos = paragraphFrom;
+	for (const tp of textPositions) {
+		const segEnd = charOffset + tp.len;
+		if (charOffset <= firstMatch && firstMatch < segEnd) fromPos = tp.pos + (firstMatch - charOffset);
+		if (charOffset <= firstMatch + searchText.length && firstMatch + searchText.length <= segEnd) {
+			toPos = tp.pos + (firstMatch + searchText.length - charOffset);
+			break;
+		}
+		charOffset = segEnd;
+	}
+	return {
+		from: fromPos,
+		to: toPos
+	};
+}
+//#endregion
+export { findTextInPmParagraph, getVanillaNodeText, getVanillaTextBetween };

package/dist/prosemirror/plugins/templateDirectives.d.ts

@@ -12,6 +12,26 @@ type DirectiveRange = {
   clauseVersion?: string; /** True for block directives that occupy their own paragraph. */
   block: boolean;
 };
+/**
+ * Nesting depth (0-based) of every block-directive opener, derived purely from
+ * the scanned ranges by containment: walk the block openers/closers in document
+ * order with a kind-aware stack, and record each opener's depth as the stack size
+ * before it is pushed. Only `block:true` if/each pairs participate (inline markers
+ * resolve within a paragraph and get no rail).
+ *
+ * Matching is kind-aware so a mid-edit / unbalanced template stays sane: a closer
+ * pops the nearest opener of the *same family* ({{/if}} ⇒ {{#if}}, {{/each}} ⇒
+ * {{#each}}), dropping any still-open openers nested above it; a closer with no
+ * matching opener is ignored (never decrements a foreign block's depth). A blind
+ * open/close counter would mis-count here: e.g. a stray {{/each}} between {{#if}}
+ * and a nested {{#each}} would wrongly pull the inner {{#each}} back to depth 0.
+ *
+ * Keyed by the opener's `from` PM position, which is unique per marker, so the
+ * overlay can look a band's depth up from its opener range. This is a pure
+ * function of the ranges (no layout), hence unit-testable in isolation; the
+ * overlay caps the *visual* indentation separately.
+ */
+declare const computeBlockDepths: (ranges: readonly DirectiveRange[]) => Map<number, number>;
 declare const scanDirectives: (doc: Node) => DirectiveRange[];
 declare const templateDirectivesKey: PluginKey<DocScanState<undefined, DirectiveRange>>;
 type TemplateDirectivesPluginOptions = {
@@ -22,4 +42,4 @@ declare const createTemplateDirectivesPlugin: ({
 }?: TemplateDirectivesPluginOptions) => import("prosemirror-state").Plugin<DocScanState<undefined, DirectiveRange>>;
 declare const getTemplateDirectives: (state: EditorState) => readonly DirectiveRange[];
 //#endregion
-export { type DirectiveKind, DirectiveRange, TemplateDirectivesPluginOptions, createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };
+export { type DirectiveKind, DirectiveRange, TemplateDirectivesPluginOptions, computeBlockDepths, createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };