@stll/folio-core 0.43.0 → 0.44.0

package/dist/prosemirror/paragraphFormattingProvenance.d.ts

@@ -0,0 +1,159 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphAttrs } from "./schema/nodes.js";
+//#region src/prosemirror/paragraphFormattingProvenance.d.ts
+/**
+ * How each `w:pPr` field reaches the saved model from paragraph attrs.
+ *
+ * - `style-resolved-attr`: the named attr holds the effective value, so the
+ *   write-back filters it against `ParagraphAttrs._resolvedFormatting`.
+ * - `direct-provenance`: the field has its own provenance channel and reader
+ *   (`alignmentFromStyle`, `spacingFromDocDefaults`, `numPrFromStyle`, …).
+ * - `derived`: not authored; recomputed from another field on load and save.
+ * - `original-only`: no editor attr writes it back; it survives through
+ *   `ParagraphAttrs._originalFormatting`.
+ */
+type ParagraphFieldWriteBack = {
+  kind: "style-resolved-attr";
+  attr: keyof ParagraphAttrs;
+} | {
+  kind: "direct-provenance";
+} | {
+  kind: "derived";
+} | {
+  kind: "original-only";
+};
+/**
+ * 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: {
+  readonly alignment: {
+    readonly kind: "direct-provenance";
+  };
+  readonly bidi: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "direction";
+  };
+  readonly kinsoku: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "kinsoku";
+  };
+  readonly overflowPunctuation: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "overflowPunctuation";
+  };
+  readonly spaceBefore: {
+    readonly kind: "direct-provenance";
+  };
+  readonly spaceAfter: {
+    readonly kind: "direct-provenance";
+  };
+  readonly lineSpacing: {
+    readonly kind: "direct-provenance";
+  };
+  readonly lineSpacingRule: {
+    readonly kind: "direct-provenance";
+  };
+  readonly snapToGrid: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "snapToGrid";
+  };
+  readonly beforeAutospacing: {
+    readonly kind: "direct-provenance";
+  };
+  readonly afterAutospacing: {
+    readonly kind: "direct-provenance";
+  };
+  readonly spacingExplicit: {
+    readonly kind: "derived";
+  };
+  readonly indentLeft: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "indentLeft";
+  };
+  readonly indentRight: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "indentRight";
+  };
+  readonly indentFirstLine: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "indentFirstLine";
+  };
+  readonly hangingIndent: {
+    readonly kind: "direct-provenance";
+  };
+  readonly borders: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "borders";
+  };
+  readonly shading: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "shading";
+  };
+  readonly tabs: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "tabs";
+  };
+  readonly keepNext: {
+    readonly kind: "original-only";
+  };
+  readonly keepLines: {
+    readonly kind: "original-only";
+  };
+  readonly widowControl: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "widowControl";
+  };
+  readonly pageBreakBefore: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "pageBreakBefore";
+  };
+  readonly contextualSpacing: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "contextualSpacing";
+  };
+  readonly numPr: {
+    readonly kind: "direct-provenance";
+  };
+  readonly numPrFromStyle: {
+    readonly kind: "derived";
+  };
+  readonly numberingChangeXml: {
+    readonly kind: "original-only";
+  };
+  readonly outlineLevel: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "outlineLevel";
+  };
+  readonly styleId: {
+    readonly kind: "direct-provenance";
+  };
+  readonly frame: {
+    readonly kind: "original-only";
+  };
+  readonly suppressLineNumbers: {
+    readonly kind: "original-only";
+  };
+  readonly suppressAutoHyphens: {
+    readonly kind: "style-resolved-attr";
+    readonly attr: "suppressAutoHyphens";
+  };
+  readonly runProperties: {
+    readonly kind: "original-only";
+  };
+  readonly runInWithNext: {
+    readonly kind: "original-only";
+  };
+};
+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[];
+/**
+ * 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 };

package/dist/prosemirror/paragraphFormattingProvenance.js

@@ -0,0 +1,106 @@
+//#region src/prosemirror/paragraphFormattingProvenance.ts
+/**
+* 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.
+*/
+const PARAGRAPH_FORMATTING_WRITE_BACK = {
+	alignment: { kind: "direct-provenance" },
+	bidi: {
+		kind: "style-resolved-attr",
+		attr: "direction"
+	},
+	kinsoku: {
+		kind: "style-resolved-attr",
+		attr: "kinsoku"
+	},
+	overflowPunctuation: {
+		kind: "style-resolved-attr",
+		attr: "overflowPunctuation"
+	},
+	spaceBefore: { kind: "direct-provenance" },
+	spaceAfter: { kind: "direct-provenance" },
+	lineSpacing: { kind: "direct-provenance" },
+	lineSpacingRule: { kind: "direct-provenance" },
+	snapToGrid: {
+		kind: "style-resolved-attr",
+		attr: "snapToGrid"
+	},
+	beforeAutospacing: { kind: "direct-provenance" },
+	afterAutospacing: { kind: "direct-provenance" },
+	spacingExplicit: { kind: "derived" },
+	indentLeft: {
+		kind: "style-resolved-attr",
+		attr: "indentLeft"
+	},
+	indentRight: {
+		kind: "style-resolved-attr",
+		attr: "indentRight"
+	},
+	indentFirstLine: {
+		kind: "style-resolved-attr",
+		attr: "indentFirstLine"
+	},
+	hangingIndent: { kind: "direct-provenance" },
+	borders: {
+		kind: "style-resolved-attr",
+		attr: "borders"
+	},
+	shading: {
+		kind: "style-resolved-attr",
+		attr: "shading"
+	},
+	tabs: {
+		kind: "style-resolved-attr",
+		attr: "tabs"
+	},
+	keepNext: { kind: "original-only" },
+	keepLines: { kind: "original-only" },
+	widowControl: {
+		kind: "style-resolved-attr",
+		attr: "widowControl"
+	},
+	pageBreakBefore: {
+		kind: "style-resolved-attr",
+		attr: "pageBreakBefore"
+	},
+	contextualSpacing: {
+		kind: "style-resolved-attr",
+		attr: "contextualSpacing"
+	},
+	numPr: { kind: "direct-provenance" },
+	numPrFromStyle: { kind: "derived" },
+	numberingChangeXml: { kind: "original-only" },
+	outlineLevel: {
+		kind: "style-resolved-attr",
+		attr: "outlineLevel"
+	},
+	styleId: { kind: "direct-provenance" },
+	frame: { kind: "original-only" },
+	suppressLineNumbers: { kind: "original-only" },
+	suppressAutoHyphens: {
+		kind: "style-resolved-attr",
+		attr: "suppressAutoHyphens"
+	},
+	runProperties: { kind: "original-only" },
+	runInWithNext: { kind: "original-only" }
+};
+const STYLE_RESOLVED_PARAGRAPH_FIELDS = Object.keys(PARAGRAPH_FORMATTING_WRITE_BACK).filter((field) => PARAGRAPH_FORMATTING_WRITE_BACK[field].kind === "style-resolved-attr");
+/**
+* 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.
+*/
+const styleResolvedParagraphFormatting = (resolved) => {
+	if (!resolved) return;
+	const governed = {};
+	let found = false;
+	for (const field of STYLE_RESOLVED_PARAGRAPH_FIELDS) {
+		const value = resolved[field];
+		if (value === void 0) continue;
+		Reflect.set(governed, field, value);
+		found = true;
+	}
+	return found ? governed : void 0;
+};
+//#endregion
+export { PARAGRAPH_FORMATTING_WRITE_BACK, STYLE_RESOLVED_PARAGRAPH_FIELDS, styleResolvedParagraphFormatting };

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

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
+import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { StyleResolver } from "../styles/styleResolver.js";
 import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
