@stll/folio-core 0.35.1 → 0.36.0

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

@@ -63,85 +63,519 @@ const comparisonKey = (token, normalization) => {
 };
 const isSeparatorOnly = (text) => SEPARATOR_ONLY.test(text);
 /**
-* Cell budget for the O(n*m) DP table below. `before`/`after` come from
-* attacker-controlled document text (a `modified` block pair), so an
-* unbounded pair of large strings would otherwise force a quadratic-sized
-* allocation. Past this budget, skip the DP and fall back to a single
-* whole-string `del` + `ins` pair — a coarser diff, but O(1) memory.
+* Cell budget shared by the residual LCS gaps inside one comparison or apply
+* scope. `before`/`after` come from attacker-controlled document text (a
+* `modified` block pair), so an unbounded pair of large strings would
+* otherwise force a quadratic-sized allocation. Package-level callers share
+* one scope across every story and operation; the standalone public helper
+* gets one scope per call.
 */
 const MAX_WORD_DIFF_CELLS = 4e6;
-/** The LCS alignment, as runs. Longest common subsequence on comparison keys. */
-const alignTokens = ({ before, after, normalization }) => {
-	const beforeKeys = before.map((token) => comparisonKey(token, normalization));
-	const afterKeys = after.map((token) => comparisonKey(token, normalization));
-	const m = before.length;
-	const n = after.length;
-	const dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
-	for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) {
-		const row = dp[i + 1];
-		const previousRow = dp[i];
-		if (!row || !previousRow) continue;
-		row[j + 1] = beforeKeys[i] === afterKeys[j] ? (previousRow[j] ?? 0) + 1 : Math.max(row[j] ?? 0, previousRow[j + 1] ?? 0);
+/**
+* Maximum combined residual tokens considered for unique-anchor discovery.
+* Comparison-key arrays, occurrence maps, and the candidate list are optional
+* linear storage over attacker-controlled text. Common affixes are removed
+* before this cap, so a small edit in a very long paragraph can still use
+* anchors without duplicating the whole input as normalized strings.
+*/
+const MAX_WORD_DIFF_ANCHOR_TOKENS = 16384;
+/**
+* Maximum source code units retained in comparison-key arrays. Token count
+* alone is not a storage bound: one word token can itself contain megabytes,
+* and case or whitespace normalization creates another string for it.
+*/
+const MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS = 1048576;
+const ALIGNMENT_OPERATION = {
+	Equal: 1,
+	Delete: 2,
+	Insert: 3
+};
+const fitsCellBudget = (beforeLength, afterLength, budget) => beforeLength === 0 || afterLength === 0 || beforeLength <= Math.floor(budget.remainingCells / afterLength);
+const pushRun = (runs, run) => {
+	const last = runs.at(-1);
+	if (last?.type === "equal" && run.type === "equal") {
+		last.before += run.before;
+		last.after += run.after;
+		last.units += run.units;
+		return;
+	}
+	if (last?.type === "del" && run.type === "del" || last?.type === "ins" && run.type === "ins") {
+		last.text += run.text;
+		return;
+	}
+	runs.push(run);
+};
+const joinTokenRange = (tokens, { start, end }) => {
+	return tokens.slice(start, end).join("");
+};
+const pushEqualRange = (runs, before, after, beforeRange, afterRange) => {
+	const units = beforeRange.end - beforeRange.start;
+	if (units === 0) return;
+	pushRun(runs, {
+		type: "equal",
+		before: joinTokenRange(before, beforeRange),
+		after: joinTokenRange(after, afterRange),
+		units
+	});
+};
+const pushChangedRange = (runs, before, after, beforeRange, afterRange) => {
+	if (beforeRange.start !== beforeRange.end) pushRun(runs, {
+		type: "del",
+		text: joinTokenRange(before, beforeRange)
+	});
+	if (afterRange.start !== afterRange.end) pushRun(runs, {
+		type: "ins",
+		text: joinTokenRange(after, afterRange)
+	});
+};
+/**
+* Unique tokens common to both ranges, reduced to a monotone subsequence of
+* target positions. Repeated boilerplate is deliberately ineligible: a unique
+* clause number or name is stronger lineage evidence than another occurrence
+* of "the" chosen by an arbitrary LCS tie.
+*/
+const findPatienceAnchors = (beforeKeys, afterKeys, beforeRange, afterRange) => {
+	const beforeOccurrences = /* @__PURE__ */ new Map();
+	for (let index = beforeRange.start; index < beforeRange.end; index++) {
+		const key = beforeKeys[index] ?? "";
+		beforeOccurrences.set(key, (beforeOccurrences.get(key) ?? 0) + 1);
+	}
+	const afterOccurrences = /* @__PURE__ */ new Map();
+	for (let index = afterRange.start; index < afterRange.end; index++) {
+		const key = afterKeys[index] ?? "";
+		const occurrence = afterOccurrences.get(key);
+		if (occurrence) occurrence.count++;
+		else afterOccurrences.set(key, {
+			count: 1,
+			index
+		});
+	}
+	const candidates = [];
+	for (let beforeIndex = beforeRange.start; beforeIndex < beforeRange.end; beforeIndex++) {
+		const key = beforeKeys[beforeIndex] ?? "";
+		const beforeCount = beforeOccurrences.get(key);
+		const afterOccurrence = afterOccurrences.get(key);
+		if (beforeCount === 1 && afterOccurrence?.count === 1) candidates.push({
+			beforeIndex,
+			afterIndex: afterOccurrence.index
+		});
+	}
+	if (candidates.length < 2) return candidates;
+	const predecessors = new Int32Array(candidates.length);
+	predecessors.fill(-1);
+	const tailCandidateIndexes = new Int32Array(candidates.length);
+	let tailCount = 0;
+	for (const [candidateIndex, candidate] of candidates.entries()) {
+		let low = 0;
+		let high = tailCount;
+		while (low < high) {
+			const middle = low + Math.floor((high - low) / 2);
+			const tail = candidates[tailCandidateIndexes[middle] ?? -1];
+			if (tail && tail.afterIndex < candidate.afterIndex) low = middle + 1;
+			else high = middle;
+		}
+		if (low > 0) predecessors[candidateIndex] = tailCandidateIndexes[low - 1] ?? -1;
+		tailCandidateIndexes[low] = candidateIndex;
+		if (low === tailCount) tailCount++;
+	}
+	const anchors = [];
+	let candidateIndex = tailCandidateIndexes[tailCount - 1] ?? -1;
+	while (candidateIndex >= 0) {
+		const candidate = candidates[candidateIndex];
+		if (candidate) anchors.push(candidate);
+		candidateIndex = predecessors[candidateIndex] ?? -1;
+	}
+	anchors.reverse();
+	return anchors;
+};
+const keysEqual = (before, after, normalization) => comparisonKey(before, normalization) === comparisonKey(after, normalization);
+const isTokenSubsequence = ({ subsequence, sequence, subsequenceRange, sequenceRange, normalization }) => {
+	if (subsequenceRange.start === subsequenceRange.end) return true;
+	let subsequenceIndex = subsequenceRange.start;
+	let subsequenceKey = comparisonKey(subsequence[subsequenceIndex] ?? "", normalization);
+	for (let sequenceIndex = sequenceRange.start; sequenceIndex < sequenceRange.end; sequenceIndex++) {
+		if (subsequenceIndex === subsequenceRange.end) return true;
+		const token = sequence[sequenceIndex] ?? "";
+		if (subsequenceKey !== comparisonKey(token, normalization)) continue;
+		subsequenceIndex++;
+		if (subsequenceIndex < subsequenceRange.end) {
+			const nextToken = subsequence[subsequenceIndex] ?? "";
+			subsequenceKey = comparisonKey(nextToken, normalization);
+		}
 	}
-	const reversed = [];
-	let i = m;
-	let j = n;
-	while (i > 0 && j > 0) {
-		if (beforeKeys[i - 1] === afterKeys[j - 1]) {
-			reversed.push({
+	return subsequenceIndex === subsequenceRange.end;
+};
+/** Classify edits whose shorter token sequence survives whole and in order. */
+const classifyMonotoneChange = ({ before, after, beforeRange, afterRange, normalization }) => {
+	const beforeLength = beforeRange.end - beforeRange.start;
+	const afterLength = afterRange.end - afterRange.start;
+	if (beforeLength === afterLength) {
+		for (let offset = 0; offset < beforeLength; offset++) if (!keysEqual(before[beforeRange.start + offset] ?? "", after[afterRange.start + offset] ?? "", normalization)) return "mixed";
+		return "equivalent";
+	}
+	if (beforeLength < afterLength) return isTokenSubsequence({
+		subsequence: before,
+		sequence: after,
+		subsequenceRange: beforeRange,
+		sequenceRange: afterRange,
+		normalization
+	}) ? "insertion" : "mixed";
+	return isTokenSubsequence({
+		subsequence: after,
+		sequence: before,
+		subsequenceRange: afterRange,
+		sequenceRange: beforeRange,
+		normalization
+	}) ? "deletion" : "mixed";
+};
+const alignMonotoneChange = (beforeText, afterText, before, after, normalization, change) => {
+	const beforeIsSubsequence = change === "insertion";
+	const subsequence = beforeIsSubsequence ? before : after;
+	const sequence = beforeIsSubsequence ? after : before;
+	const sequenceText = beforeIsSubsequence ? afterText : beforeText;
+	const runs = [];
+	let subsequenceIndex = 0;
+	let sequenceOffset = 0;
+	let sequenceChangeStartOffset = 0;
+	for (let sequenceIndex = 0; sequenceIndex < sequence.length; sequenceIndex++) {
+		const subsequenceToken = subsequence[subsequenceIndex];
+		const sequenceToken = sequence[sequenceIndex];
+		const sequenceTokenStart = sequenceOffset;
+		sequenceOffset += sequenceToken?.length ?? 0;
+		if (subsequenceToken === void 0 || sequenceToken === void 0 || !keysEqual(subsequenceToken, sequenceToken, normalization)) continue;
+		if (sequenceChangeStartOffset < sequenceTokenStart) {
+			const changedText = sequenceText.slice(sequenceChangeStartOffset, sequenceTokenStart);
+			pushRun(runs, beforeIsSubsequence ? {
+				type: "ins",
+				text: changedText
+			} : {
+				type: "del",
+				text: changedText
+			});
+		}
+		pushRun(runs, {
+			type: "equal",
+			before: beforeIsSubsequence ? subsequenceToken : sequenceToken,
+			after: beforeIsSubsequence ? sequenceToken : subsequenceToken,
+			units: 1
+		});
+		subsequenceIndex++;
+		sequenceChangeStartOffset = sequenceOffset;
+	}
+	if (sequenceChangeStartOffset < sequenceText.length) {
+		const changedText = sequenceText.slice(sequenceChangeStartOffset);
+		pushRun(runs, beforeIsSubsequence ? {
+			type: "ins",
+			text: changedText
+		} : {
+			type: "del",
+			text: changedText
+		});
+	}
+	return runs;
+};
+/** Longest-common-subsequence alignment for one residual, bounded gap. */
+const alignDenseGap = ({ before, after, beforeKeys, afterKeys, beforeRange, afterRange, runs, budget }) => {
+	const beforeLength = beforeRange.end - beforeRange.start;
+	const afterLength = afterRange.end - afterRange.start;
+	if (beforeLength === 0 || afterLength === 0) {
+		pushChangedRange(runs, before, after, beforeRange, afterRange);
+		return;
+	}
+	if (!fitsCellBudget(beforeLength, afterLength, budget)) {
+		pushChangedRange(runs, before, after, beforeRange, afterRange);
+		return;
+	}
+	const cellCount = beforeLength * afterLength;
+	budget.remainingCells -= cellCount;
+	const lengths = new Uint32Array(cellCount);
+	for (let beforeOffset = 0; beforeOffset < beforeLength; beforeOffset++) for (let afterOffset = 0; afterOffset < afterLength; afterOffset++) {
+		const index = beforeOffset * afterLength + afterOffset;
+		if (beforeKeys[beforeRange.start + beforeOffset] === afterKeys[afterRange.start + afterOffset]) {
+			lengths[index] = (beforeOffset > 0 && afterOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset - 1] ?? 0 : 0) + 1;
+			continue;
+		}
+		const above = beforeOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset] ?? 0 : 0;
+		const left = afterOffset > 0 ? lengths[index - 1] ?? 0 : 0;
+		lengths[index] = Math.max(above, left);
+	}
+	const reversedOperations = new Uint8Array(beforeLength + afterLength);
+	let operationCount = 0;
+	let beforeOffset = beforeLength - 1;
+	let afterOffset = afterLength - 1;
+	while (beforeOffset >= 0 && afterOffset >= 0) {
+		if (beforeKeys[beforeRange.start + beforeOffset] === afterKeys[afterRange.start + afterOffset]) {
+			reversedOperations[operationCount++] = ALIGNMENT_OPERATION.Equal;
+			beforeOffset--;
+			afterOffset--;
+			continue;
+		}
+		if ((beforeOffset > 0 ? lengths[(beforeOffset - 1) * afterLength + afterOffset] ?? 0 : 0) > (afterOffset > 0 ? lengths[beforeOffset * afterLength + afterOffset - 1] ?? 0 : 0)) {
+			reversedOperations[operationCount++] = ALIGNMENT_OPERATION.Delete;
+			beforeOffset--;
+		} else {
+			reversedOperations[operationCount++] = ALIGNMENT_OPERATION.Insert;
+			afterOffset--;
+		}
+	}
+	while (beforeOffset >= 0) {
+		reversedOperations[operationCount++] = ALIGNMENT_OPERATION.Delete;
+		beforeOffset--;
+	}
+	while (afterOffset >= 0) {
+		reversedOperations[operationCount++] = ALIGNMENT_OPERATION.Insert;
+		afterOffset--;
+	}
+	let beforeCursor = beforeRange.start;
+	let afterCursor = afterRange.start;
+	for (let operationIndex = operationCount - 1; operationIndex >= 0; operationIndex--) {
+		const operation = reversedOperations[operationIndex];
+		if (operation === ALIGNMENT_OPERATION.Equal) {
+			pushRun(runs, {
 				type: "equal",
-				before: before[i - 1] ?? "",
-				after: after[j - 1] ?? "",
+				before: before[beforeCursor] ?? "",
+				after: after[afterCursor] ?? "",
 				units: 1
 			});
-			i--;
-			j--;
+			beforeCursor++;
+			afterCursor++;
 			continue;
 		}
-		if ((dp[i - 1]?.[j] ?? 0) > (dp[i]?.[j - 1] ?? 0)) {
-			reversed.push({
+		if (operation === ALIGNMENT_OPERATION.Delete) {
+			pushRun(runs, {
 				type: "del",
-				text: before[i - 1] ?? ""
+				text: before[beforeCursor] ?? ""
 			});
-			i--;
-		} else {
-			reversed.push({
-				type: "ins",
-				text: after[j - 1] ?? ""
-			});
-			j--;
+			beforeCursor++;
+			continue;
 		}
+		pushRun(runs, {
+			type: "ins",
+			text: after[afterCursor] ?? ""
+		});
+		afterCursor++;
+	}
+};
+/** Factor exact boundary matches before spending the residual DP allowance. */
+const alignGap = (options) => {
+	const { beforeKeys, afterKeys, runs } = options;
+	let beforeStart = options.beforeRange.start;
+	let afterStart = options.afterRange.start;
+	const beforeEnd = options.beforeRange.end;
+	const afterEnd = options.afterRange.end;
+	while (beforeStart < beforeEnd && afterStart < afterEnd && beforeKeys[beforeStart] === afterKeys[afterStart]) {
+		beforeStart++;
+		afterStart++;
 	}
-	while (i > 0) {
-		reversed.push({
+	pushEqualRange(runs, options.before, options.after, {
+		start: options.beforeRange.start,
+		end: beforeStart
+	}, {
+		start: options.afterRange.start,
+		end: afterStart
+	});
+	let beforeMiddleEnd = beforeEnd;
+	let afterMiddleEnd = afterEnd;
+	while (beforeMiddleEnd > beforeStart && afterMiddleEnd > afterStart && beforeKeys[beforeMiddleEnd - 1] === afterKeys[afterMiddleEnd - 1]) {
+		beforeMiddleEnd--;
+		afterMiddleEnd--;
+	}
+	alignDenseGap({
+		...options,
+		beforeRange: {
+			start: beforeStart,
+			end: beforeMiddleEnd
+		},
+		afterRange: {
+			start: afterStart,
+			end: afterMiddleEnd
+		}
+	});
+	pushEqualRange(runs, options.before, options.after, {
+		start: beforeMiddleEnd,
+		end: beforeEnd
+	}, {
+		start: afterMiddleEnd,
+		end: afterEnd
+	});
+};
+/**
+* LCS alignment split at stable, unique-token anchors. Patience anchoring keeps
+* repeated boilerplate from winning a tie over a unique legal term, and makes
+* a small edit inside a long paragraph pay for only its changed gap.
+*/
+const alignTokens = ({ beforeText, afterText, before, after, normalization, budget }) => {
+	let commonPrefixLength = 0;
+	let beforePrefixLength = 0;
+	let afterPrefixLength = 0;
+	while (commonPrefixLength < before.length && commonPrefixLength < after.length && keysEqual(before[commonPrefixLength] ?? "", after[commonPrefixLength] ?? "", normalization)) {
+		beforePrefixLength += before[commonPrefixLength]?.length ?? 0;
+		afterPrefixLength += after[commonPrefixLength]?.length ?? 0;
+		commonPrefixLength++;
+	}
+	let beforeMiddleEnd = before.length;
+	let afterMiddleEnd = after.length;
+	let beforeSuffixLength = 0;
+	let afterSuffixLength = 0;
+	while (beforeMiddleEnd > commonPrefixLength && afterMiddleEnd > commonPrefixLength && keysEqual(before[beforeMiddleEnd - 1] ?? "", after[afterMiddleEnd - 1] ?? "", normalization)) {
+		beforeMiddleEnd--;
+		afterMiddleEnd--;
+		beforeSuffixLength += before[beforeMiddleEnd]?.length ?? 0;
+		afterSuffixLength += after[afterMiddleEnd]?.length ?? 0;
+	}
+	const beforeRange = {
+		start: commonPrefixLength,
+		end: beforeMiddleEnd
+	};
+	const afterRange = {
+		start: commonPrefixLength,
+		end: afterMiddleEnd
+	};
+	const monotoneChange = classifyMonotoneChange({
+		before,
+		after,
+		beforeRange,
+		afterRange,
+		normalization
+	});
+	if (monotoneChange === "equivalent") return {
+		runs: [{
+			type: "equal",
+			before: beforeText,
+			after: afterText,
+			units: before.length
+		}],
+		monotoneDirection: null
+	};
+	const monotoneDirection = monotoneChange === "mixed" ? null : monotoneChange;
+	const residualTokenCount = beforeRange.end - beforeRange.start + afterRange.end - afterRange.start;
+	const runs = [];
+	const fullInputFits = fitsCellBudget(before.length, after.length, budget);
+	const fullInputFitsStorage = before.length + after.length <= MAX_WORD_DIFF_ANCHOR_TOKENS && beforeText.length + afterText.length <= MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS;
+	const residualCodeUnitCount = beforeText.length - beforePrefixLength - beforeSuffixLength + afterText.length - afterPrefixLength - afterSuffixLength;
+	if (residualTokenCount > MAX_WORD_DIFF_ANCHOR_TOKENS || residualCodeUnitCount > MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS) {
+		if (commonPrefixLength > 0) pushRun(runs, {
+			type: "equal",
+			before: beforeText.slice(0, beforePrefixLength),
+			after: afterText.slice(0, afterPrefixLength),
+			units: commonPrefixLength
+		});
+		if (beforePrefixLength + beforeSuffixLength < beforeText.length) pushRun(runs, {
 			type: "del",
-			text: before[i - 1] ?? ""
+			text: beforeText.slice(beforePrefixLength, beforeText.length - beforeSuffixLength)
 		});
-		i--;
-	}
-	while (j > 0) {
-		reversed.push({
+		if (afterPrefixLength + afterSuffixLength < afterText.length) pushRun(runs, {
 			type: "ins",
-			text: after[j - 1] ?? ""
+			text: afterText.slice(afterPrefixLength, afterText.length - afterSuffixLength)
 		});
-		j--;
+		if (beforeSuffixLength > 0) pushRun(runs, {
+			type: "equal",
+			before: beforeText.slice(beforeText.length - beforeSuffixLength),
+			after: afterText.slice(afterText.length - afterSuffixLength),
+			units: before.length - beforeMiddleEnd
+		});
+		return {
+			runs,
+			monotoneDirection
+		};
 	}
-	const runs = [];
-	for (const run of reversed.toReversed()) {
-		const last = runs.at(-1);
-		if (last?.type === "equal" && run.type === "equal") {
-			last.before += run.before;
-			last.after += run.after;
-			last.units += run.units;
-			continue;
-		}
-		if (last?.type === "del" && run.type === "del" || last?.type === "ins" && run.type === "ins") {
-			last.text += run.text;
-			continue;
-		}
-		runs.push({ ...run });
+	const beforeMiddle = before.slice(beforeRange.start, beforeRange.end);
+	const afterMiddle = after.slice(afterRange.start, afterRange.end);
+	const beforeKeys = beforeMiddle.map((token) => comparisonKey(token, normalization));
+	const afterKeys = afterMiddle.map((token) => comparisonKey(token, normalization));
+	const middleRangeBefore = {
+		start: 0,
+		end: beforeMiddle.length
+	};
+	const middleRangeAfter = {
+		start: 0,
+		end: afterMiddle.length
+	};
+	const anchors = findPatienceAnchors(beforeKeys, afterKeys, middleRangeBefore, middleRangeAfter);
+	if (anchors.length === 0 && fullInputFits && fullInputFitsStorage) {
+		alignDenseGap({
+			before,
+			after,
+			beforeKeys: before.map((token) => comparisonKey(token, normalization)),
+			afterKeys: after.map((token) => comparisonKey(token, normalization)),
+			beforeRange: {
+				start: 0,
+				end: before.length
+			},
+			afterRange: {
+				start: 0,
+				end: after.length
+			},
+			runs,
+			budget
+		});
+		return {
+			runs,
+			monotoneDirection
+		};
 	}
-	return runs;
+	pushEqualRange(runs, before, after, {
+		start: 0,
+		end: commonPrefixLength
+	}, {
+		start: 0,
+		end: commonPrefixLength
+	});
+	let beforeStart = 0;
+	let afterStart = 0;
+	for (const anchor of anchors) {
+		alignGap({
+			before: beforeMiddle,
+			after: afterMiddle,
+			beforeKeys,
+			afterKeys,
+			beforeRange: {
+				start: beforeStart,
+				end: anchor.beforeIndex
+			},
+			afterRange: {
+				start: afterStart,
+				end: anchor.afterIndex
+			},
+			runs,
+			budget
+		});
+		pushRun(runs, {
+			type: "equal",
+			before: beforeMiddle[anchor.beforeIndex] ?? "",
+			after: afterMiddle[anchor.afterIndex] ?? "",
+			units: 1
+		});
+		beforeStart = anchor.beforeIndex + 1;
+		afterStart = anchor.afterIndex + 1;
+	}
+	alignGap({
+		before: beforeMiddle,
+		after: afterMiddle,
+		beforeKeys,
+		afterKeys,
+		beforeRange: {
+			start: beforeStart,
+			end: beforeMiddle.length
+		},
+		afterRange: {
+			start: afterStart,
+			end: afterMiddle.length
+		},
+		runs,
+		budget
+	});
+	pushEqualRange(runs, before, after, {
+		start: beforeMiddleEnd,
+		end: before.length
+	}, {
+		start: afterMiddleEnd,
+		end: after.length
+	});
+	return {
+		runs,
+		monotoneDirection
+	};
 };
 /**
 * True when the surviving matches are too short, relative to the strings they
@@ -254,21 +688,76 @@ const wholeStringReplacement = (before, after) => {
 	});
 	return segments;
 };
-const diffWordSegments = (before, after, options = {}) => {
+const diffWordSegmentsWithBudget = (before, after, options, budget) => {
+	if (before === after) return before.length === 0 ? [] : [{
+		type: "equal",
+		text: before
+	}];
 	const granularity = options.granularity ?? "word";
 	const normalization = options.normalization ?? {};
 	const beforeTokens = tokenize(before, granularity);
 	const afterTokens = tokenize(after, granularity);
 	if (beforeTokens.length === 0 && afterTokens.length === 0) return [];
-	if (beforeTokens.length * afterTokens.length > MAX_WORD_DIFF_CELLS) return wholeStringReplacement(before, after);
+	if (beforeTokens.length === 0 || afterTokens.length === 0) return wholeStringReplacement(before, after);
 	const aligned = alignTokens({
+		beforeText: before,
+		afterText: after,
 		before: beforeTokens,
 		after: afterTokens,
-		normalization
+		normalization,
+		budget
 	});
-	const surviving = demoteRejectedMatches(aligned);
-	if (isTooFragmented(surviving, (before.length + after.length) / 2)) return wholeStringReplacement(before, after);
+	let surviving = demoteRejectedMatches(aligned.runs);
+	const inventedOppositeChange = aligned.monotoneDirection === "insertion" && surviving.some(({ type }) => type === "del") || aligned.monotoneDirection === "deletion" && surviving.some(({ type }) => type === "ins");
+	const monotoneDirection = aligned.monotoneDirection;
+	if (inventedOppositeChange && monotoneDirection !== null) if (beforeTokens.length + afterTokens.length <= MAX_WORD_DIFF_ANCHOR_TOKENS && before.length + after.length <= MAX_WORD_DIFF_COMPARISON_KEY_CODE_UNITS && fitsCellBudget(beforeTokens.length, afterTokens.length, budget)) {
+		const unanchored = [];
+		alignDenseGap({
+			before: beforeTokens,
+			after: afterTokens,
+			beforeKeys: beforeTokens.map((token) => comparisonKey(token, normalization)),
+			afterKeys: afterTokens.map((token) => comparisonKey(token, normalization)),
+			beforeRange: {
+				start: 0,
+				end: beforeTokens.length
+			},
+			afterRange: {
+				start: 0,
+				end: afterTokens.length
+			},
+			runs: unanchored,
+			budget
+		});
+		surviving = unanchored;
+	} else surviving = monotoneDirection === "insertion" && aligned.runs.some(({ type }) => type === "del") || monotoneDirection === "deletion" && aligned.runs.some(({ type }) => type === "ins") ? alignMonotoneChange(before, after, beforeTokens, afterTokens, normalization, monotoneDirection) : aligned.runs;
+	if (aligned.monotoneDirection === null && isTooFragmented(surviving, (before.length + after.length) / 2)) return wholeStringReplacement(before, after);
 	return toSegments(orderDeletionsFirst(surviving));
 };
+/**
+* One internal comparison/apply scope. Every diff shares the same quadratic
+* allowance; public standalone calls below still receive a fresh allowance.
+* Not re-exported from a package entry point.
+*/
+const createWordDiffSession = (options = {}) => {
+	const resolvedOptions = {
+		granularity: options.granularity ?? "word",
+		normalization: { ...options.normalization }
+	};
+	const budget = { remainingCells: MAX_WORD_DIFF_CELLS };
+	return { diff: (before, after) => diffWordSegmentsWithBudget(before, after, resolvedOptions, budget) };
+};
+const WORD_DIFF_SESSION = Symbol("folio.wordDiffSession");
+const hasWordDiffSession = (options) => WORD_DIFF_SESSION in options;
+/** Attach one internal work scope without widening a caller-facing option type. */
+const createScopedWordDiffOptions = (options) => ({
+	...options,
+	[WORD_DIFF_SESSION]: createWordDiffSession(options)
+});
+/** Reuse an internal scope when present; ordinary public callers get a fresh one. */
+const wordDiffSessionFromOptions = (options) => {
+	if (options && hasWordDiffSession(options)) return options[WORD_DIFF_SESSION];
+	return createWordDiffSession(options);
+};
+const diffWordSegments = (before, after, options = {}) => diffWordSegmentsWithBudget(before, after, options, { remainingCells: MAX_WORD_DIFF_CELLS });
 //#endregion
-export { WORD_DIFF_GRANULARITIES, diffWordSegments };
+export { WORD_DIFF_GRANULARITIES, createScopedWordDiffOptions, createWordDiffSession, diffWordSegments, wordDiffSessionFromOptions };