@stll/folio-core 0.47.7 → 0.49.0

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

@@ -375,23 +375,16 @@ function getMarkAttr(state, markType, attr) {
 	});
 	return value;
 }
-const addDirectFontProvenance = (marks, schema, directFormatting) => {
+const withDirectFontProvenance = (attrs, directFormatting) => {
 	const directFontProperties = [];
 	if (directFormatting?.fontFamily !== void 0) directFontProperties.push("fontFamily");
 	if (directFormatting?.fontSize !== void 0) directFontProperties.push("fontSize");
 	if (directFormatting?.color !== void 0) directFontProperties.push("color");
-	if (directFontProperties.length === 0) return;
-	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
-	const existing = index >= 0 ? marks.at(index) : void 0;
-	const override = schema.mark("runFormattingOverride", {
-		...existing?.attrs,
+	if (directFontProperties.length === 0) return attrs;
+	return {
+		...attrs,
 		directFontProperties
-	});
-	if (index >= 0) {
-		marks[index] = override;
-		return;
-	}
-	marks.push(override);
+	};
 };
 const COMPLEX_SCRIPT_MIRRORS = [
 	{
@@ -407,25 +400,19 @@ const COMPLEX_SCRIPT_MIRRORS = [
 		complex: "fontSizeCs"
 	}
 ];
-const addComplexScriptAbsenceProvenance = (marks, schema, directFormatting) => {
+const withComplexScriptAbsenceProvenance = (attrs, directFormatting) => {
 	const absent = COMPLEX_SCRIPT_MIRRORS.filter(({ ordinary, complex }) => directFormatting?.[ordinary] !== void 0 && directFormatting[complex] === void 0).map(({ complex }) => complex);
-	if (absent.length === 0) return;
-	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
-	const existing = index >= 0 ? marks.at(index) : void 0;
-	const existingAbsences = new Set(existing?.attrs["complexScriptPropertyAbsences"] ?? []);
+	if (absent.length === 0) return attrs;
+	const existingAbsences = new Set(attrs?.complexScriptPropertyAbsences ?? []);
 	for (const property of absent) existingAbsences.add(property);
-	const override = schema.mark("runFormattingOverride", {
-		...existing?.attrs,
+	return {
+		...attrs,
 		complexScriptPropertyAbsences: COMPLEX_SCRIPT_RUN_PROPERTY_KEYS.filter((property) => existingAbsences.has(property))
-	});
-	if (index >= 0) {
-		marks[index] = override;
-		return;
-	}
-	marks.push(override);
+	};
 };
 function textFormattingToMarks(formatting, schema, options) {
 	if (!formatting) return [];
+	const createMark = options?.createMark ?? ((type, attrs) => schema.mark(type, attrs));
 	const marks = [];
 	const overrideFormatting = options ? options.overrideFormatting : formatting;
 	let overrideAttrs;
@@ -435,25 +422,24 @@ function textFormattingToMarks(formatting, schema, options) {
 		formatting: options.directFormatting
 	});
 	else overrideAttrs = buildRunFormattingOverrideAttrs(overrideFormatting);
-	if (overrideAttrs) marks.push(schema.mark("runFormattingOverride", overrideAttrs));
-	if (formatting.bold) marks.push(schema.mark("bold"));
-	if (formatting.italic) marks.push(schema.mark("italic"));
-	if (formatting.underline && formatting.underline.style !== "none") marks.push(schema.mark("underline", {
+	if (formatting.bold) marks.push(createMark("bold"));
+	if (formatting.italic) marks.push(createMark("italic"));
+	if (formatting.underline && formatting.underline.style !== "none") marks.push(createMark("underline", {
 		style: formatting.underline.style,
 		color: formatting.underline.color
 	}));
-	if (formatting.strike || formatting.doubleStrike) marks.push(schema.mark("strike", { double: formatting.doubleStrike || false }));
-	if (formatting.color && !formatting.color.auto) marks.push(schema.mark("textColor", {
+	if (formatting.strike || formatting.doubleStrike) marks.push(createMark("strike", { double: formatting.doubleStrike || false }));
+	if (formatting.color && !formatting.color.auto) marks.push(createMark("textColor", {
 		rgb: formatting.color.rgb,
 		themeColor: formatting.color.themeColor,
 		themeTint: formatting.color.themeTint,
 		themeShade: formatting.color.themeShade
 	}));
-	if (formatting.highlight && formatting.highlight !== "none") marks.push(schema.mark("highlight", { color: formatting.highlight }));
+	if (formatting.highlight && formatting.highlight !== "none") marks.push(createMark("highlight", { color: formatting.highlight }));
 	const runShadingMarkAttrs = shadingToRunShadingAttrs(formatting.shading);
-	if (runShadingMarkAttrs) marks.push(schema.mark("runShading", runShadingMarkAttrs));
-	if (formatting.fontSize) marks.push(schema.mark("fontSize", { size: formatting.fontSize }));
-	if (formatting.fontFamily) marks.push(schema.mark("fontFamily", {
+	if (runShadingMarkAttrs) marks.push(createMark("runShading", runShadingMarkAttrs));
+	if (formatting.fontSize) marks.push(createMark("fontSize", { size: formatting.fontSize }));
+	if (formatting.fontFamily) marks.push(createMark("fontFamily", {
 		ascii: formatting.fontFamily.ascii,
 		hAnsi: formatting.fontFamily.hAnsi,
 		eastAsia: formatting.fontFamily.eastAsia,
@@ -464,31 +450,33 @@ function textFormattingToMarks(formatting, schema, options) {
 		eastAsiaTheme: formatting.fontFamily.eastAsiaTheme,
 		csTheme: formatting.fontFamily.csTheme
 	}));
-	if (formatting.language) marks.push(schema.mark("language", formatting.language));
-	if (formatting.vertAlign === "superscript") marks.push(schema.mark("superscript"));
-	else if (formatting.vertAlign === "subscript") marks.push(schema.mark("subscript"));
-	if (formatting.allCaps) marks.push(schema.mark("allCaps"));
-	if (formatting.smallCaps) marks.push(schema.mark("smallCaps"));
+	if (formatting.language) marks.push(createMark("language", formatting.language));
+	if (formatting.vertAlign === "superscript") marks.push(createMark("superscript"));
+	else if (formatting.vertAlign === "subscript") marks.push(createMark("subscript"));
+	if (formatting.allCaps) marks.push(createMark("allCaps"));
+	if (formatting.smallCaps) marks.push(createMark("smallCaps"));
 	const spacing = typeof formatting.spacing === "number" ? formatting.spacing : null;
 	const position = typeof formatting.position === "number" ? formatting.position : null;
 	const scale = normalizeHorizontalScalePercent(formatting.scale) ?? null;
 	const kerning = typeof formatting.kerning === "number" ? formatting.kerning : null;
-	if (spacing !== null || position !== null || scale !== null || kerning !== null) marks.push(schema.mark("characterSpacing", {
+	if (spacing !== null || position !== null || scale !== null || kerning !== null) marks.push(createMark("characterSpacing", {
 		spacing,
 		position,
 		scale,
 		kerning
 	}));
-	if (formatting.hidden === true) marks.push(schema.mark("hidden"));
-	if (formatting.emboss) marks.push(schema.mark("emboss"));
-	if (formatting.imprint) marks.push(schema.mark("imprint"));
-	if (formatting.shadow) marks.push(schema.mark("textShadow"));
-	if (formatting.emphasisMark && formatting.emphasisMark !== "none") marks.push(schema.mark("emphasisMark", { type: formatting.emphasisMark }));
-	if (formatting.outline) marks.push(schema.mark("textOutline"));
-	if (formatting.rtl) marks.push(schema.mark("rtl"));
-	if (formatting.effect && formatting.effect !== "none") marks.push(schema.mark("textEffect", { effect: formatting.effect }));
-	addDirectFontProvenance(marks, schema, options?.directFormatting);
-	if (options?.authoredCarrier === "preserve") addComplexScriptAbsenceProvenance(marks, schema, options.directFormatting);
+	if (formatting.hidden === true) marks.push(createMark("hidden"));
+	if (formatting.emboss) marks.push(createMark("emboss"));
+	if (formatting.imprint) marks.push(createMark("imprint"));
+	if (formatting.shadow) marks.push(createMark("textShadow"));
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") marks.push(createMark("emphasisMark", { type: formatting.emphasisMark }));
+	if (formatting.outline) marks.push(createMark("textOutline"));
+	if (formatting.rtl) marks.push(createMark("rtl"));
+	if (formatting.effect && formatting.effect !== "none") marks.push(createMark("textEffect", { effect: formatting.effect }));
+	let provenanceAttrs = withDirectFontProvenance(overrideAttrs, options?.directFormatting);
+	if (options?.authoredCarrier === "preserve") provenanceAttrs = withComplexScriptAbsenceProvenance(provenanceAttrs, options.directFormatting);
+	if (overrideAttrs) marks.unshift(createMark("runFormattingOverride", provenanceAttrs));
+	else if (provenanceAttrs) marks.push(createMark("runFormattingOverride", provenanceAttrs));
 	return marks;
 }
 /**

package/dist/prosemirror/extensions/nodes/FieldExtension.js

@@ -9,7 +9,8 @@ const createFieldAttrs = () => ({
 	_numberedRefBaseline: { default: void 0 },
 	fieldKind: { default: "simple" },
 	fldLock: { default: null },
-	dirty: { default: null }
+	dirty: { default: null },
+	fieldResultIsFallback: { default: null }
 });
 /** A `data-` flag a pasted field carried: absent states nothing. */
 const statedFlag = (value) => value === void 0 ? null : value === "true";
@@ -19,10 +20,11 @@ const readFieldDomAttrs = (dom) => ({
 	displayText: dom.textContent ?? "",
 	fieldKind: dom.dataset["fieldKind"] ?? "simple",
 	fldLock: statedFlag(dom.dataset["fldLock"]),
-	dirty: statedFlag(dom.dataset["dirty"])
+	dirty: statedFlag(dom.dataset["dirty"]),
+	fieldResultIsFallback: statedFlag(dom.dataset["fieldResultIsFallback"])
 });
 const getFieldDomAttrs = (node) => {
-	const { fieldType, instruction, fieldKind, fldLock, dirty } = expectFieldAttrs(node);
+	const { fieldType, instruction, fieldKind, fldLock, dirty, fieldResultIsFallback } = expectFieldAttrs(node);
 	return {
 		class: `docx-field docx-field-${fieldType.toLowerCase()}`,
 		"data-field-type": fieldType,
@@ -30,6 +32,7 @@ const getFieldDomAttrs = (node) => {
 		"data-field-kind": fieldKind,
 		...fldLock === void 0 ? {} : { "data-fld-lock": String(fldLock) },
 		...dirty === void 0 ? {} : { "data-dirty": String(dirty) },
+		...fieldResultIsFallback === void 0 ? {} : { "data-field-result-is-fallback": String(fieldResultIsFallback) },
 		style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
 	};
 };

package/dist/prosemirror/extensions/nodes/SdtExtension.js

@@ -54,7 +54,13 @@ const SdtExtension = createNodeExtension({
 			* `w:sdtEndPr` as a record, so a control the editor rebuilds still
 			* writes its end mark once the captured bytes are gone.
 			*/
-			endProperties: { default: null }
+			endProperties: { default: null },
+			/**
+			* The revisions whose element encloses the control (`w:ins > w:sdt`),
+			* as opposed to revising the content inside it (`w:sdt > w:ins`). Both
+			* put the same marks on the leaves; see `contentControlRevisions.ts`.
+			*/
+			_docxEnclosingRevisionIds: { default: null }
 		},
 		parseDOM: [{
 			tag: "span.docx-sdt",
@@ -78,7 +84,8 @@ const SdtExtension = createNodeExtension({
 					checked: onOffFromDataset(el.dataset["checked"]),
 					_preserved: null,
 					rawEndPropertiesXml: null,
-					endProperties: null
+					endProperties: null,
+					_docxEnclosingRevisionIds: null
 				};
 			}
 		}],

package/dist/prosemirror/extensions/nodes/ShapeExtension.js

@@ -370,6 +370,7 @@ const ShapeExtension = createNodeExtension({
 			shapeType: { default: "rect" },
 			geometryAdjustments: { default: null },
 			_docxRunFormatting: { default: null },
+			_docxAlternateContent: { default: null },
 			shapeId: { default: null },
 			shapeName: { default: null },
 			alt: { default: null },

package/dist/prosemirror/extensions/nodes/TextBoxExtension.js

@@ -86,6 +86,7 @@ const TextBoxExtension = createNodeExtension({
 			alt: { default: null },
 			title: { default: null },
 			fillColor: { default: null },
+			gradientFill: { default: null },
 			outlineWidth: { default: null },
 			outlineColor: { default: null },
 			outlineStyle: { default: null },
@@ -111,13 +112,16 @@ const TextBoxExtension = createNodeExtension({
 			wrapDistanceSlots: { default: null },
 			wrapEffectExtentSlots: { default: null },
 			wrapPolygon: { default: null },
+			_docxAlternateContent: { default: null },
 			_docxPlacement: { default: null },
 			_docxGroupId: { default: null },
 			_docxAnchorId: { default: null },
+			_docxGroupChild: { default: null },
 			_docxTextBodyContentState: { default: { type: "authored" } },
 			_docxTrackedChange: { default: null },
 			_docxInlineSdts: { default: null },
-			_preservedAttributes: { default: null }
+			_preservedAttributes: { default: null },
+			_docxHostParagraph: { default: null }
 		},
 		parseDOM: [{
 			tag: "div.docx-textbox",

package/dist/prosemirror/listMarker.d.ts

@@ -58,6 +58,7 @@ declare const CLEARED_LIST_RENDERING_ATTRS: Readonly<{
   listMarkerSecondSlotOffsetTwips: null;
   listLevelNumFmts: null;
   listLevelStarts: null;
+  listLevelTabs: null;
   listAbstractNumId: null;
   listStartOverride: null;
 }>;

package/dist/prosemirror/listMarker.js

@@ -1,4 +1,4 @@
-import { convertBulletToUnicode } from "../docx/bulletMarkers.js";
+import { bulletMarkerFontName, convertBulletToUnicode } from "../docx/bulletMarkers.js";
 import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
 import { formatOoxmlCounter } from "../docx/ooxmlCounterFormatter.js";
 import { isListNumPr } from "../layout-engine/types.js";
@@ -20,6 +20,7 @@ const CLEARED_LIST_RENDERING_ATTRS = Object.freeze({
 	listMarkerSecondSlotOffsetTwips: null,
 	listLevelNumFmts: null,
 	listLevelStarts: null,
+	listLevelTabs: null,
 	listAbstractNumId: null,
 	listStartOverride: null
 });
@@ -84,6 +85,7 @@ function previousListAttrs(attrs) {
 		...previous.listMarkerSecondSlotOffsetTwips !== void 0 ? { listMarkerSecondSlotOffsetTwips: previous.listMarkerSecondSlotOffsetTwips } : {},
 		...previous.listLevelNumFmts !== void 0 ? { listLevelNumFmts: previous.listLevelNumFmts } : {},
 		...previous.listLevelStarts !== void 0 ? { listLevelStarts: previous.listLevelStarts } : {},
+		...previous.listLevelTabs !== void 0 ? { listLevelTabs: previous.listLevelTabs } : {},
 		...previous.listAbstractNumId !== void 0 ? { listAbstractNumId: previous.listAbstractNumId } : {},
 		...previous.listStartOverride !== void 0 ? { listStartOverride: previous.listStartOverride } : {}
 	};
@@ -203,7 +205,7 @@ function advanceListMarker(attrs, state) {
 			fromStyle: false,
 			numId: null
 		};
-		return convertBulletToUnicode(attrs.listMarker ?? markerTemplate ?? "");
+		return convertBulletToUnicode(attrs.listMarker ?? markerTemplate ?? "", bulletMarkerFontName(attrs.listMarkerFormatting));
 	}
 	const firstInstanceEncounter = !state.counters.has(numId);
 	let counters = state.counters.get(numId) ?? Array.from({ length: 9 }, () => NaN);

package/dist/prosemirror/listRenderingAttrs.d.ts

@@ -14,6 +14,7 @@ declare const LIST_RENDERING_ATTR_BY_FIELD: {
   readonly markerAlignment: "listMarkerAlignment";
   readonly markerAllCaps: "listMarkerAllCaps";
   readonly markerSuffix: "listMarkerSuffix";
+  readonly levelTabs: "listLevelTabs";
   readonly levelNumFmts: "listLevelNumFmts";
   readonly levelStarts: "listLevelStarts";
   readonly abstractNumId: "listAbstractNumId";

package/dist/prosemirror/listRenderingAttrs.js

@@ -20,6 +20,7 @@ const LIST_RENDERING_ATTR_BY_FIELD = {
 	markerAlignment: "listMarkerAlignment",
 	markerAllCaps: "listMarkerAllCaps",
 	markerSuffix: "listMarkerSuffix",
+	levelTabs: "listLevelTabs",
 	levelNumFmts: "listLevelNumFmts",
 	levelStarts: "listLevelStarts",
 	abstractNumId: "listAbstractNumId",
@@ -48,6 +49,7 @@ const listRenderingAttrPatch = (rendering) => {
 		listMarkerAlignment: rendering.markerAlignment || void 0,
 		listMarkerAllCaps: rendering.markerAllCaps || void 0,
 		listMarkerSuffix: rendering.markerSuffix || void 0,
+		listLevelTabs: rendering.levelTabs?.length ? rendering.levelTabs : void 0,
 		listLevelNumFmts: rendering.levelNumFmts || void 0,
 		listLevelStarts: rendering.levelStarts || void 0,
 		listAbstractNumId: rendering.abstractNumId,
@@ -71,6 +73,7 @@ const listRenderingFromAttrs = ({ attrs, numId }) => {
 		markerAlignment: attrs.listMarkerAlignment ?? void 0,
 		markerAllCaps: attrs.listMarkerAllCaps ?? void 0,
 		markerSuffix: attrs.listMarkerSuffix ?? void 0,
+		levelTabs: attrs.listLevelTabs ?? void 0,
 		levelNumFmts: attrs.listLevelNumFmts ?? void 0,
 		levelStarts: attrs.listLevelStarts ?? void 0,
 		abstractNumId: attrs.listAbstractNumId ?? void 0,

package/dist/prosemirror/paragraphDirection.d.ts

@@ -15,6 +15,17 @@
  * The persisted/serialized model keeps the flat OOXML tri-state
  * (`ParagraphFormatting.bidi: boolean | undefined`); `directionToBidi` /
  * `directionFromBidi` bridge the two at the conversion boundary.
+ *
+ * `source: "auto"` is a *rendering* decision only — it makes the layout
+ * painter and the editor's DOM shape the paragraph RTL, so newly typed or
+ * pasted directional text displays correctly before the user ever makes an
+ * explicit choice. It must never reach the saved package on its own: a
+ * paragraph that arrived without `w:bidi` and was never touched by the user
+ * must save without `w:bidi` too, no matter how many auto-detection passes
+ * ran over it on load. Only `source: "manual"` (an explicit user toggle, or
+ * a `w:bidi` the source document already carried) is authored content and
+ * belongs in `w:pPr`. Use `directionToBidi` for layout/rendering and
+ * `directionToAuthoredBidi` for anything that gets serialized.
  */
 type ParagraphDirection = {
   source: "auto";
@@ -29,8 +40,24 @@ declare const directionIsRtl: (direction: ParagraphDirection | null | undefined)
  * AutoBidiDetection may (re-)evaluate. A manual decision is left untouched.
  */
 declare const directionIsAutoManaged: (direction: ParagraphDirection | null | undefined) => boolean;
-/** Map a direction to the serialized OOXML `w:bidi` tri-state. */
+/**
+ * Map a direction to the OOXML `w:bidi` tri-state for layout/rendering: an
+ * auto-detected direction lays out RTL exactly like a manual one. Do not use
+ * this to decide what gets written to the saved package — see
+ * `directionToAuthoredBidi`.
+ */
 declare const directionToBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
+/**
+ * Map a direction to the OOXML `w:bidi` tri-state as *authored* content, for
+ * serialization. Only a manual decision (explicit user toggle, or a `w:bidi`
+ * the source document already carried) is ever written: `undefined` here
+ * means "the paragraph does not state its own direction," which keeps
+ * `w:pPr` free of a flag the user never asked for. An auto-detected
+ * direction (`source: "auto"`) resolves to `undefined` — same as undecided —
+ * regardless of which way detection currently leans, so it stays a view-only
+ * aid until the user makes it explicit.
+ */
+declare const directionToAuthoredBidi: (direction: ParagraphDirection | null | undefined) => boolean | undefined;
 /**
  * Reconstruct a direction from a model `bidi` value (DOCX import / load): an
  * explicit `true`/`false` is a manual decision, absence is undecided.
@@ -39,4 +66,4 @@ declare const directionFromBidi: (bidi: boolean | null | undefined) => Paragraph
 /** Runtime guard for the PM attribute validator. */
 declare const isParagraphDirection: (value: unknown) => value is ParagraphDirection;
 //#endregion
-export { ParagraphDirection, directionFromBidi, directionIsAutoManaged, directionIsRtl, directionToBidi, isParagraphDirection };
+export { ParagraphDirection, directionFromBidi, directionIsAutoManaged, directionIsRtl, directionToAuthoredBidi, directionToBidi, isParagraphDirection };

package/dist/prosemirror/paragraphDirection.js

@@ -6,13 +6,32 @@ const directionIsRtl = (direction) => direction?.source === "auto" || direction?
 * AutoBidiDetection may (re-)evaluate. A manual decision is left untouched.
 */
 const directionIsAutoManaged = (direction) => direction == null || direction.source === "auto";
-/** Map a direction to the serialized OOXML `w:bidi` tri-state. */
+/**
+* Map a direction to the OOXML `w:bidi` tri-state for layout/rendering: an
+* auto-detected direction lays out RTL exactly like a manual one. Do not use
+* this to decide what gets written to the saved package — see
+* `directionToAuthoredBidi`.
+*/
 const directionToBidi = (direction) => {
 	if (direction == null) return;
 	if (direction.source === "auto") return true;
 	return direction.value === "rtl";
 };
 /**
+* Map a direction to the OOXML `w:bidi` tri-state as *authored* content, for
+* serialization. Only a manual decision (explicit user toggle, or a `w:bidi`
+* the source document already carried) is ever written: `undefined` here
+* means "the paragraph does not state its own direction," which keeps
+* `w:pPr` free of a flag the user never asked for. An auto-detected
+* direction (`source: "auto"`) resolves to `undefined` — same as undecided —
+* regardless of which way detection currently leans, so it stays a view-only
+* aid until the user makes it explicit.
+*/
+const directionToAuthoredBidi = (direction) => {
+	if (direction == null || direction.source === "auto") return;
+	return direction.value === "rtl";
+};
+/**
 * Reconstruct a direction from a model `bidi` value (DOCX import / load): an
 * explicit `true`/`false` is a manual decision, absence is undecided.
 */
@@ -30,4 +49,4 @@ const isParagraphDirection = (value) => {
 	return value.source === "manual" && "value" in value && (value.value === "rtl" || value.value === "ltr");
 };
 //#endregion
-export { directionFromBidi, directionIsAutoManaged, directionIsRtl, directionToBidi, isParagraphDirection };
+export { directionFromBidi, directionIsAutoManaged, directionIsRtl, directionToAuthoredBidi, directionToBidi, isParagraphDirection };

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,7 +1,9 @@
+import { encloseWholeControls } from "../contentControlRevisions.js";
 import { splitBlockClearBorders } from "../extensions/features/BaseKeymapExtension.js";
 import { handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
+import { Mapping } from "prosemirror-transform";
 import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
 import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/plugins/suggestionMode.ts
@@ -87,6 +89,12 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 	});
 	if (ranges.length === 0) return;
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+	encloseWholeControls({
+		tr,
+		from: tr.mapping.map(from),
+		to: tr.mapping.map(to, -1),
+		revisionId: delAttrs.revisionId
+	});
 	for (let i = ranges.length - 1; i >= 0; i--) {
 		const range = ranges[i];
 		if (range.isOwnInsert) tr.delete(range.from, range.to);
@@ -107,6 +115,12 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 		if (start >= end) return;
 		tr.addMark(start, end, insertionType.create(attrs));
 	});
+	encloseWholeControls({
+		tr,
+		from,
+		to,
+		revisionId: attrs.revisionId
+	});
 }
 /**
 * With track changes on, pasting over a non-empty text selection marks the
@@ -439,16 +453,31 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			const tr = newState.tr;
 			tr.setMeta(SUGGESTION_META, true);
 			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 (!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);
-						tr.addMark(nodeStart, nodeEnd, insertionType.create(markAttrs));
+			const laterMaps = transactions.slice(transactions.indexOf(userTr) + 1).flatMap((transaction) => transaction.mapping.maps);
+			for (const [stepIndex, step] of userTr.steps.entries()) {
+				const stepMap = step.getMap();
+				const following = new Mapping([...userTr.mapping.maps.slice(stepIndex + 1), ...laterMaps]);
+				stepMap.forEach((_oldFrom, _oldTo, stepFrom, stepTo) => {
+					const newFrom = following.map(stepFrom, -1);
+					const newTo = following.map(stepTo, 1);
+					if (newTo > newFrom) {
+						newState.doc.nodesBetween(newFrom, newTo, (node, pos) => {
+							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);
+								tr.addMark(nodeStart, nodeEnd, insertionType.create(markAttrs));
+							}
+						});
+						encloseWholeControls({
+							tr,
+							from: newFrom,
+							to: newTo,
+							revisionId: markAttrs.revisionId
+						});
 					}
 				});
-			});
+			}
 			return tr.steps.length > 0 ? tr : null;
 		}
 	});

package/dist/prosemirror/rejoinRunCarriers.d.ts

@@ -0,0 +1,27 @@
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
+import { Transaction } from "prosemirror-state";
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/rejoinRunCarriers.d.ts
+type ContinuedRunMarksOptions = {
+  left: Node;
+  right: Node;
+  /** The paragraph's run style context, read only when the marks differ in formatting alone. */
+  context: () => ParagraphRunStyleContext;
+  styleResolver: RunStyleResolver | null;
+};
+/**
+ * The marks `right` takes to continue `left`'s run, or `null` when the two
+ * already share their marks or write different runs: another mark differs,
+ * or the formatting they state does.
+ */
+declare const continuedRunMarks: ({ left, right, context, styleResolver }: ContinuedRunMarksOptions) => readonly Mark[] | null;
+type RejoinRunsAtOptions = {
+  tr: Transaction;
+  /** Positions in `tr.doc` where resolved content began or ended. */
+  boundaries: Iterable<number>;
+  styleResolver: RunStyleResolver | null;
+};
+/** Rejoin the runs meeting at each of `boundaries`, left to right. */
+declare const rejoinRunsAt: ({ tr, boundaries, styleResolver }: RejoinRunsAtOptions) => void;
+//#endregion
+export { continuedRunMarks, rejoinRunsAt };

package/dist/prosemirror/rejoinRunCarriers.js

@@ -0,0 +1,66 @@
+import { formattingEquals } from "../docx/runConsolidator.js";
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { readAuthoredRunFormatting } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/rejoinRunCarriers.ts
+/**
+* Rejoin a run that resolving a revision left split.
+*
+* A revision splits the run it cuts into (`w:r`, `w:del > w:r`, `w:r`), and a
+* run-property change rewrites the formatting marks of the piece it covers.
+* Once the revision is resolved the pieces write the same `w:rPr`, but the
+* editor can hold that formatting on different mark carriers (a restored
+* `w:rPrChange` is rebuilt from its `w:rPr`), and leaves with different marks
+* are written as different runs. At a resolved boundary, a leaf that writes
+* the same run as the leaf before it takes that leaf's marks, so the two are
+* one run again.
+*
+* Leaves the source wrote as separate runs keep them apart: a run identity
+* (`runIdentity`) differs between them, and it is compared, not rewritten.
+* The pieces of one run read back from a saved redline share an identity
+* (`runIdentityAcrossRevisions.ts`).
+*/
+const isFormattingMark = (mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name);
+/**
+* The marks `right` takes to continue `left`'s run, or `null` when the two
+* already share their marks or write different runs: another mark differs,
+* or the formatting they state does.
+*/
+const continuedRunMarks = ({ left, right, context, styleResolver }) => {
+	if (!left.isText || !right.isText || Mark.sameSet(left.marks, right.marks)) return null;
+	const otherMarks = (node) => node.marks.filter((mark) => !isFormattingMark(mark));
+	if (!Mark.sameSet(otherMarks(left), otherMarks(right))) return null;
+	const paragraphContext = context();
+	const stated = (node) => readAuthoredRunFormatting({
+		context: paragraphContext,
+		marks: node.marks,
+		styleResolver
+	});
+	return formattingEquals(stated(left), stated(right)) ? left.marks : null;
+};
+/** Rejoin the runs meeting at each of `boundaries`, left to right. */
+const rejoinRunsAt = ({ tr, boundaries, styleResolver }) => {
+	for (const boundary of [...new Set(boundaries)].toSorted((left, right) => left - right)) {
+		if (boundary <= 0 || boundary >= tr.doc.content.size) continue;
+		const at = tr.doc.resolve(boundary);
+		const { nodeBefore: left, nodeAfter: right } = at;
+		if (!left || !right || !at.parent.inlineContent) continue;
+		const marks = continuedRunMarks({
+			left,
+			right,
+			context: () => paragraphRunStyleContextAt({
+				doc: tr.doc,
+				pos: boundary,
+				styleResolver
+			}),
+			styleResolver
+		});
+		if (marks === null) continue;
+		const to = boundary + right.nodeSize;
+		for (const mark of right.marks) if (!mark.isInSet(marks)) tr.removeMark(boundary, to, mark);
+		for (const mark of marks) if (!mark.isInSet(right.marks)) tr.addMark(boundary, to, mark);
+	}
+};
+//#endregion
+export { continuedRunMarks, rejoinRunsAt };

package/dist/prosemirror/runIdentityAcrossRevisions.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/runIdentityAcrossRevisions.d.ts
+/**
+ * `nodes`, one inline container's content, with each run a revision cut given
+ * the identity of the run it was cut from. A control is a container of its
+ * own. `nodes` itself comes back when nothing changes.
+ */
+declare const continueRunIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
+//#endregion
+export { continueRunIdentitiesAcrossRevisions };