@stll/folio-core 0.54.0 → 0.54.2

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,4 +1,5 @@
 import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
+import { clearIndentOnBackspace } from "../commands/clearParagraphIndent.js";
 import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
 import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { encloseWholeControls } from "../contentControlRevisions.js";
@@ -10,14 +11,16 @@ import { rebaseParagraphRuns } from "../rebaseParagraphRunFormatting.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { paragraphRunStyleContext } from "../runStyleFormatting.js";
 import { cellPasteRange, pasteTableCells } from "../tableCellPaste.js";
-import { handleEditorBeforeInput } from "../textInput.js";
+import { afterNativeCompositionFlush, handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
 import { getDocumentNumbering } from "./documentNumbering.js";
-import { getDocumentStyleResolver } from "./documentStyleState.js";
+import { documentStylesKey, getDocumentStyleResolver } from "./documentStyleState.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
 import { Slice } from "prosemirror-model";
+import { CellSelection } from "prosemirror-tables";
 import { Mapping, ReplaceStep } from "prosemirror-transform";
-import { AllSelection, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
+import { AllSelection, EditorState, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
+import { joinBackward, joinForward, selectNodeBackward, selectNodeForward } from "prosemirror-commands";
 import { isHistoryTransaction } from "prosemirror-history";
 import { undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/plugins/suggestionMode.ts
@@ -241,10 +244,44 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 function handleSuggestionPaste(view, slice, pluginState) {
 	const { selection } = view.state;
 	const selectsAll = selection instanceof AllSelection;
-	if (!(selection instanceof TextSelection || selectsAll) || selection.empty) return false;
+	if (!(selection instanceof TextSelection || selectsAll)) return false;
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return false;
+	if (selection.empty) {
+		const { $from } = selection;
+		const closedTable = slice.openStart === 0 && slice.openEnd === 0 && slice.content.firstChild?.type.name === "table" && slice.content.lastChild?.type.name === "table";
+		const prefix = $from.parent.content.cut(0, $from.parentOffset);
+		let deletedPrefix = prefix.size > 0;
+		prefix.forEach((node) => {
+			if (!node.marks.some((mark) => mark.type === deletionType)) deletedPrefix = false;
+		});
+		if (!closedTable || $from.parent.type.name !== "paragraph" || !deletedPrefix) return false;
+		const suffix = $from.parent.content.cut($from.parentOffset);
+		let deletedSuffix = true;
+		suffix.forEach((node) => {
+			if (!node.marks.some((mark) => mark.type === deletionType)) deletedSuffix = false;
+		});
+		const tr = view.state.tr.setMeta(SUGGESTION_META, true).setMeta("paste", true);
+		const at = $from.before();
+		tr.replaceRange(at, at, slice);
+		const revision = makeMarkAttrs(pluginState);
+		const end = tr.mapping.map(at, 1);
+		enclosePastedRunRevisions({
+			tr,
+			from: at,
+			to: end,
+			revision
+		});
+		markRangeAsInserted(tr, tr.doc, at, end, insertionType, deletionType, revision);
+		if (deletedSuffix && $from.parent.attrs["pPrMark"] == null && !paragraphEndsItsContainer($from.doc.resolve($from.before()), "paragraph")) tr.setNodeAttribute(tr.mapping.map($from.before()), "pPrMark", {
+			kind: "del",
+			info: makeParagraphMarkInfo(pluginState)
+		});
+		tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(selection.from)));
+		view.dispatch(tr.scrollIntoView());
+		return true;
+	}
 	if (selectsAll && (slice.openStart > 0 || slice.openEnd > 0)) slice = new Slice(view.state.tr.replaceSelection(slice).doc.content, 0, 0);
 	const { from, to } = selectsAll ? {
 		from: Selection.atStart(view.state.doc).from,
@@ -372,16 +409,54 @@ function handleSuggestionTableCellPaste(view, slice, pluginState) {
 			const insertFrom = tr.mapping.slice(mapFrom).map(to);
 			const sizeBefore = tr.doc.content.size;
 			tr.replaceRange(insertFrom, insertFrom, content);
-			const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			let insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			let pastedFrom = insertFrom;
+			const finalParagraph = cell.lastChild;
+			const $pasteFrom = tr.doc.resolve(pastedFrom);
+			const $pasteTo = tr.doc.resolve(insertTo);
+			if (content.openStart > 0 && content.openEnd > 0 && finalParagraph?.type.name === "paragraph" && $pasteFrom.parent.type.name === "paragraph" && $pasteTo.parent.type.name === "paragraph" && $pasteFrom.before() !== $pasteTo.before()) {
+				tr.setNodeAttribute($pasteFrom.before(), "pPrMark", {
+					kind: "ins",
+					info: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+				tr.setNodeAttribute($pasteTo.before(), "pPrMark", finalParagraph.attrs["pPrMark"]);
+				recordReplacedParagraphProperties({
+					tr,
+					position: $pasteTo.before(),
+					replaced: finalParagraph,
+					revision: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+			}
+			const emptyInsertions = [];
+			tr.doc.nodeAt(cellPos)?.forEach((node, offset) => {
+				const pos = cellPos + 1 + offset;
+				if (pos < pastedFrom && node.type.name === "paragraph" && node.content.size === 0 && isCurrentAuthorParagraphInsertion(node.attrs["pPrMark"], pluginState.author)) emptyInsertions.push({
+					from: pos,
+					to: pos + node.nodeSize
+				});
+			});
+			const retraction = tr.mapping.maps.length;
+			for (const range of emptyInsertions.toReversed()) tr.delete(range.from, range.to);
+			const retracted = tr.mapping.slice(retraction);
+			pastedFrom = retracted.map(pastedFrom);
+			insertTo = retracted.map(insertTo);
 			enclosePastedRunRevisions({
 				tr,
-				from: insertFrom,
+				from: pastedFrom,
 				to: insertTo,
 				revision
 			});
-			markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, revision);
-			tr.doc.nodesBetween(insertFrom, insertTo, (node, pos) => {
-				if (node.type.name === "paragraph" && pos >= insertFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+			markRangeAsInserted(tr, tr.doc, pastedFrom, insertTo, insertionType, deletionType, revision);
+			tr.doc.nodesBetween(pastedFrom, insertTo, (node, pos) => {
+				if (node.type.name === "paragraph" && pos >= pastedFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
 					kind: "ins",
 					info: {
 						id: revision.revisionId,
@@ -407,11 +482,7 @@ function rotateIntoFinalParagraph(state, tr, replacedPos, attrs) {
 	const replaced = tr.doc.nodeAt(replacedPos);
 	const first = replaced ? tr.doc.nodeAt(replacedPos + replaced.nodeSize) : null;
 	if (!replaced || !first) return replacedPos;
-	const replacedAttrs = expectParagraphAttrs(replaced);
-	const previousFormatting = {
-		...paragraphPropertiesSnapshot(replaced),
-		numPr: replacedAttrs.numPr ?? null
-	};
+	const previousFormatting = paragraphPropertiesSnapshot(replaced);
 	const { _sectionProperties: sectionProperties } = replaced.attrs;
 	tr.join(replacedPos + replaced.nodeSize);
 	tr.setNodeMarkup(replacedPos, void 0, first.attrs);
@@ -537,15 +608,38 @@ function suggestRangeDeletion(state, tr, from, to) {
 * prior author's revision must not be silently overwritten.
 */
 function handleSuggestionEnter(view, pluginState) {
-	const { $from } = view.state.selection;
-	if ($from.parent.type.name !== "paragraph") return false;
+	const state = view.state;
+	if (state.selection.$from.parent.type.name !== "paragraph") return false;
+	const replacement = { tr: null };
+	let splitState = state;
+	if (state.selection instanceof TextSelection && !state.selection.empty) {
+		if (!handleSuggestionDelete(state, (tr) => {
+			replacement.tr = tr;
+			const styles = documentStylesKey.get(state);
+			const plugins = [];
+			if (styles) {
+				const spec = { ...styles.spec };
+				delete spec.appendTransaction;
+				delete spec.filterTransaction;
+				plugins.push(new Plugin(spec));
+			}
+			splitState = state.reconfigure({ plugins }).apply(tr);
+		}, "forward")) return false;
+	}
+	const { $from } = splitState.selection;
 	const sourcePos = $from.before();
 	const sourceAttrs = $from.parent.attrs;
 	const captured = { tr: null };
-	if (!splitBlockClearBorders(view.state, (tr) => {
+	if (!splitBlockClearBorders(splitState, (tr) => {
 		captured.tr = tr;
 	}, view) || !captured.tr) return false;
-	const tr = captured.tr;
+	const tr = replacement.tr ?? captured.tr;
+	if (replacement.tr) {
+		for (const step of captured.tr.steps) tr.step(step);
+		tr.setSelection(captured.tr.selection.getBookmark().resolve(tr.doc));
+		tr.setStoredMarks(captured.tr.storedMarks);
+	}
+	tr.setMeta(SUGGESTION_META, true);
 	if (sourceAttrs["pPrMark"] == null) {
 		if (tr.doc.nodeAt(sourcePos)?.type.name === "paragraph") {
 			const markInfo = {
@@ -565,6 +659,24 @@ function handleSuggestionEnter(view, pluginState) {
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
+/** Find the adjacent visible unit without consuming a bookmark range marker. */
+function caretDeleteTarget(state, direction) {
+	const { $from } = state.selection;
+	const backward = direction === "backward";
+	let from = backward ? $from.pos - 1 : $from.pos;
+	let to = backward ? $from.pos : $from.pos + 1;
+	while (from >= $from.start() && to <= $from.end()) {
+		const adjacent = state.doc.resolve(from).nodeAfter;
+		if (adjacent?.type.name !== "bookmarkBoundary") return {
+			type: "inlineUnit",
+			from,
+			to
+		};
+		from += backward ? -adjacent.nodeSize : adjacent.nodeSize;
+		to += backward ? -adjacent.nodeSize : adjacent.nodeSize;
+	}
+	return { type: "paragraphEdge" };
+}
 /**
 * Detect a caret-at-paragraph-boundary scenario where Backspace/Delete should
 * record a tracked paragraph-mark deletion instead of joining paragraphs.
@@ -576,8 +688,8 @@ function handleSuggestionEnter(view, pluginState) {
 * - Delete-at-paragraph-end     → current paragraph.
 *
 * Returns `null` when there is no adjacent sibling paragraph (the join would
-* not produce paragraph-mark merging — e.g. doc start, doc end, or sibling
-* is a table). The default merge path then runs unchanged.
+* not produce paragraph-mark merging, e.g. doc start, doc end, or a table).
+* Bookmark markers at an edge do not hide the adjacent paragraph break.
 */
 function paragraphBoundaryTarget(state, direction) {
 	const { $from, empty } = state.selection;
@@ -585,14 +697,13 @@ function paragraphBoundaryTarget(state, direction) {
 	if ($from.parent.type.name !== "paragraph") return null;
 	const paragraphStart = $from.before();
 	const paragraphEnd = $from.after();
+	if (caretDeleteTarget(state, direction).type !== "paragraphEdge") return null;
 	if (direction === "backward") {
-		if ($from.parentOffset !== 0) return null;
 		if (paragraphStart === 0) return null;
 		const prev = state.doc.resolve(paragraphStart).nodeBefore;
 		if (!prev || prev.type.name !== "paragraph") return null;
 		return paragraphStart - prev.nodeSize;
 	}
-	if ($from.parentOffset !== $from.parent.content.size) return null;
 	if (paragraphEnd >= state.doc.content.size) return null;
 	const next = state.doc.resolve(paragraphEnd).nodeAfter;
 	if (!next || next.type.name !== "paragraph") return null;
@@ -616,7 +727,13 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		const joined = view.state.doc.nodeAt(joinPos);
 		try {
 			tr.join(joinPos);
-			tr.setNodeAttribute(targetParagraphPos, "pPrMark", null);
+			tr.setNodeAttribute(targetParagraphPos, "pPrMark", joined?.type === targetNode.type ? expectParagraphAttrs(joined).pPrMark : null);
+			if (joined?.type === targetNode.type) recordReplacedParagraphProperties({
+				tr,
+				position: targetParagraphPos,
+				replaced: joined,
+				revision: existingMark.info
+			});
 			const styleResolver = getDocumentStyleResolver(view.state);
 			if (styleResolver && joined?.type === targetNode.type && joined.content.size > 0) rebaseParagraphRuns({
 				previousContext: paragraphRunStyleContext(joined, styleResolver),
@@ -675,15 +792,28 @@ function handleSuggestionDelete(state, dispatch, direction) {
 			to: rangeTo.pos
 		}).sort((a, b) => b.from - a.from);
 		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState, state);
-		const cursorPos = tr.mapping.map($to.pos);
-		tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
+		if (state.selection instanceof CellSelection) tr.setSelection(state.selection.map(tr.doc, tr.mapping));
+		else {
+			const cursorPos = tr.mapping.map($to.pos);
+			tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
+		}
 		dispatch(tr.scrollIntoView());
 		return true;
 	}
 	const isBackward = direction === "backward";
-	const deletePos = isBackward ? $from.pos - 1 : $from.pos;
-	const deleteEnd = isBackward ? $from.pos : $from.pos + 1;
-	if (deletePos < 0 || deleteEnd > state.doc.content.size) return true;
+	const target = caretDeleteTarget(state, direction);
+	if (target.type === "paragraphEdge") {
+		const edge = isBackward ? $from.start() : $from.end();
+		if ($from.pos === edge) return false;
+		const virtual = EditorState.create({
+			doc: state.doc,
+			selection: TextSelection.create(state.doc, edge)
+		});
+		if ((isBackward ? joinBackward : joinForward)(virtual, dispatch)) return true;
+		return (isBackward ? selectNodeBackward : selectNodeForward)(virtual, dispatch);
+	}
+	const deletePos = target.from;
+	const deleteEnd = target.to;
 	const noteRange = expandNoteReferenceDeletionRange(state.doc, deletePos, deleteEnd);
 	const rangeFrom = noteRange?.from ?? deletePos;
 	const rangeTo = noteRange?.to ?? deleteEnd;
@@ -705,19 +835,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 }
 /** Apply the editor's selected-content deletion path for a host cut action. */
 const deleteSelectionAsSuggestion = (state, dispatch) => state.selection.empty ? false : handleSuggestionDelete(state, dispatch, "forward");
-/**
-* Mark the text committed by an IME composition as a tracked insertion.
-*
-* Invoked from `compositionend` (deferred to a microtask) rather than from the
-* `appendTransaction` catch-all. ProseMirror commits composed text as part of
-* its own composition-end flush; adding the insertion mark *synchronously*
-* during that flush re-wraps the very text node the IME just finalized, which
-* corrupts CJK (Japanese / Chinese / Korean) input — characters duplicate or
-* garble. Running one tick later, after the composition has settled, wraps the
-* committed range safely. `markRangeAsInserted` skips nodes that already carry a
-* tracked-change mark, so this is idempotent. eigenpal/docx-editor#938.
-*/
-function markComposedAsInsertion(view, from, pluginState, replaced) {
+function markComposedAsInsertion({ view, from, pluginState, replaced, compositionId }) {
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return;
@@ -725,9 +843,16 @@ function markComposedAsInsertion(view, from, pluginState, replaced) {
 	if (to <= from && !replaced) return;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
+	if (compositionId !== null) tr.setMeta("composition", compositionId);
 	if (replaced) {
-		tr.insert(from, replaced.content);
-		markRangeAsDeleted(tr, tr.doc, from, from + replaced.content.size, insertionType, deletionType, pluginState);
+		tr.replaceRange(from, from, replaced);
+		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), insertionType, deletionType, pluginState);
+		const restoredEnd = tr.doc.resolve(tr.mapping.map(from, 1));
+		const restoredStart = tr.doc.resolve(from);
+		if (restoredStart.parent.type.name === "paragraph" && restoredEnd.parent.type.name === "paragraph" && restoredStart.parent !== restoredEnd.parent) {
+			const mark = expectParagraphAttrs(restoredStart.parent).pPrMark;
+			if (mark?.kind === "del") carryIntoParagraphLeft(view.state, tr, view.state.doc.resolve(from).parent, restoredEnd.before(), mark.info);
+		}
 	}
 	const insertionFrom = tr.mapping.map(from, 1);
 	const insertionTo = tr.mapping.map(to, 1);
@@ -777,6 +902,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 	let composing = false;
 	let compositionFrom = null;
 	let compositionReplaced = null;
+	let compositionId = null;
 	return new Plugin({
 		key: suggestionModeKey,
 		state: {
@@ -788,6 +914,8 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 				};
 			},
 			apply(tr, state) {
+				const nativeCompositionId = tr.getMeta("composition");
+				if (composing && tr.docChanged && typeof nativeCompositionId === "number") compositionId = nativeCompositionId;
 				const meta = tr.getMeta(suggestionModeKey);
 				if (meta) return {
 					...state,
@@ -813,6 +941,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					if (!suggestionModeKey.getState(view.state)?.active) return false;
 					if (composing) return false;
 					composing = true;
+					compositionId = null;
 					const { from, to } = view.state.selection;
 					compositionFrom = from;
 					compositionReplaced = from === to ? null : view.state.doc.slice(from, to);
@@ -826,14 +955,23 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					compositionReplaced = null;
 					if (!pluginState?.active || from == null) {
 						composing = false;
+						compositionId = null;
 						return false;
 					}
-					queueMicrotask(() => {
+					afterNativeCompositionFlush(() => {
 						try {
 							const current = suggestionModeKey.getState(view.state);
-							if (current?.active) markComposedAsInsertion(view, from, current, replaced);
+							const nativeCompositionId = compositionId;
+							if (current?.active) markComposedAsInsertion({
+								view,
+								from,
+								pluginState: current,
+								replaced,
+								compositionId: nativeCompositionId
+							});
 						} finally {
 							composing = false;
+							compositionId = null;
 						}
 					});
 					return false;
@@ -855,6 +993,20 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 				if (event.key === "Backspace" || event.key === "Delete") {
 					const { $from, empty } = view.state.selection;
 					if (event.key === "Backspace" && empty && $from.parentOffset === 0 && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
+					if (event.key === "Backspace" && clearIndentOnBackspace(view.state, (tr) => {
+						const revision = makeMarkAttrs(pluginState);
+						recordReplacedParagraphProperties({
+							tr,
+							position: $from.before(),
+							replaced: $from.parent,
+							revision: {
+								id: revision.revisionId,
+								author: revision.author,
+								date: revision.date
+							}
+						});
+						view.dispatch(tr.setMeta("suggestionModeApplied", true));
+					})) return true;
 					const boundaryTarget = paragraphBoundaryTarget(view.state, event.key === "Backspace" ? "backward" : "forward");
 					if (boundaryTarget !== null) return applyPPrDel(view, boundaryTarget, pluginState);
 					const direction = event.key === "Backspace" ? "backward" : "forward";

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

@@ -14,6 +14,12 @@ type DirectiveRange = {
    * array path the loop iterates (`{% for row in items %}` ⇒ `items`).
    */
   expr: string;
+  /**
+   * For an `if` / `elif` whose body is one field path plus a filter chain
+   * (`{% if consented | checkbox | label("…") %}`), that path; `expr` keeps
+   * the body as authored. Unset for every other tag.
+   */
+  conditionPath?: string;
   /** Clause-slot version selector, e.g. "v3" or "latest". */
   clauseVersion?: string;
   /** Loop alias of a `for` marker (`{% for row in items %}` ⇒ `row`); unset

package/dist/prosemirror/plugins/templateDirectives.js

@@ -3,9 +3,17 @@ import { collectBlockChunks, joinChunks, offsetToDocPos } from "./pmTextScan.js"
 import { PluginKey } from "prosemirror-state";
 import { assertNever, isBlockDirectiveKind, scanMarkers } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templateDirectives.ts
+/**
+* The body of an `if` / `elif` tag as authored: its inner text after the
+* keyword. The grammar reads a body that is one path plus a filter chain as
+* that path, with the chain in `filters`; the document still holds the whole
+* body, and that is what a host keys a condition by.
+*/
+const conditionBody = ({ inner, meta }) => inner.slice(meta.kind.length).trim();
 /** The display expression for a marker (field path, clause name, key,
-*  condition, loop array path, loop property). */
-const directiveExpr = (meta) => {
+*  condition as authored, loop array path, loop property). */
+const directiveExpr = (marker) => {
+	const { meta } = marker;
 	switch (meta.kind) {
 		case "placeholder": return meta.expr;
 		case "clause": return meta.name;
@@ -13,7 +21,7 @@ const directiveExpr = (meta) => {
 		case "ref": return meta.key;
 		case "loop": return meta.property;
 		case "if":
-		case "elif": return meta.expr;
+		case "elif": return conditionBody(marker);
 		case "for": return meta.path;
 		case "else":
 		case "endif":
@@ -63,6 +71,8 @@ const computeBlockDepths = (ranges) => {
 };
 /** The loop alias a `for` marker binds, or undefined for every other kind. */
 const directiveAlias = (meta) => meta.kind === "for" ? meta.alias : void 0;
+/** The path a condition's filter chain configures, or undefined without a chain. */
+const directiveConditionPath = (meta) => (meta.kind === "if" || meta.kind === "elif") && meta.filters.length > 0 ? meta.expr : void 0;
 const scanDirectives = (doc) => {
 	const ranges = [];
 	for (const chunks of collectBlockChunks(doc)) {
@@ -73,27 +83,31 @@ const scanDirectives = (doc) => {
 		if (sole && sole.raw === trimmed && isBlockDirectiveKind(sole.meta.kind)) {
 			const last = chunks.at(-1);
 			const alias = directiveAlias(sole.meta);
+			const conditionPath = directiveConditionPath(sole.meta);
 			ranges.push({
 				from: chunks[0]?.start ?? 0,
 				to: last ? last.end ?? last.start + last.text.length : 0,
 				kind: sole.meta.kind,
-				expr: directiveExpr(sole.meta),
+				expr: directiveExpr(sole),
 				block: true,
-				...alias !== void 0 ? { alias } : {}
+				...alias !== void 0 ? { alias } : {},
+				...conditionPath !== void 0 ? { conditionPath } : {}
 			});
 			continue;
 		}
 		for (const marker of scanMarkers(joined)) {
 			const clauseVersion = marker.meta.kind === "clause" ? marker.meta.version : void 0;
 			const alias = directiveAlias(marker.meta);
+			const conditionPath = directiveConditionPath(marker.meta);
 			ranges.push({
 				from: offsetToDocPos(chunks, marker.start),
 				to: offsetToDocPos(chunks, marker.end, "end"),
 				kind: marker.meta.kind,
-				expr: directiveExpr(marker.meta),
+				expr: directiveExpr(marker),
 				block: false,
 				...clauseVersion !== void 0 ? { clauseVersion } : {},
-				...alias !== void 0 ? { alias } : {}
+				...alias !== void 0 ? { alias } : {},
+				...conditionPath !== void 0 ? { conditionPath } : {}
 			});
 		}
 	}

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -1,7 +1,7 @@
 import { scanDirectives } from "./templateDirectives.js";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { classifyMarker, isFieldPath } from "@stll/template-conditions";
+import { isFieldPath } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templatePreviewValues.ts
 /** Concatenated plain text of a preview value. */
 const templatePreviewValueText = (value) => typeof value === "string" ? value : value.runs.map((run) => run.text).join("");
@@ -64,28 +64,21 @@ function buildValueWidget(value, mode) {
 		return span;
 	};
 }
-/** Loop alias the bare-path probe binds. Any identifier does; it is discarded. */
-const CHAIN_PROBE_ALIAS = "__folioCondition";
 /** A field path opens with a letter or underscore, so `9x` and `-x` are not one. */
 const FIELD_PATH_HEAD_RE = /^[\p{L}_]/u;
 /**
 * The bare field path a condition's filter chain hangs off, or undefined when
-* the expression is not a path plus a chain.
+* the tag is not a path plus a chain.
 *
-* A host may write the tag the way `{% for x in xs | chain %}` already carries
-* one — `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
-* keying `conditions` by the bare path. Splitting on `|` would cut a quoted
-* argument such as `label("a | b")` in half, so the expression is classified as
-* that very `for` chain instead and the grammar's own argument-aware scan
-* reports the path. An expression that is not a path plus a chain of known
-* filters (`a and b`, `items|length > 0`, `ai("a|b")`) classifies as nothing,
-* which is what keeps a real expression on exact matching.
+* A host may write the tag with the chain of the boolean it names —
+* `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
+* keying `conditions` by the bare path. The grammar's argument-aware scan
+* splits the chain (`label("a | b")` stays one argument) and reports the path
+* as `conditionPath`; an expression that is not a path plus a chain of known
+* filters (`a and b`, `items|length > 0`, `ai("a|b")`) has none, which is what
+* keeps a real expression on exact matching.
 */
-const filterChainPath = (expr) => {
-	const meta = classifyMarker(`for ${CHAIN_PROBE_ALIAS} in ${expr}`, "statement");
-	if (meta?.kind !== "for" || !isFieldPath(meta.path) || !FIELD_PATH_HEAD_RE.test(meta.path)) return;
-	return meta.path;
-};
+const filterChainPath = ({ conditionPath }) => conditionPath !== void 0 && isFieldPath(conditionPath) && FIELD_PATH_HEAD_RE.test(conditionPath) ? conditionPath : void 0;
 /**
 * The verdict stored under one key. Only a key the host set itself, holding a
 * real boolean, counts: an inherited property (`constructor`, or a boolean the
@@ -102,10 +95,10 @@ const ownVerdict = (conditions, key) => {
 * by the bare path its filter chain hangs off. `undefined` means the host said
 * nothing about this block, which leaves it exactly as authored.
 */
-const conditionVerdict = (conditions, expr) => {
-	const exact = ownVerdict(conditions, expr);
+const conditionVerdict = (conditions, opener) => {
+	const exact = ownVerdict(conditions, opener.expr);
 	if (exact !== void 0) return exact;
-	const path = filterChainPath(expr);
+	const path = filterChainPath(opener);
 	return path === void 0 ? void 0 : ownVerdict(conditions, path);
 };
 /**
@@ -157,7 +150,7 @@ function collectHiddenRanges(ranges, conditions, mode) {
 		}
 		if (block === void 0 || block.opener.kind !== "if") continue;
 		const { opener, branches } = block;
-		const verdict = conditionVerdict(conditions, opener.expr);
+		const verdict = conditionVerdict(conditions, opener);
 		if (verdict === void 0) continue;
 		if (!verdict) {
 			paired.push({

package/dist/prosemirror/storyListNumbering.js

@@ -1,3 +1,4 @@
+import { createNumberingIdAllocator } from "../docx/numberingIds.js";
 import { getCachedNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
 import { paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
@@ -20,16 +21,11 @@ const remappedAbstractNumId = (abstractNumId, remap) => {
 	if (abstractNumId === null || abstractNumId === void 0 || remap.baseAbstractNumIds.has(abstractNumId)) return abstractNumId;
 	let next = remap.abstractNumIds.get(abstractNumId);
 	if (next === void 0) {
-		next = remap.nextAbstractNumId++;
+		next = remap.abstractIds.next();
 		remap.abstractNumIds.set(abstractNumId, next);
 	}
 	return next;
 };
-const maxOf = (ids, floor) => {
-	let max = floor;
-	for (const id of ids) max = Math.max(max, id);
-	return max;
-};
 /**
 * The story in `state` as it should be written into a package whose numbering
 * is now `numbering`, and that numbering completed with the story's lists.
@@ -41,10 +37,16 @@ const storyListNumbering = (state, numbering) => {
 	const definedMap = numbering ? getCachedNumberingMap(numbering) : null;
 	const referenced = /* @__PURE__ */ new Set();
 	const colliding = /* @__PURE__ */ new Set();
+	const existingAbstractNumIds = /* @__PURE__ */ new Set([...(numbering?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), ...(packageDefinitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)]);
 	state.doc.descendants((node) => {
 		if (node.type.name !== "paragraph") return true;
 		for (const numId of paragraphListReferences(node)) referenced.add(numId);
 		const attrs = expectParagraphAttrs(node);
+		if (typeof attrs.listAbstractNumId === "number") existingAbstractNumIds.add(attrs.listAbstractNumId);
+		for (const change of attrs._propertyChanges ?? []) {
+			const abstractId = change.previousFormatting?.listAbstractNumId;
+			if (typeof abstractId === "number") existingAbstractNumIds.add(abstractId);
+		}
 		const numId = paragraphNumberingReferenceId(attrs.numPr);
 		if (numId !== void 0 && !storyBase.has(numId) && definedMap?.hasNumbering(numId)) {
 			const level = definedMap.getLevel(numId, paragraphNumberingLevel(attrs.numPr) ?? 0);
@@ -56,12 +58,12 @@ const storyListNumbering = (state, numbering) => {
 		doc: state.doc,
 		numbering: completeNumberingForDoc(numbering, state.doc)
 	};
-	let nextNumId = maxOf([...defined, ...referenced], 0) + 1;
+	const numIds = createNumberingIdAllocator("num", [...defined, ...referenced]);
 	const remap = {
-		numIds: new Map([...colliding].map((numId) => [numId, nextNumId++])),
+		numIds: new Map([...colliding].map((numId) => [numId, numIds.next()])),
 		baseAbstractNumIds: new Set((packageDefinitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)),
 		abstractNumIds: /* @__PURE__ */ new Map(),
-		nextAbstractNumId: maxOf((numbering?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), -1) + 1
+		abstractIds: createNumberingIdAllocator("abstract", existingAbstractNumIds)
 	};
 	const tr = new Transform(state.doc);
 	state.doc.descendants((node, pos) => {

package/dist/prosemirror/textInput.d.ts

@@ -15,7 +15,12 @@ type TextInput = {
 declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
 /** Shared DOM boundary for editor runtimes and standalone suggestion views. */
 declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
+/**
+ * Plugin compositionend handlers run before ProseMirror queues its final DOM
+ * flush. A second microtask runs after that flush and sees the committed state.
+ */
+declare const afterNativeCompositionFlush: (callback: () => void) => void;
 /** Route committed text through the model before the browser mutates mark spans. */
 declare const createTextInputPlugin: () => Plugin<any>;
 //#endregion
-export { createTextInputPlugin, dispatchEditorTextInput, handleEditorBeforeInput };
+export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, handleEditorBeforeInput };

package/dist/prosemirror/textInput.js

@@ -45,6 +45,13 @@ const handleEditorBeforeInput = (view, event) => {
 	});
 	return true;
 };
+/**
+* Plugin compositionend handlers run before ProseMirror queues its final DOM
+* flush. A second microtask runs after that flush and sees the committed state.
+*/
+const afterNativeCompositionFlush = (callback) => {
+	queueMicrotask(() => queueMicrotask(callback));
+};
 /** Route committed text through the model before the browser mutates mark spans. */
 const createTextInputPlugin = () => {
 	const compositions = /* @__PURE__ */ new WeakMap();
@@ -55,7 +62,7 @@ const createTextInputPlugin = () => {
 		},
 		compositionend(view, event) {
 			compositions.set(view, event);
-			queueMicrotask(() => {
+			afterNativeCompositionFlush(() => {
 				if (compositions.get(view) === event) compositions.delete(view);
 			});
 			return false;
@@ -67,4 +74,4 @@ const createTextInputPlugin = () => {
 	} } });
 };
 //#endregion
-export { createTextInputPlugin, dispatchEditorTextInput, handleEditorBeforeInput };
+export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, handleEditorBeforeInput };