@stll/folio-core 0.33.1 → 0.34.0

package/dist/prosemirror/commands/comments.js

@@ -1,4 +1,5 @@
 import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
+import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { textFormattingToMarks } from "../conversion/toProseDoc.js";
 import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
@@ -61,6 +62,7 @@ function resolveChange(from, to, mode, revisionIds) {
 		const keepType = mode === "accept" ? insertionType : deletionType;
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
+		const removeKeptMarksInBulk = revisionSet === null && keepType !== void 0;
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
@@ -138,10 +140,29 @@ function resolveChange(from, to, mode, revisionIds) {
 					from: rangeFrom,
 					to: rangeTo
 				});
-				for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
+				if (!removeKeptMarksInBulk) {
+					for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
+				}
 				return true;
 			});
-			for (const range of deleteRanges.toReversed()) tr.delete(range.from, range.to);
+			if (removeKeptMarksInBulk) tr.removeMark(from, to, keepType);
+			let rangesToDelete = deleteRanges;
+			if (revisionSet === null) {
+				const coalescedDeleteRanges = [];
+				for (const range of deleteRanges) {
+					const previous = coalescedDeleteRanges.at(-1);
+					if (previous && range.from <= previous.to) {
+						previous.to = Math.max(previous.to, range.to);
+						continue;
+					}
+					coalescedDeleteRanges.push({
+						from: range.from,
+						to: range.to
+					});
+				}
+				rangesToDelete = coalescedDeleteRanges;
+			}
+			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
 			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
 			for (const op of pPrMarkOps) {
 				const mappedPos = tr.mapping.map(op.paragraphPos);
@@ -157,7 +178,7 @@ function resolveChange(from, to, mode, revisionIds) {
 					const resolved = tr.doc.resolve(mappedPos);
 					const previous = resolved.nodeBefore;
 					const sectionCanMoveBack = !carriesSection(paragraph) || previous?.type.name === paragraph.type.name && !carriesSection(previous);
-					const endsItsContainer = resolved.index() === resolved.parent.childCount - 1;
+					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
 					const canGo = op.markWasAdded || !endsItsContainer;
 					if (sectionCanMoveBack && holdsNoContent(paragraph) && canGo && resolved.parent.childCount > 1) {
 						if (carriesSection(paragraph) && previous) tr.setNodeMarkup(mappedPos - previous.nodeSize, void 0, {

package/dist/prosemirror/containerFinalParagraph.d.ts

@@ -0,0 +1,47 @@
+import { Node, ResolvedPos } from "prosemirror-model";
+//#region src/prosemirror/containerFinalParagraph.d.ts
+/**
+ * Whether the paragraph starting at `at` is the one its container ENDS with,
+ * which is the one place a paragraph mark cannot carry a revision.
+ *
+ * A deleted mark asks a reader to join the paragraph it ends with the one
+ * after it, and an inserted mark says that break was added, so rejecting it
+ * closes the paragraph back over the next one. A body, a table cell, a header
+ * or footer, a note and a text box each end with a paragraph that nothing
+ * follows, so neither direction can be resolved there: a consumer is left with
+ * a revision it can only ignore, and the redline no longer resolves to the two
+ * documents it was written from.
+ *
+ * A paragraph before a TABLE is not one of those: the table is a following
+ * sibling, so the paragraph does not end anything and carries its own mark
+ * like any other.
+ */
+declare const paragraphEndsItsContainer: (at: ResolvedPos, paragraphTypeName: string) => boolean;
+/**
+ * Every paragraph a container ENDS with in `doc`, with its position.
+ *
+ * One walk for the whole document: asking the question of each paragraph in
+ * turn costs a scan of its siblings each time, which is quadratic in a body
+ * whose paragraphs a batch has just filled.
+ */
+declare const finalParagraphsOf: (doc: Node, paragraphTypeName: string) => {
+  position: number;
+  node: Node;
+}[];
+/**
+ * The paragraph an added break can rotate BACK onto from the one at `at`: the
+ * paragraph the run of inserted ones was appended after.
+ *
+ * The walk crosses the inserted paragraphs — their own marks stay where they
+ * are, and only which paragraph is left markless changes — and stops at the
+ * first one whose mark is free. `null` when there is none: a table in between,
+ * which no mark joins across; a paragraph whose mark says something else,
+ * which the rotation must not overwrite; or a container whose every paragraph
+ * is new.
+ */
+declare const addedBreakCarrierBefore: (at: ResolvedPos, paragraphTypeName: string) => {
+  position: number;
+  node: Node;
+} | null;
+//#endregion
+export { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer };

package/dist/prosemirror/containerFinalParagraph.js

@@ -0,0 +1,92 @@
+//#region src/prosemirror/containerFinalParagraph.ts
+/**
+* A node the FILE holds as a child of the container it appears in.
+*
+* The editor keeps a text box as a block-level sibling of the paragraph that
+* anchors it; the file hangs it off that paragraph's own run, so it is not a
+* child of the container at all. A paragraph and a table are children in both.
+*/
+const isAContainerChild = (node, paragraphTypeName) => node.type.name === paragraphTypeName || node.type.spec["tableRole"] === "table";
+/** Whether every child from `fromIndex` on is one the file does not hold here. */
+const nothingFollowsIn = (parent, fromIndex, paragraphTypeName) => {
+	for (let index = fromIndex; index < parent.childCount; index++) if (isAContainerChild(parent.child(index), paragraphTypeName)) return false;
+	return true;
+};
+/**
+* Whether the paragraph starting at `at` is the one its container ENDS with,
+* which is the one place a paragraph mark cannot carry a revision.
+*
+* A deleted mark asks a reader to join the paragraph it ends with the one
+* after it, and an inserted mark says that break was added, so rejecting it
+* closes the paragraph back over the next one. A body, a table cell, a header
+* or footer, a note and a text box each end with a paragraph that nothing
+* follows, so neither direction can be resolved there: a consumer is left with
+* a revision it can only ignore, and the redline no longer resolves to the two
+* documents it was written from.
+*
+* A paragraph before a TABLE is not one of those: the table is a following
+* sibling, so the paragraph does not end anything and carries its own mark
+* like any other.
+*/
+const paragraphEndsItsContainer = (at, paragraphTypeName) => nothingFollowsIn(at.parent, at.index() + 1, paragraphTypeName);
+/**
+* Every paragraph a container ENDS with in `doc`, with its position.
+*
+* One walk for the whole document: asking the question of each paragraph in
+* turn costs a scan of its siblings each time, which is quadratic in a body
+* whose paragraphs a batch has just filled.
+*/
+const finalParagraphsOf = (doc, paragraphTypeName) => {
+	const found = [];
+	const collect = (node, contentStart) => {
+		let last = null;
+		node.forEach((child, offset) => {
+			const position = contentStart + offset;
+			if (child.type.name === paragraphTypeName) last = {
+				position,
+				node: child
+			};
+			else if (isAContainerChild(child, paragraphTypeName)) last = null;
+			if (!child.isTextblock && child.childCount > 0) collect(child, position + 1);
+		});
+		if (last !== null) found.push(last);
+	};
+	collect(doc, 0);
+	return found;
+};
+/** A paragraph's mark, when it says the break was ADDED. */
+const marksAnAddedBreak = (node) => {
+	const mark = node.attrs["pPrMark"];
+	if (typeof mark !== "object" || mark === null || !("kind" in mark)) return false;
+	return mark.kind === "ins" || mark.kind === "moveTo";
+};
+/**
+* The paragraph an added break can rotate BACK onto from the one at `at`: the
+* paragraph the run of inserted ones was appended after.
+*
+* The walk crosses the inserted paragraphs — their own marks stay where they
+* are, and only which paragraph is left markless changes — and stops at the
+* first one whose mark is free. `null` when there is none: a table in between,
+* which no mark joins across; a paragraph whose mark says something else,
+* which the rotation must not overwrite; or a container whose every paragraph
+* is new.
+*/
+const addedBreakCarrierBefore = (at, paragraphTypeName) => {
+	let position = at.pos;
+	for (let index = at.index() - 1; index >= 0; index--) {
+		const sibling = at.parent.child(index);
+		position -= sibling.nodeSize;
+		if (sibling.type.name !== paragraphTypeName) {
+			if (isAContainerChild(sibling, paragraphTypeName)) return null;
+			continue;
+		}
+		if (sibling.attrs["pPrMark"] == null) return {
+			position,
+			node: sibling
+		};
+		if (!marksAnAddedBreak(sibling)) return null;
+	}
+	return null;
+};
+//#endregion
+export { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer };

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
+import { TableAttrs, TableCellAttrs, TableRowAttrs } from "../schema/nodes.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/conversion/fromProseDoc.d.ts
 /**
@@ -12,7 +13,13 @@ type MarksToTextFormattingOptions = {
   inheritedFormatting: document_d_exports.TextFormatting | undefined;
 };
 declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
+declare function tableAttrsToFormatting(attrs: TableAttrs): document_d_exports.TableFormatting | undefined;
+/**
+ * Convert ProseMirror table row attrs to TableRowFormatting
+ */
+declare function tableRowAttrsToFormatting(attrs: TableRowAttrs): document_d_exports.TableRowFormatting | undefined;
 declare const standaloneTableCellFromProseMirror: (node: Node) => document_d_exports.TableCell;
+declare function tableCellAttrsToFormatting(attrs: TableCellAttrs): document_d_exports.TableCellFormatting | undefined;
 /**
  * Update a Document with content from a ProseMirror document
  * Preserves all non-content parts of the original document
@@ -27,4 +34,4 @@ declare function updateDocumentContent(originalDocument: document_d_exports.Docu
  */
 declare function proseDocToBlocks(pmDoc: Node): document_d_exports.BlockContent[];
 //#endregion
-export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, updateDocumentContent };
+export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -1,6 +1,7 @@
 import { numPrEqual } from "../../docx/numberingParser.js";
 import { ShapeOutlineStyleSchema, narrowEnum } from "../../docx/parserEnums.js";
 import { OUTLINE_STYLE_CSS_ALIASES, normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
+import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.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";
@@ -688,9 +689,9 @@ function createTrackedRunWrapper(type, info, child) {
 		content
 	};
 }
-function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false) {
+function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false, inheritedFormattingOverride) {
 	const content = [];
-	const inheritedFormatting = paragraph.type.name === "paragraph" ? expectParagraphAttrs(paragraph).defaultTextFormatting ?? void 0 : void 0;
+	const inheritedFormatting = inheritedFormattingOverride ?? (paragraph.type.name === "paragraph" ? expectParagraphAttrs(paragraph).defaultTextFormatting ?? void 0 : void 0);
 	const sortedEmptyHyperlinks = (emptyHyperlinks ?? []).map((attrs, order) => ({
 		attrs,
 		order
@@ -965,7 +966,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			}));
 		} else if (node.type.name === "sdt") {
 			flushCurrentInline();
-			content.push(createInlineSdtFromNode(node, textBoxAnchorMarkers));
+			content.push(createInlineSdtFromNode(node, textBoxAnchorMarkers, inheritedFormatting));
 		} else if (node.type.name === "math") {
 			flushCurrentInline();
 			content.push(createMathFromNode(node));
@@ -1368,11 +1369,11 @@ function createMathFromNode(node) {
 /**
 * Create an InlineSdt from a PM sdt node
 */
-function createInlineSdtFromNode(node, textBoxAnchorMarkers) {
+function createInlineSdtFromNode(node, textBoxAnchorMarkers, inheritedFormatting) {
 	return {
 		type: "inlineSdt",
 		properties: sdtPropertiesFromAttrs(expectSdtAttrs(node)),
-		content: extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers).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, 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")
 	};
 }
 /**
@@ -1523,6 +1524,7 @@ function createShapeRun(node) {
 function marksToTextFormatting(marks, options) {
 	const formatting = {};
 	let directOverrideFormatting;
+	let directFontProperties;
 	let characterStyleRPr;
 	let runFormattingOverrideMark;
 	for (const mark of marks) switch (mark.type.name) {
@@ -1650,9 +1652,14 @@ function marksToTextFormatting(marks, options) {
 	}
 	if (runFormattingOverrideMark) {
 		const overrideAttrs = expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark);
+		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);
+		}
 	}
 	if (characterStyleRPr) return subtractCharacterStyleFormatting({
 		directOverrideFormatting,
@@ -1660,8 +1667,29 @@ function marksToTextFormatting(marks, options) {
 		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`
@@ -1801,6 +1829,16 @@ function buildCellMarginsFromAttrs(m) {
 /**
 * Convert ProseMirror table attrs to TableFormatting
 */
+/**
+* Whether a live attr still holds what the style cascade resolved to.
+*
+* `toProseDoc` seeds an attr with the EFFECTIVE value — a border a table
+* style supplied, a margin a table declared — because that is what the editor
+* renders with. A save must write only what the node itself states, or the
+* 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);
 function tableAttrsToFormatting(attrs) {
 	if (attrs._originalFormatting) {
 		const orig = attrs._originalFormatting;
@@ -1824,7 +1862,7 @@ function tableAttrsToFormatting(attrs) {
 			type: tableWidthType ?? "dxa"
 		};
 		else delete result.width;
-		if (attrs.cellMargins) result.cellMargins = buildCellMarginsFromAttrs(attrs.cellMargins);
+		if (attrs.cellMargins && !sameResolvedValue(attrs.cellMargins, attrs._resolvedCellMargins)) result.cellMargins = buildCellMarginsFromAttrs(attrs.cellMargins);
 		return result;
 	}
 	const tableWidth = attrs.width;
@@ -2022,8 +2060,8 @@ function tableCellAttrsToFormatting(attrs) {
 		if (attrs.verticalAlign !== (orig.verticalAlign ?? void 0)) if (attrs.verticalAlign) result.verticalAlign = attrs.verticalAlign;
 		else delete result.verticalAlign;
 		if (backgroundChanged) result.shading = cellShadingFromAttrs(attrs);
-		if (attrs.borders) result.borders = attrs.borders;
-		if (attrs.margins) result.margins = buildCellMarginsFromAttrs(attrs.margins);
+		if (attrs.borders && !sameResolvedValue(attrs.borders, attrs._resolvedBorders)) result.borders = attrs.borders;
+		if (attrs.margins && !sameResolvedValue(attrs.margins, attrs._resolvedMargins)) result.margins = buildCellMarginsFromAttrs(attrs.margins);
 		if (attrs.textDirection !== (orig.textDirection ?? void 0)) if (attrs.textDirection) result.textDirection = attrs.textDirection;
 		else delete result.textDirection;
 		return result;
@@ -2154,4 +2192,4 @@ function proseDocToBlocks(pmDoc) {
 	return extractBlocks(pmDoc);
 }
 //#endregion
-export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, updateDocumentContent };
+export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting, updateDocumentContent };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -18,6 +18,7 @@ import { shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { sdtAttrsFromProperties } from "./sdtAttrs.js";
 import { panic } from "better-result";
 //#region src/prosemirror/conversion/toProseDoc.ts
+const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
 /**
 * Build a `nextTextBoxGroupId()` generator salted with a random per-load
 * nonce, so minted text-box anchor ids (`<salt>:<group>:<index>`) are unique
@@ -139,7 +140,12 @@ function toProseDoc(document, options) {
 	};
 	nodes.push(...convertBodyBlocks(paragraphs));
 	if (nodes.length === 0) nodes.push(schema.node("paragraph", {}, []));
-	const pmDoc = stampNumberedRefFieldBaselines(schema.node("doc", null, nodes));
+	const finalSectionStart = document.package.document.sections?.at(-1)?.properties.sectionStart ?? null;
+	const adjustLineHeightInTable = document.package.settings?.adjustLineHeightInTable === true;
+	const pmDoc = stampNumberedRefFieldBaselines(schema.node("doc", {
+		_finalSectionStart: finalSectionStart,
+		_adjustLineHeightInTable: adjustLineHeightInTable
+	}, nodes));
 	assertValidProseMirrorDocument(pmDoc, "Document conversion produced an invalid ProseMirror document");
 	return pmDoc;
 }
@@ -210,6 +216,7 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 	const paragraphRunFormatting = resolveRunFormattingWithoutDefaults(paragraph.formatting?.runProperties, styleResolver);
 	let inheritableParagraphRunFormatting;
 	if (paragraphRunFormatting && !isTocParagraph) inheritableParagraphRunFormatting = stripParagraphMarkFormattingForBodyRuns(paragraphRunFormatting);
+	const ordinaryStyleFormatting = paragraph.formatting?.styleId === void 0 ? mergeTextFormatting(styleRunFormatting, extraRunFormatting) : mergeTextFormatting(extraRunFormatting, styleRunFormatting);
 	const orderedToggleFormatting = cascadeStyleTextFormatting([
 		{
 			formatting: styleResolver?.getDocDefaults()?.rPr,
@@ -223,7 +230,7 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 			formatting: paragraphStyleRunFormatting,
 			type: "style"
 		}
-	], { ordinaryFormatting: mergeTextFormatting(styleRunFormatting, extraRunFormatting) });
+	], { ordinaryFormatting: ordinaryStyleFormatting });
 	let baseRunFormatting = orderedToggleFormatting.formatting;
 	if (paragraphStyleFontFamily) baseRunFormatting = mergeTextFormatting(baseRunFormatting, { fontFamily: paragraphStyleFontFamily });
 	const paragraphMarkPrecedesStyle = paragraph.formatting?.styleId !== void 0;
@@ -850,7 +857,10 @@ function convertTable(table, styleResolver, context) {
 	if (table.formatting?.justification) attrs.justification = table.formatting.justification;
 	if (columnWidths) attrs.columnWidths = columnWidths;
 	if (table.formatting?.floating) attrs.floating = table.formatting.floating;
-	if (cellMarginsAttr) attrs.cellMargins = cellMarginsAttr;
+	if (cellMarginsAttr) {
+		attrs.cellMargins = cellMarginsAttr;
+		attrs._resolvedCellMargins = cellMarginsAttr;
+	}
 	if (table.formatting?.look) attrs.look = table.formatting.look;
 	if (table.formatting?.borders) attrs.borders = table.formatting.borders;
 	if (resolvedTableIndent) attrs._resolvedIndent = resolvedTableIndent;
@@ -997,10 +1007,10 @@ function convertTableRow(row, styleResolver, context, isHeaderRow, columnWidths,
 		let cellConditionalStyle = conditionalStyles?.wholeTable;
 		cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, effectiveRowBandStyle);
 		cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, vertBandStyle);
-		if (cellIsFirstRow && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.firstRow);
-		if (cellIsLastRow && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.lastRow);
 		if (cellIsFirstCol && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.firstCol);
 		if (cellIsLastCol && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.lastCol);
+		if (cellIsFirstRow && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.firstRow);
+		if (cellIsLastRow && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.lastRow);
 		if (cellIsFirstRow && cellIsFirstCol && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow) && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.nwCell);
 		if (cellIsFirstRow && cellIsLastCol && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow) && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.neCell);
 		if (cellIsLastRow && cellIsFirstCol && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow) && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.swCell);
@@ -1059,8 +1069,14 @@ function convertTableCell({ cell, styleResolver, context, isHeader, gridWidthPer
 	if (formatting?.noWrap !== void 0) attrs.noWrap = formatting.noWrap;
 	const hideMark = formatting?.hideMark ?? conditionalStyle?.tcPr?.hideMark;
 	if (hideMark !== void 0) attrs.hideMark = hideMark;
-	if (effectiveFormatting.borders) attrs.borders = effectiveFormatting.borders;
-	if (effectiveFormatting.margins) attrs.margins = effectiveFormatting.margins;
+	if (effectiveFormatting.borders) {
+		attrs.borders = effectiveFormatting.borders;
+		attrs._resolvedBorders = effectiveFormatting.borders;
+	}
+	if (effectiveFormatting.margins) {
+		attrs.margins = effectiveFormatting.margins;
+		attrs._resolvedMargins = effectiveFormatting.margins;
+	}
 	if (formatting) attrs._originalFormatting = formatting;
 	if (cell.propertyChanges && cell.propertyChanges.length > 0) attrs.tcPrChange = [...cell.propertyChanges];
 	if (cell.structuralChange?.type === "tableCellInsertion") attrs.cellMarker = {
@@ -1256,6 +1272,7 @@ function buildRunMarks(runFormatting, inherited, styleResolver) {
 		hasCharacterStyle: styleId !== void 0,
 		paragraphMarkOverrides: inherited.paragraphMarkOverrides
 	}) });
+	addDirectFontProvenance(marks, runFormatting);
 	if (styleId) {
 		const styleRPr = characterStyleFormatting ? marksToTextFormatting(textFormattingToMarks(characterStyleFormatting)) : void 0;
 		marks.push(schema.mark("characterStyle", {
@@ -1268,6 +1285,24 @@ function buildRunMarks(runFormatting, inherited, styleResolver) {
 		mergedFormatting
 	};
 }
+const addDirectFontProvenance = (marks, 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 (!directFormatting || !Object.keys(directFormatting).some((property) => property !== "styleId")) 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,
+		...directFontProperties.length > 0 && { directFontProperties }
+	});
+	if (index >= 0) {
+		marks[index] = override;
+		return;
+	}
+	marks.push(override);
+};
 const ORDINARY_STYLE_TOGGLE_KEYS = [
 	"bold",
 	"italic",
@@ -1649,12 +1684,12 @@ function convertShape(shape) {
 		position
 	});
 }
-function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, context, extraRunFormatting, tableParagraphOverlay }) {
+function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, context, extraRunFormatting, preserveEmptyWrapper, tableParagraphOverlay }) {
 	const { textBoxes, textBoxAnchors } = extractTextBoxesFromParagraph(block, textBoxGroupId);
 	const pmParagraph = convertParagraph(block, styleResolver, context.nextHyperlinkInstanceIndex, context.pairedBookmarkIds, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
 	const nodes = [];
 	const isEmptyAfterExtraction = textBoxes.length > 0 && !hasContentBesidesTextBoxAnchors(pmParagraph);
-	const keepWrapperParagraph = isEmptyAfterExtraction && hasParagraphBoundaryPayload(block, pmParagraph);
+	const keepWrapperParagraph = isEmptyAfterExtraction && (preserveEmptyWrapper === true || hasParagraphBoundaryPayload(block, pmParagraph));
 	if (!isEmptyAfterExtraction || keepWrapperParagraph) nodes.push(pmParagraph);
 	for (const { textBox, anchorId, trackedChange, inlineSdts } of textBoxes) nodes.push(convertTextBox(textBox, styleResolver, {
 		placement: isEmptyAfterExtraction && !keepWrapperParagraph ? "standalone" : "inlineWithPrevious",
@@ -1920,11 +1955,23 @@ function headerFooterToProseDoc(content, options) {
 	};
 	const convertBlocks = (blocks) => {
 		const out = [];
-		for (const block of blocks) if (block.type === "paragraph") out.push(...convertParagraphWithTextBoxes(block, styleResolver, {
-			textBoxGroupId: nextTextBoxGroupId(),
-			context: conversionContext
-		}));
-		else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
+		for (const block of blocks) if (block.type === "paragraph") {
+			const isDetachedWatermarkHost = Reflect.get(block, DETACHED_WATERMARK_HOST) === true;
+			const paragraphNodes = convertParagraphWithTextBoxes(block, styleResolver, {
+				textBoxGroupId: nextTextBoxGroupId(),
+				context: conversionContext,
+				preserveEmptyWrapper: isDetachedWatermarkHost
+			});
+			if (isDetachedWatermarkHost) {
+				const paragraphNodeIndex = paragraphNodes.findIndex(({ type }) => type.name === "paragraph");
+				const paragraphNode = paragraphNodes[paragraphNodeIndex];
+				if (paragraphNode) paragraphNodes[paragraphNodeIndex] = paragraphNode.type.create({
+					...paragraphNode.attrs,
+					_detachedWatermarkHost: true
+				}, paragraphNode.content, paragraphNode.marks);
+			}
+			out.push(...paragraphNodes);
+		} else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
 		else out.push(convertBlockSdt(block, convertBlocks));
 		return out;
 	};

package/dist/prosemirror/extensions/core/DocExtension.js

@@ -6,7 +6,13 @@ import { createNodeExtension } from "../create.js";
 const DocExtension = createNodeExtension({
 	name: "doc",
 	schemaNodeName: "doc",
-	nodeSpec: { content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt)+" }
+	nodeSpec: {
+		attrs: {
+			_finalSectionStart: { default: null },
+			_adjustLineHeightInTable: { default: false }
+		},
+		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt)+"
+	}
 });
 //#endregion
 export { DocExtension };

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -223,6 +223,7 @@ const paragraphNodeSpec = {
 		pageBreakBefore: { default: null },
 		renderedPageBreakBefore: { default: null },
 		_pageBreakCarrier: { default: null },
+		_detachedWatermarkHost: { default: null },
 		_trailingPageBreak: { default: null },
 		keepNext: { default: null },
 		keepLines: { default: null },

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

@@ -50,6 +50,7 @@ const RunFormattingOverrideExtension = createMarkExtension({
 	schemaMarkName: "runFormattingOverride",
 	markSpec: {
 		attrs: {
+			directFontProperties: { default: null },
 			bold: { default: null },
 			italic: { default: null },
 			underline: { default: null },

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

@@ -151,6 +151,7 @@ const tableSpec = {
 		columnWidths: { default: null },
 		floating: { default: null },
 		cellMargins: { default: null },
+		_resolvedCellMargins: { default: null },
 		look: { default: null },
 		borders: { default: null },
 		_resolvedIndent: { default: null },
@@ -319,7 +320,9 @@ const tableCellSpec = {
 		backgroundColor: { default: null },
 		_resolvedBackgroundColor: { default: null },
 		borders: { default: null },
+		_resolvedBorders: { default: null },
 		margins: { default: null },
+		_resolvedMargins: { default: null },
 		textDirection: { default: null },
 		noWrap: { default: false },
 		hideMark: { default: false },
@@ -375,7 +378,9 @@ const tableHeaderSpec = {
 		backgroundColor: { default: null },
 		_resolvedBackgroundColor: { default: null },
 		borders: { default: null },
+		_resolvedBorders: { default: null },
 		margins: { default: null },
+		_resolvedMargins: { default: null },
 		textDirection: { default: null },
 		noWrap: { default: false },
 		hideMark: { default: false },

package/dist/prosemirror/schema/marks.d.ts

@@ -1,5 +1,5 @@
-import { document_d_exports } from "../../types/document.js";
 import { ShadingProperties } from "../../types/colors.js";
+import { document_d_exports } from "../../types/document.js";
 //#region src/prosemirror/schema/marks.d.ts
 /**
  * Text color mark attributes
@@ -121,17 +121,11 @@ type RunPropertyChangeMarkAttrs = {
   provenance: TrackedChangeProvenance;
   suggestionId?: string;
 };
-type RunFormattingOverrideAttrs = { [K in keyof Pick<document_d_exports.TextFormatting, "bold" | "italic" | "strike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline">]?: boolean; } & {
+type RunFormattingOverrideAttrs = Partial<Record<"bold" | "boldCs" | "cs" | "italic" | "italicCs" | "strike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline", boolean>> & {
+  directFontProperties?: readonly ("fontFamily" | "fontSize" | "color")[];
   doubleStrike?: false;
   rtl?: false;
-  /** Independent complex-script weight (`w:bCs`). */
-  boldCs?: boolean;
-  /** Force complex-script formatting for the full run (`w:cs`). */
-  cs?: boolean;
-  /** Independent complex-script size in half-points (`w:szCs`). */
   fontSizeCs?: number;
-  /** Independent complex-script slant (`w:iCs`). */
-  italicCs?: boolean;
   underline?: "none";
 };
 /**

package/dist/prosemirror/schema/nodes.d.ts

@@ -569,6 +569,13 @@ type TableAttrs = {
   look?: document_d_exports.TableLook;
   /** Table-level borders (w:tblBorders) — full BorderSpec per side */
   borders?: document_d_exports.TableBorders;
+  /**
+   * Effective default cell margins after the table-style cascade. PM-only;
+   * never serialized. What `cellMargins` resolves to when the table declares
+   * none of its own, so a save can tell a value a style supplied from one the
+   * table states — and stop writing the style's into the table's `w:tblPr`.
+   */
+  _resolvedCellMargins?: TableAttrs["cellMargins"];
   /** Effective table indent after style resolution. PM-only; never serialized. */
   _resolvedIndent?: NonNullable<document_d_exports.TableFormatting["indent"]>;
   /** Style-derived table justification fallback. PM-only; never serialized. */
@@ -677,6 +684,14 @@ type TableCellAttrs = {
   hideMark?: boolean;
   /** Cell borders — full BorderSpec per side (style, color, size) */
   borders?: document_d_exports.TableCellBorders;
+  /**
+   * Effective borders after the table and table-style cascade. PM-only; never
+   * serialized. The companion to `borders` that `_resolvedBackgroundColor` is
+   * to `backgroundColor`: what the cell renders with when it declares none of
+   * its own, so a save can tell a border a style supplied from one the cell
+   * states.
+   */
+  _resolvedBorders?: document_d_exports.TableCellBorders;
   /** Cell margins/padding in twips per side */
   margins?: {
     top?: number;
@@ -684,6 +699,13 @@ type TableCellAttrs = {
     left?: number;
     right?: number;
   };
+  /** Effective margins after the cascade. PM-only; never serialized. */
+  _resolvedMargins?: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  };
   /** Original cell formatting from DOCX for lossless round-trip serialization */
   _originalFormatting?: document_d_exports.TableCellFormatting;
   /** Tracked cell property changes (w:tcPrChange) for round-trip + accept/reject */