@stll/folio-core 0.35.1 → 0.37.0

package/dist/prosemirror/runFormattingProvenance.d.ts

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../types/document.js";
+import { RunFormattingOverrideAttrs } from "./schema/marks.js";
+//#region src/prosemirror/runFormattingProvenance.d.ts
+declare const hasAuthoredRunFormattingProvenance: ({ _authoredOff, _authoredOn, _authoredValues }: RunFormattingOverrideAttrs) => boolean;
+/** Whether an override mark still carries any rendering or authorship signal. */
+declare const hasRunFormattingOverrideAttrs: (attrs: RunFormattingOverrideAttrs) => boolean;
+/** Reconstruct the last imported/reconciled direct baseline; inherited values never enter here. */
+declare const authoredRunFormattingFromAttrs: (attrs: RunFormattingOverrideAttrs) => document_d_exports.TextFormatting | undefined;
+/** Replace the direct baseline while preserving current rendering attributes. */
+declare const withAuthoredRunFormatting: (attrs: RunFormattingOverrideAttrs, formatting: document_d_exports.TextFormatting | undefined) => RunFormattingOverrideAttrs;
+//#endregion
+export { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance, hasRunFormattingOverrideAttrs, withAuthoredRunFormatting };

package/dist/prosemirror/runFormattingProvenance.js

@@ -0,0 +1,48 @@
+import { RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_PROPERTY_SPECS, RUN_FORMATTING_VALUE_PROPERTIES } from "./schema/marks.js";
+//#region src/prosemirror/runFormattingProvenance.ts
+const isRunFormattingProperty = (property) => Object.hasOwn(RUN_FORMATTING_PROPERTY_SPECS, property);
+const hasAuthoredRunFormattingProvenance = ({ _authoredOff, _authoredOn, _authoredValues }) => Array.isArray(_authoredOn) || Array.isArray(_authoredOff) || _authoredValues != null && Object.keys(_authoredValues).length > 0;
+/** Whether an override mark still carries any rendering or authorship signal. */
+const hasRunFormattingOverrideAttrs = (attrs) => {
+	if (hasAuthoredRunFormattingProvenance(attrs)) return true;
+	return Object.values(attrs).some((value) => {
+		if (Array.isArray(value)) return value.length > 0;
+		if (typeof value === "object" && value !== null) return Object.keys(value).length > 0;
+		return value !== null && value !== void 0;
+	});
+};
+/** Reconstruct the last imported/reconciled direct baseline; inherited values never enter here. */
+const authoredRunFormattingFromAttrs = (attrs) => {
+	if (!hasAuthoredRunFormattingProvenance(attrs)) return;
+	const formatting = {};
+	for (const property of attrs._authoredOn ?? []) Reflect.set(formatting, property, true);
+	for (const property of attrs._authoredOff ?? []) Reflect.set(formatting, property, false);
+	for (const [property, value] of Object.entries(attrs._authoredValues ?? {})) if (value !== void 0 && isRunFormattingProperty(property)) Reflect.set(formatting, property, value);
+	return formatting;
+};
+/** Replace the direct baseline while preserving current rendering attributes. */
+const withAuthoredRunFormatting = (attrs, formatting) => {
+	const authoredOn = [];
+	const authoredOff = [];
+	const authoredValues = {};
+	for (const property of RUN_FORMATTING_BOOLEAN_PROPERTIES) {
+		const value = formatting?.[property];
+		if (value === true) authoredOn.push(property);
+		else if (value === false) authoredOff.push(property);
+	}
+	for (const property of RUN_FORMATTING_VALUE_PROPERTIES) {
+		const value = formatting?.[property];
+		if (value !== void 0) Reflect.set(authoredValues, property, value);
+	}
+	const next = { ...attrs };
+	delete next._authoredOn;
+	delete next._authoredOff;
+	delete next._authoredValues;
+	if (authoredOn.length > 0) next._authoredOn = authoredOn;
+	if (authoredOff.length > 0) next._authoredOff = authoredOff;
+	if (Object.keys(authoredValues).length > 0) next._authoredValues = authoredValues;
+	if (authoredOn.length === 0 && authoredOff.length === 0 && Object.keys(authoredValues).length === 0) next._authoredOn = [];
+	return next;
+};
+//#endregion
+export { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance, hasRunFormattingOverrideAttrs, withAuthoredRunFormatting };

package/dist/prosemirror/runFormattingReconciliation.d.ts

@@ -0,0 +1,25 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/runFormattingReconciliation.d.ts
+type ReadAuthoredRunFormattingOptions = {
+  context: ParagraphRunStyleContext;
+  marks: readonly Mark[];
+  styleResolver?: RunStyleResolver | null;
+};
+/** Read authored run properties without confusing inherited visuals for direct formatting. */
+declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
+type ReconcileRunFormattingMarksOptions = {
+  authoredFormatting: document_d_exports.TextFormatting;
+  context: ParagraphRunStyleContext;
+  node: Node;
+  styleResolver?: RunStyleResolver | null;
+};
+/**
+ * Rebuild a run's physical formatting marks from its authored properties and
+ * current style context. This is the inverse of {@link readAuthoredRunFormatting}:
+ * direct provenance stays direct while inherited formatting remains visual only.
+ */
+declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
+//#endregion
+export { readAuthoredRunFormatting, reconcileRunFormattingMarks };

package/dist/prosemirror/runFormattingReconciliation.js

@@ -0,0 +1,54 @@
+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 { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/runFormattingReconciliation.ts
+/** Read authored run properties without confusing inherited visuals for direct formatting. */
+const readAuthoredRunFormatting = ({ context, marks, styleResolver }) => marksToTextFormatting(marks, {
+	baseParagraphFormatting: context.baseParagraphFormatting,
+	inheritedFormatting: context.paragraphFormatting,
+	paragraphMarkFormatting: context.paragraphMarkFormatting,
+	paragraphMarkPrecedesStyle: context.paragraphMarkPrecedesStyle,
+	...styleResolver !== void 0 ? { styleResolver } : {}
+});
+/**
+* Rebuild a run's physical formatting marks from its authored properties and
+* current style context. This is the inverse of {@link readAuthoredRunFormatting}:
+* direct provenance stays direct while inherited formatting remains visual only.
+*/
+const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleResolver }) => {
+	const { marks } = node;
+	const currentCharacterStyle = marks.find(({ type }) => type.name === "characterStyle");
+	const currentCharacterStyleAttrs = currentCharacterStyle ? expectCharacterStyleMarkAttrs(currentCharacterStyle) : void 0;
+	const characterStyleType = node.type.schema.marks["characterStyle"];
+	const characterStyle = authoredFormatting.styleId !== void 0 && characterStyleType ? characterStyleType.create(currentCharacterStyleAttrs?.styleId === authoredFormatting.styleId ? currentCharacterStyleAttrs : { styleId: authoredFormatting.styleId }) : void 0;
+	const directCarrierType = node.type.schema.marks["runFormattingOverride"];
+	const styleResolutionMarks = [...hasDirectRunFormatting(authoredFormatting) && directCarrierType ? [directCarrierType.create()] : [], ...characterStyle ? [characterStyle] : []];
+	const paragraphFormatting = paragraphFormattingForRun({
+		marks: styleResolutionMarks,
+		context,
+		directFormatting: authoredFormatting
+	});
+	const formattingMarks = textFormattingToMarks(mergeTextFormatting(resolveEffectiveRunStyleFormatting({
+		marks: styleResolutionMarks,
+		paragraphFormatting,
+		...styleResolver !== void 0 ? { styleResolver } : {}
+	}), authoredFormatting), {
+		overrideFormatting: mergeTextFormatting(getParagraphMarkSuppressionOverrides({
+			directFormatting: authoredFormatting,
+			paragraphMarkFormatting: context.paragraphMarkFormatting,
+			suppressedFormatting: paragraphFormatting
+		}), authoredFormatting),
+		directFormatting: authoredFormatting
+	});
+	return Mark.setFrom([
+		...marks.filter(({ type }) => !RUN_FORMATTING_MARK_NAMES.has(type.name)),
+		...formattingMarks,
+		...characterStyle ? [characterStyle] : []
+	]);
+};
+//#endregion
+export { readAuthoredRunFormatting, reconcileRunFormattingMarks };

package/dist/prosemirror/runPropertyChangeResolution.d.ts

@@ -0,0 +1,18 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/runPropertyChangeResolution.d.ts
+type ReconstructRejectedRunFormattingMarksOptions = {
+  node: Node;
+  paragraphContext: ParagraphRunStyleContext;
+  previousFormatting: document_d_exports.RunPropertyChange["previousFormatting"];
+  styleResolver?: RunStyleResolver | null;
+};
+/**
+ * Rebuild the pre-change run marks against the paragraph's live style cascade.
+ * Both granular editor commands and the headless linear rewriter use this
+ * owner so their reject semantics cannot diverge at the bulk threshold.
+ */
+declare const reconstructRejectedRunFormattingMarks: ({ node, paragraphContext, previousFormatting, styleResolver }: ReconstructRejectedRunFormattingMarksOptions) => readonly Mark[];
+//#endregion
+export { reconstructRejectedRunFormattingMarks };

package/dist/prosemirror/runPropertyChangeResolution.js

@@ -0,0 +1,18 @@
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+//#region src/prosemirror/runPropertyChangeResolution.ts
+/**
+* Rebuild the pre-change run marks against the paragraph's live style cascade.
+* Both granular editor commands and the headless linear rewriter use this
+* owner so their reject semantics cannot diverge at the bulk threshold.
+*/
+const reconstructRejectedRunFormattingMarks = ({ node, paragraphContext, previousFormatting, styleResolver }) => {
+	return reconcileRunFormattingMarks({
+		authoredFormatting: previousFormatting ?? {},
+		context: paragraphContext,
+		node,
+		...styleResolver !== void 0 ? { styleResolver } : {}
+	}).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name));
+};
+//#endregion
+export { reconstructRejectedRunFormattingMarks };

package/dist/prosemirror/runStyleFormatting.d.ts

