@stll/folio-core 0.54.0 → 0.54.1

package/dist/ai-edits/apply.js

@@ -1486,6 +1486,13 @@ const finalParagraphPredecessor = (doc, at) => {
 	for (let index = $emptied.index() - 1; index >= 0; index--) {
 		const node = $emptied.parent.child(index);
 		position -= node.nodeSize;
+		if (node.type.spec["tableRole"] === "table" && node.childCount > 0) {
+			let allRowsDeleted = true;
+			node.forEach((row) => {
+				allRowsDeleted &&= expectTableRowAttrs(row).trDel != null;
+			});
+			if (allRowsDeleted) continue;
+		}
 		if (node.type !== emptied.type) return null;
 		if (isPlainDeletedPPrMark(node.attrs["pPrMark"]) && holdsOnlyDeletedContent(node)) continue;
 		return {
@@ -1701,6 +1708,24 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 	};
 	collectSupersededDeletedBreaks(tr.doc, 0);
 	for (const { preceding, inserted, deletedMark, precedingMark } of supersededDeletedBreaks) {
+		const insertionRevisionId = addedBreakRevisionId(precedingMark);
+		if (insertionRevisionId !== null) {
+			const previous = tr.doc.nodeAt(preceding);
+			const current = tr.doc.nodeAt(inserted);
+			if (!previous || !current) panic("A shifted paragraph break lost its carrier");
+			const previousFormatting = paragraphPropertiesOnReject(previous);
+			const existing = expectParagraphAttrs(current)._propertyChanges;
+			if (!hasSerializableParagraphPropertyChange(existing) && JSON.stringify(previousFormatting) !== JSON.stringify(paragraphPropertiesSnapshot(current))) tr.setNodeAttribute(inserted, "_propertyChanges", [...Array.isArray(existing) ? existing : [], {
+				type: "paragraphPropertyChange",
+				info: {
+					id: insertionRevisionId,
+					author,
+					date,
+					...initials ? { initials } : {}
+				},
+				previousFormatting
+			}]);
+		}
 		tr.setNodeAttribute(preceding, "pPrMark", precedingMark);
 		tr.setNodeAttribute(inserted, "pPrMark", deletedMark);
 	}

package/dist/docx/paragraphPropertySource.js

@@ -542,7 +542,7 @@ const tableCellParagraphPropertySourceBindingForTransport = (paragraph, inspecti
 };
 /** Prepare opaque continuation cells for ProseMirror and Yjs transport. */
 const transportTableCellsWithParagraphPropertySources = (cells) => {
-	const cloned = structuredClone(cells);
+	const cloned = cells.map((cell) => structuredClone(cell));
 	const sources = paragraphsInTableCells(cells);
 	const targets = paragraphsInTableCells(cloned);
 	if (sources.length !== targets.length) panic("The cloned table cells changed paragraph graph ownership.");

package/dist/docx/verticalMergeProjection.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/verticalMergeProjection.d.ts
+/** The reader and revision resolver share which continuation cells remain visible. */
+type RowSpanInfo = {
+  rowSpan: number;
+  skip: boolean;
+  preserveVMergeRestart?: boolean;
+  continuationCells?: document_d_exports.TableCell[];
+};
+declare function calculateRowSpans(table: document_d_exports.Table): Map<string, RowSpanInfo>;
+/**
+ * Whether a cell carries content a vertical-merge continuation must not hide.
+ * The reader keeps such a continuation as a cell of its own.
+ */
+declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
+//#endregion
+export { RowSpanInfo, calculateRowSpans, tableCellHasMeaningfulContent };

package/dist/docx/verticalMergeProjection.js

@@ -0,0 +1,120 @@
+import { isCellMergeContinuation } from "./tableParser.js";
+//#region src/docx/verticalMergeProjection.ts
+function calculateRowSpans(table) {
+	const result = /* @__PURE__ */ new Map();
+	const numRows = table.rows.length;
+	const activeMerges = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
+		const row = table.rows[rowIndex];
+		if (row.cells.length === 0) {
+			clearActiveVerticalMerges(activeMerges, result);
+			continue;
+		}
+		let colIndex = row.formatting?.gridBefore ?? 0;
+		const rowCells = row.cells.map((cell) => {
+			const colspan = cell.formatting?.gridSpan ?? 1;
+			const vMerge = cell.formatting?.vMerge;
+			const isMergeContinuation = isCellMergeContinuation(cell);
+			const startRow = isMergeContinuation ? activeMerges.get(colIndex) : void 0;
+			const info = {
+				cell,
+				colIndex,
+				colspan,
+				vMerge,
+				isMergeContinuation,
+				startRow,
+				hasMeaningfulContent: tableCellHasMeaningfulContent(cell),
+				shouldSkip: isMergeContinuation && startRow !== void 0
+			};
+			colIndex += colspan;
+			return info;
+		});
+		const rowWouldBeEmpty = rowCells.length > 0 && rowCells.every((cell) => cell.shouldSkip);
+		for (const cellInfo of rowCells) {
+			const { colIndex: cellColIndex, vMerge, isMergeContinuation, startRow, hasMeaningfulContent } = cellInfo;
+			const key = `${rowIndex}-${cellColIndex}`;
+			if (vMerge === "restart") {
+				closeVerticalMerge(activeMerges, result, cellColIndex);
+				activeMerges.set(cellColIndex, rowIndex);
+				result.set(key, {
+					rowSpan: 1,
+					skip: false
+				});
+			} else if (isMergeContinuation) {
+				if (startRow === void 0 || rowWouldBeEmpty || hasMeaningfulContent) {
+					result.set(key, {
+						rowSpan: 1,
+						skip: false
+					});
+					if ((rowWouldBeEmpty || hasMeaningfulContent) && startRow !== void 0) {
+						const restartCell = result.get(`${startRow}-${cellColIndex}`);
+						if (restartCell) restartCell.preserveVMergeRestart = true;
+						activeMerges.delete(cellColIndex);
+					}
+					continue;
+				}
+				const startKey = `${startRow}-${cellColIndex}`;
+				const startCell = result.get(startKey);
+				if (startCell) {
+					startCell.rowSpan++;
+					startCell.continuationCells ??= [];
+					startCell.continuationCells.push(cellInfo.cell);
+				}
+				result.set(key, {
+					rowSpan: 1,
+					skip: true
+				});
+			} else {
+				closeVerticalMerge(activeMerges, result, cellColIndex);
+				result.set(key, {
+					rowSpan: 1,
+					skip: false
+				});
+			}
+		}
+	}
+	clearActiveVerticalMerges(activeMerges, result);
+	return result;
+}
+/**
+* End the vertical merge active in one column.
+*
+* A `w:vMerge="restart"` is carried through the editor by its cell's rowspan,
+* which only exists once a continuation joins it. A merge that closes with a
+* rowspan of 1 — a restart with no continuation, one interrupted by a plain
+* cell, one whose continuation is in a row a revision removed — has nothing
+* but this flag to say the cell was a merge origin, and dropping it changes
+* the table's visible structure.
+*/
+function closeVerticalMerge(activeMerges, result, colIndex) {
+	const startRow = activeMerges.get(colIndex);
+	if (startRow === void 0) return;
+	const restartCell = result.get(`${startRow}-${colIndex}`);
+	if (restartCell && restartCell.rowSpan === 1) restartCell.preserveVMergeRestart = true;
+	activeMerges.delete(colIndex);
+}
+function clearActiveVerticalMerges(activeMerges, result) {
+	for (const colIndex of [...activeMerges.keys()]) closeVerticalMerge(activeMerges, result, colIndex);
+}
+/**
+* Whether a cell carries content a vertical-merge continuation must not hide.
+* The reader keeps such a continuation as a cell of its own.
+*/
+function tableCellHasMeaningfulContent(cell) {
+	return cell.content.some(blockHasMeaningfulContent);
+}
+function blockHasMeaningfulContent(block) {
+	if (block.type === "preservedBlock") return true;
+	if (block.type === "bookmarkStart" || block.type === "bookmarkEnd") return true;
+	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
+	if (block.type === "blockSdt" || block.type === "blockCustomXml") return true;
+	return block.content.some(paragraphContentHasMeaningfulContent);
+}
+function paragraphContentHasMeaningfulContent(content) {
+	if (content.type === "run") return content.content.length > 0;
+	if (content.type === "hyperlink") return content.children.some(paragraphContentHasMeaningfulContent);
+	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") return content.content.some(paragraphContentHasMeaningfulContent);
+	return true;
+}
+//#endregion
+export { calculateRowSpans, tableCellHasMeaningfulContent };

package/dist/prosemirror/commands/comments.js

@@ -287,7 +287,12 @@ function resolveChange(from, to, mode, revisionIds) {
 				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;

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,3 +1,4 @@
+import { isStyleSourcedParagraphNumbering } from "../../internal/paragraphFormattingSerialization.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
@@ -126,7 +127,9 @@ 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];

package/dist/prosemirror/commands/resolveAllTableChanges.js

@@ -5,7 +5,8 @@ import { nodePropertyRevisionSites, propertyRevisionRecords } from "../revisionC
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { resolveAllNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
-import { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.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";
@@ -358,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());
@@ -383,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,
@@ -438,28 +445,15 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 				});
 			}
 		} else if (marker?.kind === "merge") {
-			const joinsAbove = mode === "accept" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(entry.node) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal);
-			if (mode === "accept" && !joinsAbove) {
-				entry.touched = true;
-				entry.node = entry.node.type.create({
-					...entry.node.attrs,
-					cellMarker: null
-				}, entry.node.content, entry.node.marks);
-			} else if (!joinsAbove) {
-				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;
-				}
-				entry.node = entry.node.type.create({
-					...entry.node.attrs,
-					cellMarker: null,
-					_originalFormatting: formatting
-				}, entry.node.content, entry.node.marks);
-			} else {
+			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];

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -1,5 +1,7 @@
+import { resolveParagraphNumbering } from "../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../attrs/index.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";
@@ -38,11 +40,20 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 					...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,17 +5,16 @@ 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;
-/**
- * Whether accepting a pending vertical merge folds the cell into the one above.
- * The saved `w:vMerge` continuation is read back as its own cell when it carries
- * content, so accepting such a merge keeps the cell standing; folding it would
- * hide text that reappears when the document is reopened.
- */
-declare const acceptedMergeFoldsIntoCellAbove: (cell: Node) => 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;
 declare const createRestoredTableCell: (origin: Node, source: document_d_exports.TableCell) => Node | null;
 //#endregion
