@gajae-code/coding-agent 0.1.1

package/src/hashline/apply.ts

@@ -0,0 +1,737 @@
+import { HashlineMismatchError } from "./anchors";
+import { RANGE_INTERIOR_HASH } from "./constants";
+import { computeLineHash } from "./hash";
+import { cloneCursor } from "./parser";
+import type { Anchor, HashlineApplyOptions, HashlineCursor, HashlineEdit, HashMismatch } from "./types";
+
+export interface HashlineApplyResult {
+	lines: string;
+	firstChangedLine?: number;
+	warnings?: string[];
+	noopEdits?: HashlineNoopEdit[];
+}
+
+export interface HashlineNoopEdit {
+	editIndex: number;
+	loc: string;
+	reason: string;
+	current: string;
+}
+
+type HashlineLineOrigin = "original" | "insert" | "replacement";
+
+interface IndexedEdit {
+	edit: HashlineEdit;
+	idx: number;
+}
+
+type HashlineDeleteEdit = Extract<HashlineEdit, { kind: "delete" }>;
+
+interface HashlineReplacementGroup {
+	startIndex: number;
+	endIndex: number;
+	sourceLineNum: number;
+	replacement: string[];
+	deletes: HashlineDeleteEdit[];
+}
+
+function getHashlineEditAnchors(edit: HashlineEdit): Anchor[] {
+	if (edit.kind === "delete") return [edit.anchor];
+	if (edit.cursor.kind === "before_anchor") return [edit.cursor.anchor];
+	if (edit.cursor.kind === "after_anchor") return [edit.cursor.anchor];
+	return [];
+}
+
+/**
+ * Verify every anchor's hash. Any mismatch is reported as a `HashMismatch`;
+ * there is no auto-rebase. Callers are expected to surface mismatches as
+ * `HashlineMismatchError` so the model re-reads and re-anchors.
+ */
+function validateHashlineAnchors(edits: HashlineEdit[], fileLines: string[]): HashMismatch[] {
+	const mismatches: HashMismatch[] = [];
+	for (const edit of edits) {
+		for (const anchor of getHashlineEditAnchors(edit)) {
+			if (anchor.line < 1 || anchor.line > fileLines.length) {
+				throw new Error(`Line ${anchor.line} does not exist (file has ${fileLines.length} lines)`);
+			}
+			if (anchor.hash === RANGE_INTERIOR_HASH) continue;
+
+			const actualHash = computeLineHash(anchor.line, fileLines[anchor.line - 1] ?? "");
+			if (actualHash === anchor.hash) continue;
+
+			mismatches.push({ line: anchor.line, expected: anchor.hash, actual: actualHash });
+		}
+	}
+	return mismatches;
+}
+
+function insertAtStart(fileLines: string[], lineOrigins: HashlineLineOrigin[], lines: string[]): void {
+	if (lines.length === 0) return;
+	const origins = lines.map((): HashlineLineOrigin => "insert");
+	if (fileLines.length === 1 && fileLines[0] === "") {
+		fileLines.splice(0, 1, ...lines);
+		lineOrigins.splice(0, 1, ...origins);
+		return;
+	}
+	fileLines.splice(0, 0, ...lines);
+	lineOrigins.splice(0, 0, ...origins);
+}
+
+function insertAtEnd(fileLines: string[], lineOrigins: HashlineLineOrigin[], lines: string[]): number | undefined {
+	if (lines.length === 0) return undefined;
+	const origins = lines.map((): HashlineLineOrigin => "insert");
+	if (fileLines.length === 1 && fileLines[0] === "") {
+		fileLines.splice(0, 1, ...lines);
+		lineOrigins.splice(0, 1, ...origins);
+		return 1;
+	}
+	const hasTrailingNewline = fileLines.length > 0 && fileLines[fileLines.length - 1] === "";
+	const insertIndex = hasTrailingNewline ? fileLines.length - 1 : fileLines.length;
+	fileLines.splice(insertIndex, 0, ...lines);
+	lineOrigins.splice(insertIndex, 0, ...origins);
+	return insertIndex + 1;
+}
+
+/** Bucket edits by the line they target so we can apply each line's group in one splice. */
+
+function getAnchorTargetLine(edit: HashlineEdit): number | undefined {
+	if (edit.kind === "delete") return edit.anchor.line;
+	if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") return edit.cursor.anchor.line;
+	return undefined;
+}
+
+function collectAnchorTargetLines(edits: HashlineEdit[]): Set<number> {
+	const lines = new Set<number>();
+	for (const edit of edits) {
+		const line = getAnchorTargetLine(edit);
+		if (line !== undefined) lines.add(line);
+	}
+	return lines;
+}
+
+function findReplacementGroup(edits: HashlineEdit[], startIndex: number): HashlineReplacementGroup | undefined {
+	const first = edits[startIndex];
+	if (first?.kind !== "insert" || first.cursor.kind !== "before_anchor") return undefined;
+
+	const sourceLineNum = first.lineNum;
+	const replacement: string[] = [];
+	let index = startIndex;
+	while (index < edits.length) {
+		const edit = edits[index];
+		if (edit.kind !== "insert" || edit.lineNum !== sourceLineNum || edit.cursor.kind !== "before_anchor") break;
+		replacement.push(edit.text);
+		index++;
+	}
+
+	const deletes: HashlineDeleteEdit[] = [];
+	while (index < edits.length) {
+		const edit = edits[index];
+		if (edit.kind !== "delete" || edit.lineNum !== sourceLineNum) break;
+		deletes.push(edit);
+		index++;
+	}
+	if (deletes.length === 0) return undefined;
+
+	const startLine = deletes[0].anchor.line;
+	for (let offset = 0; offset < deletes.length; offset++) {
+		if (deletes[offset].anchor.line !== startLine + offset) return undefined;
+	}
+	const cursorLine = first.cursor.anchor.line;
+	if (cursorLine !== startLine) return undefined;
+
+	return { startIndex, endIndex: index - 1, sourceLineNum, replacement, deletes };
+}
+
+function countMatchingPrefixBlock(fileLines: string[], startLine: number, replacement: string[]): number {
+	const max = Math.min(replacement.length, startLine - 1);
+	for (let count = max; count >= 2; count--) {
+		let matches = true;
+		for (let offset = 0; offset < count; offset++) {
+			if (fileLines[startLine - count - 1 + offset] !== replacement[offset]) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) return count;
+	}
+	return 0;
+}
+
+function countMatchingSuffixBlock(fileLines: string[], endLine: number, replacement: string[]): number {
+	const max = Math.min(replacement.length, fileLines.length - endLine);
+	for (let count = max; count >= 2; count--) {
+		let matches = true;
+		for (let offset = 0; offset < count; offset++) {
+			if (fileLines[endLine + offset] !== replacement[replacement.length - count + offset]) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) return count;
+	}
+	return 0;
+}
+
+// Single-line duplicate absorption is limited to structural closing delimiters.
+// General one-line context is too easy to delete incorrectly, but duplicated
+// `};` / `)` / `]` boundaries usually indicate a replacement range stopped one
+// line early and would otherwise produce a syntax error.
+const STRUCTURAL_CLOSING_BOUNDARY_RE = /^\s*[\])}]+[;,]?\s*$/;
+
+function isStructuralClosingBoundaryLine(line: string): boolean {
+	return STRUCTURAL_CLOSING_BOUNDARY_RE.test(line);
+}
+
+interface DelimiterBalance {
+	paren: number;
+	bracket: number;
+	brace: number;
+}
+
+const ZERO_DELIMITER_BALANCE: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
+
+/**
+ * Naive bracket counter — does NOT skip string/template/comment contents. The
+ * single-line structural absorb relies on this being safe-by-asymmetry: the
+ * candidate boundary line is constrained by `STRUCTURAL_CLOSING_BOUNDARY_RE`
+ * to be pure delimiters, so noise in deleted lines or non-boundary kept payload
+ * tends to push `expected !== kept` and biases the heuristic toward NOT
+ * absorbing (the safe direction). If we ever extend this to opening boundaries
+ * or non-structural single lines, swap this for a real tokenizer.
+ */
+function computeDelimiterBalance(lines: string[]): DelimiterBalance {
+	const balance: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
+	for (const line of lines) {
+		for (const char of line) {
+			switch (char) {
+				case "(":
+					balance.paren++;
+					break;
+				case ")":
+					balance.paren--;
+					break;
+				case "[":
+					balance.bracket++;
+					break;
+				case "]":
+					balance.bracket--;
+					break;
+				case "{":
+					balance.brace++;
+					break;
+				case "}":
+					balance.brace--;
+					break;
+			}
+		}
+	}
+	return balance;
+}
+
+function delimiterBalancesEqual(a: DelimiterBalance, b: DelimiterBalance): boolean {
+	return a.paren === b.paren && a.bracket === b.bracket && a.brace === b.brace;
+}
+
+/**
+ * Decides whether the structural-boundary candidate should be dropped: the
+ * `keptPayload` (full payload with the boundary line removed) must restore the
+ * caller's `expectedBalance`, while the `fullPayload` (boundary line still
+ * present) must NOT. For replacements `expectedBalance` is the deleted
+ * region's net delimiter balance; for pure inserts it is zero.
+ */
+function shouldDropSingleStructuralBoundary(
+	fullPayload: string[],
+	keptPayload: string[],
+	expectedBalance: DelimiterBalance,
+): boolean {
+	return (
+		delimiterBalancesEqual(computeDelimiterBalance(keptPayload), expectedBalance) &&
+		!delimiterBalancesEqual(computeDelimiterBalance(fullPayload), expectedBalance)
+	);
+}
+
+function countMatchingSingleStructuralPrefixBoundary(
+	fileLines: string[],
+	startLine: number,
+	replacement: string[],
+	expectedBalance: DelimiterBalance,
+): number {
+	if (replacement.length === 0 || startLine <= 1) return 0;
+	const line = replacement[0];
+	if (!isStructuralClosingBoundaryLine(line)) return 0;
+	if (fileLines[startLine - 2] !== line) return 0;
+	return shouldDropSingleStructuralBoundary(replacement, replacement.slice(1), expectedBalance) ? 1 : 0;
+}
+
+function countMatchingSingleStructuralSuffixBoundary(
+	fileLines: string[],
+	endLine: number,
+	replacement: string[],
+	expectedBalance: DelimiterBalance,
+): number {
+	if (replacement.length === 0 || endLine >= fileLines.length) return 0;
+	const line = replacement[replacement.length - 1];
+	if (!isStructuralClosingBoundaryLine(line)) return 0;
+	if (fileLines[endLine] !== line) return 0;
+	return shouldDropSingleStructuralBoundary(replacement, replacement.slice(0, -1), expectedBalance) ? 1 : 0;
+}
+
+function hasExternalTargets(lines: Iterable<number>, externalTargetLines: Set<number>): boolean {
+	for (const line of lines) {
+		if (externalTargetLines.has(line)) return true;
+	}
+	return false;
+}
+
+function contiguousRange(start: number, count: number): number[] {
+	return Array.from({ length: count }, (_, offset) => start + offset);
+}
+
+function deleteEditForAutoAbsorbedLine(
+	line: number,
+	sourceLineNum: number,
+	index: number,
+	fileLines: string[],
+): HashlineEdit {
+	return {
+		kind: "delete",
+		anchor: { line, hash: computeLineHash(line, fileLines[line - 1] ?? "") },
+		lineNum: sourceLineNum,
+		index,
+	};
+}
+
+interface HashlinePureInsertGroup {
+	startIndex: number;
+	endIndex: number;
+	sourceLineNum: number;
+	cursor: HashlineCursor;
+	payload: string[];
+}
+
+function cursorMatches(a: HashlineCursor, b: HashlineCursor): boolean {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "bof" || a.kind === "eof") return true;
+	const aAnchor = (a as { anchor: Anchor }).anchor;
+	const bAnchor = (b as { anchor: Anchor }).anchor;
+	return aAnchor.line === bAnchor.line && aAnchor.hash === bAnchor.hash;
+}
+
+/**
+ * Collects a run of consecutive `insert` edits that all share the same
+ * `lineNum` and `cursor`, IFF that run is not immediately followed by a
+ * `delete` at the same `lineNum` (which would make it a replacement group
+ * instead). Returns the contiguous payload so we can check it for boundary
+ * duplicates against the file.
+ */
+function findPureInsertGroup(edits: HashlineEdit[], startIndex: number): HashlinePureInsertGroup | undefined {
+	const first = edits[startIndex];
+	if (first?.kind !== "insert") return undefined;
+
+	const sourceLineNum = first.lineNum;
+	const cursor = first.cursor;
+	const payload: string[] = [];
+	let index = startIndex;
+	while (index < edits.length) {
+		const edit = edits[index];
+		if (edit.kind !== "insert" || edit.lineNum !== sourceLineNum) break;
+		if (!cursorMatches(edit.cursor, cursor)) break;
+		payload.push(edit.text);
+		index++;
+	}
+
+	// If the run is followed by a delete at the same source lineNum, this is a
+	// replacement group (handled by absorbReplacement…). Decline.
+	if (index < edits.length && edits[index].kind === "delete" && edits[index].lineNum === sourceLineNum) {
+		return undefined;
+	}
+
+	return { startIndex, endIndex: index - 1, sourceLineNum, cursor, payload };
+}
+
+/**
+ * For a pure-insert group, locate the file region adjacent to the insertion
+ * point. Returns 0-indexed bounds:
+ *   - `aboveEndIdx`: index of the last file line strictly above the insertion
+ *     point (-1 if none).
+ *   - `belowStartIdx`: index of the first file line strictly below the
+ *     insertion point (`fileLines.length` if none).
+ */
+function pureInsertNeighborhood(
+	cursor: HashlineCursor,
+	fileLines: string[],
+): { aboveEndIdx: number; belowStartIdx: number } {
+	if (cursor.kind === "bof") return { aboveEndIdx: -1, belowStartIdx: 0 };
+	if (cursor.kind === "eof") return { aboveEndIdx: fileLines.length - 1, belowStartIdx: fileLines.length };
+	if (cursor.kind === "before_anchor") {
+		return { aboveEndIdx: cursor.anchor.line - 2, belowStartIdx: cursor.anchor.line - 1 };
+	}
+	// after_anchor
+	return { aboveEndIdx: cursor.anchor.line - 1, belowStartIdx: cursor.anchor.line };
+}
+
+interface PureInsertAbsorbResult {
+	keptPayload: string[];
+	absorbedLeading: number;
+	absorbedTrailing: number;
+	leadingFileRange?: { start: number; end: number }; // 1-indexed inclusive
+	trailingFileRange?: { start: number; end: number }; // 1-indexed inclusive
+}
+
+/**
+ * Mirror of replacement-absorb's prefix/suffix block check, but for pure
+ * inserts: drop payload lines that exactly duplicate the file lines
+ * immediately above (leading) or immediately below (trailing) the insertion
+ * point. Generic context echo absorption requires the caller's opt-in setting;
+ * without it, only single structural closing delimiters use the
+ * balance-validated structural rule below.
+ */
+function tryAbsorbPureInsertGroup(
+	group: HashlinePureInsertGroup,
+	fileLines: string[],
+	allowGenericBoundaryAbsorb: boolean,
+): PureInsertAbsorbResult {
+	const empty: PureInsertAbsorbResult = { keptPayload: group.payload, absorbedLeading: 0, absorbedTrailing: 0 };
+	if (group.payload.length === 0) return empty;
+
+	const { aboveEndIdx, belowStartIdx } = pureInsertNeighborhood(group.cursor, fileLines);
+
+	// Leading: payload[0..k-1] vs fileLines[aboveEndIdx-k+1 .. aboveEndIdx].
+	let absorbedLeading = 0;
+	if (allowGenericBoundaryAbsorb) {
+		const maxLead = Math.min(group.payload.length, aboveEndIdx + 1);
+		for (let count = maxLead; count >= 2; count--) {
+			let ok = true;
+			for (let offset = 0; offset < count; offset++) {
+				if (group.payload[offset] !== fileLines[aboveEndIdx - count + 1 + offset]) {
+					ok = false;
+					break;
+				}
+			}
+			if (ok) {
+				absorbedLeading = count;
+				break;
+			}
+		}
+	}
+	if (
+		absorbedLeading === 0 &&
+		allowGenericBoundaryAbsorb &&
+		group.cursor.kind === "after_anchor" &&
+		group.payload.length > 0 &&
+		aboveEndIdx >= 0 &&
+		!isStructuralClosingBoundaryLine(group.payload[0]) &&
+		group.payload[0] === fileLines[aboveEndIdx]
+	) {
+		absorbedLeading = 1;
+	}
+	if (
+		absorbedLeading === 0 &&
+		group.payload.length > 0 &&
+		aboveEndIdx >= 0 &&
+		isStructuralClosingBoundaryLine(group.payload[0]) &&
+		group.payload[0] === fileLines[aboveEndIdx] &&
+		shouldDropSingleStructuralBoundary(group.payload, group.payload.slice(1), ZERO_DELIMITER_BALANCE)
+	) {
+		absorbedLeading = 1;
+	}
+
+	// Trailing: payload[len-k..len-1] vs fileLines[belowStartIdx..belowStartIdx+k-1].
+	// Don't double-count payload lines already absorbed as leading.
+	let absorbedTrailing = 0;
+	const remainingPayload = group.payload.slice(absorbedLeading);
+	const remaining = remainingPayload.length;
+	if (allowGenericBoundaryAbsorb) {
+		const maxTrail = Math.min(remaining, fileLines.length - belowStartIdx);
+		for (let count = maxTrail; count >= 2; count--) {
+			let ok = true;
+			for (let offset = 0; offset < count; offset++) {
+				if (group.payload[group.payload.length - count + offset] !== fileLines[belowStartIdx + offset]) {
+					ok = false;
+					break;
+				}
+			}
+			if (ok) {
+				absorbedTrailing = count;
+				break;
+			}
+		}
+	}
+	if (
+		absorbedTrailing === 0 &&
+		group.cursor.kind === "before_anchor" &&
+		allowGenericBoundaryAbsorb &&
+		remaining > 0 &&
+		belowStartIdx < fileLines.length &&
+		!isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
+		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx]
+	) {
+		absorbedTrailing = 1;
+	}
+	if (
+		absorbedTrailing === 0 &&
+		remaining > 0 &&
+		belowStartIdx < fileLines.length &&
+		isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
+		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx] &&
+		shouldDropSingleStructuralBoundary(remainingPayload, remainingPayload.slice(0, -1), ZERO_DELIMITER_BALANCE)
+	) {
+		absorbedTrailing = 1;
+	}
+
+	if (absorbedLeading === 0 && absorbedTrailing === 0) return empty;
+
+	return {
+		keptPayload: group.payload.slice(absorbedLeading, group.payload.length - absorbedTrailing),
+		absorbedLeading,
+		absorbedTrailing,
+		leadingFileRange:
+			absorbedLeading > 0 ? { start: aboveEndIdx - absorbedLeading + 2, end: aboveEndIdx + 1 } : undefined,
+		trailingFileRange:
+			absorbedTrailing > 0 ? { start: belowStartIdx + 1, end: belowStartIdx + absorbedTrailing } : undefined,
+	};
+}
+
+function absorbReplacementBoundaryDuplicates(
+	edits: HashlineEdit[],
+	fileLines: string[],
+	warnings: string[],
+	options: HashlineApplyOptions,
+): HashlineEdit[] {
+	let nextSyntheticIndex = edits.length;
+	const absorbed: HashlineEdit[] = [];
+
+	// Anchor targets are stable across the loop because we only ever append
+	// synthetic deletes (never mutate originals). A line in this set that
+	// falls outside the current group's range is necessarily owned by another
+	// op, so absorbing it would silently steal its target.
+	const allTargetLines = collectAnchorTargetLines(edits);
+	const emittedAbsorbKeys = new Set<string>();
+
+	for (let index = 0; index < edits.length; index++) {
+		const group = findReplacementGroup(edits, index);
+		if (!group) {
+			const pureInsert = findPureInsertGroup(edits, index);
+			if (pureInsert) {
+				const result = tryAbsorbPureInsertGroup(
+					pureInsert,
+					fileLines,
+					options.autoDropPureInsertDuplicates === true,
+				);
+				if (result.absorbedLeading > 0 || result.absorbedTrailing > 0) {
+					if (result.leadingFileRange) {
+						const { start, end } = result.leadingFileRange;
+						const key = `pure-insert-leading:${start}..${end}`;
+						if (!emittedAbsorbKeys.has(key)) {
+							emittedAbsorbKeys.add(key);
+							warnings.push(
+								`Auto-dropped ${result.absorbedLeading} duplicate line(s) at the start of insert at line ${pureInsert.sourceLineNum} ` +
+									`(file lines ${start}..${end} already match the payload's leading lines).`,
+							);
+						}
+					}
+					if (result.trailingFileRange) {
+						const { start, end } = result.trailingFileRange;
+						const key = `pure-insert-trailing:${start}..${end}`;
+						if (!emittedAbsorbKeys.has(key)) {
+							emittedAbsorbKeys.add(key);
+							warnings.push(
+								`Auto-dropped ${result.absorbedTrailing} duplicate line(s) at the end of insert at line ${pureInsert.sourceLineNum} ` +
+									`(file lines ${start}..${end} already match the payload's trailing lines).`,
+							);
+						}
+					}
+					for (const text of result.keptPayload) {
+						absorbed.push({
+							kind: "insert",
+							cursor: cloneCursor(pureInsert.cursor),
+							text,
+							lineNum: pureInsert.sourceLineNum,
+							index: nextSyntheticIndex++,
+						});
+					}
+					index = pureInsert.endIndex;
+					continue;
+				}
+				for (let groupIndex = pureInsert.startIndex; groupIndex <= pureInsert.endIndex; groupIndex++) {
+					absorbed.push(edits[groupIndex]);
+				}
+				index = pureInsert.endIndex;
+				continue;
+			}
+			absorbed.push(edits[index]);
+			continue;
+		}
+
+		const startLine = group.deletes[0].anchor.line;
+		const endLine = group.deletes[group.deletes.length - 1].anchor.line;
+
+		const deletedBalance = computeDelimiterBalance(
+			group.deletes.map(deleteEdit => fileLines[deleteEdit.anchor.line - 1] ?? ""),
+		);
+		const prefixCount =
+			countMatchingPrefixBlock(fileLines, startLine, group.replacement) ||
+			countMatchingSingleStructuralPrefixBoundary(fileLines, startLine, group.replacement, deletedBalance);
+		const suffixCount =
+			countMatchingSuffixBlock(fileLines, endLine, group.replacement) ||
+			countMatchingSingleStructuralSuffixBoundary(fileLines, endLine, group.replacement, deletedBalance);
+		const prefixLines = contiguousRange(startLine - prefixCount, prefixCount);
+		const suffixLines = contiguousRange(endLine + 1, suffixCount);
+		const safePrefixCount = hasExternalTargets(prefixLines, allTargetLines) ? 0 : prefixCount;
+		const safeSuffixCount = hasExternalTargets(suffixLines, allTargetLines) ? 0 : suffixCount;
+
+		if (safePrefixCount > 0) {
+			const absorbStart = startLine - safePrefixCount;
+			const key = `prefix:${absorbStart}..${startLine - 1}`;
+			if (!emittedAbsorbKeys.has(key)) {
+				emittedAbsorbKeys.add(key);
+				warnings.push(
+					`Auto-absorbed ${safePrefixCount} duplicate line(s) above replacement at line ${group.sourceLineNum} ` +
+						`(file lines ${absorbStart}..${startLine - 1} matched the payload's leading lines; ` +
+						`widened the deletion to absorb them).`,
+				);
+			}
+		}
+		if (safeSuffixCount > 0) {
+			const absorbEnd = endLine + safeSuffixCount;
+			const key = `suffix:${endLine + 1}..${absorbEnd}`;
+			if (!emittedAbsorbKeys.has(key)) {
+				emittedAbsorbKeys.add(key);
+				warnings.push(
+					`Auto-absorbed ${safeSuffixCount} duplicate line(s) below replacement at line ${group.sourceLineNum} ` +
+						`(file lines ${endLine + 1}..${absorbEnd} matched the payload's trailing lines; ` +
+						`widened the deletion to absorb them).`,
+				);
+			}
+		}
+
+		for (const line of contiguousRange(startLine - safePrefixCount, safePrefixCount)) {
+			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++, fileLines));
+		}
+		for (let groupIndex = group.startIndex; groupIndex <= group.endIndex; groupIndex++) {
+			absorbed.push(edits[groupIndex]);
+		}
+		for (const line of contiguousRange(endLine + 1, safeSuffixCount)) {
+			absorbed.push(deleteEditForAutoAbsorbedLine(line, group.sourceLineNum, nextSyntheticIndex++, fileLines));
+		}
+
+		index = group.endIndex;
+	}
+
+	return absorbed;
+}
+
+function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[]> {
+	const byLine = new Map<number, IndexedEdit[]>();
+	for (const entry of edits) {
+		const line =
+			entry.edit.kind === "delete"
+				? entry.edit.anchor.line
+				: entry.edit.cursor.kind === "before_anchor"
+					? entry.edit.cursor.anchor.line
+					: 0;
+		const bucket = byLine.get(line);
+		if (bucket) bucket.push(entry);
+		else byLine.set(line, [entry]);
+	}
+	return byLine;
+}
+
+export function applyHashlineEdits(
+	text: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions = {},
+): HashlineApplyResult {
+	if (edits.length === 0) return { lines: text, firstChangedLine: undefined };
+
+	const fileLines = text.split("\n");
+	const lineOrigins: HashlineLineOrigin[] = fileLines.map(() => "original");
+	const warnings: string[] = [];
+
+	let firstChangedLine: number | undefined;
+	const trackFirstChanged = (line: number) => {
+		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
+	};
+
+	const mismatches = validateHashlineAnchors(edits, fileLines);
+	if (mismatches.length > 0) throw new HashlineMismatchError(mismatches, fileLines);
+
+	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings, options);
+
+	// Normalize after_anchor inserts to before_anchor of the next line, or EOF
+	// when the anchor is the final line. This keeps the bucketing logic below
+	// (which only knows about before_anchor / bof / eof) untouched.
+	for (const edit of normalizedEdits) {
+		if (edit.kind !== "insert" || edit.cursor.kind !== "after_anchor") continue;
+		const anchorLine = edit.cursor.anchor.line;
+		if (anchorLine >= fileLines.length) {
+			edit.cursor = { kind: "eof" };
+			continue;
+		}
+		const nextLineNum = anchorLine + 1;
+		const nextContent = fileLines[nextLineNum - 1] ?? "";
+		edit.cursor = {
+			kind: "before_anchor",
+			anchor: { line: nextLineNum, hash: computeLineHash(nextLineNum, nextContent) },
+		};
+	}
+
+	// Partition edits into BOF, EOF, and anchor-targeted buckets.
+	const bofLines: string[] = [];
+	const eofLines: string[] = [];
+	const anchorEdits: IndexedEdit[] = [];
+	normalizedEdits.forEach((edit, idx) => {
+		if (edit.kind === "insert" && edit.cursor.kind === "bof") {
+			bofLines.push(edit.text);
+		} else if (edit.kind === "insert" && edit.cursor.kind === "eof") {
+			eofLines.push(edit.text);
+		} else {
+			anchorEdits.push({ edit, idx });
+		}
+	});
+
+	// Apply per-line buckets bottom-up so earlier indices stay valid.
+	const byLine = bucketAnchorEditsByLine(anchorEdits);
+	for (const line of [...byLine.keys()].sort((a, b) => b - a)) {
+		const bucket = byLine.get(line);
+		if (!bucket) continue;
+		bucket.sort((a, b) => a.idx - b.idx);
+
+		const idx = line - 1;
+		const currentLine = fileLines[idx] ?? "";
+		const beforeLines: string[] = [];
+		let deleteLine = false;
+
+		for (const { edit } of bucket) {
+			if (edit.kind === "insert") {
+				beforeLines.push(edit.text);
+			} else if (edit.kind === "delete") {
+				deleteLine = true;
+			}
+		}
+		if (beforeLines.length === 0 && !deleteLine) continue;
+
+		const replacement = deleteLine ? beforeLines : [...beforeLines, currentLine];
+		const origins = replacement.map((): HashlineLineOrigin => (deleteLine ? "replacement" : "insert"));
+		if (!deleteLine) {
+			origins[origins.length - 1] = lineOrigins[idx] ?? "original";
+		}
+
+		fileLines.splice(idx, 1, ...replacement);
+		lineOrigins.splice(idx, 1, ...origins);
+		trackFirstChanged(line);
+	}
+
+	if (bofLines.length > 0) {
+		insertAtStart(fileLines, lineOrigins, bofLines);
+		trackFirstChanged(1);
+	}
+	const eofChangedLine = insertAtEnd(fileLines, lineOrigins, eofLines);
+	if (eofChangedLine !== undefined) trackFirstChanged(eofChangedLine);
+
+	return {
+		lines: fileLines.join("\n"),
+		firstChangedLine,
+		...(warnings.length > 0 ? { warnings } : {}),
+	};
+}