@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/paragraphIndentation.d.ts

@@ -3,9 +3,9 @@ import { FolioContentParagraphIndentation } from "../compare/content-types.js";
 import { ParagraphAttrs } from "./schema/nodes.js";
 //#region src/prosemirror/paragraphIndentation.d.ts
 /** The authored `w:ind` attribute cluster. */
-type DirectParagraphIndentation = FolioContentParagraphIndentation;
+export type DirectParagraphIndentation = FolioContentParagraphIndentation;
 /** Project only authored `w:ind` attributes, preserving zero and false. */
-declare const paragraphIndentationFromFormatting: (formatting: document_d_exports.ParagraphFormatting | null | undefined) => DirectParagraphIndentation | undefined;
+export declare const paragraphIndentationFromFormatting: (formatting: document_d_exports.ParagraphFormatting | null | undefined) => DirectParagraphIndentation | undefined;
 /**
  * Read direct indentation without materializing values inherited from a style:
  * the `w:ind` a save writes for the paragraph.
@@ -16,15 +16,15 @@ declare const paragraphIndentationFromFormatting: (formatting: document_d_export
  * command set on a paragraph whose source stated none. A hanging indent reads
  * with a negative `indentFirstLine`, as the model states it.
  */
-declare const directParagraphIndentation: (attrs: ParagraphAttrs) => DirectParagraphIndentation | undefined;
-declare const paragraphIndentationEqual: (left: DirectParagraphIndentation | null | undefined, right: DirectParagraphIndentation | null | undefined) => boolean;
+export declare const directParagraphIndentation: (attrs: ParagraphAttrs) => DirectParagraphIndentation | undefined;
+export declare const paragraphIndentationEqual: (left: DirectParagraphIndentation | null | undefined, right: DirectParagraphIndentation | null | undefined) => boolean;
 /** Replace the complete direct `w:ind` cluster in canonical formatting. */
-declare const withDirectParagraphIndentation: (formatting: document_d_exports.ParagraphFormatting | null | undefined, indentation: DirectParagraphIndentation | null | undefined) => document_d_exports.ParagraphFormatting | undefined;
+export declare const withDirectParagraphIndentation: (formatting: document_d_exports.ParagraphFormatting | null | undefined, indentation: DirectParagraphIndentation | null | undefined) => document_d_exports.ParagraphFormatting | undefined;
 type ParagraphIndentationAttrPatchOptions = {
   direct: DirectParagraphIndentation | null | undefined;
   inherited: DirectParagraphIndentation | null | undefined;
 };
 /** Project direct-over-inherited indentation into paragraph attrs. */
-declare const paragraphIndentationAttrPatch: ({ direct, inherited }: ParagraphIndentationAttrPatchOptions) => Record<string, unknown>;
+export declare const paragraphIndentationAttrPatch: ({ direct, inherited }: ParagraphIndentationAttrPatchOptions) => Record<string, unknown>;
 //#endregion
-export { DirectParagraphIndentation, directParagraphIndentation, paragraphIndentationAttrPatch, paragraphIndentationEqual, paragraphIndentationFromFormatting, withDirectParagraphIndentation };
+export {};

package/dist/prosemirror/paragraphList.d.ts

@@ -0,0 +1,39 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphNumberingSources } from "./numberingAttr.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { ResolvedParagraphNumbering } from "@stll/docx-core/model";
+//#region src/prosemirror/paragraphList.d.ts
+type ParagraphListReference = Extract<ResolvedParagraphNumbering, {
+  kind: "reference";
+}>;
+/**
+ * `projection`: only the paragraph's cached list projection made it a list
+ * (a package-free model), so its reference names no authored numbering
+ * instance and readers must not report one.
+ */
+type ListReferenceSource = "authored" | "projection";
+export type ParagraphList = {
+  kind: "none";
+} | {
+  kind: "markerless";
+  reference: ParagraphListReference;
+  source: ListReferenceSource;
+  rendering?: document_d_exports.ListRendering;
+  reason: "noNumbering" | "levelOutOfRange" | "noInstance" | "noAbstract" | "unresolvedStyleLink" | "levelNotDefined" | "markerHiddenOrBlank";
+} | {
+  kind: "marker";
+  reference: ParagraphListReference;
+  source: ListReferenceSource;
+  rendering: document_d_exports.ListRendering;
+};
+/**
+ * Resolves paragraph list membership, level, and marker visibility once for
+ * every reader. Authored numbering attrs select the reference; package
+ * definitions alone decide whether that reference paints a marker.
+ */
+export declare const resolveParagraphList: (sources: ParagraphNumberingSources & {
+  /** `null` means the current style was resolved and supplies no numbering. */
+  inheritedReference?: ParagraphListReference | null;
+}, numbering: NumberingMap | null, standaloneRendering?: document_d_exports.ListRendering) => ParagraphList;
+//#endregion
+export {};

package/dist/prosemirror/paragraphList.js

@@ -0,0 +1,81 @@
+import { computeListRendering } from "../docx/numberingParser.js";
+import { effectiveParagraphNumbering } from "./numberingAttr.js";
+import { panic } from "better-result";
+import { levelShowsMarker, numberingLevelHasMarkerSlot, paragraphNumberingReference, resolveNumberingLevel } from "@stll/docx-core/model";
+//#region src/prosemirror/paragraphList.ts
+const standaloneList = (reference, rendering, source) => rendering.markerHidden === true || rendering.marker.trim().length === 0 && ((rendering.markerTemplate ?? rendering.marker) !== "" || !numberingLevelHasMarkerSlot({ numFmt: rendering.numFmt ?? "decimal" }, rendering.isLegal)) ? {
+	kind: "markerless",
+	reference,
+	source,
+	rendering,
+	reason: "markerHiddenOrBlank"
+} : {
+	kind: "marker",
+	reference,
+	source,
+	rendering
+};
+/**
+* Resolves paragraph list membership, level, and marker visibility once for
+* every reader. Authored numbering attrs select the reference; package
+* definitions alone decide whether that reference paints a marker.
+*/
+const resolveParagraphList = (sources, numbering, standaloneRendering) => {
+	const resolved = effectiveParagraphNumbering({
+		numPr: sources.numPr,
+		numPrFromStyle: sources.inheritedReference === void 0 ? sources.numPrFromStyle : sources.inheritedReference ?? void 0
+	});
+	const projectionStandsIn = numbering === null && standaloneRendering !== void 0 && sources.numPr?.kind !== "none";
+	switch (resolved.kind) {
+		case "none":
+			if (projectionStandsIn) {
+				const reference = paragraphNumberingReference({
+					numId: standaloneRendering.numId,
+					ilvl: standaloneRendering.level
+				});
+				return standaloneList(reference, standaloneRendering, "projection");
+			}
+			return { kind: "none" };
+		case "reference": {
+			const reference = resolved;
+			if (numbering === null) return standaloneRendering === void 0 ? {
+				kind: "markerless",
+				reference,
+				source: "authored",
+				reason: "noNumbering"
+			} : standaloneList(reference, standaloneRendering, "authored");
+			const resolution = resolveNumberingLevel(numbering.definitions, reference.numId, reference.ilvl);
+			if (resolution.kind === "undefined") return {
+				kind: "markerless",
+				reference,
+				source: "authored",
+				reason: resolution.reason
+			};
+			if (!levelShowsMarker(numbering.definitions, reference.numId, reference.ilvl)) {
+				const rendering = computeListRendering(reference, numbering);
+				return {
+					kind: "markerless",
+					reference,
+					source: "authored",
+					reason: "markerHiddenOrBlank",
+					...rendering === null ? {} : { rendering }
+				};
+			}
+			const rendering = computeListRendering(reference, numbering);
+			return rendering === null ? {
+				kind: "markerless",
+				reference,
+				source: "authored",
+				reason: "markerHiddenOrBlank"
+			} : {
+				kind: "marker",
+				reference,
+				source: "authored",
+				rendering
+			};
+		}
+		default: return panic(`Unhandled paragraph numbering ${JSON.stringify(resolved)}`);
+	}
+};
+//#endregion
+export { resolveParagraphList };

package/dist/prosemirror/paragraphMarkJoin.d.ts

