@stll/folio-core 0.50.0 → 0.52.0

package/dist/ai-edits/word-diff.js

@@ -836,6 +836,137 @@ const orderDeletionsFirst = (runs) => {
 	flush();
 	return ordered;
 };
+const WORD_CHARACTER = /^[\p{L}\p{N}\p{M}]$/u;
+const LINE_BREAK = /^[\n\r\p{Zl}\p{Zp}]$/u;
+/**
+* How well a change edge between two code points reads, after
+* diff-match-patch's semantic score: the string's edge (an empty side), then
+* a line break, then the gap after a sentence or clause mark, then any space,
+* then any other mark; inside a word is worst.
+*/
+const boundaryScore = (previous, next) => {
+	if (previous.length === 0 || next.length === 0) return 6;
+	if (LINE_BREAK.test(previous) || LINE_BREAK.test(next)) return 4;
+	const previousIsSpace = WHITESPACE.test(previous);
+	const nextIsSpace = WHITESPACE.test(next);
+	if (!previousIsSpace && !WORD_CHARACTER.test(previous) && nextIsSpace) return 3;
+	if (previousIsSpace || nextIsSpace) return 2;
+	return WORD_CHARACTER.test(previous) && WORD_CHARACTER.test(next) ? 0 : 1;
+};
+/** True when `position` falls between the two halves of a surrogate pair. */
+const splitsSurrogatePair = (text, position) => {
+	const low = text.charCodeAt(position);
+	const high = text.charCodeAt(position - 1);
+	return low >= 56320 && low <= 57343 && high >= 55296 && high <= 56319;
+};
+/**
+* Where, among the lossless positions of one change, it reads best. The
+* change may slide by one character whenever the character it gives up
+* equals the one it takes on, which keeps both strings intact. Only the
+* window decides the result, so an insertion and the deletion that undoes it
+* land on the same text; the leftmost of equally good positions wins.
+*/
+const bestSlideStart = (window) => {
+	const { text, start, length, minimumStart, maximumEnd } = window;
+	const scoreAt = (position) => boundaryScore(position === 0 ? window.outsideBefore : codePointBefore(text, position), position === text.length ? window.outsideAfter : codePointAt(text, position));
+	let leftmost = start;
+	while (leftmost > minimumStart && text[leftmost - 1] === text[leftmost + length - 1]) leftmost--;
+	let best = start;
+	let bestScore = -1;
+	for (let candidate = leftmost; candidate + length <= maximumEnd; candidate++) {
+		const end = candidate + length;
+		if (!splitsSurrogatePair(text, candidate) && !splitsSurrogatePair(text, end)) {
+			const startScore = scoreAt(candidate);
+			const endScore = scoreAt(end);
+			if (!(candidate !== start && (startScore === 0 || endScore === 0)) && startScore + endScore > bestScore) {
+				best = candidate;
+				bestScore = startScore + endScore;
+			}
+		}
+		if (end === text.length || text[candidate] !== text[end]) break;
+	}
+	return best;
+};
+/**
+* Whether a change may end up directly beside `neighbour` once the equality
+* between them empties: always beside nothing, an equality or its own kind,
+* and a deletion may precede an insertion; an insertion before a deletion
+* would break deletion-first order.
+*/
+const mayAbut = (first, second) => first === void 0 || second === void 0 || first === "equal" || second === "equal" || first === second || first === "del" && second === "ins";
+/** The code point nearest `index`, walking by `step`, on the side `type` belongs to. */
+const sideCodePoint = (segments, { from, step }, type) => {
+	for (let index = from; index >= 0 && index < segments.length; index += step) {
+		const segment = segments[index];
+		if (segment === void 0 || segment.text.length === 0) continue;
+		if (segment.type === "equal" || segment.type === type) return step === 1 ? codePointAt(segment.text, 0) : codePointBefore(segment.text, segment.text.length);
+	}
+	return "";
+};
+const mergeAdjacentSegments = (segments) => {
+	const merged = [];
+	for (const segment of segments) {
+		const last = merged.at(-1);
+		if (segment.text.length === 0) continue;
+		if (last?.type === segment.type) {
+			last.text += segment.text;
+			continue;
+		}
+		merged.push(segment);
+	}
+	return merged;
+};
+/**
+* Slide every insertion or deletion that sits between equalities to the
+* position that reads best.
+*
+* An LCS places a change arbitrarily among equally long alignments: an
+* appended sentence can be marked as `". New sentence"` before the old
+* sentence's full stop, not `" New sentence."` after it. The redline then
+* marks a stop the author never touched and leaves the new sentence's own
+* unmarked. Sliding moves only where a change's edges fall, so both strings
+* still reconstruct.
+*/
+const slideChangesToReadableBoundaries = (segments) => {
+	const slid = [
+		{
+			type: "equal",
+			text: ""
+		},
+		...segments.map((segment) => ({ ...segment })),
+		{
+			type: "equal",
+			text: ""
+		}
+	];
+	for (let index = 1; index < slid.length - 1; index++) {
+		const change = slid[index];
+		const previous = slid[index - 1];
+		const next = slid[index + 1];
+		if (change === void 0 || previous === void 0 || next === void 0 || change.type === "equal" || previous.type !== "equal" || next.type !== "equal") continue;
+		const text = previous.text + change.text + next.text;
+		const start = bestSlideStart({
+			text,
+			start: previous.text.length,
+			length: change.text.length,
+			minimumStart: mayAbut(slid[index - 2]?.type, change.type) ? 0 : 1,
+			maximumEnd: mayAbut(change.type, slid[index + 2]?.type) ? text.length : text.length - 1,
+			outsideBefore: sideCodePoint(slid, {
+				from: index - 2,
+				step: -1
+			}, change.type),
+			outsideAfter: sideCodePoint(slid, {
+				from: index + 2,
+				step: 1
+			}, change.type)
+		});
+		const end = start + change.text.length;
+		previous.text = text.slice(0, start);
+		change.text = text.slice(start, end);
+		next.text = text.slice(end);
+	}
+	return mergeAdjacentSegments(slid);
+};
 const wholeStringReplacement = (before, after) => {
 	const segments = [];
 	if (before.length > 0) segments.push({
@@ -903,7 +1034,9 @@ const diffWordSegmentsWithBudget = (before, after, options, budget) => {
 		const monotoneRuns = alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection);
 		marked = whitespaceIsSignificant ? separateWhitespaceChanges(monotoneRuns) : monotoneRuns;
 	}
-	return toSegments(orderDeletionsFirst(marked));
+	const segments = toSegments(orderDeletionsFirst(marked));
+	const equalRunsAreExact = requestedNormalization.case !== true && requestedNormalization.whitespace !== true;
+	return granularity === "word" && equalRunsAreExact ? slideChangesToReadableBoundaries(segments) : segments;
 };
 /**
 * One internal comparison/apply scope. Every diff shares the same quadratic

package/dist/compare/content-alignment.js

@@ -260,6 +260,44 @@ const pairByUniqueExactText = ({ base, revised, baseFrom, baseTo, revisedFrom, r
 	}
 	return pairs.toReversed();
 };
+/**
+* Unique exact text anchors, then again inside every sub-gap they leave:
+* wording repeated elsewhere in a document is still identity evidence within
+* the one gap where it is unique, so a section's pairing does not depend on
+* whether a neighbouring section happens to repeat it. Each nested pass is
+* charged to the structural allowance; a refused pass leaves its sub-gap to
+* the similarity pairing.
+*/
+const pairByNestedUniqueExactText = ({ workSession, ...gap }) => {
+	const anchors = [];
+	const pending = [gap];
+	for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+		const found = pairByUniqueExactText(current);
+		if (found.length === 0) continue;
+		anchors.push(...found);
+		let baseFrom = current.baseFrom;
+		let revisedFrom = current.revisedFrom;
+		for (const anchor of [...found, {
+			baseIndex: current.baseTo,
+			revisedIndex: current.revisedTo
+		}]) {
+			const size = anchor.baseIndex - baseFrom + (anchor.revisedIndex - revisedFrom);
+			if (anchor.baseIndex > baseFrom && anchor.revisedIndex > revisedFrom && size <= workSession.remainingStructuralTokenLookups) {
+				workSession.remainingStructuralTokenLookups -= size;
+				pending.push({
+					...current,
+					baseFrom,
+					baseTo: anchor.baseIndex,
+					revisedFrom,
+					revisedTo: anchor.revisedIndex
+				});
+			}
+			baseFrom = anchor.baseIndex + 1;
+			revisedFrom = anchor.revisedIndex + 1;
+		}
+	}
+	return anchors.toSorted((left, right) => left.baseIndex - right.baseIndex || left.revisedIndex - right.revisedIndex);
+};
 const pairsInAnchorGaps = ({ baseLength, revisedLength, anchors, pairGap }) => {
 	const pairs = [];
 	let baseFrom = 0;
@@ -312,9 +350,122 @@ const crossedExactTextBlocks = ({ base, revised, anchors, canPair }) => {
 		revised: crossedRevised
 	};
 };
+/**
+* Minimum multiset Dice similarity for two blocks to pair inside a gap. At
+* 0.5 a paragraph still pairs after gaining up to twice its own length
+* (2n / (n + 3n)); below it, more of the pair would read as changed than
+* kept, which a removal beside an insertion says better.
+*/
+const GAP_PAIR_SIMILARITY_THRESHOLD = .5;
+/**
+* Gap similarities are compared as integers, so a tie is exact rather than an
+* accident of floating-point summation, and a tie-break can sit below the
+* smallest similarity step.
+*/
+const GAP_PAIR_SIMILARITY_SCALE = 1e3;
+/**
+* Words as case-folded runs of letters, marks and digits: punctuation glued to
+* a word ("paragraph." against "paragraph") and a capital at a sentence start
+* would otherwise count a kept word as changed.
+*/
+const gapBlockTokens = (text) => {
+	const counts = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const match of text.toLowerCase().matchAll(/[\p{L}\p{M}\p{N}]+/gu)) {
+		total += 1;
+		counts.set(match[0], (counts.get(match[0]) ?? 0) + 1);
+	}
+	return {
+		counts,
+		total
+	};
+};
+const gapBlockSimilarity = (base, revised, workSession) => {
+	if (base.total === 0 && revised.total === 0) return {
+		status: "measured",
+		value: 1
+	};
+	if (base.total === 0 || revised.total === 0) return {
+		status: "measured",
+		value: GAP_PAIR_SIMILARITY_THRESHOLD
+	};
+	const [tokens, counterparts] = base.counts.size <= revised.counts.size ? [base.counts, revised.counts] : [revised.counts, base.counts];
+	if (tokens.size > workSession.remainingStructuralTokenLookups) return { status: "budget-exceeded" };
+	workSession.remainingStructuralTokenLookups -= tokens.size;
+	let shared = 0;
+	for (const [token, count] of tokens) shared += Math.min(count, counterparts.get(token) ?? 0);
+	return {
+		status: "measured",
+		value: 2 * shared / (base.total + revised.total)
+	};
+};
+/**
+* The order-preserving pairs of one gap that maximise their summed
+* similarity, each at least `GAP_PAIR_SIMILARITY_THRESHOLD`; offsets are into
+* the gap's slices. Pairing by position instead fuses an inserted block with
+* the neighbour it pushed down, and every block after it with the next one's
+* wording. Null when the work budget refuses the gap.
+*/
+const pairGapBySimilarity = ({ base, revised, canPair, workSession }) => {
+	const baseCount = base.length;
+	const revisedCount = revised.length;
+	if (!claimFolioContentAlignmentCells(baseCount, revisedCount, workSession)) return null;
+	const revisedTokens = revised.map((block) => gapBlockTokens(block.block.text));
+	const similarityStep = Math.min(baseCount, revisedCount) + 1;
+	const similarity = new Float64Array(baseCount * revisedCount).fill(-1);
+	const candidateBase = /* @__PURE__ */ new Set();
+	const candidateRevised = /* @__PURE__ */ new Set();
+	for (const [baseOffset, baseBlock] of base.entries()) {
+		const baseTokens = gapBlockTokens(baseBlock.block.text);
+		for (const [revisedOffset, revisedBlock] of revised.entries()) {
+			if (!canPair(baseBlock, revisedBlock)) continue;
+			const tokens = revisedTokens[revisedOffset] ?? panic("A gap block has no token profile");
+			const measured = baseBlock.block.text === revisedBlock.block.text ? {
+				status: "measured",
+				value: 1
+			} : gapBlockSimilarity(baseTokens, tokens, workSession);
+			if (measured.status === "budget-exceeded") return null;
+			if (measured.value >= GAP_PAIR_SIMILARITY_THRESHOLD) {
+				const sameLabel = baseBlock.block.displayLabel !== void 0 && baseBlock.block.displayLabel === revisedBlock.block.displayLabel;
+				similarity[baseOffset * revisedCount + revisedOffset] = Math.round(measured.value * GAP_PAIR_SIMILARITY_SCALE) * similarityStep + (sameLabel ? 1 : 0);
+				candidateBase.add(baseOffset);
+				candidateRevised.add(revisedOffset);
+			}
+		}
+	}
+	const width = revisedCount + 1;
+	const scores = new Float64Array((baseCount + 1) * width);
+	const cellSimilarity = (baseOffset, revisedOffset) => similarity[baseOffset * revisedCount + revisedOffset] ?? -1;
+	const score = (row, column) => scores[row * width + column] ?? 0;
+	for (let row = baseCount - 1; row >= 0; row--) for (let column = revisedCount - 1; column >= 0; column--) {
+		const cell = cellSimilarity(row, column);
+		scores[row * width + column] = Math.max(score(row + 1, column), score(row, column + 1), cell < 0 ? 0 : score(row + 1, column + 1) + cell);
+	}
+	const pairs = [];
+	let row = 0;
+	let column = 0;
+	while (row < baseCount && column < revisedCount) {
+		const cell = cellSimilarity(row, column);
+		if (cell >= 0 && score(row, column) === score(row + 1, column + 1) + cell) {
+			pairs.push({
+				baseIndex: row,
+				revisedIndex: column
+			});
+			row += 1;
+			column += 1;
+		} else if (score(row, column) === score(row + 1, column)) row += 1;
+		else column += 1;
+	}
+	return {
+		pairs,
+		candidateBase,
+		candidateRevised
+	};
+};
 const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 	const stableIdMismatch = options.stableIdMismatch ?? "separate";
 	const idStability = options.idStability ?? folioContentIdStability;
+	const workSession = options.workSession ?? createFolioContentAlignmentWorkSession();
 	const prepared = prepareAlignmentBlocks({
 		baseBlocks,
 		revisedBlocks,
@@ -335,14 +486,15 @@ const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 		baseLength: prepared.base.length,
 		revisedLength: prepared.revised.length,
 		anchors: stableIdAnchors,
-		pairGap: (baseFrom, baseTo, revisedFrom, revisedTo) => pairByUniqueExactText({
+		pairGap: (baseFrom, baseTo, revisedFrom, revisedTo) => pairByNestedUniqueExactText({
 			base: prepared.base,
 			revised: prepared.revised,
 			baseFrom,
 			baseTo,
 			revisedFrom,
 			revisedTo,
-			canPair
+			canPair,
+			workSession
 		})
 	});
 	const exactAndStableAnchors = [...stableIdAnchors, ...exactTextAnchors].toSorted((left, right) => left.baseIndex - right.baseIndex || left.revisedIndex - right.revisedIndex);
@@ -368,12 +520,13 @@ const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 		canPair
 	});
 	const events = [];
+	const fusesACrossing = (baseBlock, revisedBlock) => baseBlock.block.text !== revisedBlock.block.text && crossed.base.has(baseBlock.index) && crossed.revised.has(revisedBlock.index);
 	const emitPositionalGap = (baseFrom, baseTo, revisedFrom, revisedTo) => {
 		const pairedCount = Math.min(baseTo - baseFrom, revisedTo - revisedFrom);
 		for (let offset = 0; offset < pairedCount; offset++) {
 			const baseBlock = prepared.base[baseFrom + offset];
 			const revisedBlock = prepared.revised[revisedFrom + offset];
-			if (baseBlock && revisedBlock) if (baseBlock.block.text !== revisedBlock.block.text && crossed.base.has(baseBlock.index) && crossed.revised.has(revisedBlock.index) || !canPair(baseBlock, revisedBlock)) {
+			if (baseBlock && revisedBlock) if (fusesACrossing(baseBlock, revisedBlock) || !canPair(baseBlock, revisedBlock)) {
 				events.push({
 					type: "baseOnly",
 					block: baseBlock.block
@@ -403,10 +556,72 @@ const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 			});
 		}
 	};
+	/**
+	* A gap's blocks pair by similarity, whether or not its sides are equal in
+	* length: an equal gap can hide an insertion beside a deletion, and pairing
+	* it by position reads each kept block as a rewrite of its neighbour. The
+	* similar pairs anchor the rest; blocks between two anchors pair by position
+	* only when neither side offered any candidate and the counts match, which
+	* reads a block rewritten beyond recognition as the modification it is.
+	*/
+	const emitGap = (baseFrom, baseTo, revisedFrom, revisedTo) => {
+		const pairing = pairGapBySimilarity({
+			base: prepared.base.slice(baseFrom, baseTo),
+			revised: prepared.revised.slice(revisedFrom, revisedTo),
+			canPair: (baseBlock, revisedBlock) => !fusesACrossing(baseBlock, revisedBlock) && canPair(baseBlock, revisedBlock),
+			workSession
+		});
+		if (pairing === null) {
+			emitPositionalGap(baseFrom, baseTo, revisedFrom, revisedTo);
+			return;
+		}
+		const { pairs, candidateBase, candidateRevised } = pairing;
+		let baseCursor = baseFrom;
+		let revisedCursor = revisedFrom;
+		const hasCandidate = (candidates, from, to) => {
+			for (let offset = from; offset < to; offset++) if (candidates.has(offset)) return true;
+			return false;
+		};
+		const emitUnpairedUntil = (baseEnd, revisedEnd) => {
+			if (baseEnd - baseCursor === revisedEnd - revisedCursor && !hasCandidate(candidateBase, baseCursor - baseFrom, baseEnd - baseFrom) && !hasCandidate(candidateRevised, revisedCursor - revisedFrom, revisedEnd - revisedFrom)) {
+				emitPositionalGap(baseCursor, baseEnd, revisedCursor, revisedEnd);
+				baseCursor = baseEnd;
+				revisedCursor = revisedEnd;
+				return;
+			}
+			for (; baseCursor < baseEnd; baseCursor++) {
+				const block = prepared.base[baseCursor]?.block;
+				if (block) events.push({
+					type: "baseOnly",
+					block
+				});
+			}
+			for (; revisedCursor < revisedEnd; revisedCursor++) {
+				const block = prepared.revised[revisedCursor]?.block;
+				if (block) events.push({
+					type: "revisedOnly",
+					block
+				});
+			}
+		};
+		for (const pair of pairs) {
+			emitUnpairedUntil(baseFrom + pair.baseIndex, revisedFrom + pair.revisedIndex);
+			const baseBlock = prepared.base[baseCursor]?.block;
+			const revisedBlock = prepared.revised[revisedCursor]?.block;
+			if (baseBlock && revisedBlock) events.push({
+				type: "pair",
+				baseBlock,
+				revisedBlock
+			});
+			baseCursor += 1;
+			revisedCursor += 1;
+		}
+		emitUnpairedUntil(baseTo, revisedTo);
+	};
 	let baseCursor = 0;
 	let revisedCursor = 0;
 	for (const anchor of anchors) {
-		emitPositionalGap(baseCursor, anchor.baseIndex, revisedCursor, anchor.revisedIndex);
+		emitGap(baseCursor, anchor.baseIndex, revisedCursor, anchor.revisedIndex);
 		const baseBlock = prepared.base[anchor.baseIndex]?.block;
 		const revisedBlock = prepared.revised[anchor.revisedIndex]?.block;
 		if (baseBlock && revisedBlock) events.push({
@@ -417,7 +632,7 @@ const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 		baseCursor = anchor.baseIndex + 1;
 		revisedCursor = anchor.revisedIndex + 1;
 	}
-	emitPositionalGap(baseCursor, prepared.base.length, revisedCursor, prepared.revised.length);
+	emitGap(baseCursor, prepared.base.length, revisedCursor, prepared.revised.length);
 	return events;
 };
 const alignFolioContentBlocks = (baseBlocks, revisedBlocks, options = {}) => alignFolioContentBlocksInScope(baseBlocks, revisedBlocks, {

package/dist/compare/content.d.ts

@@ -186,6 +186,7 @@ type ParagraphMarkPlan<Block extends FolioContentBlock> = {
   revisedBlock: Block;
   separator: string;
 };
+/** Plans keyed by their first step; each consumes the step after it. */
 declare const detectFolioContentParagraphMarkPlans: <Block extends FolioContentBlock>(steps: readonly FolioContentAlignmentStep<Block>[]) => ReadonlyMap<number, ParagraphMarkPlan<Block>>;
 type MovePair<Block extends FolioContentBlock> = {
   baseBlock: Block;

package/dist/compare/content.js

@@ -431,30 +431,61 @@ const separatorBetween = (whole, head, tail) => {
 	const separator = whole.slice(head.length, whole.length - tail.length);
 	return separator.length === 0 || /^\s+$/u.test(separator) ? separator : null;
 };
+const splitPlan = ({ baseBlock, head, tail }) => {
+	const separator = separatorBetween(baseBlock.text, head.text, tail.text);
+	return separator !== null && contentBlocksShareContainer(head, tail) ? {
+		type: "split",
+		baseBlock,
+		revisedBlocks: [head, tail],
+		offset: head.text.length,
+		separator
+	} : null;
+};
+const mergePlan = ({ revisedBlock, head, tail }) => {
+	const separator = separatorBetween(revisedBlock.text, head.text, tail.text);
+	return separator !== null && contentBlocksShareContainer(head, tail) ? {
+		type: "merge",
+		baseBlocks: [head, tail],
+		revisedBlock,
+		separator
+	} : null;
+};
+/**
+* A pair next to a one-sided block its text spells together with the pair's
+* other side. Alignment pairs a split paragraph with whichever half reads more
+* like it, so the unpaired half may stand before the pair or after it.
+*/
+const paragraphMarkPlan = (step, next) => {
+	if (step.type === "pair" && next.type === "revisedOnly") return splitPlan({
+		baseBlock: step.baseBlock,
+		head: step.revisedBlock,
+		tail: next.block
+	});
+	if (step.type === "pair" && next.type === "baseOnly") return mergePlan({
+		revisedBlock: step.revisedBlock,
+		head: step.baseBlock,
+		tail: next.block
+	});
+	if (step.type === "revisedOnly" && next.type === "pair") return splitPlan({
+		baseBlock: next.baseBlock,
+		head: step.block,
+		tail: next.revisedBlock
+	});
+	if (step.type === "baseOnly" && next.type === "pair") return mergePlan({
+		revisedBlock: next.revisedBlock,
+		head: step.block,
+		tail: next.baseBlock
+	});
+	return null;
+};
+/** Plans keyed by their first step; each consumes the step after it. */
 const detectFolioContentParagraphMarkPlans = (steps) => {
 	const plans = /* @__PURE__ */ new Map();
 	for (const [index, step] of steps.entries()) {
 		const next = steps[index + 1];
-		if (step.type !== "pair" || next === void 0) continue;
-		if (next.type === "revisedOnly") {
-			const separator = separatorBetween(step.baseBlock.text, step.revisedBlock.text, next.block.text);
-			if (separator !== null && contentBlocksShareContainer(step.revisedBlock, next.block)) plans.set(index, {
-				type: "split",
-				baseBlock: step.baseBlock,
-				revisedBlocks: [step.revisedBlock, next.block],
-				offset: step.revisedBlock.text.length,
-				separator
-			});
-			continue;
-		}
-		if (next.type !== "baseOnly") continue;
-		const separator = separatorBetween(step.revisedBlock.text, step.baseBlock.text, next.block.text);
-		if (separator !== null && contentBlocksShareContainer(step.baseBlock, next.block)) plans.set(index, {
-			type: "merge",
-			baseBlocks: [step.baseBlock, next.block],
-			revisedBlock: step.revisedBlock,
-			separator
-		});
+		if (next === void 0 || plans.has(index - 1)) continue;
+		const plan = paragraphMarkPlan(step, next);
+		if (plan !== null) plans.set(index, plan);
 	}
 	return plans;
 };

package/dist/compare/inline-provenance.js

@@ -3,7 +3,7 @@ import { expectHyperlinkMarkAttrs, expectRunPropertyChangeMarkAttrs, expectTable
 import { getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
 import { applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText } from "../prosemirror/runFormattingInlineCarriers.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
-import { paragraphRunStyleContextAt } from "../prosemirror/runStyleFormatting.js";
+import { nearestParagraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
 import { isTableCellRetainedInReviewView } from "../prosemirror/tableCellRevisionVisibility.js";
 import { canonicalJson } from "../utils/canonicalJson.js";
 //#region src/compare/inline-provenance.ts
@@ -19,10 +19,11 @@ const hyperlinkIdentity = (node) => {
 	});
 };
 const isInserted = (node) => node.marks.some(({ type }) => type.name === "insertion");
-const carrierRepresentations = (carrier) => carrier.representations.map((representation) => ({
+const carrierRepresentations = ({ carrier, paragraph }) => carrier.representations.map((representation) => ({
 	...representation,
 	from: representation.position,
-	to: representation.position + representation.node.nodeSize
+	to: representation.position + representation.node.nodeSize,
+	paragraph
 }));
 const targetBlockIdLookup = (anchors) => {
 	const ordered = Object.values(anchors).toSorted((left, right) => left.from - right.from || left.to - right.to);
@@ -53,7 +54,13 @@ const collectCarriers = ({ doc, targetSnapshot }) => {
 	const carriers = [];
 	const targetBlockIdAt = targetSnapshot ? targetBlockIdLookup(targetSnapshot.anchors) : void 0;
 	let unanchoredTargetCarrier = false;
+	const openParagraphs = [];
 	doc.descendants((node, position) => {
+		while ((openParagraphs.at(-1)?.end ?? Number.POSITIVE_INFINITY) <= position) openParagraphs.pop();
+		if (node.type.name === "paragraph") openParagraphs.push({
+			node,
+			end: position + node.nodeSize
+		});
 		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && !isTableCellRetainedInReviewView(expectTableCellAttrs(node).cellMarker?.kind, "final")) return false;
 		if (!node.isInline) return true;
 		const carrier = expandRunFormattingCarrier(node, position);
@@ -69,6 +76,7 @@ const collectCarriers = ({ doc, targetSnapshot }) => {
 		}
 		carriers.push({
 			carrier,
+			paragraph: openParagraphs.at(-1)?.node ?? null,
 			text: runFormattingCarrierReviewText(carrier),
 			targetBlockId
 		});
@@ -106,8 +114,8 @@ const matchCarrierStreams = ({ live, target }) => {
 		const targetIsText = targetCarrier.carrier.disposition === "text-run";
 		if (!liveIsText || !targetIsText) {
 			if (liveOffset !== 0 || targetOffset !== 0 || !sameCarrierShape(liveCarrier, targetCarrier)) return null;
-			const liveRepresentations = carrierRepresentations(liveCarrier.carrier);
-			const targetRepresentations = carrierRepresentations(targetCarrier.carrier);
+			const liveRepresentations = carrierRepresentations(liveCarrier);
+			const targetRepresentations = carrierRepresentations(targetCarrier);
 			for (const [index, liveRepresentation] of liveRepresentations.entries()) {
 				const targetRepresentation = targetRepresentations.at(index);
 				if (!targetRepresentation) return null;
@@ -123,8 +131,8 @@ const matchCarrierStreams = ({ live, target }) => {
 		}
 		const sharedLength = Math.min(liveText.length, targetText.length);
 		if (sharedLength === 0 || liveText.slice(0, sharedLength) !== targetText.slice(0, sharedLength)) return null;
-		const liveRepresentation = carrierRepresentations(liveCarrier.carrier).at(0);
-		const targetRepresentation = carrierRepresentations(targetCarrier.carrier).at(0);
+		const liveRepresentation = carrierRepresentations(liveCarrier).at(0);
+		const targetRepresentation = carrierRepresentations(targetCarrier).at(0);
 		if (!liveRepresentation || !targetRepresentation) return null;
 		matched.push({
 			live: {
@@ -152,12 +160,8 @@ const matchCarrierStreams = ({ live, target }) => {
 	}
 	return matched;
 };
-const authoredFormattingAt = ({ doc, representation, styleResolver }) => readAuthoredRunFormatting({
-	context: paragraphRunStyleContextAt({
-		doc,
-		pos: representation.from,
-		styleResolver
-	}),
+const authoredFormattingAt = ({ representation, styleResolver }) => readAuthoredRunFormatting({
+	context: nearestParagraphRunStyleContext(representation.paragraph, styleResolver),
 	marks: representation.node.marks,
 	styleResolver
 });
@@ -190,12 +194,10 @@ const matchInlineProvenance = ({ state, targetSnapshot, revisionStamp, originalR
 	const planned = [];
 	for (const segment of matched) {
 		const liveFormatting = authoredFormattingAt({
-			doc: state.doc,
 			representation: segment.live,
 			styleResolver: liveStyleResolver
 		});
 		const targetFormatting = authoredFormattingAt({
-			doc: targetDocument,
 			representation: segment.target,
 			styleResolver: targetStyleResolver
 		});
@@ -220,11 +222,7 @@ const matchInlineProvenance = ({ state, targetSnapshot, revisionStamp, originalR
 	let nextRevisionId = revisionStamp.idSeed;
 	const changedTargetBlockIds = /* @__PURE__ */ new Set();
 	for (const change of planned.toReversed()) {
-		const context = paragraphRunStyleContextAt({
-			doc: state.doc,
-			pos: change.live.from,
-			styleResolver: liveStyleResolver
-		});
+		const context = nearestParagraphRunStyleContext(change.live.paragraph, liveStyleResolver);
 		const formattingMarks = reconcileRunFormattingMarks({
 			authoredFormatting: change.formatting,
 			context,
@@ -321,11 +319,9 @@ const sameAuthoredInlineProvenance = (baseSnapshot, targetSnapshot) => {
 	const baseStyleResolver = styleResolverOf(baseSnapshot);
 	const targetStyleResolver = styleResolverOf(targetSnapshot);
 	return matched.every(({ live, target }) => hyperlinkIdentity(live.node) === hyperlinkIdentity(target.node) && canonicalJson(authoredFormattingAt({
-		doc: baseDocument,
 		representation: live,
 		styleResolver: baseStyleResolver
 	})) === canonicalJson(authoredFormattingAt({
-		doc: targetDocument,
 		representation: target,
 		styleResolver: targetStyleResolver
 	})));

package/dist/compare/section-boundary-properties.js

@@ -108,9 +108,22 @@ const boundaryParagraphEntriesOf = (document) => {
 	if (!children) return null;
 	return children.flatMap((child) => child.type === "paragraph" ? [child.paragraph] : []);
 };
+const hasSectionEndpoint = (document) => {
+	let found = false;
+	document.forEach((node) => {
+		if (node.type.name === "paragraph" && expectParagraphAttrs(node)._sectionProperties !== void 0) found = true;
+	});
+	return found;
+};
 /** Stage section deltas after document operations, against the accepted projection. */
 const stageSectionBoundaryProperties = ({ state, target, originalRevisionIdSeed, revisionStamp, author, maxRanges, mapTargetProperties }) => {
 	if (!Number.isSafeInteger(maxRanges) || maxRanges < 0) return { status: "budget-exceeded" };
+	if (!hasSectionEndpoint(target)) return {
+		status: "matched",
+		transaction: state.tr,
+		nextRevisionId: revisionStamp.idSeed,
+		rangeCount: 0
+	};
 	const reviewedState = resolveAllChangesInHeadlessStateWithMapping(state, "accept");
 	const reviewed = boundaryParagraphEntriesOf(reviewedState.state.doc);
 	const targets = boundaryParagraphEntriesOf(target);

package/dist/docx/selectiveSave.d.ts

@@ -3,7 +3,7 @@ import { document_d_exports } from "../types/document.js";
 type SelectiveSaveOptions = {
   /** Changed paragraph IDs to selectively patch */
   changedParaIds: Set<string>;
-  /** Whether structural changes occurred (paragraph add/delete) */
+  /** Whether paragraph membership, order, or block structure changed. */
   structuralChange: boolean;
   /** Whether any changes affected paragraphs without paraId */
   hasUntrackedChanges: boolean;