@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/commands/comments.js

@@ -7,21 +7,23 @@ import { expectFieldAttrs, expectParagraphAttrs, expectRunPropertyChangeMarkAttr
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { enclosingRevisionIds, resolutionRemovesControl, withoutResolvedEnclosures } from "../contentControlRevisions.js";
 import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
+import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
-import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
-import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
+import { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
-import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
+import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
-import { reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow } from "../tableGridMutation.js";
+import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
+import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
@@ -106,6 +108,7 @@ function resolveChange(from, to, mode, revisionIds) {
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
+			tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 			const deleteRanges = [];
 			/** Where resolved inline content began and ended, in `state.doc`. */
 			const resolvedBoundaries = [];
@@ -278,13 +281,18 @@ function resolveChange(from, to, mode, revisionIds) {
 			tableCellStructuralOps.sort((left, right) => right.cellPos - left.cellPos);
 			let resolvedTableCellStructure = false;
 			let failedTableCellMergeResolution = false;
-			const emptiedTables = [];
+			const emptiedTables = { pending: false };
 			for (const op of tableCellStructuralOps) {
 				const mappedPos = tr.mapping.map(op.cellPos);
 				const cell = tr.doc.nodeAt(mappedPos);
 				if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") continue;
 				if (op.type === "merge") {
-					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge(tr, mappedPos, op.mode);
+					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge({
+						tr,
+						cellPos: mappedPos,
+						mode: op.mode,
+						revisionSet: op.revisionSet
+					});
 					if (!resolved) {
 						failedTableCellMergeResolution = true;
 						break;
@@ -301,9 +309,15 @@ function resolveChange(from, to, mode, revisionIds) {
 				resolvedTableCellStructure = true;
 			}
 			if (failedTableCellMergeResolution) return false;
-			for (const { position, mapFrom } of emptiedTables) removeRowsWithoutCells(tr, tr.mapping.slice(mapFrom).map(position));
+			removeRowsWithoutCellsAfterBatch(tr, emptiedTables);
 			if (resolvedTableCellStructure) markStructuralChange(tr);
 			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
+			const pendingTables = [];
+			state.doc.descendants((node, position) => {
+				if (node.type.spec["tableRole"] === "table" && runInCellPending(node)) pendingTables.push(position);
+				return !node.isTextblock;
+			});
+			const joinSeams = [];
 			for (const op of pPrMarkOps) {
 				const mappedPos = tr.mapping.map(op.paragraphPos);
 				const paragraph = tr.doc.nodeAt(mappedPos);
@@ -323,7 +337,18 @@ function resolveChange(from, to, mode, revisionIds) {
 					nextPos += boundary.nodeSize;
 				}
 				const nextNode = nextPos < tr.doc.content.size ? tr.doc.nodeAt(nextPos) : null;
-				if (!(nextNode?.type.name === paragraph.type.name)) {
+				const joinable = nextNode?.type.name === paragraph.type.name;
+				const ranIn = nextNode?.type.spec["tableRole"] === "table" && boundaries.length === 0 && !pendingTables.some((position) => tr.mapping.map(position) === nextPos) ? runParagraphIntoTable({
+					tr,
+					paragraphPos: mappedPos,
+					styleResolver
+				}) : null;
+				if (ranIn) {
+					tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
+					markParagraphPropertySourceTransfers(tr, [ranIn.transfer]);
+					continue;
+				}
+				if (!joinable) {
 					const resolved = tr.doc.resolve(mappedPos);
 					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
 					const canGo = op.markWasAdded || !endsItsContainer;
@@ -340,12 +365,6 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				try {
 					if (boundaries.length > 0) {
-						const emptyFirstParagraph = holdsNoContent(paragraph);
-						const joinedAttrs = {
-							...(emptyFirstParagraph ? nextNode : paragraph).attrs,
-							pPrMark: nextNode.attrs["pPrMark"],
-							_sectionProperties: nextNode.attrs["_sectionProperties"]
-						};
 						const leftToken = getProseParagraphPropertySourceToken(paragraph);
 						const rightToken = getProseParagraphPropertySourceToken(nextNode);
 						const inlineBookmarks = inlineBookmarksForParagraphJoin({
@@ -355,16 +374,31 @@ function resolveChange(from, to, mode, revisionIds) {
 						});
 						if (!inlineBookmarks) continue;
 						tr.replaceWith(joinPos - 1, nextPos + 1, inlineBookmarks);
-						tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
-						if (emptyFirstParagraph) markParagraphPropertySourceTransfers(tr, [{
+						tr.setNodeMarkup(mappedPos, void 0, nextNode.attrs);
+						markParagraphPropertySourceTransfers(tr, [{
 							displacedToken: typeof leftToken === "string" ? leftToken : null,
 							selectedToken: typeof rightToken === "string" ? rightToken : null
 						}]);
+						if (styleResolver && paragraph.content.size > 0) rebaseParagraphRuns({
+							previousContext: paragraphRunStyleContext(paragraph, styleResolver),
+							paragraphPosition: mappedPos,
+							range: {
+								from: 0,
+								to: paragraph.content.size
+							},
+							styleResolver,
+							tr
+						});
 					} else joinAtParagraphMark({
 						tr,
 						paragraphPos: mappedPos,
 						paragraph,
-						next: nextNode
+						next: nextNode,
+						styleResolver
+					});
+					joinSeams.push({
+						position: mappedPos + 1 + paragraph.content.size,
+						step: tr.steps.length
 					});
 					if (ownsSectionEndpoint(paragraph)) {
 						removedSectionEndpointCount++;
@@ -378,9 +412,10 @@ function resolveChange(from, to, mode, revisionIds) {
 				removedReferences: removedSectionReferences
 			});
 			if (!terminalTableDeletionIsPending(tr)) resolveTerminalTableReviewCarrier(tr, mode);
+			const seams = new Set(joinSeams.map(({ position, step }) => tr.mapping.slice(step).map(position)));
 			rejoinRunsAt({
 				tr,
-				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)),
+				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)).filter((position) => !seams.has(position)),
 				styleResolver
 			});
 			if (tr.steps.length > 0) dispatch(tr);
@@ -559,6 +594,7 @@ function isTableCellRevisionAttr(value) {
 	const info = value.info;
 	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
 }
+/** Record rows for a final sweep after every cell revision has resolved. */
 function deleteTableCellAt(tr, cellPos, emptied) {
 	const cell = tr.doc.nodeAt(cellPos);
 	if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") return;
@@ -573,9 +609,10 @@ function deleteTableCellAt(tr, cellPos, emptied) {
 	const removedColumn = TableMap.get(table).findCell(cellOffset).left;
 	const spansDown = Number(cell.attrs["rowspan"]) > 1;
 	if (row.childCount > 1 || spansDown) {
-		if (row.childCount === 1) emptied.push({
-			position: tablePosition,
-			mapFrom: tr.mapping.maps.length
+		if (row.childCount === 1) markRowEmptiedInBatch({
+			tr,
+			rowPosition: resolved.start() - 1,
+			emptied
 		});
 		tr.delete(cellPos, cellPos + cell.nodeSize);
 		reconcileTableGridAfterColumnRemoval({
@@ -1336,7 +1373,10 @@ const shiftAddedParagraphBreakBefore = ({ tr, paragraphPosition, mark, fallbackA
 	const paragraph = tr.doc.nodeAt(paragraphPosition);
 	if (!paragraph || paragraph.type.name !== "paragraph") return false;
 	const resolved = tr.doc.resolve(paragraphPosition);
-	const carrier = addedBreakCarrierBefore(resolved, paragraph.type.name);
+	const carrier = addedBreakCarrierBefore({
+		at: resolved,
+		paragraphTypeName: paragraph.type.name
+	});
 	if (!carrier) return false;
 	const path = [{
 		node: paragraph,

package/dist/prosemirror/commands/formatPainter.js

@@ -1,6 +1,6 @@
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs } from "../attrs/index.js";
-import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../runFormattingReconciliation.js";
 import { paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting } from "../runStyleFormatting.js";
 //#region src/prosemirror/commands/formatPainter.ts

package/dist/prosemirror/commands/hyperlink.js

@@ -1,5 +1,6 @@
 import { normalizeUserUrl } from "../../utils/urlSecurity.js";
 import { expectHyperlinkMarkAttrs } from "../attrs/index.js";
+import { removeHyperlinkInRange } from "../hyperlinkRemoval.js";
 //#region src/prosemirror/commands/hyperlink.ts
 const hyperlinkHref = (mark) => expectHyperlinkMarkAttrs(mark).href;
 /**
@@ -87,7 +88,7 @@ const removeHyperlinkAtCursor = (view, { popupHref }) => {
 	const ranges = collectHyperlinkRanges($from.parent, $from.start(), hlType, hyperlinkHref(linkMark));
 	const targetRange = rangeAtCursor(ranges, $from.pos);
 	if (!targetRange) return false;
-	const tr = view.state.tr.removeMark(targetRange.start, targetRange.end, hlType);
+	const tr = removeHyperlinkInRange(view.state, view.state.tr, targetRange.start, targetRange.end);
 	view.dispatch(tr.scrollIntoView());
 	return true;
 };

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

@@ -48,8 +48,9 @@ declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignm
 declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnapshot;
 /**
  * Build the attr patch that rejecting one pPrChange applies to a paragraph:
- * every in-scope key set to the stored previous value, or reset to `null`
- * when the stored old pPr does not carry it. Keys the record captured beyond
+ * every in-scope key set to the stored previous value, or to what the style
+ * (`inheritedFormatting`) supplies when the stored old pPr does not carry it,
+ * `null` when neither does. Keys the record captured beyond
  * the scoped set (editor-created list suggestions snapshot list-rendering
  * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
  */

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,8 +1,11 @@
+import { isStyleSourcedParagraphNumbering } from "../../internal/paragraphFormattingSerialization.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionFromBidi } from "../paragraphDirection.js";
+import { PARAGRAPH_FORMATTING_WRITE_BACK, STYLE_RESOLVED_PARAGRAPH_FIELDS } from "../paragraphFormattingProvenance.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
+import { sameFormattingValue } from "../runFormattingFromMarks.js";
 //#region src/prosemirror/commands/propertyChangeScope.ts
 /** Editor-only suggestions are rebased away before save; every other entry emits `w:pPrChange`. */
 const hasSerializableParagraphPropertyChange = (changes) => changes?.some(({ info }) => info.provenance !== "suggested") === true;
@@ -106,12 +109,29 @@ const PPR_SPACING_ATTR_KEYS = /* @__PURE__ */ new Set([
 	"spacingExplicit",
 	"_autospacingBase"
 ]);
+/**
+* Whether the attr holds only what the paragraph's style resolves to: the
+* paragraph does not state it (its source `w:pPr` has no such field) and the
+* value is the style's. The same test a save applies before writing it.
+*/
+const styleSuppliedParagraphValue = (attrs, key) => {
+	if (!STYLE_RESOLVED_ATTR_FIELDS.has(key)) return false;
+	const field = key;
+	const inherited = attrs._resolvedFormatting?.[field];
+	return attrs._originalFormatting?.[field] === void 0 && inherited !== void 0 && inherited !== null && sameFormattingValue(Reflect.get(attrs, key), inherited);
+};
+/** Fields whose attr carries the style-resolved value under the field's own name. */
+const STYLE_RESOLVED_ATTR_FIELDS = new Set(STYLE_RESOLVED_PARAGRAPH_FIELDS.filter((field) => PARAGRAPH_FORMATTING_WRITE_BACK[field].attr === field));
 /** The in-scope paragraph properties as they stand, for a `w:pPrChange` record. */
 const paragraphPropertiesSnapshot = (node) => {
 	const attrs = expectParagraphAttrs(node);
 	const snapshot = {};
 	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
-		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key)) continue;
+		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
+		if (styleSuppliedParagraphValue(attrs, key)) continue;
+		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
+		if (styleSuppliedParagraphValue(attrs, key)) continue;
+		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
 		const value = attrs[key];
 		if (key === "hangingIndent" && value === false && attrs._originalFormatting?.hangingIndent === void 0) continue;
 		if (value !== null && value !== void 0) snapshot[key] = value;
@@ -177,15 +197,19 @@ const PPR_CHANGE_SCOPED_FORMATTING_KEYS = [
 ];
 /**
 * Build the attr patch that rejecting one pPrChange applies to a paragraph:
-* every in-scope key set to the stored previous value, or reset to `null`
-* when the stored old pPr does not carry it. Keys the record captured beyond
+* every in-scope key set to the stored previous value, or to what the style
+* (`inheritedFormatting`) supplies when the stored old pPr does not carry it,
+* `null` when neither does. Keys the record captured beyond
 * the scoped set (editor-created list suggestions snapshot list-rendering
 * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
 */
 function paragraphRejectAttrPatch(previousFormatting, inheritedFormatting) {
 	const prev = previousFormatting ?? {};
 	const patch = {};
-	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) patch[key] = Object.hasOwn(prev, key) ? prev[key] ?? null : null;
+	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) if (Object.hasOwn(prev, key)) patch[key] = prev[key] ?? null;
+	else if (STYLE_RESOLVED_ATTR_FIELDS.has(key)) patch[key] = Reflect.get(inheritedFormatting ?? {}, key) ?? null;
+	else patch[key] = null;
+	if (!Object.hasOwn(prev, "indentFirstLine") && !Object.hasOwn(prev, "hangingIndent")) patch["hangingIndent"] = inheritedFormatting?.hangingIndent ?? null;
 	if (!Object.hasOwn(prev, "alignment")) patch["alignment"] = inheritedFormatting?.alignment ?? null;
 	patch["alignmentFromStyle"] = inheritedFormatting?.alignment;
 	const directSpacing = paragraphSpacingFromFormatting(prev);

package/dist/prosemirror/commands/resolveAllTableChanges.js

@@ -6,6 +6,7 @@ import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { resolveAllNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
 import { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.js";
+import { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions } from "./tableMergeFoldDecisions.js";
 import { panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 import { StepMap } from "prosemirror-transform";
@@ -131,10 +132,12 @@ const cellRevisionMarker = (cell) => {
 	const marker = cell.attrs["cellMarker"];
 	if (typeof marker !== "object" || marker === null || !("kind" in marker) || marker.kind !== "ins" && marker.kind !== "del" && marker.kind !== "merge" || !("info" in marker) || typeof marker.info !== "object" || marker.info === null || !("revisionId" in marker.info) || typeof marker.info.revisionId !== "number") return null;
 	const verticalMergeOriginal = "verticalMergeOriginal" in marker && isTableCellMergeRevisionValue(marker.verticalMergeOriginal) ? marker.verticalMergeOriginal : void 0;
+	const verticalMerge = "verticalMerge" in marker && isTableCellMergeRevisionValue(marker.verticalMerge) ? marker.verticalMerge : void 0;
 	return {
 		kind: marker.kind,
 		info: { revisionId: marker.info.revisionId },
-		...verticalMergeOriginal ? { verticalMergeOriginal } : {}
+		...verticalMergeOriginal ? { verticalMergeOriginal } : {},
+		...verticalMerge ? { verticalMerge } : {}
 	};
 };
 /**
@@ -356,6 +359,12 @@ const compactColumnWidths = (widths, removals) => {
 /** Resolve all cell edits in reverse order against one grid and mutable slots. */
 const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched, sourceTable }) => {
 	const map = TableMap.get(table);
+	const mergeDecisions = tableMergeFoldDecisions({
+		table,
+		mode,
+		revisionSet: null
+	});
+	if (mergeDecisions.invalid.size > 0) return failedTableResolution(table);
 	const cellRectangle = indexedTableCells(map);
 	const rows = Array.from({ length: table.childCount }, (_, index) => table.child(index));
 	const rowCells = rows.map(() => /* @__PURE__ */ new Map());
@@ -381,7 +390,7 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 			for (let coveredRow = rectangle.top; coveredRow < rectangle.bottom; coveredRow++) rowOccupancy[coveredRow] = elementAt(rowOccupancy, coveredRow) + (rectangle.right - rectangle.left);
 			const initial = elementAt(elementAt(rowMetadata, rowIndex).cells, cellIndex);
 			const entry = {
-				node,
+				node: mergeDecisions.origins.has(cellOffset) ? node.type.create(resolvedTableMergeOriginAttrs(node), node.content, node.marks) : node,
 				position: cellOffset,
 				left,
 				row: rowIndex,
@@ -435,46 +444,36 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 					count: previousWidth - currentWidth
 				});
 			}
-		} else if (marker?.kind === "merge") if (mode === "accept") {
-			entry.touched = true;
-			entry.node = entry.node.type.create({
-				...entry.node.attrs,
-				cellMarker: null
-			}, entry.node.content, entry.node.marks);
-		} else if (!isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) {
-			entry.touched = true;
-			const original = entry.node.attrs["_originalFormatting"];
-			let formatting = original;
-			if (typeof original === "object" && original !== null) {
-				const copy = { ...original };
-				delete copy["vMerge"];
-				formatting = copy;
+		} else if (marker?.kind === "merge") {
+			const joinsAbove = mergeDecisions.folds.get(entry.position);
+			if (joinsAbove === void 0) return panic("Merge resolution lost its cell");
+			if (mode === "reject" && isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal) && cellRectangle(entry.position).top === 0) return failedTableResolution(table);
+			if (!joinsAbove) entry.node = entry.node.type.create(resolvedVisibleTableCellMergeAttrs({
+				cell: entry.node,
+				mode,
+				origin: mergeDecisions.origins.has(entry.position)
+			}), entry.node.content, entry.node.marks);
+			else {
+				const rectangle = cellRectangle(entry.position);
+				if (rectangle.top === 0) return failedTableResolution(table);
+				const abovePosition = map.map[(rectangle.top - 1) * map.width + rectangle.left];
+				if (abovePosition === void 0) return failedTableResolution(table);
+				const aboveRectangle = cellRectangle(abovePosition);
+				const above = byPosition.get(abovePosition);
+				if (!above || !elementAt(rowCells, above.row).has(above.left) || aboveRectangle.left !== rectangle.left || aboveRectangle.right !== rectangle.right || aboveRectangle.bottom !== rectangle.top) return failedTableResolution(table);
+				const aboveRowspan = above.node.attrs["rowspan"];
+				const cellRowspan = entry.node.attrs["rowspan"];
+				if (typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return failedTableResolution(table);
+				above.continuation ??= continuationSequence(tableCellContinuationCells(above.node, aboveRowspan));
+				appendContinuation(above.continuation, tableCellContinuationFromNode(entry.node));
+				const nested = entry.continuation ?? continuationSequence(tableCellContinuationPayload(entry.node)?.cells ?? []);
+				appendContinuationSequence(above.continuation, nested);
+				above.node = above.node.type.create({
+					...above.node.attrs,
+					rowspan: aboveRowspan + cellRowspan
+				}, above.node.content, above.node.marks);
+				elementAt(rowCells, entry.row).delete(entry.left);
 			}
-			entry.node = entry.node.type.create({
-				...entry.node.attrs,
-				cellMarker: null,
-				_originalFormatting: formatting
-			}, entry.node.content, entry.node.marks);
-		} else {
-			const rectangle = cellRectangle(entry.position);
-			if (rectangle.top === 0) return failedTableResolution(table);
-			const abovePosition = map.map[(rectangle.top - 1) * map.width + rectangle.left];
-			if (abovePosition === void 0) return failedTableResolution(table);
-			const aboveRectangle = cellRectangle(abovePosition);
-			const above = byPosition.get(abovePosition);
-			if (!above || !elementAt(rowCells, above.row).has(above.left) || aboveRectangle.left !== rectangle.left || aboveRectangle.right !== rectangle.right || aboveRectangle.bottom !== rectangle.top) return failedTableResolution(table);
-			const aboveRowspan = above.node.attrs["rowspan"];
-			const cellRowspan = entry.node.attrs["rowspan"];
-			if (typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return failedTableResolution(table);
-			above.continuation ??= continuationSequence(tableCellContinuationCells(above.node, aboveRowspan));
-			appendContinuation(above.continuation, tableCellContinuationFromNode(entry.node));
-			const nested = entry.continuation ?? continuationSequence(tableCellContinuationPayload(entry.node)?.cells ?? []);
-			appendContinuationSequence(above.continuation, nested);
-			above.node = above.node.type.create({
-				...above.node.attrs,
-				rowspan: aboveRowspan + cellRowspan
-			}, above.node.content, above.node.marks);
-			elementAt(rowCells, entry.row).delete(entry.left);
 		}
 		if (!elementAt(rowCells, entry.row).has(entry.left)) continue;
 		if (!tableCellContinuationPayload(entry.node)?.cells.some((cell) => getTableCellMergeChange(cell) !== null)) continue;

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -1,6 +1,9 @@
+import { resolveParagraphNumbering } from "../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
-import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
-import { rejectedListRenderingPatch } from "../listNumbering.js";
+import { rejectedListRenderingPatch } from "../listRendering.js";
+import { paragraphNumberingAttr } from "../numberingAttr.js";
+import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties } from "./propertyChangeScope.js";
 //#region src/prosemirror/commands/resolveParagraphProperties.ts
 /** Resolve paragraph and section property records before resolving their inline content. */
@@ -20,15 +23,37 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 				_propertyChanges: remaining.length > 0 ? remaining : null
 			};
 			if (rejection?.type === "restore-previous") {
-				const inheritedAlignment = expectParagraphAttrs(node).alignmentFromStyle;
+				const currentAttrs = expectParagraphAttrs(node);
+				const inheritedAlignment = currentAttrs.alignmentFromStyle;
+				const restoredStyleId = rejection.previousFormatting?.styleId ?? void 0;
+				const sameStyle = restoredStyleId === (currentAttrs.styleId ?? void 0);
 				let previousFormattingFromStyle;
-				if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting;
-				else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
-				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousFormattingFromStyle), rejectedListRenderingPatch({
+				let resolvedFromStyle = sameStyle ? currentAttrs._resolvedFormatting : void 0;
+				if (styleResolver) {
+					previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
+					if (!sameStyle) {
+						resolvedFromStyle = styleResolvedParagraphFormatting(previousFormattingFromStyle);
+						nextAttrs["_resolvedFormatting"] = resolvedFromStyle;
+					}
+				} else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
+				const inheritedFormatting = previousFormattingFromStyle === void 0 && resolvedFromStyle === void 0 ? void 0 : {
+					...previousFormattingFromStyle,
+					...resolvedFromStyle
+				};
+				let styleNumbering = previousFormattingFromStyle?.numPr;
+				if (!styleResolver && sameStyle) styleNumbering = currentAttrs.numPrFromStyle ?? void 0;
+				const inheritedNumbering = styleNumbering == null ? null : paragraphNumberingAttr(resolveParagraphNumbering(styleNumbering));
+				const recordedNumbering = rejection.previousFormatting?.numPr;
+				const restoredNumbering = recordedNumbering ?? inheritedNumbering;
+				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
 					current: expectParagraphAttrs(node),
 					previousFormatting: rejection.previousFormatting,
-					numbering
-				}));
+					numbering,
+					restoredNumbering
+				}), {
+					numPr: restoredNumbering,
+					numPrFromStyle: recordedNumbering == null ? inheritedNumbering : null
+				});
 				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
 				nextAttrs["_originalFormatting"] = restoredFormatting;
 				if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;

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

@@ -5,7 +5,13 @@ import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/commands/tableCellMergeResolution.d.ts
 declare const tableCellContinuationPayload: (node: Node) => DecodedTableCellParagraphSourcePayload | null;
 declare const hasMatchingCollapsedTableCellMerge: (node: Node, revisionSet: Set<number> | null) => boolean;
-declare const resolveVisibleTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject") => boolean;
+type ResolveVisibleTableCellMergeOptions = {
+  tr: Transaction;
+  cellPos: number;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+};
+declare const resolveVisibleTableCellMerge: ({ tr, cellPos, mode, revisionSet }: ResolveVisibleTableCellMergeOptions) => boolean;
 declare const tableCellContinuationCells: (cell: Node, rowspan: number) => document_d_exports.TableCell[];
 declare const tableCellContinuationFromNode: (cell: Node) => document_d_exports.TableCell;
 declare const resolveCollapsedTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject", revisionSet: Set<number> | null) => boolean;

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -1,8 +1,11 @@
 import { decodeTableCellParagraphSourcePayload, restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
+import { isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
 import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
 import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
-import { Result } from "better-result";
+import { removeRowsWithoutCellsInRange } from "../tableGridMutation.js";
+import { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions } from "./tableMergeFoldDecisions.js";
+import { Result, panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/commands/tableCellMergeResolution.ts
 const tableCellContinuationPayload = (node) => {
@@ -35,26 +38,35 @@ const tableCellContext = (doc, cellPos) => {
 	}
 	return null;
 };
-const resolveVisibleTableCellMerge = (tr, cellPos, mode) => {
+const resolveVisibleTableCellMerge = ({ tr, cellPos, mode, revisionSet }) => {
 	const cell = tr.doc.nodeAt(cellPos);
 	const marker = cell?.attrs["cellMarker"];
 	if (!cell || !isTableCellMergeRevisionAttr(marker)) return false;
-	if (mode === "accept") {
-		tr.setNodeAttribute(cellPos, "cellMarker", null);
-		return true;
-	}
-	if ((marker.verticalMergeOriginal ?? "rest") === "continue") return mergeTableCellWithCellAbove(tr, cellPos);
-	const originalFormatting = cell.attrs["_originalFormatting"];
-	let nextOriginalFormatting = originalFormatting;
-	if (typeof originalFormatting === "object" && originalFormatting !== null) {
-		nextOriginalFormatting = { ...originalFormatting };
-		delete nextOriginalFormatting.vMerge;
-	}
-	tr.setNodeMarkup(cellPos, void 0, {
-		...cell.attrs,
-		cellMarker: null,
-		_originalFormatting: nextOriginalFormatting
+	const context = tableCellContext(tr.doc, cellPos);
+	if (!context) return false;
+	const rectangle = TableMap.get(context.table).findCell(context.relativeCellPos);
+	if (mode === "reject" && isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal) && rectangle.top === 0) return false;
+	const decisions = tableMergeFoldDecisions({
+		table: context.table,
+		mode,
+		revisionSet
 	});
+	if (decisions.invalid.has(context.relativeCellPos)) return false;
+	const folds = decisions.folds.get(context.relativeCellPos);
+	if (folds === void 0) return panic("Merge resolution lost its cell");
+	for (const origin of decisions.origins) {
+		if (origin === context.relativeCellPos) continue;
+		const originPos = context.tableStart + origin;
+		const originCell = tr.doc.nodeAt(originPos);
+		if (!originCell) return panic("Merge resolution lost its origin");
+		tr.setNodeMarkup(originPos, void 0, resolvedTableMergeOriginAttrs(originCell));
+	}
+	if (folds) return mergeTableCellWithCellAbove(tr, cellPos);
+	tr.setNodeMarkup(cellPos, void 0, resolvedVisibleTableCellMergeAttrs({
+		cell,
+		mode,
+		origin: decisions.origins.has(context.relativeCellPos)
+	}));
 	return true;
 };
 const mergeTableCellWithCellAbove = (tr, cellPos) => {
@@ -73,11 +85,18 @@ const mergeTableCellWithCellAbove = (tr, cellPos) => {
 	const aboveRowspan = aboveCell?.attrs["rowspan"];
 	const cellRowspan = cell.attrs["rowspan"];
 	if (!aboveCell || typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return false;
+	removeRowsWithoutCellsInRange({
+		tr,
+		from: cellPos + 1,
+		to: cellPos + cell.nodeSize - 1
+	});
+	const capturedCell = tr.doc.nodeAt(cellPos);
+	if (!capturedCell) panic("Nested table cleanup removed its owning cell");
 	const continuationCells = tableCellContinuationCells(aboveCell, aboveRowspan);
-	continuationCells.push(tableCellContinuationFromNode(cell));
-	const nestedPayload = tableCellContinuationPayload(cell);
+	continuationCells.push(tableCellContinuationFromNode(capturedCell));
+	const nestedPayload = tableCellContinuationPayload(capturedCell);
 	if (nestedPayload) continuationCells.push(...nestedPayload.cells);
-	tr.delete(cellPos, cellPos + cell.nodeSize);
+	tr.delete(cellPos, cellPos + capturedCell.nodeSize);
 	tr.setNodeMarkup(abovePos, void 0, {
 		...aboveCell.attrs,
 		rowspan: aboveRowspan + cellRowspan,

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

@@ -0,0 +1,61 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commands/tableMergeFoldDecisions.d.ts
+type TableMergeFoldDecisionsOptions = {
+  table: Node;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+};
+/** Resolve raw merge states without converting unrelated table revisions. */
+declare const tableMergeFoldDecisions: ({ table, mode, revisionSet }: TableMergeFoldDecisionsOptions) => {
+  folds: Map<number, boolean>;
+  origins: Set<number>;
+  invalid: Set<number>;
+};
+/** Persist an implicit merge origin even when reader rules retain its continuation. */
+declare const resolvedTableMergeOriginAttrs: (cell: Node) => {
+  _originalFormatting: {
+    vMerge: string;
+    width?: import("@stll/docx-core/model").TableMeasurement;
+    borders?: import("@stll/docx-core/model").TableCellBorders;
+    margins?: import("@stll/docx-core/model").CellMargins;
+    shading?: import("@stll/docx-core/model").ShadingProperties;
+    verticalAlign?: "top" | "center" | "bottom";
+    textDirection?: import("@stll/docx-core/model").TextDirection;
+    gridSpan?: number;
+    fitText?: boolean;
+    noWrap?: boolean;
+    hideMark?: boolean;
+    conditionalFormat?: import("@stll/docx-core/model").ConditionalFormatStyle;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup;
+    sourceXml?: string;
+  };
+  _preserveVMergeRestart: boolean;
+};
+type ResolvedVisibleTableCellMergeOptions = {
+  cell: Node;
+  mode: "accept" | "reject";
+  origin: boolean;
+};
+/** A retained continuation must save the merge state the reviewer resolved. */
+declare const resolvedVisibleTableCellMergeAttrs: ({ cell, mode, origin }: ResolvedVisibleTableCellMergeOptions) => {
+  cellMarker: null;
+  _originalFormatting: {
+    width?: import("@stll/docx-core/model").TableMeasurement;
+    borders?: import("@stll/docx-core/model").TableCellBorders;
+    margins?: import("@stll/docx-core/model").CellMargins;
+    shading?: import("@stll/docx-core/model").ShadingProperties;
+    verticalAlign?: "top" | "center" | "bottom";
+    textDirection?: import("@stll/docx-core/model").TextDirection;
+    gridSpan?: number;
+    vMerge?: "restart" | "continue";
+    fitText?: boolean;
+    noWrap?: boolean;
+    hideMark?: boolean;
+    conditionalFormat?: import("@stll/docx-core/model").ConditionalFormatStyle;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup;
+    sourceXml?: string;
+  };
+  _preserveVMergeRestart: boolean;
+};
+//#endregion
+export { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions };