@stll/folio-core 0.37.5 → 0.38.0

package/dist/compare/compare.js

@@ -1,15 +1,22 @@
 import { FolioDocxReviewer, getFolioDocxComparisonAccess } from "../ai-edits/headless.js";
-import { numberingReferenceKeysOf, storyTablesOf } from "../ai-edits/snapshot.js";
+import { detachFolioAIEditSnapshotExternalHyperlinks, numberingReferenceKeysOf, remapFolioAIEditSnapshotNumberingReferences, remapFolioAIEditSnapshotStyleReferences, sourceDocumentOf, storyTablesOf } from "../ai-edits/snapshot.js";
 import { projectTableGeometry } from "../ai-edits/table-geometry.js";
 import { tableTemplateCanCrossPackageLosslessly } from "../ai-edits/table-template.js";
 import { createScopedWordDiffOptions } from "../ai-edits/word-diff.js";
 import "../document-operations.js";
 import { pairFolioDocumentStories } from "../document-stories.js";
+import { sectionReferenceHistory } from "../docx/sectionReferenceHistory.js";
+import { sameCanonicalInlinePresentation } from "../internal/compare/inline-presentation.js";
+import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
 import { createContentComparisonWorkSession } from "./content.js";
+import { sameInlineAtoms } from "./inline-atoms.js";
+import { sameAuthoredInlineProvenance } from "./inline-provenance.js";
 import { planStoryCompare } from "./plan.js";
 import { withFixedPackageDates } from "./reproducible-package.js";
+import { compareSectionBoundaryProperties } from "./section-boundary-properties.js";
 import { CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError } from "./types.js";
-import { classifyGeometryMismatch, classifyProjectionMismatch, projectSupportedInlineFormatting, revisedFinalParagraphMarks } from "./verification.js";
+import { classifyGeometryMismatch, classifyProjectionMismatch, revisedFinalParagraphMarks } from "./verification.js";
 import { Result, panic } from "better-result";
 //#region src/compare/compare.ts
 /**
@@ -78,7 +85,7 @@ const formattingRoundTripFailure = ({ invariant, story, changes, actualBlocks, e
 			story,
 			detail: "a text-equal aligned block could not be projected for formatting verification"
 		};
-		if (projectSupportedInlineFormatting(actual) !== projectSupportedInlineFormatting(expected)) return {
+		if (!sameCanonicalInlinePresentation(actual, expected)) return {
 			invariant,
 			cause: "inline-formatting",
 			story,
@@ -113,8 +120,86 @@ const compareNumbering = (base, target, referenced) => {
 	});
 	return changes.toSorted((left, right) => left.numId - right.numId || left.level - right.level);
 };
+const withoutSectionChangeHistory = ({ propertyChanges: _propertyChanges, ...properties }) => properties;
+const sectionRelationshipMap = (pairs) => {
+	const mapped = /* @__PURE__ */ new Map();
+	for (const { baseStory, targetStory } of pairs) {
+		if (baseStory.type !== "header" && baseStory.type !== "footer" || targetStory.type !== "header" && targetStory.type !== "footer" || baseStory.type !== targetStory.type) continue;
+		mapped.set(targetStory.relationshipId, baseStory.relationshipId);
+	}
+	return mapped;
+};
+const remapSectionReferences = (references, relationshipIds) => {
+	if (references === void 0) return void 0;
+	const remapped = [];
+	for (const reference of references) {
+		const relationshipId = relationshipIds.get(reference.rId);
+		if (relationshipId === void 0) return null;
+		remapped.push({
+			...reference,
+			rId: relationshipId
+		});
+	}
+	return remapped;
+};
+const safelyStageSectionProperties = ({ current, target, relationshipIds, revisionFormat }) => {
+	const targetHeaders = remapSectionReferences(target.headerReferences, relationshipIds);
+	const targetFooters = remapSectionReferences(target.footerReferences, relationshipIds);
+	if (targetHeaders === null || targetFooters === null || revisionFormat === "word" && (canonicalJson(targetHeaders) !== canonicalJson(current.headerReferences) || canonicalJson(targetFooters) !== canonicalJson(current.footerReferences)) || target.printerSettingsRelationshipId !== current.printerSettingsRelationshipId) return null;
+	const safeTarget = {
+		...withoutSectionChangeHistory(target),
+		...targetHeaders !== void 0 && { headerReferences: targetHeaders },
+		...targetFooters !== void 0 && { footerReferences: targetFooters },
+		...current.printerSettingsRelationshipId !== void 0 && { printerSettingsRelationshipId: current.printerSettingsRelationshipId }
+	};
+	return {
+		previous: withoutSectionChangeHistory(current),
+		target: safeTarget
+	};
+};
+const stageInsertedSectionProperties = ({ target, relationshipIds }) => {
+	if (target.printerSettingsRelationshipId !== void 0) return null;
+	const headers = remapSectionReferences(target.headerReferences, relationshipIds);
+	const footers = remapSectionReferences(target.footerReferences, relationshipIds);
+	if (headers === null || footers === null) return null;
+	return {
+		...withoutSectionChangeHistory(target),
+		...headers !== void 0 && { headerReferences: headers },
+		...footers !== void 0 && { footerReferences: footers }
+	};
+};
+const compareFinalSectionProperties = ({ base, target, pairs, revisionFormat }) => {
+	if (base === void 0 || target === void 0) return base === target ? { status: "same" } : {
+		status: "unsupported",
+		detail: "final section presence differs"
+	};
+	if (base.propertyChanges !== void 0 || target.propertyChanges !== void 0) return {
+		status: "unsupported",
+		detail: "input final section already carries tracked changes"
+	};
+	const staged = safelyStageSectionProperties({
+		current: base,
+		target,
+		relationshipIds: sectionRelationshipMap(pairs),
+		revisionFormat
+	});
+	if (!staged) return {
+		status: "unsupported",
+		detail: "final section relationship references differ"
+	};
+	return canonicalJson(staged.previous) === canonicalJson(staged.target) ? { status: "same" } : {
+		status: "stage",
+		...staged
+	};
+};
 /** Stage 1: both packages to editor models, paired story by story. */
 const parseComparison = async (base, target, options) => {
+	const revisionFormat = options.revisionFormat ?? "word";
+	if (revisionFormat !== "word" && revisionFormat !== "folio-exact") return Result.err(new InvalidCompareDocxOptionsError({
+		message: "revisionFormat must be word or folio-exact.",
+		option: "revisionFormat",
+		receivedValue: revisionFormat
+	}));
 	const packageDate = new Date(options.timestamp);
 	if (Number.isNaN(packageDate.getTime())) return Result.err(new InvalidCompareDocxOptionsError({
 		message: "timestamp must be a date the package can be stamped with.",
@@ -142,13 +227,34 @@ const parseComparison = async (base, target, options) => {
 		targetSnapshots.set(handle, snapshot);
 	}
 	const pairs = [];
+	const importedHeaderFooterTargetSnapshots = /* @__PURE__ */ new Set();
 	const unsupported = [];
 	const referencedNumberingLevels = /* @__PURE__ */ new Set();
+	let terminalTableCarrierStaged = false;
 	const collectNumberingReferences = (snapshot) => {
 		if (!snapshot) return;
 		for (const referenceKey of numberingReferenceKeysOf(snapshot)) referencedNumberingLevels.add(referenceKey);
 	};
-	for (const { baseStory, revisedStory: targetStory } of pairFolioDocumentStories(baseStories, targetStories)) {
+	for (const storyPair of pairFolioDocumentStories(baseStories, targetStories)) {
+		let { baseStory, revisedStory: targetStory } = storyPair;
+		let targetHeaderFooterWasImported = false;
+		let targetHeaderFooterNeedsExternalHyperlinkRebinding = false;
+		if (!baseStory && targetStory && (targetStory.type === "header" || targetStory.type === "footer")) {
+			baseStory = await getFolioDocxComparisonAccess(reviewer).createComparisonHeaderFooter(targetReviewer, targetStory);
+			if (baseStory) {
+				targetHeaderFooterWasImported = true;
+				targetHeaderFooterNeedsExternalHyperlinkRebinding = true;
+				baseSnapshots.set(baseStory, reviewer.snapshotStory(baseStory));
+			}
+		}
+		if (!targetStory && baseStory && revisionFormat === "folio-exact" && (baseStory.type === "header" || baseStory.type === "footer")) continue;
+		if (!targetStory && baseStory && (baseStory.type === "header" || baseStory.type === "footer")) {
+			targetStory = await getFolioDocxComparisonAccess(targetReviewer).createComparisonHeaderFooter(reviewer, baseStory);
+			if (targetStory) {
+				targetHeaderFooterNeedsExternalHyperlinkRebinding = true;
+				targetSnapshots.set(targetStory, targetReviewer.snapshotStory(targetStory));
+			}
+		}
 		if (!baseStory) {
 			if (!targetStory) panic("A story pair contained neither a base nor a target story");
 			collectNumberingReferences(targetSnapshots.get(targetStory));
@@ -168,8 +274,8 @@ const parseComparison = async (base, target, options) => {
 			});
 			continue;
 		}
-		const baseSnapshot = baseSnapshots.get(baseStory);
-		const targetSnapshot = targetSnapshots.get(targetStory);
+		let baseSnapshot = baseSnapshots.get(baseStory);
+		let targetSnapshot = targetSnapshots.get(targetStory);
 		collectNumberingReferences(baseSnapshot);
 		collectNumberingReferences(targetSnapshot);
 		if (!baseSnapshot || !targetSnapshot) {
@@ -180,15 +286,70 @@ const parseComparison = async (base, target, options) => {
 			});
 			continue;
 		}
+		const rawBaseSnapshot = baseSnapshot;
+		if (revisionFormat === "folio-exact" && baseStory.type === "main" && getFolioDocxComparisonAccess(reviewer).stageTerminalTableReviewCarrier(sourceDocumentOf(targetSnapshot))) {
+			const staged = reviewer.snapshotStory(baseStory);
+			if (!staged) panic("A staged terminal-table carrier lost the main story snapshot");
+			baseSnapshot = staged;
+			baseSnapshots.set(baseStory, staged);
+			terminalTableCarrierStaged = true;
+		}
+		if (targetHeaderFooterNeedsExternalHyperlinkRebinding) {
+			const detached = detachFolioAIEditSnapshotExternalHyperlinks(targetSnapshot);
+			if (!detached) {
+				unsupported.push({
+					reason: "story-not-editable",
+					baseStory,
+					targetStory
+				});
+				continue;
+			}
+			targetSnapshot = detached;
+			targetSnapshots.set(targetStory, targetSnapshot);
+		}
+		if (targetHeaderFooterWasImported) importedHeaderFooterTargetSnapshots.add(targetSnapshot);
 		pairs.push({
 			baseStory,
 			targetStory,
 			baseSnapshot,
+			...terminalTableCarrierStaged && rawBaseSnapshot !== baseSnapshot && { rawBaseSnapshot },
 			targetSnapshot
 		});
 	}
+	const styleImport = getFolioDocxComparisonAccess(reviewer).stageTargetStyles(targetReviewer, pairs.map(({ targetSnapshot }) => targetSnapshot), [...importedHeaderFooterTargetSnapshots]);
+	const styleAlignedPairs = styleImport.status === "unalignable" ? pairs : pairs.map(({ baseStory, targetStory, baseSnapshot, rawBaseSnapshot, targetSnapshot }) => ({
+		baseStory,
+		targetStory,
+		baseSnapshot,
+		rawBaseSnapshot: rawBaseSnapshot ?? baseSnapshot,
+		targetSnapshot: remapFolioAIEditSnapshotStyleReferences({
+			snapshot: targetSnapshot,
+			styleIdMap: styleImport.styleIdMap,
+			defaultParagraphStyleId: styleImport.defaultParagraphStyleId,
+			importedStyleResolver: createStyleResolver(styleImport.styles),
+			reconcileAuthoredFormatting: true
+		})
+	}));
+	const targetNumbering = getFolioDocxComparisonAccess(targetReviewer).numberingDefinitions();
+	const targetNumberingReferences = styleAlignedPairs.flatMap(({ targetSnapshot }) => targetSnapshot.blocks.flatMap((block) => block.listReference ? [block.listReference] : []));
+	const targetNumberingReferenceMap = getFolioDocxComparisonAccess(reviewer).planTargetNumberingReferences(targetNumbering, targetNumberingReferences);
+	const comparisonPairs = targetNumberingReferenceMap === null ? styleAlignedPairs : styleAlignedPairs.map(({ baseStory, targetStory, baseSnapshot, rawBaseSnapshot, targetSnapshot }) => ({
+		baseStory,
+		targetStory,
+		baseSnapshot,
+		rawBaseSnapshot: rawBaseSnapshot ?? baseSnapshot,
+		targetSnapshot: remapFolioAIEditSnapshotNumberingReferences(targetSnapshot, targetNumberingReferenceMap)
+	}));
+	const finalSectionComparison = compareFinalSectionProperties({
+		base: getFolioDocxComparisonAccess(reviewer).finalSectionProperties(),
+		target: getFolioDocxComparisonAccess(targetReviewer).finalSectionProperties(),
+		pairs: comparisonPairs,
+		revisionFormat
+	});
 	return Result.ok({
 		granularity: options.granularity ?? "word",
+		revisionFormat,
+		terminalTableCarrierStaged,
 		baseBuffer: base,
 		baseCarriedRevisions: baseProjection.revisions.present,
 		reviewer,
@@ -197,8 +358,13 @@ const parseComparison = async (base, target, options) => {
 			idSeed: baseProjection.revisions.highestId + 1
 		},
 		packageDate,
-		pairs,
+		pairs: comparisonPairs,
 		numberingChanges: compareNumbering(reviewer, targetReviewer, referencedNumberingLevels),
+		targetNumbering,
+		targetNumberingReferences,
+		targetNumberingReferenceMap: targetNumberingReferenceMap ?? /* @__PURE__ */ new Map(),
+		finalSectionComparison,
+		styleImportFailure: styleImport.status === "unalignable" ? styleImport.detail : void 0,
 		unsupported
 	});
 };
@@ -328,18 +494,58 @@ const resolveTableTemplates = (targetTables, requests) => {
 * what you could not represent" and "give me nothing unless you can prove it"
 * are both legitimate asks and only the caller knows which one it is making.
 */
-const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChanges }, planned) => {
+const applyComparison = ({ reviewer, revisionStamp, granularity, revisionFormat, terminalTableCarrierStaged, numberingChanges, targetNumbering, targetNumberingReferences, targetNumberingReferenceMap, finalSectionComparison, styleImportFailure, pairs }, planned) => {
+	const relationshipIds = sectionRelationshipMap(pairs);
+	const plannedOperationCount = planned.reduce((count, { plan }) => count + plan.operations.length, 0);
+	const finalSectionOperationCount = finalSectionComparison.status === "stage" ? 1 : 0;
+	if (plannedOperationCount + finalSectionOperationCount > 1e4) return Result.err(new CompareDocxOperationLimitError({
+		message: "The comparison needs more operations than the engine generates.",
+		limit: MAX_COMPARE_OPERATIONS
+	}));
 	const comparisonAccess = getFolioDocxComparisonAccess(reviewer);
+	const numberingStage = comparisonAccess.stageTargetNumbering(targetNumbering, targetNumberingReferences, targetNumberingReferenceMap);
 	const changes = [...numberingChanges];
 	const failures = [];
-	let idSeed = revisionStamp.idSeed;
-	let documentChanged = false;
+	if (styleImportFailure !== void 0) failures.push({
+		invariant: "accept-reproduces-target",
+		cause: "style",
+		story: { type: "main" },
+		detail: styleImportFailure
+	});
+	const finalSectionChanged = finalSectionComparison.status === "stage" && comparisonAccess.stageFinalSectionProperties({
+		target: finalSectionComparison.target,
+		previous: finalSectionComparison.previous,
+		revision: revisionStamp
+	});
+	if (finalSectionChanged) changes.push({
+		kind: "section-properties",
+		location: { story: { type: "main" } }
+	});
+	if (finalSectionComparison.status === "unsupported") failures.push({
+		invariant: "accept-reproduces-target",
+		cause: "section-properties",
+		story: { type: "main" },
+		detail: finalSectionComparison.detail
+	});
+	let idSeed = revisionStamp.idSeed + (finalSectionChanged ? 1 : 0);
+	if (numberingStage === "conflict") failures.push({
+		invariant: "accept-reproduces-target",
+		cause: "list-level",
+		story: { type: "main" },
+		detail: "target numbering definitions cannot be imported without changing existing references"
+	});
+	const folioRequirements = /* @__PURE__ */ new Set();
+	if (finalSectionChanged && finalSectionComparison.status === "stage" && sectionReferenceHistory(finalSectionComparison) !== void 0) folioRequirements.add("section-reference-history");
+	if (terminalTableCarrierStaged) folioRequirements.add("terminal-table-carrier");
+	let documentChanged = numberingStage === "staged" || finalSectionChanged;
+	let remainingProvenanceRanges = MAX_COMPARE_OPERATIONS - plannedOperationCount - finalSectionOperationCount;
 	const wordDiff = createScopedWordDiffOptions({ granularity });
 	for (const { pair, plan } of planned) {
 		changes.push(...plan.changes);
-		if (plan.operations.length === 0 && plan.tableGeometryPairings.length === 0) continue;
-		const baseBefore = pair.baseSnapshot.blocks;
-		const baseBeforeGeometry = projectTableGeometry(storyTablesOf(pair.baseSnapshot));
+		failures.push(...plan.verificationFailures);
+		const rawBaseSnapshot = pair.rawBaseSnapshot ?? pair.baseSnapshot;
+		const baseBefore = rawBaseSnapshot.blocks;
+		const baseBeforeGeometry = projectTableGeometry(storyTablesOf(rawBaseSnapshot));
 		const targetTables = new Map(storyTablesOf(pair.targetSnapshot).map(({ index, node }) => [index, node]));
 		const afterGeometry = reviewer.matchStoryTableGeometry({
 			story: pair.baseStory,
@@ -353,7 +559,6 @@ const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChange
 		const geometryChanged = afterGeometry > idSeed;
 		documentChanged ||= geometryChanged;
 		idSeed = afterGeometry;
-		if (plan.operations.length === 0 && !geometryChanged) continue;
 		if (plan.operations.length > 0) {
 			const { skipped, nextRevisionId } = reviewer.applyDocumentOperationsToStory({
 				story: pair.baseStory,
@@ -379,6 +584,171 @@ const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChange
 				skipped: refused
 			}));
 		}
+		const describedTargetIds = /* @__PURE__ */ new Set();
+		for (const change of plan.changes) switch (change.kind) {
+			case "insert":
+			case "replace":
+			case "move":
+			case "merge":
+			case "paragraph-format":
+			case "format":
+			case "run-format":
+			case "inline-atom":
+				describedTargetIds.add(change.targetBlockId);
+				break;
+			case "split":
+			case "table-insert":
+			case "table-row-insert":
+			case "table-column-insert":
+				for (const id of change.targetBlockIds) describedTargetIds.add(id);
+				break;
+			case "delete":
+			case "section-properties":
+			case "table-delete":
+			case "table-row-delete":
+			case "table-column-delete":
+			case "numbering": break;
+			default: return panic("Unhandled comparison change", { change });
+		}
+		const atoms = comparisonAccess.matchInlineAtoms({
+			story: pair.baseStory,
+			targetSnapshot: pair.targetSnapshot,
+			revisionStamp: {
+				date: revisionStamp.date,
+				idSeed
+			},
+			originalRevisionIdSeed: revisionStamp.idSeed,
+			maxRanges: remainingProvenanceRanges
+		});
+		switch (atoms.status) {
+			case "matched": {
+				idSeed = atoms.nextRevisionId;
+				remainingProvenanceRanges -= atoms.rangeCount;
+				documentChanged ||= atoms.documentChanged;
+				const changedAtomTargetIds = new Set(atoms.changedTargetBlockIds);
+				for (const block of pair.targetSnapshot.blocks) {
+					if (!changedAtomTargetIds.has(block.id) || describedTargetIds.has(block.id)) continue;
+					changes.push({
+						kind: "inline-atom",
+						location: {
+							story: pair.baseStory,
+							...block.table ? { cell: block.table } : {}
+						},
+						targetBlockId: block.id,
+						text: block.text
+					});
+				}
+				break;
+			}
+			case "unalignable":
+				failures.push({
+					invariant: "accept-reproduces-target",
+					cause: "inline-structure",
+					story: pair.baseStory,
+					detail: "supported inline atoms could not be aligned to the revised content"
+				});
+				break;
+			case "budget-exceeded": return Result.err(new CompareDocxOperationLimitError({
+				message: "The comparison exceeds its inline presentation range budget.",
+				limit: MAX_COMPARE_OPERATIONS
+			}));
+			default: return panic("Unhandled inline atom projection result", { result: atoms });
+		}
+		const provenance = comparisonAccess.matchInlineProvenance({
+			story: pair.baseStory,
+			targetSnapshot: pair.targetSnapshot,
+			revisionStamp: {
+				date: revisionStamp.date,
+				idSeed
+			},
+			originalRevisionIdSeed: revisionStamp.idSeed,
+			maxRanges: remainingProvenanceRanges
+		});
+		switch (provenance.status) {
+			case "matched": {
+				idSeed = provenance.nextRevisionId;
+				remainingProvenanceRanges -= provenance.rangeCount;
+				documentChanged ||= provenance.documentChanged;
+				const changedTargetIds = new Set(provenance.changedTargetBlockIds);
+				for (const block of pair.targetSnapshot.blocks) {
+					if (!changedTargetIds.has(block.id) || describedTargetIds.has(block.id)) continue;
+					changes.push({
+						kind: "run-format",
+						location: {
+							story: pair.baseStory,
+							...block.table ? { cell: block.table } : {}
+						},
+						targetBlockId: block.id,
+						text: block.text
+					});
+				}
+				break;
+			}
+			case "unalignable":
+				failures.push({
+					invariant: "accept-reproduces-target",
+					cause: "inline-formatting",
+					story: pair.baseStory,
+					detail: "authored run properties could not be aligned to the revised content"
+				});
+				break;
+			case "budget-exceeded": return Result.err(new CompareDocxOperationLimitError({
+				message: "The comparison exceeds its inline presentation range budget.",
+				limit: MAX_COMPARE_OPERATIONS
+			}));
+			default: return panic("Unhandled authored inline projection result", { result: provenance });
+		}
+		if (pair.baseStory.type === "main") {
+			let boundaryRequiresFolio = false;
+			const insertedBoundaries = comparisonAccess.stageMappedSectionBoundaries({
+				target: sourceDocumentOf(pair.targetSnapshot),
+				originalRevisionIdSeed: revisionStamp.idSeed,
+				maxRanges: remainingProvenanceRanges,
+				revision: {
+					date: revisionStamp.date,
+					idSeed
+				},
+				mapTargetProperties: ({ kind, current, target }) => {
+					if (kind === "inserted") {
+						const inserted = stageInsertedSectionProperties({
+							target,
+							relationshipIds
+						});
+						return inserted ? {
+							kind: "inserted",
+							target: inserted
+						} : null;
+					}
+					if (current === void 0) return null;
+					const staged = safelyStageSectionProperties({
+						current,
+						target,
+						relationshipIds,
+						revisionFormat
+					});
+					if (staged && sectionReferenceHistory(staged) !== void 0) boundaryRequiresFolio = true;
+					return staged ? {
+						kind: "retained",
+						...staged
+					} : null;
+				}
+			});
+			switch (insertedBoundaries.status) {
+				case "matched":
+					remainingProvenanceRanges -= insertedBoundaries.rangeCount;
+					idSeed = insertedBoundaries.nextRevisionId;
+					documentChanged ||= insertedBoundaries.documentChanged;
+					if (boundaryRequiresFolio) folioRequirements.add("section-reference-history");
+					break;
+				case "unalignable": break;
+				case "budget-exceeded": return Result.err(new CompareDocxOperationLimitError({
+					message: "The comparison exceeds its section boundary range budget.",
+					limit: MAX_COMPARE_OPERATIONS
+				}));
+				default: return panic("Unhandled inserted section boundary result", { result: insertedBoundaries });
+			}
+		}
+		if (plan.operations.length === 0 && !geometryChanged && atoms.status === "matched" && atoms.rangeCount === 0 && provenance.status === "matched" && provenance.rangeCount === 0 && pair.baseStory.type !== "main") continue;
 		const acceptedSnapshot = comparisonAccess.snapshotReviewedStory({
 			story: pair.baseStory,
 			view: "final"
@@ -401,6 +771,34 @@ const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChange
 			});
 			if (formattingFailure) failures.push(formattingFailure);
 		}
+		if (acceptedSnapshot && !sameAuthoredInlineProvenance(acceptedSnapshot, pair.targetSnapshot)) failures.push({
+			invariant: "accept-reproduces-target",
+			cause: "inline-formatting",
+			story: pair.baseStory,
+			detail: "accepted authored run properties differ from the revised document"
+		});
+		if (acceptedSnapshot && !sameInlineAtoms(sourceDocumentOf(acceptedSnapshot), sourceDocumentOf(pair.targetSnapshot))) failures.push({
+			invariant: "accept-reproduces-target",
+			cause: "inline-structure",
+			story: pair.baseStory,
+			detail: "accepted inline atoms differ from the revised document"
+		});
+		if (pair.baseStory.type === "main" && acceptedSnapshot) {
+			const sectionBoundaries = compareSectionBoundaryProperties({
+				current: sourceDocumentOf(acceptedSnapshot),
+				target: sourceDocumentOf(pair.targetSnapshot),
+				mapTargetProperties: (target) => stageInsertedSectionProperties({
+					target,
+					relationshipIds
+				})
+			});
+			if (sectionBoundaries.status === "unalignable" || sectionBoundaries.changes.length > 0) failures.push({
+				invariant: "accept-reproduces-target",
+				cause: "section-properties",
+				story: pair.baseStory,
+				detail: sectionBoundaries.status === "unalignable" ? sectionBoundaries.detail : "accepted paragraph section properties differ from the revised document"
+			});
+		}
 		const rejectedSnapshot = comparisonAccess.snapshotReviewedStory({
 			story: pair.baseStory,
 			view: "original"
@@ -418,11 +816,35 @@ const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChange
 				story: pair.baseStory,
 				changes: plan.changes,
 				actualBlocks: rejectedSnapshot?.blocks ?? [],
-				expectedBlocks: pair.baseSnapshot.blocks,
+				expectedBlocks: rawBaseSnapshot.blocks,
 				expectedBlockId: ({ baseBlockId }) => baseBlockId
 			});
 			if (formattingFailure) failures.push(formattingFailure);
 		}
+		if (rejectedSnapshot && !sameAuthoredInlineProvenance(rejectedSnapshot, rawBaseSnapshot)) failures.push({
+			invariant: "reject-reproduces-base",
+			cause: "inline-formatting",
+			story: pair.baseStory,
+			detail: "rejected authored run properties differ from the base document"
+		});
+		if (rejectedSnapshot && !sameInlineAtoms(sourceDocumentOf(rejectedSnapshot), sourceDocumentOf(rawBaseSnapshot))) failures.push({
+			invariant: "reject-reproduces-base",
+			cause: "inline-structure",
+			story: pair.baseStory,
+			detail: "rejected inline atoms differ from the base document"
+		});
+		if (pair.baseStory.type === "main" && rejectedSnapshot) {
+			const sectionBoundaries = compareSectionBoundaryProperties({
+				current: sourceDocumentOf(rejectedSnapshot),
+				target: sourceDocumentOf(rawBaseSnapshot)
+			});
+			if (sectionBoundaries.status === "unalignable" || sectionBoundaries.changes.length > 0) failures.push({
+				invariant: "reject-reproduces-base",
+				cause: "section-properties",
+				story: pair.baseStory,
+				detail: sectionBoundaries.status === "unalignable" ? sectionBoundaries.detail : "rejected paragraph section properties differ from the base document"
+			});
+		}
 		const geometryAcceptFailure = classifyGeometryMismatch({
 			invariant: "accept-reproduces-target",
 			story: pair.baseStory,
@@ -438,13 +860,18 @@ const applyComparison = ({ reviewer, revisionStamp, granularity, numberingChange
 		});
 		if (geometryRejectFailure) failures.push(geometryRejectFailure);
 	}
+	const firstFolioRequirement = [...folioRequirements].at(0);
 	return Result.ok({
 		changes,
 		verification: failures.length === 0 ? { status: "verified" } : {
 			status: "unverified",
 			failures
 		},
-		documentChanged
+		documentChanged,
+		compatibility: firstFolioRequirement === void 0 ? { status: "standard-ooxml" } : {
+			status: "requires-folio",
+			reasons: [firstFolioRequirement, ...[...folioRequirements].slice(1)]
+		}
 	});
 };
 /**
@@ -519,6 +946,7 @@ const compareDocx = async (base, target, options) => {
 		buffer: serialized.value,
 		changes,
 		verification,
+		compatibility: applied.value.compatibility,
 		unsupported: parsed.value.unsupported
 	});
 };

package/dist/compare/content-alignment.js

@@ -710,7 +710,7 @@ const ALIGNMENT_DIRECTION = {
 	baseOnly: 2,
 	revisedOnly: 3
 };
-const alignProfiledContentSequence = ({ base, revised, workSession, canPair = () => true, pairSoleStructuralSlot = false, primaryEvidence = "stable", similarityFactor = () => 1 }) => {
+const alignProfiledContentSequence = ({ base, revised, workSession, canPair = () => true, pairSoleStructuralSlot = false, soleShiftedPairResiduePolicy = "conservative", primaryEvidence = "stable", similarityFactor = () => 1 }) => {
 	if (base.length === 0 || revised.length === 0) return unpairedContentSequence(base.map(({ item }) => item), revised.map(({ item }) => item));
 	if ((base.length !== 1 || revised.length !== 1) && !claimFolioContentAlignmentCells(base.length, revised.length, workSession)) return unpairedContentSequence(base.map(({ item }) => item), revised.map(({ item }) => item));
 	const stablePairs = stableContentSequencePairs(base, revised);
@@ -882,7 +882,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 		});
 		hasRevisedOnly = true;
 	}
-	if (pairCount === 1 && solePairIsShifted && hasBaseOnly && hasRevisedOnly) return aligned.flatMap((entry) => entry.type === "pair" ? [{
+	if ((soleShiftedPairResiduePolicy === "conservative" || base.length === revised.length) && pairCount === 1 && solePairIsShifted && hasBaseOnly && hasRevisedOnly) return aligned.flatMap((entry) => entry.type === "pair" ? [{
 		type: "baseOnly",
 		item: entry.base
 	}, {
@@ -954,6 +954,7 @@ const pairTableRows = ({ baseRows, revisedRows, workSession, idStability }) => {
 		revised: revisedRows.map(profile),
 		workSession,
 		pairSoleStructuralSlot: true,
+		soleShiftedPairResiduePolicy: "row-count-evidence",
 		primaryEvidence: "exact",
 		similarityFactor: (base, revised) => base.profile.physicalCellCount === revised.profile.physicalCellCount ? 1 : .5
 	}).map((alignment) => {