@stll/folio-core 0.35.1 → 0.37.0

package/dist/compare/plan.js

@@ -1,6 +1,7 @@
+import { folioAIBlockIdStability } from "../ai-edits/block-identity.js";
 import { createFolioAITextRangeHandle, trailingBodyBlockId } from "../ai-edits/snapshot.js";
-import { alignFolioBlocks } from "../version-comparison.js";
-import { alignTableColumns } from "./column-alignment.js";
+import { alignFolioContentStructure, contentBlocksShareContainer, createFolioContentAlignmentWorkSession, groupFolioContentTableRows } from "./content-alignment.js";
+import { changedFolioContentParagraphFormatting, createContentComparisonWorkSession, detectFolioContentMoves, detectFolioContentParagraphMarkPlans } from "./content.js";
 import { inlineFormattingSegments } from "./formatting.js";
 import { panic } from "better-result";
 //#region src/compare/plan.ts
@@ -10,7 +11,7 @@ import { panic } from "better-result";
 * generated tracked change is accepted.
 *
 * Pure: no parsing, no serialization, no clock. Every alignment runs through
-* {@link alignFolioBlocks}, shared with the version-diff and redline paths.
+* {@link alignFolioContentStructure}, shared with representation-neutral comparison.
 *
 * ## Aligning by container, not by block
 *
@@ -34,445 +35,113 @@ import { panic } from "better-result";
 *
 * ## Move detection
 *
-* A base-only and a target-only block with identical text and at least
-* {@link MOVE_MINIMUM_WORD_COUNT} words are one relocation. The operations stay
-* a delete plus an insert — the tracked-change grammar Word round-trips has no
-* durable "moved from here" mark on this path — but the change list reports a
-* single `move` so the relocation is not read as unrelated churn. The word
-* floor keeps boilerplate one-liners from pairing as spurious moves.
+* Move, split/merge, and formatting classification come from the same neutral
+* comparison core used by non-DOCX callers. The operations remain specific to
+* the tracked-change format, but the meaning of the comparison does not fork.
 */
