@stll/folio-core 0.35.1 → 0.37.0

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -1,26 +1,35 @@
 import { numPrEqual } from "../../docx/numberingParser.js";
+import { copyParagraphPropertySource, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceTransferId, linkParagraphPropertySourceCandidate, recreateProseNodeWithParagraphPropertySource } from "../../docx/paragraphPropertySource.js";
+import { visitDocxParagraphs } from "../../docx/paragraphTraversal.js";
 import { ShapeOutlineStyleSchema, narrowEnum } from "../../docx/parserEnums.js";
+import { DATE_UTC_ATTRIBUTE } from "../../docx/trackedChangeInfo.js";
+import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { OUTLINE_STYLE_CSS_ALIASES, normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { pixelsToEmu } from "../../utils/units.js";
-import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
+import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
 import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
 import { expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
-import { applyRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
+import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges } from "../commands/propertyChangeScope.js";
+import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { resolveNumberedRefFields } from "../numberedRefFields.js";
+import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionToBidi } from "../paragraphDirection.js";
+import { directParagraphSpacing } from "../paragraphSpacing.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
+import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "../runFormattingProvenance.js";
+import { paragraphFormattingForRun, paragraphRunStyleContext, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "../runStyleFormatting.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
-import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
-import { runShadingAttrsToShading } from "./runShadingMark.js";
+import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { decodeSdtListItems, sdtPropertiesFromAttrs, sdtPropertiesMatchAttrs } from "./sdtAttrs.js";
 import { textFormattingToMarks } from "./toProseDoc.js";
 import { panic } from "better-result";
-import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 import { Fragment } from "prosemirror-model";
+import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/prosemirror/conversion/fromProseDoc.ts
 /**
 * ProseMirror to Document Conversion
@@ -76,12 +85,68 @@ function textBoxWrapFromAttrs(attrs) {
 	if (attrs.distRight !== void 0) wrap.distR = pixelsToEmu(attrs.distRight);
 	return wrap;
 }
-/**
-* Convert a ProseMirror document to our Document type
-*/
+const assignUniqueParagraph = (paragraphs, paraId, paragraph) => {
+	const existing = paragraphs.get(paraId);
+	if (!paragraphs.has(paraId) || existing === paragraph) {
+		paragraphs.set(paraId, paragraph);
+		return;
+	}
+	paragraphs.set(paraId, null);
+};
+const uniqueParagraphsById = (content, includeTransferIds = false) => {
+	const paragraphs = /* @__PURE__ */ new Map();
+	visitDocxParagraphs({ documentBody: { content } }, (paragraph) => {
+		const { paraId } = paragraph;
+		if (paraId) assignUniqueParagraph(paragraphs, paraId, paragraph);
+		const transferId = includeTransferIds ? getParagraphPropertySourceTransferId(paragraph) : void 0;
+		if (transferId) assignUniqueParagraph(paragraphs, transferId, paragraph);
+	});
+	return paragraphs;
+};
+const restoreParagraphPropertySources = (content, baseContent, linkedTargets, linkedSources) => {
+	const baseParagraphs = uniqueParagraphsById(baseContent, true);
+	for (const [paraId, paragraph] of uniqueParagraphsById(content)) {
+		const baseParagraph = baseParagraphs.get(paraId);
+		if (!paragraph || !baseParagraph || linkedTargets.has(paragraph) || linkedSources.has(baseParagraph) || !getParagraphPropertySource(baseParagraph)) continue;
+		copyParagraphPropertySource(paragraph, baseParagraph);
+		const baseFormatting = baseParagraph.formatting;
+		if (!baseFormatting?.numPr || !baseFormatting.numPrFromStyle || !numPrEqual(baseFormatting.numPr, baseFormatting.numPrFromStyle)) continue;
+		const { numPr, numPrFromStyle, ...authoredFormatting } = baseFormatting;
+		if (canonicalJson(paragraph.formatting ?? {}) !== canonicalJson(authoredFormatting)) continue;
+		paragraph.formatting = {
+			...paragraph.formatting,
+			numPr,
+			numPrFromStyle
+		};
+	}
+};
+const restoreLinkedParagraphPropertySources = (content) => {
+	const targetsBySource = /* @__PURE__ */ new Map();
+	const linkedTargets = /* @__PURE__ */ new Set();
+	visitDocxParagraphs({ documentBody: { content } }, (paragraph) => {
+		const source = getParagraphPropertySourceCandidate(paragraph);
+		if (!source) return;
+		linkedTargets.add(paragraph);
+		const targets = targetsBySource.get(source);
+		if (targets) targets.push(paragraph);
+		else targetsBySource.set(source, [paragraph]);
+	});
+	for (const [source, targets] of targetsBySource) if (targets.length === 1) {
+		const target = targets.at(0);
+		if (target) copyParagraphPropertySource(target, source);
+	}
+	return {
+		targets: linkedTargets,
+		sources: new Set(targetsBySource.keys())
+	};
+};
+/** Convert a ProseMirror document to the document model. */
 function fromProseDoc(pmDoc, baseDocument) {
 	assertValidProseMirrorDocument(pmDoc, "Cannot convert invalid ProseMirror document to DOCX model");
-	const documentBody = { content: extractBlocks(pmDoc) };
+	const blocks = extractBlocks(pmDoc, "resolve", baseDocument?.package.styles ? createStyleEngine(baseDocument.package.styles) : null);
+	const linkedSources = restoreLinkedParagraphPropertySources(blocks);
+	if (baseDocument) restoreParagraphPropertySources(blocks, baseDocument.package.document.content, linkedSources.targets, linkedSources.sources);
+	const documentBody = { content: blocks };
 	if (baseDocument?.package.document.finalSectionProperties) documentBody.finalSectionProperties = baseDocument.package.document.finalSectionProperties;
 	if (baseDocument?.package.document.sections) documentBody.sections = baseDocument.package.document.sections;
 	if (baseDocument?.package.document.comments) documentBody.comments = baseDocument.package.document.comments;
@@ -105,15 +170,40 @@ const hasSuggestedInsertion = (marks) => marks.some((mark) => mark.type.name ===
 * Returns the input array unchanged when there is nothing to strip so callers
 * can skip rebuilding the node.
 */
-function stripSuggestedInlineMarks(marks) {
+function stripSuggestedInlineMarks(marks, { baseParagraphFormatting, inheritedFormatting, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver }) {
 	const hasSuggestedDeletion = marks.some((mark) => mark.type.name === "deletion" && isSuggestedMark(mark));
 	const suggestedRunPropertyChange = marks.find((mark) => mark.type.name === "runPropertyChange" && isSuggestedMark(mark));
 	if (!hasSuggestedDeletion && !suggestedRunPropertyChange) return marks;
 	let next = marks.filter((mark) => !((mark.type.name === "deletion" || mark.type.name === "runPropertyChange") && isSuggestedMark(mark)));
 	if (suggestedRunPropertyChange) {
 		const previousFormatting = expectRunPropertyChangeMarkAttrs(suggestedRunPropertyChange).changes.at(0)?.previousFormatting;
+		const characterStyleMark = marks.find(({ type }) => type.name === "characterStyle");
+		const characterStyleAttrs = characterStyleMark ? expectCharacterStyleMarkAttrs(characterStyleMark) : void 0;
+		const preservedCharacterStyleAttrs = previousFormatting?.styleId !== void 0 && characterStyleAttrs?.styleId === previousFormatting.styleId ? characterStyleAttrs : void 0;
+		const paragraphFormatting = paragraphFormattingForRun({
+			marks,
+			context: {
+				baseParagraphFormatting,
+				paragraphFormatting: inheritedFormatting,
+				paragraphMarkFormatting,
+				paragraphMarkPrecedesStyle
+			},
+			...previousFormatting !== void 0 ? { directFormatting: previousFormatting } : {}
+		});
+		const effectivePreviousFormatting = mergeTextFormatting(preservedCharacterStyleAttrs ? resolveEffectiveRunStyleFormatting({
+			marks,
+			paragraphFormatting,
+			styleResolver
+		}) : paragraphFormatting, previousFormatting);
 		next = next.filter((mark) => !RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
-		for (const restored of textFormattingToMarks(previousFormatting)) next = restored.addToSet(next);
+		for (const restored of textFormattingToMarks(effectivePreviousFormatting, {
+			overrideFormatting: previousFormatting,
+			directFormatting: previousFormatting
+		})) next = restored.addToSet(next);
+		if (previousFormatting?.styleId) {
+			const characterStyle = suggestedRunPropertyChange.type.schema.marks["characterStyle"];
+			if (characterStyle) next = characterStyle.create(preservedCharacterStyleAttrs ?? { styleId: previousFormatting.styleId }).addToSet(next);
+		}
 	}
 	return next;
 }
@@ -131,6 +221,22 @@ function stripSuggestedInlineMarks(marks) {
 */
 function stripSuggestedNodeAttrs(node) {
 	const name = node.type.name;
+	if (name === "paragraph") {
+		const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+		if (!Array.isArray(propertyChanges)) return null;
+		if (!propertyChanges.some(({ info }) => info.provenance === "suggested")) return null;
+		const removal = removeParagraphPropertyChanges(propertyChanges, ({ info }) => info.provenance === "suggested");
+		if (removal.type === "unchanged") return null;
+		const nextAttrs = {
+			...node.attrs,
+			_propertyChanges: removal.remaining.length > 0 ? removal.remaining : null
+		};
+		if (removal.type === "restore-previous") {
+			Object.assign(nextAttrs, paragraphRejectAttrPatch(removal.previousFormatting));
+			nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(removal.previousFormatting, nextAttrs["_originalFormatting"]);
+		}
+		return nextAttrs;
+	}
 	if (name === "tableRow") {
 		const rowAttrs = expectTableRowAttrs(node);
 		if (rowAttrs.trDel?.provenance === "suggested") return {
@@ -171,18 +277,32 @@ function isSuggestedInsertedNode(node) {
 * Surviving block nodes are rebuilt with their suggested delete/merge markers
 * cleared and their children stripped.
 */
-function mapSuggestionStrippedNode(node) {
+function mapSuggestionStrippedNode(node, formattingContext = {
+	baseParagraphFormatting: void 0,
+	inheritedFormatting: void 0,
+	paragraphMarkFormatting: void 0,
+	paragraphMarkPrecedesStyle: false,
+	styleResolver: null
+}) {
 	if (node.isInline) {
 		if (hasSuggestedInsertion(node.marks)) return null;
-		const marks = stripSuggestedInlineMarks(node.marks);
+		const marks = stripSuggestedInlineMarks(node.marks, formattingContext);
 		return marks === node.marks ? node : node.mark(marks);
 	}
 	if (isSuggestedInsertedNode(node)) return null;
 	const nextAttrs = stripSuggestedNodeAttrs(node);
 	const children = [];
 	let changed = nextAttrs !== null;
+	const paragraphStyleContext = node.type.name === "paragraph" ? paragraphRunStyleContext(node, formattingContext.styleResolver) : void 0;
+	const childFormattingContext = paragraphStyleContext ? {
+		baseParagraphFormatting: paragraphStyleContext.baseParagraphFormatting,
+		inheritedFormatting: paragraphStyleContext.paragraphFormatting,
+		paragraphMarkFormatting: paragraphStyleContext.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: paragraphStyleContext.paragraphMarkPrecedesStyle,
+		styleResolver: formattingContext.styleResolver
+	} : formattingContext;
 	node.forEach((child) => {
-		const mapped = mapSuggestionStrippedNode(child);
+		const mapped = mapSuggestionStrippedNode(child, childFormattingContext);
 		if (mapped === null) {
 			changed = true;
 			return;
@@ -192,15 +312,24 @@ function mapSuggestionStrippedNode(node) {
 	});
 	if (!changed) return node;
 	const content = Fragment.fromArray(children);
-	return nextAttrs === null ? node.copy(content) : node.type.create(nextAttrs, content, node.marks);
+	return recreateProseNodeWithParagraphPropertySource(node, {
+		...nextAttrs === null ? {} : { attrs: nextAttrs },
+		content
+	});
 }
 /**
 * Strip suggested (AI-proposed) tracked changes from a document so it
 * serializes as though the suggestion never happened. See the call site in
 * {@link extractBlocks} for why this is the sole serialization boundary.
 */
-function stripSuggestedProvenance(doc) {
-	return mapSuggestionStrippedNode(doc) ?? doc;
+function stripSuggestedProvenance(doc, styleResolver) {
+	return mapSuggestionStrippedNode(doc, {
+		baseParagraphFormatting: void 0,
+		inheritedFormatting: void 0,
+		paragraphMarkFormatting: void 0,
+		paragraphMarkPrecedesStyle: false,
+		styleResolver
+	}) ?? doc;
 }
 function materializeNumberedRefValues(doc) {
 	const results = resolveNumberedRefFields(doc);
@@ -208,10 +337,10 @@ function materializeNumberedRefValues(doc) {
 	const visit = (node) => {
 		if (node.type.name === "field" || node.type.name === "structuredField") {
 			const displayText = results.get(node);
-			if (displayText !== void 0) return node.type.create({
+			if (displayText !== void 0) return recreateProseNodeWithParagraphPropertySource(node, { attrs: {
 				...node.attrs,
 				displayText
-			}, node.content, node.marks);
+			} });
 			return node;
 		}
 		if (node.childCount === 0) return node;
@@ -222,12 +351,12 @@ function materializeNumberedRefValues(doc) {
 			children.push(mappedChild);
 			changed ||= mappedChild !== child;
 		});
-		return changed ? node.copy(Fragment.fromArray(children)) : node;
+		return changed ? recreateProseNodeWithParagraphPropertySource(node, { content: Fragment.fromArray(children) }) : node;
 	};
 	return visit(doc);
 }
-function extractBlocks(inputDoc, refResolution = "resolve") {
-	const strippedDoc = stripSuggestedProvenance(inputDoc);
+function extractBlocks(inputDoc, refResolution = "resolve", styleResolver = null) {
+	const strippedDoc = stripSuggestedProvenance(inputDoc, styleResolver);
 	const pmDoc = refResolution === "resolve" ? materializeNumberedRefValues(strippedDoc) : strippedDoc;
 	const blocks = [];
 	const textBoxAnchorMarkers = /* @__PURE__ */ new Map();
@@ -252,25 +381,26 @@ function extractBlocks(inputDoc, refResolution = "resolve") {
 			return;
 		}
 		if (node.type.name === "paragraph") {
-			const paragraph = convertPMParagraph(node, documentCounts, textBoxAnchorMarkers);
+			const paragraph = convertPMParagraph(node, documentCounts, textBoxAnchorMarkers, styleResolver);
 			prependPageBreaks(paragraph, pendingPageBreaks);
 			pendingPageBreaks = 0;
 			blocks.push(paragraph);
 			previousStandaloneTextBox = null;
 		} else if (node.type.name === "table") {
 			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
-			blocks.push(convertPMTable(node, documentCounts));
+			blocks.push(convertPMTable(node, documentCounts, styleResolver));
 			previousStandaloneTextBox = null;
 		} else if (node.type.name === "textBox") {
 			previousStandaloneTextBox = appendTextBoxBlock(blocks, node, {
 				pendingPageBreaks,
 				previousStandaloneTextBox,
-				textBoxAnchorMarkers
+				textBoxAnchorMarkers,
+				styleResolver
 			});
 			pendingPageBreaks = 0;
 		} else if (node.type.name === "blockSdt") {
 			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
-			blocks.push(convertPMBlockSdt(node));
+			blocks.push(convertPMBlockSdt(node, styleResolver));
 			previousStandaloneTextBox = null;
 		}
 	});
@@ -278,7 +408,7 @@ function extractBlocks(inputDoc, refResolution = "resolve") {
 	removeUnresolvedTextBoxAnchors(blocks, textBoxAnchorMarkers);
 	return blocks;
 }
-function convertPMBlockSdt(node) {
+function convertPMBlockSdt(node, styleResolver) {
 	const attrs = expectBlockSdtAttrs(node);
 	const properties = { sdtType: attrs.sdtType };
 	if (attrs.alias) properties.alias = attrs.alias;
@@ -296,7 +426,7 @@ function convertPMBlockSdt(node) {
 	if (attrs.rawEndPropertiesXml) properties.rawEndPropertiesXml = attrs.rawEndPropertiesXml;
 	if (attrs.rawSdtChildrenBeforeContent) properties.rawSdtChildrenBeforeContent = attrs.rawSdtChildrenBeforeContent;
 	if (attrs.rawSdtChildrenAfterContent) properties.rawSdtChildrenAfterContent = attrs.rawSdtChildrenAfterContent;
-	const extracted = extractBlocks(node.type.schema.node("doc", null, node.content), "inherit");
+	const extracted = extractBlocks(node.type.schema.node("doc", null, node.content), "inherit", styleResolver);
 	return {
 		type: "blockSdt",
 		properties,
@@ -316,7 +446,7 @@ function isStillSyntheticFiller(blocks) {
 }
 function appendTextBoxBlock(blocks, node, options) {
 	const attrs = expectTextBoxAttrs(node);
-	const paragraph = convertPMTextBox(node);
+	const paragraph = convertPMTextBox(node, options.styleResolver);
 	const previousBlock = blocks.at(-1);
 	if (attrs._docxPlacement === "inlineWithPrevious" && previousBlock?.type === "paragraph") {
 		appendPageBreaks(previousBlock, options.pendingPageBreaks);
@@ -456,6 +586,7 @@ function listRenderingFromAttrs(attrs) {
 	if (!(attrs.listMarker != null || attrs.listIsBullet || attrs.listNumFmt != null)) return;
 	return {
 		marker: attrs.listMarker ?? "",
+		...attrs.listMarkerTemplate != null && { markerTemplate: attrs.listMarkerTemplate },
 		level: attrs.numPr?.ilvl ?? 0,
 		numId,
 		isBullet: attrs.listIsBullet ?? false,
@@ -506,9 +637,16 @@ function appendPageBreaks(paragraph, count) {
 /**
 * Convert a ProseMirror paragraph node to our Paragraph type
 */
-function convertPMParagraph(node, documentCounts, textBoxAnchorMarkers) {
+function convertPMParagraph(node, documentCounts, textBoxAnchorMarkers, styleResolver = null) {
 	const attrs = expectParagraphAttrs(node);
-	let content = extractParagraphContent(node, documentCounts, attrs._emptyHyperlinks ?? void 0, textBoxAnchorMarkers, attrs.renderedPageBreakBefore === true);
+	const paragraphStyleContext = paragraphRunStyleContext(node, styleResolver);
+	let content = extractParagraphContent(node, documentCounts, attrs._emptyHyperlinks ?? void 0, textBoxAnchorMarkers, attrs.renderedPageBreakBefore === true, {
+		baseParagraphFormatting: paragraphStyleContext.baseParagraphFormatting,
+		inheritedFormatting: paragraphStyleContext.paragraphFormatting,
+		paragraphMarkFormatting: paragraphStyleContext.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: paragraphStyleContext.paragraphMarkPrecedesStyle,
+		styleResolver
+	});
 	const bookmarks = attrs.bookmarks;
 	if (bookmarks && bookmarks.length > 0) {
 		const starts = bookmarks.map((b) => ({
@@ -541,12 +679,20 @@ function convertPMParagraph(node, documentCounts, textBoxAnchorMarkers) {
 	else if (attrs.sectionBreakType) paragraph.sectionProperties = { sectionStart: attrs.sectionBreakType };
 	if (attrs._propertyChanges && attrs._propertyChanges.length > 0) paragraph.propertyChanges = attrs._propertyChanges.map(propertyChangeFromAttrs);
 	if (attrs.pPrMark) paragraph.pPrMark = attrs.pPrMark;
+	linkParagraphPropertySourceCandidate(paragraph, node);
 	return paragraph;
 }
 const propertyChangeFromAttrs = (change) => {
-	const { previousFormatting, currentFormatting, ...info } = change;
-	if (previousFormatting === void 0) return currentFormatting === void 0 ? info : {
-		...info,
+	const { previousFormatting, currentFormatting, info, ...changeInfo } = change;
+	const serializedInfo = { ...info };
+	Reflect.deleteProperty(serializedInfo, "provenance");
+	Reflect.deleteProperty(serializedInfo, "suggestionId");
+	const normalizedChangeInfo = {
+		...changeInfo,
+		info: serializedInfo
+	};
+	if (previousFormatting === void 0) return currentFormatting === void 0 ? normalizedChangeInfo : {
+		...normalizedChangeInfo,
 		currentFormatting
 	};
 	const { numPr, ...previousWithoutNumPr } = previousFormatting;
@@ -555,7 +701,7 @@ const propertyChangeFromAttrs = (change) => {
 		numPr
 	};
 	return {
-		...info,
+		...normalizedChangeInfo,
 		previousFormatting: normalizedPrevious,
 		...currentFormatting !== void 0 && { currentFormatting }
 	};
@@ -576,6 +722,8 @@ function assignBooleanToggle(result, attrs, orig, key) {
 	else result[key] = value;
 }
 function paragraphAttrsToFormatting(attrs) {
+	const directAlignment = directParagraphAlignment(attrs);
+	const directSpacing = directParagraphSpacing(attrs);
 	const spaceBefore = Reflect.get(attrs, "spaceBefore");
 	const spaceAfter = Reflect.get(attrs, "spaceAfter");
 	const beforeHasAutospacingBase = hasAutospacingBaseSide(attrs._autospacingBase, "before");
@@ -584,9 +732,12 @@ function paragraphAttrsToFormatting(attrs) {
 	const afterOriginalAutospacing = attrs._originalFormatting?.afterAutospacing === true;
 	const beforeAutospacingEdited = beforeHasAutospacingBase ? !autospacingMatchesBase(attrs._autospacingBase, "before", spaceBefore) : beforeOriginalAutospacing && attrs._autospacingBase == null;
 	const afterAutospacingEdited = afterHasAutospacingBase ? !autospacingMatchesBase(attrs._autospacingBase, "after", spaceAfter) : afterOriginalAutospacing && attrs._autospacingBase == null;
-	const shouldSerializeSpaceBefore = typeof spaceBefore === "number" && (!beforeHasAutospacingBase || beforeAutospacingEdited);
-	const shouldSerializeSpaceAfter = typeof spaceAfter === "number" && (!afterHasAutospacingBase || afterAutospacingEdited);
-	const hasDirectLineSpacing = attrs.lineSpacingExplicit === true;
+	const beforeIsInherited = attrs.spacingFromDocDefaults?.before === true || attrs.spacingFromImplicitDefaultStyle?.before === true;
+	const afterIsInherited = attrs.spacingFromDocDefaults?.after === true || attrs.spacingFromImplicitDefaultStyle?.after === true;
+	const shouldSerializeSpaceBefore = typeof spaceBefore === "number" && (attrs.spacingExplicit?.before === true || beforeAutospacingEdited || !beforeIsInherited && !beforeHasAutospacingBase);
+	const shouldSerializeSpaceAfter = typeof spaceAfter === "number" && (attrs.spacingExplicit?.after === true || afterAutospacingEdited || !afterIsInherited && !afterHasAutospacingBase);
+	const hasDirectLineSpacing = directSpacing?.lineSpacing !== void 0;
+	const hasDirectLineSpacingRule = directSpacing?.lineSpacingRule !== void 0;
 	if (attrs._originalFormatting) {
 		const orig = attrs._originalFormatting;
 		const result = { ...orig };
@@ -600,17 +751,18 @@ function paragraphAttrsToFormatting(attrs) {
 			if (typeof spaceAfter === "number") result.spaceAfter = spaceAfter;
 			else delete result.spaceAfter;
 		}
-		if (attrs.spacingExplicit?.before && typeof spaceBefore === "number") result.spaceBefore = spaceBefore;
-		if (attrs.spacingExplicit?.after && typeof spaceAfter === "number") result.spaceAfter = spaceAfter;
-		const originalHasDirectLineSpacing = orig.lineSpacing !== void 0 || orig.lineSpacingRule !== void 0;
-		if (hasDirectLineSpacing || originalHasDirectLineSpacing) {
-			if (typeof attrs.lineSpacing === "number") result.lineSpacing = attrs.lineSpacing;
-			else Reflect.deleteProperty(result, "lineSpacing");
-			if (attrs.lineSpacingRule) result.lineSpacingRule = attrs.lineSpacingRule;
-			else Reflect.deleteProperty(result, "lineSpacingRule");
-		}
-		if (attrs.alignment !== (orig.alignment ?? void 0)) if (attrs.alignment) result.alignment = attrs.alignment;
-		else delete result.alignment;
+		if (orig.spaceBefore !== void 0 || attrs.spacingExplicit?.before) if (typeof spaceBefore === "number") result.spaceBefore = spaceBefore;
+		else Reflect.deleteProperty(result, "spaceBefore");
+		if (orig.spaceAfter !== void 0 || attrs.spacingExplicit?.after) if (typeof spaceAfter === "number") result.spaceAfter = spaceAfter;
+		else Reflect.deleteProperty(result, "spaceAfter");
+		const originalHasDirectLineSpacing = orig.lineSpacing !== void 0;
+		if (hasDirectLineSpacing || originalHasDirectLineSpacing) if (typeof attrs.lineSpacing === "number") result.lineSpacing = attrs.lineSpacing;
+		else Reflect.deleteProperty(result, "lineSpacing");
+		const originalHasDirectLineSpacingRule = orig.lineSpacingRule !== void 0;
+		if (hasDirectLineSpacingRule || originalHasDirectLineSpacingRule) if (attrs.lineSpacingRule) result.lineSpacingRule = attrs.lineSpacingRule;
+		else Reflect.deleteProperty(result, "lineSpacingRule");
+		if (directAlignment === void 0) Reflect.deleteProperty(result, "alignment");
+		else result.alignment = directAlignment;
 		if (isStyleSourcedNumPr(attrs)) {
 			delete result.numPr;
 			delete result.numPrFromStyle;
@@ -636,15 +788,15 @@ function paragraphAttrsToFormatting(attrs) {
 	}
 	const outlineLevel = Reflect.get(attrs, "outlineLevel");
 	const bidi = directionToBidi(attrs.direction);
-	if (!(attrs.alignment || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || attrs.snapToGrid != null || attrs.indentLeft || attrs.indentRight || attrs.indentFirstLine || attrs.numPr || attrs.styleId || attrs.borders || attrs.shading || attrs.tabs || typeof outlineLevel === "number" || attrs.contextualSpacing || attrs.spacingExplicit || bidi != null || attrs.pageBreakBefore != null || attrs.widowControl != null || attrs.kinsoku != null || attrs.overflowPunctuation != null || attrs.suppressAutoHyphens != null)) return;
+	if (!(directAlignment !== void 0 || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || hasDirectLineSpacingRule || attrs.snapToGrid != null || attrs.indentLeft || attrs.indentRight || attrs.indentFirstLine || attrs.numPr || attrs.styleId || attrs.borders || attrs.shading || attrs.tabs || typeof outlineLevel === "number" || attrs.contextualSpacing || attrs.spacingExplicit || bidi != null || attrs.pageBreakBefore != null || attrs.widowControl != null || attrs.kinsoku != null || attrs.overflowPunctuation != null || attrs.suppressAutoHyphens != null)) return;
 	const f = {};
-	if (attrs.alignment) f.alignment = attrs.alignment;
+	if (directAlignment !== void 0) f.alignment = directAlignment;
 	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
 	if (beforeAutospacingEdited) f.beforeAutospacing = false;
 	if (shouldSerializeSpaceAfter) f.spaceAfter = spaceAfter;
 	if (afterAutospacingEdited) f.afterAutospacing = false;
 	if (hasDirectLineSpacing && typeof attrs.lineSpacing === "number") f.lineSpacing = attrs.lineSpacing;
-	if (hasDirectLineSpacing && attrs.lineSpacingRule) f.lineSpacingRule = attrs.lineSpacingRule;
+	if (hasDirectLineSpacingRule && attrs.lineSpacingRule) f.lineSpacingRule = attrs.lineSpacingRule;
 	if (attrs.snapToGrid != null) f.snapToGrid = attrs.snapToGrid;
 	if (attrs.spacingExplicit) f.spacingExplicit = attrs.spacingExplicit;
 	if (attrs.indentLeft) f.indentLeft = attrs.indentLeft;
@@ -691,7 +843,14 @@ function createTrackedRunWrapper(type, info, child) {
 }
 function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false, inheritedFormattingOverride) {
 	const content = [];
-	const inheritedFormatting = inheritedFormattingOverride ?? (paragraph.type.name === "paragraph" ? expectParagraphAttrs(paragraph).defaultTextFormatting ?? void 0 : void 0);
+	const paragraphStyleContext = paragraph.type.name === "paragraph" ? paragraphRunStyleContext(paragraph) : void 0;
+	const formattingContext = inheritedFormattingOverride ?? {
+		baseParagraphFormatting: paragraphStyleContext?.baseParagraphFormatting,
+		inheritedFormatting: paragraphStyleContext?.paragraphFormatting,
+		paragraphMarkFormatting: paragraphStyleContext?.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: paragraphStyleContext?.paragraphMarkPrecedesStyle ?? false,
+		styleResolver: null
+	};
 	const sortedEmptyHyperlinks = (emptyHyperlinks ?? []).map((attrs, order) => ({
 		attrs,
 		order
@@ -703,6 +862,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	let currentHyperlink = null;
 	let currentHyperlinkKey = null;
 	let currentTrackedChange;
+	const sourceRunOwners = /* @__PURE__ */ new WeakMap();
 	const openedComments = /* @__PURE__ */ new Set();
 	const commentLastOffset = /* @__PURE__ */ new Map();
 	paragraph.forEach((node, offset) => {
@@ -720,6 +880,24 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			currentHyperlinkKey = null;
 		}
 	};
+	const appendDirectRun = (node, run, coalescePlainText = false) => {
+		const marksKey = getMarksKey(node.marks);
+		const ownerId = pageBreakRunOwnerId(node);
+		const currentOwnerId = currentRun ? sourceRunOwners.get(currentRun) : void 0;
+		const currentRunIsPlainText = currentRun?.content.every((runContent) => runContent.type === "text");
+		const joinsOwnedSourceRun = ownerId !== void 0 && ownerId === currentOwnerId && currentRun !== null && runsShareProperties(currentRun, run);
+		const joinsOrdinaryText = coalescePlainText && ownerId === void 0 && currentOwnerId === void 0 && currentRunIsPlainText === true && currentMarksKey === marksKey;
+		if (currentRun && (joinsOwnedSourceRun || joinsOrdinaryText)) {
+			if (joinsOrdinaryText) {
+				for (const runContent of run.content) if (runContent.type === "text") appendTextToRun(currentRun, runContent.text);
+			} else currentRun.content.push(...run.content);
+			return;
+		}
+		if (currentRun) content.push(currentRun);
+		currentRun = run;
+		currentMarksKey = marksKey;
+		rememberSourceRunOwner(run, node, sourceRunOwners);
+	};
 	const syncCommentRanges = (node, offset) => {
 		const nodeCommentIds = getCommentMarkIds(node.marks);
 		const toClose = [];
@@ -794,6 +972,10 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				id: changeAttrs.revisionId,
 				author: changeAttrs.author || "Unknown",
 				...changeAttrs.date ? { date: changeAttrs.date } : {},
+				...changeAttrs.utcDate ? { utcDate: {
+					attribute: DATE_UTC_ATTRIBUTE,
+					value: changeAttrs.utcDate
+				} } : {},
 				...changeAttrs.initials ? { initials: changeAttrs.initials } : {}
 			};
 			if (insertionMark) content.push({
@@ -819,6 +1001,10 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				author: changeAttrs.author || "Unknown"
 			};
 			if (changeAttrs.date) info.date = changeAttrs.date;
+			if (changeAttrs.utcDate) info.utcDate = {
+				attribute: DATE_UTC_ATTRIBUTE,
+				value: changeAttrs.utcDate
+			};
 			if (changeAttrs.initials) info.initials = changeAttrs.initials;
 			let type;
 			if (insertionMark) type = changeAttrs.moveKind === "moveTo" ? "moveTo" : "insertion";
@@ -841,18 +1027,19 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				if (currentTrackedChange.type !== "hyperlink") panic("A tracked hyperlink lost its serialization parent");
 				if (node.type.name === "bookmarkBoundary") {
 					addNodeToHyperlink({
+						...formattingContext,
 						hyperlink: currentTrackedChange.hyperlink,
-						inheritedFormatting,
-						node
+						node,
+						sourceRunOwners
 					});
 					return;
 				}
 				const run = createTrackedChangeRun({
-					inheritedFormatting,
+					...formattingContext,
 					marks: otherMarks,
 					node
 				});
-				if (run) currentTrackedChange.hyperlink.children.push(run);
+				if (run) appendRunToHyperlink(currentTrackedChange.hyperlink, run, node, sourceRunOwners);
 				return;
 			}
 			if (!currentTrackedChange || currentTrackedChange.type !== "direct" || currentTrackedChange.key !== trackedChangeKey) {
@@ -881,22 +1068,32 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			}
 			if (node.type.name === "field" || node.type.name === "structuredField") {
 				currentTrackedChange.wrapper.content.push(createFieldFromNode(node, {
+					...formattingContext,
 					marks: otherMarks,
 					textBoxAnchorMarkers
 				}));
 				return;
 			}
 			const run = createTrackedChangeRun({
-				inheritedFormatting,
+				...formattingContext,
 				marks: otherMarks,
 				node
 			});
-			if (run) currentTrackedChange.wrapper.content.push(run);
+			if (run) appendRunToTrackedWrapper(currentTrackedChange.wrapper, run, node, sourceRunOwners);
+			return;
+		}
+		const ownedRun = linkMark || pageBreakRunOwnerId(node) === void 0 ? null : createTrackedChangeRun({
+			...formattingContext,
+			marks: node.marks,
+			node
+		});
+		if (ownedRun) {
+			appendDirectRun(node, ownedRun, node.isText);
 			return;
 		}
 		if (noteRefMark && !linkMark) {
 			flushCurrentInline();
-			content.push(createNoteReferenceRun(noteRefMark, node.marks));
+			content.push(createNoteReferenceRun(noteRefMark, node.marks, formattingContext));
 			return;
 		}
 		if (linkMark) {
@@ -907,9 +1104,10 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				currentHyperlinkKey = linkKey;
 			}
 			addNodeToHyperlink({
+				...formattingContext,
 				hyperlink: currentHyperlink,
-				inheritedFormatting,
-				node
+				node,
+				sourceRunOwners
 			});
 			return;
 		}
@@ -928,24 +1126,24 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				type: "bookmarkEnd",
 				id: attrs.id
 			});
-		} else if (node.isText) {
-			const marksKey = getMarksKey(node.marks);
-			if (currentRun && currentMarksKey === marksKey) appendTextToRun(currentRun, node.text || "");
-			else {
-				if (currentRun) content.push(currentRun);
-				currentRun = createRunFromText({
-					inheritedFormatting,
-					marks: node.marks,
-					text: node.text || ""
-				});
-				currentMarksKey = marksKey;
-			}
+		} else if (node.isText) appendDirectRun(node, createRunFromText({
+			...formattingContext,
+			marks: node.marks,
+			text: node.text || ""
+		}), true);
+		else if (node.type.name === "pageBreakRun") {
+			const { clear } = expectPageBreakRunAttrs(node);
+			appendDirectRun(node, createPageBreakCarrierRun({
+				...formattingContext,
+				clear,
+				marks: node.marks
+			}));
 		} else if (node.type.name === "symbol") {
 			flushCurrentInline();
-			content.push(createSymbolRun(node, node.marks));
+			content.push(createSymbolRun(node, node.marks, formattingContext));
 		} else if (node.type.name === "hardBreak") {
 			flushCurrentInline();
-			content.push(createBreakRun(readHardBreakType(node)));
+			content.push(createBreakRun(expectHardBreakAttrs(node), node.marks, formattingContext));
 		} else if (node.type.name === "image") {
 			flushCurrentInline();
 			content.push(createImageRun(node));
@@ -954,19 +1152,20 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			content.push(createShapeRun(node));
 		} else if (node.type.name === "tab") {
 			flushCurrentInline();
-			content.push(createTabRun(node));
+			content.push(createTabRun(node, node.marks, formattingContext));
 		} else if (node.type.name === "renderedPageBreak") {
 			flushCurrentInline();
 			content.push(createRenderedPageBreakRun());
 		} else if (node.type.name === "field" || node.type.name === "structuredField") {
 			flushCurrentInline();
 			content.push(createFieldFromNode(node, {
+				...formattingContext,
 				marks: node.marks,
 				textBoxAnchorMarkers
 			}));
 		} else if (node.type.name === "sdt") {
 			flushCurrentInline();
-			content.push(createInlineSdtFromNode(node, textBoxAnchorMarkers, inheritedFormatting));
+			content.push(createInlineSdtFromNode(node, textBoxAnchorMarkers, formattingContext));
 		} else if (node.type.name === "math") {
 			flushCurrentInline();
 			content.push(createMathFromNode(node));
@@ -1002,12 +1201,20 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	});
 	return content;
 }
-function createTrackedChangeRun({ inheritedFormatting, marks, node }) {
+function createTrackedChangeRun({ baseParagraphFormatting, inheritedFormatting, marks, node, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver }) {
+	const formattingContext = {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle,
+		styleResolver
+	};
 	const noteRefMark = marks.find((mark) => mark.type.name === "footnoteRef");
-	if (noteRefMark) return createNoteReferenceRun(noteRefMark, marks);
-	if (node.isText) {
-		const formatting = marksToTextFormatting(marks, { inheritedFormatting });
-		const run = {
+	let run = null;
+	if (noteRefMark) run = createNoteReferenceRun(noteRefMark, marks, formattingContext);
+	else if (node.isText) {
+		const formatting = marksToTextFormatting(marks, formattingContext);
+		run = {
 			type: "run",
 			content: node.text ? [{
 				type: "text",
@@ -1016,15 +1223,26 @@ function createTrackedChangeRun({ inheritedFormatting, marks, node }) {
 			...Object.keys(formatting).length > 0 ? { formatting } : {}
 		};
 		restoreRunPropertyChanges(run, marks);
-		return run;
-	}
-	if (node.type.name === "symbol") return createSymbolRun(node, marks);
-	if (node.type.name === "hardBreak") return createBreakRun(readHardBreakType(node));
-	if (node.type.name === "image") return createImageRun(node);
-	if (node.type.name === "shape") return createShapeRun(node);
-	if (node.type.name === "tab") return createTabRun(node);
-	if (node.type.name === "renderedPageBreak") return createRenderedPageBreakRun();
-	return null;
+	} else if (node.type.name === "symbol") run = createSymbolRun(node, marks, formattingContext);
+	else if (node.type.name === "hardBreak") run = createBreakRun(expectHardBreakAttrs(node), marks, formattingContext);
+	else if (node.type.name === "pageBreakRun") {
+		const { clear } = expectPageBreakRunAttrs(node);
+		run = createPageBreakCarrierRun({
+			...formattingContext,
+			clear,
+			marks
+		});
+	} else if (node.type.name === "image") run = createImageRun(node);
+	else if (node.type.name === "shape") run = createShapeRun(node);
+	else if (node.type.name === "tab") run = createTabRun(node, marks, formattingContext);
+	else if (node.type.name === "renderedPageBreak") run = createRenderedPageBreakRun();
+	if (!run || pageBreakRunOwnerId(node) === void 0) return run;
+	if (node.type.name === "image" || node.type.name === "shape" || node.type.name === "renderedPageBreak") {
+		const formatting = getRunFormattingFromMarks(marks, formattingContext);
+		if (formatting) run.formatting = formatting;
+		restoreRunPropertyChanges(run, marks);
+	}
+	return run;
 }
 function createEmptyHyperlink(attrs) {
 	const hyperlink = {
@@ -1111,7 +1329,7 @@ function createHyperlink(linkMark) {
 	if (attrs.rId) hyperlink.rId = attrs.rId;
 	return hyperlink;
 }
-function addNodeToHyperlink({ hyperlink, inheritedFormatting, node }) {
+function addNodeToHyperlink({ baseParagraphFormatting, hyperlink, inheritedFormatting, node, paragraphMarkFormatting, paragraphMarkPrecedesStyle, sourceRunOwners, styleResolver }) {
 	if (node.type.name === "bookmarkBoundary") {
 		const attrs = expectBookmarkBoundaryAttrs(node);
 		if (attrs.type === "start") hyperlink.children.push({
@@ -1127,31 +1345,84 @@ function addNodeToHyperlink({ hyperlink, inheritedFormatting, node }) {
 		});
 		return;
 	}
+	const formattingContext = {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle,
+		styleResolver
+	};
+	const nonLinkMarks = node.marks.filter((mark) => mark.type.name !== "hyperlink");
+	const ownedRun = pageBreakRunOwnerId(node) === void 0 ? null : createTrackedChangeRun({
+		...formattingContext,
+		marks: nonLinkMarks,
+		node
+	});
+	if (ownedRun) {
+		appendRunToHyperlink(hyperlink, ownedRun, node, sourceRunOwners);
+		return;
+	}
 	const noteRefMark = node.marks.find((m) => m.type.name === "footnoteRef");
 	if (noteRefMark) {
-		hyperlink.children.push(createNoteReferenceRun(noteRefMark, node.marks));
+		hyperlink.children.push(createNoteReferenceRun(noteRefMark, node.marks, {
+			baseParagraphFormatting,
+			inheritedFormatting,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver
+		}));
 		return;
 	}
-	const nonLinkMarks = node.marks.filter((m) => m.type.name !== "hyperlink");
 	if (node.isText && node.text) {
 		const run = createRunFromText({
+			baseParagraphFormatting,
 			inheritedFormatting,
 			marks: nonLinkMarks,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver,
 			text: node.text
 		});
 		hyperlink.children.push(run);
 		return;
 	}
 	if (node.type.name === "symbol") {
-		hyperlink.children.push(createSymbolRun(node, nonLinkMarks));
+		hyperlink.children.push(createSymbolRun(node, nonLinkMarks, {
+			baseParagraphFormatting,
+			inheritedFormatting,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver
+		}));
 		return;
 	}
 	if (node.type.name === "hardBreak") {
-		hyperlink.children.push(createBreakRun(readHardBreakType(node), nonLinkMarks));
+		hyperlink.children.push(createBreakRun(expectHardBreakAttrs(node), nonLinkMarks, {
+			baseParagraphFormatting,
+			inheritedFormatting,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver
+		}));
+		return;
+	}
+	if (node.type.name === "pageBreakRun") {
+		const { clear } = expectPageBreakRunAttrs(node);
+		hyperlink.children.push(createPageBreakCarrierRun({
+			...formattingContext,
+			clear,
+			marks: nonLinkMarks
+		}));
 		return;
 	}
 	if (node.type.name === "tab") {
-		hyperlink.children.push(createTabRun(node, nonLinkMarks));
+		hyperlink.children.push(createTabRun(node, nonLinkMarks, {
+			baseParagraphFormatting,
+			inheritedFormatting,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver
+		}));
 		return;
 	}
 	if (node.type.name === "renderedPageBreak") {
@@ -1169,7 +1440,7 @@ function getNoteReferenceVertAlign(noteAttrs, marks) {
 	if (marks.some((mark) => mark.type.name === "superscript")) return "superscript";
 	if (noteAttrs.vertAlign === "baseline" || noteAttrs.vertAlign === "superscript") return noteAttrs.vertAlign;
 }
-function createNoteReferenceRun(noteRefMark, marks) {
+function createNoteReferenceRun(noteRefMark, marks, formattingContext) {
 	const noteAttrs = expectFootnoteRefMarkAttrs(noteRefMark);
 	const run = {
 		type: "run",
@@ -1178,12 +1449,24 @@ function createNoteReferenceRun(noteRefMark, marks) {
 			id: typeof noteAttrs.id === "string" ? Number.parseInt(noteAttrs.id, 10) || 0 : noteAttrs.id
 		}]
 	};
+	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	const vertAlign = getNoteReferenceVertAlign(noteAttrs, marks);
-	if (vertAlign) run.formatting = { vertAlign };
+	if (formatting) run.formatting = formatting;
+	if (vertAlign && formatting?.vertAlign === void 0 && formatting?.styleId === void 0) run.formatting = {
+		...formatting,
+		vertAlign
+	};
+	restoreRunPropertyChanges(run, marks);
 	return run;
 }
-function createRunFromText({ inheritedFormatting, marks, text }) {
-	const formatting = getRunFormattingFromMarks(marks, { inheritedFormatting });
+function createRunFromText({ baseParagraphFormatting, inheritedFormatting, marks, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver, text }) {
+	const formatting = getRunFormattingFromMarks(marks, {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle,
+		styleResolver
+	});
 	const run = {
 		type: "run",
 		content: [{
@@ -1195,7 +1478,7 @@ function createRunFromText({ inheritedFormatting, marks, text }) {
 	restoreRunPropertyChanges(run, marks);
 	return run;
 }
-function createSymbolRun(node, marks) {
+function createSymbolRun(node, marks, formattingContext) {
 	const { font, char } = expectSymbolAttrs(node);
 	const run = {
 		type: "run",
@@ -1205,7 +1488,7 @@ function createSymbolRun(node, marks) {
 			char
 		}]
 	};
-	const formatting = getRunFormattingFromMarks(marks);
+	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
 	restoreRunPropertyChanges(run, marks);
 	return run;
@@ -1218,10 +1501,14 @@ function restoreRunPropertyChanges(run, marks) {
 	run.propertyChanges = [...changes];
 }
 function getRunFormattingFromMarks(marks, options) {
-	if (!marks || marks.length === 0) return;
+	if (!marks || marks.length === 0 && !options) return;
 	const formatting = marksToTextFormatting(marks, options);
 	return Object.keys(formatting).length > 0 ? formatting : void 0;
 }
+function getAtomRunFormattingFromMarks(marks, options) {
+	if (!marks?.some(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name))) return;
+	return getRunFormattingFromMarks(marks, options);
+}
 /**
 * Append text to an existing run
 */
@@ -1233,19 +1520,81 @@ function appendTextToRun(run, text) {
 		text
 	});
 }
+function runsShareProperties(left, right) {
+	return canonicalJson({
+		formatting: left.formatting,
+		propertyChanges: left.propertyChanges
+	}) === canonicalJson({
+		formatting: right.formatting,
+		propertyChanges: right.propertyChanges
+	});
+}
+function pageBreakRunOwnerId(node) {
+	const mark = node.marks.find(({ type }) => type.name === "pageBreakRunOwner");
+	return mark ? expectPageBreakRunOwnerMarkAttrs(mark).id : void 0;
+}
+function canJoinOwnedRuns(previous, run, node, sourceRunOwners) {
+	if (!previous || !runsShareProperties(previous, run)) return false;
+	const ownerId = pageBreakRunOwnerId(node);
+	return ownerId !== void 0 && sourceRunOwners.get(previous) === ownerId;
+}
+function rememberSourceRunOwner(run, node, sourceRunOwners) {
+	const ownerId = pageBreakRunOwnerId(node);
+	if (ownerId !== void 0) sourceRunOwners.set(run, ownerId);
+}
+function appendRunToTrackedWrapper(wrapper, run, node, sourceRunOwners) {
+	const previous = wrapper.content.at(-1);
+	if (previous?.type === "run" && canJoinOwnedRuns(previous, run, node, sourceRunOwners)) {
+		previous.content.push(...run.content);
+		return;
+	}
+	wrapper.content.push(run);
+	rememberSourceRunOwner(run, node, sourceRunOwners);
+}
+function appendRunToHyperlink(hyperlink, run, node, sourceRunOwners) {
+	const previous = hyperlink.children.at(-1);
+	if (previous?.type === "run" && canJoinOwnedRuns(previous, run, node, sourceRunOwners)) {
+		previous.content.push(...run.content);
+		return;
+	}
+	hyperlink.children.push(run);
+	rememberSourceRunOwner(run, node, sourceRunOwners);
+}
+function createPageBreakCarrierRun({ baseParagraphFormatting, clear, inheritedFormatting, marks, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver }) {
+	const run = {
+		type: "run",
+		content: [{
+			type: "break",
+			breakType: "page",
+			...clear !== void 0 ? { clear } : {}
+		}]
+	};
+	const formatting = getAtomRunFormattingFromMarks(marks, {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle,
+		styleResolver
+	});
+	if (formatting) run.formatting = formatting;
+	if (marks) restoreRunPropertyChanges(run, marks);
+	return run;
+}
 /**
 * Create a Run containing a line break
 */
-function createBreakRun(breakType = "textWrapping", marks) {
+function createBreakRun(attrs, marks, formattingContext) {
 	const run = {
 		type: "run",
 		content: [{
 			type: "break",
-			breakType
+			...attrs.breakType !== void 0 ? { breakType: attrs.breakType } : {},
+			...attrs.clear !== void 0 ? { clear: attrs.clear } : {}
 		}]
 	};
-	const formatting = getRunFormattingFromMarks(marks);
+	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
+	if (marks) restoreRunPropertyChanges(run, marks);
 	return run;
 }
 function createRenderedPageBreakRun() {
@@ -1254,13 +1603,10 @@ function createRenderedPageBreakRun() {
 		content: [{ type: "renderedPageBreak" }]
 	};
 }
-function readHardBreakType(node) {
-	return expectHardBreakAttrs(node).breakType ?? "textWrapping";
-}
 /**
 * Create a Run containing a tab
 */
-function createTabRun(node, marks) {
+function createTabRun(node, marks, formattingContext) {
 	const { positional } = expectTabAttrs(node);
 	const run = {
 		type: "run",
@@ -1269,15 +1615,32 @@ function createTabRun(node, marks) {
 			...positional ? { positional } : {}
 		}]
 	};
-	const formatting = getRunFormattingFromMarks(marks);
+	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
+	if (marks) restoreRunPropertyChanges(run, marks);
 	return run;
 }
-function createFieldFromNode(node, { marks, textBoxAnchorMarkers }) {
+function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormatting, marks, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver, textBoxAnchorMarkers }) {
 	const attrs = expectFieldAttrs(node);
-	const formatting = marks && marks.length > 0 ? marksToTextFormatting(marks) : void 0;
+	const formatting = marks && marks.length > 0 ? marksToTextFormatting(marks, {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle,
+		styleResolver
+	}) : void 0;
+	const extractedContent = extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers, false, {
+		baseParagraphFormatting,
+		inheritedFormatting,
+		paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: paragraphMarkPrecedesStyle ?? false,
+		styleResolver: styleResolver ?? null
+	}).filter((content) => content.type === "run" || content.type === "hyperlink");
+	const hasExplicitPageBreak = extractedContent.some((content) => {
+		return (content.type === "run" ? [content] : content.children).some((run) => run.type === "run" && run.content.some((runContent) => runContent.type === "break" && runContent.breakType === "page"));
+	});
 	let displayText = attrs.displayText ?? "";
-	if (!displayText) switch (attrs.fieldType) {
+	if (!displayText && !hasExplicitPageBreak) switch (attrs.fieldType) {
 		case "PAGE":
 			displayText = "1";
 			break;
@@ -1296,7 +1659,7 @@ function createFieldFromNode(node, { marks, textBoxAnchorMarkers }) {
 		}],
 		...formatting && Object.keys(formatting).length > 0 ? { formatting } : {}
 	};
-	const extractedContent = extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers).filter((content) => content.type === "run" || content.type === "hyperlink");
+	if (marks && node.type.name === "field") restoreRunPropertyChanges(displayRun, marks);
 	const fieldContent = extractedContent.length > 0 ? synchronizeFieldDisplayText(extractedContent, displayText, displayRun) : [];
 	if (attrs.fieldKind === "complex") {
 		const complex = {
@@ -1369,11 +1732,11 @@ function createMathFromNode(node) {
 /**
 * Create an InlineSdt from a PM sdt node
 */
-function createInlineSdtFromNode(node, textBoxAnchorMarkers, inheritedFormatting) {
+function createInlineSdtFromNode(node, textBoxAnchorMarkers, formattingContext) {
 	return {
 		type: "inlineSdt",
 		properties: sdtPropertiesFromAttrs(expectSdtAttrs(node)),
-		content: extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers, false, inheritedFormatting).filter((c) => c.type === "run" || c.type === "hyperlink" || c.type === "simpleField" || c.type === "complexField" || c.type === "inlineSdt" || c.type === "insertion" || c.type === "deletion" || c.type === "moveFrom" || c.type === "moveTo" || c.type === "mathEquation")
+		content: extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers, false, formattingContext).filter((c) => c.type === "run" || c.type === "hyperlink" || c.type === "simpleField" || c.type === "complexField" || c.type === "inlineSdt" || c.type === "insertion" || c.type === "deletion" || c.type === "moveFrom" || c.type === "moveTo" || c.type === "mathEquation")
 	};
 }
 /**
@@ -1521,20 +1884,380 @@ function createShapeRun(node) {
 		}]
 	};
 }
+const RUN_FORMATTING_VISUAL_GROUPS = {
+	bold: "bold",
+	boldCs: null,
+	italic: "italic",
+	italicCs: null,
+	underline: "underline",
+	strike: "strike",
+	doubleStrike: "strike",
+	vertAlign: "vertAlign",
+	smallCaps: "smallCaps",
+	allCaps: "allCaps",
+	hidden: "hidden",
+	color: "color",
+	highlight: "highlight",
+	shading: "shading",
+	fontSize: "fontSize",
+	fontSizeCs: null,
+	fontFamily: "fontFamily",
+	language: "language",
+	spacing: "characterSpacing",
+	position: "characterSpacing",
+	scale: "characterSpacing",
+	kerning: "characterSpacing",
+	effect: "effect",
+	emphasisMark: "emphasisMark",
+	emboss: "emboss",
+	imprint: "imprint",
+	outline: "outline",
+	shadow: "shadow",
+	rtl: "rtl",
+	cs: null,
+	styleId: null
+};
+const RUN_FORMATTING_FAST_PATH_DISPOSITION = {
+	bold: "visual",
+	boldCs: "structural",
+	italic: "visual",
+	italicCs: "structural",
+	underline: "visual",
+	strike: "visual",
+	doubleStrike: "visual",
+	vertAlign: "visual",
+	smallCaps: "visual",
+	allCaps: "visual",
+	hidden: "visual",
+	color: "visual",
+	highlight: "visual",
+	shading: "visual",
+	fontSize: "visual",
+	fontSizeCs: "structural",
+	fontFamily: "visual",
+	language: "visual",
+	spacing: "visual",
+	position: "visual",
+	scale: "visual",
+	kerning: "visual",
+	effect: "visual",
+	emphasisMark: "visual",
+	emboss: "visual",
+	imprint: "visual",
+	outline: "visual",
+	shadow: "visual",
+	rtl: "visual",
+	cs: "structural",
+	styleId: "character-style"
+};
+const hasOnlyCarrierlessVisualFormatting = (formatting) => {
+	for (const property of Object.keys(formatting)) if (RUN_FORMATTING_FAST_PATH_DISPOSITION[property] !== "visual") return false;
+	return true;
+};
+const visibleUnderline = (formatting) => {
+	const underline = formatting?.underline;
+	return underline?.style === "none" ? void 0 : underline;
+};
+const visibleStrike = (formatting) => {
+	if (formatting?.doubleStrike === true) return "double";
+	return formatting?.strike === true ? "single" : void 0;
+};
+const visibleColor = (formatting) => formatting?.color?.auto === true ? void 0 : formatting?.color;
+const visibleValue = (value) => value === "none" ? void 0 : value;
+/**
+* Compare the exact presentation encoded by PM run marks without allocating the
+* intermediate maps used by reconciliation. Non-visual authored state is
+* deliberately absent here: the carrierless fast path below excludes every
+* structural carrier before calling this predicate.
+*/
+const sameVisualFormatting = (left, right) => {
+	if (left?.bold === true !== (right?.bold === true) || left?.italic === true !== (right?.italic === true) || !sameFormattingValue(visibleUnderline(left), visibleUnderline(right)) || visibleStrike(left) !== visibleStrike(right) || !sameFormattingValue(visibleColor(left), visibleColor(right)) || visibleValue(left?.highlight) !== visibleValue(right?.highlight) || (left?.fontSize || void 0) !== (right?.fontSize || void 0) || !sameFormattingValue(left?.fontFamily, right?.fontFamily) || !sameFormattingValue(left?.language, right?.language) || (left?.vertAlign === "superscript" || left?.vertAlign === "subscript" ? left.vertAlign : void 0) !== (right?.vertAlign === "superscript" || right?.vertAlign === "subscript" ? right.vertAlign : void 0) || left?.allCaps === true !== (right?.allCaps === true) || left?.smallCaps === true !== (right?.smallCaps === true) || left?.hidden === true !== (right?.hidden === true) || left?.emboss === true !== (right?.emboss === true) || left?.imprint === true !== (right?.imprint === true) || left?.shadow === true !== (right?.shadow === true) || left?.outline === true !== (right?.outline === true) || left?.rtl === true !== (right?.rtl === true) || (typeof left?.spacing === "number" ? left.spacing : null) !== (typeof right?.spacing === "number" ? right.spacing : null) || (typeof left?.position === "number" ? left.position : null) !== (typeof right?.position === "number" ? right.position : null) || (normalizeHorizontalScalePercent(left?.scale) ?? null) !== (normalizeHorizontalScalePercent(right?.scale) ?? null) || (typeof left?.kerning === "number" ? left.kerning : null) !== (typeof right?.kerning === "number" ? right.kerning : null) || visibleValue(left?.effect) !== visibleValue(right?.effect) || visibleValue(left?.emphasisMark) !== visibleValue(right?.emphasisMark)) return false;
+	return sameFormattingValue(shadingToRunShadingAttrs(left?.shading), shadingToRunShadingAttrs(right?.shading));
+};
+const visualFormattingGroups = (formatting) => {
+	const groups = /* @__PURE__ */ new Map();
+	if (!formatting) return groups;
+	if (formatting.bold) groups.set("bold", true);
+	if (formatting.italic) groups.set("italic", true);
+	if (formatting.underline && formatting.underline.style !== "none") groups.set("underline", {
+		style: formatting.underline.style || "single",
+		...formatting.underline.color ? { color: formatting.underline.color } : {}
+	});
+	if (formatting.strike || formatting.doubleStrike) groups.set("strike", formatting.doubleStrike ? "double" : "single");
+	if (formatting.color && !formatting.color.auto) {
+		const { rgb, themeColor, themeTint, themeShade } = formatting.color;
+		groups.set("color", {
+			...rgb ? { rgb } : {},
+			...themeColor ? { themeColor } : {},
+			...themeTint ? { themeTint } : {},
+			...themeShade ? { themeShade } : {}
+		});
+	}
+	if (formatting.highlight && formatting.highlight !== "none") groups.set("highlight", formatting.highlight);
+	const shadingAttrs = shadingToRunShadingAttrs(formatting.shading);
+	if (shadingAttrs) groups.set("shading", runShadingAttrsToShading(shadingAttrs));
+	if (formatting.fontSize) groups.set("fontSize", formatting.fontSize);
+	if (formatting.fontFamily) {
+		const { ascii, hAnsi, eastAsia, cs, hint, asciiTheme, hAnsiTheme, eastAsiaTheme, csTheme } = formatting.fontFamily;
+		groups.set("fontFamily", {
+			...ascii ? { ascii } : {},
+			...hAnsi ? { hAnsi } : {},
+			...eastAsia ? { eastAsia } : {},
+			...cs ? { cs } : {},
+			...hint ? { hint } : {},
+			...asciiTheme ? { asciiTheme } : {},
+			...hAnsiTheme ? { hAnsiTheme } : {},
+			...eastAsiaTheme ? { eastAsiaTheme } : {},
+			...csTheme ? { csTheme } : {}
+		});
+	}
+	if (formatting.language) {
+		const { val, eastAsia, bidi } = formatting.language;
+		groups.set("language", {
+			...val ? { val } : {},
+			...eastAsia ? { eastAsia } : {},
+			...bidi ? { bidi } : {}
+		});
+	}
+	if (formatting.vertAlign === "superscript" || formatting.vertAlign === "subscript") groups.set("vertAlign", formatting.vertAlign);
+	for (const [property, group] of [
+		["allCaps", "allCaps"],
+		["smallCaps", "smallCaps"],
+		["hidden", "hidden"],
+		["emboss", "emboss"],
+		["imprint", "imprint"],
+		["shadow", "shadow"],
+		["outline", "outline"],
+		["rtl", "rtl"]
+	]) if (formatting[property]) groups.set(group, true);
+	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) groups.set("characterSpacing", {
+		spacing,
+		position,
+		scale,
+		kerning
+	});
+	if (formatting.effect && formatting.effect !== "none") groups.set("effect", formatting.effect);
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") groups.set("emphasisMark", formatting.emphasisMark);
+	return groups;
+};
+const expectedRunFormattingOverrideAttrs = (authoredFormatting) => {
+	const attrs = buildRunFormattingOverrideAttrs(authoredFormatting, {
+		type: "authored-baseline",
+		formatting: authoredFormatting
+	});
+	const hasDirectFormatting = Object.keys(authoredFormatting).some((property) => property !== "styleId");
+	if (!attrs && !hasDirectFormatting) return;
+	const expected = { ...attrs };
+	const directFontProperties = [
+		"color",
+		"fontFamily",
+		"fontSize"
+	].filter((property) => authoredFormatting[property] !== void 0);
+	if (directFontProperties.length > 0) expected.directFontProperties = directFontProperties;
+	const complexScriptPropertyAbsences = [
+		["bold", "boldCs"],
+		["italic", "italicCs"],
+		["fontSize", "fontSizeCs"]
+	].filter(([ordinary, complex]) => authoredFormatting[ordinary] !== void 0 && authoredFormatting[complex] === void 0).map(([, complex]) => complex);
+	if (complexScriptPropertyAbsences.length > 0) expected.complexScriptPropertyAbsences = complexScriptPropertyAbsences;
+	return Object.keys(expected).length > 0 ? expected : void 0;
+};
+const changedVisualFormattingGroups = (observedFormatting, expectedFormatting) => {
+	const actual = visualFormattingGroups(observedFormatting);
+	const expected = visualFormattingGroups(expectedFormatting);
+	const changed = /* @__PURE__ */ new Set();
+	for (const group of /* @__PURE__ */ new Set([...actual.keys(), ...expected.keys()])) {
+		const actualValue = actual.get(group);
+		const expectedValue = expected.get(group);
+		if (!sameFormattingValue(actualValue, expectedValue)) changed.add(group);
+	}
+	return changed;
+};
+const VISUAL_BOOLEAN_FORMATTING_PROPERTIES = /* @__PURE__ */ new Set([
+	"allCaps",
+	"bold",
+	"doubleStrike",
+	"emboss",
+	"hidden",
+	"imprint",
+	"italic",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike"
+]);
+const fontFamilyDifference = (actual, inherited) => {
+	const difference = {};
+	for (const property of [
+		"ascii",
+		"hAnsi",
+		"eastAsia",
+		"cs",
+		"hint",
+		"asciiTheme",
+		"hAnsiTheme",
+		"eastAsiaTheme",
+		"csTheme"
+	]) {
+		const value = actual[property];
+		if (value !== void 0 && value !== inherited?.[property]) Reflect.set(difference, property, value);
+	}
+	return Object.keys(difference).length > 0 ? difference : void 0;
+};
+const DIRECT_OVERRIDE_FORMATTING_PROPERTIES = [
+	"allCaps",
+	"bold",
+	"boldCs",
+	"cs",
+	"doubleStrike",
+	"emboss",
+	"fontSizeCs",
+	"hidden",
+	"imprint",
+	"italic",
+	"italicCs",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike",
+	"underline"
+];
+const POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS = /* @__PURE__ */ new Set([
+	"allCaps",
+	"emboss",
+	"hidden",
+	"imprint",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike"
+]);
+const setFormattingFromOverrideSignal = (formatting, property, value) => {
+	Reflect.deleteProperty(formatting, property);
+	if (value === void 0) return;
+	if (property === "underline") {
+		formatting.underline = { style: "none" };
+		return;
+	}
+	Reflect.set(formatting, property, value);
+};
+const sameFormattingValue = (left, right) => {
+	if (left === right) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((value, index) => sameFormattingValue(value, right[index]));
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameFormattingValue(Reflect.get(left, key), Reflect.get(right, key)));
+};
+const reconcileOverrideSignals = (formatting, current, expected, inheritedFormatting, observedFormatting) => {
+	for (const property of DIRECT_OVERRIDE_FORMATTING_PROPERTIES) {
+		if (sameFormattingValue(current?.[property], expected?.[property])) continue;
+		if (current?.[property] === void 0 && expected?.[property] === true && POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS.has(property)) continue;
+		if (current && hasAuthoredRunFormattingProvenance(current) && expected?.[property] === void 0 && sameFormattingValue(current[property], inheritedFormatting?.[property])) continue;
+		setFormattingFromOverrideSignal(formatting, property, current?.[property]);
+	}
+	for (const property of [
+		"color",
+		"fontFamily",
+		"fontSize"
+	]) {
+		const currentIsDirect = current?.directFontProperties?.includes(property) === true;
+		if (currentIsDirect === (expected?.directFontProperties?.includes(property) === true)) continue;
+		if (!currentIsDirect) {
+			Reflect.deleteProperty(formatting, property);
+			continue;
+		}
+		const observed = observedFormatting[property];
+		if (observed !== void 0) Reflect.set(formatting, property, observed);
+	}
+	for (const property of [
+		"boldCs",
+		"italicCs",
+		"fontSizeCs"
+	]) {
+		const currentIsAbsent = current?.complexScriptPropertyAbsences?.includes(property) === true;
+		if (currentIsAbsent !== (expected?.complexScriptPropertyAbsences?.includes(property) === true) && currentIsAbsent) Reflect.deleteProperty(formatting, property);
+	}
+};
+/**
+* Reconcile source-authored provenance with the current visual mark set at the
+* one save boundary shared by editor commands, raw transactions and compare.
+* Unchanged groups keep exact source state (including equal direct values and
+* otherwise invisible sentinels); changed groups derive the smallest direct
+* override needed relative to the current style cascade.
+*/
+const reconcileAuthoredFormatting = ({ authoredFormatting, carrierlessContext, currentOverrideAttrs, inheritedFormatting, observedFormatting }) => {
+	const hasAuthoredFormatting = Object.keys(authoredFormatting).length > 0;
+	if (carrierlessContext === "ordinary" && currentOverrideAttrs === void 0 && !hasAuthoredFormatting && hasOnlyCarrierlessVisualFormatting(observedFormatting)) {
+		if (sameVisualFormatting(observedFormatting, inheritedFormatting)) return authoredFormatting;
+		if (observedFormatting.fontFamily === void 0 && sameVisualFormatting(inheritedFormatting, void 0)) return observedFormatting;
+	}
+	const expectedFormatting = hasAuthoredFormatting ? mergeTextFormatting(inheritedFormatting, authoredFormatting) : inheritedFormatting;
+	const changedGroups = changedVisualFormattingGroups(observedFormatting, expectedFormatting);
+	const reconciled = { ...authoredFormatting };
+	for (const property of Object.keys(RUN_FORMATTING_VISUAL_GROUPS)) {
+		const group = RUN_FORMATTING_VISUAL_GROUPS[property];
+		if (group === null || !changedGroups.has(group)) continue;
+		Reflect.deleteProperty(reconciled, property);
+		if (VISUAL_BOOLEAN_FORMATTING_PROPERTIES.has(property)) {
+			const observed = observedFormatting[property] === true;
+			if (observed !== (inheritedFormatting?.[property] === true)) Reflect.set(reconciled, property, observed);
+			continue;
+		}
+		const observed = observedFormatting[property];
+		if (observed === void 0) continue;
+		if (property === "fontFamily") {
+			const difference = fontFamilyDifference(observed, inheritedFormatting?.fontFamily);
+			if (difference) reconciled.fontFamily = difference;
+			continue;
+		}
+		if (!sameFormattingValue(observed, inheritedFormatting?.[property])) Reflect.set(reconciled, property, observed);
+	}
+	if (currentOverrideAttrs !== void 0) reconcileOverrideSignals(reconciled, currentOverrideAttrs, expectedRunFormattingOverrideAttrs(authoredFormatting), inheritedFormatting, observedFormatting);
+	return reconciled;
+};
+const formattingAuthorshipCost = (formatting) => {
+	let cost = 0;
+	const visit = (value) => {
+		if (value === void 0) return;
+		if (value === null || typeof value !== "object") {
+			cost++;
+			return;
+		}
+		const entries = Object.entries(value);
+		if (entries.length === 0) {
+			cost++;
+			return;
+		}
+		for (const [, nested] of entries) visit(nested);
+	};
+	for (const [property, value] of Object.entries(formatting)) if (property !== "styleId") visit(value);
+	return cost;
+};
 function marksToTextFormatting(marks, options) {
 	const formatting = {};
 	let directOverrideFormatting;
 	let directFontProperties;
-	let characterStyleRPr;
+	let characterStyleId;
 	let runFormattingOverrideMark;
+	let currentOverrideAttrs;
 	for (const mark of marks) switch (mark.type.name) {
 		case "bold":
 			formatting.bold = true;
-			formatting.boldCs = true;
 			break;
 		case "italic":
 			formatting.italic = true;
-			formatting.italicCs = true;
 			break;
 		case "underline": {
 			const attrs = expectUnderlineMarkAttrs(mark);
@@ -1563,12 +2286,9 @@ function marksToTextFormatting(marks, options) {
 		case "runShading":
 			formatting.shading = runShadingAttrsToShading(expectRunShadingMarkAttrs(mark));
 			break;
-		case "fontSize": {
-			const attrs = expectFontSizeMarkAttrs(mark);
-			formatting.fontSize = attrs.size;
-			formatting.fontSizeCs = attrs.size;
+		case "fontSize":
+			formatting.fontSize = expectFontSizeMarkAttrs(mark).size;
 			break;
-		}
 		case "fontFamily": {
 			const attrs = expectFontFamilyMarkAttrs(mark);
 			const ff = {};
@@ -1576,8 +2296,7 @@ function marksToTextFormatting(marks, options) {
 			if (attrs.hAnsi) ff.hAnsi = attrs.hAnsi;
 			if (attrs.eastAsia) ff.eastAsia = attrs.eastAsia;
 			if (attrs.hint) ff.hint = attrs.hint;
-			const csVal = attrs.cs || attrs.ascii;
-			if (csVal) ff.cs = csVal;
+			if (attrs.cs) ff.cs = attrs.cs;
 			if (attrs.asciiTheme) ff.asciiTheme = attrs.asciiTheme;
 			if (attrs.hAnsiTheme) ff.hAnsiTheme = attrs.hAnsiTheme;
 			if (attrs.eastAsiaTheme) ff.eastAsiaTheme = attrs.eastAsiaTheme;
@@ -1645,100 +2364,77 @@ function marksToTextFormatting(marks, options) {
 		case "characterStyle": {
 			const attrs = expectCharacterStyleMarkAttrs(mark);
 			formatting.styleId = attrs.styleId;
-			characterStyleRPr = attrs._styleRPr;
+			characterStyleId = attrs.styleId;
 			break;
 		}
 		default: break;
 	}
+	let authoredFormatting = {};
 	if (runFormattingOverrideMark) {
 		const overrideAttrs = expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark);
+		currentOverrideAttrs = overrideAttrs;
 		directFontProperties = overrideAttrs.directFontProperties;
-		applyRunFormattingOverrideAttrs(formatting, overrideAttrs);
 		directOverrideFormatting = {};
 		applyRunFormattingOverrideAttrs(directOverrideFormatting, overrideAttrs);
 		for (const property of directFontProperties ?? []) {
 			const value = formatting[property];
 			if (value !== void 0) Reflect.set(directOverrideFormatting, property, value);
 		}
+		authoredFormatting = authoredRunFormattingFromAttrs(overrideAttrs) ?? directOverrideFormatting;
 	}
-	if (characterStyleRPr) return subtractCharacterStyleFormatting({
-		directOverrideFormatting,
-		formatting,
-		inheritedFormatting: options?.inheritedFormatting,
-		styleRPr: characterStyleRPr
-	});
-	for (const property of [
-		"fontFamily",
-		"fontSize",
-		"color"
-	]) {
-		if (directFontProperties?.includes(property)) continue;
-		const value = formatting[property];
-		const inheritedValue = options?.inheritedFormatting?.[property];
-		const matchesInherited = property === "fontFamily" ? sameFontFamily(formatting.fontFamily, options?.inheritedFormatting?.fontFamily) : JSON.stringify(value) === JSON.stringify(inheritedValue);
-		if (inheritedValue !== void 0 && matchesInherited) Reflect.deleteProperty(formatting, property);
-	}
-	return formatting;
-}
-const sameFontFamily = (left, right) => [
-	"ascii",
-	"hAnsi",
-	"eastAsia",
-	"hint",
-	"asciiTheme",
-	"hAnsiTheme",
-	"eastAsiaTheme",
-	"csTheme"
-].every((property) => left?.[property] === right?.[property]) && (left?.cs ?? left?.ascii) === (right?.cs ?? right?.ascii);
-/**
-* Negatable boolean run-property keys whose serializer emits an explicit
-* `w:val="0"` override when the value is `false` (see `serializeTextFormatting`
-* in `runSerializer.ts`). Each entry pairs a base key with the complex-script
-* mirror that `marksToTextFormatting` sets alongside it (the bold/italic marks
-* set `*Cs` too), so a negative override disables both. Keys without a complex
-* mirror use `null`.
-*/
-const NEGATABLE_STYLE_KEYS = [
-	["bold", "boldCs"],
-	["italic", "italicCs"],
-	["strike", null],
-	["doubleStrike", null],
-	["allCaps", null],
-	["smallCaps", null],
-	["hidden", null],
-	["emboss", null],
-	["imprint", null],
-	["shadow", null],
-	["outline", null],
-	["rtl", null]
-];
-function subtractCharacterStyleFormatting({ directOverrideFormatting, formatting, inheritedFormatting, styleRPr }) {
-	const result = {};
-	const effectiveStyleFormatting = cascadeStyleTextFormatting([{
-		formatting: inheritedFormatting,
-		type: "direct"
-	}, {
-		formatting: styleRPr,
-		type: "style"
-	}]).formatting;
-	for (const key of Object.keys(formatting)) {
-		const value = formatting[key];
-		if (value === void 0) continue;
-		if (directOverrideFormatting?.[key] !== void 0) {
-			result[key] = value;
-			continue;
-		}
-		const styleValue = key === "styleId" ? void 0 : effectiveStyleFormatting?.[key];
-		if ((key === "boldCs" || key === "italicCs") && styleValue === false && value === true) continue;
-		if (styleValue !== void 0 && JSON.stringify(value) === JSON.stringify(styleValue)) continue;
-		result[key] = value;
+	if (characterStyleId !== void 0 && !options?.styleResolver) {
+		const conservativeFormatting = mergeTextFormatting(formatting, directOverrideFormatting) ?? {};
+		for (const property of currentOverrideAttrs?.complexScriptPropertyAbsences ?? []) Reflect.deleteProperty(conservativeFormatting, property);
+		return {
+			...conservativeFormatting,
+			styleId: characterStyleId
+		};
 	}
-	for (const [key, csKey] of NEGATABLE_STYLE_KEYS) {
-		if (effectiveStyleFormatting?.[key] !== true || formatting[key] !== void 0) continue;
-		result[key] = false;
-		if (csKey !== null) result[csKey] = false;
+	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting: paragraphFormattingForRun({
+			context: {
+				baseParagraphFormatting: options?.baseParagraphFormatting,
+				paragraphFormatting: options?.inheritedFormatting,
+				paragraphMarkFormatting: options?.paragraphMarkFormatting,
+				paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
+			},
+			directFormatting: authoredFormatting,
+			marks
+		}),
+		...options?.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
+	});
+	let reconciled = reconcileAuthoredFormatting({
+		authoredFormatting,
+		carrierlessContext: options?.paragraphMarkFormatting === void 0 ? "ordinary" : "paragraph-mark",
+		currentOverrideAttrs,
+		inheritedFormatting,
+		observedFormatting: formatting
+	});
+	if (runFormattingOverrideMark === void 0 && characterStyleId === void 0 && options?.paragraphMarkFormatting !== void 0) {
+		const suppressedInheritedFormatting = resolveEffectiveRunStyleFormatting({
+			marks,
+			paragraphFormatting: suppressParagraphMarkFormatting({
+				baseFormatting: options.baseParagraphFormatting,
+				directFormatting: authoredFormatting,
+				paragraphMarkFormatting: options.paragraphMarkFormatting,
+				paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
+			}),
+			...options.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
+		});
+		const suppressed = reconcileAuthoredFormatting({
+			authoredFormatting,
+			carrierlessContext: "paragraph-mark",
+			currentOverrideAttrs,
+			inheritedFormatting: suppressedInheritedFormatting,
+			observedFormatting: formatting
+		});
+		if (formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
 	}
-	return result;
+	return {
+		...reconciled,
+		...characterStyleId !== void 0 ? { styleId: characterStyleId } : {}
+	};
 }
 /**
 * Convert a ProseMirror table node to our Table type
@@ -1760,9 +2456,9 @@ function inferTableBorders(rows) {
 		}
 	}
 }
-function convertPMTable(node, documentCounts) {
+function convertPMTable(node, documentCounts, styleResolver = null) {
 	const attrs = expectTableAttrs(node);
-	const rows = convertPMTableRows(node, documentCounts);
+	const rows = convertPMTableRows(node, documentCounts, styleResolver);
 	const formatting = tableAttrsToFormatting(attrs) || void 0;
 	if (!formatting?.borders) {
 		const inferredBorders = inferTableBorders(rows);
@@ -1795,11 +2491,11 @@ function convertPMTable(node, documentCounts) {
 function restoreTablePropertyChanges(table, attrs) {
 	if (Array.isArray(attrs.tblPrChange) && attrs.tblPrChange.length > 0) table.propertyChanges = [...attrs.tblPrChange];
 }
-function convertPMTableRows(node, documentCounts) {
+function convertPMTableRows(node, documentCounts, styleResolver = null) {
 	const rows = [];
 	const activeVerticalMerges = /* @__PURE__ */ new Map();
 	node.forEach((rowNode) => {
-		if (rowNode.type.name === "tableRow") rows.push(convertPMTableRow(rowNode, documentCounts, activeVerticalMerges));
+		if (rowNode.type.name === "tableRow") rows.push(convertPMTableRow(rowNode, documentCounts, activeVerticalMerges, styleResolver));
 	});
 	return rows;
 }
@@ -1838,7 +2534,7 @@ function buildCellMarginsFromAttrs(m) {
 * inherited value becomes a direct override that outranks the style it came
 * from on reload. The resolved companion is what tells the two apart.
 */
-const sameResolvedValue = (live, resolved) => resolved !== void 0 && resolved !== null && canonicalJson(live) === canonicalJson(resolved);
+const sameResolvedValue = (live, resolved) => resolved !== void 0 && resolved !== null && sameFormattingValue(live, resolved);
 function tableAttrsToFormatting(attrs) {
 	if (attrs._originalFormatting) {
 		const orig = attrs._originalFormatting;
@@ -1887,7 +2583,7 @@ function tableAttrsToFormatting(attrs) {
 /**
 * Convert a ProseMirror table row node to our TableRow type
 */
-function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
+function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleResolver = null) {
 	const attrs = expectTableRowAttrs(node);
 	const cells = [];
 	let gridColumn = 0;
@@ -1908,7 +2604,7 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
 		if (cellNode.type.name === "tableCell" || cellNode.type.name === "tableHeader") {
 			const cellAttrs = expectTableCellAttrs(cellNode);
 			const colspan = Math.max(cellAttrs.colspan, 1);
-			cells.push(convertPMTableCell(cellNode, documentCounts));
+			cells.push(convertPMTableCell(cellNode, documentCounts, styleResolver));
 			if (cellAttrs.rowspan > 1) {
 				const continuationCells = cellAttrs._docxVMergeContinuationCells;
 				activeVerticalMerges?.set(gridColumn, {
@@ -1934,6 +2630,10 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
 			id: attrs.trIns.revisionId,
 			author: attrs.trIns.author,
 			...attrs.trIns.date != null && { date: attrs.trIns.date },
+			...attrs.trIns.utcDate != null && { utcDate: {
+				attribute: "w16du:dateUtc",
+				value: attrs.trIns.utcDate
+			} },
 			...attrs.trIns.initials != null && { initials: attrs.trIns.initials }
 		}
 	};
@@ -1943,6 +2643,10 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
 			id: attrs.trDel.revisionId,
 			author: attrs.trDel.author,
 			...attrs.trDel.date != null && { date: attrs.trDel.date },
+			...attrs.trDel.utcDate != null && { utcDate: {
+				attribute: "w16du:dateUtc",
+				value: attrs.trDel.utcDate
+			} },
 			...attrs.trDel.initials != null && { initials: attrs.trDel.initials }
 		}
 	};
@@ -1994,22 +2698,23 @@ function tableRowAttrsToFormatting(attrs) {
 /**
 * Convert a ProseMirror table cell node to our TableCell type
 */
-function convertPMTableCell(node, documentCounts) {
+function convertPMTableCell(node, documentCounts, styleResolver = null) {
 	const attrs = expectTableCellAttrs(node);
 	const content = [];
 	const textBoxAnchorMarkers = /* @__PURE__ */ new Map();
 	let previousStandaloneTextBox = null;
 	node.forEach((contentNode) => {
 		if (contentNode.type.name === "paragraph") {
-			content.push(convertPMParagraph(contentNode, documentCounts, textBoxAnchorMarkers));
+			content.push(convertPMParagraph(contentNode, documentCounts, textBoxAnchorMarkers, styleResolver));
 			previousStandaloneTextBox = null;
 		} else if (contentNode.type.name === "table") {
-			content.push(convertPMTable(contentNode, documentCounts));
+			content.push(convertPMTable(contentNode, documentCounts, styleResolver));
 			previousStandaloneTextBox = null;
 		} else if (contentNode.type.name === "textBox") previousStandaloneTextBox = appendTextBoxBlock(content, contentNode, {
 			pendingPageBreaks: 0,
 			previousStandaloneTextBox,
-			textBoxAnchorMarkers
+			textBoxAnchorMarkers,
+			styleResolver
 		});
 	});
 	removeUnresolvedTextBoxAnchors(content, textBoxAnchorMarkers);
@@ -2025,6 +2730,10 @@ function convertPMTableCell(node, documentCounts) {
 			id: attrs.cellMarker.info.revisionId,
 			author: attrs.cellMarker.info.author,
 			...attrs.cellMarker.info.date != null && { date: attrs.cellMarker.info.date },
+			...attrs.cellMarker.info.utcDate != null && { utcDate: {
+				attribute: "w16du:dateUtc",
+				value: attrs.cellMarker.info.utcDate
+			} },
 			...attrs.cellMarker.info.initials != null && { initials: attrs.cellMarker.info.initials }
 		};
 		if (attrs.cellMarker.kind === "merge") cell.structuralChange = {
@@ -2086,13 +2795,13 @@ function tableCellAttrsToFormatting(attrs) {
 * Convert a ProseMirror textBox node back to a Paragraph wrapping a ShapeContent run.
 * The text box content becomes a Shape with textBody.
 */
-function convertPMTextBox(node) {
+function convertPMTextBox(node, styleResolver = null) {
 	const attrs = expectTextBoxAttrs(node);
 	const verticalAlign = normalizeShapeTextAnchor(attrs.verticalAlign);
 	const childBlocks = [];
 	node.forEach((child) => {
-		if (child.type.name === "paragraph") childBlocks.push(convertPMParagraph(child));
-		else if (child.type.name === "table") childBlocks.push(convertPMTable(child));
+		if (child.type.name === "paragraph") childBlocks.push(convertPMParagraph(child, void 0, void 0, styleResolver));
+		else if (child.type.name === "table") childBlocks.push(convertPMTable(child, void 0, styleResolver));
 	});
 	const shape = {
 		type: "shape",
@@ -2188,8 +2897,11 @@ function updateDocumentContent(originalDocument, pmDoc) {
 * Used for converting edited header/footer PM content back to the document
 * model.
 */
-function proseDocToBlocks(pmDoc) {
-	return extractBlocks(pmDoc);
+function proseDocToBlocks(pmDoc, baseContent, styles) {
+	const blocks = extractBlocks(pmDoc, "resolve", styles ? createStyleEngine(styles) : null);
+	const linkedSources = restoreLinkedParagraphPropertySources(blocks);
+	if (baseContent) restoreParagraphPropertySources(blocks, baseContent, linkedSources.targets, linkedSources.sources);
+	return blocks;
 }
 //#endregion
 export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };