@stll/folio-core 0.53.0 → 0.54.0

package/dist/ai-edits/read.js

@@ -2,6 +2,7 @@ import { expectRunPropertyChangeMarkAttrs, expectTrackedChangeMarkAttrs } from "
 import { getFolioNodeRevisionCarriers } from "../prosemirror/revisionCarriers.js";
 import { expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomDisposition } from "../prosemirror/runFormattingInlineCarriers.js";
 import { getTableCellMergeChange } from "../prosemirror/tableCellMergeRevision.js";
+import { enclosingInsertionAncestors, trackedRevisionLayerOf } from "../prosemirror/trackedRevisionPath.js";
 import { readerTextOf } from "./note-references.js";
 import { collectNoteReferenceLabels, createFolioAIEditSnapshot, sourceDocumentOf } from "./snapshot.js";
 //#region src/ai-edits/read.ts
@@ -53,16 +54,29 @@ const firstBlockIdWithin = ({ node, nodePos, blockStarts }) => {
 };
 const belongsToRowRevision = (scope, revision) => revision.id === scope.change.id || revision.author === scope.change.author && revision.date === scope.change.date;
 /** Shared revision interpreter; a null block map omits unrelated block-id projection. */
-const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
+const getTrackedChangeGroupsFromProjectedDoc = (doc, blockStarts) => {
 	const insertionType = doc.type.schema.marks["insertion"];
 	const deletionType = doc.type.schema.marks["deletion"];
 	const grouped = /* @__PURE__ */ new Map();
+	const inlineRanges = /* @__PURE__ */ new Map();
+	const lastInlineGroupByPath = /* @__PURE__ */ new Map();
+	const transparentInlineEnds = /* @__PURE__ */ new Map();
+	const transparentGap = (start, end) => {
+		let pos = start;
+		while (pos < end) {
+			const next = transparentInlineEnds.get(pos);
+			if (next === void 0) return false;
+			pos = next;
+		}
+		return pos === end;
+	};
 	const structuralChangeCellPositions = /* @__PURE__ */ new Map();
 	const rowRevisionScopes = [];
 	const derivedFormattingRepresentationPositions = /* @__PURE__ */ new Set();
 	const noteReferences = collectNoteReferenceLabels(doc);
 	let currentBlockId = null;
 	doc.descendants((node, pos) => {
+		if (node.type.name === "commentReference") transparentInlineEnds.set(pos, pos + node.nodeSize);
 		while (pos >= (rowRevisionScopes.at(-1)?.end ?? Number.POSITIVE_INFINITY)) rowRevisionScopes.pop();
 		const nodeRevisionCarriers = getFolioNodeRevisionCarriers(node, pos);
 		if (nodeRevisionCarriers.length > 0) {
@@ -204,70 +218,106 @@ const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => {
 			}
 		}
 		const text = readerTextOf(node, noteReferences);
-		for (const mark of node.marks) {
-			if (mark.type.name === "runPropertyChange") continue;
-			if (typeof mark.attrs["revisionId"] !== "number") continue;
-			let kind;
-			if (mark.type === insertionType) kind = "insertion";
-			else if (mark.type === deletionType) kind = "deletion";
-			else continue;
-			const author = mark.attrs["author"];
-			const date = mark.attrs["date"];
-			const layers = [...(expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors ?? []).map((ancestor) => ({
-				kind: ancestor.type === "insertion" || ancestor.type === "moveTo" ? "insertion" : "deletion",
-				revision: {
-					id: ancestor.revisionId,
-					author: ancestor.author,
-					date: ancestor.date ?? null
-				}
-			})), {
-				kind,
-				revision: {
-					id: mark.attrs["revisionId"],
-					author: typeof author === "string" ? author : "",
-					date: typeof date === "string" ? date : null
-				}
-			}];
-			for (const { kind: layerKind, revision } of layers) {
-				const rowScope = rowRevisionScopes.at(-1);
-				if (rowScope?.kind === layerKind && belongsToRowRevision(rowScope, revision)) continue;
-				const key = `${currentBlockId ?? ""}:${layerKind}:${revision.id}`;
-				const existing = grouped.get(key);
-				if (existing) {
-					existing.text += text;
-					continue;
-				}
-				grouped.set(key, {
-					...revision,
-					type: layerKind,
-					text,
-					blockId: currentBlockId
-				});
+		const insertionMark = node.marks.find((mark) => mark.type === insertionType);
+		const deletionMark = node.marks.find((mark) => mark.type === deletionType);
+		const mark = deletionMark ?? insertionMark;
+		if (!mark || typeof mark.attrs["revisionId"] !== "number") return;
+		const attrs = expectTrackedChangeMarkAttrs(mark);
+		const pathLayers = [...enclosingInsertionAncestors({
+			insertionMark: deletionMark ? insertionMark : void 0,
+			ancestors: attrs._docxRevisionAncestors ?? [],
+			node
+		}), trackedRevisionLayerOf(mark, node)];
+		const layers = pathLayers.map((layer) => ({
+			kind: layer.type === "insertion" || layer.type === "moveTo" ? "insertion" : "deletion",
+			revision: {
+				id: layer.revisionId,
+				author: layer.author,
+				date: layer.date ?? null
+			}
+		}));
+		for (const [layerIndex, { kind: layerKind, revision }] of layers.entries()) {
+			const rowScope = rowRevisionScopes.at(-1);
+			if (rowScope?.kind === layerKind && belongsToRowRevision(rowScope, revision)) continue;
+			const path = `${currentBlockId ?? ""}:${JSON.stringify(pathLayers.slice(0, layerIndex + 1))}`;
+			const previousKey = lastInlineGroupByPath.get(path);
+			const previousRange = previousKey === void 0 ? void 0 : inlineRanges.get(previousKey);
+			const key = previousKey !== void 0 && previousRange && transparentGap(previousRange.end, pos) ? previousKey : `${path}:${pos}`;
+			lastInlineGroupByPath.set(path, key);
+			const hyperlink = node.marks.find((candidate) => candidate.type.name === "hyperlink");
+			const commentId = node.marks.find((candidate) => candidate.type.name === "comment")?.attrs["commentId"];
+			const boundary = {
+				hyperlink: hyperlink ? String(hyperlink.attrs["href"] ?? "") : null,
+				comment: typeof commentId === "number" ? commentId : null,
+				revisionParents: JSON.stringify(pathLayers.slice(0, layerIndex))
+			};
+			const range = inlineRanges.get(key);
+			if (range) {
+				range.end = pos + node.nodeSize;
+				range.lastBoundary = boundary;
+			} else inlineRanges.set(key, {
+				start: pos,
+				end: pos + node.nodeSize,
+				firstBoundary: boundary,
+				lastBoundary: boundary
+			});
+			const existing = grouped.get(key);
+			if (existing) {
+				existing.text += text;
+				continue;
 			}
+			grouped.set(key, {
+				...revision,
+				type: layerKind,
+				text,
+				blockId: currentBlockId
+			});
 		}
 	});
-	return [...grouped.values()];
+	const groups = [];
+	let previousKey = null;
+	for (const [key, change] of grouped) {
+		const range = inlineRanges.get(key);
+		const previous = groups.at(-1);
+		const previousRange = previousKey === null ? void 0 : inlineRanges.get(previousKey);
+		if (previous && range && previousRange && previousRange.end <= range.start && transparentGap(previousRange.end, range.start) && previousRange.lastBoundary.revisionParents === range.firstBoundary.revisionParents && (previousRange.lastBoundary.hyperlink !== range.firstBoundary.hyperlink || previousRange.lastBoundary.comment !== range.firstBoundary.comment || previousRange.end !== range.start) && (change.type === "insertion" || change.type === "deletion") && previous.change.type === change.type && previous.change.author === change.author && previous.change.date === change.date && previous.change.blockId === change.blockId) {
+			previous.change.text += change.text;
+			previous.ids.push(change.id);
+			previousRange.end = range.end;
+			previousRange.lastBoundary = range.lastBoundary;
+			continue;
+		}
+		groups.push({
+			change: { ...change },
+			ids: [change.id]
+		});
+		previousKey = key;
+	}
+	return groups;
 };
+const getTrackedChangesFromProjectedDoc = (doc, blockStarts) => getTrackedChangeGroupsFromProjectedDoc(doc, blockStarts).map(({ change }) => change);
 /** Read revisions from the exact immutable document that produced a snapshot. */
 const getTrackedChangesFromSnapshot = (snapshot) => getTrackedChangesFromProjectedDoc(sourceDocumentOf(snapshot), blockStartIdsFromSnapshot(snapshot));
 /**
 * The tracked changes present in the body, read from inline marks and
-* structural node attributes. Runs of one inline revision within a block fold
-* into a single entry.
+* structural node attributes. Adjacent runs sharing a revision wrapper path
+* fold into one entry; interrupted or differently nested wrappers stay separate.
 *
 * A tracked row insertion or deletion marks the row AND every run in its
 * cells, the way Word writes it. Both halves are one change, so the run marks
 * fold into the row's entry rather than reporting a second time.
 */
 const getTrackedChangesFromDoc = (doc) => getTrackedChangesFromProjectedDoc(doc, blockStartIdsFromDoc(doc));
+/** Physical revision ids behind an inline change split by markup. */
+const getTrackedChangeGroupIdsFromDoc = (doc, id) => getTrackedChangeGroupsFromProjectedDoc(doc, blockStartIdsFromDoc(doc)).find(({ ids }) => ids.includes(id))?.ids ?? [id];
 /** @internal Read revision statistics without paying for an unrelated block projection. */
 const getTrackedChangeStatsFromDoc = (doc) => {
 	let highestId = 0;
-	const changes = getTrackedChangesFromProjectedDoc(doc, null);
-	for (const change of changes) highestId = Math.max(highestId, change.id);
+	const groups = getTrackedChangeGroupsFromProjectedDoc(doc, null);
+	for (const { ids } of groups) for (const id of ids) highestId = Math.max(highestId, id);
 	return {
 		highestId,
-		present: changes.length > 0
+		present: groups.length > 0
 	};
 };
 /**
@@ -313,4 +363,4 @@ const getCommentAnchorsFromDoc = (doc) => {
 	}));
 };
 //#endregion
-export { FOLIO_REVIEW_CHANGE_KINDS, getCommentAnchorsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };
+export { FOLIO_REVIEW_CHANGE_KINDS, getCommentAnchorsFromDoc, getTrackedChangeGroupIdsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot };

package/dist/ai-edits/revisionStretches.d.ts

@@ -0,0 +1,17 @@
+import { Transaction } from "prosemirror-state";
+//#region src/ai-edits/revisionStretches.d.ts
+type SeparateRevisionStretchesOptions = {
+  tr: Transaction;
+  revisionSeed: number;
+};
+type SeparatedRevisionStretches = {
+  nextRevisionId: number;
+  /** Each fresh id, with the revision whose stretch it now names. */
+  minted: {
+    revisionId: number;
+    from: number;
+  }[];
+};
+declare const separateRevisionStretches: ({ tr, revisionSeed }: SeparateRevisionStretchesOptions) => SeparatedRevisionStretches;
+//#endregion
+export { SeparatedRevisionStretches, separateRevisionStretches };

package/dist/ai-edits/revisionStretches.js

@@ -0,0 +1,80 @@
+import { expectTrackedChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+//#region src/ai-edits/revisionStretches.ts
+const INLINE_REVISION_MARKS = /* @__PURE__ */ new Set(["insertion", "deletion"]);
+const separateRevisionStretches = ({ tr, revisionSeed }) => {
+	let nextRevisionId = revisionSeed;
+	const minted = [];
+	const retargets = [];
+	let stretches = /* @__PURE__ */ new Map();
+	tr.doc.descendants((node, pos) => {
+		if (node.isTextblock) {
+			stretches = /* @__PURE__ */ new Map();
+			return true;
+		}
+		if (!node.isInline || !(node.isLeaf || node.isText)) return true;
+		const layersOf = (mark) => {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			return [...(attrs._docxRevisionAncestors ?? []).flatMap((ancestor) => ancestor.type === "insertion" || ancestor.type === "deletion" ? [{
+				kind: ancestor.type,
+				revisionId: ancestor.revisionId
+			}] : []), {
+				kind: mark.type.name,
+				revisionId: attrs.revisionId
+			}];
+		};
+		const revisionMarks = node.marks.filter((mark) => INLINE_REVISION_MARKS.has(mark.type.name) && expectTrackedChangeMarkAttrs(mark).moveKind === void 0);
+		const carried = new Set(revisionMarks.flatMap((mark) => layersOf(mark).map(({ kind, revisionId }) => `${kind}:${String(revisionId)}`)));
+		if (node.type.name !== "commentReference") {
+			for (const [key, stretch] of stretches) if (!carried.has(key)) stretch.interrupted = true;
+		}
+		for (const mark of revisionMarks) {
+			const ids = /* @__PURE__ */ new Map();
+			for (const { kind, revisionId } of layersOf(mark)) {
+				const key = `${kind}:${String(revisionId)}`;
+				let stretch = stretches.get(key);
+				if (!stretch) {
+					stretch = {
+						id: revisionId,
+						interrupted: false
+					};
+					stretches.set(key, stretch);
+				} else if (stretch.interrupted) {
+					const fresh = nextRevisionId++;
+					minted.push({
+						revisionId: fresh,
+						from: revisionId
+					});
+					stretch = {
+						id: fresh,
+						interrupted: false
+					};
+					stretches.set(key, stretch);
+				}
+				if (stretch.id !== revisionId) ids.set(revisionId, stretch.id);
+			}
+			if (ids.size > 0) retargets.push({
+				from: pos,
+				to: pos + node.nodeSize,
+				mark,
+				ids
+			});
+		}
+		return true;
+	});
+	for (const { from, to, mark, ids } of retargets) {
+		const attrs = expectTrackedChangeMarkAttrs(mark);
+		const ancestors = attrs._docxRevisionAncestors;
+		tr.removeMark(from, to, mark);
+		tr.addMark(from, to, mark.type.create({
+			...mark.attrs,
+			revisionId: ids.get(attrs.revisionId) ?? attrs.revisionId,
+			...ancestors && { _docxRevisionAncestors: ancestors.map((ancestor) => Object.assign(structuredClone(ancestor), { revisionId: ids.get(ancestor.revisionId) ?? ancestor.revisionId })) }
+		}));
+	}
+	return {
+		nextRevisionId,
+		minted
+	};
+};
+//#endregion
+export { separateRevisionStretches };

package/dist/ai-edits/snapshot.js

@@ -4,13 +4,13 @@ import { resolveParagraphNumbering } from "../docx/numberingReference.js";
 import { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName } from "../docx/opaqueCarrier.js";
 import { recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectCharacterStyleMarkAttrs, expectHyperlinkMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs } from "../prosemirror/attrs/index.js";
-import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.js";
 import { createListLabelCounter } from "../prosemirror/listLabels.js";
 import { paragraphNumberingAttr, readParagraphNumberingAttr } from "../prosemirror/numberingAttr.js";
 import { readOutlineLevelAttr } from "../prosemirror/outlineLevelAttr.js";
 import { directParagraphAlignment } from "../prosemirror/paragraphAlignment.js";
 import { directParagraphIndentation } from "../prosemirror/paragraphIndentation.js";
 import { directParagraphSpacing } from "../prosemirror/paragraphSpacing.js";
+import { marksToTextFormatting } from "../prosemirror/runFormattingFromMarks.js";
 import { runFormattingInlineAtomCleanText } from "../prosemirror/runFormattingInlineCarriers.js";
 import { authoredRunFormattingFromAttrs } from "../prosemirror/runFormattingProvenance.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
@@ -748,7 +748,8 @@ const getDefaultPreviewRunStyle = (node, styleResolver) => {
 	};
 };
 const getPreviewRunStyle = (marks, defaultStyle) => {
-	const style = { ...defaultStyle };
+	const { bold: _bold, italic: _italic, underline: _underline, strike: _strike, ...inherited } = defaultStyle;
+	const style = { ...inherited };
 	for (const mark of marks) switch (mark.type.name) {
 		case "bold":
 			style.bold = true;

package/dist/ai-edits/table-cell-mutations.d.ts

@@ -17,5 +17,7 @@ declare const mergeTableRectangle: ({ tr, tablePosition, table, rectangle }: Tab
 declare const mergeTrackedVerticalTableCells: ({ tr, tablePosition, table, rectangle, revisionId, author, date }: TrackedTableCellRectangleMutationOptions) => Transaction | null;
 declare const splitTableRectangle: ({ tr, tablePosition, table, rectangle }: TableCellRectangleMutationOptions) => Transaction | null;
 declare const splitTrackedVerticalTableCell: ({ tr, tablePosition, table, rectangle, revisionId, author, date }: TrackedTableCellRectangleMutationOptions) => Transaction | null;
+/** A cell holding one empty paragraph: all a tracked merge may fold away. */
+declare const isEmptyTableCell: (cell: Node) => boolean;
 //#endregion
-export { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell };
+export { isEmptyTableCell, mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell };

package/dist/ai-edits/table-cell-mutations.js

@@ -259,6 +259,7 @@ const splitTrackedVerticalTableCell = ({ tr, tablePosition, table, rectangle, re
 	markStructuralChange(tr);
 	return tr;
 };
+/** A cell holding one empty paragraph: all a tracked merge may fold away. */
 const isEmptyTableCell = (cell) => cell.childCount === 1 && cell.firstChild?.isTextblock === true && cell.firstChild.childCount === 0;
 const trackedSplitCellFromStoredSource = ({ origin, source, marker }) => {
 	if (source.formatting?.gridSpan !== void 0 && source.formatting.gridSpan > 1) return null;
@@ -286,4 +287,4 @@ const formattingWithoutVerticalMerge = (formatting) => {
 	return next;
 };
 //#endregion
-export { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell };
+export { isEmptyTableCell, mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell };

package/dist/ai-edits/table-row-column-mutations.d.ts

@@ -1,4 +1,5 @@
 import { TableStructureRevision } from "./table-template.js";
+import { RowsEmptiedInBatch } from "../prosemirror/tableGridMutation.js";
 import { TableRowTarget } from "./table-targets.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
@@ -30,6 +31,8 @@ type TableRowColumnMutationResult = {
   type: "applied";
   transaction: Transaction;
   revisionId: number | null;
+  /** Every revision written: a column change writes one per cell. */
+  revisionIds: readonly number[];
 } | {
   type: "unsupported";
 };
@@ -117,8 +120,10 @@ type ApplyTableColumnDeletionOptions = {
   deletion: TableColumnDeletion;
   insertedColumnCount: number;
   revision: TableStructureRevision | null;
+  /** Where to defer closing rows the deletion leaves without cells, when it runs in a batch. */
+  emptiedRows?: RowsEmptiedInBatch;
 };
-declare const applyTableColumnDeletion: ({ tr, deletion, insertedColumnCount, revision }: ApplyTableColumnDeletionOptions) => TableRowColumnMutationResult;
+declare const applyTableColumnDeletion: ({ tr, deletion, insertedColumnCount, revision, emptiedRows }: ApplyTableColumnDeletionOptions) => TableRowColumnMutationResult;
 type ApplyTableRowDeletionOptions = {
   tr: Transaction;
   deletion: TableRowDeletion;

package/dist/ai-edits/table-row-column-mutations.js

@@ -1,10 +1,19 @@
 import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
-import { reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow } from "../prosemirror/tableGridMutation.js";
+import { markRowsEmptiedInBatch, reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow } from "../prosemirror/tableGridMutation.js";
 import { stripBlockIdentityAttrs } from "./block-identity.js";
 import { findEnclosingTableCell, findEnclosingTableRow } from "./table-targets.js";
 import { tableRowFromTemplate } from "./table-template.js";
 import { TableMap, columnIsHeader, removeColumn, rowIsHeader, tableNodeTypes } from "prosemirror-tables";
 //#region src/ai-edits/table-row-column-mutations.ts
+/**
+* The revision of the `index`th cell a column change marks. The save writes
+* each cell's marker as a revision of its own, and each is accepted or
+* rejected on its own; the reviewer's revisions are those from the start.
+*/
+const cellRevision = (revision, index) => ({
+	...revision,
+	revisionId: revision.revisionId + index
+});
 const UNPLACED_TEXT_PREVIEW_LENGTH = 40;
 const previewCellText = (text) => JSON.stringify(text.length > UNPLACED_TEXT_PREVIEW_LENGTH ? `${text.slice(0, UNPLACED_TEXT_PREVIEW_LENGTH)}…` : text);
 /**
@@ -165,6 +174,7 @@ const applyTableColumnInsertion = ({ tr, insertion, cellTexts, revision }) => {
 	});
 	if (!actions || revision && actions.some(({ type }) => type === "setColspan")) return { type: "unsupported" };
 	const mapFrom = tr.mapping.maps.length;
+	let markedCells = 0;
 	for (const action of actions) {
 		const position = tr.mapping.slice(mapFrom).map(tablePosition + 1 + action.position);
 		if (action.type === "setColspan") {
@@ -175,7 +185,7 @@ const applyTableColumnInsertion = ({ tr, insertion, cellTexts, revision }) => {
 			...action.cell.attrs,
 			cellMarker: {
 				kind: "ins",
-				info: revision
+				info: cellRevision(revision, markedCells++)
 			}
 		}, action.cell.content) : action.cell;
 		tr.insert(position, cell);
@@ -186,9 +196,9 @@ const applyTableColumnInsertion = ({ tr, insertion, cellTexts, revision }) => {
 		previousTable: table,
 		insertedColumn: insertion.columnIndex
 	});
-	return applied(tr, revision);
+	return applied(tr, revision, markedCells);
 };
-const applyTableColumnDeletion = ({ tr, deletion, insertedColumnCount, revision }) => {
+const applyTableColumnDeletion = ({ tr, deletion, insertedColumnCount, revision, emptiedRows }) => {
 	const tablePosition = tr.mapping.map(deletion.tablePosition, 1);
 	const table = tr.doc.nodeAt(tablePosition);
 	if (!table || table.type.spec["tableRole"] !== "table") return { type: "unsupported" };
@@ -202,12 +212,12 @@ const applyTableColumnDeletion = ({ tr, deletion, insertedColumnCount, revision
 			columnIndex
 		});
 		if (!cellPositions) return { type: "unsupported" };
-		for (const cellPosition of cellPositions) tr.setNodeAttribute(tablePosition + 1 + cellPosition, "cellMarker", {
+		for (const [index, cellPosition] of cellPositions.entries()) tr.setNodeAttribute(tablePosition + 1 + cellPosition, "cellMarker", {
 			kind: "del",
-			info: revision
+			info: cellRevision(revision, index)
 		});
 		markStructuralChange(tr);
-		return applied(tr, revision);
+		return applied(tr, revision, cellPositions.length);
 	}
 	if (map.width === 1) {
 		const transaction = deleteTableNode({
@@ -232,7 +242,13 @@ const applyTableColumnDeletion = ({ tr, deletion, insertedColumnCount, revision
 		previousTable: table,
 		removedColumn: columnIndex
 	});
-	removeRowsWithoutCells(tr, tablePosition);
+	if (emptiedRows) markRowsEmptiedInBatch({
+		tr,
+		tablePosition,
+		previousTable: table,
+		emptied: emptiedRows
+	});
+	else removeRowsWithoutCells(tr, tablePosition);
 	return applied(tr, null);
 };
 const applyTableRowDeletion = ({ tr, deletion, revision }) => {
@@ -269,10 +285,11 @@ const applyTableRowDeletion = ({ tr, deletion, revision }) => {
 	}, at.index());
 	return applied(tr, null);
 };
-const applied = (transaction, revision) => ({
+const applied = (transaction, revision, revisionCount = 1) => ({
 	type: "applied",
 	transaction,
-	revisionId: revision?.revisionId ?? null
+	revisionId: revision?.revisionId ?? null,
+	revisionIds: revision ? Array.from({ length: revisionCount }, (_, index) => revision.revisionId + index) : []
 });
 const deleteTableNode = ({ tr, tablePosition, table }) => {
 	const tableEnd = tablePosition + table.nodeSize;

package/dist/compare/content-alignment.d.ts

@@ -17,6 +17,10 @@ type FolioContentBlockPair = {
   baseIndex: number;
   revisedIndex: number;
 };
+type IncreasingPairOptions = {
+  priority?: (pair: FolioContentBlockPair) => number;
+  tieBreak?: "earliest" | "minimum-tail";
+};
 /**
  * Longest strictly increasing subsequence by revised index.
  *
@@ -24,7 +28,7 @@ type FolioContentBlockPair = {
  * preserving the historical deterministic tie break while reducing the
  * stable-anchor pass from quadratic to O(n log n).
  */
-declare const longestIncreasingFolioContentPairs: (pairs: readonly FolioContentBlockPair[]) => FolioContentBlockPair[];
+declare const longestIncreasingFolioContentPairs: (pairs: readonly FolioContentBlockPair[], options?: IncreasingPairOptions) => FolioContentBlockPair[];
 type FolioContentAlignedBlockEvent<Block extends FolioContentBlock = FolioContentBlock> = {
   type: "pair";
   baseBlock: Block;

package/dist/compare/content-alignment.js

@@ -45,15 +45,29 @@ const folioContentIdStability = (block) => block.idStability ?? "stable";
 * preserving the historical deterministic tie break while reducing the
 * stable-anchor pass from quadratic to O(n log n).
 */
-const longestIncreasingFolioContentPairs = (pairs) => {
+const longestIncreasingFolioContentPairs = (pairs, options = {}) => {
 	if (pairs.length === 0) return [];
 	const coordinates = [...new Set(pairs.map(({ revisedIndex }) => revisedIndex))].toSorted((left, right) => left - right);
 	const rankByCoordinate = new Map(coordinates.map((coordinate, index) => [coordinate, index + 1]));
-	const treeLengths = new Int32Array(coordinates.length + 1);
 	const treeIndexes = new Int32Array(coordinates.length + 1).fill(-1);
 	const lengths = new Int32Array(pairs.length).fill(1);
 	const predecessors = new Int32Array(pairs.length).fill(-1);
-	const earlier = (leftLength, leftIndex, rightLength, rightIndex) => leftLength > rightLength || leftLength === rightLength && leftLength > 0 && leftIndex < rightIndex;
+	const priorities = new Int32Array(pairs.length);
+	const earlier = ({ leftIndex, rightIndex }) => {
+		const leftLength = lengths[leftIndex] ?? 0;
+		const rightLength = lengths[rightIndex] ?? 0;
+		if (leftLength !== rightLength) return leftLength > rightLength;
+		if (leftLength === 0) return false;
+		const leftPriority = priorities[leftIndex] ?? 0;
+		const rightPriority = priorities[rightIndex] ?? 0;
+		if (leftPriority !== rightPriority) return leftPriority > rightPriority;
+		if (options.tieBreak === "minimum-tail") {
+			const leftTail = pairs[leftIndex]?.revisedIndex ?? Number.POSITIVE_INFINITY;
+			const rightTail = pairs[rightIndex]?.revisedIndex ?? Number.POSITIVE_INFINITY;
+			if (leftTail !== rightTail) return leftTail < rightTail;
+		}
+		return leftIndex < rightIndex;
+	};
 	let bestEnd = 0;
 	let groupStart = 0;
 	while (groupStart < pairs.length) {
@@ -63,32 +77,38 @@ const longestIncreasingFolioContentPairs = (pairs) => {
 		for (let pairIndex = groupStart; pairIndex < groupEnd; pairIndex++) {
 			const pair = pairs[pairIndex];
 			const rank = pair === void 0 ? void 0 : rankByCoordinate.get(pair.revisedIndex);
-			if (rank === void 0) continue;
+			if (rank === void 0 || pair === void 0) continue;
 			let predecessorLength = 0;
 			let predecessorIndex = -1;
 			for (let cursor = rank - 1; cursor > 0; cursor -= cursor & -cursor) {
-				const candidateLength = treeLengths[cursor] ?? 0;
 				const candidateIndex = treeIndexes[cursor] ?? -1;
-				if (earlier(candidateLength, candidateIndex, predecessorLength, predecessorIndex)) {
+				const candidateLength = lengths[candidateIndex] ?? 0;
+				if (earlier({
+					leftIndex: candidateIndex,
+					rightIndex: predecessorIndex
+				})) {
 					predecessorLength = candidateLength;
 					predecessorIndex = candidateIndex;
 				}
 			}
 			lengths[pairIndex] = predecessorLength + 1;
 			predecessors[pairIndex] = predecessorIndex;
-			if ((lengths[pairIndex] ?? 0) > (lengths[bestEnd] ?? 0)) bestEnd = pairIndex;
+			priorities[pairIndex] = (priorities[predecessorIndex] ?? 0) + (options.priority?.(pair) ?? 0);
+			if (earlier({
+				leftIndex: pairIndex,
+				rightIndex: bestEnd
+			})) bestEnd = pairIndex;
 		}
 		for (let pairIndex = groupStart; pairIndex < groupEnd; pairIndex++) {
 			const pair = pairs[pairIndex];
 			const rank = pair === void 0 ? void 0 : rankByCoordinate.get(pair.revisedIndex);
 			if (rank === void 0) continue;
-			for (let cursor = rank; cursor < treeLengths.length; cursor += cursor & -cursor) {
-				const currentLength = treeLengths[cursor] ?? 0;
+			for (let cursor = rank; cursor < treeIndexes.length; cursor += cursor & -cursor) {
 				const currentIndex = treeIndexes[cursor] ?? -1;
-				if (earlier(lengths[pairIndex] ?? 0, pairIndex, currentLength, currentIndex)) {
-					treeLengths[cursor] = lengths[pairIndex] ?? 0;
-					treeIndexes[cursor] = pairIndex;
-				}
+				if (earlier({
+					leftIndex: pairIndex,
+					rightIndex: currentIndex
+				})) treeIndexes[cursor] = pairIndex;
 			}
 		}
 		groupStart = groupEnd;
@@ -238,27 +258,14 @@ const pairByUniqueExactText = ({ base, revised, baseFrom, baseTo, revisedFrom, r
 	}
 	const orderedCandidates = candidates.toSorted((left, right) => left.baseIndex - right.baseIndex || left.revisedIndex - right.revisedIndex);
 	if (orderedCandidates.length === 0) return [];
-	const tailRevisedIndexes = [];
-	const tailCandidateIndexes = [];
-	const predecessors = new Int32Array(orderedCandidates.length).fill(-1);
-	orderedCandidates.forEach((candidate, candidateIndex) => {
-		let lower = 0;
-		let upper = tailRevisedIndexes.length;
-		while (lower < upper) {
-			const middle = lower + Math.floor((upper - lower) / 2);
-			if ((tailRevisedIndexes[middle] ?? Number.POSITIVE_INFINITY) < candidate.revisedIndex) lower = middle + 1;
-			else upper = middle;
+	return longestIncreasingFolioContentPairs(orderedCandidates, {
+		tieBreak: "minimum-tail",
+		priority: ({ baseIndex, revisedIndex }) => {
+			const baseBlock = base[baseIndex];
+			const revisedBlock = revised[revisedIndex];
+			return baseBlock && revisedBlock && baseBlock.pairingFacts.id === revisedBlock.pairingFacts.id && baseBlock.pairingFacts.idStability !== revisedBlock.pairingFacts.idStability ? 1 : 0;
 		}
-		predecessors[candidateIndex] = lower === 0 ? -1 : tailCandidateIndexes[lower - 1] ?? -1;
-		tailRevisedIndexes[lower] = candidate.revisedIndex;
-		tailCandidateIndexes[lower] = candidateIndex;
 	});
-	const pairs = [];
-	for (let candidateIndex = tailCandidateIndexes.at(-1) ?? -1; candidateIndex !== -1; candidateIndex = predecessors[candidateIndex] ?? -1) {
-		const candidate = orderedCandidates[candidateIndex];
-		if (candidate) pairs.push(candidate);
-	}
-	return pairs.toReversed();
 };
 /**
 * Unique exact text anchors, then again inside every sub-gap they leave:

package/dist/compare/inline-provenance.js

@@ -1,6 +1,6 @@
 import { sourceDocumentOf, styleResolverOf } from "../ai-edits/snapshot.js";
 import { expectHyperlinkMarkAttrs, expectRunPropertyChangeMarkAttrs, expectTableCellAttrs } from "../prosemirror/attrs/index.js";
-import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyleState.js";
 import { applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText } from "../prosemirror/runFormattingInlineCarriers.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
 import { nearestParagraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";

package/dist/controller/layoutPipeline.js

@@ -30,6 +30,7 @@ import { renderPages } from "../layout-painter/renderPage.js";
 import { tryBuildIncrementalMeasures } from "../paged-layout/incrementalMeasure.js";
 import { computePerBlockMeasureInputs } from "../paged-layout/sectionBlockWidths.js";
 import { getMargins, getPageNumbering, getPageSize, twipsToPixels } from "../paged-layout/sectionGeometry.js";
+import { markupViewNotes } from "../prosemirror/markupViewNotes.js";
 import { projectMarkupView } from "../prosemirror/markupViewProjection.js";
 import { templatePreviewValuesKey } from "../prosemirror/plugins/templatePreviewValues.js";
 import { getDocumentWatermark } from "../watermark/index.js";
@@ -215,10 +216,10 @@ function runLayoutPipelineMeasured(deps, state, options) {
 		recordPhaseDuration("flow-blocks", phaseStartedAt);
 		phaseStartedAt = performance.now();
 		const footnoteRefs = collectFootnoteRefs(newBlocks);
-		const documentFootnotes = document?.package.footnotes;
+		const documentFootnotes = markupViewNotes(document?.package.footnotes, markupView, state, document);
 		const hasFootnotes = footnoteRefs.length > 0 && documentFootnotes !== void 0;
 		const footnoteDisplayNumbers = documentFootnotes ? computeNoteDisplayNumbers(documentFootnotes, footnoteRefs.map((ref) => ref.footnoteId)) : void 0;
-		const documentEndnotes = document?.package.endnotes;
+		const documentEndnotes = markupViewNotes(document?.package.endnotes, markupView, state, document);
 		const endnoteDisplayNumbers = documentEndnotes ? computeNoteDisplayNumbers(documentEndnotes, collectEndnoteRefs(newBlocks).map((ref) => ref.endnoteId)) : void 0;
 		const endnoteNumberFormat = document?.package.document.sections?.at(-1)?.properties.endnotePr?.numFmt ?? document?.package.settings?.endnotePr?.numFmt ?? "lowerRoman";
 		const endnoteTexts = endnoteDisplayNumbers ? formatEndnoteTexts(endnoteDisplayNumbers, (displayNumber) => formatOoxmlCounter(displayNumber, endnoteNumberFormat)) : void 0;