@@ -0,0 +1,50 @@
+import { document_d_exports } from "../types/document.js";
+import { StyleEngine } from "../style-engine/styleEngine.js";
+import "../style-engine/index.js";
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/runStyleFormatting.d.ts
+declare const hasDirectRunFormatting: (formatting: document_d_exports.TextFormatting | undefined) => boolean;
+declare const stripParagraphMarkOnlyFormatting: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
+declare const stripParagraphMarkFormattingForBodyRuns: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
+type SuppressParagraphMarkFormattingOptions = {
+  baseFormatting: document_d_exports.TextFormatting | undefined;
+  directFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphMarkPrecedesStyle?: boolean;
+};
+declare const suppressParagraphMarkFormatting: ({ baseFormatting, directFormatting, paragraphMarkFormatting, paragraphMarkPrecedesStyle }: SuppressParagraphMarkFormattingOptions) => document_d_exports.TextFormatting | undefined;
+type GetParagraphMarkSuppressionOverridesOptions = {
+  directFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
+  suppressedFormatting: document_d_exports.TextFormatting | undefined;
+};
+declare const getParagraphMarkSuppressionOverrides: ({ directFormatting, paragraphMarkFormatting, suppressedFormatting }: GetParagraphMarkSuppressionOverridesOptions) => document_d_exports.TextFormatting | undefined;
+type ParagraphRunStyleContext = {
+  baseParagraphFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
+  paragraphMarkPrecedesStyle: boolean;
+};
+type RunStyleResolver = Pick<StyleEngine, "getDefaultCharacterStyle" | "getDocDefaults" | "getRunStyleOwnProperties" | "resolveParagraphStyle">;
+declare const paragraphRunStyleContext: (paragraph: Node, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
+type ParagraphFormattingForRunOptions = {
+  context: ParagraphRunStyleContext;
+  directFormatting?: document_d_exports.TextFormatting;
+  marks: readonly Mark[];
+};
+declare const paragraphFormattingForRun: ({ context, directFormatting, marks }: ParagraphFormattingForRunOptions) => document_d_exports.TextFormatting | undefined;
+type ParagraphRunStyleContextAtOptions = {
+  doc: Node;
+  pos: number;
+  styleResolver?: RunStyleResolver | null;
+};
+declare const paragraphRunStyleContextAt: ({ doc, pos, styleResolver }: ParagraphRunStyleContextAtOptions) => ParagraphRunStyleContext;
+type ResolveEffectiveRunStyleFormattingOptions = {
+  marks: readonly Mark[];
+  paragraphFormatting: document_d_exports.TextFormatting | undefined;
+  styleResolver?: RunStyleResolver | null;
+};
+/** Resolve the non-direct run cascade from shared document styles and the current paragraph. */
+declare const resolveEffectiveRunStyleFormatting: ({ marks, paragraphFormatting, styleResolver }: ResolveEffectiveRunStyleFormattingOptions) => document_d_exports.TextFormatting | undefined;
+//#endregion
+export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

package/dist/prosemirror/runStyleFormatting.js

@@ -0,0 +1,105 @@
+import { STYLE_TOGGLE_KEYS, mergeTextFormatting } from "../utils/textFormattingMerge.js";
+import { expectCharacterStyleMarkAttrs, expectParagraphAttrs } from "./attrs/index.js";
+import { cascadeStyleFromResolvedBase, cascadeStyleTextFormatting } from "./styles/styleToggleCascade.js";
+//#region src/prosemirror/runStyleFormatting.ts
+const PARAGRAPH_MARK_BOOLEAN_KEYS = [
+	"bold",
+	"italic",
+	"strike",
+	"doubleStrike",
+	"allCaps",
+	"smallCaps",
+	"hidden",
+	"emboss",
+	"imprint",
+	"shadow",
+	"outline",
+	"rtl"
+];
+const hasDirectRunFormatting = (formatting) => {
+	if (!formatting) return false;
+	return Object.entries(formatting).some(([property, value]) => property !== "styleId" && value !== void 0);
+};
+const stripParagraphMarkOnlyFormatting = (formatting) => {
+	const { allCaps: _allCaps, highlight: _highlight, shading: _shading, smallCaps: _smallCaps, vertAlign: _vertAlign, ...formattingForBody } = formatting;
+	return Object.keys(formattingForBody).length > 0 ? formattingForBody : void 0;
+};
+const stripParagraphMarkFormattingForBodyRuns = (formatting) => {
+	const paragraphMarkFormatting = stripParagraphMarkOnlyFormatting(formatting);
+	if (!paragraphMarkFormatting) return;
+	const { fontFamily: _fontFamily, ...bodyRunFormatting } = paragraphMarkFormatting;
+	return Object.keys(bodyRunFormatting).length > 0 ? bodyRunFormatting : void 0;
+};
+const suppressParagraphMarkFormatting = ({ baseFormatting, directFormatting, paragraphMarkFormatting, paragraphMarkPrecedesStyle = false }) => {
+	if (!paragraphMarkFormatting) return baseFormatting;
+	const result = (paragraphMarkPrecedesStyle ? mergeTextFormatting(paragraphMarkFormatting, baseFormatting) : mergeTextFormatting(baseFormatting, paragraphMarkFormatting)) ?? {};
+	for (const property of PARAGRAPH_MARK_BOOLEAN_KEYS) if (paragraphMarkFormatting[property] !== void 0 && directFormatting?.[property] === void 0) Reflect.set(result, property, baseFormatting?.[property] ?? false);
+	for (const property of ["fontSize", "fontSizeCs"]) if (paragraphMarkFormatting[property] !== void 0 && directFormatting?.[property] === void 0 && baseFormatting?.[property] !== void 0) result[property] = baseFormatting[property];
+	if (paragraphMarkFormatting.underline !== void 0 && directFormatting?.underline === void 0) result.underline = { style: "none" };
+	if (paragraphMarkFormatting.spacing !== void 0 && directFormatting?.spacing === void 0) result.spacing = 0;
+	return Object.keys(result).length > 0 ? result : void 0;
+};
+const getParagraphMarkSuppressionOverrides = ({ directFormatting, paragraphMarkFormatting, suppressedFormatting }) => {
+	if (!paragraphMarkFormatting) return;
+	const overrides = {};
+	for (const property of PARAGRAPH_MARK_BOOLEAN_KEYS) if (paragraphMarkFormatting[property] !== void 0 && directFormatting?.[property] === void 0 && suppressedFormatting?.[property] === false) Reflect.set(overrides, property, false);
+	if (paragraphMarkFormatting.underline !== void 0 && directFormatting?.underline === void 0 && suppressedFormatting?.underline?.style === "none") overrides.underline = { style: "none" };
+	return Object.keys(overrides).length > 0 ? overrides : void 0;
+};
+const paragraphRunStyleContext = (paragraph, styleResolver) => {
+	const attrs = expectParagraphAttrs(paragraph);
+	const paragraphMarkFormatting = attrs._originalFormatting?.runProperties;
+	const resolvedParagraphMarkFormatting = cascadeStyleTextFormatting([{
+		formatting: paragraphMarkFormatting?.styleId ? styleResolver?.getRunStyleOwnProperties(paragraphMarkFormatting.styleId) : void 0,
+		type: "style"
+	}, {
+		formatting: paragraphMarkFormatting,
+		type: "direct"
+	}]).formatting;
+	const inheritableParagraphMarkFormatting = resolvedParagraphMarkFormatting ? stripParagraphMarkFormattingForBodyRuns(resolvedParagraphMarkFormatting) : void 0;
+	return {
+		baseParagraphFormatting: styleResolver?.resolveParagraphStyle(attrs.styleId).runFormatting,
+		paragraphFormatting: attrs.defaultTextFormatting ?? void 0,
+		paragraphMarkFormatting: inheritableParagraphMarkFormatting,
+		paragraphMarkPrecedesStyle: attrs.styleId !== void 0
+	};
+};
+const paragraphFormattingForRun = ({ context, directFormatting, marks }) => {
+	if (!marks.some(({ type }) => type.name === "runFormattingOverride" || type.name === "characterStyle")) return context.paragraphFormatting;
+	return suppressParagraphMarkFormatting({
+		baseFormatting: context.baseParagraphFormatting,
+		directFormatting,
+		paragraphMarkFormatting: context.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: context.paragraphMarkPrecedesStyle
+	});
+};
+const paragraphRunStyleContextAt = ({ doc, pos, styleResolver }) => {
+	const resolved = doc.resolve(pos);
+	for (let depth = resolved.depth; depth >= 0; depth--) {
+		const ancestor = resolved.node(depth);
+		if (ancestor.type.name === "paragraph") return paragraphRunStyleContext(ancestor, styleResolver);
+	}
+	return {
+		baseParagraphFormatting: void 0,
+		paragraphFormatting: void 0,
+		paragraphMarkFormatting: void 0,
+		paragraphMarkPrecedesStyle: false
+	};
+};
+/** Resolve the non-direct run cascade from shared document styles and the current paragraph. */
+const resolveEffectiveRunStyleFormatting = ({ marks, paragraphFormatting, styleResolver }) => {
+	const characterStyle = marks.find(({ type }) => type.name === "characterStyle");
+	const hasDirectFormattingCarrier = marks.some(({ type }) => type.name === "runFormattingOverride");
+	let styleFormatting;
+	if (characterStyle) styleFormatting = styleResolver?.getRunStyleOwnProperties(expectCharacterStyleMarkAttrs(characterStyle).styleId);
+	else if (hasDirectFormattingCarrier) styleFormatting = styleResolver?.getDefaultCharacterStyle()?.rPr;
+	if (!styleFormatting) return paragraphFormatting;
+	const docDefaults = styleResolver?.getDocDefaults()?.rPr;
+	return cascadeStyleFromResolvedBase({
+		baseFormatting: paragraphFormatting,
+		defaultsActiveProperties: STYLE_TOGGLE_KEYS.filter((property) => docDefaults?.[property] === true),
+		styleFormatting
+	});
+};
+//#endregion
+export { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

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

@@ -1,5 +1,5 @@
-import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
-import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
+import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
 //#region src/prosemirror/schema/index.d.ts
 declare const singletonManager: ExtensionManager;
@@ -11,4 +11,4 @@ type DocxSchema = typeof schema;
 type DocxNode = ReturnType<typeof schema.node>;
 type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };
+export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type PageBreakRunOwnerMarkAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };

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