-/** Words a relocated block needs before the move pass will pair it. */
-const MOVE_MINIMUM_WORD_COUNT = 3;
-/**
-* Cap on same-text base-only blocks the move pass keeps per text. Without it a
-* document repeating one paragraph thousands of times would make the pass
-* quadratic on attacker-controlled input.
-*/
-const MAX_MOVE_CANDIDATES_PER_TEXT = 64;
-/**
-* How much of a relocated paragraph must survive the relocation for it still
-* to read as one. Below it the two paragraphs are a deletion and an unrelated
-* insertion, and calling them a move would tell the reader the wrong story
-* about where the text came from.
-*/
-const MOVE_SIMILARITY_THRESHOLD = .8;
-/**
-* Total pair comparisons the similarity pass may make in one story. Exact text
-* matches are found by lookup; only what is left pays this, and it is capped
-* so two documents of unmatched paragraphs cannot make the pass quadratic.
-*/
-const MAX_MOVE_SIMILARITY_COMPARISONS = 2e4;
-/**
-* Dice coefficient over word tokens: twice the shared tokens over the two
-* token counts. Multiset rather than set, so a paragraph repeating a word does
-* not match one that says it once.
-*/
-const tokenSimilarity = (left, right) => {
-	const leftTokens = left.split(/\s+/u).filter((token) => token.length > 0);
-	const rightTokens = right.split(/\s+/u).filter((token) => token.length > 0);
-	if (leftTokens.length === 0 || rightTokens.length === 0) return 0;
-	const remaining = /* @__PURE__ */ new Map();
-	for (const token of leftTokens) remaining.set(token, (remaining.get(token) ?? 0) + 1);
-	let shared = 0;
-	for (const token of rightTokens) {
-		const count = remaining.get(token) ?? 0;
-		if (count > 0) {
-			remaining.set(token, count - 1);
-			shared += 1;
-		}
-	}
-	return 2 * shared / (leftTokens.length + rightTokens.length);
-};
-const wordCountReaches = (text, minimum) => {
-	let count = 0;
-	for (const word of text.split(/\s+/u)) if (word.length > 0 && ++count >= minimum) return true;
-	return false;
-};
-/**
-* The document's segments, normalized to strictly alternate body, table, body,
-* ... and to begin and end with a body segment — inserting empty body segments
-* where the document has none.
-*
-* Without the padding the two sides can hold different segment shapes (a
-* document that opens with a table against one that opens with a heading), and
-* the alignment's positional fallback would then put a body segment opposite a
-* table. That pair is unusable, so the whole table would be reissued as a
-* deletion plus an insertion. Padding keeps like opposite like.
-*/
-const splitSegments = (blocks) => {
-	const segments = [];
-	let currentTableIndex = null;
-	for (const block of blocks) {
-		const tableIndex = block.table?.outerTableIndex ?? null;
-		const current = segments.at(-1);
-		if (current !== void 0 && currentTableIndex === tableIndex) {
-			current.blocks.push(block);
-			continue;
-		}
-		if (block.table && segments.at(-1)?.kind !== "body") segments.push({
-			kind: "body",
-			blocks: []
-		});
-		segments.push({
-			kind: block.table ? "table" : "body",
-			blocks: [block]
-		});
-		currentTableIndex = tableIndex;
-	}
-	if (segments.length === 0 || segments.at(-1)?.kind === "table") segments.push({
-		kind: "body",
-		blocks: []
-	});
-	return segments;
-};
-/**
-* Blocks of one table segment grouped into rows, in document order.
-*
-* Keyed by table AND row, not by row alone: a segment holds the whole
-* outermost table, so a nested table's first row would otherwise merge with
-* its parent's first row and the alignment would compare one against the
-* other.
-*/
-const groupRows = (blocks) => {
-	const rows = /* @__PURE__ */ new Map();
-	for (const block of blocks) {
-		if (!block.table) continue;
-		const key = `${String(block.table.tableIndex)}:${String(block.table.rowIndex)}`;
-		const row = rows.get(key);
-		if (row) row.push(block);
-		else rows.set(key, [block]);
-	}
-	return [...rows.values()];
-};
-const rowText = (row) => row.map(({ text }) => text).join(" ");
-const rowLocation = (row) => row.at(0)?.table ?? null;
-/** Zip one paired row's cells by physical cell index, then by paragraph order. */
-const alignRowCells = (baseRow, targetRow, baseColumnKeys, targetColumnKeys) => {
-	const byCell = (row, columnKeys) => {
-		const cells = /* @__PURE__ */ new Map();
-		for (const block of row) {
-			const table = block.table;
-			let cellIndex = table?.cellIndex ?? 0;
-			if (table && columnKeys) {
-				const alignedColumn = columnKeys.get(table.gridColumnIndex);
-				if (alignedColumn === void 0) return panic("A paired table cell has no aligned grid column", { gridColumnIndex: table.gridColumnIndex });
-				cellIndex = alignedColumn;
-			}
-			const blocks = cells.get(cellIndex);
-			if (blocks) blocks.push(block);
-			else cells.set(cellIndex, [block]);
-		}
-		return cells;
-	};
-	const baseCells = byCell(baseRow, baseColumnKeys);
-	const targetCells = byCell(targetRow, targetColumnKeys);
-	const cellIndexes = [.../* @__PURE__ */ new Set([...baseCells.keys(), ...targetCells.keys()])].toSorted((left, right) => left - right);
-	const steps = [];
-	for (const cellIndex of cellIndexes) {
-		const baseBlocks = baseCells.get(cellIndex) ?? [];
-		const targetBlocks = targetCells.get(cellIndex) ?? [];
-		const paired = Math.min(baseBlocks.length, targetBlocks.length);
-		for (let index = 0; index < paired; index++) {
-			const baseBlock = baseBlocks[index];
-			const targetBlock = targetBlocks[index];
-			if (baseBlock && targetBlock) steps.push({
-				type: "pair",
-				baseBlock,
-				targetBlock
-			});
-		}
-		for (const block of baseBlocks.slice(paired)) steps.push({
-			type: "baseOnly",
-			block
-		});
-		for (const block of targetBlocks.slice(paired)) steps.push({
-			type: "targetOnly",
-			block
-		});
-	}
-	return steps;
-};
-/**
-* Align one table's rows, then its cells.
-*
-* Running the block alignment straight over a table's paragraphs cannot see
-* rows: it happily pairs a cell of one row with a cell of another, and a row
-* that was wholly added or removed shows up as a scatter of unmatched
-* paragraphs. Aligning rows first — each row standing in as one proxy block of
-* its joined cell text — keeps a whole-row change whole, and confines every
-* other difference to a cell that really corresponds.
-*/
-/**
-* One segment's blocks split per table, in first-appearance order. A segment
-* is a whole outermost table, so it holds the parent's blocks and every nested
-* table's; a row alignment that mixed them would compare the parent's first
-* row against a nested table's.
-*/
-const groupTables = (blocks) => {
-	const tables = /* @__PURE__ */ new Map();
-	for (const block of blocks) {
-		if (!block.table) continue;
-		const existing = tables.get(block.table.tableIndex);
-		if (existing) existing.push(block);
-		else tables.set(block.table.tableIndex, [block]);
-	}
-	return [...tables.values()];
-};
-/**
-* Align a paired table segment: each table in it against the table at the same
-* place on the other side, then that table's rows, then its cells. Tables are
-* paired by order within the segment because the segment IS one table plus
-* whatever nests inside it — the nth nested table of one answers to the nth of
-* the other.
-*/
-const buildTableSegmentSteps = (baseBlocks, targetBlocks) => {
-	const baseTables = groupTables(baseBlocks);
-	const targetTables = groupTables(targetBlocks);
-	const steps = [];
-	const paired = Math.min(baseTables.length, targetTables.length);
-	for (let index = 0; index < paired; index++) steps.push(...buildTableSteps(baseTables[index] ?? [], targetTables[index] ?? []));
-	for (const blocks of baseTables.slice(paired)) {
-		const location = blocks.at(0)?.table;
-		if (location) steps.push({
-			type: "baseTable",
-			blocks,
-			location
-		});
-	}
-	for (const blocks of targetTables.slice(paired)) {
-		const location = blocks.at(0)?.table;
-		if (location) steps.push({
-			type: "targetTable",
-			blocks,
-			location
-		});
-	}
-	return steps;
-};
-/**
-* How alike two rows must be for one to be read as the other, edited. Below
-* it the pair is a deleted row and an inserted one.
-*/
-const ROW_PAIR_SIMILARITY = .5;
-/**
-* How alike two rows are: their text, halved when their shapes differ.
-*
-* A row's shape is its physical cell count. Two rows with the same words in a
-* different number of cells are not the same row edited, and pairing them
-* would report every cell as changed rather than the row as replaced.
-*/
-const rowSimilarity = (base, target) => {
-	if (!base || !target) return 0;
-	const text = tokenSimilarity(rowText(base), rowText(target));
-	return rowCellTexts(base).length === rowCellTexts(target).length ? text : text / 2;
-};
-/**
-* Align one table's rows.
-*
-* Exact text first, then SIMILARITY rather than position. Positional fallback
-* is what made a deleted row plus a few cell edits report as a change in every
-* row of the table: each row was paired with the one below it, so every cell
-* differed. Pairing on similarity, and stepping one row on the side whose next
-* row matches better, keeps the deletion where it happened.
-*/
-const alignTableRows = (baseRows, targetRows, baseColumnKeys, targetColumnKeys) => {
-	const steps = [];
-	const pushRow = (row, side) => {
-		const location = rowLocation(row);
-		if (location) steps.push({
-			type: side === "base" ? "baseRow" : "targetRow",
-			blocks: row,
-			location
-		});
-	};
-	let baseCursor = 0;
-	let targetCursor = 0;
-	while (baseCursor < baseRows.length && targetCursor < targetRows.length) {
-		const baseRow = baseRows[baseCursor];
-		const targetRow = targetRows[targetCursor];
-		if (!baseRow || !targetRow) break;
-		const here = rowSimilarity(baseRow, targetRow);
-		if (here < 1) {
-			const baseAhead = rowSimilarity(baseRows[baseCursor + 1], targetRow);
-			const targetAhead = rowSimilarity(baseRow, targetRows[targetCursor + 1]);
-			if (baseAhead >= ROW_PAIR_SIMILARITY && baseAhead > here && baseAhead >= targetAhead) {
-				pushRow(baseRow, "base");
-				baseCursor += 1;
-				continue;
-			}
-			if (targetAhead >= ROW_PAIR_SIMILARITY && targetAhead > here) {
-				pushRow(targetRow, "target");
-				targetCursor += 1;
-				continue;
-			}
-		}
-		steps.push(...alignRowCells(baseRow, targetRow, baseColumnKeys, targetColumnKeys));
-		baseCursor += 1;
-		targetCursor += 1;
-	}
-	for (const row of baseRows.slice(baseCursor)) pushRow(row, "base");
-	for (const row of targetRows.slice(targetCursor)) pushRow(row, "target");
-	return steps;
-};
-const buildTableSteps = (baseBlocks, targetBlocks) => {
-	const columns = alignTableColumns(baseBlocks, targetBlocks);
-	return columns ? [...columns.steps, ...alignTableRows(groupRows(columns.baseBlocks), groupRows(columns.targetBlocks), columns.baseColumnKeys, columns.targetColumnKeys)] : alignTableRows(groupRows(baseBlocks), groupRows(targetBlocks));
-};
-const buildBodySteps = (baseBlocks, targetBlocks) => alignFolioBlocks(baseBlocks, targetBlocks).map((event) => {
-	switch (event.type) {
+const toCompareStep = (step) => {
+	switch (step.type) {
 		case "pair": return {
 			type: "pair",
-			baseBlock: event.baseBlock,
-			targetBlock: event.revisedBlock
+			baseBlock: step.baseBlock,
+			targetBlock: step.revisedBlock
 		};
 		case "baseOnly": return {
 			type: "baseOnly",
-			block: event.block
+			block: step.block,
+			moveScope: step.moveScope
 		};
 		case "revisedOnly": return {
 			type: "targetOnly",
-			block: event.block
+			block: step.block,
+			moveScope: step.moveScope
+		};
+		case "baseRow": return {
+			type: "baseRow",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "revisedRow": return {
+			type: "targetRow",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "baseTable": return {
+			type: "baseTable",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "revisedTable": return {
+			type: "targetTable",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "baseColumn": return {
+			type: "baseColumn",
+			blocks: step.blocks,
+			location: step.location,
+			columnIndex: step.columnIndex
+		};
+		case "revisedColumn": return {
+			type: "targetColumn",
+			blocks: step.blocks,
+			location: step.location,
+			columnIndex: step.columnIndex,
+			anchor: step.anchor
 		};
-		default: return panic("Unhandled block alignment event", { event });
+		default: return panic("Unhandled content alignment step", { step });
 	}
-});
-/**
-* Every block of an unpaired segment, as one-sided steps. A whole table stays
-* whole: reissuing it row by row would need a table to put the rows in, and
-* the point of an unpaired table segment is that there is none.
-*/
-const unpairedSegmentSteps = (segment, side) => {
-	if (segment.kind !== "table") return segment.blocks.map((block) => side === "base" ? {
-		type: "baseOnly",
-		block
-	} : {
-		type: "targetOnly",
-		block
-	});
-	const location = segment.blocks.at(0)?.table;
-	if (!location) return [];
-	return [{
-		type: side === "base" ? "baseTable" : "targetTable",
-		blocks: segment.blocks,
-		location
-	}];
 };
-/**
-* Align the two stories segment by segment, in order.
-*
-* Segments are paired by position rather than by text. Both sides have been
-* normalized to the same alternating shape, so position already carries the
-* meaning: the nth table of one document answers to the nth table of the
-* other, and the body text between two tables answers to the body text between
-* the same two tables. Matching segments on text instead lets a paragraph that
-* moved across a table steal the table's own pairing, which reissues the whole
-* table as a deletion and an insertion.
-*
-* When the two documents hold different numbers of tables the shapes diverge,
-* and the surplus segments are reported one-sided. The operation builder turns
-* those segments into `insertTable` or `deleteTable` operations.
-*/
-const segmentText = (segment) => segment.blocks.map(({ text }) => text).join(" ");
-/**
-* How alike two table segments must be before a lookahead match may steal the
-* pairing from the table in front of it. Two tables drawn from one document's
-* vocabulary score alike by chance, so a lookahead has to clear this bar as
-* well as beat what it displaces.
-*/
-const TABLE_PAIR_SIMILARITY = .5;
-/**
-* Pair the two segment sequences, marking the segments only one side has.
-*
-* Pairing by index cannot see a table added or removed: the nth table of one
-* document is put opposite the nth of the other, so deleting the first table
-* shifts every later one and the comparison rewrites each table's contents
-* into the next table along. Segments strictly alternate body, table, body,
-* ..., so a one-segment lookahead on each side is enough to tell "this table
-* changed a lot" from "this table is gone": the next table on the other side
-* matching better is what says the current one is unpaired.
-*/
-const alignSegments = (baseSegments, targetSegments) => {
-	const paired = [];
-	const similarity = (left, right) => left === void 0 || right === void 0 || left.kind !== right.kind ? 0 : tokenSimilarity(segmentText(left), segmentText(right));
-	let baseCursor = 0;
-	let targetCursor = 0;
-	while (baseCursor < baseSegments.length && targetCursor < targetSegments.length) {
-		const baseSegment = baseSegments[baseCursor];
-		const targetSegment = targetSegments[targetCursor];
-		if (!baseSegment || !targetSegment) break;
-		if (baseSegment.kind !== targetSegment.kind) {
-			paired.push({
-				baseSegment,
-				targetSegment: null
-			});
-			baseCursor += 1;
-			continue;
-		}
-		if (baseSegment.kind === "body") {
-			paired.push({
-				baseSegment,
-				targetSegment
-			});
-			baseCursor += 1;
-			targetCursor += 1;
-			continue;
-		}
-		const here = similarity(baseSegment, targetSegment);
-		const baseAhead = similarity(baseSegments[baseCursor + 2], targetSegment);
-		const targetAhead = similarity(baseSegment, targetSegments[targetCursor + 2]);
-		if (baseAhead >= TABLE_PAIR_SIMILARITY && baseAhead > here && baseAhead >= targetAhead) {
-			paired.push({
-				baseSegment,
-				targetSegment: null
-			});
-			baseCursor += 1;
-			continue;
-		}
-		if (targetAhead >= TABLE_PAIR_SIMILARITY && targetAhead > here) {
-			paired.push({
-				baseSegment: null,
-				targetSegment
-			});
-			targetCursor += 1;
-			continue;
-		}
-		paired.push({
-			baseSegment,
-			targetSegment
-		});
-		baseCursor += 1;
-		targetCursor += 1;
+const toContentAlignmentStep = (step) => {
+	switch (step.type) {
+		case "pair": return {
+			type: "pair",
+			baseBlock: step.baseBlock,
+			revisedBlock: step.targetBlock
+		};
+		case "baseOnly": return step;
+		case "targetOnly": return {
+			type: "revisedOnly",
+			block: step.block,
+			moveScope: step.moveScope
+		};
+		case "baseRow":
+		case "baseTable":
+		case "baseColumn": return step;
+		case "targetRow": return {
+			type: "revisedRow",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "targetTable": return {
+			type: "revisedTable",
+			blocks: step.blocks,
+			location: step.location
+		};
+		case "targetColumn": return {
+			type: "revisedColumn",
+			blocks: step.blocks,
+			location: step.location,
+			columnIndex: step.columnIndex,
+			anchor: step.anchor
+		};
+		default: return panic("Unhandled compare step", { step });
 	}
-	for (const segment of baseSegments.slice(baseCursor)) paired.push({
-		baseSegment: segment,
-		targetSegment: null
-	});
-	for (const segment of targetSegments.slice(targetCursor)) paired.push({
-		baseSegment: null,
-		targetSegment: segment
-	});
-	return paired;
 };
 const isEmptyParagraphNode = (block, snapshot) => {
 	const anchor = snapshot.anchors[block.id] ?? panic("A comparison snapshot block has no matching anchor", { blockId: block.id });
 	return block.text === "" && block.table === void 0 && anchor.to - anchor.from === 2;
 };
 /** Align both stories, optionally holding the two last paragraphs out as a pair. */
-const alignedSteps = (baseBlocks, targetBlocks, terminalCarrierPair) => {
-	const alignedBaseBlocks = terminalCarrierPair ? baseBlocks.slice(0, -1) : baseBlocks;
-	const alignedTargetBlocks = terminalCarrierPair ? targetBlocks.slice(0, -1) : targetBlocks;
-	const steps = [];
-	for (const { baseSegment, targetSegment } of alignSegments(splitSegments(alignedBaseBlocks), splitSegments(alignedTargetBlocks))) {
-		if (baseSegment && targetSegment) {
-			steps.push(...baseSegment.kind === "table" ? buildTableSegmentSteps(baseSegment.blocks, targetSegment.blocks) : buildBodySteps(baseSegment.blocks, targetSegment.blocks));
-			continue;
-		}
-		if (baseSegment) {
-			steps.push(...unpairedSegmentSteps(baseSegment, "base"));
-			continue;
-		}
-		if (targetSegment) steps.push(...unpairedSegmentSteps(targetSegment, "target"));
-	}
+const alignedSteps = (baseBlocks, targetBlocks, terminalCarrierPair, wholeTableReplacement, workSession = createFolioContentAlignmentWorkSession()) => {
+	const steps = alignFolioContentStructure({
+		baseBlocks: terminalCarrierPair ? baseBlocks.slice(0, -1) : baseBlocks,
+		revisedBlocks: terminalCarrierPair ? targetBlocks.slice(0, -1) : targetBlocks,
+		wholeTableReplacement,
+		workSession,
+		stableIdMismatch: "pair",
+		idStability: folioAIBlockIdStability
+	}).map(toCompareStep);
 	if (terminalCarrierPair) steps.push(terminalCarrierPair);
 	return steps;
 };
@@ -520,7 +189,7 @@ const addedTerminalCarrierIsStranded = (steps, baseBlocks, targetBlocks) => {
 	const baseLastStep = steps.findIndex((step) => step.type === "pair" && step.baseBlock.id === baseLast.id || step.type === "baseOnly" && step.block.id === baseLast.id);
 	return baseLastStep === -1 || steps.slice(baseLastStep + 1).some((step) => step.type !== "targetOnly");
 };
-const buildSteps = ({ baseSnapshot, targetSnapshot }) => {
+const buildSteps = ({ baseSnapshot, targetSnapshot, wholeTableReplacement, workSession }) => {
 	const baseBlocks = baseSnapshot.blocks;
 	const targetBlocks = targetSnapshot.blocks;
 	const baseLast = baseBlocks.at(-1);
@@ -531,9 +200,13 @@ const buildSteps = ({ baseSnapshot, targetSnapshot }) => {
 		targetBlock: targetLast
 	} : null;
 	const bothStoriesEndBlank = carrierPair !== null && isEmptyParagraphNode(carrierPair.baseBlock, baseSnapshot) && isEmptyParagraphNode(carrierPair.targetBlock, targetSnapshot);
-	const steps = alignedSteps(baseBlocks, targetBlocks, bothStoriesEndBlank ? carrierPair : null);
+	const alignmentBudgetBeforeAttempt = workSession.remainingLcsCells;
+	const structuralTokenBudgetBeforeAttempt = workSession.remainingStructuralTokenLookups;
+	const steps = alignedSteps(baseBlocks, targetBlocks, bothStoriesEndBlank ? carrierPair : null, wholeTableReplacement, workSession);
 	if (carrierPair === null || bothStoriesEndBlank || !shareAContainer(carrierPair.baseBlock, carrierPair.targetBlock) || !(terminalCarrierIsStranded(steps, baseBlocks) || addedTerminalCarrierIsStranded(steps, baseBlocks, targetBlocks))) return steps;
-	return alignedSteps(baseBlocks, targetBlocks, carrierPair);
+	workSession.remainingLcsCells = alignmentBudgetBeforeAttempt;
+	workSession.remainingStructuralTokenLookups = structuralTokenBudgetBeforeAttempt;
+	return alignedSteps(baseBlocks, targetBlocks, carrierPair, wholeTableReplacement, workSession);
 };
 /**
 * Two blocks are in the same container when a paragraph mark between them
@@ -542,103 +215,15 @@ const buildSteps = ({ baseSnapshot, targetSnapshot }) => {
 * paragraph-mark edit however similar the text looks.
 */
 const shareAContainer = (left, right) => {
-	if (!left.table || !right.table) return left.table === void 0 && right.table === void 0;
-	return left.table.tableIndex === right.table.tableIndex && left.table.rowIndex === right.table.rowIndex && left.table.cellIndex === right.table.cellIndex;
-};
-/**
-* The text between `head` and `tail` inside `whole`, when `whole` is exactly
-* the two joined by whitespace (or by nothing). `null` when it is not: any
-* other difference is a rewrite, not a moved paragraph mark.
-*/
-const separatorBetween = (whole, head, tail) => {
-	if (head.length === 0 || tail.length === 0 || whole.length < head.length + tail.length) return null;
-	if (!whole.startsWith(head) || !whole.endsWith(tail)) return null;
-	const separator = whole.slice(head.length, whole.length - tail.length);
-	return separator.length === 0 || /^\s+$/u.test(separator) ? separator : null;
-};
-/**
-* Where the alignment produced a rewrite plus an insertion or a deletion that
-* is really one paragraph mark moving, by step index of the PAIR step. The
-* step after it is consumed with it.
-*
-* The alignment cannot see this: it pairs the base paragraph with the target
-* half that still matches it and leaves the other half unpaired, which is a
-* correct alignment and a misleading redline.
-*/
-const detectParagraphMarkEdits = (steps) => {
-	const plans = /* @__PURE__ */ new Map();
-	for (const [index, step] of steps.entries()) {
-		const next = steps[index + 1];
-		if (step.type !== "pair" || next === void 0) continue;
-		if (next.type === "targetOnly") {
-			const separator = separatorBetween(step.baseBlock.text, step.targetBlock.text, next.block.text);
-			if (separator !== null && shareAContainer(step.targetBlock, next.block)) plans.set(index, {
-				type: "split",
-				baseBlock: step.baseBlock,
-				targetBlocks: [step.targetBlock, next.block],
-				offset: step.targetBlock.text.length,
-				separator
-			});
-			continue;
-		}
-		if (next.type !== "baseOnly") continue;
-		const separator = separatorBetween(step.targetBlock.text, step.baseBlock.text, next.block.text);
-		if (separator !== null && shareAContainer(step.baseBlock, next.block)) plans.set(index, {
-			type: "merge",
-			baseBlocks: [step.baseBlock, next.block],
-			targetBlock: step.targetBlock,
-			separator
-		});
-	}
-	return plans;
-};
-/** Base block id -> target block id for every relocation the move pass found. */
-const detectMoves = (steps, consumed) => {
-	const candidatesByText = /* @__PURE__ */ new Map();
-	for (const [index, step] of steps.entries()) {
-		if (consumed.has(index) || step.type !== "baseOnly" || !wordCountReaches(step.block.text, MOVE_MINIMUM_WORD_COUNT)) continue;
-		const queue = candidatesByText.get(step.block.text);
-		if (!queue) {
-			candidatesByText.set(step.block.text, [step.block.id]);
-			continue;
-		}
-		if (queue.length < MAX_MOVE_CANDIDATES_PER_TEXT) queue.push(step.block.id);
-	}
-	const unmatched = [];
-	for (const [index, step] of steps.entries()) {
-		if (consumed.has(index) || step.type !== "baseOnly" || !wordCountReaches(step.block.text, MOVE_MINIMUM_WORD_COUNT)) continue;
-		unmatched.push(step.block);
-	}
-	const movesByBaseBlockId = /* @__PURE__ */ new Map();
-	const takenBaseBlockIds = /* @__PURE__ */ new Set();
-	let comparisonBudget = MAX_MOVE_SIMILARITY_COMPARISONS;
-	for (const [index, step] of steps.entries()) {
-		if (consumed.has(index) || step.type !== "targetOnly") continue;
-		const exact = candidatesByText.get(step.block.text)?.shift();
-		if (exact !== void 0) {
-			takenBaseBlockIds.add(exact);
-			movesByBaseBlockId.set(exact, step.block.id);
-			continue;
-		}
-		if (!wordCountReaches(step.block.text, MOVE_MINIMUM_WORD_COUNT)) continue;
-		let best = null;
-		for (const candidate of unmatched) {
-			if (comparisonBudget <= 0) break;
-			if (takenBaseBlockIds.has(candidate.id)) continue;
-			comparisonBudget -= 1;
-			const similarity = tokenSimilarity(candidate.text, step.block.text);
-			if (similarity >= MOVE_SIMILARITY_THRESHOLD && (best === null || similarity > best.similarity)) best = {
-				block: candidate,
-				similarity
-			};
-		}
-		if (best) {
-			takenBaseBlockIds.add(best.block.id);
-			movesByBaseBlockId.set(best.block.id, step.block.id);
-		}
-	}
-	return movesByBaseBlockId;
-};
+	return contentBlocksShareContainer(left, right);
+};
+/** Narrow the neutral patch to the operation contract without explicit undefined fields. */
+const toFolioAIBlockParagraphProperties = (properties) => ({
+	...properties.styleId !== void 0 && { styleId: properties.styleId },
+	...properties.listLevel !== void 0 && { listLevel: properties.listLevel },
+	...properties.alignment !== void 0 && { alignment: properties.alignment },
+	...properties.spacing !== void 0 && { spacing: properties.spacing }
+});
 /**
 * For each step, the id of the next base block at or after it — the anchor a
 * target-only insertion is placed before. `null` once no base block follows.
@@ -709,7 +294,7 @@ const findRowAnchor = (steps, stepIndex) => {
 * actually occupies; the empty strings are the cells a `w:gridSpan` covers.
 */
 const tableCellTexts = (blocks) => {
-	const rows = groupRows(blocks).map((row) => rowCellTexts(row));
+	const rows = groupFolioContentTableRows(blocks).map((row) => rowCellTexts(row));
 	let width = 0;
 	for (const row of rows) width = Math.max(width, row.length);
 	for (const row of rows) while (row.length < width) row.push("");
@@ -735,18 +320,6 @@ const columnCellTexts = (blocks) => {
 	}
 	return [...byCell.values()];
 };
-/**
-* The paragraph properties that differ, or `null` when they agree. Only the
-* ones a block projection can see and an operation can set: a list level and
-* a paragraph style, the two edits that move no words and are invisible in a
-* text diff.
-*/
-const changedParagraphProperties = (baseBlock, targetBlock) => {
-	const properties = {};
-	if ((baseBlock.styleId ?? null) !== (targetBlock.styleId ?? null)) properties.styleId = targetBlock.styleId ?? null;
-	if (baseBlock.listLevel !== targetBlock.listLevel) properties.listLevel = targetBlock.listLevel ?? null;
-	return Object.keys(properties).length > 0 ? properties : null;
-};
 const locationOf = (story, block) => block.table ? {
 	story,
 	cell: block.table
@@ -797,11 +370,11 @@ const lastBlockByContainer = (blocks) => {
 * rather than an edit of its own, so it adds no entry to the change list: what
 * the reader is told is that paragraphs were removed and paragraphs added.
 */
-const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, nextOperationId }) => {
+const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, tableTemplates, nextOperationId }) => {
 	const plan = [...operations];
 	const deletionIndexByBlockId = /* @__PURE__ */ new Map();
 	const insertIndexesByAnchor = /* @__PURE__ */ new Map();
-	const tableAnchorIds = /* @__PURE__ */ new Set();
+	const tableInsertIndexesByAnchor = /* @__PURE__ */ new Map();
 	const markedBlockIds = /* @__PURE__ */ new Set();
 	for (const [index, operation] of plan.entries()) switch (operation.type) {
 		case "deleteBlock":
@@ -814,9 +387,12 @@ const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, n
 			insertIndexesByAnchor.set(operation.blockId, placed);
 			break;
 		}
-		case "insertTable":
-			tableAnchorIds.add(operation.blockId);
+		case "insertTable": {
+			const placed = tableInsertIndexesByAnchor.get(operation.blockId) ?? [];
+			placed.push(index);
+			tableInsertIndexesByAnchor.set(operation.blockId, placed);
 			break;
+		}
 		case "splitBlock":
 		case "mergeBlockWithNext":
 			markedBlockIds.add(operation.blockId);
@@ -835,8 +411,8 @@ const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, n
 	const trailingRunOf = (container, carrier) => {
 		const blockIds = [];
 		const insertIndexes = [];
+		const tableInsertIndexes = [];
 		let chainStart = null;
-		let holdsAnInsertedTable = false;
 		let index = indexById.get(carrier.id) ?? panic("A container's last block is not in the snapshot it came from", { blockId: carrier.id });
 		for (; index >= 0; index--) {
 			const block = blocks[index];
@@ -847,23 +423,35 @@ const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, n
 			}
 			blockIds.push(block.id);
 			insertIndexes.push(...insertIndexesByAnchor.get(block.id) ?? []);
-			holdsAnInsertedTable ||= tableAnchorIds.has(block.id);
+			tableInsertIndexes.push(...tableInsertIndexesByAnchor.get(block.id) ?? []);
 		}
 		return {
 			blockIds,
 			chainStart,
 			insertIndexes: insertIndexes.toSorted((left, right) => left - right),
-			holdsAnInsertedTable
+			tableInsertIndexes: tableInsertIndexes.toSorted((left, right) => left - right)
 		};
 	};
 	const targetLastByContainer = lastBlockByContainer(targetSnapshot.blocks);
+	const terminalTargetTableIndex = targetSnapshot.blocks.at(-1)?.table?.outerTableIndex;
+	const targetTableIndexByOperationId = new Map(tableTemplates.map(({ operationId, targetTableIndex }) => [operationId, targetTableIndex]));
 	const dropped = /* @__PURE__ */ new Set();
 	const appended = [];
 	for (const [container, carrier] of lastBlockByContainer(blocks)) {
 		const carrierDeletionIndex = deletionIndexByBlockId.get(carrier.id);
 		if (carrierDeletionIndex === void 0) continue;
 		const run = trailingRunOf(container, carrier);
-		if (run.holdsAnInsertedTable) continue;
+		if (run.tableInsertIndexes.length > 0) {
+			const tableInsertIndex = run.tableInsertIndexes.length === 1 ? run.tableInsertIndexes.at(0) : void 0;
+			const tableInsert = tableInsertIndex === void 0 ? void 0 : plan[tableInsertIndex];
+			if (container !== "body" || !isEmptyParagraphNode(carrier, baseSnapshot) || tableInsertIndex === void 0 || terminalTargetTableIndex === void 0 || tableInsert?.type !== "insertTable" || targetTableIndexByOperationId.get(tableInsert.id) !== terminalTargetTableIndex) continue;
+			plan[tableInsertIndex] = {
+				...tableInsert,
+				blockId: carrier.id,
+				position: "after"
+			};
+			continue;
+		}
 		const lastInsertIndex = run.insertIndexes.at(-1);
 		if (lastInsertIndex === void 0) {
 			if (run.chainStart) appended.push({
@@ -895,18 +483,23 @@ const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, n
 					text: insert.text,
 					...insert.moveId !== void 0 && { moveId: insert.moveId },
 					styleId: insert.styleId ?? null,
-					listLevel: insert.listLevel ?? null
+					listLevel: insert.listLevel ?? null,
+					alignment: insert.alignment ?? null,
+					spacing: insert.spacing ?? null
 				};
 			}
 		}
 		const targetCarrier = targetLastByContainer.get(container);
-		const properties = targetCarrier && changedParagraphProperties(carrier, targetCarrier);
-		if (properties) appended.push({
-			id: nextOperationId(),
-			type: "setBlockParagraphProperties",
-			blockId: carrier.id,
-			properties
-		});
+		const contentProperties = targetCarrier && changedFolioContentParagraphFormatting(carrier, targetCarrier);
+		if (contentProperties) {
+			const properties = toFolioAIBlockParagraphProperties(contentProperties);
+			appended.push({
+				id: nextOperationId(),
+				type: "setBlockParagraphProperties",
+				blockId: carrier.id,
+				properties
+			});
+		}
 	}
 	return [...plan.filter((_, index) => !dropped.has(index)), ...appended];
 };
@@ -942,14 +535,23 @@ const tableGeometryPairingsOf = (steps) => {
 * Plan one story's comparison, or `null` when it needs more operations than
 * `maxOperations`.
 */
-const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }) => {
+const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations, wholeTableReplacement = "allow", workSession = createContentComparisonWorkSession() }) => {
+	const effectiveWholeTableReplacement = wholeTableReplacement === "allow" && trailingBodyBlockId(baseSnapshot) === null ? "avoid" : wholeTableReplacement;
 	const steps = buildSteps({
 		baseSnapshot,
-		targetSnapshot
+		targetSnapshot,
+		wholeTableReplacement: effectiveWholeTableReplacement,
+		workSession: workSession.alignment
 	});
-	const paragraphMarkPlans = detectParagraphMarkEdits(steps);
+	const contentSteps = steps.map(toContentAlignmentStep);
+	const paragraphMarkPlans = detectFolioContentParagraphMarkPlans(contentSteps);
 	const consumedSteps = new Set([...paragraphMarkPlans.keys()].map((index) => index + 1));
-	const movesByBaseBlockId = detectMoves(steps, consumedSteps);
+	const movesByBaseBlockId = new Map(detectFolioContentMoves({
+		steps: contentSteps,
+		consumedStepIndexes: consumedSteps,
+		workSession,
+		idStability: folioAIBlockIdStability
+	}).map(({ baseBlock, revisedBlock }) => [baseBlock.id, revisedBlock.id]));
 	const moveSourceByTargetBlockId = /* @__PURE__ */ new Map();
 	for (const [baseBlockId, targetBlockId] of movesByBaseBlockId) moveSourceByTargetBlockId.set(targetBlockId, baseBlockId);
 	const anchorIds = nextBaseBlockIdByStep(steps);
@@ -958,11 +560,10 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 	const tableTemplates = [];
 	/**
 	* The anchor everything past the base document's content hangs from: its
-	* last BODY-LEVEL paragraph, which the format guarantees exists because a
-	* table may not be the last child of a body. Anchoring to the last block
-	* instead put the anchor inside a table whenever the story ended with one,
-	* and an insertion anchored there escapes to the table's boundary, where no
-	* paragraph mark can express the break it added.
+	* last BODY-LEVEL paragraph, when it has one. Anchoring to the last block
+	* instead puts the anchor inside a terminal table, and a paragraph insertion
+	* then escapes to the table's boundary where no paragraph mark can express
+	* the break it added.
 	*
 	* The applier orders insertions that resolve to one position by their order
 	* in this array, so the tail is emitted where its step sits rather than
@@ -985,7 +586,9 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 			text: block.text,
 			...moveSourceId !== void 0 && { moveId: moveIdOf(moveSourceId) },
 			styleId: block.styleId ?? null,
-			listLevel: block.listLevel ?? null
+			listLevel: block.listLevel ?? null,
+			alignment: block.directAlignment ?? null,
+			spacing: block.directSpacing ?? null
 		};
 		if (anchorId !== null) {
 			operations.push({
@@ -1008,7 +611,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 		if (consumedSteps.has(stepIndex)) continue;
 		const paragraphMarkPlan = paragraphMarkPlans.get(stepIndex);
 		if (paragraphMarkPlan?.type === "split") {
-			const { baseBlock, targetBlocks: splitInto, offset, separator } = paragraphMarkPlan;
+			const { baseBlock, revisedBlocks: splitInto, offset, separator } = paragraphMarkPlan;
 			changes.push({
 				kind: "split",
 				location: locationOf(story, baseBlock),
@@ -1026,7 +629,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 			continue;
 		}
 		if (paragraphMarkPlan?.type === "merge") {
-			const { baseBlocks, targetBlock, separator } = paragraphMarkPlan;
+			const { baseBlocks, revisedBlock: targetBlock, separator } = paragraphMarkPlan;
 			changes.push({
 				kind: "merge",
 				location: locationOf(story, baseBlocks[0]),
@@ -1045,8 +648,9 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 		switch (step.type) {
 			case "pair": {
 				const { baseBlock, targetBlock } = step;
-				const properties = changedParagraphProperties(baseBlock, targetBlock);
-				if (properties) {
+				const contentProperties = changedFolioContentParagraphFormatting(baseBlock, targetBlock);
+				if (contentProperties) {
+					const properties = toFolioAIBlockParagraphProperties(contentProperties);
 					changes.push({
 						kind: "paragraph-format",
 						location: locationOf(story, baseBlock),
@@ -1295,6 +899,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 		baseSnapshot,
 		targetSnapshot,
 		operations,
+		tableTemplates,
 		nextOperationId
 	});
 	return planned.length > maxOperations ? null : {