@stll/folio-core 0.36.0 → 0.37.1

package/dist/prosemirror/commands/comments.js

@@ -1,13 +1,19 @@
+import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionResolution.js";
+import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
 import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
-import { textFormattingToMarks } from "../conversion/toProseDoc.js";
-import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
+import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
+import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
+import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
+import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { TableMap, removeRow } from "prosemirror-tables";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
@@ -56,7 +62,7 @@ function removeCommentMark(commentId) {
 * the operation matches every revision mark or property-change entry in the
 * range (the bulk accept-all/reject-all path).
 */
-function resolveChange(from, to, mode, revisionIds) {
+function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 	return (state, dispatch) => {
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
@@ -65,6 +71,7 @@ function resolveChange(from, to, mode, revisionIds) {
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
 		const removeKeptMarksInBulk = revisionSet === null && keepType !== void 0;
+		const canBulkInlineResolution = execution === "headless-bulk-inline" && revisionSet === null && from === 0 && to === state.doc.content.size && stateAllowsHeadlessRevisionResolution(state);
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
@@ -72,6 +79,8 @@ function resolveChange(from, to, mode, revisionIds) {
 			const pPrMarkOps = [];
 			const tableRowStructuralOps = [];
 			const tableCellStructuralOps = [];
+			let removedSectionEndpointCount = 0;
+			const removedSectionReferences = [];
 			state.doc.nodesBetween(from, to, (node, pos) => {
 				if (node.type.name === "paragraph") {
 					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
@@ -92,9 +101,14 @@ function resolveChange(from, to, mode, revisionIds) {
 								_propertyChanges: remaining.length > 0 ? remaining : null
 							};
 							if (rejection?.type === "restore-previous") {
-								const previousAlignmentFromStyle = styleResolver ? styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting?.alignment : expectParagraphAttrs(node).alignmentFromStyle;
-								Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousAlignmentFromStyle));
-								nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+								const inheritedAlignment = expectParagraphAttrs(node).alignmentFromStyle;
+								let previousFormattingFromStyle;
+								if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting;
+								else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
+								Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousFormattingFromStyle));
+								const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+								nextAttrs["_originalFormatting"] = restoredFormatting;
+								if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;
 							}
 						}
 					}
@@ -113,7 +127,13 @@ function resolveChange(from, to, mode, revisionIds) {
 							nextAttrs["sectionBreakType"] = sectionBreakTypeFromSectionStart(restored.sectionStart);
 						}
 					}
-					if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
+					if (nextAttrs) if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
+						nextAttrs,
+						paragraphPosition: pos,
+						styleResolver,
+						tr
+					});
+					else tr.setNodeMarkup(pos, void 0, nextAttrs);
 					return true;
 				}
 				if (node.type.name === "tableRow" && rangeCoversNode(from, to, pos, node)) {
@@ -125,15 +145,20 @@ function resolveChange(from, to, mode, revisionIds) {
 				if (tableChangeAttrName !== void 0) {
 					if (rangeCoversNode(from, to, pos, node)) {
 						const nextAttrs = resolveTablePropertyChangeAttrs(node, tableChangeAttrName, mode, revisionSet);
-						if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
+						if (nextAttrs) {
+							tr.setNodeMarkup(pos, void 0, nextAttrs);
+							markStructuralChange(tr);
+						}
 					}
 					return true;
 				}
 				if (!node.isInline) return true;
+				if (canBulkInlineResolution) return true;
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
+				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -141,9 +166,10 @@ function resolveChange(from, to, mode, revisionIds) {
 					to: rangeTo,
 					mark: runPropertyChangeMark,
 					mode,
-					revisionSet
+					revisionSet,
+					styleResolver
 				});
-				if (removeType && node.marks.some((m) => m.type === removeType && matchesRevision(m))) deleteRanges.push({
+				if (removesNode) deleteRanges.push({
 					from: rangeFrom,
 					to: rangeTo
 				});
@@ -152,24 +178,34 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				return true;
 			});
-			if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
-			let rangesToDelete = deleteRanges;
-			if (revisionSet === null) {
-				const coalescedDeleteRanges = [];
-				for (const range of deleteRanges) {
-					const previous = coalescedDeleteRanges.at(-1);
-					if (previous && range.from <= previous.to) {
-						previous.to = Math.max(previous.to, range.to);
-						continue;
+			let bulkInlineChangeTracking = null;
+			if (canBulkInlineResolution) bulkInlineChangeTracking = appendHeadlessInlineResolution({
+				tr,
+				mode,
+				keepType,
+				removeType,
+				styleResolver
+			});
+			else {
+				if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
+				let rangesToDelete = deleteRanges;
+				if (revisionSet === null) {
+					const coalescedDeleteRanges = [];
+					for (const range of deleteRanges) {
+						const previous = coalescedDeleteRanges.at(-1);
+						if (previous && range.from <= previous.to) {
+							previous.to = Math.max(previous.to, range.to);
+							continue;
+						}
+						coalescedDeleteRanges.push({
+							from: range.from,
+							to: range.to
+						});
 					}
-					coalescedDeleteRanges.push({
-						from: range.from,
-						to: range.to
-					});
+					rangesToDelete = coalescedDeleteRanges;
 				}
-				rangesToDelete = coalescedDeleteRanges;
+				for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
 			}
-			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
 			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
 			for (const op of pPrMarkOps) {
 				const mappedPos = tr.mapping.map(op.paragraphPos);
@@ -181,35 +217,34 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				const joinPos = mappedPos + paragraph.nodeSize;
 				const nextNode = joinPos < tr.doc.content.size ? tr.doc.nodeAt(joinPos) : null;
-				if (!(nextNode?.type.name === paragraph.type.name && !(carriesSection(paragraph) && carriesSection(nextNode)))) {
+				if (!(nextNode?.type.name === paragraph.type.name)) {
 					const resolved = tr.doc.resolve(mappedPos);
-					const previous = resolved.nodeBefore;
-					const sectionCanMoveBack = !carriesSection(paragraph) || previous?.type.name === paragraph.type.name && !carriesSection(previous);
 					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
 					const canGo = op.markWasAdded || !endsItsContainer;
-					if (sectionCanMoveBack && holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
-						if (carriesSection(paragraph) && previous) tr.setNodeMarkup(mappedPos - previous.nodeSize, void 0, {
-							...previous.attrs,
-							sectionBreakType: paragraph.attrs["sectionBreakType"],
-							_sectionProperties: paragraph.attrs["_sectionProperties"]
-						});
+					if (holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
+						if (ownsSectionEndpoint(paragraph)) {
+							removedSectionEndpointCount++;
+							removedSectionReferences.push(...sectionReferencesOf(paragraph));
+						}
 						tr.delete(mappedPos, mappedPos + paragraph.nodeSize);
 						continue;
 					}
 					tr.setNodeAttribute(mappedPos, "pPrMark", null);
 					continue;
 				}
-				const formattingOwner = holdsNoContent(paragraph) ? nextNode : paragraph;
-				const sectionOwner = carriesSection(paragraph) ? paragraph : nextNode;
 				const joinedAttrs = {
-					...formattingOwner.attrs,
+					...(holdsNoContent(paragraph) ? nextNode : paragraph).attrs,
 					pPrMark: nextNode.attrs["pPrMark"],
-					sectionBreakType: sectionOwner.attrs["sectionBreakType"],
-					_sectionProperties: sectionOwner.attrs["_sectionProperties"]
+					sectionBreakType: nextNode.attrs["sectionBreakType"],
+					_sectionProperties: nextNode.attrs["_sectionProperties"]
 				};
 				try {
 					tr.join(joinPos);
 					tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
+					if (ownsSectionEndpoint(paragraph)) {
+						removedSectionEndpointCount++;
+						removedSectionReferences.push(...sectionReferencesOf(paragraph));
+					}
 				} catch {}
 			}
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
@@ -259,12 +294,18 @@ function resolveChange(from, to, mode, revisionIds) {
 			}
 			if (failedTableCellMergeResolution) return false;
 			if (resolvedTableCellStructure) markStructuralChange(tr);
+			if (bulkInlineChangeTracking) markChangedParagraphRanges(tr, bulkInlineChangeTracking);
+			if (removedSectionEndpointCount > 0) markTrackedSectionEndpointRemoval(tr, {
+				sourceDoc: state.doc,
+				removedEndpointCount: removedSectionEndpointCount,
+				removedReferences: removedSectionReferences
+			});
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
 	};
 }
-const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet }) => {
+const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet, styleResolver }) => {
 	const { changes } = expectRunPropertyChangeMarkAttrs(mark);
 	const matches = changes.filter((change) => revisionSet === null || revisionSet.has(change.info.id));
 	if (matches.length === 0) return;
@@ -273,15 +314,18 @@ const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet
 	if (remaining.length > 0) tr.addMark(from, to, mark.type.create({ changes: remaining }));
 	if (mode === "accept") return;
 	const previousFormatting = matches.at(0)?.previousFormatting;
+	const styleContext = paragraphRunStyleContextAt({
+		doc: tr.doc,
+		pos: from,
+		styleResolver
+	});
 	for (const currentMark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(currentMark.type.name)) tr.removeMark(from, to, currentMark.type);
-	for (const previousMark of textFormattingToMarks(previousFormatting)) tr.addMark(from, to, previousMark);
-	if (previousFormatting?.styleId) {
-		const characterStyle = node.type.schema.marks["characterStyle"];
-		if (characterStyle) tr.addMark(from, to, characterStyle.create({
-			styleId: previousFormatting.styleId,
-			_styleRPr: null
-		}));
-	}
+	for (const previousMark of reconstructRejectedRunFormattingMarks({
+		node,
+		paragraphContext: styleContext,
+		previousFormatting,
+		styleResolver
+	})) tr.addMark(from, to, previousMark);
 };
 function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
 	for (const attrName of ["trIns", "trDel"]) {
@@ -376,11 +420,33 @@ function deleteTableCellAt(tr, cellPos) {
 	const resolved = tr.doc.resolve(cellPos);
 	const row = resolved.parent;
 	if (row.type.spec["tableRole"] !== "row") return;
+	const tableDepth = resolved.depth - 1;
+	const table = resolved.node(tableDepth);
+	if (table.type.spec["tableRole"] !== "table") return;
+	const tablePosition = resolved.before(tableDepth);
+	const cellOffset = cellPos - resolved.start(tableDepth);
+	const removedColumn = TableMap.get(table).findCell(cellOffset).left;
 	if (row.childCount > 1) {
 		tr.delete(cellPos, cellPos + cell.nodeSize);
+		reconcileTableGridAfterColumnRemoval({
+			tr,
+			tablePosition,
+			previousTable: table,
+			removedColumn
+		});
+		return;
+	}
+	if (table.childCount === 1) {
+		deleteTableRowAt(tr, resolved.start() - 1);
 		return;
 	}
 	deleteTableRowAt(tr, resolved.start() - 1);
+	reconcileTableGridAfterColumnRemoval({
+		tr,
+		tablePosition,
+		previousTable: table,
+		removedColumn
+	});
 }
 function deleteTableRowAt(tr, rowPos) {
 	const resolved = tr.doc.resolve(rowPos);
@@ -487,16 +553,24 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
+const ownsSectionEndpoint = (paragraph) => {
+	const attrs = expectParagraphAttrs(paragraph);
+	return attrs._sectionProperties !== void 0 || attrs.sectionBreakType !== void 0;
+};
+const sectionReferencesOf = (paragraph) => {
+	const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
+	if (!sectionProperties) return [];
+	return [...(sectionProperties.headerReferences ?? []).map(({ type, rId }) => ({
+		part: "header",
+		type,
+		relationshipId: rId
+	})), ...(sectionProperties.footerReferences ?? []).map(({ type, rId }) => ({
+		part: "footer",
+		type,
+		relationshipId: rId
+	}))];
+};
 const isAddedPPrMarkAttr = (value) => isPPrMarkAttr(value) && (value.kind === "ins" || value.kind === "moveTo");
-/**
-* Whether the paragraph's mark carries a section's properties.
-*
-* A section break lives on a paragraph mark, so the paragraph is where the
-* section ends. Removing it removes the section: a document that had two ends
-* up with one, and every setting the dropped section carried — page size,
-* margins, its header and footer references — goes with it.
-*/
-const carriesSection = (paragraph) => paragraph.attrs["sectionBreakType"] != null || paragraph.attrs["_sectionProperties"] != null;
 function readRevisionInfo(info) {
 	const revision = {};
 	if (typeof info?.author === "string") revision.author = info.author;
@@ -574,6 +648,20 @@ function rejectAllChanges() {
 	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
 }
 /**
+* Resolve a complete state synchronously for a headless reader or writer.
+*
+* @internal The replacement transaction is consumed here and never exposed:
+* it is deliberately not an editor command and must not be transported or
+* mapped through concurrent edits.
+*/
+function resolveAllChangesInHeadlessState(state, mode) {
+	let resolvedState = state;
+	resolveChange(0, state.doc.content.size, mode, void 0, "headless-bulk-inline")(state, (transaction) => {
+		resolvedState = state.apply(transaction);
+	});
+	return resolvedState;
+}
+/**
 * Find the document range covered by all revision carriers with any of the
 * given ids. Returns null when none are present (already accepted/rejected, or
 * never existed). A replace operation typically passes two ids; standalone
@@ -965,12 +1053,31 @@ const reauthorParagraphPropertySuggestions = ({ node, matchesSuggestion, author,
 	});
 	return changed ? next : null;
 };
+const canReauthorParagraphPropertySuggestions = (doc, matchesSuggestion) => {
+	let valid = true;
+	doc.descendants((node) => {
+		if (!valid || node.type.name !== "paragraph") return;
+		const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+		if (!Array.isArray(propertyChanges)) return;
+		let serializableCount = 0;
+		for (const change of propertyChanges) {
+			const suggested = readSuggestedParagraphPropertyChange(change);
+			if (!suggested || matchesSuggestion(suggested.suggestionId)) serializableCount++;
+		}
+		if (serializableCount > 1) {
+			valid = false;
+			return false;
+		}
+	});
+	return valid;
+};
 const appendRotatedParagraphPropertyChange = ({ tr, currentPosition, previous, mark, fallbackAuthor }) => {
 	const current = tr.doc.nodeAt(currentPosition);
 	if (!current || current.type.name !== "paragraph") return false;
 	const author = typeof mark.info.author === "string" ? mark.info.author : fallbackAuthor;
 	if (author === void 0) return false;
 	const existing = expectParagraphAttrs(current)._propertyChanges;
+	if (hasSerializableParagraphPropertyChange(existing)) return false;
 	tr.setNodeMarkup(currentPosition, void 0, {
 		...current.attrs,
 		_propertyChanges: [...Array.isArray(existing) ? existing : [], {
@@ -1194,6 +1301,7 @@ const removeSuggestedInsertNodes = ({ tr, positions, resolvedRevisionIds }) => {
 */
 const acceptSuggestions = (matchesSuggestion, options) => {
 	return (state, dispatch) => {
+		if (!canReauthorParagraphPropertySuggestions(state.doc, matchesSuggestion)) return false;
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
 		const runPropertyChangeType = state.schema.marks["runPropertyChange"];
@@ -1547,4 +1655,4 @@ function findPreviousChange(state, startPos) {
 	return result.value;
 }
 //#endregion
-export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark };
+export { acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState };

package/dist/prosemirror/commands/formatPainter.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../../types/document.js";
 import { Command, EditorState } from "prosemirror-state";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/commands/formatPainter.d.ts
@@ -9,22 +10,56 @@ import { Mark } from "prosemirror-model";
  * text direction or hide content, which is surprising for a formatting brush.
  */
 declare const PAINTABLE_MARK_NAMES: ReadonlySet<string>;
+type PaintableFormatting = {
+  allCaps?: document_d_exports.TextFormatting["allCaps"];
+  bold?: document_d_exports.TextFormatting["bold"];
+  boldCs?: document_d_exports.TextFormatting["boldCs"];
+  color?: document_d_exports.TextFormatting["color"];
+  cs?: document_d_exports.TextFormatting["cs"];
+  doubleStrike?: document_d_exports.TextFormatting["doubleStrike"];
+  effect?: document_d_exports.TextFormatting["effect"];
+  emboss?: document_d_exports.TextFormatting["emboss"];
+  emphasisMark?: document_d_exports.TextFormatting["emphasisMark"];
+  fontFamily?: document_d_exports.TextFormatting["fontFamily"];
+  fontSize?: document_d_exports.TextFormatting["fontSize"];
+  fontSizeCs?: document_d_exports.TextFormatting["fontSizeCs"];
+  highlight?: document_d_exports.TextFormatting["highlight"];
+  imprint?: document_d_exports.TextFormatting["imprint"];
+  italic?: document_d_exports.TextFormatting["italic"];
+  italicCs?: document_d_exports.TextFormatting["italicCs"];
+  kerning?: document_d_exports.TextFormatting["kerning"];
+  outline?: document_d_exports.TextFormatting["outline"];
+  position?: document_d_exports.TextFormatting["position"];
+  scale?: document_d_exports.TextFormatting["scale"];
+  shading?: document_d_exports.TextFormatting["shading"];
+  shadow?: document_d_exports.TextFormatting["shadow"];
+  smallCaps?: document_d_exports.TextFormatting["smallCaps"];
+  spacing?: document_d_exports.TextFormatting["spacing"];
+  strike?: document_d_exports.TextFormatting["strike"];
+  underline?: document_d_exports.TextFormatting["underline"];
+  vertAlign?: document_d_exports.TextFormatting["vertAlign"];
+};
+type CapturedTextFormatting = Readonly<{
+  effectiveFormatting: Readonly<PaintableFormatting>;
+  marks: readonly Mark[];
+  type: "capturedTextFormatting";
+}>;
 /**
- * Capture the paintable character marks active over the current selection.
- * Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
- * selection reads the stored/insertion marks; a range reads its leading run.
- * Returns an empty array when the source carries no direct character formatting.
+ * Capture the paintable character formatting active over the current selection.
+ * An empty selection reads the stored/insertion marks; a range reads its leading
+ * run. The discriminated result deliberately represents an effectively plain run:
+ * `null` belongs to the host's “nothing captured” state, not this command.
  */
-declare function captureFormatMarks(state: EditorState): Mark[];
+declare function captureFormatMarks(state: EditorState): CapturedTextFormatting;
 /**
  * Apply captured marks onto the current selection's range: clear every paintable
  * mark type first (replace, not merge — so painting Georgia-12-bold onto
  * Arial-10 leaves only Georgia-12-bold), then lay down the captured marks.
  *
- * Best-effort: a collapsed selection or an empty capture is a no-op (returns
- * false so a keymap binding stays unclaimed and the keystroke passes through).
- * Never throws.
+ * Best-effort: a collapsed selection, no capture, or a target-relative delta
+ * that cannot be represented without guessing document defaults is a no-op.
+ * Returns false so a keymap binding stays unclaimed; never partially mutates.
  */
-declare function applyFormatMarks(marks: readonly Mark[]): Command;
+declare function applyFormatMarks(captured: CapturedTextFormatting | null): Command;
 //#endregion
-export { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };
+export { CapturedTextFormatting, PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };