@stll/folio-core 0.62.0 → 0.63.1

package/dist/prosemirror/plugins/autocompleteSuggestion.js

@@ -2,29 +2,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/plugins/autocompleteSuggestion.ts
-/**
-* Autocomplete Suggestion Plugin
-*
-* Headless ProseMirror plugin for inline ghost-text autocomplete.
-* Mirrors the anonymization plugin shape: this module owns the
-* "what" (a single in-flight suggestion anchored at a doc
-* position) and {@link AutocompleteCaretOverlay} owns the paint.
-*
-* Lifecycle:
-*   idle ──setSuggestionStart──▶ streaming ──appendToken*──▶ shown
-*      ◀──clearSuggestion──────────────────────────────────────┘
-*
-* The document is never mutated while the suggestion is shown;
-* the ghost text and "stella" caret are projected onto the page
-* via {@link AutocompleteCaretOverlay} reading this plugin's
-* state and a single inline widget decoration carrying the
-* anchor position.
-*
-* On accept (Tab/⌘→), call {@link acceptAutocompleteSuggestion}
-* to commit the suggestion as a real text insertion in a single
-* transaction. On dismiss (Esc, edit, blur), call
-* {@link clearAutocompleteSuggestion}.
-*/
 const IDLE = {
 	status: "idle",
 	anchor: null,
@@ -97,7 +74,7 @@ const autocompleteSuggestionPlugin = (options = {}) => {
 		renderInline: options.renderInline ?? false,
 		keymap: options.keymap ?? false
 	};
-	return new Plugin({
+	const spec = {
 		key: autocompleteSuggestionKey.createKey(),
 		state: {
 			init: (_config, instance) => ({
@@ -150,7 +127,8 @@ const autocompleteSuggestionPlugin = (options = {}) => {
 				return false;
 			} } : {}
 		}
-	});
+	};
+	return new Plugin(spec);
 };
 const getAutocompleteSuggestion = (state) => autocompleteSuggestionKey.getState(state)?.suggestion ?? IDLE;
 const startAutocompleteSuggestion = (tr, anchor, requestId) => tr.setMeta(autocompleteSuggestionKey, {

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

@@ -1,15 +1,15 @@
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import "../../content-controls/index.js";
-import { Plugin } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/plugins/contentControlWidgets.d.ts
-type ContentControlWidgetAnchor = {
+export type ContentControlWidgetAnchor = {
   getBoundingClientRect: () => {
     bottom: number;
     left: number;
   };
 };
-type ContentControlWidgetEvent = {
+export type ContentControlWidgetEvent = {
   kind: "dropdownOpen";
   tag: string;
   /** PM position of the clicked SDT instance — disambiguates duplicates. */
@@ -36,7 +36,7 @@ type ContentControlWidgetEvent = {
   anchor: ContentControlWidgetAnchor;
   error: ContentControlLockedError | ContentControlTypeError | ContentControlBoundError;
 };
-type ContentControlWidgetCallback = (event: ContentControlWidgetEvent) => void;
+export type ContentControlWidgetCallback = (event: ContentControlWidgetEvent) => void;
 type ContentControlWidgetClickEvent = {
   preventDefault: () => void;
   target: unknown;
@@ -47,12 +47,12 @@ type HandleContentControlWidgetClickOptions = {
   onEvent: ContentControlWidgetCallback;
   view: ContentControlWidgetView;
 };
-declare const contentControlWidgetsPluginKey: Readonly<{
+export declare const contentControlWidgetsPluginKey: Readonly<{
   key: string;
-  createKey: () => import("prosemirror-state").PluginKey<unknown>;
+  createKey: () => PluginKey<unknown>;
   owns: (plugin: Plugin<unknown>) => boolean;
-  get: (state: import("prosemirror-state").EditorState) => Plugin<unknown> | undefined;
-  getState: (state: import("prosemirror-state").EditorState) => unknown;
+  get: (state: EditorState) => Plugin<unknown> | undefined;
+  getState: (state: EditorState) => unknown;
 }>;
 /**
  * CustomEvent name dispatched on the editor view DOM whenever the plugin
@@ -63,14 +63,14 @@ declare const contentControlWidgetsPluginKey: Readonly<{
  * adapter's responsibility explicit: receive event → render UI →
  * call dispatchDropdownPick / dispatchDatePick.
  */
-declare const CONTENT_CONTROL_WIDGET_EVENT_NAME = "folio:content-control-widget";
+export declare const CONTENT_CONTROL_WIDGET_EVENT_NAME = "folio:content-control-widget";
 /**
  * Interpret one click from either the live ProseMirror DOM or the painted page
  * tree. Both surfaces carry the same `data-sdt-*` projection, so adapters only
  * need to forward the click and render the resulting typed event.
  */
-declare const handleContentControlWidgetClick: ({ event, onEvent, view }: HandleContentControlWidgetClickOptions) => boolean;
-declare function createContentControlWidgetsPlugin(onEvent?: ContentControlWidgetCallback): Plugin;
+export declare const handleContentControlWidgetClick: ({ event, onEvent, view }: HandleContentControlWidgetClickOptions) => boolean;
+export declare function createContentControlWidgetsPlugin(onEvent?: ContentControlWidgetCallback): Plugin;
 /**
  * Stable resolver helpers exposed for the UI shell so a popover menu or
  * date picker can dispatch the same transaction the plugin would.
@@ -79,7 +79,7 @@ declare function createContentControlWidgetsPlugin(onEvent?: ContentControlWidge
  * `pmPos` field) so the dispatch lands on the exact instance the user
  * interacted with — duplicate-tag SDTs are no longer ambiguous.
  */
-declare function dispatchDropdownPick(view: EditorView, pmPos: number, value: string): boolean;
-declare function dispatchDatePick(view: EditorView, pmPos: number, date: string): boolean;
+export declare function dispatchDropdownPick(view: EditorView, pmPos: number, value: string): boolean;
+export declare function dispatchDatePick(view: EditorView, pmPos: number, date: string): boolean;
 //#endregion
-export { CONTENT_CONTROL_WIDGET_EVENT_NAME, ContentControlWidgetAnchor, ContentControlWidgetCallback, ContentControlWidgetEvent, contentControlWidgetsPluginKey, createContentControlWidgetsPlugin, dispatchDatePick, dispatchDropdownPick, handleContentControlWidgetClick };
+export {};

package/dist/prosemirror/plugins/contentControlWidgets.js

@@ -1,6 +1,7 @@
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import { findBlockSdtMatch, setContentControlValueTr } from "../commands/contentControls.js";
 import { createPluginKeyOwner } from "../pluginKeyOwner.js";
+import { selectLockedInlineControl } from "./lockedControlKeyHandling.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/contentControlWidgets.ts
 /**
@@ -153,13 +154,18 @@ function createContentControlWidgetsPlugin(onEvent = () => void 0) {
 	};
 	return new Plugin({
 		key: contentControlWidgetsPluginKey.createKey(),
-		props: { handleDOMEvents: { click(view, event) {
-			return handleContentControlWidgetClick({
-				view,
-				event,
-				onEvent: (payload) => emit(view, payload)
-			});
-		} } },
+		props: {
+			handleKeyDown(view, event) {
+				return selectLockedInlineControl(view, event);
+			},
+			handleDOMEvents: { click(view, event) {
+				return handleContentControlWidgetClick({
+					view,
+					event,
+					onEvent: (payload) => emit(view, payload)
+				});
+			} }
+		},
 		view() {
 			return {};
 		}

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

@@ -3,11 +3,11 @@ import { Node } from "prosemirror-model";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/createDocScanPlugin.d.ts
 declare const SET_META = "set";
-type DocScanState<TConfig, TRange> = {
+export type DocScanState<TConfig, TRange> = {
   config: TConfig;
   ranges: readonly TRange[];
 };
-type DocScanPluginOptions<TConfig, TRange> = {
+export type DocScanPluginOptions<TConfig, TRange> = {
   key: PluginKeyOwner<DocScanState<TConfig, TRange>>;
   initialConfig: TConfig;
   /** Recompute the ranges from the current doc + config. */
@@ -20,14 +20,14 @@ type DocScanPluginOptions<TConfig, TRange> = {
    */
   onRangesChange?: (ranges: readonly TRange[]) => void;
 };
-declare const createDocScanPlugin: <TConfig, TRange>({ key, initialConfig, scan, onRangesChange }: DocScanPluginOptions<TConfig, TRange>) => Plugin<DocScanState<TConfig, TRange>>;
-declare const setDocScanConfigMeta: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, config: TConfig) => {
+export declare const createDocScanPlugin: <TConfig, TRange>({ key, initialConfig, scan, onRangesChange }: DocScanPluginOptions<TConfig, TRange>) => Plugin<DocScanState<TConfig, TRange>>;
+export declare const setDocScanConfigMeta: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, config: TConfig) => {
   key: PluginKeyOwner<DocScanState<TConfig, TRange>>;
   payload: {
     type: typeof SET_META;
     config: TConfig;
   };
 };
-declare const getDocScanRanges: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, state: EditorState) => readonly TRange[];
+export declare const getDocScanRanges: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, state: EditorState) => readonly TRange[];
 //#endregion
-export { DocScanPluginOptions, DocScanState, createDocScanPlugin, getDocScanRanges, setDocScanConfigMeta };
+export {};

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

@@ -1,36 +1,38 @@
 import { document_d_exports } from "../../types/document.js";
 import { NumberingMap } from "../../docx/numberingParser.js";
+import { Node } from "prosemirror-model";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.d.ts
-declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+export declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+/** Numbering derived from a document when no editor plugin owns package definitions. */
+export declare const getDocumentNumberingForDoc: (doc: Node) => NumberingMap | null;
 /**
  * The numbering the document's paragraphs resolve against: the package's
  * definitions plus every instance a list command defined in this document.
  * An instance whose paragraphs were all deleted may linger until the next
  * completion; the save completes from the document itself.
  */
-declare const getDocumentNumbering: (state: EditorState) => NumberingMap | null;
+export declare const getDocumentNumbering: (state: EditorState) => NumberingMap | null;
 /** The package's own definitions, without the instances the document defines. */
-declare const getPackageNumberingDefinitions: (state: EditorState) => document_d_exports.NumberingDefinitions | null;
+export declare const getPackageNumberingDefinitions: (state: EditorState) => document_d_exports.NumberingDefinitions | null;
 /**
  * Whether the state knows its document's numbering at all. A state without
  * the plugin cannot tell a package with no numbering part from one it was
  * never told about.
  */
-declare const hasDocumentNumbering: (state: EditorState) => boolean;
+export declare const hasDocumentNumbering: (state: EditorState) => boolean;
 /**
  * The document's numbering definitions: `null` for a document without a
  * numbering part, `undefined` when the state carries no numbering plugin and
  * so cannot say what the document defines.
  */
-declare const getStatedDocumentNumbering: (state: EditorState) => document_d_exports.NumberingDefinitions | null | undefined;
+export declare const getStatedDocumentNumbering: (state: EditorState) => document_d_exports.NumberingDefinitions | null | undefined;
 /**
  * The numbering instances (`w:num` ids) the document defines, or `null` when
  * the state carries no numbering plugin and so cannot say. A document without
  * a numbering part defines none.
  */
-declare const getDocumentNumberingInstanceIds: (state: EditorState) => ReadonlySet<number> | null;
+export declare const getDocumentNumberingInstanceIds: (state: EditorState) => ReadonlySet<number> | null;
 /** Replace numbering state while retaining every unrelated plugin state. */
-declare const withDocumentNumbering: (state: EditorState, definitions: document_d_exports.NumberingDefinitions) => EditorState;
-//#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };
+export declare const withDocumentNumbering: (state: EditorState, definitions: document_d_exports.NumberingDefinitions) => EditorState;
+//#endregion

package/dist/prosemirror/plugins/documentNumbering.js

@@ -4,7 +4,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { AddMarkStep, DocAttrStep, RemoveMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.ts
-/** Document-scoped numbering definitions for list-editing commands. */
 const documentNumberingKey = createPluginKeyOwner("documentNumbering");
 const completedState = (definitions, doc) => {
 	const completed = completeNumberingForDoc(definitions ?? void 0, doc);
@@ -13,52 +12,58 @@ const completedState = (definitions, doc) => {
 		map: completed ? getCachedNumberingMap(completed) : null
 	};
 };
-/** Steps that can change a paragraph's attrs or bring paragraphs in, by what they replace. */
 const isReplace = (step) => step instanceof ReplaceStep || step instanceof ReplaceAroundStep;
-/** Steps that change nothing a numbering reference lives in. */
-const leavesParagraphAttrs = (step) => step instanceof AddMarkStep || step instanceof RemoveMarkStep || step instanceof DocAttrStep;
+const leavesNumberingUnchanged = (step) => step instanceof AddMarkStep || step instanceof RemoveMarkStep || step instanceof DocAttrStep;
+const containsNumberedParagraph = (node, from, to) => {
+	let found = false;
+	node.nodesBetween(from, to, (child, pos) => {
+		if (child.type.name !== "paragraph" || pos < from || pos + child.nodeSize > to || paragraphListReferences(child).length === 0) return !found;
+		found = true;
+		return false;
+	});
+	return found;
+};
 /**
-* Whether `tr` may have introduced a reference `map` does not define. Only the
-* ranges its steps replaced are read, so typing costs one paragraph, not the
-* document. A step that changes attrs in place (not by replacement) is not
-* localised and answers yes.
+* Whether a transaction can change a paragraph-level numbering source. Text
+* and mark edits do not; paragraph attrs and structural replacements do. The
+* latter are inspected in the step-local document rather than by walking the
+* completed document.
 */
-const mayReferenceUnknownInstance = (tr, map) => {
-	const ranges = [];
-	for (const [index, step] of tr.steps.entries()) {
-		if (leavesParagraphAttrs(step)) continue;
-		if (!isReplace(step)) return true;
-		const later = tr.mapping.slice(index + 1);
-		step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-			ranges.push({
-				from: later.map(newStart, -1),
-				to: later.map(newEnd, 1)
-			});
-		});
-	}
-	const size = tr.doc.content.size;
-	const isUnknown = (numId) => !(map?.hasNumbering(numId) ?? false);
-	return ranges.some(({ from, to }) => {
-		let unknown = false;
-		const start = Math.min(Math.max(0, from), size);
-		tr.doc.nodesBetween(start, Math.min(Math.max(start, to), size), (node) => {
-			if (unknown) return false;
-			if (node.type.name !== "paragraph") return true;
-			unknown = paragraphListReferences(node).some(isUnknown);
-			return false;
-		});
-		return unknown;
+const changesNumberingInputs = (tr) => tr.steps.some((step, index) => {
+	if (leavesNumberingUnchanged(step)) return false;
+	if (!isReplace(step)) return true;
+	let insertsNumberedParagraph = false;
+	step.slice.content.descendants((node) => {
+		if (paragraphListReferences(node).length === 0) return !insertsNumberedParagraph;
+		insertsNumberedParagraph = true;
+		return false;
 	});
-};
+	if (insertsNumberedParagraph) return true;
+	const before = tr.docs[index];
+	if (before === void 0) return true;
+	const fromParent = before.resolve(step.from).parent;
+	const toParent = before.resolve(step.to).parent;
+	if (fromParent !== toParent && (paragraphListReferences(fromParent).length > 0 || paragraphListReferences(toParent).length > 0)) return true;
+	return containsNumberedParagraph(before, step.from, step.to);
+});
 const createDocumentNumberingPlugin = (definitions) => new Plugin({
 	key: documentNumberingKey.createKey(),
 	state: {
 		init: (_config, state) => completedState(definitions ?? null, state.doc),
-		apply: (tr, current, _oldState, state) => tr.docChanged && mayReferenceUnknownInstance(tr, current.map) ? completedState(current.definitions, state.doc) : current
+		apply: (tr, current, _oldState, state) => tr.docChanged && changesNumberingInputs(tr) ? completedState(current.definitions, state.doc) : current
 	}
 });
 /** Numbering for states without the plugin, one per document node. */
 const untrackedNumbering = /* @__PURE__ */ new WeakMap();
+/** Numbering derived from a document when no editor plugin owns package definitions. */
+const getDocumentNumberingForDoc = (doc) => {
+	let untracked = untrackedNumbering.get(doc);
+	if (!untracked) {
+		untracked = completedState(null, doc);
+		untrackedNumbering.set(doc, untracked);
+	}
+	return untracked.map;
+};
 /**
 * The numbering the document's paragraphs resolve against: the package's
 * definitions plus every instance a list command defined in this document.
@@ -68,12 +73,7 @@ const untrackedNumbering = /* @__PURE__ */ new WeakMap();
 const getDocumentNumbering = (state) => {
 	const tracked = documentNumberingKey.getState(state);
 	if (tracked) return tracked.map;
-	let untracked = untrackedNumbering.get(state.doc);
-	if (!untracked) {
-		untracked = completedState(null, state.doc);
-		untrackedNumbering.set(state.doc, untracked);
-	}
-	return untracked.map;
+	return getDocumentNumberingForDoc(state.doc);
 };
 /** The package's own definitions, without the instances the document defines. */
 const getPackageNumberingDefinitions = (state) => documentNumberingKey.getState(state)?.definitions ?? null;
@@ -109,4 +109,4 @@ const withDocumentNumbering = (state, definitions) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentNumberingPlugin(definitions)] });
 };
 //#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };
+export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingForDoc, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };

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

@@ -1,23 +1,23 @@
 import { document_d_exports } from "../../types/document.js";
 import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { StyleResolver } from "../styles/styleResolver.js";
-import { EditorState } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyleState.d.ts
-declare const documentStylesKey: Readonly<{
+export declare const documentStylesKey: Readonly<{
   key: string;
-  createKey: () => import("prosemirror-state").PluginKey<StyleResolver | null>;
-  owns: (plugin: import("prosemirror-state").Plugin<StyleResolver | null>) => boolean;
-  get: (state: EditorState) => import("prosemirror-state").Plugin<StyleResolver | null> | undefined;
+  createKey: () => PluginKey<StyleResolver | null>;
+  owns: (plugin: Plugin<StyleResolver | null>) => boolean;
+  get: (state: EditorState) => Plugin<StyleResolver | null> | undefined;
   getState: (state: EditorState) => StyleResolver | null | undefined;
 }>;
 /** Read the document's StyleResolver, or null when the plugin isn't installed. */
-declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
+export declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
 /**
  * The document's style definitions by id, or `null` when the state carries no
  * styles plugin and so cannot say what the document defines. A document
  * without a styles part defines none.
  */
-declare function getDocumentStyleDefinitions(state: EditorState): {
+export declare function getDocumentStyleDefinitions(state: EditorState): {
   get: (styleId: string) => document_d_exports.Style | undefined;
   paragraphStyles: () => document_d_exports.Style[];
 } | null;
@@ -27,6 +27,5 @@ declare function getDocumentStyleDefinitions(state: EditorState): {
  * the plugin every lookup misses, which degrades classification to the
  * paragraph's own outline level rather than to English style ids.
  */
-declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
-//#endregion
-export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };
+export declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
+//#endregion

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

@@ -5,7 +5,7 @@ import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
 type DocumentStylesInput = document_d_exports.StyleDefinitions | StyleResolver | null | undefined;
 /** Canonical projections own formatting; expose the resolver without PM repair transactions. */
-declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) => Plugin;
+export declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) => Plugin;
 /**
  * Create the plugin holding a StyleResolver for the document's `styles` for
  * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -13,8 +13,8 @@ declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) =>
  * fresh resolver. Accepts a pre-built resolver too, for callers that already
  * have one.
  */
-declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
+export declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
-declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
+export declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion
-export { createDocumentStyleContextPlugin, createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };
+export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };

package/dist/prosemirror/plugins/documentStyles.js

@@ -38,7 +38,8 @@ const rebaseEditedParagraphJoins = (transactions, tr, resolver) => {
 			const before = transaction.docs[index];
 			if (!before) continue;
 			const map = step.getMap();
-			const mapping = new Mapping([map, ...new Mapping(maps.slice(offset + index + 1)).maps]);
+			const following = new Mapping(maps.slice(offset + index + 1));
+			const mapping = new Mapping([map, ...following.maps]);
 			map.forEach((oldFrom, oldTo) => {
 				before.nodesBetween(oldFrom, oldTo, (paragraph, position) => {
 					if (paragraph.type.name !== "paragraph") return true;

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

@@ -0,0 +1,4 @@
+import { EditorView } from "prosemirror-view";
+//#region src/prosemirror/plugins/lockedControlKeyHandling.d.ts
+export declare const selectLockedInlineControl: (view: Pick<EditorView, "dispatch" | "state">, event: KeyboardEvent) => boolean;
+//#endregion

package/dist/prosemirror/plugins/lockedControlKeyHandling.js

@@ -0,0 +1,16 @@
+import { NodeSelection, TextSelection } from "prosemirror-state";
+//#region src/prosemirror/plugins/lockedControlKeyHandling.ts
+const selectLockedInlineControl = (view, event) => {
+	if (event.key !== "Backspace" && event.key !== "Delete") return false;
+	const { state } = view;
+	if (!(state.selection instanceof TextSelection) || !state.selection.empty) return false;
+	const backward = event.key === "Backspace";
+	const { $from } = state.selection;
+	const node = backward ? $from.nodeBefore : $from.nodeAfter;
+	if (!node || node.type.name !== "sdt" || node.attrs["lock"] !== "contentLocked") return false;
+	const pos = backward ? $from.pos - node.nodeSize : $from.pos;
+	view.dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)).scrollIntoView());
+	return true;
+};
+//#endregion
+export { selectLockedInlineControl };

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

@@ -1,6 +1,6 @@
+import { NumberingMap } from "../../docx/numberingParser.js";
 import { StyleEngine } from "../../style-engine/styleEngine.js";
 import "../../style-engine/index.js";
-import { NumberingMap } from "../../docx/numberingParser.js";
 import { ParagraphCascadeResolver } from "../styles/paragraphStyleCascade.js";
 import { EditorState, Transaction } from "prosemirror-state";
 //#region src/prosemirror/plugins/paragraphStyleResolution.d.ts
@@ -10,6 +10,6 @@ type ParagraphStyleResolver = ParagraphCascadeResolver & Pick<StyleEngine, "getD
  * that has not been projected yet. Returns the transaction to append, or null
  * when every touched paragraph already reads as a reopened document would.
  */
-declare const resolveEditedParagraphStyles: (transactions: readonly Transaction[], state: EditorState, resolver: ParagraphStyleResolver, numbering: () => NumberingMap | null) => Transaction | null;
+export declare const resolveEditedParagraphStyles: (transactions: readonly Transaction[], state: EditorState, resolver: ParagraphStyleResolver, numbering: () => NumberingMap | null) => Transaction | null;
 //#endregion
-export { resolveEditedParagraphStyles };
+export {};

package/dist/prosemirror/plugins/paragraphStyleResolution.js

@@ -10,6 +10,23 @@ import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/plugins/paragraphStyleResolution.ts
+/**
+* Resolve the style cascade onto paragraphs an edit creates.
+*
+* A loaded paragraph carries its effective formatting as attrs: `toProseDoc`
+* projects the style cascade (docDefaults, the paragraph style chain) onto
+* every paragraph, and the painter reads those attrs. A paragraph an edit
+* creates — a paste, a structural table command, a replacement that joins
+* paragraphs, a cut that empties the document — starts from the node spec's
+* defaults instead, so it paints without its inherited spacing and run
+* defaults until the document is saved and reopened.
+*
+* {@link resolveEditedParagraphStyles} closes that gap in one place: after
+* every edit it projects the same cascade onto each paragraph the edit touched
+* and that the load path never saw, filling only what the paragraph leaves
+* unstated, with the provenance a save needs to keep those inherited values
+* out of the paragraph's own `w:pPr`.
+*/
 /** The ranges of `doc` the given transactions changed, in its own positions. */
 const changedRanges = (transactions) => {
 	const ranges = [];
@@ -52,6 +69,8 @@ const statedFormatting = (attrs) => {
 	copy("shading");
 	copy("tabs");
 	copy("kinsoku");
+	copy("autoSpaceDE");
+	copy("autoSpaceDN");
 	copy("overflowPunctuation");
 	copy("suppressAutoHyphens");
 	copy("pageBreakBefore");
@@ -74,9 +93,10 @@ const isUnset = (value) => value === null || value === void 0;
 const cascadePatch = (node, resolver, tableParagraphOverlay, numbering) => {
 	const attrs = expectParagraphAttrs(node);
 	const styleId = attrs.styleId ?? void 0;
+	const formatting = statedFormatting(attrs);
 	const { attrs: cascade, stylePpr } = paragraphStyleCascadeAttrs({
 		styleId,
-		formatting: statedFormatting(attrs),
+		formatting,
 		styleResolver: resolver,
 		tableParagraphOverlay,
 		includeParagraphMarkRunProperties: false
@@ -121,6 +141,8 @@ const cascadePatch = (node, resolver, tableParagraphOverlay, numbering) => {
 		"shading",
 		"tabs",
 		"kinsoku",
+		"autoSpaceDE",
+		"autoSpaceDN",
 		"overflowPunctuation",
 		"suppressAutoHyphens",
 		"pageBreakBefore",

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

@@ -1,6 +1,6 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/plugins/pmTextScan.d.ts
-type TextChunk = {
+export type TextChunk = {
   text: string;
   /** PM doc position where this chunk's first char lives. */
   start: number;
@@ -13,10 +13,9 @@ type TextChunk = {
  * An explicit page-break run ends a segment: it is zero-width in the joined
  * text, but a text-shaped overlay must not select across that structural atom.
  */
-declare const collectBlockChunks: (doc: Node) => TextChunk[][];
+export declare const collectBlockChunks: (doc: Node) => TextChunk[][];
 /** Map a joined-string offset back to its PM doc position. */
-declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
+export declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
 /** Join a block's chunks into the single string callers scan. */
-declare const joinChunks: (chunks: TextChunk[]) => string;
-//#endregion
-export { TextChunk, collectBlockChunks, joinChunks, offsetToDocPos };
+export declare const joinChunks: (chunks: TextChunk[]) => string;
+//#endregion

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

@@ -1,35 +1,36 @@
 import { Node } from "prosemirror-model";
+import { TaggedErrorClass } from "better-result";
 //#region src/prosemirror/plugins/revisionIds.d.ts
-declare const RevisionIdAllocationError_base: import("better-result").TaggedErrorClass<"RevisionIdAllocationError">;
-declare class RevisionIdAllocationError extends RevisionIdAllocationError_base<{
+declare const RevisionIdAllocationErrorBase: TaggedErrorClass<"RevisionIdAllocationError">;
+export declare class RevisionIdAllocationError extends RevisionIdAllocationErrorBase<{
   message: string;
   first: number;
   next: number;
 }> {}
 /** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
-declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
+export declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
 /** The next free id, including after the signed 32-bit boundary wraps. */
-declare const nextRevisionId: () => number;
+export declare const nextRevisionId: () => number;
 /**
  * A shared batch increments its seed locally, so a single free id is not
  * enough: start in the largest free interval. Every contiguous batch that
  * can fit anywhere fits here, including after loaded ids shorten the tail.
  * Continue within this interval until another producer changes the cursor.
  */
-declare const nextRevisionIdRange: () => number;
+export declare const nextRevisionIdRange: () => number;
 /** Reserve a deterministic batch without changing its caller-supplied ids. */
-declare const reserveRevisionIds: (first: number, next: number) => void;
+export declare const reserveRevisionIds: (first: number, next: number) => void;
 /** Shared producers must never cross a loaded or already issued id on wrap. */
-declare const claimRevisionIds: (first: number, next: number) => void;
+export declare const claimRevisionIds: (first: number, next: number) => void;
 /** Mint a bounded id without reusing loaded or previously issued ids. */
-declare function mintRevisionId(): number;
+export declare function mintRevisionId(): number;
 /** Reserve a valid loaded id and prefer the range above it. */
-declare function seedRevisionIdsAbove(maxId: number): void;
-declare const maxAnnotationIdInDoc: (doc: Node) => number;
+export declare function seedRevisionIdsAbove(maxId: number): void;
+export declare const maxAnnotationIdInDoc: (doc: Node) => number;
 /**
  * Raise the counter above every annotation id already present in `doc`.
  * Called from the suggestion-mode plugin's `state.init`.
  */
-declare function seedRevisionIdsFromDoc(doc: Node): void;
+export declare function seedRevisionIdsFromDoc(doc: Node): void;
 //#endregion
-export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export {};

package/dist/prosemirror/plugins/revisionIds.js

@@ -2,6 +2,17 @@ import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/plugins/revisionIds.ts
 /**
+* Tracked-revision id minting (`w:id` on `<w:ins>` / `<w:del>`).
+*
+* Uniqueness comes from `seedRevisionIdsAbove` (called on load with the
+* document's own max id), NOT from the counter's starting value. A clock seed
+* bought uniqueness at the cost of ids no consumer could read — see
+* `MAX_REVISION_ID`. Port of eigenpal/docx-editor#1093.
+*
+* Kept free of `suggestionMode` imports so the suggestion plugin can mint
+* without a load-order cycle.
+*/
+/**
 * Next id to hand out. Starts at 1 (0 is the serializer's "unusable metadata"
 * fallback) and is raised past a loaded document's existing ids by
 * `seedRevisionIdsAbove`.
@@ -11,7 +22,8 @@ import { MAX_REVISION_ID } from "@stll/docx-core/model";
 */
 let counter = 1;
 const occupiedIds = /* @__PURE__ */ new Set();
-var RevisionIdAllocationError = class extends TaggedError("RevisionIdAllocationError") {};
+const RevisionIdAllocationErrorBase = TaggedError("RevisionIdAllocationError");
+var RevisionIdAllocationError = class extends RevisionIdAllocationErrorBase {};
 /** Batches use contiguous ids; on rollover prefer the largest unused interval. */
 const largestFreeIntervalStart = (reservedIds) => {
 	let first = 1;