@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/noteReferenceReview.d.ts

@@ -4,35 +4,35 @@ import { Transform } from "prosemirror-transform";
 //#region src/prosemirror/noteReferenceReview.d.ts
 type NoteKind = "footnote" | "endnote";
 /** `footnote:<id>` or `endnote:<id>`. */
-type NoteKey = `${NoteKind}:${number}`;
+export type NoteKey = `${NoteKind}:${number}`;
 /**
  * The notes a story's text refers to, and whether each reference is pending
  * deletion: a reference is deleted when every character of it is.
  */
-declare const noteReferenceStates: (doc: Node) => Map<NoteKey, "live" | "deleted">;
+export declare const noteReferenceStates: (doc: Node) => Map<NoteKey, "live" | "deleted">;
 /** The notes whose reference a change took from pending deletion back to live. */
-declare const noteReferencesRestored: (before: Node, after: Node) => NoteKey[];
+export declare const noteReferencesRestored: (before: Node, after: Node) => NoteKey[];
 /**
  * The revisions that deleted a note along with its reference: its text and
  * its paragraph marks, deleted by the reference deletion's author at its
  * date. A deletion in the note made some other time is a change of its own,
  * which resolving the reference leaves alone.
  */
-declare const noteDeletionRevisions: (doc: Node, reference: Mark) => number[];
+export declare const noteDeletionRevisions: (doc: Node, reference: Mark) => number[];
 /**
  * The document with the named notes' deletions that went with their
  * reference rejected: the notes whose reference's deletion was rejected get
  * their text back. `before` is the body that still had those deletions.
  */
-declare const restoreNotes: (document: document_d_exports.Document, keys: Iterable<NoteKey>, before: Node) => document_d_exports.Document;
+export declare const restoreNotes: (document: document_d_exports.Document, keys: Iterable<NoteKey>, before: Node) => document_d_exports.Document;
 /** The deletion each pending-deleted note reference carries. */
-declare const referenceDeletions: (doc: Node) => Map<NoteKey, Mark>;
+export declare const referenceDeletions: (doc: Node) => Map<NoteKey, Mark>;
 /**
  * Delete a note's text and its paragraph marks along with its reference: by
  * the reference deletion's author at its date, so resolving the reference
  * resolves them too (see {@link noteDeletionRevisions}).
  */
-declare const deleteNoteWithReference: <T extends Transform>(transform: T, reference: Mark) => T;
+export declare const deleteNoteWithReference: <T extends Transform>(transform: T, reference: Mark) => T;
 /**
  * Keeps an editor's notes following their references across body edits. The
  * editor reports the body as it was before the edits it has not yet written
@@ -43,7 +43,7 @@ declare const deleteNoteWithReference: <T extends Transform>(transform: T, refer
  *   text with it: the note returns to what it was, or, when the note changed
  *   since, its text is deleted along with the reference.
  */
-type NoteReferenceFollower = {
+export type NoteReferenceFollower = {
   /** The body before the edits the next {@link reconcile} writes back. */
   noteBase: (before: Node) => void;
   /** The document to write back, its notes following the body's references. */
@@ -57,21 +57,21 @@ type NoteReferenceFollower = {
   /** Forget the pending base and what earlier restores replaced (a new document). */
   reset: () => void;
 };
-declare const createNoteReferenceFollower: () => NoteReferenceFollower;
+export declare const createNoteReferenceFollower: () => NoteReferenceFollower;
 /** The notes model content refers to, live or pending deletion. */
-declare const noteKeysReferencedIn: (content: unknown) => Set<NoteKey>;
+export declare const noteKeysReferencedIn: (content: unknown) => Set<NoteKey>;
 /**
  * The notes anything refers to, live or pending deletion: the main story, and
  * the stories the body does not hold (headers, footers, comments, notes).
  * References inside the `skipped` notes do not count: those notes are going.
  */
-declare const referencedNotes: (document: document_d_exports.Document, skipped?: ReadonlySet<string>) => Set<NoteKey>;
+export declare const referencedNotes: (document: document_d_exports.Document, skipped?: ReadonlySet<string>) => Set<NoteKey>;
 /**
  * The document without the notes nothing refers to any more: a note goes
  * with its reference, so accepting the reference's deletion leaves a note no
  * reader can reach, and saving drops it, with the comments anchored only in
  * it. Separators stay.
  */
-declare const withoutUnreferencedNotes: (document: document_d_exports.Document) => document_d_exports.Document;
+export declare const withoutUnreferencedNotes: (document: document_d_exports.Document) => document_d_exports.Document;
 //#endregion
-export { NoteKey, NoteReferenceFollower, createNoteReferenceFollower, deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes, restoreNotes, withoutUnreferencedNotes };
+export {};

package/dist/prosemirror/noteReferenceReview.js

@@ -11,15 +11,10 @@ import { createDocumentNumberingPlugin } from "./plugins/documentNumbering.js";
 import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
 import { mintRevisionId } from "./plugins/revisionIds.js";
 import { schema, singletonManager } from "./schema/index.js";
+import { setDocumentBodyComments } from "@stll/docx-core/model";
 import { Transform } from "prosemirror-transform";
 import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/noteReferenceReview.ts
-/**
-* A note goes with its reference. Deleting a note's reference while tracking
-* changes deletes the note's text too, so rejecting that deletion must give
-* the note its text back, whichever surface resolves it: the body editor
-* resolves the reference, and this resolves the note's story to match.
-*/
 const noteKey = (kind, id) => `${kind}:${id}`;
 /**
 * The notes a story's text refers to, and whether each reference is pending
@@ -330,16 +325,15 @@ const withoutUnreferencedNotes = (document) => {
 			...[...keptFootnotes ?? [], ...keptEndnotes ?? []].map((note) => note.content)
 		])
 	}) : void 0;
+	const documentBody = { ...document.package.document };
+	if (keptComments !== void 0 && keptComments.length !== comments?.length) setDocumentBodyComments(documentBody, keptComments);
 	return {
 		...document,
 		package: {
 			...document.package,
 			...keptFootnotes !== void 0 && { footnotes: keptFootnotes },
 			...keptEndnotes !== void 0 && { endnotes: keptEndnotes },
-			...keptComments !== void 0 && keptComments.length !== comments?.length && { document: {
-				...document.package.document,
-				comments: keptComments
-			} }
+			...keptComments !== void 0 && keptComments.length !== comments?.length && { document: documentBody }
 		}
 	};
 };

package/dist/prosemirror/numberedRefFields.d.ts

@@ -6,19 +6,19 @@ type NumberedRefSpec = {
   bookmark: string;
   numberSwitch: NumberSwitch;
 };
-type NumberedRefResolutionOptions = {
+export type NumberedRefResolutionOptions = {
   /** Counter snapshot at the start of this body story. The resolver consumes it in place. */
   listCounterState?: ListCounterState;
   /** Counter snapshot for tracked deletions in the original document view. */
   originalListCounterState?: ListCounterState;
 };
-declare function parseNumberedRefInstruction(instruction: string): NumberedRefSpec | null;
+export declare function parseNumberedRefInstruction(instruction: string): NumberedRefSpec | null;
 /** Stamp only proven numbered REF fields with clone-safe calibration state. */
-declare function stampNumberedRefFieldBaselines(doc: Node): Node;
+export declare function stampNumberedRefFieldBaselines(doc: Node): Node;
 /**
  * Resolve bounded, numbered REF fields against bookmarks in the ProseMirror body story.
  * Unsupported or uncalibrated fields are absent from the returned map and retain their cache.
  */
-declare function resolveNumberedRefFields(doc: Node, options?: NumberedRefResolutionOptions): ReadonlyMap<Node, string>;
+export declare function resolveNumberedRefFields(doc: Node, options?: NumberedRefResolutionOptions): ReadonlyMap<Node, string>;
 //#endregion
-export { NumberedRefResolutionOptions, parseNumberedRefInstruction, resolveNumberedRefFields, stampNumberedRefFieldBaselines };
+export {};

package/dist/prosemirror/numberingAttr.d.ts

@@ -1,21 +1,21 @@
 import { ParagraphNumberingOverride } from "@stll/docx-core/model";
 //#region src/prosemirror/numberingAttr.d.ts
-type ParagraphNumberingSources = {
+export type ParagraphNumberingSources = {
   numPr: ParagraphNumberingOverride | undefined;
   numPrFromStyle: ParagraphNumberingOverride | undefined;
 };
-type ParagraphNumberingBoundarySources = {
+export type ParagraphNumberingBoundarySources = {
   numPr: ParagraphNumberingOverride | null | undefined;
   numPrFromStyle: ParagraphNumberingOverride | null | undefined;
 };
 /** Normalize attr absence at the boundary, while requiring both source tiers. */
-declare const paragraphNumberingSourcesFromBoundary: ({ numPr, numPrFromStyle }: ParagraphNumberingBoundarySources) => ParagraphNumberingSources;
+export declare const paragraphNumberingSourcesFromBoundary: ({ numPr, numPrFromStyle }: ParagraphNumberingBoundarySources) => ParagraphNumberingSources;
 /** Effective membership is derived; neither source slot becomes an authored override. */
-declare const effectiveParagraphNumbering: ({ numPr, numPrFromStyle }: ParagraphNumberingSources) => import("@stll/docx-core/model").ResolvedParagraphNumbering;
+export declare const effectiveParagraphNumbering: ({ numPr, numPrFromStyle }: ParagraphNumberingSources) => import("@stll/docx-core/model").ResolvedParagraphNumbering;
 /** A list reference for membership consumers; cancellation and absence are not lists.
  * OOXML defaults an omitted ilvl to zero only within an existing numbering reference.
  */
-declare const effectiveParagraphNumberingReference: (sources: ParagraphNumberingSources) => (import("@stll/docx-core/model").ParagraphNumberingReference & {
+export declare const effectiveParagraphNumberingReference: (sources: ParagraphNumberingSources) => (import("@stll/docx-core/model").ParagraphNumberingReference & {
   readonly ilvl: number;
 }) | undefined;
 declare const PARAGRAPH_NUMBERING_ATTR: unique symbol;
@@ -35,11 +35,11 @@ declare const PARAGRAPH_NUMBERING_ATTR: unique symbol;
  * Reading needs no unbranding: the brand is a phantom property, so an attr
  * value is already a `ParagraphNumberingOverride` to every consumer.
  */
-type ParagraphNumberingAttr = ParagraphNumberingOverride & {
+export type ParagraphNumberingAttr = ParagraphNumberingOverride & {
   readonly [PARAGRAPH_NUMBERING_ATTR]: true;
 };
 /** Mint the attr value for a stated override: the one model-to-attr crossing. */
-declare const paragraphNumberingAttr: (numbering: ParagraphNumberingOverride) => ParagraphNumberingAttr;
+export declare const paragraphNumberingAttr: (numbering: ParagraphNumberingOverride) => ParagraphNumberingAttr;
 /**
  * The `numPr` that takes a paragraph out of its list. When its style supplies
  * the numbering, the paragraph has to state the cancellation (`w:numId="0"`):
@@ -47,7 +47,7 @@ declare const paragraphNumberingAttr: (numbering: ParagraphNumberingOverride) =>
  * numbering straight back. A cancellation states no level (17.9.18: there is
  * no id left for a level to belong to).
  */
-declare const removedNumberingAttr: (numPrFromStyle: ParagraphNumberingOverride | null | undefined) => ParagraphNumberingAttr | null;
+export declare const removedNumberingAttr: (numPrFromStyle: ParagraphNumberingOverride | null | undefined) => ParagraphNumberingAttr | null;
 /**
  * The one shape check over a persisted `numPr` attr.
  *
@@ -65,7 +65,7 @@ declare const removedNumberingAttr: (numPrFromStyle: ParagraphNumberingOverride
  * `ilvl` is bounded below and not above: real packages carry levels past the
  * nine the format defines, and docx-core preserves them.
  */
-declare const paragraphNumberingFromAttrValue: (value: unknown) => ParagraphNumberingAttr | null;
+export declare const paragraphNumberingFromAttrValue: (value: unknown) => ParagraphNumberingAttr | null;
 /**
  * A paragraph's stated numbering, read straight from an unvalidated attrs
  * record. `null` is the attr's absent state, which is what the node spec's
@@ -76,6 +76,6 @@ declare const paragraphNumberingFromAttrValue: (value: unknown) => ParagraphNumb
  * attr schema this build does not read, and `yjsDocumentMetadata`'s version
  * gate exists to make that unreachable.
  */
-declare const readParagraphNumberingAttr: (value: unknown) => ParagraphNumberingAttr | null;
+export declare const readParagraphNumberingAttr: (value: unknown) => ParagraphNumberingAttr | null;
 //#endregion
-export { ParagraphNumberingAttr, ParagraphNumberingBoundarySources, ParagraphNumberingSources, effectiveParagraphNumbering, effectiveParagraphNumberingReference, paragraphNumberingAttr, paragraphNumberingFromAttrValue, paragraphNumberingSourcesFromBoundary, readParagraphNumberingAttr, removedNumberingAttr };
+export {};

package/dist/prosemirror/outlineLevelAttr.d.ts

@@ -13,7 +13,7 @@ import { OutlineLevel } from "@stll/docx-core/model";
  * as an `outlineLevel` no consumer recognises and every consumer silently
  * ignores. Returning `null` for it is what lets the caller refuse.
  */
-declare const outlineLevelFromAttrValue: (value: unknown) => OutlineLevel | null;
+export declare const outlineLevelFromAttrValue: (value: unknown) => OutlineLevel | null;
 /**
  * A paragraph's stated outline level, read straight from an unvalidated attrs
  * record. `null` is the attr's absent state, which is what the node spec's
@@ -24,6 +24,5 @@ declare const outlineLevelFromAttrValue: (value: unknown) => OutlineLevel | null
  * this build does not read, and `yjsDocumentMetadata`'s version gate exists to
  * make that unreachable.
  */
-declare const readOutlineLevelAttr: (value: unknown) => OutlineLevel | null;
-//#endregion
-export { outlineLevelFromAttrValue, readOutlineLevelAttr };
+export declare const readOutlineLevelAttr: (value: unknown) => OutlineLevel | null;
+//#endregion

package/dist/prosemirror/pageBreakRunProjection.d.ts

@@ -18,8 +18,8 @@ declare const PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES: {
   readonly outline: "An outline paragraph is split at its explicit page-break run, so each part carries the outline level";
   readonly textBoxAnchor: "A text-box anchor following an explicit page-break run is hosted by the paragraph's first part";
 };
-type PageBreakRunParagraphProjectionReason = keyof typeof PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES;
-type PageBreakRunParagraphProjectionDisposition = {
+export type PageBreakRunParagraphProjectionReason = keyof typeof PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES;
+export type PageBreakRunParagraphProjectionDisposition = {
   status: "exact";
 } | {
   status: "approximate";
@@ -40,7 +40,7 @@ type PageBreakRunParagraphFeatures = {
   textBoxAnchorAfterPageBreak: boolean;
 };
 /** Keep source-import and ProseMirror-layout ownership decisions on one predicate. */
-declare const pageBreakRunParagraphProjectionDispositionForFeatures: ({ attrs, effectiveFrame, textBoxAnchorAfterPageBreak }: PageBreakRunParagraphFeatures) => PageBreakRunParagraphProjectionDisposition;
-declare const pageBreakRunParagraphProjectionDisposition: (paragraph: Node) => PageBreakRunParagraphProjectionDisposition;
+export declare const pageBreakRunParagraphProjectionDispositionForFeatures: ({ attrs, effectiveFrame, textBoxAnchorAfterPageBreak }: PageBreakRunParagraphFeatures) => PageBreakRunParagraphProjectionDisposition;
+export declare const pageBreakRunParagraphProjectionDisposition: (paragraph: Node) => PageBreakRunParagraphProjectionDisposition;
 //#endregion
-export { PageBreakRunParagraphProjectionDisposition, PageBreakRunParagraphProjectionReason, pageBreakRunParagraphProjectionDisposition, pageBreakRunParagraphProjectionDispositionForFeatures };
+export {};

package/dist/prosemirror/paraText.d.ts

@@ -1,9 +1,9 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/paraText.d.ts
 /** Text of a single PM node (typically a paragraph), vanilla view. */
-declare function getVanillaNodeText(node: Node): string;
+export declare function getVanillaNodeText(node: Node): string;
 /** Text between two doc positions, vanilla view. */
-declare function getVanillaTextBetween(doc: Node, from: number, to: number): string;
+export declare function getVanillaTextBetween(doc: Node, from: number, to: number): string;
 /**
  * Find `searchText` within a PM paragraph range and return its position.
  *
@@ -17,9 +17,8 @@ declare function getVanillaTextBetween(doc: Node, from: number, to: number): str
  * excluded (not in the doc yet), tracked deletions are included (still
  * in the doc until accepted), and comment markers are stripped.
  */
-declare function findTextInPmParagraph(doc: Node, paragraphFrom: number, paragraphTo: number, searchText: string): {
+export declare function findTextInPmParagraph(doc: Node, paragraphFrom: number, paragraphTo: number, searchText: string): {
   from: number;
   to: number;
 } | null;
-//#endregion
-export { findTextInPmParagraph, getVanillaNodeText, getVanillaTextBetween };
+//#endregion

package/dist/prosemirror/paragraphAlignment.d.ts

@@ -7,6 +7,5 @@ import { ParagraphAttrs } from "./schema/nodes.js";
  * explicit provenance; the final branch covers PM-created content whose
  * effective value is observably different from its style.
  */
-declare const directParagraphAlignment: (attrs: ParagraphAttrs) => document_d_exports.ParagraphAlignment | undefined;
-//#endregion
-export { directParagraphAlignment };
+export declare const directParagraphAlignment: (attrs: ParagraphAttrs) => document_d_exports.ParagraphAlignment | undefined;
+//#endregion

package/dist/prosemirror/paragraphDirection.d.ts

@@ -27,26 +27,26 @@
  * belongs in `w:pPr`. Use `directionToBidi` for layout/rendering and
  * `directionToAuthoredBidi` for anything that gets serialized.
  */
-type ParagraphDirection = {
+export type ParagraphDirection = {
   source: "auto";
 } | {
   source: "manual";
   value: "rtl" | "ltr";
 };
 /** Whether the paragraph lays out and exports right-to-left. */
-declare const directionIsRtl: (direction: ParagraphDirection | null | undefined) => boolean;
+export declare const directionIsRtl: (direction: ParagraphDirection | null | undefined) => boolean;
 /**
  * Auto-managed paragraphs (undecided, or previously auto-set) are the ones
  * AutoBidiDetection may (re-)evaluate. A manual decision is left untouched.
  */
-declare const directionIsAutoManaged: (direction: ParagraphDirection | null | undefined) => boolean;
+export declare const directionIsAutoManaged: (direction: ParagraphDirection | null | undefined) => boolean;
 /**
  * Map a direction to the OOXML `w:bidi` tri-state for layout/rendering: an
  * auto-detected direction lays out RTL exactly like a manual one. Do not use
  * this to decide what gets written to the saved package — see
  * `directionToAuthoredBidi`.
  */
-declare const directionToBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
+export declare const directionToBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
 /**
  * Map a direction to the OOXML `w:bidi` tri-state as *authored* content, for
  * serialization. Only a manual decision (explicit user toggle, or a `w:bidi`
@@ -57,13 +57,12 @@ declare const directionToBidi: (direction: ParagraphDirection | null | undefined
  * regardless of which way detection currently leans, so it stays a view-only
  * aid until the user makes it explicit.
  */
-declare const directionToAuthoredBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
+export declare const directionToAuthoredBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
 /**
  * Reconstruct a direction from a model `bidi` value (DOCX import / load): an
  * explicit `true`/`false` is a manual decision, absence is undecided.
  */
-declare const directionFromBidi: (bidi: boolean | null | undefined) => ParagraphDirection | null;
+export declare const directionFromBidi: (bidi: boolean | null | undefined) => ParagraphDirection | null;
 /** Runtime guard for the PM attribute validator. */
-declare const isParagraphDirection: (value: unknown) => value is ParagraphDirection;
-//#endregion
-export { ParagraphDirection, directionFromBidi, directionIsAutoManaged, directionIsRtl, directionToAuthoredBidi, directionToBidi, isParagraphDirection };
+export declare const isParagraphDirection: (value: unknown) => value is ParagraphDirection;
+//#endregion

package/dist/prosemirror/paragraphFormattingProvenance.d.ts

@@ -12,7 +12,7 @@ import { ParagraphAttrs } from "./schema/nodes.js";
  * - `original-only`: no editor attr writes it back; it survives through
  *   `ParagraphAttrs._originalFormatting`.
  */
-type ParagraphFieldWriteBack = {
+export type ParagraphFieldWriteBack = {
   kind: "style-resolved-attr";
   attr: keyof ParagraphAttrs;
 } | {
@@ -26,7 +26,7 @@ type ParagraphFieldWriteBack = {
  * Total over `ParagraphFormatting`, so a new `w:pPr` field cannot land without
  * a decision about how a save tells its authored value from its inherited one.
  */
-declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
+export declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
   readonly alignment: {
     readonly kind: "direct-provenance";
   };
@@ -38,6 +38,14 @@ declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
     readonly kind: "style-resolved-attr";
     readonly attr: "kinsoku";
   };
+  readonly autoSpaceDE: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "autoSpaceDE";
+  };
+  readonly autoSpaceDN: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "autoSpaceDN";
+  };
   readonly overflowPunctuation: {
     readonly kind: "style-resolved-attr";
     readonly attr: "overflowPunctuation";
@@ -160,15 +168,14 @@ declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
     readonly kind: "original-only";
   };
 };
-type StyleResolvedParagraphField = { [Field in keyof typeof PARAGRAPH_FORMATTING_WRITE_BACK]: (typeof PARAGRAPH_FORMATTING_WRITE_BACK)[Field] extends {
+export type StyleResolvedParagraphField = { [Field in keyof typeof PARAGRAPH_FORMATTING_WRITE_BACK]: (typeof PARAGRAPH_FORMATTING_WRITE_BACK)[Field] extends {
   kind: "style-resolved-attr";
 } ? Field : never; }[keyof typeof PARAGRAPH_FORMATTING_WRITE_BACK];
-declare const STYLE_RESOLVED_PARAGRAPH_FIELDS: StyleResolvedParagraphField[];
+export declare const STYLE_RESOLVED_PARAGRAPH_FIELDS: StyleResolvedParagraphField[];
 /**
  * The part of a resolved style cascade a save needs to keep out of direct
  * `w:pPr`. Narrowed to the governed fields so an ordinary paragraph, whose
  * cascade supplies only spacing, stores nothing at all.
  */
-declare const styleResolvedParagraphFormatting: (resolved: document_d_exports.ParagraphFormatting | undefined) => document_d_exports.ParagraphFormatting | undefined;
-//#endregion
-export { PARAGRAPH_FORMATTING_WRITE_BACK, ParagraphFieldWriteBack, STYLE_RESOLVED_PARAGRAPH_FIELDS, StyleResolvedParagraphField, styleResolvedParagraphFormatting };
+export declare const styleResolvedParagraphFormatting: (resolved: document_d_exports.ParagraphFormatting | undefined) => document_d_exports.ParagraphFormatting | undefined;
+//#endregion

package/dist/prosemirror/paragraphFormattingProvenance.js

@@ -13,6 +13,14 @@ const PARAGRAPH_FORMATTING_WRITE_BACK = {
 		kind: "style-resolved-attr",
 		attr: "kinsoku"
 	},
+	autoSpaceDE: {
+		kind: "style-resolved-attr",
+		attr: "autoSpaceDE"
+	},
+	autoSpaceDN: {
+		kind: "style-resolved-attr",
+		attr: "autoSpaceDN"
+	},
 	overflowPunctuation: {
 		kind: "style-resolved-attr",
 		attr: "overflowPunctuation"

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 {};