@@ -2,6 +2,16 @@ import { RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/paragraphMarkJoin.d.ts
+/**
+ * The attrs the paragraph a join leaves takes: `next`'s, less the editing
+ * sessions (`w:rsid*` attributes) it shares with the removed `paragraph`.
+ *
+ * A split copies the paragraph's attrs onto both halves, and a save writes
+ * the sessions on the first half only, the first record in document order.
+ * Rejecting the split removes that first half, so the paragraph left names
+ * none of them, live as after a save.
+ */
+export declare const joinedParagraphAttrs: (paragraph: Node, next: Node) => Node["attrs"];
 type JoinAtParagraphMarkOptions = {
   tr: Transaction;
   /** Position of the paragraph whose mark goes. */
@@ -16,6 +26,6 @@ type JoinAtParagraphMarkOptions = {
    */
   styleResolver: RunStyleResolver | null;
 };
-declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, styleResolver }: JoinAtParagraphMarkOptions) => void;
+export declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, styleResolver }: JoinAtParagraphMarkOptions) => void;
 //#endregion
-export { joinAtParagraphMark };
+export {};

package/dist/prosemirror/paragraphMarkJoin.js

@@ -5,6 +5,37 @@ import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
 import { paragraphRunStyleContext } from "./runStyleFormatting.js";
 import { panic } from "better-result";
 //#region src/prosemirror/paragraphMarkJoin.ts
+/**
+* Removing a paragraph mark: the one join both a resolved revision and a
+* retracted one perform.
+*
+* A paragraph's mark ends it, and in OOXML its properties live on that mark.
+* With the mark gone, the paragraph runs on into the next one and ends with
+* the NEXT paragraph's mark, so the paragraph left is the next one: its
+* identity, its paragraph properties (style, numbering, the mark's own run
+* properties), its mark's revision and its section endpoint all survive, and
+* the removed mark takes its paragraph's properties and section endpoint with
+* it. This holds whether the first paragraph still has words or not.
+*
+* The first paragraph's runs keep their direct formatting; what its style
+* lent them is re-read in the next paragraph's style.
+*/
+/**
+* The attrs the paragraph a join leaves takes: `next`'s, less the editing
+* sessions (`w:rsid*` attributes) it shares with the removed `paragraph`.
+*
+* A split copies the paragraph's attrs onto both halves, and a save writes
+* the sessions on the first half only, the first record in document order.
+* Rejecting the split removes that first half, so the paragraph left names
+* none of them, live as after a save.
+*/
+const joinedParagraphAttrs = (paragraph, next) => {
+	const sessions = next.attrs["_preservedAttributes"];
+	return typeof sessions === "object" && sessions !== null && sessions === paragraph.attrs["_preservedAttributes"] ? {
+		...next.attrs,
+		_preservedAttributes: null
+	} : next.attrs;
+};
 const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, styleResolver }) => {
 	const boundary = paragraphPos + paragraph.nodeSize;
 	const join = paragraphJoinAfter(tr.doc, boundary);
@@ -13,13 +44,13 @@ const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, styleResolver
 		const leftToken = getProseParagraphPropertySourceToken(paragraph);
 		const rightToken = getProseParagraphPropertySourceToken(next);
 		tr.replaceWith(boundary - 1, join.nextPosition + 1, join.inlineBookmarks);
-		tr.setNodeMarkup(paragraphPos, void 0, next.attrs);
+		tr.setNodeMarkup(paragraphPos, void 0, joinedParagraphAttrs(paragraph, next));
 		markParagraphPropertySourceTransfers(tr, [{
 			displacedToken: typeof leftToken === "string" ? leftToken : null,
 			selectedToken: typeof rightToken === "string" ? rightToken : null
 		}]);
 	} else joinProseParagraphsWithRightPropertySource({
-		attrs: next.attrs,
+		attrs: joinedParagraphAttrs(paragraph, next),
 		pos: boundary,
 		transaction: tr
 	});
@@ -37,4 +68,4 @@ const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, styleResolver
 	tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 };
 //#endregion
-export { joinAtParagraphMark };
+export { joinAtParagraphMark, joinedParagraphAttrs };

package/dist/prosemirror/paragraphPropertyCarry.d.ts

@@ -1,6 +1,6 @@
 import { ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
-import { RunStyleResolver } from "./runStyleFormatting.js";
 import { NumberingMap } from "../docx/numberingParser.js";
+import { RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/paragraphPropertyCarry.d.ts
@@ -22,7 +22,7 @@ type CarriedParagraphPropertiesOptions = Pick<CarryParagraphPropertiesOptions, "
   target: Node;
 };
 /** The exact formatting transfer, shared with pre-mutation capacity checks. */
-declare const carriedParagraphProperties: ({ source, target, keep }: CarriedParagraphPropertiesOptions) => RecordedFormatting;
+export declare const carriedParagraphProperties: ({ source, target, keep }: CarriedParagraphPropertiesOptions) => RecordedFormatting;
 /**
  * Give a paragraph another one's properties: the pPr a property change
  * covers. Its identity, mark, mark run properties and section stay its own,
@@ -30,7 +30,7 @@ declare const carriedParagraphProperties: ({ source, target, keep }: CarriedPara
  * change now records what it had: a paragraph holds one, and a pending one
  * already records it.
  */
-declare const carryParagraphProperties: ({ tr, position, source, styleResolver, numbering, revision, keep }: CarryParagraphPropertiesOptions) => {
+export declare const carryParagraphProperties: ({ tr, position, source, styleResolver, numbering, revision, keep }: CarryParagraphPropertiesOptions) => {
   tr: Transaction;
   changed: boolean;
   tracked: boolean;
@@ -46,7 +46,7 @@ type ParagraphLeftAfterOptions = {
  * the next one, or, when its own break is pending deletion too, the first
  * paragraph after it whose break stays. Null when no paragraph follows.
  */
-declare const paragraphLeftAfter: ({ doc, paragraphPos, removedBreakPositions }: ParagraphLeftAfterOptions) => number | null;
+export declare const paragraphLeftAfter: ({ doc, paragraphPos, removedBreakPositions }: ParagraphLeftAfterOptions) => number | null;
 /**
  * A paragraph now holds the break another one had (a split, or a paste into
  * it, leaves that break on the last part) but reads with other properties:
@@ -55,7 +55,7 @@ declare const paragraphLeftAfter: ({ doc, paragraphPos, removedBreakPositions }:
  * pending property change on the other one travels as it is. Returns whether
  * a change under `revision` was written.
  */
-declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revision }: {
+export declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revision }: {
   tr: Transaction;
   position: number;
   replaced: Node;
@@ -65,6 +65,6 @@ declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revi
  * The properties a batch's own property change set on a paragraph: the ones
  * whose value differs from what that change records as before.
  */
-declare const propertiesSetInBatch: (node: Node, batchRevisionIds: ReadonlySet<number>) => ReadonlySet<string>;
+export declare const propertiesSetInBatch: (node: Node, batchRevisionIds: ReadonlySet<number>) => ReadonlySet<string>;
 //#endregion
-export { carriedParagraphProperties, carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };
+export {};

package/dist/prosemirror/paragraphSpacing.d.ts

@@ -3,27 +3,27 @@ import { FolioAIParagraphSpacing } from "../ai-edits/types.js";
 import { ParagraphAttrs } from "./schema/nodes.js";
 //#region src/prosemirror/paragraphSpacing.d.ts
 /** The complete modeled attribute set of one direct `w:pPr/w:spacing`. */
-declare const DIRECT_PARAGRAPH_SPACING_KEYS: readonly ["spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "beforeAutospacing", "afterAutospacing"];
-type DirectParagraphSpacing = FolioAIParagraphSpacing;
+export declare const DIRECT_PARAGRAPH_SPACING_KEYS: readonly ["spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "beforeAutospacing", "afterAutospacing"];
+export type DirectParagraphSpacing = FolioAIParagraphSpacing;
 type ExactLineSpacingProvenance = Exclude<NonNullable<ParagraphAttrs["lineSpacingExplicit"]>, boolean>;
-declare const lineSpacingProvenanceFromSpacing: (spacing: DirectParagraphSpacing | null | undefined) => ExactLineSpacingProvenance | undefined;
+export declare const lineSpacingProvenanceFromSpacing: (spacing: DirectParagraphSpacing | null | undefined) => ExactLineSpacingProvenance | undefined;
 /** Project only authored `w:spacing` attributes, preserving explicit zero and false. */
-declare const paragraphSpacingFromFormatting: (formatting: DirectParagraphSpacing | null | undefined) => DirectParagraphSpacing | undefined;
+export declare const paragraphSpacingFromFormatting: (formatting: DirectParagraphSpacing | null | undefined) => DirectParagraphSpacing | undefined;
 /**
  * Read direct spacing independently of the effective values used for layout.
  * Imported and command-authored paragraphs keep their source in
  * `_originalFormatting`; explicit PM attrs cover newly created content.
  */
-declare const directParagraphSpacing: (attrs: ParagraphAttrs) => DirectParagraphSpacing | undefined;
+export declare const directParagraphSpacing: (attrs: ParagraphAttrs) => DirectParagraphSpacing | undefined;
 /** Structural equality for the canonical, fixed-order spacing projection. */
-declare const paragraphSpacingEqual: (left: DirectParagraphSpacing | null | undefined, right: DirectParagraphSpacing | null | undefined) => boolean;
+export declare const paragraphSpacingEqual: (left: DirectParagraphSpacing | null | undefined, right: DirectParagraphSpacing | null | undefined) => boolean;
 /** Replace the complete direct `w:spacing` cluster in canonical formatting. */
-declare const withDirectParagraphSpacing: (formatting: document_d_exports.ParagraphFormatting | null | undefined, spacing: DirectParagraphSpacing | null | undefined) => document_d_exports.ParagraphFormatting | undefined;
+export declare const withDirectParagraphSpacing: (formatting: document_d_exports.ParagraphFormatting | null | undefined, spacing: DirectParagraphSpacing | null | undefined) => document_d_exports.ParagraphFormatting | undefined;
 type ParagraphSpacingAttrPatchOptions = {
   direct: DirectParagraphSpacing | null | undefined;
   inherited: DirectParagraphSpacing | null | undefined;
 };
 /** Project direct-over-inherited spacing into the attrs consumed by layout. */
-declare const paragraphSpacingAttrPatch: ({ direct, inherited }: ParagraphSpacingAttrPatchOptions) => Record<string, unknown>;
+export declare const paragraphSpacingAttrPatch: ({ direct, inherited }: ParagraphSpacingAttrPatchOptions) => Record<string, unknown>;
 //#endregion
-export { DIRECT_PARAGRAPH_SPACING_KEYS, DirectParagraphSpacing, directParagraphSpacing, lineSpacingProvenanceFromSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqual, paragraphSpacingFromFormatting, withDirectParagraphSpacing };
+export {};

package/dist/prosemirror/paragraphSpacing.js

@@ -64,16 +64,22 @@ const directParagraphSpacing = (attrs) => {
 		if (typeof spaceAfter === "number") spacing.spaceAfter = spaceAfter;
 		else Reflect.deleteProperty(spacing, "spaceAfter");
 	}
-	if (spacing.spaceBefore !== void 0 || attrs.spacingExplicit?.before === true) if (typeof spaceBefore === "number") spacing.spaceBefore = spaceBefore;
-	else Reflect.deleteProperty(spacing, "spaceBefore");
-	if (spacing.spaceAfter !== void 0 || attrs.spacingExplicit?.after === true) if (typeof spaceAfter === "number") spacing.spaceAfter = spaceAfter;
-	else Reflect.deleteProperty(spacing, "spaceAfter");
-	if (lineProvenance === "value" || lineProvenance === "both") if (typeof attrs.lineSpacing === "number") spacing.lineSpacing = attrs.lineSpacing;
-	else Reflect.deleteProperty(spacing, "lineSpacing");
-	else Reflect.deleteProperty(spacing, "lineSpacing");
-	if (lineProvenance === "rule" || lineProvenance === "both") if (attrs.lineSpacingRule !== void 0) spacing.lineSpacingRule = attrs.lineSpacingRule;
-	else Reflect.deleteProperty(spacing, "lineSpacingRule");
-	else Reflect.deleteProperty(spacing, "lineSpacingRule");
+	if (spacing.spaceBefore !== void 0 || attrs.spacingExplicit?.before === true) {
+		if (typeof spaceBefore === "number") spacing.spaceBefore = spaceBefore;
+		else Reflect.deleteProperty(spacing, "spaceBefore");
+	}
+	if (spacing.spaceAfter !== void 0 || attrs.spacingExplicit?.after === true) {
+		if (typeof spaceAfter === "number") spacing.spaceAfter = spaceAfter;
+		else Reflect.deleteProperty(spacing, "spaceAfter");
+	}
+	if (lineProvenance === "value" || lineProvenance === "both") {
+		if (typeof attrs.lineSpacing === "number") spacing.lineSpacing = attrs.lineSpacing;
+		else Reflect.deleteProperty(spacing, "lineSpacing");
+	} else Reflect.deleteProperty(spacing, "lineSpacing");
+	if (lineProvenance === "rule" || lineProvenance === "both") {
+		if (attrs.lineSpacingRule !== void 0) spacing.lineSpacingRule = attrs.lineSpacingRule;
+		else Reflect.deleteProperty(spacing, "lineSpacingRule");
+	} else Reflect.deleteProperty(spacing, "lineSpacingRule");
 	return Object.keys(spacing).length > 0 ? spacing : void 0;
 };
 /** Structural equality for the canonical, fixed-order spacing projection. */

package/dist/prosemirror/pluginKeyOwner.d.ts

@@ -1,6 +1,6 @@
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/pluginKeyOwner.d.ts
-type PluginKeyOwner<State> = Readonly<{
+export type PluginKeyOwner<State> = Readonly<{
   key: string;
   createKey: () => PluginKey<State>;
   owns: (plugin: Plugin<State>) => boolean;
@@ -8,6 +8,5 @@ type PluginKeyOwner<State> = Readonly<{
   getState: (state: EditorState) => State | undefined;
 }>;
 /** An immutable plugin family descriptor; each plugin owns its actual key. */
-declare const createPluginKeyOwner: <State = unknown>(name: string) => PluginKeyOwner<State>;
-//#endregion
-export { PluginKeyOwner, createPluginKeyOwner };
+export declare const createPluginKeyOwner: <State = unknown>(name: string) => PluginKeyOwner<State>;
+//#endregion

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

@@ -2,7 +2,7 @@ import { PluginKeyOwner } from "../pluginKeyOwner.js";
 import { Plugin } from "prosemirror-state";
 import { DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/plugins/aiCitationDecorations.d.ts
-declare const aiCitationDecorationsKey: Readonly<{
+export declare const aiCitationDecorationsKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<AICitationDecorationState>;
   owns: (plugin: Plugin<AICitationDecorationState>) => boolean;
@@ -11,7 +11,7 @@ declare const aiCitationDecorationsKey: Readonly<{
 }>;
 declare const SET_META = "set";
 declare const ACTIVE_META = "active";
-type AICitationRange = {
+export type AICitationRange = {
   /** Stable id from the thread message. */
   id: string;
   from: number;
@@ -28,15 +28,15 @@ type AICitationDecorationState = {
  * update which ranges are shown and which one is currently active
  * (e.g., the one the user just clicked).
  */
-declare function createAICitationDecorationsPlugin(): Plugin<AICitationDecorationState>;
-declare function setAICitationsMeta(citations: AICitationRange[]): {
+export declare function createAICitationDecorationsPlugin(): Plugin<AICitationDecorationState>;
+export declare function setAICitationsMeta(citations: AICitationRange[]): {
   key: PluginKeyOwner<AICitationDecorationState>;
   payload: {
     type: typeof SET_META;
     citations: AICitationRange[];
   };
 };
-declare function setActiveCitationMeta(activeId: string | null): {
+export declare function setActiveCitationMeta(activeId: string | null): {
   key: PluginKeyOwner<AICitationDecorationState>;
   payload: {
     type: typeof ACTIVE_META;
@@ -44,4 +44,4 @@ declare function setActiveCitationMeta(activeId: string | null): {
   };
 };
 //#endregion
-export { AICitationRange, aiCitationDecorationsKey, createAICitationDecorationsPlugin, setAICitationsMeta, setActiveCitationMeta };
+export {};

package/dist/prosemirror/plugins/aiCitationDecorations.js

@@ -2,18 +2,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/plugins/aiCitationDecorations.ts
-/**
-* AI Citation Decorations Plugin
-*
-* Renders pointer-back-to-source highlights on Folio (DOCX) ranges
-* cited by an AI answer. Distinct from the suggestion-decoration
-* plugin: citations are read-only pointers (no edit semantics) and
-* usually appear briefly when the user clicks a citation chip in the
-* thread.
-*
-* The host pushes updates via the `setAICitationsMeta` /
-* `setActiveCitationMeta` helpers below.
-*/
 const aiCitationDecorationsKey = createPluginKeyOwner("aiCitationDecorations");
 const SET_META = "set";
 const ACTIVE_META = "active";

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

@@ -3,7 +3,7 @@ import { PluginKeyOwner } from "../pluginKeyOwner.js";
 import { Plugin } from "prosemirror-state";
 import { DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/plugins/aiSuggestionDecorations.d.ts
-declare const aiSuggestionDecorationsKey: Readonly<{
+export declare const aiSuggestionDecorationsKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<AISuggestionDecorationState>;
   owns: (plugin: Plugin<AISuggestionDecorationState>) => boolean;
@@ -21,7 +21,7 @@ type AISuggestionDecorationState = {
  * Severity → CSS modifier class. Shared with the paged editor's
  * suggestion overlay so both renderers stay on the same class names.
  */
-declare const AI_SUGGESTION_SEVERITY_CLASS: Record<AISuggestionSeverity, string>;
+export declare const AI_SUGGESTION_SEVERITY_CLASS: Record<AISuggestionSeverity, string>;
 /**
  * ProseMirror plugin that renders AI suggestions as inline decorations.
  *
@@ -29,15 +29,15 @@ declare const AI_SUGGESTION_SEVERITY_CLASS: Record<AISuggestionSeverity, string>
  * {@link setFocusedSuggestionMeta} to highlight the active one when the
  * user navigates the review panel.
  */
-declare function createAISuggestionDecorationsPlugin(): Plugin<AISuggestionDecorationState>;
-declare function setAISuggestionsMeta(suggestions: AISuggestion[]): {
+export declare function createAISuggestionDecorationsPlugin(): Plugin<AISuggestionDecorationState>;
+export declare function setAISuggestionsMeta(suggestions: AISuggestion[]): {
   key: PluginKeyOwner<AISuggestionDecorationState>;
   payload: {
     type: typeof SET_META;
     suggestions: AISuggestion[];
   };
 };
-declare function setFocusedSuggestionMeta(focusedId: string | null): {
+export declare function setFocusedSuggestionMeta(focusedId: string | null): {
   key: PluginKeyOwner<AISuggestionDecorationState>;
   payload: {
     type: typeof FOCUS_META;
@@ -45,4 +45,4 @@ declare function setFocusedSuggestionMeta(focusedId: string | null): {
   };
 };
 //#endregion
-export { AI_SUGGESTION_SEVERITY_CLASS, aiSuggestionDecorationsKey, createAISuggestionDecorationsPlugin, setAISuggestionsMeta, setFocusedSuggestionMeta };
+export {};

package/dist/prosemirror/plugins/aiSuggestionDecorations.js

@@ -2,20 +2,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 //#region src/prosemirror/plugins/aiSuggestionDecorations.ts
-/**
-* AI Suggestion Decorations Plugin
-*
-* Renders pending AI suggestions as non-mutating ProseMirror decorations
-* — subtle dotted underlines on the suggested ranges. The focused
-* suggestion additionally previews its change in the text: the original
-* range is struck through and the suggested text is injected after it
-* as a widget. The document itself is never modified by the suggestion
-* queue; decorations live purely in the view layer.
-*
-* The plugin keeps a `DecorationSet` derived from the suggestion list.
-* Updates are pushed via the `setAISuggestions` meta key, which the
-* Folio editor wires up whenever the suggestion list changes.
-*/
 const aiSuggestionDecorationsKey = createPluginKeyOwner("aiSuggestionDecorations");
 const SET_META = "set";
 const FOCUS_META = "focus";

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

@@ -1,7 +1,7 @@
 import { PluginKeyOwner } from "../pluginKeyOwner.js";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/anonymizationDecorations.d.ts
-type AnonymizationTerm = {
+export type AnonymizationTerm = {
   /** Canonical surface form, displayed in tooltips. */
   canonical: string;
   /** Label slug (e.g. "person", "organization"). */
@@ -9,7 +9,7 @@ type AnonymizationTerm = {
   /** Optional alternate surface forms also matched verbatim. */
   variants?: readonly string[];
 };
-type AnonymizationMatch = {
+export type AnonymizationMatch = {
   /** Inclusive PM doc position of the match start. */
   from: number;
   /** Exclusive PM doc position of the match end. */
@@ -22,21 +22,21 @@ type AnonymizationDecorationState = {
   terms: readonly AnonymizationTerm[];
   matches: readonly AnonymizationMatch[];
 };
-declare const anonymizationDecorationsKey: Readonly<{
+export declare const anonymizationDecorationsKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<AnonymizationDecorationState>;
   owns: (plugin: Plugin<AnonymizationDecorationState>) => boolean;
   get: (state: EditorState) => Plugin<AnonymizationDecorationState> | undefined;
   getState: (state: EditorState) => AnonymizationDecorationState | undefined;
 }>;
-declare const slugAnonymizationLabel: (label: string) => string;
+export declare const slugAnonymizationLabel: (label: string) => string;
 /**
  * Plugin that keeps a list of anonymization-term match ranges
  * synced with the document. Host pushes terms via
  * {@link setAnonymizationTermsMeta}; the paged-editor reads
  * the matches and paints the overlay.
  */
-type AnonymizationPluginOptions = {
+export type AnonymizationPluginOptions = {
   /**
    * Push-side bridge for hosts that need to mirror the current
    * match list outside the PM state tree (e.g. an inspector
@@ -48,8 +48,8 @@ type AnonymizationPluginOptions = {
    */
   onMatchesChange?: (matches: readonly AnonymizationMatch[]) => void;
 };
-declare const createAnonymizationDecorationsPlugin: ({ onMatchesChange }?: AnonymizationPluginOptions) => Plugin<AnonymizationDecorationState>;
-declare const setAnonymizationTermsMeta: (terms: readonly AnonymizationTerm[]) => {
+export declare const createAnonymizationDecorationsPlugin: ({ onMatchesChange }?: AnonymizationPluginOptions) => Plugin<AnonymizationDecorationState>;
+export declare const setAnonymizationTermsMeta: (terms: readonly AnonymizationTerm[]) => {
   key: PluginKeyOwner<AnonymizationDecorationState>;
   payload: {
     type: typeof SET_META;
@@ -57,6 +57,6 @@ declare const setAnonymizationTermsMeta: (terms: readonly AnonymizationTerm[]) =
   };
 };
 /** Read anonymization matches owned by this editor state. */
-declare const getAnonymizationMatches: (state: EditorState) => readonly AnonymizationMatch[];
+export declare const getAnonymizationMatches: (state: EditorState) => readonly AnonymizationMatch[];
 //#endregion
-export { AnonymizationMatch, AnonymizationPluginOptions, AnonymizationTerm, anonymizationDecorationsKey, createAnonymizationDecorationsPlugin, getAnonymizationMatches, setAnonymizationTermsMeta, slugAnonymizationLabel };
+export {};

package/dist/prosemirror/plugins/anonymizationDecorations.js

@@ -2,24 +2,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { collectBlockChunks, joinChunks, offsetToDocPos } from "./pmTextScan.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/anonymizationDecorations.ts
-/**
-* Anonymization Match Plugin
-*
-* Owns the "what to highlight" half of the anonymization
-* overlay: the host pushes a list of terms via the
-* `setAnonymizationTermsMeta` meta, this plugin scans text
-* nodes for each surface form, and exposes the resulting
-* match ranges through its state.
-*
-* The plugin does **not** produce ProseMirror decorations.
-* Folio's editor lives off-screen (HiddenProseMirror) and PM
-* decorations never reach the visible paged DOM. The visible
-* highlights are painted by {@link AnonymizationRectsOverlay},
-* which reads the match ranges from this plugin's state and
-* projects them through `selectionToRects` to coordinates on
-* the paged canvas. Single source of truth for the ranges,
-* one painter.
-*/
 const SET_META = "set";
 const anonymizationDecorationsKey = createPluginKeyOwner("anonymizationDecorations");
 const slugAnonymizationLabel = (label) => label.toLowerCase().replace(/[^a-z0-9]+/gu, "-");