@oh-my-pi/hashline 15.5.12 → 15.5.13

package/src/parser.ts

@@ -2,24 +2,14 @@
  * Token-driven state machine that turns a stream of {@link Token}s into a
  * flat list of {@link Edit}s. Sits between the {@link Tokenizer} and the
  * applier.
- *
- * Lifecycle:
- *
- * 1. Construct one {@link Executor} per patch (or share one with `reset()`).
- * 2. Feed it tokens via {@link Executor.feed}. Hunk body rows accumulate
- *    until the next hunk header or {@link end} flushes them.
- * 3. Call {@link Executor.end} to flush the trailing pending hunk and
- *    validate cross-hunk invariants (no overlapping deletes, etc.).
- *
- * Convenience entry point: {@link parsePatch}.
  */
-import { HL_PAYLOAD_REPEAT, HL_PAYLOAD_REPLACE } from "./format";
+import { HL_PAYLOAD_REPLACE } from "./format";
 import {
 	BARE_BODY_AUTO_PIPED_WARNING,
-	PLUS_PREFIXED_REPEAT_WARNING,
-	REPLACE_PAIR_COALESCED_OVERLAP_WARNING,
-	REPLACE_PAIR_COALESCED_WARNING,
-	UNIFIED_DIFF_BODY_AUTO_CONVERT_WARNING,
+	DELETE_TAKES_NO_BODY,
+	EMPTY_INSERT,
+	EMPTY_REPLACE,
+	MINUS_ROW_REJECTED,
 } from "./messages";
 import { type BlockTarget, cloneCursor, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
 import type { Anchor, Cursor, Edit } from "./types";
@@ -30,51 +20,19 @@ function validateRangeOrder(range: ParsedRange, lineNum: number): void {
 	}
 }
 
-/**
- * If `text` (the slice after a `+` literal sigil) trims to `&A..B` (or `&A`,
- * accepted as `&A,A`), return the parsed range. Otherwise `null`. Used to
- * silently reroute `+&A..B` rows as repeats — models reflexively prefix every
- * body row with `+`, including ones that should be repeats.
- */
-function tryParseLiteralAsRepeat(text: string): ParsedRange | null {
-	const stripped = text.trim();
-	if (stripped.length === 0 || stripped.charCodeAt(0) !== 38 /* & */) return null;
-	const match = /^&([1-9]\d*)(?:\.\.([1-9]\d*))?$/.exec(stripped);
-	if (match === null) return null;
-	const start = Number.parseInt(match[1], 10);
-	const end = match[2] !== undefined ? Number.parseInt(match[2], 10) : start;
-	return { start: { line: start }, end: { line: end } };
-}
-
-function rangesEqual(a: ParsedRange, b: ParsedRange): boolean {
-	return a.start.line === b.start.line && a.end.line === b.end.line;
-}
-
-function targetsEqualConcreteRange(a: BlockTarget, b: BlockTarget): boolean {
-	return a.kind === "range" && b.kind === "range" && rangesEqual(a.range, b.range);
-}
-
-function rangesOverlap(a: ParsedRange, b: ParsedRange): boolean {
-	return a.start.line <= b.end.line && b.start.line <= a.end.line;
+function expandRange(range: ParsedRange): Anchor[] {
+	const anchors: Anchor[] = [];
+	for (let line = range.start.line; line <= range.end.line; line++) anchors.push({ line });
+	return anchors;
 }
 
-function rangesOverlapBetweenTargets(a: BlockTarget, b: BlockTarget): boolean {
-	return a.kind === "range" && b.kind === "range" && rangesOverlap(a.range, b.range);
+function isSkippableCommentLine(line: string): boolean {
+	return line.trimStart().startsWith("#");
 }
 
-/**
- * Detect OpenAI-`apply_patch` / unified-diff contamination in a raw line.
- * Returns the error message to throw, or `null` when the line is clean.
- *
- * Hashline's own file-header prefix (`¶path#hash`) sits next to
- * apply_patch sentinels (`*** Update File: path`); the latter are caught
- * here. Any `@@`-bracketed shape is also caught — hashline hunks are bare
- * `A B` lines, never `@@ ... @@`.
- */
 function detectApplyPatchContamination(text: string, _hasPending: boolean): string | null {
 	const trimmed = text.trimStart();
 	if (trimmed.length === 0) return null;
-
 	if (
 		trimmed.startsWith("*** Update File:") ||
 		trimmed.startsWith("*** Add File:") ||
@@ -85,86 +43,51 @@ function detectApplyPatchContamination(text: string, _hasPending: boolean): stri
 		return (
 			`apply_patch sentinel ${JSON.stringify(preview)} is not valid in hashline. ` +
 			"File sections start with `¶path#HASH` (no `Update File:` / `Add File:` keyword). " +
-			"Hunks are bare `A B` lines with `+TEXT` / `&A..B` body rows."
+			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
 		);
 	}
 	if (/^@@\s+[-+]?\d+,\d+\s+[-+]?\d+,\d+\s+@@/.test(trimmed)) {
 		return (
 			"unified-diff hunk header (`@@ -N,M +N,M @@`) is not valid in hashline. " +
-			"Hashline hunks are bare `A B` lines (or `BOF` / `EOF` keywords)."
+			"Use `replace N..M:`, `delete N..M`, or `insert before|after|head|tail:` ops."
 		);
 	}
 	if (trimmed.startsWith("@@")) {
 		const preview = trimmed.length > 48 ? `${trimmed.slice(0, 48)}…` : trimmed;
 		return (
 			`\`@@\`-bracketed hunk header ${JSON.stringify(preview)} is not valid in hashline. ` +
-			"Drop the `@@ ... @@` brackets and write the range directly: `5 7` (`BOF` / `EOF` for virtual positions)."
+			"Drop the `@@ ... @@` brackets and write a verb header such as `replace N..M:`."
 		);
 	}
+	if (/^delete\s+[1-9]\d*(?:\s*(?:\.\.|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
+		return "`delete N..M` has no colon and no body. Remove the colon and body rows.";
+	}
 	if (/^[1-9]\d*\s*$/.test(trimmed)) {
+		return `hunk headers need a verb. Use \`replace ${trimmed}..${trimmed}:\` to replace, or \`delete ${trimmed}\` to delete.`;
+	}
+	const bareRange = /^([1-9]\d*)\s*[-. …]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
+	if (bareRange !== null) {
 		return (
-			`single-number hunk header ${JSON.stringify(trimmed)} is no longer accepted. ` +
-			`Spell single-line ranges as \`${trimmed} ${trimmed}\` (two numbers); ` +
-			"hashline hunks are bare `A B` lines (or `BOF` / `EOF`)."
+			`bare range hunk header ${JSON.stringify(trimmed)} is not valid. ` +
+			`Hunk headers need a verb: write \`replace ${bareRange[1]}..${bareRange[2]}:\` or \`delete ${bareRange[1]}..${bareRange[2]}\`.`
 		);
 	}
 	return null;
 }
 
-function pendingHasAnyContent(pending: Pending): boolean {
-	return pending.payloads.length > 0 || pending.pendingRaws.length > 0;
-}
-
-function expandRange(range: ParsedRange): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (let line = range.start.line; line <= range.end.line; line++) {
-		anchors.push({ line });
-	}
-	return anchors;
-}
-
-function isSkippableCommentLine(line: string): boolean {
-	return line.trimStart().startsWith("#");
-}
-
 interface PendingComment {
 	lineNum: number;
 	text: string;
 }
 
-type PayloadRow =
-	| { kind: "literal"; text: string; lineNum: number }
-	| { kind: "repeat"; range: ParsedRange; lineNum: number };
+type PayloadRow = { kind: "literal"; text: string; lineNum: number };
 
 interface Pending {
 	target: BlockTarget;
 	lineNum: number;
 	payloads: PayloadRow[];
-	/**
-	 * Bare body rows (no `+`/`&` prefix) buffered while we wait to see
-	 * whether the entire hunk body is uniformly unprefixed. On flush, if
-	 * every row was bare AND no `+`/`&` row was ever observed for this hunk,
-	 * we auto-prepend `+` and emit a {@link BARE_BODY_AUTO_PIPED_WARNING}.
-	 */
-	pendingRaws: { text: string; lineNum: number }[];
-	/**
-	 * Set true the first time a `-` row arrives inside the hunk body. From
-	 * then on we strip one leading space from raw rows (treating them as
-	 * unified-diff context lines) and retroactively strip the same space
-	 * from prior `pendingRaws`/`payloads` literals that began with a space.
-	 */
-	unifiedDiffMode: boolean;
 }
 
-/**
- * Token-driven state machine that turns a stream of {@link Token}s into a
- * flat list of {@link Edit}s.
- *
- * `feed()` accepts tokens one at a time; hunk body rows accumulate until
- * the next hunk header or {@link end} flushes them. After `terminated`
- * flips true (on `envelope-end` or `abort`) subsequent feeds are silently
- * ignored so callers can keep draining their tokenizer.
- */
 export class Executor {
 	#edits: Edit[] = [];
 	#warnings: string[] = [];
@@ -179,24 +102,12 @@ export class Executor {
 
 	#consumePendingSkippableComments(): void {
 		if (this.#skippableComments.length === 0) return;
-		const comment = this.#skippableComments[0];
+		for (const comment of this.#skippableComments) this.#handleRaw(comment.text, comment.lineNum);
 		this.#skippableComments = [];
-		this.#handleRaw(comment.text, comment.lineNum);
-	}
-
-	/** True once an `envelope-end` or `abort` token has been observed. */
-	get terminated(): boolean {
-		return this.#terminated;
 	}
 
-	/**
-	 * Consume one token. After `terminated` flips true subsequent feeds are
-	 * silently ignored so callers can keep draining the tokenizer without
-	 * explicit early-exit guards.
-	 */
 	feed(token: Token): void {
 		if (this.#terminated) return;
-
 		switch (token.kind) {
 			case "envelope-begin":
 				this.#consumePendingSkippableComments();
@@ -219,10 +130,6 @@ export class Executor {
 				this.#consumePendingSkippableComments();
 				this.#handleLiteralPayload(token.text, token.lineNum);
 				return;
-			case "payload-repeat":
-				this.#consumePendingSkippableComments();
-				this.#handleRepeatPayload(token.range, token.lineNum);
-				return;
 			case "raw":
 				if (this.#pending === undefined && isSkippableCommentLine(token.text)) {
 					this.#skippableComments.push({ text: token.text, lineNum: token.lineNum });
@@ -233,47 +140,15 @@ export class Executor {
 				return;
 			case "op-block":
 				this.#discardPendingSkippableComments();
-				if (token.target.kind === "range") validateRangeOrder(token.target.range, token.lineNum);
-
-				if (this.#pending !== undefined && targetsEqualConcreteRange(this.#pending.target, token.target)) {
-					// Identical-range coalesce: drop the first hunk. Last-wins.
-					this.#pending = undefined;
-					if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
-						this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
-					}
-				} else if (
-					this.#pending !== undefined &&
-					!pendingHasAnyContent(this.#pending) &&
-					rangesOverlapBetweenTargets(this.#pending.target, token.target)
-				) {
-					// Overlapping bare-then-concrete: drop the bare one.
-					this.#pending = undefined;
-					if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_OVERLAP_WARNING)) {
-						this.#warnings.push(REPLACE_PAIR_COALESCED_OVERLAP_WARNING);
-					}
-				} else {
-					this.#flushPending();
+				if (token.target.kind === "replace" || token.target.kind === "delete") {
+					validateRangeOrder(token.target.range, token.lineNum);
 				}
-				this.#pending = {
-					target: token.target,
-					lineNum: token.lineNum,
-					payloads: [],
-					pendingRaws: [],
-					unifiedDiffMode: false,
-				};
+				this.#flushPending();
+				this.#pending = { target: token.target, lineNum: token.lineNum, payloads: [] };
 				return;
 		}
 	}
 
-	/**
-	 * Flush any open pending hunk and return the accumulated edits and
-	 * warnings. The executor is single-use; {@link reset} is required for
-	 * reuse.
-	 *
-	 * Throws if two hunks target the same line with non-identical ranges.
-	 * Identical-range hunks in the same patch are coalesced last-wins by
-	 * `feed()` with a warning, so they never reach the validator.
-	 */
 	end(): { edits: Edit[]; warnings: string[] } {
 		this.#consumePendingSkippableComments();
 		this.#flushPending();
@@ -281,24 +156,15 @@ export class Executor {
 		return { edits: this.#edits, warnings: this.#warnings };
 	}
 
-	/**
-	 * Streaming-tolerant variant of {@link end}. Identical, except a pending
-	 * hunk whose body has not yet accumulated any rows is treated as still
-	 * in flight and dropped instead of flushed (which would otherwise commit
-	 * a destructive delete while the model may still be typing payload).
-	 */
 	endStreaming(): { edits: Edit[]; warnings: string[] } {
 		this.#consumePendingSkippableComments();
-		if (this.#pending && pendingHasAnyContent(this.#pending)) {
-			this.#flushPending();
-		} else {
-			this.#pending = undefined;
-		}
+		if (this.#pending && this.#pending.payloads.length > 0) this.#flushPending();
+		else if (this.#pending?.target.kind === "delete") this.#flushPending();
+		else this.#pending = undefined;
 		this.#validateNoOverlappingDeletes();
 		return { edits: this.#edits, warnings: this.#warnings };
 	}
 
-	/** Reset to a fresh state so the same instance can drive another parse. */
 	reset(): void {
 		this.#edits = [];
 		this.#warnings = [];
@@ -308,12 +174,6 @@ export class Executor {
 		this.#terminated = false;
 	}
 
-	/**
-	 * Each hunk contributes a delete edit per line in its range; if any line
-	 * ends up targeted by deletes originating from two different source
-	 * hunks (distinguished by their `lineNum`), the patch is internally
-	 * inconsistent.
-	 */
 	#validateNoOverlappingDeletes(): void {
 		const sourceLinesByAnchor = new Map<number, number[]>();
 		for (const edit of this.#edits) {
@@ -330,7 +190,7 @@ export class Executor {
 			const [firstBlock, secondBlock] = [...sourceLines].sort((a, b) => a - b);
 			throw new Error(
 				`line ${secondBlock}: anchor line ${anchorLine} is already targeted by another hunk on line ${firstBlock}. ` +
-					`Issue ONE hunk per range; payload is only the final desired content, never a before/after pair.`,
+					"Issue ONE hunk per range; payload is only the final desired content, never a before/after pair.",
 			);
 		}
 	}
@@ -343,93 +203,25 @@ export class Executor {
 					`Got ${JSON.stringify(`${HL_PAYLOAD_REPLACE}${text}`)}.`,
 			);
 		}
-		// Silent recovery: a body row of `+&A..B` (or `+&A` shorthand) is a
-		// repeat row the model mistakenly prefixed with `+`. Reroute as a
-		// repeat and surface a warning so the model sees the mistake.
-		const repeatRange = tryParseLiteralAsRepeat(text);
-		if (repeatRange !== null) {
-			if (!this.#warnings.includes(PLUS_PREFIXED_REPEAT_WARNING)) {
-				this.#warnings.push(PLUS_PREFIXED_REPEAT_WARNING);
-			}
-			this.#handleRepeatPayload(repeatRange, lineNum);
-			return;
-		}
+		if (pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
 		pending.payloads.push({ kind: "literal", text, lineNum });
 	}
 
-	#handleRepeatPayload(range: ParsedRange, lineNum: number): void {
-		const pending = this.#pending;
-		if (!pending) {
-			throw new Error(
-				`line ${lineNum}: payload line has no preceding hunk header. ` +
-					`Got ${JSON.stringify(`${HL_PAYLOAD_REPEAT}${range.start.line}..${range.end.line}`)}.`,
-			);
-		}
-		validateRangeOrder(range, lineNum);
-		pending.payloads.push({ kind: "repeat", range, lineNum });
-	}
-
-	/**
-	 * Switch the pending hunk into unified-diff mode and retroactively
-	 * strip the leading metadata-space from any literal payloads or
-	 * buffered raws that already arrived. Idempotent.
-	 */
-	#enterUnifiedDiffMode(pending: Pending): void {
-		if (pending.unifiedDiffMode) return;
-		pending.unifiedDiffMode = true;
-		for (const row of pending.pendingRaws) {
-			if (row.text.length > 0 && row.text.charCodeAt(0) === 32) {
-				row.text = row.text.slice(1);
-			}
-		}
-		for (const payload of pending.payloads) {
-			if (payload.kind === "literal" && payload.text.length > 0 && payload.text.charCodeAt(0) === 32) {
-				payload.text = payload.text.slice(1);
-			}
-		}
-	}
-
 	#handleRaw(text: string, lineNum: number): void {
-		// Detect OpenAI-apply_patch / unified-diff contamination first so the
-		// error message names the offending shape instead of the generic
-		// "payload row must start with …" diagnostic.
 		const contamination = detectApplyPatchContamination(text, this.#pending !== undefined);
 		if (contamination !== null) throw new Error(`line ${lineNum}: ${contamination}`);
-
 		if (this.#pending) {
 			if (text.trim().length === 0) return;
-
-			// L9: `-`-prefixed body rows are unified-diff "removed" markers.
-			// The hunk header's range already deletes those lines, so we
-			// silently drop them and enter unified-diff mode for subsequent
-			// rows (which causes leading-space stripping on context lines).
-			if (text.charCodeAt(0) === 45 /* - */) {
-				this.#enterUnifiedDiffMode(this.#pending);
-				if (!this.#warnings.includes(UNIFIED_DIFF_BODY_AUTO_CONVERT_WARNING)) {
-					this.#warnings.push(UNIFIED_DIFF_BODY_AUTO_CONVERT_WARNING);
-				}
-				return;
-			}
-
-			// Treat any non-`+`/`&` body row as a literal. When the hunk is
-			// in unified-diff mode and the row carries the metadata leading
-			// space, strip ONE space so the actual content lands cleanly.
-			const literalText =
-				this.#pending.unifiedDiffMode && text.charCodeAt(0) === 32 /* space */ ? text.slice(1) : text;
-			if (!this.#warnings.includes(BARE_BODY_AUTO_PIPED_WARNING)) {
-				this.#warnings.push(BARE_BODY_AUTO_PIPED_WARNING);
-			}
-			this.#pending.payloads.push({ kind: "literal", text: literalText, lineNum });
+			if (this.#pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
+			if (text.trimStart().charCodeAt(0) === 45 /* - */) throw new Error(`line ${lineNum}: ${MINUS_ROW_REJECTED}`);
+			if (!this.#warnings.includes(BARE_BODY_AUTO_PIPED_WARNING)) this.#warnings.push(BARE_BODY_AUTO_PIPED_WARNING);
+			this.#pending.payloads.push({ kind: "literal", text, lineNum });
 			return;
 		}
-
-		// Whitespace-only raw lines outside any pending block are silently
-		// dropped; fully empty lines arrive as `blank` tokens.
 		if (text.trim().length === 0) return;
-
 		throw new Error(
 			`line ${lineNum}: payload line has no preceding hunk header. ` +
-				`Use an \`A B\` (or \`BOF\` / \`EOF\`) line above the body. Got ${JSON.stringify(text)}.`,
+				`Use \`replace N..M:\`, \`delete N..M\`, or \`insert before|after|head|tail:\` above the body. Got ${JSON.stringify(text)}.`,
 		);
 	}
 
@@ -444,112 +236,62 @@ export class Executor {
 		});
 	}
 
-	#pushRepeat(cursor: Cursor, range: ParsedRange, lineNum: number, mode?: "replacement"): void {
-		this.#edits.push({
-			kind: "repeat",
-			cursor: cloneCursor(cursor),
-			range: { start: { ...range.start }, end: { ...range.end } },
-			lineNum,
-			index: this.#editIndex++,
-			...(mode === undefined ? {} : { mode }),
-		});
-	}
-
 	#pushDelete(anchor: Anchor, lineNum: number): void {
 		this.#edits.push({ kind: "delete", anchor: { ...anchor }, lineNum, index: this.#editIndex++ });
 	}
 
-	#emitPayloadRow(cursor: Cursor, payload: PayloadRow, lineNum: number, mode?: "replacement"): void {
-		if (payload.kind === "literal") {
-			this.#pushInsert(cursor, payload.text, lineNum, mode);
-			return;
-		}
-		this.#pushRepeat(cursor, payload.range, lineNum, mode);
+	#emitPayloadRows(cursor: Cursor, payloads: readonly PayloadRow[], lineNum: number, mode?: "replacement"): void {
+		for (const payload of payloads) this.#pushInsert(cursor, payload.text, lineNum, mode);
 	}
 
 	#flushPending(): void {
 		const pending = this.#pending;
 		if (!pending) return;
-
-		// Convert any buffered bare body rows to literal payloads. Mixed
-		// blocks have already been rejected; we only get here when payloads
-		// `pendingRaws` is kept for type compatibility but no longer used —
-		// bare rows are now pushed directly into `payloads` as literals at
-		// arrival time (preserving body-row order).
 		const { target, lineNum, payloads } = pending;
-		if (target.kind === "bof" || target.kind === "eof") {
-			const cursor: Cursor = target.kind === "bof" ? { kind: "bof" } : { kind: "eof" };
-			for (const payload of payloads) {
-				this.#emitPayloadRow(cursor, payload, lineNum);
-			}
-			// Empty body at BOF/EOF is a no-op (nothing to insert).
-			this.#pending = undefined;
+		this.#pending = undefined;
+		if (target.kind === "delete") {
+			for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);
 			return;
 		}
-
-		const cursor: Cursor = { kind: "before_anchor", anchor: { ...target.range.start } };
-		// Empty body = pure delete. Otherwise, emit the body rows as
-		// replacement payload and delete the original range.
-		for (const payload of payloads) {
-			this.#emitPayloadRow(cursor, payload, lineNum, "replacement");
+		if (payloads.length === 0) {
+			if (target.kind === "replace") throw new Error(`line ${lineNum}: ${EMPTY_REPLACE}`);
+			throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
 		}
-		for (const anchor of expandRange(target.range)) {
-			this.#pushDelete(anchor, lineNum);
+		if (target.kind === "replace") {
+			const cursor: Cursor = { kind: "before_anchor", anchor: { ...target.range.start } };
+			this.#emitPayloadRows(cursor, payloads, lineNum, "replacement");
+			for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);
+			return;
 		}
-		this.#pending = undefined;
+		if (target.kind === "insert_before") {
+			this.#emitPayloadRows({ kind: "before_anchor", anchor: { ...target.anchor } }, payloads, lineNum);
+			return;
+		}
+		if (target.kind === "insert_after") {
+			this.#emitPayloadRows({ kind: "after_anchor", anchor: { ...target.anchor } }, payloads, lineNum);
+			return;
+		}
+		const cursor: Cursor = target.kind === "bof" ? { kind: "bof" } : { kind: "eof" };
+		this.#emitPayloadRows(cursor, payloads, lineNum);
 	}
 }
 
-/**
- * Drive a full hashline diff through the tokenizer + executor pipeline and
- * return the resulting edits plus any parse-time warnings. This is the
- * convenience entry point most callers want; reach for {@link Tokenizer} /
- * {@link Executor} directly only when you need streaming feeds, cross-section
- * state, or custom token handling.
- */
+function drain(executor: Executor, tokenizer: Tokenizer): { edits: Edit[]; warnings: string[] } {
+	for (const token of tokenizer.end()) executor.feed(token);
+	return executor.end();
+}
+
 export function parsePatch(diff: string): { edits: Edit[]; warnings: string[] } {
 	const tokenizer = new Tokenizer();
 	const executor = new Executor();
-	const drain = (tokens: Token[]): void => {
-		for (const token of tokens) {
-			if (executor.terminated) return;
-			executor.feed(token);
-		}
-	};
-	drain(tokenizer.feed(diff));
-	drain(tokenizer.end());
-	return executor.end();
+	for (const token of tokenizer.feed(diff)) executor.feed(token);
+	return drain(executor, tokenizer);
 }
 
-/**
- * Streaming-tolerant variant of {@link parsePatch}. Returns whatever edits
- * parsed successfully when the diff is still being typed:
- *
- * - per-token feed errors stop the drain but preserve the edits already
- *   collected (the trailing hunk is malformed mid-stream — wait for the
- *   next chunk),
- * - the trailing pending hunk is dropped if it has no payload yet (avoids
- *   a destructive bare-delete preview while payload may still be coming).
- *
- * Throws only on the cross-hunk overlap validator, which catches conflicting
- * shapes (two hunks hitting the same anchor). Streaming preview callers
- * should treat any throw here as "no preview this tick".
- */
 export function parsePatchStreaming(diff: string): { edits: Edit[]; warnings: string[] } {
 	const tokenizer = new Tokenizer();
 	const executor = new Executor();
-	const drain = (tokens: Token[]): boolean => {
-		for (const token of tokens) {
-			if (executor.terminated) return false;
-			try {
-				executor.feed(token);
-			} catch {
-				return true; // stop on first parse error; keep what's collected
-			}
-		}
-		return false;
-	};
-	if (drain(tokenizer.feed(diff))) return executor.endStreaming();
-	drain(tokenizer.end());
+	for (const token of tokenizer.feed(diff)) executor.feed(token);
+	for (const token of tokenizer.end()) executor.feed(token);
 	return executor.endStreaming();
 }

package/src/patcher.ts

@@ -23,14 +23,14 @@
  * filesystem configuration.
  */
 import { applyEdits } from "./apply";
-import { formatHashlineHeader, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./format";
+import { computeFileHash, formatHashlineHeader, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./format";
 import type { Filesystem, WriteResult } from "./fs";
 import { isNotFound } from "./fs";
 import type { Patch, PatchSection } from "./input";
 import { MismatchError } from "./mismatch";
 import { detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { Recovery, type RecoveryResult } from "./recovery";
-import type { Snapshot, SnapshotStore } from "./snapshots";
+import type { SnapshotStore } from "./snapshots";
 import type { ApplyResult, Edit } from "./types";
 
 export interface PatcherOptions {
@@ -97,8 +97,8 @@ export class PreparedSection {
 
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
-		if (edit.kind === "delete" || edit.kind === "repeat") return true;
-		return edit.cursor.kind === "before_anchor";
+		if (edit.kind === "delete") return true;
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }
 
@@ -116,25 +116,6 @@ function recoveryToApplyResult(result: RecoveryResult): ApplyResult {
 		warnings: result.warnings,
 	};
 }
-
-/**
- * Decide whether `snapshot` proves the live file is byte-for-byte the read
- * the model authored against. Two shapes:
- *   - Full-text snapshot: cheap string equality.
- *   - Sparse snapshot (e.g. selector reads, search hits): every anchor line
- *     must be in the snapshot AND every recorded line must match the live
- *     file. Without this branch, sparse reads can't short-circuit and fall
- *     through to recovery, which declines them as "patcher-owned direct
- *     apply" — yielding a spurious MismatchError on unchanged files.
- */
-function snapshotProvesUnchanged(snapshot: Snapshot, currentText: string, section: PatchSection): boolean {
-	if (snapshot.fullText !== undefined) return snapshot.fullText === currentText;
-	for (const lineNumber of section.collectAnchorLines()) {
-		if (snapshot.get(lineNumber) === undefined) return false;
-	}
-	return snapshot.matchesLiveFile(currentText.split("\n"));
-}
-
 function mergeWarnings(...sources: ReadonlyArray<readonly string[] | undefined>): string[] {
 	const out: string[] = [];
 	for (const source of sources) {
@@ -324,9 +305,8 @@ export class Patcher {
 	}
 
 	#recordFullSnapshot(canonicalPath: string, normalized: string): string {
-		return this.snapshots.recordContiguous(canonicalPath, 1, normalized.split("\n"), { fullText: normalized });
+		return this.snapshots.record(canonicalPath, normalized);
 	}
-
 	#applyWithRecovery(args: {
 		section: PatchSection;
 		canonicalPath: string;
@@ -337,29 +317,27 @@ export class Patcher {
 		const { section, canonicalPath, exists, normalized, edits } = args;
 		const expected = exists ? section.fileHash : undefined;
 		if (expected === undefined) return applyEdits(normalized, [...edits]);
-
-		const snapshot = this.snapshots.byHash(canonicalPath, expected);
-		if (snapshot && snapshotProvesUnchanged(snapshot, normalized, section)) {
-			return applyEdits(normalized, [...edits]);
-		}
-		if (snapshot) {
-			const recovered = this.recovery.tryRecover({
-				path: canonicalPath,
-				currentText: normalized,
-				fileHash: expected,
-				edits,
-			});
-			if (recovered) return recoveryToApplyResult(recovered);
-		}
-
-		const currentHash = this.#recordFullSnapshot(canonicalPath, normalized);
+		// Whole-file unchanged → the tag still names the live content, so an
+		// edit anchored at ANY line (displayed or not) is safe to apply.
+		if (computeFileHash(normalized) === expected) return applyEdits(normalized, [...edits]);
+		// File drifted: try to replay the edit against the version the tag
+		// names and 3-way-merge it onto the live content.
+		const recovered = this.recovery.tryRecover({
+			path: canonicalPath,
+			currentText: normalized,
+			fileHash: expected,
+			edits,
+		});
+		if (recovered) return recoveryToApplyResult(recovered);
+		const hashRecognized = this.snapshots.byHash(canonicalPath, expected) !== null;
+		const actualFileHash = this.#recordFullSnapshot(canonicalPath, normalized);
 		throw new MismatchError({
 			path: section.path,
 			expectedFileHash: expected,
-			actualFileHash: currentHash,
+			actualFileHash,
 			fileLines: normalized.split("\n"),
 			anchorLines: section.collectAnchorLines(),
-			hashRecognized: snapshot !== null,
+			hashRecognized,
 		});
 	}
 }