@stll/folio-core 0.33.1 → 0.33.2

package/dist/compare/plan.js

@@ -457,16 +457,8 @@ 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;
 };
-const buildSteps = ({ story, baseSnapshot, targetSnapshot }) => {
-	const baseBlocks = baseSnapshot.blocks;
-	const targetBlocks = targetSnapshot.blocks;
-	const baseLast = baseBlocks.at(-1);
-	const targetLast = targetBlocks.at(-1);
-	const terminalCarrierPair = story.type === "main" && baseLast !== void 0 && isEmptyParagraphNode(baseLast, baseSnapshot) && targetLast !== void 0 && isEmptyParagraphNode(targetLast, targetSnapshot) ? {
-		type: "pair",
-		baseBlock: baseLast,
-		targetBlock: targetLast
-	} : null;
+/** 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 = [];
@@ -485,6 +477,65 @@ const buildSteps = ({ story, baseSnapshot, targetSnapshot }) => {
 	return steps;
 };
 /**
+* Whether an alignment left the story's last paragraph removed with no
+* paragraph of its own container surviving in front of it.
+*
+* That paragraph's mark is the one a story cannot lose, and a deleted mark
+* joins two paragraphs of ONE container, so with nothing of that container in
+* front of it there is no chain a removal could run down. The paragraph then
+* stays whatever the plan says, and the story ends on a blank line the target
+* does not have — unless the words the target ends with are written into it,
+* which is what reserving it for the target's last paragraph does.
+*/
+const terminalCarrierIsStranded = (steps, baseBlocks) => {
+	const carrier = baseBlocks.at(-1);
+	if (carrier === void 0) return false;
+	const removed = new Set(steps.flatMap((step) => step.type === "baseOnly" ? [step.block.id] : []));
+	if (!removed.has(carrier.id)) return false;
+	const container = containerKeyOf(carrier);
+	for (let index = baseBlocks.length - 2; index >= 0; index--) {
+		const block = baseBlocks[index];
+		if (block === void 0 || containerKeyOf(block) !== container) return true;
+		if (!removed.has(block.id)) return false;
+	}
+	return true;
+};
+/**
+* Whether an alignment ADDED the story's last paragraph with something other
+* than paragraphs between it and the base's.
+*
+* An inserted mark at a container's end has the same problem its deletion
+* does: nothing follows it, so rejecting the addition cannot close the break
+* back over the next paragraph. The applier rotates instead — the paragraph
+* the run was appended after takes the inserted mark, and the last one takes
+* the free mark — and that rotation reaches only across paragraphs. A table
+* among them stops it, and the words the target ends with have to be written
+* into the base's own last paragraph instead.
+*/
+const addedTerminalCarrierIsStranded = (steps, baseBlocks, targetBlocks) => {
+	const baseLast = baseBlocks.at(-1);
+	const targetLast = targetBlocks.at(-1);
+	if (baseLast === void 0 || targetLast === void 0) return false;
+	if (!steps.some((step) => step.type === "targetOnly" && step.block.id === targetLast.id)) return false;
+	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 baseBlocks = baseSnapshot.blocks;
+	const targetBlocks = targetSnapshot.blocks;
+	const baseLast = baseBlocks.at(-1);
+	const targetLast = targetBlocks.at(-1);
+	const carrierPair = baseLast !== void 0 && targetLast !== void 0 ? {
+		type: "pair",
+		baseBlock: baseLast,
+		targetBlock: targetLast
+	} : null;
+	const bothStoriesEndBlank = carrierPair !== null && isEmptyParagraphNode(carrierPair.baseBlock, baseSnapshot) && isEmptyParagraphNode(carrierPair.targetBlock, targetSnapshot);
+	const steps = alignedSteps(baseBlocks, targetBlocks, bothStoriesEndBlank ? carrierPair : null);
+	if (carrierPair === null || bothStoriesEndBlank || !shareAContainer(carrierPair.baseBlock, carrierPair.targetBlock) || !(terminalCarrierIsStranded(steps, baseBlocks) || addedTerminalCarrierIsStranded(steps, baseBlocks, targetBlocks))) return steps;
+	return alignedSteps(baseBlocks, targetBlocks, carrierPair);
+};
+/**
 * Two blocks are in the same container when a paragraph mark between them
 * exists at all: two body paragraphs, or two paragraphs of one table cell. A
 * mark cannot span a cell boundary, so a split or a merge across one is not a
@@ -714,67 +765,178 @@ const lastBlockByContainer = (blocks) => {
 	return last;
 };
 /**
-* The operations that keep a container's final paragraph mark when the plan
-* deletes the paragraphs that end it.
+* Rewrite the plan so a container's final paragraph mark survives the removal
+* of the paragraphs that end it.
 *
 * A deleted paragraph mark means "merge this paragraph into the following
 * one". A container's final paragraph has no following one, so the mark cannot
 * say it: the applier leaves that mark alone, and the removal has to be
-* expressed one paragraph earlier. The chain therefore runs from the last
-* SURVIVING paragraph forward — its mark goes, each removed paragraph's mark
-* goes with it, and the container's final paragraph stays as the carrier the
-* merged text lands in.
+* expressed one paragraph earlier. The carrier is that final paragraph, and
+* every trailing removal resolves onto it.
+*
+* Nothing is inserted where the run was: the chain runs from the last
+* SURVIVING paragraph forward. Its mark goes, each removed paragraph's mark
+* goes with it, and the carrier loses its words and keeps its mark as the
+* paragraph the merged text lands in. A carrier that has no words to lose is
+* not deleted at all: its removal is entirely the marks in front of it, and an
+* operation that would write no revision belongs nowhere in the plan.
 *
-* The carrier keeps its own mark, and a paragraph's properties live on its
-* mark, so the merged paragraph ends up with the carrier's. Those properties
-* therefore become the target's, written as `w:pPrChange` so rejecting
-* restores what the carrier had. That is bookkeeping for the merge rather than
-* an edit of its own, so it adds no entry to the change list: what the reader
-* is told is that the paragraphs were removed.
+* Something IS inserted there: the inserted paragraphs stand where the removed
+* ones did, and the last of them lands INSIDE the carrier as inserted runs
+* before its kept mark, so the carrier is the target's last paragraph rather
+* than a blank line after it. The other inserted paragraphs carry inserted
+* marks of their own and sit before the carrier. The mark count then works out
+* on its own — one mark deleted for every removed paragraph but the carrier,
+* one inserted for every added paragraph but the last — so the chain is not
+* rotated as well.
 *
-* Nothing is rotated when the plan puts a block inside or after the run. The
-* carrier is then no longer what ends the container, its mark is deleted like
-* any other, and the count already works out.
+* The carrier keeps its own mark either way, and a paragraph's properties live
+* on its mark, so the merged paragraph ends up with the carrier's. Those
+* properties therefore become the target's, written as `w:pPrChange` so
+* rejecting restores what the carrier had. That is bookkeeping for the merge
+* 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 trailingDeletionOperations = ({ baseSnapshot, targetSnapshot, operations, nextOperationId }) => {
+const withTrailingDeletionRules = ({ baseSnapshot, targetSnapshot, operations, nextOperationId }) => {
+	const plan = [...operations];
+	const deletionIndexByBlockId = /* @__PURE__ */ new Map();
+	const insertIndexesByAnchor = /* @__PURE__ */ new Map();
+	const tableAnchorIds = /* @__PURE__ */ new Set();
+	const markedBlockIds = /* @__PURE__ */ new Set();
+	for (const [index, operation] of plan.entries()) switch (operation.type) {
+		case "deleteBlock":
+			deletionIndexByBlockId.set(operation.blockId, index);
+			break;
+		case "insertBeforeBlock":
+		case "insertAfterBlock": {
+			const placed = insertIndexesByAnchor.get(operation.blockId) ?? [];
+			placed.push(index);
+			insertIndexesByAnchor.set(operation.blockId, placed);
+			break;
+		}
+		case "insertTable":
+			tableAnchorIds.add(operation.blockId);
+			break;
+		case "splitBlock":
+		case "mergeBlockWithNext":
+			markedBlockIds.add(operation.blockId);
+			break;
+		default: break;
+	}
+	if (deletionIndexByBlockId.size === 0) return plan;
 	const blocks = baseSnapshot.blocks;
-	const deletedBlockIds = new Set(operations.flatMap((operation) => operation.type === "deleteBlock" ? [operation.blockId] : []));
-	if (deletedBlockIds.size === 0) return [];
-	const placedAtBlockIds = new Set(operations.flatMap((operation) => operation.type === "insertBeforeBlock" || operation.type === "insertAfterBlock" || operation.type === "insertTable" ? [operation.blockId] : []));
-	const markedBlockIds = new Set(operations.flatMap((operation) => operation.type === "splitBlock" || operation.type === "mergeBlockWithNext" ? [operation.blockId] : []));
-	const targetLastByContainer = lastBlockByContainer(targetSnapshot.blocks);
 	const indexById = new Map(blocks.map((block, index) => [block.id, index]));
-	const added = [];
-	for (const [container, carrier] of lastBlockByContainer(blocks)) {
-		if (!deletedBlockIds.has(carrier.id)) continue;
-		let index = indexById.get(carrier.id) ?? panic("A container's last block is not in the snapshot it came from", { blockId: carrier.id });
+	/**
+	* Walk back from a container's last block over the run of deleted
+	* paragraphs it ends with. A block of another container in between — a
+	* table between two body paragraphs, a table nested in a cell — ends the
+	* walk: no mark joins across it.
+	*/
+	const trailingRunOf = (container, carrier) => {
+		const blockIds = [];
+		const insertIndexes = [];
 		let chainStart = null;
-		let placedInRun = false;
+		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];
 			if (block === void 0 || containerKeyOf(block) !== container) break;
-			if (!deletedBlockIds.has(block.id)) {
+			if (!deletionIndexByBlockId.has(block.id)) {
 				chainStart = markedBlockIds.has(block.id) ? null : block;
 				break;
 			}
-			placedInRun ||= placedAtBlockIds.has(block.id);
+			blockIds.push(block.id);
+			insertIndexes.push(...insertIndexesByAnchor.get(block.id) ?? []);
+			holdsAnInsertedTable ||= tableAnchorIds.has(block.id);
+		}
+		return {
+			blockIds,
+			chainStart,
+			insertIndexes: insertIndexes.toSorted((left, right) => left - right),
+			holdsAnInsertedTable
+		};
+	};
+	const targetLastByContainer = lastBlockByContainer(targetSnapshot.blocks);
+	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;
+		const lastInsertIndex = run.insertIndexes.at(-1);
+		if (lastInsertIndex === void 0) {
+			if (run.chainStart) appended.push({
+				id: nextOperationId(),
+				type: "mergeBlockWithNext",
+				blockId: run.chainStart.id
+			});
+			if (isEmptyParagraphNode(carrier, baseSnapshot)) dropped.add(carrierDeletionIndex);
+		} else {
+			const lastInsert = plan[lastInsertIndex];
+			if (lastInsert === void 0 || lastInsert.type !== "insertBeforeBlock" && lastInsert.type !== "insertAfterBlock" || lastInsert.moveId !== void 0) continue;
+			const carrierDeletion = plan[carrierDeletionIndex];
+			if (carrierDeletion?.type !== "deleteBlock" || carrierDeletion.moveId !== void 0) continue;
+			dropped.add(lastInsertIndex);
+			if (carrier.text === lastInsert.text) dropped.add(carrierDeletionIndex);
+			else plan[carrierDeletionIndex] = {
+				id: carrierDeletion.id,
+				type: "replaceBlock",
+				blockId: carrier.id,
+				text: lastInsert.text
+			};
+			for (const index of run.insertIndexes.slice(0, -1)) {
+				const insert = plan[index];
+				if (insert?.type !== "insertBeforeBlock" && insert?.type !== "insertAfterBlock") continue;
+				plan[index] = {
+					id: insert.id,
+					type: "insertBeforeBlock",
+					blockId: carrier.id,
+					text: insert.text,
+					...insert.moveId !== void 0 && { moveId: insert.moveId },
+					styleId: insert.styleId ?? null,
+					listLevel: insert.listLevel ?? null
+				};
+			}
 		}
-		if (placedInRun) continue;
-		if (chainStart) added.push({
-			id: nextOperationId(),
-			type: "mergeBlockWithNext",
-			blockId: chainStart.id
-		});
 		const targetCarrier = targetLastByContainer.get(container);
 		const properties = targetCarrier && changedParagraphProperties(carrier, targetCarrier);
-		if (properties) added.push({
+		if (properties) appended.push({
 			id: nextOperationId(),
 			type: "setBlockParagraphProperties",
 			blockId: carrier.id,
 			properties
 		});
 	}
-	return added;
+	return [...plan.filter((_, index) => !dropped.has(index)), ...appended];
+};
+const cellCoordinate = ({ tableIndex, rowIndex, cellIndex }) => ({
+	tableIndex,
+	rowIndex,
+	cellIndex
+});
+/**
+* The cells the alignment paired, one entry each. A cell holds several
+* paragraphs and each pairs on its own, so the first pairing of a cell is the
+* one kept: later ones would name the same two cells.
+*/
+const tableGeometryPairingsOf = (steps) => {
+	const pairings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const step of steps) {
+		if (step.type !== "pair") continue;
+		const base = step.baseBlock.table;
+		const target = step.targetBlock.table;
+		if (!base || !target) continue;
+		const key = `${String(base.tableIndex)}:${String(base.rowIndex)}:${String(base.cellIndex)}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		pairings.push({
+			base: cellCoordinate(base),
+			target: cellCoordinate(target)
+		});
+	}
+	return pairings;
 };
 /**
 * Plan one story's comparison, or `null` when it needs more operations than
@@ -782,7 +944,6 @@ const trailingDeletionOperations = ({ baseSnapshot, targetSnapshot, operations,
 */
 const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }) => {
 	const steps = buildSteps({
-		story,
 		baseSnapshot,
 		targetSnapshot
 	});
@@ -794,6 +955,7 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 	const anchorIds = nextBaseBlockIdByStep(steps);
 	const changes = [];
 	const operations = [];
+	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
@@ -1056,23 +1218,20 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 					targetBlockIds: step.blocks.map(({ id }) => id)
 				});
 				const before = anchorIds[stepIndex] ?? null;
-				if (before !== null) {
-					operations.push({
-						id: nextOperationId(),
-						type: "insertTable",
-						blockId: before,
-						position: "before",
-						rows
-					});
-					break;
-				}
-				if (tailAnchorId !== null) operations.push({
-					id: nextOperationId(),
+				const anchorBlockId = before ?? tailAnchorId;
+				if (anchorBlockId === null) break;
+				const operationId = nextOperationId();
+				operations.push({
+					id: operationId,
 					type: "insertTable",
-					blockId: tailAnchorId,
-					position: "after",
+					blockId: anchorBlockId,
+					position: before === null ? "after" : "before",
 					rows
 				});
+				tableTemplates.push({
+					operationId,
+					targetTableIndex: step.location.tableIndex
+				});
 				break;
 			}
 			case "targetRow": {
@@ -1093,13 +1252,19 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 					for (const block of step.blocks) pushInsertOperation(block, anchorIds[stepIndex] ?? null);
 					break;
 				}
+				const rowOperationId = nextOperationId();
 				operations.push({
-					id: nextOperationId(),
+					id: rowOperationId,
 					type: "insertTableRow",
 					blockId: anchor.blockId,
 					position: anchor.position,
 					cellTexts: cells
 				});
+				tableTemplates.push({
+					operationId: rowOperationId,
+					targetTableIndex: step.location.tableIndex,
+					targetRowIndex: step.location.rowIndex
+				});
 				break;
 			}
 			case "targetColumn":
@@ -1126,15 +1291,17 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 		}
 		if (operations.length > maxOperations) return null;
 	}
-	operations.push(...trailingDeletionOperations({
+	const planned = withTrailingDeletionRules({
 		baseSnapshot,
 		targetSnapshot,
 		operations,
 		nextOperationId
-	}));
-	return operations.length > maxOperations ? null : {
+	});
+	return planned.length > maxOperations ? null : {
 		changes,
-		operations
+		operations: planned,
+		tableTemplates,
+		tableGeometryPairings: tableGeometryPairingsOf(steps)
 	};
 };
 //#endregion

package/dist/compare/types.d.ts

@@ -1,7 +1,7 @@
 import { FolioAIBlockParagraphProperties, FolioAIBlockTableLocation, FolioAIEditSkippedOperation, FolioAIInlineFormatting } from "../ai-edits/types.js";
 import { WordDiffGranularity } from "../ai-edits/word-diff.js";
 import { FolioDocumentStoryHandle, FolioNumberingLevel } from "../ai-edits/headless.js";
-import { CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkDeletion } from "./verification.js";
+import { CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkRevision } from "./verification.js";
 //#region src/compare/types.d.ts
 /** Everything {@link compareDocx} needs; nothing it reads from the ambient clock. */
 type CompareDocxOptions = {
@@ -279,18 +279,20 @@ declare class CompareDocxSerializeError extends CompareDocxSerializeError_base<{
 }> {}
 declare const CompareDocxFinalParagraphMarkError_base: import("better-result").TaggedErrorClass<"CompareDocxFinalParagraphMarkError">;
 /**
- * A container's final paragraph mark carries a deletion, so the package would
- * not open.
+ * A container's final paragraph mark carries a revision, so the package would
+ * not open, or would open carrying one no reader can resolve.
  *
  * A deleted paragraph mark means "merge this paragraph into the following
- * one", and a container's last paragraph has no following one. Checked before
- * the package is written, and fatal under either `onUnverified` setting: there
- * is no redline to emit when a consumer refuses the file.
+ * one", an inserted one means the break was added and rejecting it closes the
+ * paragraph back over the next one, and a container's last paragraph has no
+ * following one either way. Checked before the package is written, and fatal
+ * under either `onUnverified` setting: there is no redline to emit when a
+ * consumer refuses the file.
  */
 declare class CompareDocxFinalParagraphMarkError extends CompareDocxFinalParagraphMarkError_base<{
   message: string;
   /** Every container that carries one, each named structurally. */
-  deletions: readonly FinalParagraphMarkDeletion[];
+  revisions: readonly FinalParagraphMarkRevision[];
 }> {}
 type CompareDocxError = CompareDocxApplyError | CompareDocxFinalParagraphMarkError | CompareDocxOperationLimitError | CompareDocxParseError | CompareDocxRoundTripError | CompareDocxSerializeError | InvalidCompareDocxOptionsError;
 //#endregion

package/dist/compare/types.js

@@ -29,13 +29,15 @@ var CompareDocxRoundTripError = class extends TaggedError("CompareDocxRoundTripE
 var CompareDocxOperationLimitError = class extends TaggedError("CompareDocxOperationLimitError") {};
 var CompareDocxSerializeError = class extends TaggedError("CompareDocxSerializeError") {};
 /**
-* A container's final paragraph mark carries a deletion, so the package would
-* not open.
+* A container's final paragraph mark carries a revision, so the package would
+* not open, or would open carrying one no reader can resolve.
 *
 * A deleted paragraph mark means "merge this paragraph into the following
-* one", and a container's last paragraph has no following one. Checked before
-* the package is written, and fatal under either `onUnverified` setting: there
-* is no redline to emit when a consumer refuses the file.
+* one", an inserted one means the break was added and rejecting it closes the
+* paragraph back over the next one, and a container's last paragraph has no
+* following one either way. Checked before the package is written, and fatal
+* under either `onUnverified` setting: there is no redline to emit when a
+* consumer refuses the file.
 */
 var CompareDocxFinalParagraphMarkError = class extends TaggedError("CompareDocxFinalParagraphMarkError") {};
 //#endregion

package/dist/compare/verification.d.ts

@@ -1,5 +1,6 @@
 import { FolioAIBlock } from "../ai-edits/types.js";
 import { FolioDocumentStoryHandle } from "../ai-edits/headless.js";
+import { ParagraphMarkChangeKind } from "@stll/docx-core/model";
 //#region src/compare/verification.d.ts
 /** The two directions of the round trip, each an invariant of its own. */
 declare const COMPARE_VERIFICATION_INVARIANTS: readonly ["accept-reproduces-target", "reject-reproduces-base"];
@@ -9,7 +10,7 @@ type CompareVerificationInvariant = (typeof COMPARE_VERIFICATION_INVARIANTS)[num
  * that fits is the one reported, because a block in the wrong container is a
  * different finding from a block whose words are wrong even when both are true.
  */
-declare const COMPARE_VERIFICATION_CAUSES: readonly ["invisible-structure", "block-count", "container", "style", "list-level", "inline-formatting", "whitespace", "text"];
+declare const COMPARE_VERIFICATION_CAUSES: readonly ["invisible-structure", "block-count", "container", "table-geometry", "style", "list-level", "inline-formatting", "whitespace", "text"];
 type CompareVerificationCause = (typeof COMPARE_VERIFICATION_CAUSES)[number];
 /** One invariant that did not hold, in one story. */
 type CompareVerificationFailure = {
@@ -44,6 +45,13 @@ type ClassifyOptions = {
   /** What the invariant says it should leave. */
   expected: readonly string[];
 };
+/**
+ * The failure two table-geometry projections describe, or `null` when they
+ * agree. One line per table, so the detail names which table diverged and
+ * whether the count itself did — never a property value, which could carry a
+ * style name either document chose.
+ */
+declare const classifyGeometryMismatch: ({ invariant, story, actual, expected }: ClassifyOptions) => CompareVerificationFailure | null;
 /**
  * The failure two projections describe, or `null` when they agree.
  *
@@ -52,32 +60,43 @@ type ClassifyOptions = {
  */
 declare const classifyProjectionMismatch: ({ invariant, story, actual, expected }: ClassifyOptions) => CompareVerificationFailure | null;
 /**
- * A container whose last paragraph carries a deletion on its mark.
+ * A container whose last paragraph carries a revision on its mark.
  *
  * Structural facts only — a path through the package model and an index — so
  * the finding is safe to log, report or quote.
  */
-type FinalParagraphMarkDeletion = {
+type FinalParagraphMarkRevision = {
   /** Where the container sits in the package model, e.g. `package.document.content`. */
   container: string;
   /** The paragraph's index among its container's children. */
   paragraphIndex: number;
-  /** The mark kind found there: `del`, or `moveFrom` for a relocation's source. */
-  kind: "del" | "moveFrom";
+  /** The mark kind found there, `moveFrom` / `moveTo` for a relocation's ends. */
+  kind: ParagraphMarkChangeKind;
 };
 /**
- * Every container in a package whose final paragraph mark carries a deletion.
+ * Every container in a package whose final paragraph mark carries a revision.
  *
- * A deleted paragraph mark says "join this paragraph with the one after it".
- * The last paragraph of a body, a table cell, a header or footer, a note or a
- * text box has no paragraph after it, so the mark states an edit that cannot
- * be carried out, and a consumer refuses the package rather than opening it.
+ * A deleted paragraph mark says "join this paragraph with the one after it",
+ * and an inserted one says that break was ADDED, so rejecting it closes the
+ * paragraph back over the next one. The last paragraph of a body, a table
+ * cell, a header or footer, a note or a text box has no paragraph after it, so
+ * neither direction states an edit that can be carried out: a consumer refuses
+ * the package, or opens it and leaves a revision standing that neither
+ * accepting nor rejecting everything can clear. The exception is a cell of a
+ * row the package is DELETING: there the mark leaves with its row.
  *
  * The walk is over the package model rather than over a list of the containers
  * known today: a container is any sequence that ends in a paragraph, so a part
  * the model grows later is covered the day it arrives instead of the day
  * someone remembers this function.
+ *
+ * `since` scopes it to the revisions a comparison MINTED: a base may arrive
+ * carrying one of these on a paragraph in a part no story mounts, which folio
+ * preserves the way it preserves everything else it parses. What this proves
+ * is that the comparison writes none of its own.
  */
-declare const deletedFinalParagraphMarks: (packageModel: unknown) => FinalParagraphMarkDeletion[];
+declare const revisedFinalParagraphMarks: (packageModel: unknown, { since }?: {
+  since?: number;
+}) => FinalParagraphMarkRevision[];
 //#endregion
-export { COMPARE_VERIFICATION_CAUSES, COMPARE_VERIFICATION_INVARIANTS, CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkDeletion, classifyProjectionMismatch, deletedFinalParagraphMarks, projectSupportedInlineFormatting, sameProjection };
+export { COMPARE_VERIFICATION_CAUSES, COMPARE_VERIFICATION_INVARIANTS, CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkRevision, classifyGeometryMismatch, classifyProjectionMismatch, projectSupportedInlineFormatting, revisedFinalParagraphMarks, sameProjection };