@stll/folio-core 0.35.1 → 0.37.0

package/dist/prosemirror/pageBreakRunProjection.js

@@ -0,0 +1,47 @@
+import { expectParagraphAttrs } from "./attrs/index.js";
+//#region src/prosemirror/pageBreakRunProjection.ts
+const PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES = {
+	borders: "A bordered paragraph containing an explicit page-break run cannot be projected",
+	frame: "A framed paragraph containing an explicit page-break run cannot be projected",
+	outline: "An outline paragraph containing an explicit page-break run cannot be projected",
+	textBoxAnchor: "A paragraph containing both an explicit page-break run and a text-box anchor cannot be projected"
+};
+/** Keep source-import and ProseMirror-layout ownership decisions on one predicate. */
+const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiveFrame, hasTextBoxAnchor }) => {
+	if (effectiveFrame !== void 0 && effectiveFrame.dropCap !== "drop" && effectiveFrame.dropCap !== "margin") return {
+		status: "unsupported",
+		reason: "frame",
+		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.frame
+	};
+	if (attrs.outlineLevel !== void 0) return {
+		status: "unsupported",
+		reason: "outline",
+		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.outline
+	};
+	if (attrs.borders !== void 0 && Object.values(attrs.borders).some((border) => border !== void 0)) return {
+		status: "unsupported",
+		reason: "borders",
+		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.borders
+	};
+	if (hasTextBoxAnchor) return {
+		status: "unsupported",
+		reason: "textBoxAnchor",
+		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.textBoxAnchor
+	};
+	return { status: "supported" };
+};
+const pageBreakRunParagraphProjectionDisposition = (paragraph) => {
+	const attrs = expectParagraphAttrs(paragraph);
+	let hasTextBoxAnchor = false;
+	paragraph.descendants((descendant) => {
+		hasTextBoxAnchor ||= descendant.type.name === "textBoxAnchor";
+		return !hasTextBoxAnchor;
+	});
+	return pageBreakRunParagraphProjectionDispositionForFeatures({
+		attrs,
+		effectiveFrame: attrs._originalFormatting?.frame,
+		hasTextBoxAnchor
+	});
+};
+//#endregion
+export { pageBreakRunParagraphProjectionDisposition, pageBreakRunParagraphProjectionDispositionForFeatures };

package/dist/prosemirror/paraText.js

@@ -53,7 +53,12 @@ function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
 	if (!searchText) return null;
 	let fullText = "";
 	const textPositions = [];