@@ -13,7 +14,14 @@ declare const documentStylesKey: PluginKey<StyleResolver | null>;
 declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
 /** Read the document's StyleResolver, or null when the plugin isn't installed. */
 declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
+/**
+ * Read the document's built-in style index, for the callers that classify
+ * paragraphs (heading collection, markdown export, the AI snapshot). Without
+ * the plugin every lookup misses, which degrades classification to the
+ * paragraph's own outline level rather than to English style ids.
+ */
+declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver, withDocumentStyles };

package/dist/prosemirror/plugins/documentStyles.js

@@ -1,3 +1,4 @@
+import { EMPTY_BUILT_IN_STYLE_INDEX } from "../../docx/builtInStyles.js";
 import { StyleResolver, createStyleResolver } from "../styles/styleResolver.js";
 import { Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.ts
@@ -42,6 +43,15 @@ function createDocumentStylesPlugin(styles) {
 function getDocumentStyleResolver(state) {
 	return documentStylesKey.getState(state) ?? null;
 }
+/**
+* Read the document's built-in style index, for the callers that classify
+* paragraphs (heading collection, markdown export, the AI snapshot). Without
+* the plugin every lookup misses, which degrades classification to the
+* paragraph's own outline level rather than to English style ids.
+*/
+function getDocumentBuiltInStyles(state) {
+	return getDocumentStyleResolver(state)?.builtInStyles ?? EMPTY_BUILT_IN_STYLE_INDEX;
+}
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 const withDocumentStyles = (state, styles) => {
 	const previous = documentStylesKey.get(state);
@@ -49,4 +59,4 @@ const withDocumentStyles = (state, styles) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentStylesPlugin(styles)] });
 };
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver, withDocumentStyles };

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

