@stll/folio-core 0.33.0 → 0.33.2

package/dist/compare/plan.d.ts

@@ -1,10 +1,40 @@
 import { FolioAIEditOperation, FolioAIEditSnapshot } from "../ai-edits/types.js";
+import { TableGeometryPairing } from "../ai-edits/table-geometry.js";
 import { FolioDocumentStoryHandle } from "../ai-edits/headless.js";
 import { CompareChange } from "./types.js";
 //#region src/compare/plan.d.ts
+/**
+ * A table the target document already holds, which the operation naming it
+ * should place verbatim instead of rebuilding from its cell texts.
+ *
+ * The plan is pure and sees only block snapshots, so it names the table by the
+ * index the snapshot numbers tables with; the caller, which has both
+ * documents, resolves the index to the node.
+ */
+type CompareTableTemplateRequest = {
+  /** The `insertTable` or `insertTableRow` operation this table belongs to. */
+  operationId: string;
+  /** Index of the table in the TARGET story. */
+  targetTableIndex: number;
+  /** Set for a row insertion: which of that table's rows to place. */
+  targetRowIndex?: number;
+};
 type CompareStoryPlan = {
   changes: CompareChange[];
   operations: FolioAIEditOperation[];
+  /**
+   * Where an operation's table comes from. Kept beside the operations rather
+   * than inside them because a table node is not JSON, and the serialized
+   * operation contract describes a table by its cell texts.
+   */
+  tableTemplates: CompareTableTemplateRequest[];
+  /**
+   * Base cells the alignment put opposite a target cell. Their tables, rows
+   * and cells are the ones whose `w:tblPr` / `w:trPr` / `w:tcPr` the caller
+   * matches: a table that stayed in place while its widths, shading or header
+   * row changed moves no block, so no operation carries the difference.
+   */
+  tableGeometryPairings: TableGeometryPairing[];
 };
 type PlanStoryCompareOptions = {
   story: FolioDocumentStoryHandle;
@@ -19,4 +49,4 @@ type PlanStoryCompareOptions = {
  */
 declare const planStoryCompare: ({ story, baseSnapshot, targetSnapshot, maxOperations }: PlanStoryCompareOptions) => CompareStoryPlan | null;
 //#endregion
-export { CompareStoryPlan, PlanStoryCompareOptions, planStoryCompare };
+export { CompareStoryPlan, CompareTableTemplateRequest, PlanStoryCompareOptions, planStoryCompare };

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
@@ -701,12 +752,198 @@ const locationOf = (story, block) => block.table ? {
 	cell: block.table
 } : { story };
 /**
+* The container a paragraph mark ends: the story's body, or one table cell. A
+* mark joins the paragraph it ends with the next paragraph of the SAME
+* container, so two blocks on either side of a boundary are not neighbours for
+* this purpose however adjacent they read.
+*/
+const containerKeyOf = ({ table }) => table ? `t${String(table.tableIndex)}r${String(table.rowIndex)}c${String(table.cellIndex)}` : "body";
+/** Each container's last block, in the order the story holds them. */
+const lastBlockByContainer = (blocks) => {
+	const last = /* @__PURE__ */ new Map();
+	for (const block of blocks) last.set(containerKeyOf(block), block);
+	return last;
+};
+/**
+* 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 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.
+*
+* 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.
+*
+* 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 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 indexById = new Map(blocks.map((block, index) => [block.id, index]));
+	/**
+	* 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 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 (!deletionIndexByBlockId.has(block.id)) {
+				chainStart = markedBlockIds.has(block.id) ? null : block;
+				break;
+			}
+			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
+				};
+			}
+		}
+		const targetCarrier = targetLastByContainer.get(container);
+		const properties = targetCarrier && changedParagraphProperties(carrier, targetCarrier);
+		if (properties) appended.push({
+			id: nextOperationId(),
+			type: "setBlockParagraphProperties",
+			blockId: carrier.id,
+			properties
+		});
+	}
+	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
 * `maxOperations`.
 */
 const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }) => {
 	const steps = buildSteps({
-		story,
 		baseSnapshot,
 		targetSnapshot
 	});
@@ -718,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
@@ -980,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": {
@@ -1017,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":
@@ -1050,9 +1291,17 @@ const planStoryCompare = ({ story, baseSnapshot, targetSnapshot, maxOperations }
 		}
 		if (operations.length > maxOperations) return null;
 	}
-	return operations.length > maxOperations ? null : {
+	const planned = withTrailingDeletionRules({
+		baseSnapshot,
+		targetSnapshot,
+		operations,
+		nextOperationId
+	});
+	return planned.length > maxOperations ? null : {
 		changes,
-		operations
+		operations: planned,
+		tableTemplates,
+		tableGeometryPairings: tableGeometryPairingsOf(steps)
 	};
 };
 //#endregion

package/dist/compare/reproducible-package.d.ts

@@ -1,6 +1,6 @@
 //#region src/compare/reproducible-package.d.ts
 /**
- * The last clock in the compare path is the ZIP container itself.
+ * The last two clocks in the compare path are outside the document body.
  *
  * Every part the serializer rewrites is stored with JSZip's default entry
  * date, which is `new Date()`. The XML is identical between two runs, but the
@@ -8,8 +8,12 @@
  * both runs land in the same two-second bucket — so the packages match most of
  * the time and differ occasionally, which is worse than differing always.
  *
- * Restamping every entry from the comparison's own timestamp removes it. It
- * also states the truth about the package: a generated redline is dated by the
+ * The save also stamps `dcterms:modified` in `docProps/core.xml` from the wall
+ * clock, which is the same failure one part deeper: two runs over identical
+ * inputs differ in that part alone.
+ *
+ * Restamping both from the comparison's own timestamp removes them. It also
+ * states the truth about the package: a generated redline is dated by the
  * comparison that produced it, not by the second it happened to be written.
  */
 declare const withFixedPackageDates: (buffer: ArrayBuffer, date: Date) => Promise<ArrayBuffer>;

package/dist/compare/reproducible-package.js

@@ -1,7 +1,7 @@
 import JSZip from "jszip";
 //#region src/compare/reproducible-package.ts
 /**
-* The last clock in the compare path is the ZIP container itself.
+* The last two clocks in the compare path are outside the document body.
 *
 * Every part the serializer rewrites is stored with JSZip's default entry
 * date, which is `new Date()`. The XML is identical between two runs, but the
@@ -9,14 +9,31 @@ import JSZip from "jszip";
 * both runs land in the same two-second bucket — so the packages match most of
 * the time and differ occasionally, which is worse than differing always.
 *
-* Restamping every entry from the comparison's own timestamp removes it. It
-* also states the truth about the package: a generated redline is dated by the
+* The save also stamps `dcterms:modified` in `docProps/core.xml` from the wall
+* clock, which is the same failure one part deeper: two runs over identical
+* inputs differ in that part alone.
+*
+* Restamping both from the comparison's own timestamp removes them. It also
+* states the truth about the package: a generated redline is dated by the
 * comparison that produced it, not by the second it happened to be written.
 */
 /** JSZip deflate level `repackDocx` writes DOCX parts at. */
 const DOCX_COMPRESSION_LEVEL = 6;
+const CORE_PROPERTIES_PATH = "docProps/core.xml";
+const MODIFIED_ELEMENT = /<dcterms:modified[^<>]*>[^<]*<\/dcterms:modified>/u;
+/**
+* Rewrite `dcterms:modified` where the save already wrote one. An absent
+* element stays absent: the comparison edits the document it was handed, and
+* synthesizing metadata the input never carried is a different decision.
+*/
+const withFixedModifiedDate = (corePropsXml, date) => corePropsXml.replace(MODIFIED_ELEMENT, `<dcterms:modified xsi:type="dcterms:W3CDTF">${date.toISOString()}</dcterms:modified>`);
 const withFixedPackageDates = async (buffer, date) => {
 	const zip = await JSZip.loadAsync(buffer);
+	const coreProps = zip.file(CORE_PROPERTIES_PATH);
+	if (coreProps) zip.file(CORE_PROPERTIES_PATH, withFixedModifiedDate(await coreProps.async("text"), date), {
+		compression: "DEFLATE",
+		compressionOptions: { level: DOCX_COMPRESSION_LEVEL }
+	});
 	zip.forEach((_path, file) => {
 		file.date = date;
 	});

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 } 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 = {
@@ -277,6 +277,23 @@ declare class CompareDocxSerializeError extends CompareDocxSerializeError_base<{
   message: string;
   cause: unknown;
 }> {}
-type CompareDocxError = CompareDocxApplyError | CompareDocxOperationLimitError | CompareDocxParseError | CompareDocxRoundTripError | CompareDocxSerializeError | InvalidCompareDocxOptionsError;
+declare const CompareDocxFinalParagraphMarkError_base: import("better-result").TaggedErrorClass<"CompareDocxFinalParagraphMarkError">;
+/**
+ * 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", 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. */
+  revisions: readonly FinalParagraphMarkRevision[];
+}> {}
+type CompareDocxError = CompareDocxApplyError | CompareDocxFinalParagraphMarkError | CompareDocxOperationLimitError | CompareDocxParseError | CompareDocxRoundTripError | CompareDocxSerializeError | InvalidCompareDocxOptionsError;
 //#endregion
-export { COMPARE_UNSUPPORTED_REASONS, CompareChange, CompareChangeLocation, CompareDocxApplyError, CompareDocxError, CompareDocxOperationLimitError, CompareDocxOptions, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, CompareFormatRange, CompareResult, CompareUnsupportedPart, CompareUnsupportedReason, InvalidCompareDocxOptionsError };
+export { COMPARE_UNSUPPORTED_REASONS, CompareChange, CompareChangeLocation, CompareDocxApplyError, CompareDocxError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxOptions, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, CompareFormatRange, CompareResult, CompareUnsupportedPart, CompareUnsupportedReason, InvalidCompareDocxOptionsError };

package/dist/compare/types.js

@@ -28,5 +28,17 @@ var CompareDocxRoundTripError = class extends TaggedError("CompareDocxRoundTripE
 /** The difference needs more operations than the engine will generate. */
 var CompareDocxOperationLimitError = class extends TaggedError("CompareDocxOperationLimitError") {};
 var CompareDocxSerializeError = class extends TaggedError("CompareDocxSerializeError") {};
+/**
+* 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", 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
-export { COMPARE_UNSUPPORTED_REASONS, CompareDocxApplyError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError };
+export { COMPARE_UNSUPPORTED_REASONS, CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError };

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.
  *
@@ -51,5 +59,44 @@ type ClassifyOptions = {
  * a divergence always produces a failure rather than being dropped.
  */
 declare const classifyProjectionMismatch: ({ invariant, story, actual, expected }: ClassifyOptions) => CompareVerificationFailure | null;
+/**
+ * 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 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, `moveFrom` / `moveTo` for a relocation's ends. */
+  kind: ParagraphMarkChangeKind;
+};
+/**
+ * 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",
+ * 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 revisedFinalParagraphMarks: (packageModel: unknown, { since }?: {
+  since?: number;
+}) => FinalParagraphMarkRevision[];
 //#endregion
-export { COMPARE_VERIFICATION_CAUSES, COMPARE_VERIFICATION_INVARIANTS, CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, classifyProjectionMismatch, projectSupportedInlineFormatting, sameProjection };
+export { COMPARE_VERIFICATION_CAUSES, COMPARE_VERIFICATION_INVARIANTS, CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkRevision, classifyGeometryMismatch, classifyProjectionMismatch, projectSupportedInlineFormatting, revisedFinalParagraphMarks, sameProjection };