-export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -1,9 +1,10 @@
 import { decodeTableCellParagraphSourcePayload, restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
 import { isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
 import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
-import { standaloneTableCellToProseMirror, tableCellHasMeaningfulContent } from "../conversion/toProseDoc.js";
+import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 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
@@ -37,33 +38,35 @@ const tableCellContext = (doc, cellPos) => {
 	}
 	return null;
 };
-/**
-* Whether accepting a pending vertical merge folds the cell into the one above.
-* The saved `w:vMerge` continuation is read back as its own cell when it carries
-* content, so accepting such a merge keeps the cell standing; folding it would
-* hide text that reappears when the document is reopened.
-*/
-const acceptedMergeFoldsIntoCellAbove = (cell) => !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell));
-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" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(cell) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) return mergeTableCellWithCellAbove(tr, cellPos);
-	if (mode === "accept") {
-		tr.setNodeAttribute(cellPos, "cellMarker", null);
-		return true;
-	}
-	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) => {
@@ -201,4 +204,4 @@ const createRestoredTableCell = (origin, source) => {
 	return Result.try(() => origin.type.schema.nodeFromJSON(restored.toJSON())).unwrapOr(null);
 };
 //#endregion
-export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

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 };

package/dist/prosemirror/commands/tableMergeFoldDecisions.js