@@ -1,3 +1,3 @@
 import { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./selectionTracker.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentStyleResolver } from "./documentStyles.js";
-export { type SelectionChangeCallback, type SelectionContext, createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };
+import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyles.js";
+export { type SelectionChangeCallback, type SelectionContext, createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentBuiltInStyles, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/index.js

@@ -1,3 +1,3 @@
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentStyleResolver } from "./documentStyles.js";
+import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyles.js";
 import { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./selectionTracker.js";
-export { createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };
+export { createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentBuiltInStyles, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };

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

@@ -14,9 +14,18 @@ declare function mintRevisionId(): number;
  */
 declare function seedRevisionIdsAbove(maxId: number): void;
 /**
- * Raise the counter above every revision id already present in `doc`.
+ * The highest id in `doc` from any part of the annotation space.
+ *
+ * A revision, a comment and a bookmark draw their `w:id` from one space, so a
+ * counter seeded above its own kind alone still mints over another kind's id.
+ * Both allocators seed from this, and the save-time normalization avoids the
+ * same space, so the three agree on what is taken.
+ */
+declare function maxAnnotationIdInDoc(doc: Node): number;
+/**
+ * Raise the counter above every annotation id already present in `doc`.
  * Called from the suggestion-mode plugin's `state.init`.
  */
 declare function seedRevisionIdsFromDoc(doc: Node): void;
 //#endregion
-export { mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/plugins/revisionIds.js

@@ -31,16 +31,24 @@ function seedRevisionIdsAbove(maxId) {
 /** Node attrs that carry a revision id directly (`revisionId` field). */
 const DIRECT_REVISION_ATTR_KEYS = ["trIns", "trDel"];
 /**
-* Raise the counter above every revision id already present in `doc`.
-* Called from the suggestion-mode plugin's `state.init`.
+* The highest id in `doc` from any part of the annotation space.
+*
+* A revision, a comment and a bookmark draw their `w:id` from one space, so a
+* counter seeded above its own kind alone still mints over another kind's id.
+* Both allocators seed from this, and the save-time normalization avoids the
+* same space, so the three agree on what is taken.
 */
-function seedRevisionIdsFromDoc(doc) {
+function maxAnnotationIdInDoc(doc) {
 	let max = 0;
 	const consider = (id) => {
 		if (typeof id === "number" && Number.isInteger(id) && id > max && id <= MAX_REVISION_ID) max = id;
 	};
 	doc.descendants((node) => {
-		for (const mark of node.marks) consider(mark.attrs["revisionId"]);
+		for (const mark of node.marks) {
+			consider(mark.attrs["revisionId"]);
+			consider(mark.attrs["commentId"]);
+		}
+		if (node.type.name === "bookmarkBoundary") consider(node.attrs["id"]);
 		const attrs = node.attrs;
 		const pPrMark = attrs["pPrMark"];
 		if (pPrMark?.info) consider(pPrMark.info.id);
@@ -51,7 +59,14 @@ function seedRevisionIdsFromDoc(doc) {
 		const cellMarker = attrs["cellMarker"];
 		if (cellMarker?.info) consider(cellMarker.info.revisionId);
 	});
-	seedRevisionIdsAbove(max);
+	return max;
+}
+/**
+* Raise the counter above every annotation id already present in `doc`.
+* Called from the suggestion-mode plugin's `state.init`.
+*/
+function seedRevisionIdsFromDoc(doc) {
+	seedRevisionIdsAbove(maxAnnotationIdInDoc(doc));
 }
 //#endregion
-export { mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/runFormattingReconciliation.js

@@ -1,9 +1,10 @@
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
 import { marksToTextFormatting } from "./conversion/fromProseDoc.js";
-import { textFormattingToMarks } from "./conversion/toProseDoc.js";
+import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
+import { schema } from "./schema/index.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
@@ -36,7 +37,7 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 		marks: styleResolutionMarks,
 		paragraphFormatting,
 		...styleResolver !== void 0 ? { styleResolver } : {}
-	}), authoredFormatting), {
+	}), authoredFormatting), schema, {
 		overrideFormatting: mergeTextFormatting(getParagraphMarkSuppressionOverrides({
 			directFormatting: authoredFormatting,
 			paragraphMarkFormatting: context.paragraphMarkFormatting,

package/dist/prosemirror/runStyleFormatting.d.ts

@@ -26,7 +26,7 @@ type ParagraphRunStyleContext = {
   paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkPrecedesStyle: boolean;
 };
-type RunStyleResolver = Pick<StyleEngine, "getDefaultCharacterStyle" | "getDefaultParagraphStyle" | "getDocDefaults" | "getRunStyleOwnProperties" | "getStyle" | "resolveParagraphStyle">;
+type RunStyleResolver = Pick<StyleEngine, "builtInStyles" | "getDefaultCharacterStyle" | "getDefaultParagraphStyle" | "getDocDefaults" | "getRunStyleOwnProperties" | "getStyle" | "resolveParagraphStyle">;
 type ResolveParagraphBodyRunFormattingOptions = {
   styleId: string | undefined;
   styleResolver?: RunStyleResolver | null | undefined;

package/dist/prosemirror/schema/nodes.d.ts

@@ -27,9 +27,11 @@ type BookmarkBoundaryAttrs = {
   name: string;
   colFirst?: number;
   colLast?: number;
+  displacedByCustomXml?: document_d_exports.DisplacedByCustomXml;
 } | {
   type: "end";
   id: number;
+  displacedByCustomXml?: document_d_exports.DisplacedByCustomXml;
 };
 /**
  * Paragraph node attributes - maps to ParagraphFormatting
@@ -189,6 +191,19 @@ type ParagraphAttrs = {
   /** Original inline paragraph formatting from DOCX (pre-style-resolution).
    *  Used by fromProseDoc for lossless round-trip serialization. */
   _originalFormatting?: document_d_exports.ParagraphFormatting;
+  /**
+   * The `w:pPr` the style cascade resolves to for this paragraph: document
+   * defaults, the enclosing table style, then the `w:pStyle` chain. PM-only;
+   * never serialized.
+   *
+   * The formatting attrs above hold the EFFECTIVE value, because that is what
+   * the editor renders with. A save must write only what the paragraph states
+   * itself, so it needs this companion to tell an inherited value from an
+   * authored one — writing an inherited value back as direct `w:pPr` outranks
+   * the style it came from, and a later edit to that style stops reaching the
+   * paragraph. `TableCellAttrs._resolvedBorders` is the same device.
+   */
+  _resolvedFormatting?: document_d_exports.ParagraphFormatting;
   /** Import-effective spacing baseline for HTML auto-spacing detection.
    *  PM-only; never serialized back into DOCX formatting. */
   _autospacingBase?: {
@@ -334,6 +349,14 @@ type ImageAttrs = {
   _docxRawImageFingerprint?: string;
   /** Embedded-object previews use their authored box as the exact line height. */
   _docxObjectPreview?: boolean;
+  /**
+   * The `w:rPr` of the run this atom came from. Inline atoms do not carry the
+   * run's formatting marks (see `withRunBoundaryMarks`), so without this the
+   * run properties of an embedded object, picture or shape are lost on save
+   * (`content[].content[].formatting: object became absent` in the corpus
+   * census).
+   */
+  _docxRunFormatting?: document_d_exports.TextFormatting;
 };
 /**
  * Field node attributes
@@ -507,6 +530,14 @@ type ShapeAttrs = {
   glowColor?: string;
   /** Glow radius in pixels */
   glowRadius?: number;
+  /**
+   * The `w:rPr` of the run this atom came from. Inline atoms do not carry the
+   * run's formatting marks (see `withRunBoundaryMarks`), so without this the
+   * run properties of an embedded object, picture or shape are lost on save
+   * (`content[].content[].formatting: object became absent` in the corpus
+   * census).
+   */
+  _docxRunFormatting?: document_d_exports.TextFormatting;
 };
 /**
  * Text box node attributes

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -4,6 +4,7 @@ import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
 import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../listMarker.js";
 import { listRenderingAttrPatch } from "../listRenderingAttrs.js";
+import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
 //#region src/prosemirror/styles/resolvedStyleAttrs.ts
 /**
 * Shared helper for projecting a resolved paragraph style onto ProseMirror
@@ -45,6 +46,7 @@ function paragraphAttrsFromResolvedStyle(resolved, identity) {
 		outlineLevel: ppr?.outlineLevel ?? null,
 		borders: ppr?.borders ?? null,
 		defaultTextFormatting: hasRunFormatting ? runFormatting : null,
+		_resolvedFormatting: styleResolvedParagraphFormatting(ppr),
 		_autospacingBase: autospacingBaseFromResolvedParagraphFormatting(ppr),
 		_tableOfContentsLevel: tableOfContentsStyleLevel(identity) ?? null
 	};

package/dist/prosemirror/styles/styleResolver.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
+import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 //#region src/prosemirror/styles/styleResolver.d.ts
 /**
  * Resolved style properties ready for rendering
@@ -27,6 +28,7 @@ type TableCellParagraphSpacingOverlay = Pick<document_d_exports.ParagraphFormatt
  */
 declare class StyleResolver {
   private readonly stylesById;
+  private builtInStyleIndex;
   private readonly docDefaults;
   private readonly defaultParagraphStyle;
   private readonly defaultCharacterStyle;
@@ -36,6 +38,13 @@ declare class StyleResolver {
    * Get a style by ID
    */
   getStyle(styleId: string): document_d_exports.Style | undefined;
+  /**
+   * This document's styles indexed by the built-in they are, so a consumer can
+   * ask whether a paragraph is a heading without matching an English style id.
+   * Built on first use and kept: the resolver outlives a single query, and the
+   * outline sidebar rebuilds its heading list on every transaction.
+   */
+  get builtInStyles(): BuiltInStyleIndex;
   /**
    * Get all available paragraph styles (for toolbar dropdown)
    */

package/dist/prosemirror/styles/styleResolver.js

@@ -1,3 +1,4 @@
+import { createBuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { BUILT_IN_DEFAULT_PARAGRAPH_FORMATTING, resolveDefaultParagraphStyle } from "../../docx/defaultParagraphStyle.js";
 import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
 import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
@@ -27,6 +28,7 @@ const BUILTIN_NORMAL_STYLE = {
 */
 var StyleResolver = class {
 	stylesById;
+	builtInStyleIndex;
 	docDefaults;
 	defaultParagraphStyle;
 	defaultCharacterStyle;
@@ -48,6 +50,16 @@ var StyleResolver = class {
 		return this.stylesById.get(styleId);
 	}
 	/**
+	* This document's styles indexed by the built-in they are, so a consumer can
+	* ask whether a paragraph is a heading without matching an English style id.
+	* Built on first use and kept: the resolver outlives a single query, and the
+	* outline sidebar rebuilds its heading list on every transaction.
+	*/
+	get builtInStyles() {
+		this.builtInStyleIndex ??= createBuiltInStyleIndex(this.stylesById.values(), this.docDefaults);
+		return this.builtInStyleIndex;
+	}
+	/**
 	* Get all available paragraph styles (for toolbar dropdown)
 	*/
 	getParagraphStyles() {

package/dist/style-engine/styleEngine.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../types/document.js";
+import { BuiltInStyleIndex } from "../docx/builtInStyles.js";
 import { ResolvedParagraphStyle, TableCellParagraphSpacingOverlay } from "../prosemirror/styles/styleResolver.js";
 //#region src/style-engine/styleEngine.d.ts
 /** Engine construction options. */
@@ -44,6 +45,8 @@ type StyleEngine = {
   getParagraphStyles: () => document_d_exports.Style[];
   /** All visible table styles, sorted for the table-style gallery. */
   getTableStyles: () => document_d_exports.Style[];
+  /** The document's styles indexed by the built-in they are — see {@link StyleResolver.builtInStyles}. */
+  builtInStyles: BuiltInStyleIndex;
   /**
    * Resolve the full paragraph cascade for a given styleId.
    * Returned object is cached and must not be mutated.

package/dist/style-engine/styleEngine.js

@@ -62,6 +62,9 @@ function createStyleEngine(styleDefinitions, options) {
 		getDefaultTableStyle: () => resolver.getDefaultTableStyle(),
 		getParagraphStyles: () => resolver.getParagraphStyles(),
 		getTableStyles: () => resolver.getTableStyles(),
+		get builtInStyles() {
+			return resolver.builtInStyles;
+		},
 		resolveParagraphStyle: (styleId) => memoize(paragraphCache, cacheKey(styleId), () => resolver.resolveParagraphStyle(styleId)),
 		resolveParagraphStyleInTable: (styleId, tableParagraphOverlay) => tableParagraphOverlay === void 0 ? memoize(paragraphCache, cacheKey(styleId), () => resolver.resolveParagraphStyleInTable(styleId, void 0)) : memoizeInTable(styleId, tableParagraphOverlay),
 		resolveRunStyle: (styleId) => memoize(runCache, cacheKey(styleId), () => resolver.resolveRunStyle(styleId)),

package/dist/style-sets/extract.js

@@ -1,4 +1,4 @@
-import { BUILT_IN_DEFAULT_PARAGRAPH_FORMATTING, BUILT_IN_DEFAULT_PARAGRAPH_STYLE_ID, BUILT_IN_DEFAULT_PARAGRAPH_STYLE_NAME, resolveDefaultParagraphStyle } from "../docx/defaultParagraphStyle.js";
+import { mintDefaultParagraphStyle, resolveDefaultParagraphStyle } from "../docx/defaultParagraphStyle.js";
 import { getCachedNumberingMap } from "../docx/numberingParser.js";
 import { isNumberingReference } from "../docx/numberingReference.js";
 import { normalizeStyleNumberingReferences } from "../docx/numberingReferenceNormalization.js";
@@ -83,28 +83,6 @@ const ensureInitialParagraphStyle = ({ styles, requested, hasDocDefaults }) => {
 	styles.push(minted);
 	return minted.styleId;
 };
-/**
-* The default paragraph style a set needs when its source declared none.
-*
-* The id only has to be free, because the set is what defines it. The
-* formatting has to be the built-in template's whenever the source had no
-* `w:docDefaults`, because that is what the source itself rendered as: a
-* consumer applies its built-in Normal only where no default paragraph style
-* exists, and this minted style is one. Where the source did declare
-* `w:docDefaults`, the set carries them and they remain authoritative, so the
-* minted style states nothing.
-*/
-const mintDefaultParagraphStyle = ({ takenStyleIds, hasDocDefaults }) => {
-	let styleId = BUILT_IN_DEFAULT_PARAGRAPH_STYLE_ID;
-	for (let suffix = 1; takenStyleIds.has(styleId); suffix += 1) styleId = `${BUILT_IN_DEFAULT_PARAGRAPH_STYLE_ID}${suffix}`;
-	return {
-		styleId,
-		type: "paragraph",
-		name: BUILT_IN_DEFAULT_PARAGRAPH_STYLE_NAME,
-		default: true,
-		...hasDocDefaults ? {} : { pPr: { ...BUILT_IN_DEFAULT_PARAGRAPH_FORMATTING } }
-	};
-};
 const collectStyleDependencyClosure = (stylesById, requestedStyleIds) => {
 	const selected = /* @__PURE__ */ new Set();
 	const pending = [...requestedStyleIds];