@stll/folio-core 0.36.0 → 0.37.1

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

@@ -1,27 +1,50 @@
+import { canonicalJson } from "../../../utils/canonicalJson.js";
 import { createExtension } from "../create.js";
 import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep } from "prosemirror-transform";
 import { Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.ts
-/**
-* Paragraph Change Tracker Extension
-*
-* Watches ProseMirror transactions and records which paragraph IDs (paraId)
-* were modified. Also detects structural changes (paragraphs added/deleted).
-* Used by the selective save system to patch only changed paragraphs in document.xml.
-*/
 const paragraphChangeTrackerKey = new PluginKey("paragraphChangeTracker");
 const CLEAR_META = "clear";
 const IGNORE_META = "ignore";
 const STRUCTURAL_META = "structural";
-/**
-* Count paragraph nodes in a ProseMirror document
-*/
-function countParagraphs(doc) {
-	let count = 0;
-	doc.descendants((node) => {
-		if (node.type.name === "paragraph") count++;
-	});
-	return count;
+const CHANGED_PARAGRAPH_RANGES_META = "folioChangedParagraphRanges";
+const SECTION_ENDPOINT_REMOVAL_META = "folioSectionEndpointRemoval";
+const isChangedParagraphRangesMeta = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "changed-paragraph-ranges";
+const isRemovedSectionReference = (value) => typeof value === "object" && value !== null && "part" in value && (value.part === "header" || value.part === "footer") && "type" in value && (value.type === "default" || value.type === "first" || value.type === "even") && "relationshipId" in value && typeof value.relationshipId === "string";
+const isTrackedSectionEndpointRemoval = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "tracked-section-endpoint-removal" && "sourceParagraphEndpointCount" in value && typeof value.sourceParagraphEndpointCount === "number" && Number.isSafeInteger(value.sourceParagraphEndpointCount) && "expectedParagraphEndpointCount" in value && typeof value.expectedParagraphEndpointCount === "number" && Number.isSafeInteger(value.expectedParagraphEndpointCount) && value.sourceParagraphEndpointCount > value.expectedParagraphEndpointCount && value.expectedParagraphEndpointCount >= 0 && "sourceEndpointFingerprint" in value && typeof value.sourceEndpointFingerprint === "string" && "expectedEndpointFingerprint" in value && typeof value.expectedEndpointFingerprint === "string" && "removedReferences" in value && Array.isArray(value.removedReferences) && value.removedReferences.every(isRemovedSectionReference);
+const isTrackedSectionEndpointRemovalMeta = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "tracked-section-endpoint-removal-meta" && "authorization" in value && isTrackedSectionEndpointRemoval(value.authorization);
+/** Count the structural values the tracker compares for every transaction. */
+function countDocumentStructure(doc) {
+	let paragraphs = 0;
+	let sectionEndpoints = 0;
+	const endpointRecords = [];
+	const visit = (parent, parentPath) => {
+		parent.forEach((node, _offset, index) => {
+			if (node.type.name === "paragraph") {
+				paragraphs++;
+				if (node.attrs["_sectionProperties"] != null || node.attrs["sectionBreakType"] != null) {
+					sectionEndpoints++;
+					endpointRecords.push({
+						path: parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`,
+						paraId: node.attrs["paraId"] ?? null,
+						sectionBreakType: node.attrs["sectionBreakType"] ?? null,
+						sectionProperties: node.attrs["_sectionProperties"] ?? null
+					});
+				}
+				return;
+			}
+			if (node.childCount > 0) {
+				const path = parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`;
+				visit(node, path);
+			}
+		});
+	};
+	visit(doc, "");
+	return {
+		paragraphs,
+		sectionEndpoints,
+		sectionEndpointFingerprint: canonicalJson(endpointRecords)
+	};
 }
 /**
 * Collect paraIds of all paragraphs that overlap with the given range
@@ -81,33 +104,82 @@ function createParagraphChangeTrackerPlugin() {
 		key: paragraphChangeTrackerKey,
 		state: {
 			init(_config, state) {
+				const counts = countDocumentStructure(state.doc);
 				return {
 					changedParaIds: /* @__PURE__ */ new Set(),
 					structuralChange: false,
 					hasUntrackedChanges: false,
-					paragraphCount: countParagraphs(state.doc)
+					paragraphCount: counts.paragraphs,
+					sectionEndpointCount: counts.sectionEndpoints,
+					sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+					sectionEndpointRemoval: null
 				};
 			},
 			apply(tr, prevState) {
 				const meta = tr.getMeta(paragraphChangeTrackerKey);
-				if (meta === CLEAR_META) return {
-					changedParaIds: /* @__PURE__ */ new Set(),
-					structuralChange: false,
-					hasUntrackedChanges: false,
-					paragraphCount: prevState.paragraphCount
-				};
-				if (meta === IGNORE_META) return {
-					...prevState,
-					paragraphCount: tr.docChanged ? countParagraphs(tr.doc) : prevState.paragraphCount
-				};
+				const changedParagraphRangesMeta = tr.getMeta(CHANGED_PARAGRAPH_RANGES_META);
+				const sectionEndpointRemovalMeta = tr.getMeta(SECTION_ENDPOINT_REMOVAL_META);
+				if (meta === CLEAR_META) {
+					const counts = countDocumentStructure(tr.doc);
+					return {
+						changedParaIds: /* @__PURE__ */ new Set(),
+						structuralChange: false,
+						hasUntrackedChanges: false,
+						paragraphCount: counts.paragraphs,
+						sectionEndpointCount: counts.sectionEndpoints,
+						sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+						sectionEndpointRemoval: null
+					};
+				}
+				if (meta === IGNORE_META) {
+					const counts = tr.docChanged ? countDocumentStructure(tr.doc) : {
+						paragraphs: prevState.paragraphCount,
+						sectionEndpoints: prevState.sectionEndpointCount,
+						sectionEndpointFingerprint: prevState.sectionEndpointFingerprint
+					};
+					return {
+						...prevState,
+						paragraphCount: counts.paragraphs,
+						sectionEndpointCount: counts.sectionEndpoints,
+						sectionEndpointRemoval: counts.sectionEndpointFingerprint === prevState.sectionEndpointFingerprint ? prevState.sectionEndpointRemoval : null,
+						sectionEndpointFingerprint: counts.sectionEndpointFingerprint
+					};
+				}
 				if (!tr.docChanged) return prevState;
-				const newCount = countParagraphs(tr.doc);
+				const counts = countDocumentStructure(tr.doc);
+				const newCount = counts.paragraphs;
+				let sectionEndpointRemoval = prevState.sectionEndpointRemoval;
+				if (counts.sectionEndpointFingerprint !== prevState.sectionEndpointFingerprint) if (isTrackedSectionEndpointRemovalMeta(sectionEndpointRemovalMeta) && sectionEndpointRemovalMeta.authorization.sourceEndpointFingerprint === prevState.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.expectedEndpointFingerprint === counts.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.sourceParagraphEndpointCount === prevState.sectionEndpointCount && sectionEndpointRemovalMeta.authorization.expectedParagraphEndpointCount === counts.sectionEndpoints && counts.sectionEndpoints < prevState.sectionEndpointCount) {
+					const authorization = sectionEndpointRemovalMeta.authorization;
+					sectionEndpointRemoval = {
+						type: "tracked-section-endpoint-removal",
+						sourceParagraphEndpointCount: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceParagraphEndpointCount : authorization.sourceParagraphEndpointCount,
+						expectedParagraphEndpointCount: authorization.expectedParagraphEndpointCount,
+						sourceEndpointFingerprint: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceEndpointFingerprint : authorization.sourceEndpointFingerprint,
+						expectedEndpointFingerprint: authorization.expectedEndpointFingerprint,
+						removedReferences: [...prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.removedReferences : [], ...authorization.removedReferences]
+					};
+				} else sectionEndpointRemoval = null;
 				const newState = {
 					changedParaIds: new Set(prevState.changedParaIds),
 					structuralChange: prevState.structuralChange || meta === STRUCTURAL_META,
 					hasUntrackedChanges: prevState.hasUntrackedChanges,
-					paragraphCount: newCount
+					paragraphCount: newCount,
+					sectionEndpointCount: counts.sectionEndpoints,
+					sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+					sectionEndpointRemoval
 				};
+				if (isChangedParagraphRangesMeta(changedParagraphRangesMeta)) for (const batch of changedParagraphRangesMeta.batches) {
+					const remap = tr.mapping.slice(batch.mappingFrom);
+					for (const range of batch.ranges) {
+						const from = mapStepPosition(remap, range.from, 1);
+						const to = mapStepPosition(remap, range.to, -1);
+						if (to <= from) continue;
+						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const id of ids) newState.changedParaIds.add(id);
+						if (hasUntracked) newState.hasUntrackedChanges = true;
+					}
+				}
 				if (prevState.paragraphCount !== newCount) newState.structuralChange = true;
 				for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
 					const step = tr.steps[stepIndex];
@@ -169,6 +241,29 @@ function hasStructuralChanges(state) {
 function hasUntrackedChanges(state) {
 	return getChangeTrackerState(state)?.hasUntrackedChanges ?? false;
 }
+/** Exact section-count transition authorized by tracked paragraph-mark resolution. */
+function getTrackedSectionEndpointRemoval(state) {
+	return getChangeTrackerState(state)?.sectionEndpointRemoval ?? null;
+}
+/** Record only a complete, internally consistent endpoint-removal transition. */
+function markTrackedSectionEndpointRemoval(tr, { sourceDoc, removedEndpointCount, removedReferences }) {
+	const sourceStructure = countDocumentStructure(sourceDoc);
+	const sourceParagraphEndpointCount = sourceStructure.sectionEndpoints;
+	const expectedStructure = countDocumentStructure(tr.doc);
+	const expectedParagraphEndpointCount = expectedStructure.sectionEndpoints;
+	if (sourceParagraphEndpointCount - expectedParagraphEndpointCount !== removedEndpointCount) return tr;
+	return tr.setMeta(SECTION_ENDPOINT_REMOVAL_META, {
+		type: "tracked-section-endpoint-removal-meta",
+		authorization: {
+			type: "tracked-section-endpoint-removal",
+			sourceParagraphEndpointCount,
+			expectedParagraphEndpointCount,
+			sourceEndpointFingerprint: sourceStructure.sectionEndpointFingerprint,
+			expectedEndpointFingerprint: expectedStructure.sectionEndpointFingerprint,
+			removedReferences
+		}
+	});
+}
 /**
 * Create a transaction that clears the change tracker
 */
@@ -181,6 +276,15 @@ function ignoreTrackedChanges(tr) {
 function markStructuralChange(tr) {
 	return tr.setMeta(paragraphChangeTrackerKey, STRUCTURAL_META);
 }
+/** Record mark-only paragraph changes whose replacement step has a granular map. */
+function markChangedParagraphRanges(tr, batch) {
+	const previous = tr.getMeta(CHANGED_PARAGRAPH_RANGES_META);
+	const batches = isChangedParagraphRangesMeta(previous) ? [...previous.batches, batch] : [batch];
+	return tr.setMeta(CHANGED_PARAGRAPH_RANGES_META, {
+		type: "changed-paragraph-ranges",
+		batches
+	});
+}
 const ParagraphChangeTrackerExtension = createExtension({
 	name: "paragraphChangeTracker",
 	defaultOptions: {},
@@ -189,4 +293,4 @@ const ParagraphChangeTrackerExtension = createExtension({
 	}
 });
 //#endregion
-export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markStructuralChange, paragraphChangeTrackerKey };
+export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey };

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

@@ -1,6 +1,7 @@
 import { htmlCommentEnd } from "../../../utils/htmlComments.js";
 import { stripXmlDeclarations } from "../../../utils/stripXmlDeclarations.js";
 import { readBookmarkBoundaryAttrs } from "../../bookmarkBoundaryAttrs.js";
+import { findInvalidBookmarkBoundaryIds } from "../../bookmarkBoundaryIntegrity.js";
 import { Fragment, Slice } from "prosemirror-model";
 //#region src/prosemirror/extensions/features/pasteCleanup.ts
 /**
@@ -187,35 +188,28 @@ function cleanPastedHtml(html, options = {}) {
 }
 /** Remove incomplete or duplicate bookmark pairs at copied slice edges. */
 function removeUnpairedBookmarkBoundaries(slice) {
-	const counts = /* @__PURE__ */ new Map();
+	const boundaries = [];
 	let boundaryIndex = 0;
 	slice.content.descendants((node) => {
 		if (node.type.name !== "bookmarkBoundary") return true;
 		const result = readBookmarkBoundaryAttrs(node);
 		if (!result.ok) return false;
 		const attrs = result.value;
-		const count = counts.get(attrs.id) ?? {
-			starts: 0,
-			ends: 0
-		};
-		if (attrs.type === "start") {
-			count.starts += 1;
-			count.firstStart ??= boundaryIndex;
-		} else {
-			count.ends += 1;
-			count.firstEnd ??= boundaryIndex;
-		}
+		boundaries.push({
+			id: attrs.id,
+			type: attrs.type,
+			position: boundaryIndex
+		});
 		boundaryIndex += 1;
-		counts.set(attrs.id, count);
 		return false;
 	});
-	const pairedIds = new Set([...counts].flatMap(([id, count]) => count.starts === 1 && count.ends === 1 && count.firstStart !== void 0 && count.firstEnd !== void 0 && count.firstStart < count.firstEnd ? [id] : []));
+	const invalidIds = findInvalidBookmarkBoundaryIds(boundaries);
 	const filterFragment = (fragment) => {
 		const children = [];
 		fragment.forEach((node) => {
 			if (node.type.name === "bookmarkBoundary") {
 				const result = readBookmarkBoundaryAttrs(node);
-				if (result.ok && pairedIds.has(result.value.id)) children.push(node);
+				if (result.ok && !invalidIds.has(result.value.id)) children.push(node);
 				return;
 			}
 			children.push(node.childCount === 0 ? node : node.copy(filterFragment(node.content)));

package/dist/prosemirror/extensions/marks/BoldExtension.js

@@ -1,6 +1,6 @@
 import { createMarkExtension } from "../create.js";
+import { toggleMarkForAllScripts } from "./markUtils.js";
 import { panic } from "better-result";
-import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/BoldExtension.ts
 /**
 * Bold Mark Extension
@@ -31,9 +31,10 @@ const BoldExtension = createMarkExtension({
 	onSchemaReady(ctx) {
 		const boldType = ctx.schema.marks["bold"];
 		if (!boldType) panic("Missing mark type: bold");
+		const toggleBold = toggleMarkForAllScripts(boldType, "bold");
 		return {
-			commands: { toggleBold: () => toggleMark(boldType) },
-			keyboardShortcuts: { "Mod-b": toggleMark(boldType) }
+			commands: { toggleBold: () => toggleBold },
+			keyboardShortcuts: { "Mod-b": toggleBold }
 		};
 	}
 });

package/dist/prosemirror/extensions/marks/CharacterStyleExtension.d.ts

@@ -6,16 +6,13 @@ import { MarkExtension } from "../types.js";
  * Carries a run's character style reference through ProseMirror so semantic
  * styles (e.g. a house "DefinedTerm" style) survive the load → edit → save
  * round-trip. The style's resolved formatting is flattened into the regular
- * marks at load for rendering; this mark only preserves the reference plus a
- * private snapshot of the style's own run properties (`_styleRPr`) that the
- * serializer uses to avoid re-emitting style-provided values as direct
- * formatting.
+ * marks at load for rendering; this mark preserves only the reference. Style
+ * formatting resolves through the document's shared style engine so it does
+ * not become stale when a run moves between paragraph contexts.
  *
  * The mark renders as an unstyled span with a `data-character-style`
  * attribute. parseDOM restores the styleId (so copy/paste inside the editor
- * keeps the reference) but not the snapshot — pasted content then serializes
- * with the reference plus explicit formatting, which renders identically and
- * degrades gracefully.
+ * keeps the reference).
  */
 declare const CharacterStyleExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
 //#endregion

package/dist/prosemirror/extensions/marks/CharacterStyleExtension.js

@@ -7,25 +7,19 @@ import { createMarkExtension } from "../create.js";
 * Carries a run's character style reference through ProseMirror so semantic
 * styles (e.g. a house "DefinedTerm" style) survive the load → edit → save
 * round-trip. The style's resolved formatting is flattened into the regular
-* marks at load for rendering; this mark only preserves the reference plus a
-* private snapshot of the style's own run properties (`_styleRPr`) that the
-* serializer uses to avoid re-emitting style-provided values as direct
-* formatting.
+* marks at load for rendering; this mark preserves only the reference. Style
+* formatting resolves through the document's shared style engine so it does
+* not become stale when a run moves between paragraph contexts.
 *
 * The mark renders as an unstyled span with a `data-character-style`
 * attribute. parseDOM restores the styleId (so copy/paste inside the editor
-* keeps the reference) but not the snapshot — pasted content then serializes
-* with the reference plus explicit formatting, which renders identically and
-* degrades gracefully.
+* keeps the reference).
 */
 const CharacterStyleExtension = createMarkExtension({
 	name: "characterStyle",
 	schemaMarkName: "characterStyle",
 	markSpec: {
-		attrs: {
-			styleId: { default: "" },
-			_styleRPr: { default: null }
-		},
+		attrs: { styleId: { default: "" } },
 		parseDOM: [{
 			tag: "span[data-character-style]",
 			getAttrs: (dom) => {

package/dist/prosemirror/extensions/marks/FontSizeExtension.js

@@ -1,6 +1,6 @@
 import { expectFontSizeMarkAttrs } from "../../attrs/index.js";
 import { createMarkExtension } from "../create.js";
-import { removeMark, setMark } from "./markUtils.js";
+import { clearFontSizeForAllScripts, setFontSizeForAllScripts } from "./markUtils.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/FontSizeExtension.ts
 /**
@@ -38,8 +38,8 @@ const FontSizeExtension = createMarkExtension({
 		const fontSizeType = ctx.schema.marks["fontSize"];
 		if (!fontSizeType) panic("Missing mark type: fontSize");
 		return { commands: {
-			setFontSize: (size) => setMark(fontSizeType, { size }),
-			clearFontSize: () => removeMark(fontSizeType)
+			setFontSize: (size) => setFontSizeForAllScripts(fontSizeType, size),
+			clearFontSize: () => clearFontSizeForAllScripts(fontSizeType)
 		} };
 	}
 });

package/dist/prosemirror/extensions/marks/ItalicExtension.js

@@ -1,6 +1,6 @@
 import { createMarkExtension } from "../create.js";
+import { toggleMarkForAllScripts } from "./markUtils.js";
 import { panic } from "better-result";
-import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/ItalicExtension.ts
 /**
 * Italic Mark Extension
@@ -24,9 +24,10 @@ const ItalicExtension = createMarkExtension({
 	onSchemaReady(ctx) {
 		const italicType = ctx.schema.marks["italic"];
 		if (!italicType) panic("Missing mark type: italic");
+		const toggleItalic = toggleMarkForAllScripts(italicType, "italic");
 		return {
-			commands: { toggleItalic: () => toggleMark(italicType) },
-			keyboardShortcuts: { "Mod-i": toggleMark(italicType) }
+			commands: { toggleItalic: () => toggleItalic },
+			keyboardShortcuts: { "Mod-i": toggleItalic }
 		};
 	}
 });

package/dist/prosemirror/extensions/marks/PageBreakRunOwnerExtension.d.ts

@@ -0,0 +1,13 @@
+import { MarkExtension } from "../types.js";
+//#region src/prosemirror/extensions/marks/PageBreakRunOwnerExtension.d.ts
+/**
+ * Editor-only identity for the authored run surrounding a page-break atom.
+ *
+ * Ordinary formatting marks cannot distinguish two adjacent source runs with
+ * identical properties. This mark is added only to a run containing an
+ * explicit page break, so every sibling carrier can be rejoined exactly on
+ * save without changing the generic run-coalescing model.
+ */
+declare const PageBreakRunOwnerExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { PageBreakRunOwnerExtension };

package/dist/prosemirror/extensions/marks/PageBreakRunOwnerExtension.js

@@ -0,0 +1,39 @@
+import { expectPageBreakRunOwnerMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/PageBreakRunOwnerExtension.ts
+/**
+* Editor-only identity for the authored run surrounding a page-break atom.
+*
+* Ordinary formatting marks cannot distinguish two adjacent source runs with
+* identical properties. This mark is added only to a run containing an
+* explicit page break, so every sibling carrier can be rejoined exactly on
+* save without changing the generic run-coalescing model.
+*/
+const CANONICAL_OWNER_ID = /^(?:0|[1-9]\d*)$/u;
+const PageBreakRunOwnerExtension = createMarkExtension({
+	name: "pageBreakRunOwner",
+	schemaMarkName: "pageBreakRunOwner",
+	markSpec: {
+		attrs: { id: {} },
+		inclusive: false,
+		parseDOM: [{
+			tag: "span[data-docx-page-break-run-owner]",
+			getAttrs(dom) {
+				const rawId = dom.dataset["docxPageBreakRunOwner"];
+				if (rawId === void 0 || !CANONICAL_OWNER_ID.test(rawId)) return false;
+				const id = Number(rawId);
+				return Number.isSafeInteger(id) ? { id } : false;
+			}
+		}],
+		toDOM(mark) {
+			const { id } = expectPageBreakRunOwnerMarkAttrs(mark);
+			return [
+				"span",
+				{ "data-docx-page-break-run-owner": String(id) },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { PageBreakRunOwnerExtension };

package/dist/prosemirror/extensions/marks/RunFormattingOverrideExtension.d.ts

@@ -3,7 +3,13 @@ import { RunFormattingOverrideAttrs } from "../../schema/marks.js";
 import { MarkExtension } from "../types.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/extensions/marks/RunFormattingOverrideExtension.d.ts
-declare function buildRunFormattingOverrideAttrs(formatting: document_d_exports.TextFormatting | undefined): RunFormattingOverrideAttrs | undefined;
+type BuildRunFormattingOverrideAttrsOptions = {
+  type: "authored-baseline";
+  formatting: document_d_exports.TextFormatting | undefined;
+} | {
+  type: "structural-only";
+};
+declare function buildRunFormattingOverrideAttrs(formatting: document_d_exports.TextFormatting | undefined, options?: BuildRunFormattingOverrideAttrsOptions): RunFormattingOverrideAttrs | undefined;
 declare function applyRunFormattingOverrideAttrs(formatting: document_d_exports.TextFormatting, attrs: RunFormattingOverrideAttrs): void;
 declare function applyRunFormattingOverrideMark(formatting: document_d_exports.TextFormatting, mark: Mark): void;
 declare const RunFormattingOverrideExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;

package/dist/prosemirror/extensions/marks/RunFormattingOverrideExtension.js

@@ -1,34 +1,60 @@
 import { expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { withAuthoredRunFormatting } from "../../runFormattingProvenance.js";
 import { createMarkExtension } from "../create.js";
 //#region src/prosemirror/extensions/marks/RunFormattingOverrideExtension.ts
-function buildRunFormattingOverrideAttrs(formatting) {
-	if (!formatting) return;
+function buildRunFormattingOverrideAttrs(formatting, options) {
 	const attrs = {};
-	if (formatting.bold !== void 0) attrs.bold = formatting.bold;
-	if (formatting.italic !== void 0) attrs.italic = formatting.italic;
-	if (formatting.underline?.style === "none") attrs.underline = "none";
-	if (formatting.strike !== void 0) attrs.strike = formatting.strike;
-	if (formatting.doubleStrike === false) attrs.doubleStrike = false;
-	if (formatting.allCaps !== void 0) attrs.allCaps = formatting.allCaps;
-	if (formatting.smallCaps !== void 0) attrs.smallCaps = formatting.smallCaps;
-	if (formatting.hidden !== void 0) attrs.hidden = formatting.hidden;
-	if (formatting.emboss !== void 0) attrs.emboss = formatting.emboss;
-	if (formatting.imprint !== void 0) attrs.imprint = formatting.imprint;
-	if (formatting.shadow !== void 0) attrs.shadow = formatting.shadow;
-	if (formatting.outline !== void 0) attrs.outline = formatting.outline;
-	if (formatting.rtl === false) attrs.rtl = false;
-	if (formatting.boldCs !== void 0) attrs.boldCs = formatting.boldCs;
-	if (formatting.italicCs !== void 0) attrs.italicCs = formatting.italicCs;
-	if (formatting.fontSizeCs !== void 0 && formatting.fontSizeCs !== formatting.fontSize) attrs.fontSizeCs = formatting.fontSizeCs;
-	if (formatting.cs !== void 0) attrs.cs = formatting.cs;
-	return Object.keys(attrs).length > 0 ? attrs : void 0;
+	if (formatting?.bold !== void 0) attrs.bold = formatting.bold;
+	if (formatting?.italic !== void 0) attrs.italic = formatting.italic;
+	if (formatting?.underline?.style === "none") attrs.underline = "none";
+	if (formatting?.color?.auto === true) attrs.color = "auto";
+	if (formatting?.highlight === "none") attrs.highlight = "none";
+	if (formatting?.shading?.pattern === "nil") attrs.shading = {
+		...formatting.shading,
+		pattern: "nil"
+	};
+	if (formatting?.strike !== void 0) attrs.strike = formatting.strike;
+	if (formatting?.doubleStrike === false) attrs.doubleStrike = false;
+	if (formatting?.vertAlign === "baseline") attrs.vertAlign = "baseline";
+	if (formatting?.allCaps !== void 0) attrs.allCaps = formatting.allCaps;
+	if (formatting?.smallCaps !== void 0) attrs.smallCaps = formatting.smallCaps;
+	if (formatting?.hidden !== void 0) attrs.hidden = formatting.hidden;
+	if (formatting?.emboss !== void 0) attrs.emboss = formatting.emboss;
+	if (formatting?.imprint !== void 0) attrs.imprint = formatting.imprint;
+	if (formatting?.shadow !== void 0) attrs.shadow = formatting.shadow;
+	if (formatting?.outline !== void 0) attrs.outline = formatting.outline;
+	if (formatting?.spacing === 0) attrs.spacing = 0;
+	if (formatting?.position === 0) attrs.position = 0;
+	if (formatting?.scale === 100) attrs.scale = 100;
+	if (formatting?.kerning === 0) attrs.kerning = 0;
+	if (formatting?.emphasisMark === "none") attrs.emphasisMark = "none";
+	if (formatting?.effect === "none") attrs.effect = "none";
+	if (formatting?.rtl === false) attrs.rtl = false;
+	if (formatting?.boldCs !== void 0) attrs.boldCs = formatting.boldCs;
+	if (formatting?.italicCs !== void 0) attrs.italicCs = formatting.italicCs;
+	if (formatting?.fontSizeCs !== void 0) attrs.fontSizeCs = formatting.fontSizeCs;
+	if (formatting?.cs !== void 0) attrs.cs = formatting.cs;
+	const provenance = options ?? {
+		type: "authored-baseline",
+		formatting
+	};
+	if (provenance.type === "structural-only") return Object.keys(attrs).length > 0 ? attrs : void 0;
+	const authoredFormatting = provenance.formatting;
+	const hasAuthoredFormatting = Object.entries(authoredFormatting ?? {}).some(([property, value]) => property !== "styleId" && value !== void 0);
+	if (Object.keys(attrs).length === 0 && !hasAuthoredFormatting) return;
+	const withProvenance = withAuthoredRunFormatting(attrs, authoredFormatting);
+	return Object.keys(withProvenance).length > 0 ? withProvenance : void 0;
 }
 function applyRunFormattingOverrideAttrs(formatting, attrs) {
 	if (attrs.bold !== void 0) formatting.bold = attrs.bold;
 	if (attrs.italic !== void 0) formatting.italic = attrs.italic;
 	if (attrs.underline === "none") formatting.underline = { style: "none" };
+	if (attrs.color === "auto") formatting.color = { auto: true };
+	if (attrs.highlight === "none") formatting.highlight = "none";
+	if (attrs.shading?.pattern === "nil") formatting.shading = attrs.shading;
 	if (attrs.strike !== void 0) formatting.strike = attrs.strike;
 	if (attrs.doubleStrike === false) formatting.doubleStrike = false;
+	if (attrs.vertAlign === "baseline") formatting.vertAlign = "baseline";
 	if (attrs.allCaps !== void 0) formatting.allCaps = attrs.allCaps;
 	if (attrs.smallCaps !== void 0) formatting.smallCaps = attrs.smallCaps;
 	if (attrs.hidden !== void 0) formatting.hidden = attrs.hidden;
@@ -36,6 +62,12 @@ function applyRunFormattingOverrideAttrs(formatting, attrs) {
 	if (attrs.imprint !== void 0) formatting.imprint = attrs.imprint;
 	if (attrs.shadow !== void 0) formatting.shadow = attrs.shadow;
 	if (attrs.outline !== void 0) formatting.outline = attrs.outline;
+	if (attrs.spacing === 0) formatting.spacing = 0;
+	if (attrs.position === 0) formatting.position = 0;
+	if (attrs.scale === 100) formatting.scale = 100;
+	if (attrs.kerning === 0) formatting.kerning = 0;
+	if (attrs.emphasisMark === "none") formatting.emphasisMark = "none";
+	if (attrs.effect === "none") formatting.effect = "none";
 	if (attrs.rtl === false) formatting.rtl = false;
 	if (attrs.boldCs !== void 0) formatting.boldCs = attrs.boldCs;
 	if (attrs.italicCs !== void 0) formatting.italicCs = attrs.italicCs;
@@ -50,12 +82,22 @@ const RunFormattingOverrideExtension = createMarkExtension({
 	schemaMarkName: "runFormattingOverride",
 	markSpec: {
 		attrs: {
+			_authoredOn: { default: null },
+			_authoredOff: { default: null },
+			_authoredValues: { default: null },
 			directFontProperties: { default: null },
+			complexScriptPropertyAbsences: { default: null },
+			color: { default: null },
 			bold: { default: null },
 			italic: { default: null },
 			underline: { default: null },
 			strike: { default: null },
 			doubleStrike: { default: null },
+			effect: { default: null },
+			emphasisMark: { default: null },
+			highlight: { default: null },
+			kerning: { default: null },
+			position: { default: null },
 			allCaps: { default: null },
 			smallCaps: { default: null },
 			hidden: { default: null },
@@ -64,10 +106,14 @@ const RunFormattingOverrideExtension = createMarkExtension({
 			shadow: { default: null },
 			outline: { default: null },
 			rtl: { default: null },
+			scale: { default: null },
+			shading: { default: null },
+			spacing: { default: null },
 			boldCs: { default: null },
 			italicCs: { default: null },
 			fontSizeCs: { default: null },
-			cs: { default: null }
+			cs: { default: null },
+			vertAlign: { default: null }
 		},
 		toDOM(mark) {
 			const attrs = expectRunFormattingOverrideMarkAttrs(mark);

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -4,6 +4,13 @@ import { Mark, MarkType, Schema } from "prosemirror-model";
 //#region src/prosemirror/extensions/marks/markUtils.d.ts
 type MarkAttrs = Record<string, unknown>;
 declare function setMark(markType: MarkType, attrs: MarkAttrs): Command;
+type PairedToggleProperty = "bold" | "italic";
+/** UI toggle whose direct-formatting contract explicitly targets both script families. */
+declare const toggleMarkForAllScripts: (markType: MarkType, property: PairedToggleProperty) => Command;
+/** UI size command whose direct-formatting contract explicitly targets both script families. */
+declare const setFontSizeForAllScripts: (markType: MarkType, size: number) => Command;
+/** Clears both ordinary and complex-script direct size through the UI command boundary. */
+declare const clearFontSizeForAllScripts: (markType: MarkType) => Command;
 declare function toggleUnderlineMark(markType: MarkType): Command;
 declare function removeMark(markType: MarkType): Command;
 /**
@@ -31,4 +38,4 @@ declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string,
  */
 declare function createRemoveMarkCommand(markType: MarkType): Command;
 //#endregion
-export { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setMark, textFormattingToMarks, toggleUnderlineMark };
+export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };