@stll/folio-core 0.62.0 → 0.63.1

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

@@ -1,15 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/BidiShortcutExtension.d.ts
-/**
- * Bidi Shortcut Extension — Ctrl/Cmd+Left Shift → LTR, Ctrl/Cmd+Right Shift → RTL
- *
- * Uses KeyboardEvent.code to distinguish ShiftLeft vs ShiftRight, matching the
- * standard Google Docs shortcut behavior. The keydown/keyup state machine lives
- * in {@link createBidiShortcutController}; this module only wires it to the
- * editor view and dispatches the schema command on keyup.
- *
- * Priority: High (50) — should intercept before other keymaps
- */
-declare const BidiShortcutExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { BidiShortcutExtension };
+export declare const BidiShortcutExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,15 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/ContentControlWidgetsExtension.d.ts
-/**
- * Content-Control Widgets Extension — wires the interactive widget plugin
- * into the editor so clicking inside a typed content control invokes the
- * appropriate transaction.
- *
- * The plugin owns checkbox toggling outright; dropdown / date picker chrome
- * is delegated to the editor shell via the `onWidgetEvent` callback (the
- * shell renders the menu / picker and dispatches via `dispatchDropdownPick`
- * / `dispatchDatePick`).
- */
-declare const ContentControlWidgetsExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { ContentControlWidgetsExtension };
+export declare const ContentControlWidgetsExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,11 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/DropCursorExtension.d.ts
-/**
- * Drop Cursor Extension — shows a visual indicator when dragging content
- *
- * Uses prosemirror-dropcursor to display a cursor line at the drop position
- * when dragging images or other content within the editor.
- */
-declare const DropCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { DropCursorExtension };
+export declare const DropCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,13 +1,12 @@
 import { Extension } from "../types.js";
-import { Plugin } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/EmptyParagraphFormatExtension.d.ts
-declare const emptyParagraphFormatKey: Readonly<{
+export declare const emptyParagraphFormatKey: 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;
 }>;