@@ -0,0 +1,79 @@
+import { isCellMergeContinuation, isCellMergeStart, isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
+import { tableCellHasMeaningfulContent } from "../../docx/verticalMergeProjection.js";
+import { expectTableCellAttrs } from "../attrs/index.js";
+import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
+import { panic } from "better-result";
+import { TableMap } from "prosemirror-tables";
+//#region src/prosemirror/commands/tableMergeFoldDecisions.ts
+/** Resolve raw merge states without converting unrelated table revisions. */
+const tableMergeFoldDecisions = ({ table, mode, revisionSet }) => {
+	const decisions = /* @__PURE__ */ new Map();
+	const origins = /* @__PURE__ */ new Set();
+	const invalid = /* @__PURE__ */ new Set();
+	const map = TableMap.get(table);
+	const visited = /* @__PURE__ */ new Set();
+	for (const [index, position] of map.map.entries()) {
+		if (visited.has(position)) continue;
+		visited.add(position);
+		const cell = table.nodeAt(position);
+		if (cell?.attrs["cellMarker"]?.kind !== "merge") continue;
+		const marker = expectTableCellAttrs(cell).cellMarker;
+		if (marker?.kind !== "merge" || revisionSet !== null && !revisionSet.has(marker.info.revisionId)) continue;
+		const continues = isTableCellMergeRevisionContinuation(mode === "accept" ? marker.verticalMerge : marker.verticalMergeOriginal);
+		decisions.set(position, continues && (mode === "reject" || !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell))));
+		if (!continues) continue;
+		if (Math.floor(index / map.width) === 0) {
+			invalid.add(position);
+			continue;
+		}
+		const abovePosition = map.map[index - map.width];
+		if (abovePosition === void 0) return panic("Merge resolution lost its origin");
+		const above = table.nodeAt(abovePosition);
+		if (!above) return panic("Merge resolution lost its origin");
+		const rectangle = map.findCell(position);
+		const aboveRectangle = map.findCell(abovePosition);
+		if (rectangle.left !== aboveRectangle.left || rectangle.right !== aboveRectangle.right || rectangle.top !== aboveRectangle.bottom) {
+			invalid.add(position);
+			continue;
+		}
+		const aboveMarker = expectTableCellAttrs(above).cellMarker;
+		const aboveContinues = aboveMarker?.kind === "merge" && (revisionSet === null || revisionSet.has(aboveMarker.info.revisionId)) && isTableCellMergeRevisionContinuation(mode === "accept" ? aboveMarker.verticalMerge : aboveMarker.verticalMergeOriginal);
+		const aboveModel = standaloneTableCellFromProseMirror(above);
+		if (mode === "accept" && (aboveContinues && decisions.get(abovePosition) === false || isCellMergeContinuation(aboveModel) && tableCellHasMeaningfulContent(aboveModel))) decisions.set(position, false);
+		if (aboveContinues || isCellMergeContinuation(aboveModel) || isCellMergeStart(aboveModel)) continue;
+		origins.add(abovePosition);
+	}
+	return {
+		folds: decisions,
+		origins,
+		invalid
+	};
+};
+/** Persist an implicit merge origin even when reader rules retain its continuation. */
+const resolvedTableMergeOriginAttrs = (cell) => ({
+	...cell.attrs,
+	_originalFormatting: {
+		...expectTableCellAttrs(cell)._originalFormatting,
+		vMerge: "restart"
+	},
+	_preserveVMergeRestart: true
+});
+/** A retained continuation must save the merge state the reviewer resolved. */
+const resolvedVisibleTableCellMergeAttrs = ({ cell, mode, origin }) => {
+	const attrs = expectTableCellAttrs(cell);
+	const marker = attrs.cellMarker;
+	if (marker?.kind !== "merge") return panic("Cell has no merge revision");
+	const continuation = mode === "accept" ? marker.verticalMerge : marker.verticalMergeOriginal;
+	const formatting = { ...attrs._originalFormatting };
+	if (origin) formatting.vMerge = "restart";
+	else if (isTableCellMergeRevisionContinuation(continuation)) formatting.vMerge = "continue";
+	else delete formatting.vMerge;
+	return {
+		...cell.attrs,
+		cellMarker: null,
+		_originalFormatting: formatting,
+		_preserveVMergeRestart: origin
+	};
+};
+//#endregion
+export { resolvedTableMergeOriginAttrs, resolvedVisibleTableCellMergeAttrs, tableMergeFoldDecisions };

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

@@ -23,11 +23,6 @@ type ToProseDocOptions = {
  * @param options - Conversion options including style definitions
  */
 declare function toProseDoc(document: document_d_exports.Document, options?: ToProseDocOptions): Node;
-/**
- * Whether a cell carries content a vertical-merge continuation must not hide.
- * The reader keeps such a continuation as a cell of its own.
- */
-declare function tableCellHasMeaningfulContent(cell: document_d_exports.TableCell): boolean;
 declare function standaloneTableCellToProseMirror(cell: document_d_exports.TableCell, nodeType: "tableCell" | "tableHeader"): Node;
 /**
  * Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document.
@@ -44,4 +39,4 @@ declare function footnoteToProseDoc(content: document_d_exports.BlockContent[],
  */
 declare function createEmptyDoc(): Node;
 //#endregion
-export { ToProseDocOptions, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, tableCellHasMeaningfulContent, toProseDoc };
+export { ToProseDocOptions, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -6,6 +6,7 @@ import { isBaselineVertAlign } from "../../docx/runParser.js";
 import { replayableShapeAlternateContent } from "../../docx/shapeAlternateContent.js";
 import { resolveTableLook } from "../../docx/tableLook.js";
 import { isCellMergeContinuation } from "../../docx/tableParser.js";
+import { calculateRowSpans } from "../../docx/verticalMergeProjection.js";
 import { copiedWrapPolygon } from "../../docx/wrapPolygon.js";
 import { buildPageBreakRunSourceDescendantIndex } from "../../internal/pageBreakRunSourceDescendantIndex.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
@@ -893,122 +894,6 @@ function resolveTextFormatting(formatting, styleResolver) {
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
-function calculateRowSpans(table) {
-	const result = /* @__PURE__ */ new Map();
-	const numRows = table.rows.length;
-	const activeMerges = /* @__PURE__ */ new Map();
-	for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
-		const row = table.rows[rowIndex];
-		if (row.cells.length === 0) {
-			clearActiveVerticalMerges(activeMerges, result);
-			continue;
-		}
-		let colIndex = row.formatting?.gridBefore ?? 0;
-		const rowCells = row.cells.map((cell) => {
-			const colspan = cell.formatting?.gridSpan ?? 1;
-			const vMerge = cell.formatting?.vMerge;
-			const isMergeContinuation = isCellMergeContinuation(cell);
-			const startRow = isMergeContinuation ? activeMerges.get(colIndex) : void 0;
-			const info = {
-				cell,
-				colIndex,
-				colspan,
-				vMerge,
-				isMergeContinuation,
-				startRow,
-				hasMeaningfulContent: tableCellHasMeaningfulContent(cell),
-				shouldSkip: isMergeContinuation && startRow !== void 0
-			};
-			colIndex += colspan;
-			return info;
-		});
-		const rowWouldBeEmpty = rowCells.length > 0 && rowCells.every((cell) => cell.shouldSkip);
-		for (const cellInfo of rowCells) {
-			const { colIndex: cellColIndex, vMerge, isMergeContinuation, startRow, hasMeaningfulContent } = cellInfo;
-			const key = `${rowIndex}-${cellColIndex}`;
-			if (vMerge === "restart") {
-				closeVerticalMerge(activeMerges, result, cellColIndex);
-				activeMerges.set(cellColIndex, rowIndex);
-				result.set(key, {
-					rowSpan: 1,
-					skip: false
-				});
-			} else if (isMergeContinuation) {
-				if (startRow === void 0 || rowWouldBeEmpty || hasMeaningfulContent) {
-					result.set(key, {
-						rowSpan: 1,
-						skip: false
-					});
-					if ((rowWouldBeEmpty || hasMeaningfulContent) && startRow !== void 0) {
-						const restartCell = result.get(`${startRow}-${cellColIndex}`);
-						if (restartCell) restartCell.preserveVMergeRestart = true;
-						activeMerges.delete(cellColIndex);
-					}
-					continue;
-				}
-				const startKey = `${startRow}-${cellColIndex}`;
-				const startCell = result.get(startKey);
-				if (startCell) {
-					startCell.rowSpan++;
-					startCell.continuationCells ??= [];
-					startCell.continuationCells.push(cellInfo.cell);
-				}
-				result.set(key, {
-					rowSpan: 1,
-					skip: true
-				});
-			} else {
-				closeVerticalMerge(activeMerges, result, cellColIndex);
-				result.set(key, {
-					rowSpan: 1,
-					skip: false
-				});
-			}
-		}
-	}
-	clearActiveVerticalMerges(activeMerges, result);
-	return result;
-}
-/**
-* End the vertical merge active in one column.
-*
-* A `w:vMerge="restart"` is carried through the editor by its cell's rowspan,
-* which only exists once a continuation joins it. A merge that closes with a
-* rowspan of 1 — a restart with no continuation, one interrupted by a plain
-* cell, one whose continuation is in a row a revision removed — has nothing
-* but this flag to say the cell was a merge origin, and dropping it changes
-* the table's visible structure.
-*/
-function closeVerticalMerge(activeMerges, result, colIndex) {
-	const startRow = activeMerges.get(colIndex);
-	if (startRow === void 0) return;
-	const restartCell = result.get(`${startRow}-${colIndex}`);
-	if (restartCell && restartCell.rowSpan === 1) restartCell.preserveVMergeRestart = true;
-	activeMerges.delete(colIndex);
-}
-function clearActiveVerticalMerges(activeMerges, result) {
-	for (const colIndex of [...activeMerges.keys()]) closeVerticalMerge(activeMerges, result, colIndex);
-}
-/**
-* Whether a cell carries content a vertical-merge continuation must not hide.
-* The reader keeps such a continuation as a cell of its own.
-*/
-function tableCellHasMeaningfulContent(cell) {
-	return cell.content.some(blockHasMeaningfulContent);
-}
-function blockHasMeaningfulContent(block) {
-	if (block.type === "preservedBlock") return true;
-	if (block.type === "bookmarkStart" || block.type === "bookmarkEnd") return true;
-	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
-	if (block.type === "blockSdt" || block.type === "blockCustomXml") return true;
-	return block.content.some(paragraphContentHasMeaningfulContent);
-}
-function paragraphContentHasMeaningfulContent(content) {
-	if (content.type === "run") return content.content.length > 0;
-	if (content.type === "hyperlink") return content.children.some(paragraphContentHasMeaningfulContent);
-	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") return content.content.some(paragraphContentHasMeaningfulContent);
-	return true;
-}
 function convertTable(table, styleResolver, context) {
 	for (const row of table.rows) for (const cell of row.cells) {
 		if (isCellMergeContinuation(cell) && context.pageBreakRunSourceDescendants.containsPageBreakRun(cell.content)) {
@@ -2840,4 +2725,4 @@ function createEmptyDoc() {
 	return schema.node("doc", null, [schema.node("paragraph", {}, [])]);
 }
 //#endregion
-export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, tableCellHasMeaningfulContent, toProseDoc };
+export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };

package/dist/prosemirror/listNumbering.js

@@ -7,6 +7,7 @@ import { listRenderingFor, recordsListRendering } from "./listRendering.js";
 import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
 import { directParagraphIndentation } from "./paragraphIndentation.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
 import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
 import { listAttrsFromNumbering, listLevelIndentAttrPatch } from "./styles/resolvedStyleAttrs.js";
 //#region src/prosemirror/listNumbering.ts
@@ -20,22 +21,15 @@ const PARAGRAPH_NODE = "paragraph";
 */
 const listChangeSnapshot = (node, attrs) => {
 	const previousFormatting = paragraphPropertiesSnapshot(node.type.create(attrs, node.content, node.marks));
-	previousFormatting["numPr"] = attrs["numPr"] ?? null;
+	previousFormatting["numPr"] ??= null;
 	for (const key of LIST_RENDERING_ATTR_KEYS) previousFormatting[key] = attrs[key] ?? null;
 	return previousFormatting;
 };
-/**
-* The original state a pending record describes, completed with the list
-* attrs it may not state. A record written by a list command states them all.
-* One written for another property (or read from a file) states the scope
-* only: its numbering is the original's, and an absent one means the original
-* had none, so the rendering is recomputed from it rather than copied from
-* the live paragraph, whose list may since have changed.
-*/
-const originalListFormatting = (record, numbering) => {
+const originalListFormatting = ({ record, numbering, styleResolver }) => {
 	const original = { ...record };
 	if (recordsListRendering(record)) return original;
-	Object.assign(original, listRenderingFor(record.numPr, numbering));
+	const inherited = styleResolver?.resolveParagraphStyle(record.styleId ?? void 0).paragraphFormatting?.numPr;
+	Object.assign(original, listRenderingFor(record.numPr ?? inherited, numbering));
 	original["numPr"] = record.numPr ?? null;
 	return original;
 };
@@ -54,12 +48,16 @@ const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested
 * the file) keeps its author, id and date: the change joins that revision
 * rather than re-attributing it, and it is never dropped.
 */
-const trackListChange = ({ current, next, rev, numbering }) => {
+const trackListChange = ({ current, next, rev, numbering, styleResolver }) => {
 	const currentAttrs = expectParagraphAttrs(current);
 	const existing = currentAttrs._propertyChanges ?? [];
 	const pending = existing.find(({ info }) => info.provenance !== "suggested");
 	const retained = existing.filter((change) => change !== pending);
-	const previousFormatting = pending?.previousFormatting ? originalListFormatting(pending.previousFormatting, numbering) : listChangeSnapshot(current, currentAttrs);
+	const previousFormatting = pending?.previousFormatting ? originalListFormatting({
+		record: pending.previousFormatting,
+		numbering,
+		styleResolver
+	}) : listChangeSnapshot(current, currentAttrs);
 	const ownPending = pending !== void 0 && pending.info.author === rev.author;
 	if (ownPending && canonicalJson(previousFormatting) === canonicalJson(listChangeSnapshot(current, next))) return {
 		...next,
@@ -198,12 +196,14 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 const applyParagraphUpdates = ({ tr, state, updates }) => {
 	const rev = makeRevisionInfo(state);
 	const numbering = getDocumentNumbering(state);
+	const styleResolver = getDocumentStyleResolver(state);
 	for (const { pos, node, next } of updates) {
 		const attrs = rev ? trackListChange({
 			current: node,
 			next,
 			rev,
-			numbering
+			numbering,
+			styleResolver
 		}) : next;
 		tr.setNodeMarkup(pos, void 0, attrs);
 	}

package/dist/prosemirror/listRendering.d.ts

@@ -1,11 +1,12 @@
 import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
 import { NumberingMap } from "../docx/numberingParser.js";
+import { ParagraphNumberingOverride } from "../docx/numberingReference.js";
 //#region src/prosemirror/listRendering.d.ts
 type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
 /** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
 declare const recordsListRendering: (record: PreviousFormatting) => boolean;
 /** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
-declare const listRenderingFor: (numPr: PreviousFormatting["numPr"], numbering: NumberingMap | null) => Record<string, unknown>;
+declare const listRenderingFor: (numPr: ParagraphNumberingOverride | null | undefined, numbering: NumberingMap | null) => Record<string, unknown>;
 /**
  * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
  * reject restores the recorded numbering, but the rendering attrs sit outside
@@ -21,7 +22,8 @@ type RejectedListRenderingOptions = {
   /** The previous state the rejected record restores. */
   previousFormatting: PreviousFormatting | null | undefined;
   numbering: NumberingMap | null;
+  restoredNumbering: ParagraphAttrs["numPr"] | null;
 };
-declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
+declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering, restoredNumbering }: RejectedListRenderingOptions) => Record<string, unknown>;
 //#endregion
 export { RejectedListRenderingOptions, listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/listRendering.js

@@ -16,10 +16,9 @@ const listRenderingFor = (numPr, numbering) => {
 	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
 	return attrs;
 };
-const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
-	const record = previousFormatting ?? {};
-	if (recordsListRendering(record)) return {};
-	const restored = record.numPr ?? void 0;
+const rejectedListRenderingPatch = ({ current, previousFormatting, numbering, restoredNumbering }) => {
+	if (recordsListRendering(previousFormatting ?? {})) return {};
+	const restored = restoredNumbering ?? void 0;
 	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
 	return listRenderingFor(restored, numbering);
 };

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -86,7 +86,7 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 };
 /**
 * Whether the carried numbering is the paragraph's own or its style's: the
-* record holds `numPr` as the paragraph reads it, and a style's numbering
+* record holds only stated numbering, and a style's numbering
 * stays the style's rather than becoming the paragraph's own `w:numPr`.
 */
 const carriedNumberingProvenance = (source, target, keep) => ({ numPrFromStyle: expectParagraphAttrs(keep?.has("numPr") ? target : source).numPrFromStyle });
@@ -112,10 +112,7 @@ const paragraphLeftAfter = ({ doc, paragraphPos, removedBreakPositions }) => {
 		node = next;
 	}
 };
-const recordedFormatting = (node) => ({
-	...paragraphPropertiesSnapshot(node),
-	numPr: expectParagraphAttrs(node).numPr ?? null
-});
+const recordedFormatting = paragraphPropertiesSnapshot;
 /**
 * A paragraph now holds the break another one had (a split, or a paste into
 * it, leaves that break on the last part) but reads with other properties:

package/dist/prosemirror/plugins/suggestionMode.js

@@ -407,11 +407,7 @@ function rotateIntoFinalParagraph(state, tr, replacedPos, attrs) {
 	const replaced = tr.doc.nodeAt(replacedPos);
 	const first = replaced ? tr.doc.nodeAt(replacedPos + replaced.nodeSize) : null;
 	if (!replaced || !first) return replacedPos;
-	const replacedAttrs = expectParagraphAttrs(replaced);
-	const previousFormatting = {
-		...paragraphPropertiesSnapshot(replaced),
-		numPr: replacedAttrs.numPr ?? null
-	};
+	const previousFormatting = paragraphPropertiesSnapshot(replaced);
 	const { _sectionProperties: sectionProperties } = replaced.attrs;
 	tr.join(replacedPos + replaced.nodeSize);
 	tr.setNodeMarkup(replacedPos, void 0, first.attrs);

package/dist/prosemirror/plugins/templateDirectives.d.ts

@@ -14,6 +14,12 @@ type DirectiveRange = {
    * array path the loop iterates (`{% for row in items %}` ⇒ `items`).
    */
   expr: string;
+  /**
+   * For an `if` / `elif` whose body is one field path plus a filter chain
+   * (`{% if consented | checkbox | label("…") %}`), that path; `expr` keeps
+   * the body as authored. Unset for every other tag.
+   */
+  conditionPath?: string;
   /** Clause-slot version selector, e.g. "v3" or "latest". */
   clauseVersion?: string;
   /** Loop alias of a `for` marker (`{% for row in items %}` ⇒ `row`); unset

package/dist/prosemirror/plugins/templateDirectives.js

@@ -3,9 +3,17 @@ import { collectBlockChunks, joinChunks, offsetToDocPos } from "./pmTextScan.js"
 import { PluginKey } from "prosemirror-state";
 import { assertNever, isBlockDirectiveKind, scanMarkers } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templateDirectives.ts
+/**
+* The body of an `if` / `elif` tag as authored: its inner text after the
+* keyword. The grammar reads a body that is one path plus a filter chain as
+* that path, with the chain in `filters`; the document still holds the whole
+* body, and that is what a host keys a condition by.
+*/
+const conditionBody = ({ inner, meta }) => inner.slice(meta.kind.length).trim();
 /** The display expression for a marker (field path, clause name, key,
-*  condition, loop array path, loop property). */
-const directiveExpr = (meta) => {
+*  condition as authored, loop array path, loop property). */
+const directiveExpr = (marker) => {
+	const { meta } = marker;
 	switch (meta.kind) {
 		case "placeholder": return meta.expr;
 		case "clause": return meta.name;
@@ -13,7 +21,7 @@ const directiveExpr = (meta) => {
 		case "ref": return meta.key;
 		case "loop": return meta.property;
 		case "if":
-		case "elif": return meta.expr;
+		case "elif": return conditionBody(marker);
 		case "for": return meta.path;
 		case "else":
 		case "endif":
@@ -63,6 +71,8 @@ const computeBlockDepths = (ranges) => {
 };
 /** The loop alias a `for` marker binds, or undefined for every other kind. */
 const directiveAlias = (meta) => meta.kind === "for" ? meta.alias : void 0;
+/** The path a condition's filter chain configures, or undefined without a chain. */
+const directiveConditionPath = (meta) => (meta.kind === "if" || meta.kind === "elif") && meta.filters.length > 0 ? meta.expr : void 0;
 const scanDirectives = (doc) => {
 	const ranges = [];
 	for (const chunks of collectBlockChunks(doc)) {
@@ -73,27 +83,31 @@ const scanDirectives = (doc) => {
 		if (sole && sole.raw === trimmed && isBlockDirectiveKind(sole.meta.kind)) {
 			const last = chunks.at(-1);
 			const alias = directiveAlias(sole.meta);
+			const conditionPath = directiveConditionPath(sole.meta);
 			ranges.push({
 				from: chunks[0]?.start ?? 0,
 				to: last ? last.end ?? last.start + last.text.length : 0,
 				kind: sole.meta.kind,
-				expr: directiveExpr(sole.meta),
+				expr: directiveExpr(sole),
 				block: true,
-				...alias !== void 0 ? { alias } : {}
+				...alias !== void 0 ? { alias } : {},
+				...conditionPath !== void 0 ? { conditionPath } : {}
 			});
 			continue;
 		}
 		for (const marker of scanMarkers(joined)) {
 			const clauseVersion = marker.meta.kind === "clause" ? marker.meta.version : void 0;
 			const alias = directiveAlias(marker.meta);
+			const conditionPath = directiveConditionPath(marker.meta);
 			ranges.push({
 				from: offsetToDocPos(chunks, marker.start),
 				to: offsetToDocPos(chunks, marker.end, "end"),
 				kind: marker.meta.kind,
-				expr: directiveExpr(marker.meta),
+				expr: directiveExpr(marker),
 				block: false,
 				...clauseVersion !== void 0 ? { clauseVersion } : {},
-				...alias !== void 0 ? { alias } : {}
+				...alias !== void 0 ? { alias } : {},
+				...conditionPath !== void 0 ? { conditionPath } : {}
 			});
 		}
 	}

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -1,7 +1,7 @@
 import { scanDirectives } from "./templateDirectives.js";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { classifyMarker, isFieldPath } from "@stll/template-conditions";
+import { isFieldPath } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templatePreviewValues.ts
 /** Concatenated plain text of a preview value. */
 const templatePreviewValueText = (value) => typeof value === "string" ? value : value.runs.map((run) => run.text).join("");
@@ -64,28 +64,21 @@ function buildValueWidget(value, mode) {
 		return span;
 	};
 }
-/** Loop alias the bare-path probe binds. Any identifier does; it is discarded. */
-const CHAIN_PROBE_ALIAS = "__folioCondition";
 /** A field path opens with a letter or underscore, so `9x` and `-x` are not one. */
 const FIELD_PATH_HEAD_RE = /^[\p{L}_]/u;
 /**
 * The bare field path a condition's filter chain hangs off, or undefined when
-* the expression is not a path plus a chain.
+* the tag is not a path plus a chain.
 *
-* A host may write the tag the way `{% for x in xs | chain %}` already carries
-* one — `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
-* keying `conditions` by the bare path. Splitting on `|` would cut a quoted
-* argument such as `label("a | b")` in half, so the expression is classified as
-* that very `for` chain instead and the grammar's own argument-aware scan
-* reports the path. An expression that is not a path plus a chain of known
-* filters (`a and b`, `items|length > 0`, `ai("a|b")`) classifies as nothing,
-* which is what keeps a real expression on exact matching.
+* A host may write the tag with the chain of the boolean it names —
+* `{% if buyer_is_a_consumer | checkbox | ai("Is the buyer …") %}` — while
+* keying `conditions` by the bare path. The grammar's argument-aware scan
+* splits the chain (`label("a | b")` stays one argument) and reports the path
+* as `conditionPath`; an expression that is not a path plus a chain of known
+* filters (`a and b`, `items|length > 0`, `ai("a|b")`) has none, which is what
+* keeps a real expression on exact matching.
 */
-const filterChainPath = (expr) => {
-	const meta = classifyMarker(`for ${CHAIN_PROBE_ALIAS} in ${expr}`, "statement");
-	if (meta?.kind !== "for" || !isFieldPath(meta.path) || !FIELD_PATH_HEAD_RE.test(meta.path)) return;
-	return meta.path;
-};
+const filterChainPath = ({ conditionPath }) => conditionPath !== void 0 && isFieldPath(conditionPath) && FIELD_PATH_HEAD_RE.test(conditionPath) ? conditionPath : void 0;
 /**
 * The verdict stored under one key. Only a key the host set itself, holding a
 * real boolean, counts: an inherited property (`constructor`, or a boolean the
@@ -102,10 +95,10 @@ const ownVerdict = (conditions, key) => {
 * by the bare path its filter chain hangs off. `undefined` means the host said
 * nothing about this block, which leaves it exactly as authored.
 */
-const conditionVerdict = (conditions, expr) => {
-	const exact = ownVerdict(conditions, expr);
+const conditionVerdict = (conditions, opener) => {
+	const exact = ownVerdict(conditions, opener.expr);
 	if (exact !== void 0) return exact;
-	const path = filterChainPath(expr);
+	const path = filterChainPath(opener);
 	return path === void 0 ? void 0 : ownVerdict(conditions, path);
 };
 /**
@@ -157,7 +150,7 @@ function collectHiddenRanges(ranges, conditions, mode) {
 		}
 		if (block === void 0 || block.opener.kind !== "if") continue;
 		const { opener, branches } = block;
-		const verdict = conditionVerdict(conditions, opener.expr);
+		const verdict = conditionVerdict(conditions, opener);
 		if (verdict === void 0) continue;
 		if (!verdict) {
 			paired.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.54.0",
+  "version": "0.54.1",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",
@@ -134,9 +134,9 @@
     "perf": "bun scripts/profile-editor.ts"
   },
   "dependencies": {
-    "@stll/docx-core": "^0.29.0",
+    "@stll/docx-core": "^0.30.0",
     "@stll/docx-utils": "^0.1.0",
-    "@stll/template-conditions": ">=0.4.0 <1.0.0",
+    "@stll/template-conditions": "^0.6.2",
     "better-result": "3.0.1",
     "csstype": "^3.1.3",
     "dompurify": "^3.4.13",