+	const structuralBoundaryOffsets = [];
 	doc.nodesBetween(paragraphFrom, paragraphTo, (node, pos) => {
+		if (node.type.name === "pageBreakRun") {
+			structuralBoundaryOffsets.push(fullText.length);
+			return false;
+		}
 		if (node.marks.some((m) => m.type.name === "insertion")) return false;
 		if (node.isText && node.text) {
 			textPositions.push({
@@ -81,6 +86,7 @@ function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
 	if (firstMatch === -1) return null;
 	if (fullText.indexOf(searchText, firstMatch + 1) !== -1) return null;
 	const matchEnd = firstMatch + searchText.length;
+	if (structuralBoundaryOffsets.some((offset) => offset > firstMatch && offset < matchEnd)) return null;
 	let segmentStart = 0;
 	for (const position of textPositions) {
 		const segmentEnd = segmentStart + position.text.length;

package/dist/prosemirror/paragraphAlignment.d.ts

@@ -0,0 +1,12 @@
+import { document_d_exports } from "../types/document.js";
+import { ParagraphAttrs } from "./schema/nodes.js";
+//#region src/prosemirror/paragraphAlignment.d.ts
+/**
+ * Read the authored paragraph-level `w:jc`, independently of the effective
+ * alignment used for layout. Imported and command-authored paragraphs carry
+ * explicit provenance; the final branch covers PM-created content whose
+ * effective value is observably different from its style.
+ */
+declare const directParagraphAlignment: (attrs: ParagraphAttrs) => document_d_exports.ParagraphAlignment | undefined;
+//#endregion
+export { directParagraphAlignment };

package/dist/prosemirror/paragraphAlignment.js

@@ -0,0 +1,13 @@
+//#region src/prosemirror/paragraphAlignment.ts
+/**
+* Read the authored paragraph-level `w:jc`, independently of the effective
+* alignment used for layout. Imported and command-authored paragraphs carry
+* explicit provenance; the final branch covers PM-created content whose
+* effective value is observably different from its style.
+*/
+const directParagraphAlignment = (attrs) => {
+	if (attrs._originalFormatting?.alignment != null) return attrs._originalFormatting.alignment;
+	if (attrs.alignment != null && attrs.alignment !== attrs.alignmentFromStyle) return attrs.alignment;
+};
+//#endregion
+export { directParagraphAlignment };

package/dist/prosemirror/paragraphSpacing.d.ts

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

package/dist/prosemirror/paragraphSpacing.js

@@ -0,0 +1,125 @@
+import { autospacingMatchesBase, hasAutospacingBaseSide, setAutospacingBaseValue } from "./autospacingBase.js";
+//#region src/prosemirror/paragraphSpacing.ts
+/** The complete modeled attribute set of one direct `w:pPr/w:spacing`. */
+const DIRECT_PARAGRAPH_SPACING_KEYS = [
+	"spaceBefore",
+	"spaceAfter",
+	"lineSpacing",
+	"lineSpacingRule",
+	"beforeAutospacing",
+	"afterAutospacing"
+];
+const lineSpacingProvenanceFromSpacing = (spacing) => {
+	const hasValue = spacing?.lineSpacing !== void 0;
+	const hasRule = spacing?.lineSpacingRule !== void 0;
+	if (hasValue && hasRule) return "both";
+	if (hasValue) return "value";
+	return hasRule ? "rule" : void 0;
+};
+/** Resolve exact provenance, including editor states written with the former boolean marker. */
+const lineSpacingProvenance = (attrs) => {
+	if (typeof attrs.lineSpacingExplicit === "string") return attrs.lineSpacingExplicit;
+	const original = paragraphSpacingFromFormatting(attrs._originalFormatting);
+	const originalProvenance = lineSpacingProvenanceFromSpacing(original);
+	if (originalProvenance !== void 0 || attrs.lineSpacingExplicit !== true) return originalProvenance;
+	return lineSpacingProvenanceFromSpacing({
+		...typeof attrs.lineSpacing === "number" ? { lineSpacing: attrs.lineSpacing } : {},
+		...attrs.lineSpacingRule !== void 0 ? { lineSpacingRule: attrs.lineSpacingRule } : {}
+	});
+};
+/** Project only authored `w:spacing` attributes, preserving explicit zero and false. */
+const paragraphSpacingFromFormatting = (formatting) => {
+	if (!formatting) return;
+	const spacing = {
+		...formatting.spaceBefore !== void 0 ? { spaceBefore: formatting.spaceBefore } : {},
+		...formatting.spaceAfter !== void 0 ? { spaceAfter: formatting.spaceAfter } : {},
+		...formatting.lineSpacing !== void 0 ? { lineSpacing: formatting.lineSpacing } : {},
+		...formatting.lineSpacingRule !== void 0 ? { lineSpacingRule: formatting.lineSpacingRule } : {},
+		...formatting.beforeAutospacing !== void 0 ? { beforeAutospacing: formatting.beforeAutospacing } : {},
+		...formatting.afterAutospacing !== void 0 ? { afterAutospacing: formatting.afterAutospacing } : {}
+	};
+	return Object.keys(spacing).length > 0 ? spacing : void 0;
+};
+/**
+* Read direct spacing independently of the effective values used for layout.
+* Imported and command-authored paragraphs keep their source in
+* `_originalFormatting`; explicit PM attrs cover newly created content.
+*/
+const directParagraphSpacing = (attrs) => {
+	const spacing = paragraphSpacingFromFormatting(attrs._originalFormatting) ?? {};
+	const lineProvenance = lineSpacingProvenance(attrs);
+	const spaceBefore = attrs.spaceBefore;
+	const spaceAfter = attrs.spaceAfter;
+	const beforeHasBase = hasAutospacingBaseSide(attrs._autospacingBase, "before");
+	const afterHasBase = hasAutospacingBaseSide(attrs._autospacingBase, "after");
+	const beforeAutospacingEdited = beforeHasBase ? !autospacingMatchesBase(attrs._autospacingBase, "before", spaceBefore) : spacing.beforeAutospacing === true && attrs._autospacingBase == null;
+	const afterAutospacingEdited = afterHasBase ? !autospacingMatchesBase(attrs._autospacingBase, "after", spaceAfter) : spacing.afterAutospacing === true && attrs._autospacingBase == null;
+	if (beforeAutospacingEdited) {
+		spacing.beforeAutospacing = false;
+		if (typeof spaceBefore === "number") spacing.spaceBefore = spaceBefore;
+		else Reflect.deleteProperty(spacing, "spaceBefore");
+	}
+	if (afterAutospacingEdited) {
+		spacing.afterAutospacing = false;
+		if (typeof spaceAfter === "number") spacing.spaceAfter = spaceAfter;
+		else Reflect.deleteProperty(spacing, "spaceAfter");
+	}
+	if (spacing.spaceBefore !== void 0 || attrs.spacingExplicit?.before === true) if (typeof spaceBefore === "number") spacing.spaceBefore = spaceBefore;
+	else Reflect.deleteProperty(spacing, "spaceBefore");
+	if (spacing.spaceAfter !== void 0 || attrs.spacingExplicit?.after === true) if (typeof spaceAfter === "number") spacing.spaceAfter = spaceAfter;
+	else Reflect.deleteProperty(spacing, "spaceAfter");
+	if (lineProvenance === "value" || lineProvenance === "both") if (typeof attrs.lineSpacing === "number") spacing.lineSpacing = attrs.lineSpacing;
+	else Reflect.deleteProperty(spacing, "lineSpacing");
+	else Reflect.deleteProperty(spacing, "lineSpacing");
+	if (lineProvenance === "rule" || lineProvenance === "both") if (attrs.lineSpacingRule !== void 0) spacing.lineSpacingRule = attrs.lineSpacingRule;
+	else Reflect.deleteProperty(spacing, "lineSpacingRule");
+	else Reflect.deleteProperty(spacing, "lineSpacingRule");
+	return Object.keys(spacing).length > 0 ? spacing : void 0;
+};
+/** Structural equality for the canonical, fixed-order spacing projection. */
+const paragraphSpacingEqual = (left, right) => (left?.spaceBefore ?? null) === (right?.spaceBefore ?? null) && (left?.spaceAfter ?? null) === (right?.spaceAfter ?? null) && (left?.lineSpacing ?? null) === (right?.lineSpacing ?? null) && (left?.lineSpacingRule ?? null) === (right?.lineSpacingRule ?? null) && (left?.beforeAutospacing ?? null) === (right?.beforeAutospacing ?? null) && (left?.afterAutospacing ?? null) === (right?.afterAutospacing ?? null);
+/** Replace the complete direct `w:spacing` cluster in canonical formatting. */
+const withDirectParagraphSpacing = (formatting, spacing) => {
+	const result = { ...formatting };
+	for (const key of DIRECT_PARAGRAPH_SPACING_KEYS) Reflect.deleteProperty(result, key);
+	Reflect.deleteProperty(result, "spacingExplicit");
+	if (spacing) {
+		Object.assign(result, spacing);
+		const spacingExplicit = {
+			...spacing.spaceBefore !== void 0 ? { before: true } : {},
+			...spacing.spaceAfter !== void 0 ? { after: true } : {}
+		};
+		if (Object.keys(spacingExplicit).length > 0) result.spacingExplicit = spacingExplicit;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+};
+/** Project direct-over-inherited spacing into the attrs consumed by layout. */
+const paragraphSpacingAttrPatch = ({ direct, inherited }) => {
+	const effective = {
+		...inherited,
+		...direct
+	};
+	const spacingExplicit = {
+		...direct?.spaceBefore !== void 0 ? { before: true } : {},
+		...direct?.spaceAfter !== void 0 ? { after: true } : {}
+	};
+	const spacingFromStyle = {
+		...direct?.spaceBefore === void 0 && inherited?.spaceBefore !== void 0 ? { before: true } : {},
+		...direct?.spaceAfter === void 0 && inherited?.spaceAfter !== void 0 ? { after: true } : {}
+	};
+	const autospacingBase = {};
+	if (effective.beforeAutospacing === true) setAutospacingBaseValue(autospacingBase, "before", effective.spaceBefore);
+	if (effective.afterAutospacing === true) setAutospacingBaseValue(autospacingBase, "after", effective.spaceAfter);
+	return {
+		spaceBefore: effective.spaceBefore ?? null,
+		spaceAfter: effective.spaceAfter ?? null,
+		lineSpacing: effective.lineSpacing ?? null,
+		lineSpacingRule: effective.lineSpacingRule ?? null,
+		lineSpacingExplicit: lineSpacingProvenanceFromSpacing(direct) ?? null,
+		spacingExplicit: Object.keys(spacingExplicit).length > 0 ? spacingExplicit : null,
+		spacingFromImplicitDefaultStyle: Object.keys(spacingFromStyle).length > 0 ? spacingFromStyle : null,
+		_autospacingBase: Object.keys(autospacingBase).length > 0 ? autospacingBase : null
+	};
+};
+//#endregion
+export { DIRECT_PARAGRAPH_SPACING_KEYS, directParagraphSpacing, lineSpacingProvenanceFromSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqual, paragraphSpacingFromFormatting, withDirectParagraphSpacing };

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

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../../types/document.js";
+import { NumberingMap } from "../../docx/numberingParser.js";
+import { EditorState, Plugin } from "prosemirror-state";
+//#region src/prosemirror/plugins/documentNumbering.d.ts
+declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+declare const getDocumentNumbering: (state: EditorState) => NumberingMap | null;
+//#endregion
+export { createDocumentNumberingPlugin, getDocumentNumbering };

package/dist/prosemirror/plugins/documentNumbering.js

@@ -0,0 +1,18 @@
+import { getCachedNumberingMap } from "../../docx/numberingParser.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/documentNumbering.ts
+/** Document-scoped numbering definitions for list-editing commands. */
+const documentNumberingKey = new PluginKey("documentNumbering");
+const createDocumentNumberingPlugin = (definitions) => {
+	const numbering = definitions ? getCachedNumberingMap(definitions) : null;
+	return new Plugin({
+		key: documentNumberingKey,
+		state: {
+			init: () => numbering,
+			apply: (_transaction, value) => value
+		}
+	});
+};
+const getDocumentNumbering = (state) => documentNumberingKey.getState(state) ?? null;
+//#endregion
+export { createDocumentNumberingPlugin, getDocumentNumbering };

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

@@ -9,8 +9,9 @@ type TextChunk = {
 };
 /**
  * Collect every block-level node's text content as an array of
- * chunks (one per PM text node), grouped per block. Join a block's
- * chunk texts to scan it as a single string.
+ * chunks (one per PM text node), grouped per uninterrupted scan segment.
+ * An explicit page-break run ends a segment: it is zero-width in the joined
+ * text, but a text-shaped overlay must not select across that structural atom.
  */
 declare const collectBlockChunks: (doc: Node) => TextChunk[][];
 /** Map a joined-string offset back to its PM doc position. */

package/dist/prosemirror/plugins/pmTextScan.js

@@ -1,15 +1,25 @@
 //#region src/prosemirror/plugins/pmTextScan.ts
 /**
 * Collect every block-level node's text content as an array of
-* chunks (one per PM text node), grouped per block. Join a block's
-* chunk texts to scan it as a single string.
+* chunks (one per PM text node), grouped per uninterrupted scan segment.
+* An explicit page-break run ends a segment: it is zero-width in the joined
+* text, but a text-shaped overlay must not select across that structural atom.
 */
 const collectBlockChunks = (doc) => {
 	const blocks = [];
 	doc.descendants((node, pos) => {
 		if (node.isTextblock) {
-			const chunks = [];
+			let chunks = [];
+			const flushSegment = () => {
+				if (chunks.length === 0) return;
+				blocks.push(chunks);
+				chunks = [];
+			};
 			node.descendants((child, offset) => {
+				if (child.type.name === "pageBreakRun") {
+					flushSegment();
+					return false;
+				}
 				if (child.isText && child.text !== void 0) {
 					const start = pos + 1 + offset;
 					chunks.push({
@@ -30,7 +40,7 @@ const collectBlockChunks = (doc) => {
 				}
 				return true;
 			});
-			if (chunks.length > 0) blocks.push(chunks);
+			flushSegment();
 			return false;
 		}
 		return true;

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,7 +1,8 @@
 import { splitBlockClearBorders } from "../extensions/features/BaseKeymapExtension.js";
+import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
-import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/plugins/suggestionMode.ts
 /**
 * Suggestion Mode Plugin
@@ -71,7 +72,7 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState) {
 	const ranges = [];
 	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText && !(node.isInline && node.type.allowsMarkType(deletionType))) return;
+		if (!canCarryTrackedRunMark(node)) return;
 		const start = Math.max(pos, from);
 		const end = Math.min(pos + node.nodeSize, to);
 		if (start >= end) return;
@@ -92,16 +93,13 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 	}
 }
 /**
-* Add the insertion mark to every inline node in `[from, to)` that can carry
-* it and does not already carry a tracked-change mark. Mirrors the catch-all's
-* node-by-node walk: a leaf text node's own `markSet` is empty so
-* `allowsMarkType` is false, hence the explicit `isText` arm; content already
-* carrying an insertion/deletion is left untouched so another author's revision
-* isn't overwritten. eigenpal/docx-editor#784.
+* Add the insertion mark to every run carrier in `[from, to)` that does not
+* already carry a tracked-change mark. Content already carrying a revision is
+* left untouched so another author's attribution is not overwritten.
 */
 function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, attrs) {
 	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText && !(node.isInline && node.type.allowsMarkType(insertionType))) return;
+		if (!canCarryTrackedRunMark(node)) return;
 		if (node.marks.some((m) => m.type === insertionType || m.type === deletionType)) return;
 		const start = Math.max(pos, from);
 		const end = Math.min(pos + node.nodeSize, to);
@@ -289,7 +287,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const deleteEnd = isBackward ? $from.pos : $from.pos + 1;
 	if (deletePos < 0 || deleteEnd > state.doc.content.size) return true;
 	const nodeAfter = state.doc.resolve(deletePos).nodeAfter;
-	if (!nodeAfter || !(nodeAfter.isText || nodeAfter.isInline && nodeAfter.type.allowsMarkType(deletionType))) return false;
+	if (!nodeAfter || !canCarryTrackedRunMark(nodeAfter)) return false;
 	const hasOwnInsertion = nodeAfter.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
 	if (nodeAfter.marks.some((m) => m.type === deletionType)) {
 		const newPos = isBackward ? deletePos : deleteEnd;
@@ -449,7 +447,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			const deletionType = newState.schema.marks["deletion"];
 			for (const step of userTr.steps) step.getMap().forEach((_oldFrom, _oldTo, newFrom, newTo) => {
 				if (newTo > newFrom) newState.doc.nodesBetween(newFrom, newTo, (node, pos) => {
-					if (!node.isText && !(node.isInline && node.type.allowsMarkType(insertionType))) return;
+					if (!canCarryTrackedRunMark(node)) return;
 					if (!node.marks.some((m) => m.type === insertionType || deletionType && m.type === deletionType)) {
 						const nodeStart = Math.max(pos, newFrom);
 						const nodeEnd = Math.min(pos + node.nodeSize, newTo);

package/dist/prosemirror/rebaseParagraphRunFormatting.d.ts

@@ -0,0 +1,16 @@
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/rebaseParagraphRunFormatting.d.ts
+type RebaseParagraphRunFormattingOptions = {
+  nextAttrs: Record<string, unknown>;
+  paragraphPosition: number;
+  styleResolver: RunStyleResolver;
+  tr: Transaction;
+};
+/**
+ * Change paragraph attrs and re-resolve inherited run marks in the new style
+ * context without turning the old rendered style into direct run formatting.
+ */
+declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
+//#endregion
+export { setParagraphAttrsWithRebasedRunFormatting };

package/dist/prosemirror/rebaseParagraphRunFormatting.js

@@ -0,0 +1,61 @@
+import { expandRunFormattingCarrier } from "./runFormattingInlineCarriers.js";
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { panic } from "better-result";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/rebaseParagraphRunFormatting.ts
+/**
+* Change paragraph attrs and re-resolve inherited run marks in the new style
+* context without turning the old rendered style into direct run formatting.
+*/
+const setParagraphAttrsWithRebasedRunFormatting = ({ nextAttrs, paragraphPosition, styleResolver, tr }) => {
+	const paragraph = tr.doc.nodeAt(paragraphPosition);
+	if (!paragraph || paragraph.type.name !== "paragraph") return panic("Cannot rebase run formatting outside a paragraph", {
+		nodeType: paragraph?.type.name,
+		paragraphPosition
+	});
+	const previousContext = paragraphRunStyleContext(paragraph, styleResolver);
+	const nextContext = paragraphRunStyleContext(paragraph.type.create(nextAttrs, paragraph.content, paragraph.marks), styleResolver);
+	const changes = [];
+	const collectRebasedRepresentation = ({ node, position }) => {
+		const nextMarks = reconcileRunFormattingMarks({
+			authoredFormatting: readAuthoredRunFormatting({
+				context: previousContext,
+				marks: node.marks,
+				styleResolver
+			}),
+			context: nextContext,
+			node,
+			styleResolver
+		});
+		if (Mark.sameSet(node.marks, nextMarks)) return;
+		changes.push({
+			attrs: node.attrs,
+			currentFormattingMarks: node.marks.filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)),
+			from: position,
+			isText: node.isText,
+			marks: nextMarks,
+			to: position + node.nodeSize
+		});
+	};
+	paragraph.descendants((node, relativePosition) => {
+		if (!node.isInline) return true;
+		const carrier = expandRunFormattingCarrier(node, paragraphPosition + 1 + relativePosition);
+		if (!carrier) return !node.isAtom;
+		for (const representation of carrier.representations) collectRebasedRepresentation(representation);
+		return false;
+	});
+	tr = tr.setNodeMarkup(paragraphPosition, void 0, nextAttrs);
+	for (const { attrs, currentFormattingMarks, from, isText, marks, to } of changes) {
+		if (!isText) {
+			tr = tr.setNodeMarkup(from, void 0, attrs, marks);
+			continue;
+		}
+		for (const mark of currentFormattingMarks) tr = tr.removeMark(from, to, mark.type);
+		for (const mark of marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr = tr.addMark(from, to, mark);
+	}
+	return tr;
+};
+//#endregion
+export { setParagraphAttrsWithRebasedRunFormatting };

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -0,0 +1,64 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/runFormattingInlineCarriers.d.ts
+type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
+/**
+ * How every inline atom maps to a serialized run-formatting carrier.
+ *
+ * This is intentionally separate from tracked wrapper ownership: drawings and
+ * bookmarks can sit inside an insertion/deletion wrapper, but their editor
+ * marks do not serialize as run properties. The runtime fixed-point test binds
+ * this map to the complete schema atom set.
+ */
+declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
+  readonly bookmarkBoundary: "not-a-run";
+  readonly field: "field-run";
+  readonly hardBreak: "break-run";
+  readonly image: "not-a-run";
+  readonly math: "not-a-run";
+  readonly pageBreakRun: "page-break-carrier";
+  readonly renderedPageBreak: "not-a-run";
+  readonly shape: "not-a-run";
+  readonly structuredField: "structured-field";
+  readonly symbol: "symbol-run";
+  readonly tab: "tab-run";
+  readonly text: "text-run";
+  readonly textBoxAnchor: "not-a-run";
+}>;
+declare const runFormattingInlineAtomDisposition: (node: Node) => RunFormattingInlineAtomDisposition | null;
+type RunFormattingCarrierRepresentation = {
+  node: Node;
+  position: number;
+  role: "owner" | "serialized-result";
+};
+type RunFormattingCarrier = {
+  disposition: Exclude<RunFormattingInlineAtomDisposition, "not-a-run">;
+  node: Node;
+  position: number;
+  representations: readonly RunFormattingCarrierRepresentation[];
+};
+type SelectedRunFormattingCarrierRepresentation = RunFormattingCarrierRepresentation & {
+  carrierDisposition: RunFormattingCarrier["disposition"];
+  from: number;
+  to: number;
+};
+/**
+ * Expand one logical carrier into every editor node that materializes its run
+ * properties. A structured field is owned by its outer atom, while its result
+ * runs are derived representations needed by the package serializer.
+ */
+declare const expandRunFormattingCarrier: (node: Node, position: number) => RunFormattingCarrier | null;
+type SelectRunFormattingCarrierRepresentationsOptions = {
+  doc: Node;
+  from: number;
+  to: number;
+};
+/**
+ * Resolve a document range to the exact editor nodes that serialize run
+ * properties. The result is shared by every formatting mutation so preflight,
+ * direct edits, and tracked edits cannot disagree about ownership.
+ */
+declare const selectRunFormattingCarrierRepresentations: ({ doc, from, to }: SelectRunFormattingCarrierRepresentationsOptions) => SelectedRunFormattingCarrierRepresentation[];
+/** Deterministic visible text for one logical formatting revision carrier. */
+declare const runFormattingCarrierReviewText: (carrier: RunFormattingCarrier) => string;
+//#endregion
+export { RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS, RunFormattingCarrier, RunFormattingCarrierRepresentation, RunFormattingInlineAtomDisposition, SelectedRunFormattingCarrierRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomDisposition, selectRunFormattingCarrierRepresentations };

package/dist/prosemirror/runFormattingInlineCarriers.js

@@ -0,0 +1,121 @@
+import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
+import { expectFieldAttrs, expectSymbolAttrs } from "./attrs/index.js";
+import { panic } from "better-result";
+//#region src/prosemirror/runFormattingInlineCarriers.ts
+/**
+* How every inline atom maps to a serialized run-formatting carrier.
+*
+* This is intentionally separate from tracked wrapper ownership: drawings and
+* bookmarks can sit inside an insertion/deletion wrapper, but their editor
+* marks do not serialize as run properties. The runtime fixed-point test binds
+* this map to the complete schema atom set.
+*/
+const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS = Object.freeze({
+	bookmarkBoundary: "not-a-run",
+	field: "field-run",
+	hardBreak: "break-run",
+	image: "not-a-run",
+	math: "not-a-run",
+	pageBreakRun: "page-break-carrier",
+	renderedPageBreak: "not-a-run",
+	shape: "not-a-run",
+	structuredField: "structured-field",
+	symbol: "symbol-run",
+	tab: "tab-run",
+	text: "text-run",
+	textBoxAnchor: "not-a-run"
+});
+const dispositionsByName = new Map(Object.entries(RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS));
+const runFormattingInlineAtomDisposition = (node) => {
+	if (!node.isInline || !node.isAtom) return null;
+	const disposition = dispositionsByName.get(node.type.name);
+	if (!disposition) return panic(`Inline atom ${JSON.stringify(node.type.name)} has no run-formatting disposition`);
+	return disposition;
+};
+/**
+* Expand one logical carrier into every editor node that materializes its run
+* properties. A structured field is owned by its outer atom, while its result
+* runs are derived representations needed by the package serializer.
+*/
+const expandRunFormattingCarrier = (node, position) => {
+	const disposition = runFormattingInlineAtomDisposition(node);
+	if (disposition === null || disposition === "not-a-run") return null;
+	if (disposition !== "structured-field") return {
+		disposition,
+		node,
+		position,
+		representations: [{
+			node,
+			position,
+			role: "owner"
+		}]
+	};
+	const representations = [{
+		node,
+		position,
+		role: "owner"
+	}];
+	node.descendants((child, relativePosition) => {
+		const childDisposition = runFormattingInlineAtomDisposition(child);
+		if (childDisposition === null) return true;
+		if (childDisposition === "structured-field") return panic("A structured field cannot contain another structured field");
+		if (childDisposition !== "not-a-run") representations.push({
+			node: child,
+			position: position + 1 + relativePosition,
+			role: "serialized-result"
+		});
+		return false;
+	});
+	return {
+		disposition,
+		node,
+		position,
+		representations
+	};
+};
+/**
+* Resolve a document range to the exact editor nodes that serialize run
+* properties. The result is shared by every formatting mutation so preflight,
+* direct edits, and tracked edits cannot disagree about ownership.
+*/
+const selectRunFormattingCarrierRepresentations = ({ doc, from, to }) => {
+	const selected = [];
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isInline) return true;
+		const carrier = expandRunFormattingCarrier(node, position);
+		if (!carrier) return !node.isAtom;
+		if (carrier.disposition === "page-break-carrier") return false;
+		for (const representation of carrier.representations) {
+			if (runFormattingInlineAtomDisposition(representation.node) === "page-break-carrier") continue;
+			const representationFrom = Math.max(from, representation.position);
+			const representationTo = Math.min(to, representation.position + representation.node.nodeSize);
+			if (representationFrom >= representationTo) continue;
+			if (carrier.disposition === "structured-field" && representation.role === "owner" && (representationFrom !== representation.position || representationTo !== representation.position + representation.node.nodeSize)) continue;
+			selected.push({
+				...representation,
+				carrierDisposition: carrier.disposition,
+				from: representationFrom,
+				to: representationTo
+			});
+		}
+		return false;
+	});
+	return selected;
+};
+/** Deterministic visible text for one logical formatting revision carrier. */
+const runFormattingCarrierReviewText = (carrier) => {
+	switch (carrier.disposition) {
+		case "text-run": return carrier.node.text ?? "";
+		case "tab-run": return "	";
+		case "break-run": return "\n";
+		case "page-break-carrier": return "";
+		case "symbol-run": {
+			const { char } = expectSymbolAttrs(carrier.node);
+			return decodeOoxmlSymbolCharacter(char) ?? "�";
+		}
+		case "field-run":
+		case "structured-field": return expectFieldAttrs(carrier.node).displayText ?? carrier.node.textContent;
+	}
+};
+//#endregion
+export { RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS, expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomDisposition, selectRunFormattingCarrierRepresentations };