@stll/folio-core 0.33.1 → 0.34.0

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

@@ -5,8 +5,8 @@ import { DocPositionRange, clampRangeToDocSize, resolveFolioAIBlockRange, resolv
 import { buildAnnotatedBlockText } from "./clean-text.js";
 import { ApplyFolioDocumentOperationsOptions, FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FolioDocumentOperation, FolioDocumentOperationAffectedTarget, FolioDocumentOperationBatch, FolioDocumentOperationCapabilities, FolioDocumentOperationIssue, FolioDocumentOperationMode, FolioDocumentOperationPrecondition, FolioDocumentOperationReceipt, FolioDocumentOperationRecovery, FolioDocumentOperationResult, FolioDocumentOperationResultBase, FolioDocumentOperationStatus, FolioDocumentOperationStory, FolioDocumentOperationType, FolioDocumentOperationUndoFailureReason, FolioDocumentOperationUndoHandle, FolioDocumentOperationUndoResult, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, isFolioDocumentOperationModeSupported, isSupportedFolioDocumentOperationVersion, parseFolioDocumentOperationBatch } from "../document-operations.js";
 import { FolioCommentAnchor, FolioReviewChange, FolioReviewChangeKind, getCommentAnchorsFromDoc, getTrackedChangesFromDoc } from "./read.js";
-import { FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioApplyDocumentOperationsToStoryOptions, FolioDocumentStory, FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, FolioEditableDocumentStoryHandle, FolioReadReviewedStoryOptions, FolioResolveReviewedStoryOptions, FolioResolvedReviewedView, FolioReviewedStory, FolioReviewedView, UnsupportedFolioReviewedViewError, isFolioResolvedReviewedView, isFolioReviewedView } from "./headless.js";
 import { createFolioAIEditSnapshot, createFolioAITextRangeHandle, hashFolioAIBlockText, isFolioAIContentBlock, normalizeFolioAIBlockText } from "./snapshot.js";
+import { FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioApplyDocumentOperationsToStoryOptions, FolioDocumentStory, FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, FolioEditableDocumentStoryHandle, FolioReadReviewedStoryOptions, FolioResolveReviewedStoryOptions, FolioResolvedReviewedView, FolioReviewedStory, FolioReviewedView, UnsupportedFolioReviewedViewError, isFolioResolvedReviewedView, isFolioReviewedView } from "./headless.js";
 import { getFolioDocumentOutline, readFolioDocumentSection } from "./scoped-reading.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.js";
 export { type ApplyFolioDocumentOperationsOptions, type DocPositionRange, FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, type FolioAIBlock, type FolioAIBlockAnchor, type FolioAIBlockKind, type FolioAIBlockPreviewRun, type FolioAIBlockTableLocation, type FolioAIComment, type FolioAIEditAppliedOperation, type FolioAIEditApplyMode, type FolioAIEditApplyOutcome, type FolioAIEditApplyResult, type FolioAIEditNormalization, type FolioAIEditNormalizationCode, type FolioAIEditOperation, type FolioAIEditPrecondition, type FolioAIEditReviewMeta, type FolioAIEditSeverity, type FolioAIEditSkipReason, type FolioAIEditSkippedOperation, type FolioAIEditSnapshot, type FolioAIEditView, type FolioAIInlineFormatting, type FolioAISignatureParty, type FolioAITextRangeHandle, type FolioApplyDocumentOperationsToStoryOptions, type FolioCommentAnchor, type FolioDocumentNavigationTarget, type FolioDocumentOperation, type FolioDocumentOperationAffectedTarget, type FolioDocumentOperationBatch, type FolioDocumentOperationCapabilities, type FolioDocumentOperationIssue, type FolioDocumentOperationMode, type FolioDocumentOperationPrecondition, type FolioDocumentOperationReceipt, type FolioDocumentOperationRecovery, type FolioDocumentOperationResult, type FolioDocumentOperationResultBase, type FolioDocumentOperationStatus, type FolioDocumentOperationStory, type FolioDocumentOperationType, type FolioDocumentOperationUndoFailureReason, type FolioDocumentOperationUndoHandle, type FolioDocumentOperationUndoResult, type FolioDocumentOutline, type FolioDocumentOutlineEntry, type FolioDocumentSection, type FolioDocumentSectionHandle, type FolioDocumentSectionReadResult, type FolioDocumentStory, type FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, type FolioEditableDocumentStoryHandle, type FolioReadReviewedStoryOptions, type FolioResolveReviewedStoryOptions, type FolioResolvedReviewedView, type FolioReviewChange, type FolioReviewChangeKind, type FolioReviewedStory, type FolioReviewedView, type FolioRevisionStamp, type FolioWordDiffOptions, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, UnsupportedFolioReviewedViewError, WORD_DIFF_GRANULARITIES, type WordDiffGranularity, type WordDiffNormalization, type WordDiffOptions, type WordDiffSegment, applyFolioAIEditOperations, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, buildAnnotatedBlockText, clampRangeToDocSize, createFolioAIEditSnapshot, createFolioAITextRangeHandle, diffWordSegments, getCommentAnchorsFromDoc, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, getFolioDocumentOutline, getFolioParaIdFromBlockId, getTrackedChangesFromDoc, hashFolioAIBlockText, isFolioAIContentBlock, isFolioDocumentOperationModeSupported, isFolioResolvedReviewedView, isFolioReviewedView, isSupportedFolioDocumentOperationVersion, normalizeFolioAIBlockText, parseFolioDocumentOperationBatch, readFolioDocumentSection, resolveFolioAIBlockRange, resolveFolioAITextRange, resolvePassageRange };

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

@@ -50,6 +50,24 @@ declare const createFolioAITextRangeHandle: ({ blockId, text, startOffset, endOf
  * whole subtree, so a table nested inside a hidden row is hidden with it.
  */
 declare const isHiddenTableRow: (node: Node) => boolean;
+/** One table of a story, numbered the way {@link createFolioAIEditSnapshot} numbers it. */
+type FolioStoryTable = {
+  /** Document-order index over every table, nested ones included. */
+  index: number;
+  /** The table node's position in the story document. */
+  start: number;
+  node: Node;
+};
+/**
+ * Every table of one story in document order, nested tables included and
+ * hidden rows' subtrees excluded.
+ *
+ * The single place a story's tables are numbered. `table.tableIndex` on a
+ * block, the geometry a comparison copies out of the target and the geometry
+ * it checks its own work against all read this list, so no second walk can
+ * number the same document differently.
+ */
+declare const folioStoryTables: (doc: Node) => FolioStoryTable[];
 declare const createFolioAIEditSnapshot: (doc: Node) => FolioAIEditSnapshot;
 //#endregion
-export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };
+export { FolioStoryTable, createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };

package/dist/ai-edits/snapshot.js

@@ -1,3 +1,4 @@
+import { expectRunFormattingOverrideMarkAttrs } from "../prosemirror/attrs/index.js";
 import { deriveBlankBlockId, deriveBlockId } from "../types/block-id.js";
 import { buildCleanBlockText } from "./clean-text.js";
 import { TableMap } from "prosemirror-tables";
@@ -69,6 +70,29 @@ const TABLE_ROLE_ROW = "row";
 */
 const isHiddenTableRow = (node) => node.type.name === TABLE_ROW_NODE_NAME && node.attrs["hidden"] === true;
 /**
+* Every table of one story in document order, nested tables included and
+* hidden rows' subtrees excluded.
+*
+* The single place a story's tables are numbered. `table.tableIndex` on a
+* block, the geometry a comparison copies out of the target and the geometry
+* it checks its own work against all read this list, so no second walk can
+* number the same document differently.
+*/
+const folioStoryTables = (doc) => {
+	const tables = [];
+	doc.descendants((node, pos) => {
+		if (node.isTextblock) return false;
+		if (isHiddenTableRow(node)) return false;
+		if (node.type.spec["tableRole"] === TABLE_ROLE_TABLE) tables.push({
+			index: tables.length,
+			start: pos,
+			node
+		});
+		return true;
+	});
+	return tables;
+};
+/**
 * Locate the block inside its innermost enclosing table, or `undefined` when
 * it sits outside every table.
 */
@@ -102,7 +126,7 @@ const createFolioAIEditSnapshot = (doc) => {
 	const draftBlocks = [];
 	const hashCounts = /* @__PURE__ */ new Map();
 	const usedBlockIds = /* @__PURE__ */ new Set();
-	const tableIndexByStart = /* @__PURE__ */ new Map();
+	const tableIndexByStart = new Map(folioStoryTables(doc).map(({ start, index }) => [start, index]));
 	const path = [];
 	let blockIndex = 0;
 	let blankIndex = 0;
@@ -110,7 +134,6 @@ const createFolioAIEditSnapshot = (doc) => {
 		while (pos >= (path.at(-1)?.end ?? Number.POSITIVE_INFINITY)) path.pop();
 		if (!node.isTextblock) {
 			if (isHiddenTableRow(node)) return false;
-			if (node.type.spec["tableRole"] === TABLE_ROLE_TABLE) tableIndexByStart.set(pos, tableIndexByStart.size);
 			if (!node.isLeaf) path.push({
 				node,
 				start: pos,
@@ -230,14 +253,16 @@ const getPreviewRuns = (node) => {
 		if (!child.isText || child.text === void 0) return true;
 		if (child.marks.some((mark) => mark.type.name === DELETION_MARK)) return false;
 		const style = getPreviewRunStyle(child.marks, defaultStyle);
+		const directFormatting = getDirectPreviewRunStyle(child.marks, defaultStyle);
 		const previous = runs.at(-1);
-		if (previous && samePreviewRunStyle(previous, style)) {
+		if (previous && samePreviewRunStyle(previous, style) && sameDirectFormatting(previous.directFormatting, directFormatting)) {
 			previous.text += child.text;
 			return false;
 		}
 		runs.push({
 			text: child.text,
-			...style
+			...style,
+			...!isEmptyPreviewRunStyle(directFormatting) && { directFormatting }
 		});
 		return false;
 	});
@@ -288,6 +313,23 @@ const getPreviewRunStyle = (marks, defaultStyle) => {
 	}
 	return style;
 };
+const getDirectPreviewRunStyle = (marks, inheritedStyle) => {
+	const markedStyle = getPreviewRunStyle(marks, {});
+	const directStyle = {};
+	const overrideMark = marks.find(({ type }) => type.name === "runFormattingOverride");
+	const hasFormattingProvenance = overrideMark !== void 0 || marks.some(({ type }) => type.name === "characterStyle");
+	const directFontProperties = overrideMark ? expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties : void 0;
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	]) if (Boolean(markedStyle[property]) !== Boolean(inheritedStyle[property])) directStyle[property] = Boolean(markedStyle[property]);
+	if (markedStyle.fontFamily !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontFamily") : markedStyle.fontFamily !== inheritedStyle.fontFamily)) directStyle.fontFamily = markedStyle.fontFamily;
+	if (markedStyle.fontSizePt !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontSize") : markedStyle.fontSizePt !== inheritedStyle.fontSizePt)) directStyle.fontSizePt = markedStyle.fontSizePt;
+	if (markedStyle.color !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("color") : markedStyle.color !== inheritedStyle.color)) directStyle.color = markedStyle.color;
+	return directStyle;
+};
 const getBooleanTextFormatting = (formatting) => ({
 	...Reflect.get(formatting, "bold") === true && { bold: true },
 	...Reflect.get(formatting, "italic") === true && { italic: true },
@@ -330,6 +372,8 @@ const getColorFromAttrs = (attrs) => {
 	return `#${rgb}`;
 };
 const samePreviewRunStyle = (run, style) => run.bold === style.bold && run.italic === style.italic && run.underline === style.underline && run.strike === style.strike && run.fontFamily === style.fontFamily && run.fontSizePt === style.fontSizePt && run.color === style.color;
+const isEmptyPreviewRunStyle = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
+const sameDirectFormatting = (left, right) => left === void 0 && isEmptyPreviewRunStyle(right) || left !== void 0 && left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
 const isUnstyledPreviewRun = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
 //#endregion
-export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };
+export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };

package/dist/ai-edits/table-geometry.d.ts

@@ -0,0 +1,56 @@
+import { FolioStoryTable } from "./snapshot.js";
+import { Transaction } from "prosemirror-state";
+import { Node } from "prosemirror-model";
+//#region src/ai-edits/table-geometry.d.ts
+/**
+ * One line per table, in the document order tables are numbered in: the
+ * table's own properties, then each row's and each cell's. Nested tables get
+ * their own lines rather than being folded into their parent's, so a
+ * difference names the table it is in.
+ */
+declare const projectTableGeometry: (tables: readonly FolioStoryTable[]) => string[];
+/** Where a cell sits: which table, which row of it, which cell of that row. */
+type TableCellCoordinate = {
+  tableIndex: number;
+  rowIndex: number;
+  cellIndex: number;
+};
+/** One base cell and the target cell it was aligned with. */
+type TableGeometryPairing = {
+  base: TableCellCoordinate;
+  target: TableCellCoordinate;
+};
+type MatchTableGeometryOptions = {
+  tr: Transaction;
+  /** The base story's tables, with the positions the transaction will write at. */
+  baseTables: readonly FolioStoryTable[];
+  /** The target story's tables, by the same index the pairings name. */
+  targetTables: ReadonlyMap<number, Node>;
+  pairings: readonly TableGeometryPairing[];
+  revision: {
+    author: string;
+    date: string;
+    idSeed: number;
+  };
+};
+type MatchTableGeometryResult = {
+  /** First revision id a following batch may allocate. */
+  nextRevisionId: number;
+  /** Tables, rows and cells whose properties the match moved. */
+  matched: number;
+};
+/**
+ * Copy a paired table's, row's and cell's properties from the document it was
+ * compared against, recording the previous set so a reject restores it.
+ *
+ * Pairings name cells, because that is what the block alignment resolves; the
+ * row and the table each cell sits in are matched with it. A property set that
+ * already agrees is left alone, so an unchanged table produces no revision.
+ *
+ * `colspan` / `rowspan` never move: they shape the table map, and changing one
+ * without restructuring the rows around it leaves the map inconsistent with
+ * its own grid. That is the rule a reject of a `w:tcPrChange` follows too.
+ */
+declare const matchTableGeometry: ({ tr, baseTables, targetTables, pairings, revision }: MatchTableGeometryOptions) => MatchTableGeometryResult;
+//#endregion
+export { MatchTableGeometryResult, TableCellCoordinate, TableGeometryPairing, matchTableGeometry, projectTableGeometry };

package/dist/ai-edits/table-geometry.js

@@ -0,0 +1,217 @@
+import { tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "../prosemirror/commands/propertyChangeScope.js";
+import { tableAttrsToFormatting, tableCellAttrsToFormatting, tableRowAttrsToFormatting } from "../prosemirror/conversion/fromProseDoc.js";
+import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
+//#region src/ai-edits/table-geometry.ts
+const ORIGINAL_FORMATTING = "_originalFormatting";
+/**
+* The formatting a parser stored verbatim for the save path. It is deliberately
+* outside every projection below: a document saved by an editor materializes
+* style-resolved properties into its own `w:tcPr`, so two packages that render
+* the same table can store different formatting for it, and comparing what was
+* stored would report a difference no redline can or should represent. What is
+* compared is the effective set the properties resolve to.
+*/
+const withoutOriginalFormatting = (keys) => keys.filter((key) => key !== ORIGINAL_FORMATTING);
+/**
+* Attrs a `w:tblPrChange` reject restores, and therefore the attrs a match
+* writes and the projection reads. `columnWidths` is deliberately outside
+* them: the grid is `w:tblGrid`, not `w:tblPr`, and the editable model has no
+* `w:tblGridChange` to record a change of it against.
+*/
+const TABLE_SCOPED_ATTRS = withoutOriginalFormatting(Object.keys(tableRejectAttrPatch(void 0)));
+const ROW_SCOPED_ATTRS = withoutOriginalFormatting(Object.keys(tableRowRejectAttrPatch(void 0)));
+const CELL_SCOPED_ATTRS = withoutOriginalFormatting(Object.keys(tableCellRejectAttrPatch(void 0, void 0)));
+/**
+* `false` and absent are the same thing for every property in scope here: they
+* are all presence flags (`w:tblHeader`, `w:hidden`, `w:noWrap`), and a parser
+* that materializes an absent one as `false` must not read as a difference
+* from one that leaves it unset.
+*/
+const scopedAttrs = (attrs, keys) => {
+	const scoped = {};
+	for (const key of keys) {
+		const value = attrs[key];
+		scoped[key] = value === false ? null : value ?? null;
+	}
+	return scoped;
+};
+const cellProjection = (cell) => canonicalJson({
+	colspan: cell.attrs["colspan"],
+	rowspan: cell.attrs["rowspan"],
+	...scopedAttrs(cell.attrs, CELL_SCOPED_ATTRS)
+});
+const rowProjection = (row) => {
+	const cells = [];
+	row.forEach((cell) => {
+		cells.push(cellProjection(cell));
+	});
+	return `${canonicalJson(scopedAttrs(row.attrs, ROW_SCOPED_ATTRS))}|${cells.join("|")}`;
+};
+/**
+* One line per table, in the document order tables are numbered in: the
+* table's own properties, then each row's and each cell's. Nested tables get
+* their own lines rather than being folded into their parent's, so a
+* difference names the table it is in.
+*/
+const projectTableGeometry = (tables) => tables.map(({ node }) => {
+	const rows = [];
+	node.forEach((row) => {
+		rows.push(rowProjection(row));
+	});
+	return `${canonicalJson(scopedAttrs(node.attrs, TABLE_SCOPED_ATTRS))}#${rows.join("#")}`;
+});
+const childPositions = (node, start) => {
+	const positions = [];
+	let offset = start + 1;
+	node.forEach((child) => {
+		positions.push(offset);
+		offset += child.nodeSize;
+	});
+	return positions;
+};
+/**
+* `Node["attrs"]` is an open record, and the converters below want the node
+* type's own shape. The two span counts are the only members the schema always
+* carries a value for, so naming them is what turns the record into one.
+*/
+const cellAttrsOf = (node) => ({
+	...effectiveAttrs(node),
+	colspan: typeof node.attrs["colspan"] === "number" ? node.attrs["colspan"] : 1,
+	rowspan: typeof node.attrs["rowspan"] === "number" ? node.attrs["rowspan"] : 1
+});
+/**
+* The node's attrs with the style cascade's own values cleared, so the
+* converter treats every effective value as one the node states.
+*
+* A change element stores the COMPLETE previous property set and a reject
+* rebuilds the live properties from it alone, so the record has to hold what
+* the node renders with — including a border its table style supplied. The
+* save path wants the opposite (write only what the node states, or the
+* inherited value becomes an override), which is what the resolved companions
+* are for; a record is the one place they get in the way.
+*/
+const effectiveAttrs = (node) => ({
+	...node.attrs,
+	_resolvedBorders: null,
+	_resolvedMargins: null,
+	_resolvedCellMargins: null
+});
+const TABLE_SCOPE = {
+	keys: TABLE_SCOPED_ATTRS,
+	formattingOf: (node) => tableAttrsToFormatting(effectiveAttrs(node)),
+	rejectPatch: (previousFormatting) => tableRejectAttrPatch(previousFormatting),
+	changeAttr: "tblPrChange",
+	changeType: "tablePropertyChange"
+};
+const ROW_SCOPE = {
+	keys: ROW_SCOPED_ATTRS,
+	formattingOf: (node) => tableRowAttrsToFormatting(node.attrs),
+	rejectPatch: (previousFormatting) => tableRowRejectAttrPatch(previousFormatting),
+	changeAttr: "trPrChange",
+	changeType: "tableRowPropertyChange"
+};
+const CELL_SCOPE = {
+	keys: CELL_SCOPED_ATTRS,
+	formattingOf: (node) => tableCellAttrsToFormatting(cellAttrsOf(node)),
+	rejectPatch: (previousFormatting, liveFormatting) => tableCellRejectAttrPatch(previousFormatting, liveFormatting),
+	changeAttr: "tcPrChange",
+	changeType: "tableCellPropertyChange"
+};
+const scopedValues = (attrs, keys) => canonicalJson(scopedAttrs(attrs, keys));
+/**
+* One node's properties, matched to the node it was paired with, or `null`
+* when the difference cannot be recorded.
+*
+* A change element stores the COMPLETE previous property set, and rejecting it
+* rebuilds the live properties from that record alone. So the record is built
+* from what the node would SERIALIZE, not from what its parser stored: a cell
+* inherits borders and margins from the table and from a table style, and a
+* record that omitted them would reject to a third document.
+*
+* The check is direct, and it is what keeps the round trip exact: rebuild the
+* live values from the record and see whether they come back. Where they do
+* not, the difference is left alone rather than written as a revision that
+* cannot be undone.
+*/
+const propertyChangeFor = (base, target, position, scope) => {
+	const live = scopedValues(base.attrs, scope.keys);
+	if (live === scopedValues(target.attrs, scope.keys)) return null;
+	const previousFormatting = scope.formattingOf(base);
+	if (scopedValues(scope.rejectPatch(previousFormatting, previousFormatting), scope.keys) !== live) return null;
+	return {
+		position,
+		attrs: {
+			...scopedAttrs(target.attrs, scope.keys),
+			[ORIGINAL_FORMATTING]: scope.formattingOf(target) ?? null
+		},
+		changeAttr: scope.changeAttr,
+		changeType: scope.changeType,
+		previousFormatting
+	};
+};
+/**
+* Copy a paired table's, row's and cell's properties from the document it was
+* compared against, recording the previous set so a reject restores it.
+*
+* Pairings name cells, because that is what the block alignment resolves; the
+* row and the table each cell sits in are matched with it. A property set that
+* already agrees is left alone, so an unchanged table produces no revision.
+*
+* `colspan` / `rowspan` never move: they shape the table map, and changing one
+* without restructuring the rows around it leaves the map inconsistent with
+* its own grid. That is the rule a reject of a `w:tcPrChange` follows too.
+*/
+const matchTableGeometry = ({ tr, baseTables, targetTables, pairings, revision }) => {
+	const baseByIndex = new Map(baseTables.map((table) => [table.index, table]));
+	const targets = [];
+	const claimed = /* @__PURE__ */ new Set();
+	const consider = (base, target, position, scope) => {
+		if (claimed.has(position)) return;
+		claimed.add(position);
+		const change = propertyChangeFor(base, target, position, scope);
+		if (change) targets.push(change);
+	};
+	for (const { base, target } of pairings) {
+		const baseTable = baseByIndex.get(base.tableIndex);
+		const targetTable = targetTables.get(target.tableIndex);
+		if (!baseTable || !targetTable) continue;
+		const baseRow = baseTable.node.maybeChild(base.rowIndex);
+		const targetRow = targetTable.maybeChild(target.rowIndex);
+		const rowPosition = childPositions(baseTable.node, baseTable.start)[base.rowIndex];
+		if (!baseRow || !targetRow || rowPosition === void 0) continue;
+		const baseCell = baseRow.maybeChild(base.cellIndex);
+		const targetCell = targetRow.maybeChild(target.cellIndex);
+		const cellPosition = childPositions(baseRow, rowPosition)[base.cellIndex];
+		if (!baseCell || !targetCell || cellPosition === void 0) continue;
+		consider(baseTable.node, targetTable, baseTable.start, TABLE_SCOPE);
+		consider(baseRow, targetRow, rowPosition, ROW_SCOPE);
+		consider(baseCell, targetCell, cellPosition, CELL_SCOPE);
+	}
+	let revisionId = revision.idSeed;
+	for (const target of targets) {
+		const node = tr.doc.nodeAt(target.position);
+		if (!node) continue;
+		tr.setNodeMarkup(target.position, void 0, {
+			...node.attrs,
+			...target.attrs,
+			[target.changeAttr]: [{
+				type: target.changeType,
+				info: {
+					id: revisionId,
+					author: revision.author,
+					date: revision.date
+				},
+				...target.previousFormatting != null && { previousFormatting: target.previousFormatting }
+			}]
+		});
+		revisionId += 1;
+	}
+	if (revisionId > revision.idSeed) markStructuralChange(tr);
+	return {
+		nextRevisionId: revisionId,
+		matched: targets.length
+	};
+};
+//#endregion
+export { matchTableGeometry, projectTableGeometry };

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

@@ -1,4 +1,4 @@
-import { TrackedChangeProvenance } from "../prosemirror/schema/marks.js";
+import { TableStructureRevision } from "./table-template.js";
 import { TableRowTarget } from "./table-targets.js";
 import { Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
@@ -27,19 +27,6 @@ type TableColumnInsertion = {
   columnIndex: number;
 };
 type TableColumnDeletion = TableColumnInsertion;
-type TableStructureRevision = {
-  revisionId: number;
-  author: string;
-  date: string;
-  /** Optional author initials (w:initials), carried for round-trip. */
-  initials?: string;
-  /**
-   * `"suggested"` marks the produced `trIns`/`trDel`/`cellMarker` as an AI
-   * proposal that is stripped from serialized DOCX until accepted.
-   */
-  provenance?: TrackedChangeProvenance;
-  suggestionId?: string;
-};
 type TableRowColumnMutationResult = {
   type: "applied";
   transaction: Transaction;
@@ -63,8 +50,39 @@ type ApplyTableRowInsertionOptions = {
   insertion: TableRowInsertion;
   cellTexts: readonly string[] | undefined;
   revision: TableStructureRevision | null;
+  /**
+   * The row to place, when the caller has one — a comparison adding a row the
+   * target document already holds. Its `w:trPr` and per-cell `w:tcPr` travel
+   * with it; `cellTexts` builds the row from the neighbouring one when it is
+   * absent or does not fit this table's grid.
+   */
+  template?: Node;
+};
+declare const applyTableRowInsertion: ({ tr, insertion, cellTexts, revision, template }: ApplyTableRowInsertionOptions) => TableRowColumnMutationResult;
+type MarkTableRowContentOptions = {
+  tr: Transaction;
+  rowPosition: number;
+  kind: "insertion" | "deletion";
+  revision: TableStructureRevision;
 };
-declare const applyTableRowInsertion: ({ tr, insertion, cellTexts, revision }: ApplyTableRowInsertionOptions) => TableRowColumnMutationResult;
+/**
+ * Mark the runs inside a row whose structural revision was just written.
+ *
+ * Word records a tracked row insertion or deletion twice: on the row
+ * (`w:trPr/w:ins` | `w:trPr/w:del`) AND around every run in its cells
+ * (`w:ins` | `w:del`, the latter with `w:delText`). A consumer that reads only
+ * run-level revisions — which is most of them — keeps a deleted row's text on
+ * accept and an inserted row's text on reject when the row marker stands
+ * alone, so the two must always be written together.
+ *
+ * Two kinds of run stay unmarked. A run that already carries a revision keeps
+ * it, because OOXML nests `w:ins`/`w:del` but the editable model holds one
+ * wrapper per run and overwriting would drop the earlier revision. A cell that
+ * spans into the row below survives the deletion — `removeRow` moves it down
+ * and shortens its span — so marking its text would delete content the
+ * accepted document must still hold.
+ */
+declare const markTableRowContent: ({ tr, rowPosition, kind, revision }: MarkTableRowContentOptions) => void;
 type ApplyTableColumnInsertionOptions = {
   tr: Transaction;
   insertion: TableColumnInsertion;
@@ -98,4 +116,4 @@ declare const applyTableRowDeletion: ({ tr, deletion, revision }: ApplyTableRowD
  */
 declare const splitCellParagraphTexts: (text: string) => string[];
 //#endregion
-export { TableColumnDeletion, TableColumnInsertion, TableRowDeletion, TableRowInsertion, TableStructureRevision, applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, splitCellParagraphTexts };
+export { MarkTableRowContentOptions, TableColumnDeletion, TableColumnInsertion, TableRowDeletion, TableRowInsertion, applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, markTableRowContent, splitCellParagraphTexts };

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

@@ -1,6 +1,7 @@
 import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
 import { stripBlockIdentityAttrs } from "./block-identity.js";
 import { findEnclosingTableCell, findEnclosingTableRow } from "./table-targets.js";
+import { tableRowFromTemplate } from "./table-template.js";
 import { TableMap, columnIsHeader, removeColumn, removeRow, rowIsHeader, tableNodeTypes } from "prosemirror-tables";
 //#region src/ai-edits/table-row-column-mutations.ts
 const getTableColumnCoordinateKey = ({ tablePosition, columnIndex }) => `${tablePosition}:${columnIndex}`;
@@ -25,7 +26,7 @@ const findTableRowInsertion = ({ doc, blockFrom, position }) => {
 		rowIndex
 	});
 };
-const applyTableRowInsertion = ({ tr, insertion, cellTexts, revision }) => {
+const applyTableRowInsertion = ({ tr, insertion, cellTexts, revision, template }) => {
 	if (revision && insertion.rowspanUpdates.length > 0) return { type: "unsupported" };
 	const liveRowspanUpdates = [];
 	for (const updatePosition of insertion.rowspanUpdates) {
@@ -44,8 +45,15 @@ const applyTableRowInsertion = ({ tr, insertion, cellTexts, revision }) => {
 		rowspan: update.rowspan + 1
 	});
 	const rowAttrs = revision ? { trIns: revision } : null;
-	const row = insertion.rowType.create(rowAttrs, insertion.cells);
-	tr.insert(insertion.rowPosition, populateTableRow(row, cellTexts));
+	const templated = template === void 0 ? null : tableRowFromTemplate({
+		template,
+		columnCount: insertion.columnCount
+	});
+	const row = templated ? templated.type.create({
+		...templated.attrs,
+		...rowAttrs
+	}, templated.content) : populateTableRow(insertion.rowType.create(rowAttrs, insertion.cells), cellTexts);
+	tr.insert(insertion.rowPosition, row);
 	if (revision) markTableRowContent({
 		tr,
 		rowPosition: insertion.rowPosition,
@@ -389,4 +397,4 @@ const getTableColumnDeletionCellPositions = ({ map, table, columnIndex }) => {
 	return [...positions];
 };
 //#endregion
-export { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, splitCellParagraphTexts };
+export { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, markTableRowContent, splitCellParagraphTexts };

package/dist/ai-edits/table-template.d.ts

@@ -0,0 +1,60 @@
+import { TrackedChangeProvenance } from "../prosemirror/schema/marks.js";
+import { Node, Schema } from "prosemirror-model";
+//#region src/ai-edits/table-template.d.ts
+/** The node an operation should place, by the id of the operation placing it. */
+type FolioTableTemplates = ReadonlyMap<string, Node>;
+/**
+ * A structural tracked change on a table row.
+ *
+ * A whole-table insertion has no element of its own in the format: every row
+ * carries `w:trPr/w:ins`, and every run inside it carries `w:ins` as well. A
+ * consumer that reads only run-level revisions keeps the text of a rejected
+ * insertion when the row marker stands alone, so the two are always written
+ * together.
+ */
+type TableStructureRevision = {
+  revisionId: number;
+  author: string;
+  date: string;
+  /** Optional author initials (w:initials), carried for round-trip. */
+  initials?: string;
+  /**
+   * `"suggested"` marks the produced `trIns`/`trDel`/`cellMarker` as an AI
+   * proposal that is stripped from serialized DOCX until accepted.
+   */
+  provenance?: TrackedChangeProvenance;
+  suggestionId?: string;
+};
+type TableFromTemplateOptions = {
+  schema: Schema;
+  template: Node;
+  /** Present in tracked mode: the whole table is stamped as one insertion. */
+  revision?: TableStructureRevision;
+};
+/**
+ * The template table, ready to insert: its properties, grid, rows and cells
+ * carried verbatim, nested tables included, and every row plus every run
+ * stamped as an insertion when the caller is tracking changes.
+ *
+ * `null` when the template is not a table or holds no rows, so the caller can
+ * fall back to the operation's own cell texts rather than place something that
+ * is not one.
+ */
+declare const tableFromTemplate: ({ schema, template, revision }: TableFromTemplateOptions) => Node | null;
+type TableRowFromTemplateOptions = {
+  template: Node;
+  /** Grid columns the row has to occupy, from the table receiving it. */
+  columnCount: number;
+};
+/**
+ * The template row, ready to insert into an existing table.
+ *
+ * Refused — `null`, so the caller falls back to the operation's cell texts —
+ * when the row's cells do not span exactly the receiving table's grid: a row
+ * of a different width would leave the table's map inconsistent with its own
+ * grid. A cell that merged vertically in the document it came from is placed
+ * unmerged, because the rows it reached into are not this table's.
+ */
+declare const tableRowFromTemplate: ({ template, columnCount }: TableRowFromTemplateOptions) => Node | null;
+//#endregion
+export { FolioTableTemplates, TableStructureRevision, tableFromTemplate, tableRowFromTemplate };