@@ -102,6 +102,8 @@ type TrackedChangeMarkAttrs = {
   revisionId: number;
   author: string;
   date?: string;
+  /** UTC companion timestamp carried privately through the editable model. */
+  utcDate?: string;
   /** Optional author initials (w:initials) carried through the round-trip. */
   initials?: string;
   moveKind?: "moveTo" | "moveFrom";
@@ -121,28 +123,101 @@ type RunPropertyChangeMarkAttrs = {
   provenance: TrackedChangeProvenance;
   suggestionId?: string;
 };
-type RunFormattingOverrideAttrs = Partial<Record<"bold" | "boldCs" | "cs" | "italic" | "italicCs" | "strike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline", boolean>> & {
+/** Editor-only identity for one authored run that contains an explicit page break. */
+type PageBreakRunOwnerMarkAttrs = {
+  id: number;
+};
+declare const COMPLEX_SCRIPT_RUN_PROPERTY_KEYS: readonly ["boldCs", "italicCs", "fontSizeCs"];
+type ComplexScriptRunPropertyKey = (typeof COMPLEX_SCRIPT_RUN_PROPERTY_KEYS)[number];
+declare const RUN_FORMATTING_BOOLEAN_PROPERTIES: readonly ["bold", "boldCs", "italic", "italicCs", "strike", "doubleStrike", "smallCaps", "allCaps", "hidden", "emboss", "imprint", "outline", "shadow", "rtl", "cs"];
+declare const RUN_FORMATTING_VALUE_PROPERTIES: readonly ["underline", "vertAlign", "color", "highlight", "shading", "fontSize", "fontSizeCs", "fontFamily", "language", "spacing", "position", "scale", "kerning", "effect", "emphasisMark"];
+type RunFormattingBooleanProperty = (typeof RUN_FORMATTING_BOOLEAN_PROPERTIES)[number];
+type RunFormattingValueProperty = (typeof RUN_FORMATTING_VALUE_PROPERTIES)[number];
+declare const RUN_FORMATTING_PROPERTY_SPECS: {
+  readonly bold: "boolean";
+  readonly boldCs: "boolean";
+  readonly italic: "boolean";
+  readonly italicCs: "boolean";
+  readonly underline: "value";
+  readonly strike: "boolean";
+  readonly doubleStrike: "boolean";
+  readonly vertAlign: "value";
+  readonly smallCaps: "boolean";
+  readonly allCaps: "boolean";
+  readonly hidden: "boolean";
+  readonly color: "value";
+  readonly highlight: "value";
+  readonly shading: "value";
+  readonly fontSize: "value";
+  readonly fontSizeCs: "value";
+  readonly fontFamily: "value";
+  readonly language: "value";
+  readonly spacing: "value";
+  readonly position: "value";
+  readonly scale: "value";
+  readonly kerning: "value";
+  readonly effect: "value";
+  readonly emphasisMark: "value";
+  readonly emboss: "boolean";
+  readonly imprint: "boolean";
+  readonly outline: "boolean";
+  readonly shadow: "boolean";
+  readonly rtl: "boolean";
+  readonly cs: "boolean";
+  readonly styleId: "style";
+};
+type AuthoredRunFormattingValues = Partial<Pick<document_d_exports.TextFormatting, RunFormattingValueProperty>>;
+type RunFormattingOverrideAttrs = {
+  allCaps?: boolean;
+  bold?: boolean;
+  boldCs?: boolean;
+  cs?: boolean;
+  emboss?: boolean;
+  hidden?: boolean;
+  imprint?: boolean;
+  italic?: boolean;
+  italicCs?: boolean;
+  outline?: boolean;
+  shadow?: boolean;
+  smallCaps?: boolean;
+  strike?: boolean;
+  /** Imported/reconciled direct-positive baseline; current PM signals may diverge after edits. */
+  _authoredOn?: readonly RunFormattingBooleanProperty[];
+  /** Imported/reconciled direct-negative baseline; absence means the property was inherited. */
+  _authoredOff?: readonly RunFormattingBooleanProperty[];
+  /** Imported/reconciled direct value baseline, including nested slot identity and sentinels. */
+  _authoredValues?: AuthoredRunFormattingValues;
   directFontProperties?: readonly ("fontFamily" | "fontSize" | "color")[];
+  /** Current complex-script mirrors explicitly omitted by the run. */
+  complexScriptPropertyAbsences?: readonly ComplexScriptRunPropertyKey[];
+  color?: "auto";
   doubleStrike?: false;
+  effect?: "none";
+  emphasisMark?: "none";
+  highlight?: "none";
+  kerning?: 0;
+  position?: 0;
   rtl?: false;
+  scale?: 100;
+  shading?: ShadingProperties & {
+    pattern: "nil";
+  };
+  spacing?: 0;
   fontSizeCs?: number;
   underline?: "none";
+  vertAlign?: "baseline";
 };
 /**
  * Character style mark attributes (w:rStyle).
  *
  * `styleId` is the OOXML character style reference, carried so a styled run
  * re-serializes as a style reference instead of losing the semantic link.
- * `_styleRPr` is the style's own run properties snapshotted at load in mark
- * normal form (the shape `marksToTextFormatting` produces); `fromProseDoc`
- * subtracts values equal to this snapshot so style-provided formatting is not
- * baked into the run as direct formatting on save. It is absent when the
- * style was unknown at load — nothing was resolved, so nothing is subtracted
- * and the reference round-trips verbatim.
+ * Style formatting is resolved once per document through the style engine;
+ * duplicating it on every styled run bloats collaborative state and becomes
+ * stale when a run moves between paragraph contexts.
  */
 type CharacterStyleAttrs = {
   styleId: string;
-  _styleRPr?: document_d_exports.TextFormatting;
 };
 /**
  * Hyperlink mark attributes
@@ -154,4 +229,4 @@ type HyperlinkAttrs = {
   _docxHyperlinkIndex?: number;
 };
 //#endregion
-export { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TRACKED_CHANGE_PROVENANCE_VALUES, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedChangeProvenance, UnderlineAttrs };
+export { AuthoredRunFormattingValues, COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, ComplexScriptRunPropertyKey, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_PROPERTY_SPECS, RUN_FORMATTING_VALUE_PROPERTIES, RunFormattingBooleanProperty, RunFormattingOverrideAttrs, RunFormattingValueProperty, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TRACKED_CHANGE_PROVENANCE_VALUES, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedChangeProvenance, UnderlineAttrs };

package/dist/prosemirror/schema/marks.js

@@ -11,5 +11,77 @@
 *   DOCX can only ever produce `"user"` marks.
 */
 const TRACKED_CHANGE_PROVENANCE_VALUES = ["user", "suggested"];
+const COMPLEX_SCRIPT_RUN_PROPERTY_KEYS = [
+	"boldCs",
+	"italicCs",
+	"fontSizeCs"
+];
+const RUN_FORMATTING_BOOLEAN_PROPERTIES = [
+	"bold",
+	"boldCs",
+	"italic",
+	"italicCs",
+	"strike",
+	"doubleStrike",
+	"smallCaps",
+	"allCaps",
+	"hidden",
+	"emboss",
+	"imprint",
+	"outline",
+	"shadow",
+	"rtl",
+	"cs"
+];
+const RUN_FORMATTING_VALUE_PROPERTIES = [
+	"underline",
+	"vertAlign",
+	"color",
+	"highlight",
+	"shading",
+	"fontSize",
+	"fontSizeCs",
+	"fontFamily",
+	"language",
+	"spacing",
+	"position",
+	"scale",
+	"kerning",
+	"effect",
+	"emphasisMark"
+];
+const RUN_FORMATTING_PROPERTY_SPECS = {
+	bold: "boolean",
+	boldCs: "boolean",
+	italic: "boolean",
+	italicCs: "boolean",
+	underline: "value",
+	strike: "boolean",
+	doubleStrike: "boolean",
+	vertAlign: "value",
+	smallCaps: "boolean",
+	allCaps: "boolean",
+	hidden: "boolean",
+	color: "value",
+	highlight: "value",
+	shading: "value",
+	fontSize: "value",
+	fontSizeCs: "value",
+	fontFamily: "value",
+	language: "value",
+	spacing: "value",
+	position: "value",
+	scale: "value",
+	kerning: "value",
+	effect: "value",
+	emphasisMark: "value",
+	emboss: "boolean",
+	imprint: "boolean",
+	outline: "boolean",
+	shadow: "boolean",
+	rtl: "boolean",
+	cs: "boolean",
+	styleId: "style"
+};
 //#endregion
-export { TRACKED_CHANGE_PROVENANCE_VALUES };
+export { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_PROPERTY_SPECS, RUN_FORMATTING_VALUE_PROPERTIES, TRACKED_CHANGE_PROVENANCE_VALUES };