-declare const EmptyParagraphFormatExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { EmptyParagraphFormatExtension, emptyParagraphFormatKey };
+export declare const EmptyParagraphFormatExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,18 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/GapCursorExtension.d.ts
-/**
- * GapCursor Extension — provides a caret slot before / between / after
- * isolating block nodes (notably `blockSdt`).
- *
- * Without gapcursor, a user cannot place the caret before a doc-starting
- * SDT, between two adjacent SDTs, or after a doc-final SDT — the
- * `isolating` boundary makes regular text selections refuse those
- * positions. The prosemirror-gapcursor plugin paints a thin "gap" caret
- * at those slots so the document stays fully navigable.
- *
- * The plugin also exposes `Backspace` / `Delete` handlers that join the
- * gap into the neighbour when sensible.
- */
-declare const GapCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { GapCursorExtension };
+export declare const GapCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,14 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/ImageDragExtension.d.ts
-/**
- * Image Drag Extension — handles drag-to-reposition for images
- *
- * Provides:
- * - Ghost outline visual during drag
- * - Drop indicator showing where image will land
- * - Inline images: reorder within text flow via ProseMirror's default drag
- * - Custom drag initiation from mousedown on selected images
- */
-declare const ImageDragExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { ImageDragExtension };
+export declare const ImageDragExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,11 +1,4 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/ImagePasteExtension.d.ts
-/**
- * Image Paste Extension — handles image files pasted from the clipboard
- *
- * When an image file is present on the clipboard, this intercepts the paste,
- * reads the image data, and inserts an image node instead of a file icon.
- */
-declare const ImagePasteExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { ImagePasteExtension };
+export declare const ImagePasteExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -44,7 +44,8 @@ async function insertImageFiles(view, files) {
 		if (!await isSafeImageFile(file)) continue;
 		let dataUrl;
 		try {
-			const safeSrc = sanitizeImageSrc(await readFileAsDataUrl(file));
+			const rawDataUrl = await readFileAsDataUrl(file);
+			const safeSrc = sanitizeImageSrc(rawDataUrl);
 			if (!safeSrc) continue;
 			dataUrl = safeSrc;
 		} catch {

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

@@ -1,20 +1,5 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/JoinedRunStyleExtension.d.ts
-/**
- * Runs that a join moves into another paragraph take that paragraph's style.
- *
- * Deleting across a paragraph break (Backspace or Delete at the break, a
- * deletion or typing over a selection that spans paragraphs) runs the later
- * paragraph's remaining text on into the earlier one. A run's direct
- * formatting is its own and stays; what the later paragraph's style lent it
- * does not travel, and it reads in the style of the paragraph it now belongs
- * to. The document styles plugin re-reads those runs after an ordinary edit.
- *
- * A transaction that re-reads the runs it moves itself (resolving a tracked
- * change, an operation that merges paragraphs) says so with
- * {@link JOINED_RUNS_RESTYLED_META}, and is left as it is.
- */
-declare const JOINED_RUNS_RESTYLED_META = "joinedRunsRestyled";
-declare const JoinedRunStyleExtension: (options?: Partial<{}> | undefined) => Extension;
-//#endregion
-export { JOINED_RUNS_RESTYLED_META, JoinedRunStyleExtension };
+export declare const JOINED_RUNS_RESTYLED_META = "joinedRunsRestyled";
+export declare const JoinedRunStyleExtension: (options?: Partial<{}> | undefined) => Extension;
+//#endregion

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

@@ -1,13 +1,12 @@
 import { Extension } from "../types.js";
 import { Command, EditorState } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ListExtension.d.ts
-declare const toggleBulletList: Command;
-declare const toggleNumberedList: Command;
-declare function isInList(state: EditorState): boolean;
-declare function getListInfo(state: EditorState): {
+export declare const toggleBulletList: Command;
+export declare const toggleNumberedList: Command;
+export declare function isInList(state: EditorState): boolean;
+export declare function getListInfo(state: EditorState): {
   numId: number;
   ilvl: number;
 } | null;
-declare const ListExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { ListExtension, getListInfo, isInList, toggleBulletList, toggleNumberedList };
+export declare const ListExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion

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

@@ -1,14 +1,14 @@
 import { Extension } from "../types.js";
 import { Node } from "prosemirror-model";
-import { EditorState, Plugin, Transaction } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParaIdAllocatorExtension.d.ts
 type ParagraphPropertySourceSeed = {
   contract: string | null;
   tokens: ReadonlySet<string>;
 };
-declare const paraIdAllocatorKey: Readonly<{
+export declare const paraIdAllocatorKey: Readonly<{
   key: string;
-  createKey: () => import("prosemirror-state").PluginKey<ParagraphPropertySourceSeed>;
+  createKey: () => PluginKey<ParagraphPropertySourceSeed>;
   owns: (plugin: Plugin<ParagraphPropertySourceSeed>) => boolean;
   get: (state: EditorState) => Plugin<ParagraphPropertySourceSeed> | undefined;
   getState: (state: EditorState) => ParagraphPropertySourceSeed | undefined;
@@ -23,9 +23,9 @@ declare const paraIdAllocatorKey: Readonly<{
  * be deterministic, so it says so on its own transaction rather than leaving
  * the plugin to guess.
  */
-declare const deterministicParaIdSeedKey = "stll.folio.meta.deterministicParaIdSeed";
+export declare const deterministicParaIdSeedKey = "stll.folio.meta.deterministicParaIdSeed";
 /** Ask the allocator to mint reproducible ids for the paragraphs `tr` creates. */
-declare const requestDeterministicParaIds: (tr: Transaction, seed: string) => Transaction;
+export declare const requestDeterministicParaIds: (tr: Transaction, seed: string) => Transaction;
 type ParagraphPropertySourceKeeper = {
   status: "ambiguous";
 } | {
@@ -42,7 +42,7 @@ type MappedParagraphKeepers = {
  *
  * @internal Exported for the per-step equivalence test.
  */
-declare const mapParagraphKeepers: (oldDoc: Node, transactions: readonly Transaction[], sourceSeed: ParagraphPropertySourceSeed) => MappedParagraphKeepers;
+export declare const mapParagraphKeepers: (oldDoc: Node, transactions: readonly Transaction[], sourceSeed: ParagraphPropertySourceSeed) => MappedParagraphKeepers;
 /**
  * Allocate initial paragraph IDs before constructing editor state.
  *
@@ -50,8 +50,9 @@ declare const mapParagraphKeepers: (oldDoc: Node, transactions: readonly Transac
  * step per missing paragraph. Live edits still use the transaction-based plugin
  * below so history, mappings, and duplicate ownership retain their semantics.
  */
-declare const ensureParaIdsInDoc: (doc: Node) => Node;
-declare const ensureParaIdsInState: (state: EditorState) => EditorState;
-declare const ParaIdAllocatorExtension: (options?: Partial<{}> | undefined) => Extension;
+export declare const ensureParaIdsInDoc: (doc: Node) => Node;
+/** {@link ensureParaIdsInDoc} for a state that already exists. */
+export declare const ensureParaIdsInState: (state: EditorState) => EditorState;
+export declare const ParaIdAllocatorExtension: (options?: Partial<{}> | undefined) => Extension;
 //#endregion
-export { ParaIdAllocatorExtension, deterministicParaIdSeedKey, ensureParaIdsInDoc, ensureParaIdsInState, mapParagraphKeepers, paraIdAllocatorKey, requestDeterministicParaIds };
+export {};

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

@@ -6,7 +6,7 @@ import { createExtension } from "../create.js";
 import { ignoreTrackedChanges } from "./ParagraphChangeTrackerExtension.js";
 import { panic } from "better-result";
 import { Fragment } from "prosemirror-model";
-import { Plugin } from "prosemirror-state";
+import { Plugin, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParaIdAllocatorExtension.ts
 /**
 * ParaIdAllocator — assigns a stable `w14:paraId` to every paragraph.
@@ -27,7 +27,10 @@ import { Plugin } from "prosemirror-state";
 * ids in an `appendTransaction` hook after every doc-changed step.
 *
 * Id lifecycle rules (locked by the co-located tests):
-* - Missing/empty/reserved-zero id: a fresh random id is minted.
+* - Load: a missing/empty/reserved-zero or duplicate id gets one derived
+*   from the paragraph's text and ordinal (`ensureParaIdsInDoc`), the same
+*   id the headless reviewer derives for the same document.
+* - Missing/empty/reserved-zero id after an edit: a fresh random id is minted.
 * - Split: the half holding the paragraph's original start position
 *   keeps the id; the other half gets a fresh one. Anchors inside the
 *   content stay resolvable on the half that carries them.
@@ -59,6 +62,14 @@ const paraIdAllocatorKey = createPluginKeyOwner("paraIdAllocator");
 const deterministicParaIdSeedKey = "stll.folio.meta.deterministicParaIdSeed";
 /** Ask the allocator to mint reproducible ids for the paragraphs `tr` creates. */
 const requestDeterministicParaIds = (tr, seed) => tr.setMeta(deterministicParaIdSeedKey, seed);
+const deterministicSeedOf = (transaction) => {
+	const seed = transaction.getMeta(deterministicParaIdSeedKey);
+	if (typeof seed === "string") return seed;
+	const root = transaction.getMeta("appendedTransaction");
+	if (!(root instanceof Transaction)) return void 0;
+	const rootSeed = root.getMeta(deterministicParaIdSeedKey);
+	return typeof rootSeed === "string" ? rootSeed : void 0;
+};
 /**
 * A fresh id not already in `taken`: derived from `seed` and the paragraph's
 * position when the caller asked for reproducibility, random otherwise. Both
@@ -162,11 +173,13 @@ const collectParagraphCensus = (doc, sourceSeed) => {
 		} else census.missingParaIds.push(occurrence);
 		if (sourceSeed) {
 			const token = getProseParagraphPropertySourceToken(node);
-			if (token !== null && token !== void 0) if (typeof token !== "string" || !contractMatchesSeed || !sourceSeed.contract || !sourceSeed.tokens.has(token) || !paragraphPropertySourceTokenMatchesContract(token, sourceSeed.contract)) census.invalidSourceTokens.push(occurrence);
-			else {
-				const occurrences = census.sourceTokens.get(token) ?? [];
-				occurrences.push(occurrence);
-				census.sourceTokens.set(token, occurrences);
+			if (token !== null && token !== void 0) {
+				if (typeof token !== "string" || !contractMatchesSeed || !sourceSeed.contract || !sourceSeed.tokens.has(token) || !paragraphPropertySourceTokenMatchesContract(token, sourceSeed.contract)) census.invalidSourceTokens.push(occurrence);
+				else {
+					const occurrences = census.sourceTokens.get(token) ?? [];
+					occurrences.push(occurrence);
+					census.sourceTokens.set(token, occurrences);
+				}
 			}
 		}
 		return false;
@@ -197,7 +210,6 @@ const collectParaIdUpdatesFromCensus = (census, keeperPositions, deterministicSe
 	updates.sort((left, right) => left.pos - right.pos);
 	return updates;
 };
-const collectParaIdUpdates = (doc) => collectParaIdUpdatesFromCensus(collectParagraphCensus(doc));
 const collectParagraphPropertySourceUpdates = (census, keeperPositions, transactions) => {
 	const updates = /* @__PURE__ */ new Map();
 	for (const { pos } of census.invalidSourceTokens) updates.set(pos, null);
@@ -227,49 +239,49 @@ const collectParagraphPropertySourceUpdates = (census, keeperPositions, transact
 		token
 	})).sort((left, right) => left.pos - right.pos);
 };
-const collectInitialParaIds = (doc) => {
-	let needsRewrite = false;
+/**
+* The ids a loaded document's paragraphs take, in document order: `null`
+* keeps the paragraph's own id, a string replaces it.
+*
+* This is the only load-time allocator. The live editor and the headless
+* reviewer both seed through it, so the same document gives the same block ids
+* on either side: an id read from the editor resolves when the edit is applied
+* headlessly, and re-parsing the same bytes mints the same ids. An id is
+* derived from the paragraph's text and its document ordinal, never drawn at
+* random. Authored ids are reserved first, so a minted id never takes one a
+* later paragraph owns; of a duplicated authored id, the first occurrence
+* keeps it.
+*/
+const planLoadParaIds = (doc) => {
+	const paragraphs = [];
 	const taken = /* @__PURE__ */ new Set();
 	doc.descendants((node) => {
 		if (node.type.name !== "paragraph") return true;
+		paragraphs.push(node);
 		const id = node.attrs["paraId"];
-		if (!isUsableParaId(id) || taken.has(id)) needsRewrite = true;
-		else taken.add(id);
+		if (isUsableParaId(id)) taken.add(id);
 		return false;
 	});
-	return {
-		needsRewrite,
-		taken
-	};
-};
-const rewriteInitialParaIds = (parent, taken, seen) => {
-	let changed = false;
-	const children = [];
-	parent.forEach((child) => {
-		let next = child;
-		if (child.type.name === "paragraph") {
-			const id = child.attrs["paraId"];
-			if (!isUsableParaId(id) || seen.has(id)) {
-				let newId = generateHexId();
-				while (taken.has(newId)) newId = generateHexId();
-				taken.add(newId);
-				seen.add(newId);
-				next = recreateProseNodeWithParagraphPropertySource(child, { attrs: {
-					...child.attrs,
-					paraId: newId
-				} });
-			} else seen.add(id);
-			const paraId = next.attrs["paraId"];
-			if (typeof paraId === "string") transferProseParagraphPropertySource(next, child, paraId);
-		} else if (child.childCount > 0) {
-			const content = rewriteInitialParaIds(child, taken, seen);
-			if (content !== child.content) next = recreateProseNodeWithParagraphPropertySource(child, { content });
+	const kept = /* @__PURE__ */ new Set();
+	return paragraphs.map((paragraph, index) => {
+		const id = paragraph.attrs["paraId"];
+		if (isUsableParaId(id) && !kept.has(id)) {
+			kept.add(id);
+			return null;
 		}
-		if (next !== child) changed = true;
-		children.push(next);
+		const seed = `${paragraph.textContent}:${String(index + 1)}`;
+		let minted = deterministicHexId(seed);
+		for (let salt = 1; taken.has(minted); salt++) minted = deterministicHexId(`${seed}:${String(salt)}`);
+		taken.add(minted);
+		return minted;
 	});
-	return changed ? Fragment.fromArray(children) : parent.content;
 };
+/** A paragraph's attrs once it holds an id folio minted rather than read. */
+const mintedParagraphAttrs = (paragraph, paraId) => ({
+	...paragraph.attrs,
+	paraId,
+	...paragraph.type.spec.attrs?.["idStability"] !== void 0 && { idStability: "positional" }
+});
 /**
 * Allocate initial paragraph IDs before constructing editor state.
 *
@@ -278,19 +290,48 @@ const rewriteInitialParaIds = (parent, taken, seen) => {
 * below so history, mappings, and duplicate ownership retain their semantics.
 */
 const ensureParaIdsInDoc = (doc) => {
-	const { needsRewrite, taken } = collectInitialParaIds(doc);
-	if (!needsRewrite) return doc;
-	return recreateProseNodeWithParagraphPropertySource(doc, { content: rewriteInitialParaIds(doc, taken, /* @__PURE__ */ new Set()) });
+	const plan = planLoadParaIds(doc);
+	if (plan.every((paraId) => paraId === null)) return doc;
+	let ordinal = 0;
+	const rewrite = (parent) => {
+		let changed = false;
+		const children = [];
+		parent.forEach((child) => {
+			let next = child;
+			if (child.type.name === "paragraph") {
+				const minted = plan[ordinal];
+				ordinal += 1;
+				if (minted !== null && minted !== void 0) next = recreateProseNodeWithParagraphPropertySource(child, { attrs: mintedParagraphAttrs(child, minted) });
+				const paraId = next.attrs["paraId"];
+				if (typeof paraId === "string") transferProseParagraphPropertySource(next, child, paraId);
+			} else if (child.childCount > 0) {
+				const content = rewrite(child);
+				if (content !== child.content) next = recreateProseNodeWithParagraphPropertySource(child, { content });
+			}
+			if (next !== child) changed = true;
+			children.push(next);
+		});
+		return changed ? Fragment.fromArray(children) : parent.content;
+	};
+	return recreateProseNodeWithParagraphPropertySource(doc, { content: rewrite(doc) });
 };
+/** {@link ensureParaIdsInDoc} for a state that already exists. */
 const ensureParaIdsInState = (state) => {
-	const updates = collectParaIdUpdates(state.doc);
-	if (updates.length === 0) return state;
+	const plan = planLoadParaIds(state.doc);
+	if (plan.every((paraId) => paraId === null)) return state;
 	const tr = state.tr;
-	for (const update of updates) setProseParagraphMarkupWithPropertySource({
-		attrs: update.attrs,
-		ownership: "transfer-allocated-id",
-		pos: update.pos,
-		transaction: tr
+	let ordinal = 0;
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const minted = plan[ordinal];
+		ordinal += 1;
+		if (minted !== null && minted !== void 0) setProseParagraphMarkupWithPropertySource({
+			attrs: mintedParagraphAttrs(node, minted),
+			ownership: "transfer-allocated-id",
+			pos,
+			transaction: tr
+		});
+		return false;
 	});
 	ignoreTrackedChanges(tr);
 	tr.setMeta(paraIdAllocatorKey, "allocated");
@@ -308,7 +349,7 @@ const createParaIdAllocatorPlugin = () => new Plugin({
 		const paragraphSourceSeed = paraIdAllocatorKey.getState(oldState);
 		if (!paragraphSourceSeed) panic("ParaId allocator lost its paragraph-property source seed");
 		const keeperPositions = mapParagraphKeepers(oldState.doc, transactions, paragraphSourceSeed);
-		const deterministicSeed = transactions.map((transaction) => transaction.getMeta("stll.folio.meta.deterministicParaIdSeed")).find((value) => typeof value === "string") ?? null;
+		const deterministicSeed = transactions.map(deterministicSeedOf).find((value) => typeof value === "string") ?? null;
 		const census = collectParagraphCensus(newState.doc, paragraphSourceSeed);
 		const updates = collectParaIdUpdatesFromCensus(census, keeperPositions.paraIds, deterministicSeed);
 		const paragraphSourceUpdates = collectParagraphPropertySourceUpdates(census, keeperPositions.sourceTokens, transactions);

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

@@ -2,16 +2,16 @@ import { document_d_exports } from "../../../types/document.js";
 import { Extension } from "../types.js";
 import { RemovedSectionReference, TrackedSectionEndpointRemoval } from "../../../internal/sectionEndpointResolution.js";
 import { Node } from "prosemirror-model";
-import { EditorState, Plugin, Transaction } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts
-declare const paragraphChangeTrackerKey: Readonly<{
+export declare const paragraphChangeTrackerKey: Readonly<{
   key: string;
-  createKey: () => import("prosemirror-state").PluginKey<InternalParagraphChangeTrackerState>;
+  createKey: () => PluginKey<InternalParagraphChangeTrackerState>;
   owns: (plugin: Plugin<InternalParagraphChangeTrackerState>) => boolean;
   get: (state: EditorState) => Plugin<InternalParagraphChangeTrackerState> | undefined;
   getState: (state: EditorState) => InternalParagraphChangeTrackerState | undefined;
 }>;
-type ParagraphChangeTrackerState = {
+export type ParagraphChangeTrackerState = {
   /** Set of paraIds that were modified since last clear */
   changedParaIds: Set<string>;
   /** Whether paragraph order, membership, or block structure changed. */
@@ -36,25 +36,25 @@ type InternalParagraphChangeTrackerState = ParagraphChangeTrackerState & {
   /** The section records themselves, by identity. */
   sectionRecords: ReadonlySet<document_d_exports.SectionProperties>;
 };
-declare function createParagraphChangeTrackerPlugin(): Plugin<InternalParagraphChangeTrackerState>;
+export declare function createParagraphChangeTrackerPlugin(): Plugin<InternalParagraphChangeTrackerState>;
 /**
  * Get the change tracker state from an EditorState
  */
-declare function getChangeTrackerState(state: EditorState): ParagraphChangeTrackerState | undefined;
+export declare function getChangeTrackerState(state: EditorState): ParagraphChangeTrackerState | undefined;
 /**
  * Get the set of changed paragraph IDs from an EditorState
  */
-declare function getChangedParagraphIds(state: EditorState): Set<string>;
+export declare function getChangedParagraphIds(state: EditorState): Set<string>;
 /**
  * Check if paragraph membership, order, or block structure changed
  */
-declare function hasStructuralChanges(state: EditorState): boolean;
+export declare function hasStructuralChanges(state: EditorState): boolean;
 /**
  * Check if any changes affected paragraphs without paraId
  */
-declare function hasUntrackedChanges(state: EditorState): boolean;
+export declare function hasUntrackedChanges(state: EditorState): boolean;
 /** Exact section-count transition authorized by tracked paragraph-mark resolution. */
-declare function getTrackedSectionEndpointRemoval(state: EditorState): TrackedSectionEndpointRemoval | null;
+export declare function getTrackedSectionEndpointRemoval(state: EditorState): TrackedSectionEndpointRemoval | null;
 type RepackWithEditorSectionRemovalsOptions<T> = {
   /** The editor state the document was built from. */
   state: EditorState;
@@ -72,29 +72,29 @@ type RepackWithEditorSectionRemovalsOptions<T> = {
  * tracker records exactly those removals; without them the repack throws and
  * the edit cannot be saved.
  */
-declare const repackWithEditorSectionRemovals: <T>({ state, document, repack }: RepackWithEditorSectionRemovalsOptions<T>) => Promise<T>;
+export declare const repackWithEditorSectionRemovals: <T>({ state, document, repack }: RepackWithEditorSectionRemovalsOptions<T>) => Promise<T>;
 type MarkTrackedSectionEndpointRemovalOptions = {
   sourceDoc: Node;
   removedEndpointCount: number;
   removedReferences: readonly RemovedSectionReference[];
 };
 /** Record only a complete, internally consistent endpoint-removal transition. */
-declare function markTrackedSectionEndpointRemoval(tr: Transaction, { sourceDoc, removedEndpointCount, removedReferences }: MarkTrackedSectionEndpointRemovalOptions): Transaction;
+export declare function markTrackedSectionEndpointRemoval(tr: Transaction, { sourceDoc, removedEndpointCount, removedReferences }: MarkTrackedSectionEndpointRemovalOptions): Transaction;
 /**
  * Record that `tr` removed section breaks on purpose: a command whose job is
  * to remove the break (not to delete its paragraph mark, which the tracker
  * reads for itself). Only a plain removal is recorded; a transaction that also
  * adds or replaces a record is left as it is.
  */
-declare function markSectionBreakRemoval(tr: Transaction, sourceDoc: Node): Transaction;
+export declare function markSectionBreakRemoval(tr: Transaction, sourceDoc: Node): Transaction;
 /**
  * Create a transaction that clears the change tracker
  */
-declare function clearTrackedChanges(state: EditorState): Transaction;
-declare function ignoreTrackedChanges(tr: Transaction): Transaction;
+export declare function clearTrackedChanges(state: EditorState): Transaction;
+export declare function ignoreTrackedChanges(tr: Transaction): Transaction;
 /** A committed package-story/property edit requires the full package serializer. */
-declare const markPackageChange: (tr: Transaction) => Transaction;
-declare function markStructuralChange(tr: Transaction): Transaction;
+export declare const markPackageChange: (tr: Transaction) => Transaction;
+export declare function markStructuralChange(tr: Transaction): Transaction;
 type MarkChangedParagraphRangesOptions = {
   ranges: readonly {
     from: number;
@@ -104,7 +104,7 @@ type MarkChangedParagraphRangesOptions = {
   replacesStepMapAt?: number;
 };
 /** Record mark-only paragraph changes whose replacement step has a granular map. */
-declare function markChangedParagraphRanges(tr: Transaction, batch: MarkChangedParagraphRangesOptions): Transaction;
-declare const ParagraphChangeTrackerExtension: (options?: Partial<{}> | undefined) => Extension;
+export declare function markChangedParagraphRanges(tr: Transaction, batch: MarkChangedParagraphRangesOptions): Transaction;
+export declare const ParagraphChangeTrackerExtension: (options?: Partial<{}> | undefined) => Extension;
 //#endregion
-export { ParagraphChangeTrackerExtension, ParagraphChangeTrackerState, clearTrackedChanges, createParagraphChangeTrackerPlugin, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markPackageChange, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };
+export {};

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

@@ -91,7 +91,8 @@ function collectAffectedParaIds(doc, from, to) {
 	const positions = /* @__PURE__ */ new Set();
 	let hasUntracked = false;
 	const start = Math.max(0, Math.min(from, doc.content.size));
-	nodesBetweenIndexed(doc, start, Math.max(start, Math.min(to, doc.content.size)), (node, pos) => {
+	const end = Math.max(start, Math.min(to, doc.content.size));
+	nodesBetweenIndexed(doc, start, end, (node, pos) => {
 		if (node.type.name === "paragraph") {
 			positions.add(pos);
 			const paraId = node.attrs["paraId"];

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

@@ -1,25 +1,8 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/PasteCleanupExtension.d.ts
-/**
- * Paste Cleanup Extension
- *
- * Wires two paste-handling behaviors into the editor:
- *
- * 1. `transformPastedHTML` — strips Office/web producer cruft from pasted HTML
- *    (see {@link cleanPastedHtml}) before the schema parser reads it. Runs at
- *    `Highest` priority so the cleanup happens before the style inliner and the
- *    default clipboard parser; ProseMirror chains every plugin's
- *    `transformPastedHTML`, so this cooperates with the inliner rather than
- *    replacing it, and `<style>` blocks are left intact for it to resolve.
- * 2. `transformPasted` — drops unpaired bookmark and move-range boundaries,
- *    then points pasted headings at the open document's own heading style
- *    (see {@link retargetPastedHeadingStyles}).
- * 3. `Mod-Alt-v` — "paste without formatting", inserting clipboard text with
- *    the source formatting stripped (see {@link pasteWithoutFormatting}).
- */
 type PasteCleanupOptions = {
   getInternalClipboardToken?: () => string;
 };
-declare const PasteCleanupExtension: (options?: Partial<PasteCleanupOptions> | undefined) => Extension;
+export declare const PasteCleanupExtension: (options?: Partial<PasteCleanupOptions> | undefined) => Extension;
 //#endregion
-export { PasteCleanupExtension };
+export {};

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

@@ -1,19 +1,8 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/features/PasteStyleInlinerExtension.d.ts
 /**
- * Paste Style Inliner Extension
- *
- * When pasting from apps like Google Docs that use class-based CSS
- * (e.g. `<style>.c5 { margin-top: 12pt }</style>`) instead of inline styles,
- * ProseMirror's parseDOM can't read the styles because elements aren't attached
- * to the live document during parsing.
- *
- * This extension provides a `transformPastedHTML` hook that:
- * 1. Parses the pasted HTML string
- * 2. Extracts all `<style>` rules
- * 3. Inlines them onto matching elements
- * 4. Returns the modified HTML so parseDOM can read inline styles
+ * Transform pasted HTML by inlining class-based CSS and unwrapping Google Docs wrappers.
  */
-declare const PasteStyleInlinerExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { PasteStyleInlinerExtension };
+export declare function transformPastedHTML(html: string): string;
+export declare const PasteStyleInlinerExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion