@stll/folio-core 0.44.0 → 0.46.0

package/dist/ai-edits/__fixtures__/paragraphs.js

@@ -1,3 +1,4 @@
+import { escapeXmlText } from "@stll/docx-core";
 import JSZip from "jszip";
 //#region src/ai-edits/__fixtures__/paragraphs.ts
 /**
@@ -13,8 +14,7 @@ const ZIP_ENTRY_OPTIONS = {
 	date: new Date(Date.UTC(2e3, 0, 1)),
 	createFolders: false
 };
-const escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-const paragraphXml = (text) => `<w:p><w:r><w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r></w:p>`;
+const paragraphXml = (text) => `<w:p><w:r><w:t xml:space="preserve">${escapeXmlText(text)}</w:t></w:r></w:p>`;
 const buildParagraphsDocx = async (paragraphs, { inTableCell } = {}) => {
 	const paragraphsXml = paragraphs.map(paragraphXml).join("");
 	const body = inTableCell ? `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr><w:tblGrid><w:gridCol w:w="9360"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcW w:w="9360" w:type="dxa"/></w:tcPr>${paragraphsXml}</w:tc></w:tr></w:tbl>` + paragraphXml("After the table.") : paragraphsXml;

package/dist/ai-edits/apply.js

@@ -10,6 +10,7 @@ import { directParagraphIndentation, paragraphIndentationAttrPatch, paragraphInd
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqual, paragraphSpacingFromFormatting, withDirectParagraphSpacing } from "../prosemirror/paragraphSpacing.js";
 import { getDocumentNumbering } from "../prosemirror/plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
+import { addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, surveyReplacedAnnotations } from "../prosemirror/replacedAnnotations.js";
 import { applyMarksToRunFormattingRepresentation, runFormattingInlineControlNodeName, selectRunFormattingCarrierRepresentations } from "../prosemirror/runFormattingInlineCarriers.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
 import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
@@ -949,6 +950,14 @@ const buildEmphasisInlineContent = (schema, text, baseMarks) => {
 	}
 	return nodes.length > 0 ? nodes : [schema.text(text, [...baseMarks])];
 };
+/**
+* Inline content for a block the applier rebuilds whole, carrying over the
+* annotations the block's old content held (see `replacedAnnotations`).
+*/
+const rebuiltBlockContent = ({ doc, blockFrom, blockTo, content }) => annotatedReplacement({
+	annotations: surveyReplacedAnnotations(doc, blockFrom + 1, blockTo - 1),
+	content: Fragment.fromArray([...content])
+}).fragment;
 const isBatchableParagraphInsertion = (item, mode) => {
 	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return false;
 	if (item.commentText !== void 0) return false;
@@ -1608,7 +1617,12 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					const replacement = item.operation.text;
 					const paragraphType = view.state.schema.nodes["paragraph"];
 					if (paragraphType) {
-						const node = paragraphType.create(null, replacement.length === 0 ? null : buildEmphasisInlineContent(view.state.schema, replacement, commentMark ? [commentMark] : []));
+						const node = paragraphType.create(null, rebuiltBlockContent({
+							doc: tr.doc,
+							blockFrom: item.blockFrom,
+							blockTo: item.blockTo,
+							content: replacement.length === 0 ? [] : buildEmphasisInlineContent(view.state.schema, replacement, commentMark ? [commentMark] : [])
+						}));
 						tr = tr.replaceWith(item.blockFrom, item.blockTo, node);
 						tr = applyReplaceBlockStyleId({
 							item,
@@ -1619,7 +1633,12 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 					}
 				}
 				if (mode === "direct" && hasInlineEmphasis(item.operation.text)) {
-					const node = item.blockNode.type.create({ ...item.blockNode.attrs }, buildEmphasisInlineContent(view.state.schema, item.operation.text, commentMark ? [commentMark] : []));
+					const node = item.blockNode.type.create({ ...item.blockNode.attrs }, rebuiltBlockContent({
+						doc: tr.doc,
+						blockFrom: item.blockFrom,
+						blockTo: item.blockTo,
+						content: buildEmphasisInlineContent(view.state.schema, item.operation.text, commentMark ? [commentMark] : [])
+					}));
 					tr = tr.replaceWith(item.blockFrom, item.blockTo, node);
 					tr = applyReplaceBlockStyleId({
 						item,
@@ -2342,18 +2361,28 @@ const cleanTextInlineNodes = ({ schema, text, marks = [] }) => {
 	if (trailing.length > 0) nodes.push(schema.text(trailing, marks));
 	return nodes;
 };
-const insertCleanText = ({ tr, from, to, text }) => {
-	if (!hasCleanTextControls(text)) return {
+const insertCleanText = ({ tr, from, to, text, standsInFor }) => {
+	const annotations = surveyReplacedAnnotations(tr.doc, from, to);
+	const replaced = standsInFor ? surveyReplacedAnnotations(tr.doc, standsInFor.from, standsInFor.to).carried : [];
+	if (!hasReplacedAnnotations(annotations) && replaced.length === 0 && !hasCleanTextControls(text)) return {
 		transaction: tr.insertText(text, from, to),
+		start: from,
 		end: from + text.length
 	};
-	const content = Fragment.fromArray(cleanTextInlineNodes({
-		schema: tr.doc.type.schema,
-		text
-	}));
+	const schema = tr.doc.type.schema;
+	const { fragment, leadingSize, contentSize } = annotatedReplacement({
+		annotations,
+		content: Fragment.fromArray(cleanTextInlineNodes({
+			schema,
+			text,
+			marks: addCarriedMarks(inheritedReplacementMarks(tr.doc, from, to), replaced)
+		}))
+	});
+	const start = from + leadingSize;
 	return {
-		transaction: tr.replaceWith(from, to, content),
-		end: from + content.size
+		transaction: tr.replaceWith(from, to, fragment),
+		start,
+		end: start + contentSize
 	};
 };
 const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete, revisionIdInsert, commentMark, suggestionId = null, initials, diffText }) => {
@@ -2365,8 +2394,11 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 	})());
 	if (mode === "direct") {
 		if ((item.operation.type === "replaceInBlock" || item.operation.type === "replaceRange") && hasInlineEmphasis(item.operation.replace)) {
-			const content = buildEmphasisInlineContent(nextTr.doc.type.schema, item.operation.replace, commentMark ? [commentMark] : []);
-			return nextTr.replaceWith(item.from, item.to, content);
+			const { fragment } = annotatedReplacement({
+				annotations: surveyReplacedAnnotations(nextTr.doc, item.from, item.to),
+				content: Fragment.fromArray(buildEmphasisInlineContent(nextTr.doc.type.schema, item.operation.replace, commentMark ? [commentMark] : []))
+			});
+			return nextTr.replaceWith(item.from, item.to, fragment);
 		}
 		const inserted = insertCleanText({
 			tr: nextTr,
@@ -2375,7 +2407,7 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 			text: replacement
 		});
 		nextTr = inserted.transaction;
-		if (commentMark && replacement.length > 0) nextTr = nextTr.addMark(item.from, inserted.end, commentMark);
+		if (commentMark && replacement.length > 0) nextTr = nextTr.addMark(inserted.start, inserted.end, commentMark);
 		return nextTr;
 	}
 	const insertionType = nextTr.doc.type.schema.marks["insertion"];
@@ -2465,11 +2497,15 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 						tr: nextTr,
 						from: step.at,
 						to: step.at,
-						text: step.text
+						text: step.text,
+						standsInFor: {
+							from: item.from,
+							to: item.to
+						}
 					});
 					nextTr = inserted.transaction;
-					nextTr = nextTr.addMark(step.at, inserted.end, insertionType.create(insAttrs));
-					if (commentMark) nextTr = nextTr.addMark(step.at, inserted.end, commentMark);
+					nextTr = nextTr.addMark(inserted.start, inserted.end, insertionType.create(insAttrs));
+					if (commentMark) nextTr = nextTr.addMark(inserted.start, inserted.end, commentMark);
 				}
 			}
 			return nextTr;
@@ -2480,11 +2516,15 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 			tr: nextTr,
 			from: item.to,
 			to: item.to,
-			text: replacement
+			text: replacement,
+			standsInFor: {
+				from: item.from,
+				to: item.to
+			}
 		});
 		nextTr = inserted.transaction;
-		nextTr = nextTr.addMark(item.to, inserted.end, insertionType.create(insAttrs));
-		if (commentMark) nextTr = nextTr.addMark(item.to, inserted.end, commentMark);
+		nextTr = nextTr.addMark(inserted.start, inserted.end, insertionType.create(insAttrs));
+		if (commentMark) nextTr = nextTr.addMark(inserted.start, inserted.end, commentMark);
 	}
 	if (item.to > item.from && deletionType) {
 		nextTr = nextTr.addMark(item.from, item.to, deletionType.create(delAttrs));

package/dist/ai-edits/headless.js

@@ -212,6 +212,7 @@ const sameReferencedNumberingLevels = ({ current, target, numId, levelsByNumId }
 	for (const level of levelsByNumId.get(numId) ?? []) {
 		const currentLevel = currentNumbering.getLevel(numId, level);
 		const targetLevel = targetNumbering.getLevel(numId, level);
+		if (currentLevel === null && targetLevel === null) continue;
 		if (!currentLevel || !targetLevel || canonicalJson(currentLevel) !== canonicalJson(targetLevel)) return false;
 	}
 	return true;
@@ -1543,7 +1544,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* same states, so the text now describes exactly what a save would write.
 	*/
 	storyBlocks(state, source) {
-		return state ? proseDocToBlocks(state.doc, source.content, this.baseDocument.package.styles, { emptyFieldResult: "authored" }) : source.content;
+		return state ? proseDocToBlocks(state.doc, source.content, this.baseDocument.package.styles) : source.content;
 	}
 	getHeaderFooterStoryText(story, source) {
 		const state = this.secondaryStoryStates.get(headerFooterStoryKey(story))?.state;

package/dist/compare/compare.js

@@ -15,7 +15,7 @@ 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 { CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, InvalidCompareDocxOptionsError, compareDocxSerializeError } from "./types.js";
 import { classifyGeometryMismatch, classifyProjectionMismatch, revisedFinalParagraphMarks } from "./verification.js";
 import { Result, panic } from "better-result";
 //#region src/compare/compare.ts
@@ -903,10 +903,7 @@ const serializeComparison = async ({ baseBuffer, baseCarriedRevisions, reviewer,
 	}));
 	return await Result.tryPromise({
 		try: async () => await withFixedPackageDates(await reviewer.toBuffer(), packageDate),
-		catch: (cause) => new CompareDocxSerializeError({
-			message: "The compared document could not be serialized.",
-			cause
-		})
+		catch: (cause) => compareDocxSerializeError("The compared document could not be serialized", cause)
 	});
 };
 /**

package/dist/compare/content-alignment.js

@@ -455,6 +455,27 @@ const MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS = 16384;
 const MAX_CONTENT_STRUCTURE_PROFILE_TOKENS = 64;
 const MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS = 256;
 const CONTENT_STRUCTURE_ANCHOR_MINIMUM_WORD_COUNT = 3;
+/** Four independent 32-bit lanes, so a digest collision needs four at once. */
+const CONTENT_DIGEST_SEEDS = [
+	2166136261,
+	2654435769,
+	2246822507,
+	3266489909
+];
+const CONTENT_DIGEST_PRIMES = [
+	16777619,
+	1540483477,
+	668265263,
+	374761393
+];
+const foldContentDigest = (lanes, text) => {
+	for (let index = 0; index < text.length; index++) {
+		const unit = text.charCodeAt(index);
+		for (let lane = 0; lane < lanes.length; lane++) lanes[lane] = Math.imul((lanes[lane] ?? 0) ^ unit, CONTENT_DIGEST_PRIMES[lane] ?? 1);
+	}
+	for (let lane = 0; lane < lanes.length; lane++) lanes[lane] = Math.imul((lanes[lane] ?? 0) ^ text.length, CONTENT_DIGEST_PRIMES[lane] ?? 1);
+};
+const renderContentDigest = (lanes, blockCount) => `${String(blockCount)}:${[...lanes].map((lane) => (lane >>> 0).toString(36)).join(":")}`;
 const createContentStructureProfile = ({ blocks, blockStructure, idStability, physicalCellCount, retainContainerIdentity = false }) => {
 	let containerIdentity = null;
 	if (retainContainerIdentity) if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) containerIdentity = { status: "unavailable" };
@@ -481,39 +502,34 @@ const createContentStructureProfile = ({ blocks, blockStructure, idStability, ph
 			if (idStability(block) === "stable") stableIds.push(block.id);
 		}
 	}
-	if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) return {
-		anchorTexts: [],
+	const lanes = Int32Array.from(CONTENT_DIGEST_SEEDS);
+	for (const block of blocks) foldContentDigest(lanes, JSON.stringify([
+		...blockStructure(block),
+		block.kind,
+		block.text
+	]));
+	const identity = {
 		blockIds,
 		containerIdentity,
-		exactSignature: null,
+		contentDigest: renderContentDigest(lanes, blocks.length),
 		physicalCellCount: physicalCellCount ?? null,
-		stableIds,
-		tokenCounts: null,
-		tokenCount: 0
+		stableIds
+	};
+	const overCap = {
+		...identity,
+		anchors: { status: "skipped-over-cap" },
+		tokens: { status: "skipped-over-cap" }
 	};
+	if (blocks.length > MAX_CONTENT_STRUCTURE_PROFILE_BLOCKS) return overCap;
 	let textCodeUnits = 0;
 	for (const block of blocks) {
-		if (block.kind.length > MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS || block.text.length > MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS - textCodeUnits) return {
-			anchorTexts: [],
-			blockIds,
-			containerIdentity,
-			exactSignature: null,
-			physicalCellCount: physicalCellCount ?? null,
-			stableIds,
-			tokenCounts: null,
-			tokenCount: 0
-		};
+		if (block.kind.length > MAX_CONTENT_STRUCTURE_PROFILE_KIND_CODE_UNITS || block.text.length > MAX_CONTENT_STRUCTURE_PROFILE_TEXT_CODE_UNITS - textCodeUnits) return overCap;
 		textCodeUnits += block.text.length;
 	}
 	const tokenCounts = /* @__PURE__ */ new Map();
 	const anchorTexts = /* @__PURE__ */ new Set();
 	let tokenCount = 0;
 	let tokensComplete = true;
-	const signature = blocks.map((block) => [
-		...blockStructure(block),
-		block.kind,
-		block.text
-	]);
 	for (const block of blocks) {
 		let blockWordCount = 0;
 		for (const match of block.text.matchAll(/\S+/gu)) {
@@ -530,24 +546,31 @@ const createContentStructureProfile = ({ blocks, blockStructure, idStability, ph
 		if (!tokensComplete) break;
 	}
 	return {
-		anchorTexts: [...anchorTexts],
-		blockIds,
-		containerIdentity,
-		exactSignature: JSON.stringify(signature),
-		physicalCellCount: physicalCellCount ?? null,
-		stableIds,
-		tokenCounts: tokensComplete ? tokenCounts : null,
-		tokenCount: tokensComplete ? tokenCount : 0
+		...identity,
+		anchors: {
+			status: "computed",
+			texts: [...anchorTexts]
+		},
+		tokens: tokensComplete ? {
+			status: "computed",
+			counts: tokenCounts,
+			total: tokenCount
+		} : { status: "skipped-over-cap" }
 	};
 };
+const UNKNOWN_CONTENT_STRUCTURE_SIMILARITY = { status: "unknown" };
 const contentStructureProfileSimilarity = (base, revised, workSession) => {
-	if (!base.tokenCounts || !revised.tokenCounts || base.tokenCount === 0 || revised.tokenCount === 0) return 0;
-	const [tokens, counterparts] = base.tokenCounts.size <= revised.tokenCounts.size ? [base.tokenCounts, revised.tokenCounts] : [revised.tokenCounts, base.tokenCounts];
-	if (tokens.size > workSession.remainingStructuralTokenLookups) return 0;
+	if (base.tokens.status === "skipped-over-cap" || revised.tokens.status === "skipped-over-cap") return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
+	if (base.tokens.total === 0 || revised.tokens.total === 0) return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
+	const [tokens, counterparts] = base.tokens.counts.size <= revised.tokens.counts.size ? [base.tokens.counts, revised.tokens.counts] : [revised.tokens.counts, base.tokens.counts];
+	if (tokens.size > workSession.remainingStructuralTokenLookups) return UNKNOWN_CONTENT_STRUCTURE_SIMILARITY;
 	workSession.remainingStructuralTokenLookups -= tokens.size;
 	let shared = 0;
 	for (const [token, count] of tokens) shared += Math.min(count, counterparts.get(token) ?? 0);
-	return 2 * shared / (base.tokenCount + revised.tokenCount);
+	return {
+		status: "measured",
+		value: 2 * shared / (base.tokens.total + revised.tokens.total)
+	};
 };
 const tableStructureProfile = (blocks, idStability) => {
 	const tableOrdinalByIndex = /* @__PURE__ */ new Map();
@@ -634,7 +657,6 @@ const uniqueExactContentSequencePairs = ({ baseKeys, revisedKeys }) => {
 	const uniqueIndexes = (keys) => {
 		const indexes = /* @__PURE__ */ new Map();
 		keys.forEach((key, index) => {
-			if (key === -1) return;
 			indexes.set(key, indexes.has(key) ? null : index);
 		});
 		return indexes;
@@ -731,16 +753,15 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 	}
 	const exactSignatureKeys = /* @__PURE__ */ new Map();
 	let nextExactSignatureKey = 0;
-	const internExactSignature = (signature) => {
-		if (signature === null) return -1;
-		const existing = exactSignatureKeys.get(signature);
+	const internContentDigest = (digest) => {
+		const existing = exactSignatureKeys.get(digest);
 		if (existing !== void 0) return existing;
 		const key = nextExactSignatureKey++;
-		exactSignatureKeys.set(signature, key);
+		exactSignatureKeys.set(digest, key);
 		return key;
 	};
-	const baseExactSignatureKeys = base.map(({ profile }) => internExactSignature(profile.exactSignature));
-	const revisedExactSignatureKeys = revised.map(({ profile }) => internExactSignature(profile.exactSignature));
+	const baseExactSignatureKeys = base.map(({ profile }) => internContentDigest(profile.contentDigest));
+	const revisedExactSignatureKeys = revised.map(({ profile }) => internContentDigest(profile.contentDigest));
 	let persistedPairs = /* @__PURE__ */ new Set();
 	if (base.some(({ profile }) => profile.containerIdentity !== null) || revised.some(({ profile }) => profile.containerIdentity !== null)) {
 		const exactPairs = uniqueExactContentSequencePairs({
@@ -781,16 +802,20 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 			if (!revisedItem) continue;
 			if (!canPair(baseItem, revisedItem)) continue;
 			const pairIndex = baseIndex * revised.length + revisedIndex;
-			const exact = baseExactSignatureKeys[baseIndex] !== -1 && baseExactSignatureKeys[baseIndex] === revisedExactSignatureKeys[revisedIndex];
+			const exact = baseExactSignatureKeys[baseIndex] === revisedExactSignatureKeys[revisedIndex];
 			const stable = stablePairs.has(pairIndex);
-			const profileSimilarity = exact ? 1 : contentStructureProfileSimilarity(baseItem.profile, revisedItem.profile, workSession);
-			const similar = Math.max(0, Math.min(1, profileSimilarity * similarityFactor(baseItem, revisedItem)));
+			const profileSimilarity = exact ? {
+				status: "measured",
+				value: 1
+			} : contentStructureProfileSimilarity(baseItem.profile, revisedItem.profile, workSession);
+			const similar = profileSimilarity.status === "measured" ? Math.max(0, Math.min(1, profileSimilarity.value * similarityFactor(baseItem, revisedItem))) : 0;
+			const similarEnough = profileSimilarity.status === "measured" && similar >= CONTENT_STRUCTURE_PAIR_SIMILARITY;
 			const stableAtSamePosition = stable && baseIndex === revisedIndex;
 			const persistedAtSamePosition = baseIndex === revisedIndex && provenanceTransitionAtSamePosition[baseIndex] === 1;
 			const shiftedPersisted = baseIndex !== revisedIndex && persistedPairs.has(pairIndex);
 			const persisted = persistedAtSamePosition || shiftedPersisted;
 			const soleStructuralSlot = pairSoleStructuralSlot && base.length === 1 && revised.length === 1;
-			if (!exact && !stableAtSamePosition && !persisted && !soleStructuralSlot && similar < CONTENT_STRUCTURE_PAIR_SIMILARITY) continue;
+			if (!exact && !stableAtSamePosition && !persisted && !soleStructuralSlot && !similarEnough) continue;
 			pairScores[pairIndex] = (stable ? stableWeight : 0) + (exact ? exactWeight : 0) + (shiftedPersisted && !stable && !exact ? secondaryWeight : 0) + (persistedAtSamePosition ? continuityBonus : 0) + Math.round(similar * CONTENT_STRUCTURE_SIMILARITY_SCALE) + (soleStructuralSlot ? 1 : 0);
 		}
 	}
@@ -1124,11 +1149,10 @@ const contentStructureEvidenceIndexes = (base, revised) => {
 	let nextExactKey = 0;
 	const internExactSignatures = (items) => {
 		for (const { profile } of items) {
-			if (profile.exactSignature === null) continue;
-			let key = exactKeys.get(profile.exactSignature);
+			let key = exactKeys.get(profile.contentDigest);
 			if (key === void 0) {
 				key = nextExactKey++;
-				exactKeys.set(profile.exactSignature, key);
+				exactKeys.set(profile.contentDigest, key);
 			}
 			exactKeyByProfile.set(profile, key);
 		}
@@ -1152,7 +1176,7 @@ const contentStructureEvidenceIndexes = (base, revised) => {
 					if (indexes.at(-1) !== itemIndex) indexes.push(itemIndex);
 				} else stableIndexes.set(id, [itemIndex]);
 			}
-			for (const text of profile.anchorTexts) {
+			for (const text of profile.anchors.status === "computed" ? profile.anchors.texts : []) {
 				const indexes = anchorTextIndexes.get(text);
 				if (indexes) {
 					if (indexes.at(-1) !== itemIndex) indexes.push(itemIndex);
@@ -1190,12 +1214,13 @@ const sortedIndexesLeaveRange = (indexes, start, end) => {
 const profileHasEvidenceOutsideRange = (profile, opposite, start, end) => {
 	const exactKey = opposite.exactKeyByProfile.get(profile);
 	if (exactKey !== void 0 && sortedIndexesLeaveRange(opposite.exactIndexes.get(exactKey), start, end)) return true;
-	if (profile.anchorTexts.some((text) => sortedIndexesLeaveRange(opposite.anchorTextIndexes.get(text), start, end))) return true;
+	if (profile.anchors.status === "computed" && profile.anchors.texts.some((text) => sortedIndexesLeaveRange(opposite.anchorTextIndexes.get(text), start, end))) return true;
 	return profile.stableIds.some((id) => sortedIndexesLeaveRange(opposite.stableIndexes.get(id), start, end));
 };
 const profilesShareContentAnchor = (base, revised) => {
-	const baseTexts = new Set(base.anchorTexts);
-	return revised.anchorTexts.some((text) => baseTexts.has(text));
+	if (base.anchors.status === "skipped-over-cap" || revised.anchors.status === "skipped-over-cap") return "unknown";
+	const baseTexts = new Set(base.anchors.texts);
+	return revised.anchors.texts.some((text) => baseTexts.has(text)) ? "shares" : "disjoint";
 };
 const isBodyDocumentSegment = (segment) => segment.kind === "body";
 const profileBodySegments = (segments, idStability) => segments.flatMap((segment) => isBodyDocumentSegment(segment) ? [{
@@ -1288,13 +1313,13 @@ const pairTableSegmentsInGaps = ({ base, revised, baseGaps, revisedGaps, trusted
 		const revisedEnd = revisedStart + revisedItems.length;
 		const baseHasExternalEvidence = new Set(baseItems.filter(({ profile }) => profileHasEvidenceOutsideRange(profile, evidence.revised, revisedStart, revisedEnd)).map(({ item }) => item));
 		const revisedHasExternalEvidence = new Set(revisedItems.filter(({ profile }) => profileHasEvidenceOutsideRange(profile, evidence.base, baseStart, baseEnd)).map(({ item }) => item));
-		const solePairHasContentAnchor = baseItems.length === 1 && revisedItems.length === 1 && profilesShareContentAnchor(baseItems.at(0)?.profile ?? panic("A sole base table has no profile"), revisedItems.at(0)?.profile ?? panic("A sole revised table has no profile"));
+		const solePairAnchorOverlap = baseItems.length === 1 && revisedItems.length === 1 ? profilesShareContentAnchor(baseItems.at(0)?.profile ?? panic("A sole base table has no profile"), revisedItems.at(0)?.profile ?? panic("A sole revised table has no profile")) : "disjoint";
 		const alignments = alignProfiledContentSequence({
 			base: baseItems,
 			revised: revisedItems,
 			workSession,
 			canPair: (baseItem, revisedItem) => !baseHasExternalEvidence.has(baseItem.item) && !revisedHasExternalEvidence.has(revisedItem.item),
-			pairSoleStructuralSlot: trustedBodyPairCount > 0 || solePairHasContentAnchor
+			pairSoleStructuralSlot: trustedBodyPairCount > 0 || solePairAnchorOverlap === "shares"
 		});
 		for (const alignment of alignments) {
 			if (alignment.type !== "pair") continue;

package/dist/compare/inline-atoms.js

@@ -29,6 +29,15 @@ const textBlocksOf = (doc) => {
 	});
 	return blocks;
 };
+/**
+* Clean-text offset nearest a document position.
+*
+* `buildCleanBlockText` returns one offset per character plus one for
+* end-of-block, so there is always an offset to land on. The result was typed
+* `number | null` and never was: the caller's refusal branch could not run,
+* while an empty `offsets` would have produced `-1` rather than the `null` the
+* type promised.
+*/
 const offsetAt = ({ offsets, position }) => {
 	let low = 0;
 	let high = offsets.length;
@@ -40,16 +49,33 @@ const offsetAt = ({ offsets, position }) => {
 	}
 	return Math.min(low, offsets.length - 1);
 };
+/**
+* Attributes a conversion mints for itself rather than reads from the package.
+*
+* `toProseDoc` salts text-box anchor ids with a per-load nonce so a pasted span
+* cannot hijack a real anchor. A comparison reads two independent conversions,
+* so a minted handle differs on every run, and a key holding one makes a
+* document differ from itself. Only document facts belong in a key.
+*
+* The guard against a node type gaining a minted attribute without being added
+* here is not this list but `compareIdentity.property.test.ts`, which compares
+* generated packages carrying each atom with themselves.
+*/
+const CONVERSION_LOCAL_ATTRS = { textBoxAnchor: ["anchorId"] };
+const documentFactAttrs = (node) => {
+	const local = CONVERSION_LOCAL_ATTRS[node.type.name];
+	if (!local) return node.attrs;
+	return Object.fromEntries(Object.entries(node.attrs).filter(([name]) => !local.includes(name)));
+};
 const atomKey = (node) => canonicalJson({
 	type: node.type.name,
-	attrs: node.attrs,
+	attrs: documentFactAttrs(node),
 	content: node.content.toJSON()
 });
 const atomBlockOf = ({ node, from }) => {
 	const clean = buildCleanBlockText(node, from, { fieldResults: "omitted" });
 	const supported = [];
 	const unsupportedTopology = [];
-	let unalignable = false;
 	node.descendants((child, relativePosition) => {
 		if (child.isText) return false;
 		if (!child.isInline || !child.isAtom) return true;
@@ -58,18 +84,14 @@ const atomBlockOf = ({ node, from }) => {
 			offsets: clean.offsets,
 			position
 		});
-		if (offset === null) {
-			unalignable = true;
-			return false;
-		}
 		if (!isSupportedAtom(child)) {
 			if (child.type.name === "renderedPageBreak") return false;
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(child.attrs)}`);
+			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
 			return false;
 		}
 		const prepared = prepareTargetInlineAtom(child);
 		if (!prepared) {
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(child.attrs)}`);
+			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
 			return false;
 		}
 		supported.push({
@@ -80,7 +102,7 @@ const atomBlockOf = ({ node, from }) => {
 		});
 		return false;
 	});
-	return unalignable ? null : {
+	return {
 		node,
 		from,
 		cleanText: clean.text,
@@ -108,15 +130,7 @@ const targetBlockIdLookup = (snapshot) => {
 		return owner?.id;
 	};
 };
-const atomBlocksOf = (doc) => {
-	const blocks = [];
-	for (const block of textBlocksOf(doc)) {
-		const atoms = atomBlockOf(block);
-		if (!atoms) return null;
-		blocks.push(atoms);
-	}
-	return blocks;
-};
+const atomBlocksOf = (doc) => textBlocksOf(doc).map(atomBlockOf);
 const sameBlockTopology = (left, right) => left.node.type === right.node.type && left.cleanText === right.cleanText && canonicalJson(left.unsupportedTopology) === canonicalJson(right.unsupportedTopology);
 const matchingAtomGroup = ({ live, target, liveStart, targetStart }) => {
 	if (live.length === target.length && live.every((atom, index) => atom.key === target[index]?.key)) return live.map((_, index) => [liveStart + index, targetStart + index]);
@@ -260,7 +274,7 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 	let sourceBlocks;
 	const liveBlocks = atomBlocksOf(reviewed.state.doc);
 	const targetBlocks = atomBlocksOf(targetDocument);
-	if (!liveBlocks || !targetBlocks || liveBlocks.length !== targetBlocks.length) return { status: "unalignable" };
+	if (liveBlocks.length !== targetBlocks.length) return { status: "unalignable" };
 	const actions = [];
 	for (const [index, live] of liveBlocks.entries()) {
 		const target = targetBlocks[index];
@@ -366,7 +380,7 @@ const sameInlineAtoms = (leftDocument, rightDocument) => {
 	if (!hasSupportedAtom(leftDocument) && !hasSupportedAtom(rightDocument)) return true;
 	const leftBlocks = atomBlocksOf(leftDocument);
 	const rightBlocks = atomBlocksOf(rightDocument);
-	if (!leftBlocks || !rightBlocks || leftBlocks.length !== rightBlocks.length) return false;
+	if (leftBlocks.length !== rightBlocks.length) return false;
 	return leftBlocks.every((left, index) => {
 		const right = rightBlocks[index];
 		if (left.supported.length === 0 && right?.supported.length === 0) return true;

package/dist/compare/scenario.js

@@ -1,6 +1,6 @@
 import { FolioDocxReviewer } from "../ai-edits/headless.js";
 import { createFolioAITextRangeHandle } from "../ai-edits/snapshot.js";
-import { CompareDocxParseError, CompareDocxSerializeError } from "./types.js";
+import { CompareDocxParseError, compareDocxSerializeError } from "./types.js";
 import { Result, panic } from "better-result";
 //#region src/compare/scenario.ts
 /**
@@ -252,10 +252,7 @@ const applyEditScript = async (base, script) => {
 	}
 	const serialized = await Result.tryPromise({
 		try: async () => await reviewer.toBuffer(),
-		catch: (cause) => new CompareDocxSerializeError({
-			message: "The edit script's target document could not be serialized.",
-			cause
-		})
+		catch: (cause) => compareDocxSerializeError("The edit script's target document could not be serialized", cause)
 	});
 	return serialized.isErr() ? Result.err(serialized.error) : Result.ok({
 		buffer: serialized.value,

package/dist/compare/types.d.ts

@@ -316,6 +316,14 @@ declare class CompareDocxSerializeError extends CompareDocxSerializeError_base<{
   message: string;
   cause: unknown;
 }> {}
+/**
+ * A serialize failure whose message names the reason.
+ *
+ * `cause` is structured context a caller can branch on, but a log line, a
+ * report and the corpus census read the message, and a constant one collapses
+ * every distinct save failure into a single undiagnosable row.
+ */
+declare const compareDocxSerializeError: (context: string, cause: unknown) => CompareDocxSerializeError;
 declare const CompareDocxFinalParagraphMarkError_base: import("better-result").TaggedErrorClass<"CompareDocxFinalParagraphMarkError">;
 /**
  * A container's final paragraph mark carries a revision, so the package would
@@ -335,4 +343,4 @@ declare class CompareDocxFinalParagraphMarkError extends CompareDocxFinalParagra
 }> {}
 type CompareDocxError = CompareDocxApplyError | CompareDocxFinalParagraphMarkError | CompareDocxOperationLimitError | CompareDocxParseError | CompareDocxRoundTripError | CompareDocxSerializeError | InvalidCompareDocxOptionsError;
 //#endregion
-export { COMPARE_REVISION_FORMATS, COMPARE_UNSUPPORTED_REASONS, CompareChange, CompareChangeLocation, CompareCompatibility, CompareDocxApplyError, CompareDocxError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxOptions, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, CompareFolioRequirement, CompareResult, CompareRevisionFormat, CompareUnsupportedPart, CompareUnsupportedReason, InvalidCompareDocxOptionsError };
+export { COMPARE_REVISION_FORMATS, COMPARE_UNSUPPORTED_REASONS, CompareChange, CompareChangeLocation, CompareCompatibility, CompareDocxApplyError, CompareDocxError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxOptions, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, CompareFolioRequirement, CompareResult, CompareRevisionFormat, CompareUnsupportedPart, CompareUnsupportedReason, InvalidCompareDocxOptionsError, compareDocxSerializeError };

package/dist/compare/types.js

@@ -31,6 +31,17 @@ var CompareDocxRoundTripError = class extends TaggedError("CompareDocxRoundTripE
 var CompareDocxOperationLimitError = class extends TaggedError("CompareDocxOperationLimitError") {};
 var CompareDocxSerializeError = class extends TaggedError("CompareDocxSerializeError") {};
 /**
+* A serialize failure whose message names the reason.
+*
+* `cause` is structured context a caller can branch on, but a log line, a
+* report and the corpus census read the message, and a constant one collapses
+* every distinct save failure into a single undiagnosable row.
+*/
+const compareDocxSerializeError = (context, cause) => new CompareDocxSerializeError({
+	message: `${context}: ${cause instanceof Error ? cause.message : String(cause)}`,
+	cause
+});
+/**
 * A container's final paragraph mark carries a revision, so the package would
 * not open, or would open carrying one no reader can resolve.
 *
@@ -43,4 +54,4 @@ var CompareDocxSerializeError = class extends TaggedError("CompareDocxSerializeE
 */
 var CompareDocxFinalParagraphMarkError = class extends TaggedError("CompareDocxFinalParagraphMarkError") {};
 //#endregion
-export { COMPARE_REVISION_FORMATS, COMPARE_UNSUPPORTED_REASONS, CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError };
+export { COMPARE_REVISION_FORMATS, COMPARE_UNSUPPORTED_REASONS, CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError, compareDocxSerializeError };