@oh-my-pi/hashline 15.5.4 → 15.5.7

package/src/messages.ts

@@ -27,41 +27,18 @@ export const ABORT_WARNING =
 	"Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";
 
 /**
- * Warning text appended when two consecutive `A-B:` ops on the exact same
- * range get coalesced (model painted a before/after pair). The second op wins;
- * the first op's payload is silently discarded.
+ * Warning text appended when two consecutive blocks target the exact same
+ * concrete range. The second block wins; the first block is discarded.
  */
 export const REPLACE_PAIR_COALESCED_WARNING =
-	"Detected an identical-range before/after replace pair; kept only the second block's payload. Issue ONE op per range — the payload is the final desired content, never both old and new.";
+	"Detected two identical-range hashline blocks; kept only the second block. Issue ONE block per range — payload is the final desired content, never both old and new.";
 
-/**
- * Warning text appended when un-prefixed continuation lines are accepted as
- * implicit payload (lenient legacy behavior). The author wrote a multi-line
- * replace without `+` prefixes; the parser accepted it because the lines did
- * not classify as ops/headers/payloads, but the canonical syntax requires `+`
- * on every continuation line after the op.
- */
-export const IMPLICIT_CONTINUATION_WARNING =
-	"Accepted continuation line(s) without the `+` prefix as implicit payload. Canonical syntax is `A-B:` followed by `+` on every continuation row; without `+`, lines that look like ops will be parsed as new ops instead of payload. Prefer the explicit form.";
+/** Error text prefix emitted when an anchor line carries inline payload. */
+export const INLINE_PAYLOAD_REJECTED_PREFIX = "Inline payload on the anchor line is rejected.";
 
-/**
- * Warning text appended when an inner `LINE:TEXT` (or sub-range `A-B:TEXT`)
- * op arrives while an outer `A-B:` replace is still pending and the inner
- * anchor falls inside the outer range. The author used the read-output
- * `LINE:TEXT` format as if it were a payload-continuation line; we strip the
- * `LINE:` prefix and append the body to the pending payload, but warn so the
- * canonical `+`-continuation form remains preferred.
- */
-export const PAYLOAD_LINE_PREFIX_DEMOTED_WARNING =
-	"Detected one or more `LINE:TEXT` lines whose anchors fell inside a pending replace range; treated them as payload-continuation lines and stripped the `LINE:` prefix. Inside an `A-B:` block, every payload line must be on its own row prefixed with `+` — never reuse the read-output gutter format.";
-
-/**
- * Warning text appended when an op carries an inline payload (`LINE:TEXT`,
- * `LINE↑CONTENT`, `LINE↓CONTENT`). Canonical syntax is the bare op followed
- * by `+`-prefixed payload rows on the next line(s).
- */
-export const INLINE_PAYLOAD_ACCEPTED_WARNING =
-	"Accepted inline payload on the op line (e.g. `LINE:CONTENT`, `LINE↑CONTENT`). Canonical syntax is the bare op followed by `+`-prefixed payload rows on the next line(s). Prefer the explicit form.";
+/** Error text emitted when `|` replacement payload targets BOF/EOF. */
+export const VIRTUAL_REPLACE_REJECTED_MESSAGE =
+	"BOF:/EOF: anchors are virtual positions and cannot use `|` replacement payload. Use `↑` or `↓` payload lines.";
 
 /** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
 export const RECOVERY_EXTERNAL_WARNING =
@@ -71,6 +48,14 @@ export const RECOVERY_EXTERNAL_WARNING =
 export const RECOVERY_SESSION_CHAIN_WARNING =
 	"Recovered from a stale file hash using an earlier in-session snapshot (the file hash advanced after a prior edit in this session).";
 
-/** Warning text emitted by `Recovery` when the session-chain fast-path was taken. */
+/**
+ * Warning text emitted by `Recovery` when the session-chain replay
+ * fast-path was taken. Distinct from {@link RECOVERY_SESSION_CHAIN_WARNING}
+ * because replay is the less-certain mode: the structured-patch 3-way
+ * merge refused, the anchor-content gate passed, but a coincidental
+ * insert+delete pair earlier in the chain could still leave an anchor's
+ * line number pointing at a duplicated row. Surface the hedge so the
+ * model verifies before continuing.
+ */
 export const RECOVERY_SESSION_REPLAY_WARNING =
 	"Recovered by replaying your edits onto the current file content — your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";

package/src/parser.ts

@@ -6,29 +6,28 @@
  * Lifecycle:
  *
  * 1. Construct one {@link Executor} per hunk (or share one with `reset()`).
- * 2. Feed it tokens via {@link Executor.feed}. Multi-line payloads are
- *    accumulated across tokens until the next op flushes them.
- * 3. Call {@link Executor.end} to flush the trailing pending op and validate
- *    cross-op invariants (no overlapping deletes, etc.).
+ * 2. Feed it tokens via {@link Executor.feed}. Block payload rows are
+ *    accumulated across tokens until the next anchor block flushes them.
+ * 3. Call {@link Executor.end} to flush the trailing pending block and validate
+ *    cross-block invariants (no overlapping deletes, etc.).
  *
  * Convenience entry point: {@link parsePatch}.
  */
-import {
-	HL_OP_CHARS,
-	HL_OP_DELETE,
-	HL_OP_INSERT_AFTER,
-	HL_OP_INSERT_BEFORE,
-	HL_OP_REPLACE,
-	HL_PAYLOAD_PREFIX,
-} from "./format";
+import { HL_OP_REPLACE, HL_PAYLOAD_ABOVE, HL_PAYLOAD_BELOW, HL_PAYLOAD_REPLACE } from "./format";
 import {
 	ABORT_WARNING,
-	IMPLICIT_CONTINUATION_WARNING,
-	INLINE_PAYLOAD_ACCEPTED_WARNING,
-	PAYLOAD_LINE_PREFIX_DEMOTED_WARNING,
+	INLINE_PAYLOAD_REJECTED_PREFIX,
 	REPLACE_PAIR_COALESCED_WARNING,
+	VIRTUAL_REPLACE_REJECTED_MESSAGE,
 } from "./messages";
-import { cloneCursor, isDeleteOpWithPayload, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
+import {
+	type BlockTarget,
+	cloneCursor,
+	type ParsedRange,
+	type PayloadBucket,
+	type Token,
+	Tokenizer,
+} from "./tokenizer";
 import type { Anchor, Cursor, Edit } from "./types";
 
 function validateRangeOrder(range: ParsedRange, lineNum: number): void {
@@ -41,8 +40,8 @@ function rangesEqual(a: ParsedRange, b: ParsedRange): boolean {
 	return a.start.line === b.start.line && a.end.line === b.end.line;
 }
 
-function rangeContains(outer: ParsedRange, inner: ParsedRange): boolean {
-	return outer.start.line <= inner.start.line && inner.end.line <= outer.end.line;
+function targetsEqualConcreteRange(a: BlockTarget, b: BlockTarget): boolean {
+	return a.kind === "range" && b.kind === "range" && rangesEqual(a.range, b.range);
 }
 
 function expandRange(range: ParsedRange): Anchor[] {
@@ -53,21 +52,46 @@ function expandRange(range: ParsedRange): Anchor[] {
 	return anchors;
 }
 
-type PendingOp =
-	| { kind: "insert"; cursor: Cursor; lineNum: number }
-	| { kind: "replace"; range: ParsedRange; lineNum: number };
+function isSkippableCommentLine(line: string): boolean {
+	return line.trimStart().startsWith("#");
+}
+
+function sigilForBucket(bucket: PayloadBucket): string {
+	if (bucket === "above") return HL_PAYLOAD_ABOVE;
+	if (bucket === "below") return HL_PAYLOAD_BELOW;
+	return HL_PAYLOAD_REPLACE;
+}
+
+function describeTarget(target: BlockTarget): string {
+	if (target.kind === "bof") return "BOF:";
+	if (target.kind === "eof") return "EOF:";
+	const { start, end } = target.range;
+	return start.line === end.line ? `${start.line}:` : `${start.line}-${end.line}:`;
+}
+
+interface PendingComment {
+	lineNum: number;
+	text: string;
+}
+
+interface PayloadRow {
+	bucket: PayloadBucket;
+	text: string;
+	lineNum: number;
+}
 
 interface Pending {
-	op: PendingOp;
-	payload: string[];
+	target: BlockTarget;
+	lineNum: number;
+	payloads: PayloadRow[];
 }
 
 /**
  * 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; multi-line payloads accumulate
- * until the next op or {@link end} flushes them. After `terminated` flips
+ * `feed()` accepts tokens one at a time; block payload rows accumulate until
+ * the next anchor block 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.
  */
@@ -77,6 +101,18 @@ export class Executor {
 	#editIndex = 0;
 	#pending: Pending | undefined;
 	#terminated = false;
+	#skippableComments: PendingComment[] = [];
+
+	#discardPendingSkippableComments(): void {
+		this.#skippableComments = [];
+	}
+
+	#consumePendingSkippableComments(): void {
+		if (this.#skippableComments.length === 0) return;
+		const comment = this.#skippableComments[0];
+		this.#skippableComments = [];
+		this.#handleRaw(comment.text, comment.lineNum);
+	}
 
 	/** True once an `envelope-end` or `abort` token has been observed. */
 	get terminated(): boolean {
@@ -85,7 +121,7 @@ export class Executor {
 
 	/**
 	 * Consume one token. After `terminated` flips true subsequent feeds are
-	 * silently ignored so callers can keep draining their tokenizer without
+	 * silently ignored so callers can keep draining the tokenizer without
 	 * explicit early-exit guards.
 	 */
 	feed(token: Token): void {
@@ -93,8 +129,10 @@ export class Executor {
 
 		switch (token.kind) {
 			case "envelope-begin":
+				this.#consumePendingSkippableComments();
 				return;
 			case "envelope-end":
+				this.#consumePendingSkippableComments();
 				this.#terminated = true;
 				return;
 			case "abort":
@@ -102,120 +140,95 @@ export class Executor {
 				this.#terminated = true;
 				return;
 			case "header":
+				this.#consumePendingSkippableComments();
 				this.#flushPending();
 				return;
 			case "blank":
+				this.#consumePendingSkippableComments();
 				return;
 			case "payload":
-				this.#handlePayload(token.text, token.lineNum);
+				this.#consumePendingSkippableComments();
+				this.#handlePayload(token.bucket, token.text, token.lineNum);
 				return;
 			case "raw":
+				if (this.#pending === undefined && isSkippableCommentLine(token.text)) {
+					this.#skippableComments.push({ text: token.text, lineNum: token.lineNum });
+					return;
+				}
+				this.#consumePendingSkippableComments();
 				this.#handleRaw(token.text, token.lineNum);
 				return;
-			case "op-delete":
-				this.#flushPending();
-				if (token.trailingPayload) {
+			case "op-block":
+				this.#discardPendingSkippableComments();
+				if (token.inlineBody !== undefined) {
 					throw new Error(
-						`line ${token.lineNum}: ${HL_OP_DELETE} deletes only. Payload is forbidden after ${HL_OP_DELETE}; use ${HL_OP_REPLACE} to replace.`,
+						`line ${token.lineNum}: ${INLINE_PAYLOAD_REJECTED_PREFIX} ` +
+							`Use a bare anchor line such as ${describeTarget(token.target)}, then put payload on following rows prefixed with ` +
+							`${HL_PAYLOAD_REPLACE}, ${HL_PAYLOAD_ABOVE}, or ${HL_PAYLOAD_BELOW}.`,
 					);
 				}
-				validateRangeOrder(token.range, token.lineNum);
-				for (const anchor of expandRange(token.range)) {
-					this.#edits.push({ kind: "delete", anchor, lineNum: token.lineNum, index: this.#editIndex++ });
-				}
-				return;
-			case "op-insert":
-				this.#flushPending();
-				this.#pending = {
-					op: { kind: "insert", cursor: token.cursor, lineNum: token.lineNum },
-					payload: [],
-				};
-				if (token.inlineBody !== undefined) {
-					this.#pending.payload.push(token.inlineBody);
-					if (!this.#warnings.includes(INLINE_PAYLOAD_ACCEPTED_WARNING)) {
-						this.#warnings.push(INLINE_PAYLOAD_ACCEPTED_WARNING);
-					}
-				}
-				return;
-			case "op-replace":
-				validateRangeOrder(token.range, token.lineNum);
-				if (this.#pending !== undefined && this.#pending.op.kind === "replace") {
-					const outer = this.#pending.op.range;
-					const inner = token.range;
-					if (rangesEqual(outer, inner)) {
-						// Identical-range before/after pair. Drop the "before" payload
-						// silently; the second op proceeds as the lone winner. Other
-						// overlap shapes (different ranges, replace+delete, delete+delete)
-						// still hit the post-hoc validator.
-						this.#pending = undefined;
-						if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
-							this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
-						}
-					} else if (rangeContains(outer, inner)) {
-						// Model wrote a payload line in read-output `LINE:TEXT` format
-						// (or `A-B:TEXT` for a sub-range) inside an outer `A-B:` block.
-						// The tokenizer can't tell payload from op when the anchor and
-						// sigil shape are identical, so demote: append the op's inline
-						// body to the pending payload, strip the `LINE:` prefix, and
-						// keep accumulating. Without this the inner anchors would each
-						// register as their own delete and clash with the outer range.
-						this.#pending.payload.push(token.inlineBody ?? "");
-						if (!this.#warnings.includes(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING)) {
-							this.#warnings.push(PAYLOAD_LINE_PREFIX_DEMOTED_WARNING);
-						}
-						return;
-					}
-				}
-				this.#flushPending();
-				this.#pending = {
-					op: { kind: "replace", range: token.range, lineNum: token.lineNum },
-					payload: [],
-				};
-				if (token.inlineBody !== undefined) {
-					this.#pending.payload.push(token.inlineBody);
-					if (!this.#warnings.includes(INLINE_PAYLOAD_ACCEPTED_WARNING)) {
-						this.#warnings.push(INLINE_PAYLOAD_ACCEPTED_WARNING);
+				if (token.target.kind === "range") validateRangeOrder(token.target.range, token.lineNum);
+				if (this.#pending !== undefined && targetsEqualConcreteRange(this.#pending.target, token.target)) {
+					this.#pending = undefined;
+					if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
+						this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
 					}
+				} else {
+					this.#flushPending();
 				}
+				this.#pending = { target: token.target, lineNum: token.lineNum, payloads: [] };
 				return;
 		}
 	}
 
 	/**
-	 * Flush any open pending op (with its full accumulated payload, including
-	 * explicit `+` blank lines) and return the accumulated edits and
-	 * warnings. The executor is single-use; {@link reset} is required for
-	 * reuse.
+	 * Flush any open pending block and return the accumulated edits and
+	 * warnings. The executor is single-use; {@link reset} is required for reuse.
 	 *
-	 * Throws if two replace/delete ops target the same line with non-identical
-	 * shapes (different ranges, replace+delete, delete+delete). Identical-range
-	 * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
-	 * warning, so they never reach the validator.
+	 * Throws if two replacement/delete blocks target the same line with
+	 * non-identical ranges. Identical-range blocks in the same hunk are
+	 * coalesced last-wins by `feed()` with a warning, so they never reach the
+	 * validator.
 	 */
 	end(): { edits: Edit[]; warnings: string[] } {
+		this.#consumePendingSkippableComments();
 		this.#flushPending();
 		this.#validateNoOverlappingDeletes();
 		return { edits: this.#edits, warnings: this.#warnings };
 	}
 
+	/**
+	 * Streaming-tolerant variant of {@link end}. Identical, except a pending
+	 * block whose payload has not yet accumulated any rows is treated as still
+	 * in flight and dropped instead of flushed (which would otherwise preview a
+	 * destructive bare delete while the model may still be typing payload).
+	 */
+	endStreaming(): { edits: Edit[]; warnings: string[] } {
+		this.#consumePendingSkippableComments();
+		if (this.#pending && this.#pending.payloads.length > 0) {
+			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 = [];
 		this.#editIndex = 0;
 		this.#pending = undefined;
+		this.#skippableComments = [];
 		this.#terminated = false;
 	}
 
 	/**
-	 * Each `:` / `!` op contributes a delete edit per line in its range; if
-	 * any line ends up targeted by deletes originating from two different
-	 * source ops (distinguished by their `lineNum`), the patch is internally
-	 * inconsistent. Identical-range `A-B:` pairs are already collapsed by
-	 * `feed()`; remaining shapes here are an `A-B:` that overlaps a later
-	 * `N!`/`N:` with a different range, or two `!` deletes on the same line.
-	 * The applier would run both literally and the file would end up with two
-	 * copies of the line, not a chosen winner.
+	 * Each replacement/delete block contributes a delete edit per line in its
+	 * range; if any line ends up targeted by deletes originating from two
+	 * different source blocks (distinguished by their `lineNum`), the patch is
+	 * internally inconsistent.
 	 */
 	#validateNoOverlappingDeletes(): void {
 		const sourceLinesByAnchor = new Map<number, number[]>();
@@ -230,100 +243,118 @@ export class Executor {
 		}
 		for (const [anchorLine, sourceLines] of sourceLinesByAnchor) {
 			if (sourceLines.length < 2) continue;
-			const [firstOp, secondOp] = [...sourceLines].sort((a, b) => a - b);
+			const [firstBlock, secondBlock] = [...sourceLines].sort((a, b) => a - b);
 			throw new Error(
-				`line ${secondOp}: anchor line ${anchorLine} is already targeted by the ${HL_OP_REPLACE}/${HL_OP_DELETE} op on line ${firstOp}. ` +
-					`Issue ONE op per range; payload is only the final desired content, never a before/after pair.`,
+				`line ${secondBlock}: anchor line ${anchorLine} is already targeted by the ${HL_OP_REPLACE} block on line ${firstBlock}. ` +
+					`Issue ONE block per range; payload is only the final desired content, never a before/after pair.`,
 			);
 		}
 	}
 
-	#handlePayload(text: string, lineNum: number): void {
-		if (this.#pending) {
-			this.#pending.payload.push(text);
-			return;
+	#handlePayload(bucket: PayloadBucket, text: string, lineNum: number): void {
+		const pending = this.#pending;
+		if (!pending) {
+			throw new Error(
+				`line ${lineNum}: payload line has no preceding A-B:, A:, BOF:, or EOF: anchor. ` +
+					`Got ${JSON.stringify(`${sigilForBucket(bucket)}${text}`)}.`,
+			);
 		}
-
-		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
-				`Got ${JSON.stringify(`${HL_PAYLOAD_PREFIX}${text}`)}.`,
-		);
+		if (bucket === "replace" && pending.target.kind !== "range") {
+			throw new Error(`line ${lineNum}: ${VIRTUAL_REPLACE_REJECTED_MESSAGE}`);
+		}
+		pending.payloads.push({ bucket, text, lineNum });
 	}
 
 	#handleRaw(text: string, lineNum: number): void {
 		if (this.#pending) {
 			if (text.trim().length === 0) return;
-			// Lenient legacy fallback: the tokenizer routes a line to `raw` only
-			// when it does not parse as an op, header, payload, or envelope
-			// marker. A `raw` token while a pending op exists is therefore an
-			// unambiguous continuation row that the author wrote without the
-			// `+` prefix. Accept it as payload and warn so the canonical
-			// `+`-prefixed form remains preferred.
-			this.#pending.payload.push(text);
-			if (!this.#warnings.includes(IMPLICIT_CONTINUATION_WARNING)) {
-				this.#warnings.push(IMPLICIT_CONTINUATION_WARNING);
-			}
-			return;
+			throw new Error(
+				`line ${lineNum}: payload row in a hashline block must start with ` +
+					`${HL_PAYLOAD_REPLACE}, ${HL_PAYLOAD_ABOVE}, or ${HL_PAYLOAD_BELOW}. Got ${JSON.stringify(text)}.`,
+			);
 		}
 
-		// Whitespace-only raw lines outside any pending op are silently dropped;
+		// Whitespace-only raw lines outside any pending block are silently dropped;
 		// fully empty lines arrive as `blank` tokens.
 		if (text.trim().length === 0) return;
-		// Orphan raw text outside any pending op: pick the most specific
-		// diagnostic so the user sees the actionable hint.
-		if (isDeleteOpWithPayload(text)) {
-			throw new Error(
-				`line ${lineNum}: ${HL_OP_DELETE} deletes only. Payload is forbidden after ${HL_OP_DELETE}; use ${HL_OP_REPLACE} to replace.`,
-			);
-		}
 
 		const firstChar = text[0];
-		const startsWithOp = firstChar !== undefined && HL_OP_CHARS.includes(firstChar);
-		if (startsWithOp || firstChar === "-" || firstChar === "@" || firstChar === "«" || firstChar === "»") {
+		if (firstChar === "-" || firstChar === "@" || firstChar === "«" || firstChar === "»") {
 			throw new Error(
-				`line ${lineNum}: unrecognized op. Use LINE${HL_OP_INSERT_BEFORE} (insert before), LINE${HL_OP_INSERT_AFTER} (insert after), LINE${HL_OP_REPLACE} / A-B${HL_OP_REPLACE} (replace), or LINE${HL_OP_DELETE} / A-B${HL_OP_DELETE} (delete). ` +
-					`Got ${JSON.stringify(text)}.`,
+				`line ${lineNum}: unrecognized hashline block. Use A-B:, A:, BOF:, or EOF: anchors followed by ` +
+					`${HL_PAYLOAD_REPLACE}, ${HL_PAYLOAD_ABOVE}, or ${HL_PAYLOAD_BELOW} payload rows. Got ${JSON.stringify(text)}.`,
 			);
 		}
 
 		throw new Error(
-			`line ${lineNum}: payload line has no preceding ${HL_OP_INSERT_BEFORE}, ${HL_OP_INSERT_AFTER}, ${HL_OP_REPLACE}, or ${HL_OP_DELETE} operation. ` +
-				`Got ${JSON.stringify(text)}.`,
+			`line ${lineNum}: payload line has no preceding A-B:, A:, BOF:, or EOF: anchor. Got ${JSON.stringify(text)}.`,
 		);
 	}
 
+	#pushInsert(cursor: Cursor, text: string, lineNum: number, mode?: "replacement"): void {
+		this.#edits.push({
+			kind: "insert",
+			cursor: cloneCursor(cursor),
+			text,
+			lineNum,
+			index: this.#editIndex++,
+			...(mode === undefined ? {} : { mode }),
+		});
+	}
+
+	#pushDelete(anchor: Anchor, lineNum: number): void {
+		this.#edits.push({ kind: "delete", anchor: { ...anchor }, lineNum, index: this.#editIndex++ });
+	}
+
 	#flushPending(): void {
 		const pending = this.#pending;
 		if (!pending) return;
 
-		const { op, payload } = pending;
-		const linesToInsert = payload.length === 0 ? [""] : payload;
+		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.#pushInsert(cursor, payload.text, lineNum);
+			}
+			this.#pending = undefined;
+			return;
+		}
+
+		const above: string[] = [];
+		const replacement: string[] = [];
+		const below: string[] = [];
+		for (const payload of payloads) {
+			if (payload.bucket === "above") above.push(payload.text);
+			else if (payload.bucket === "below") below.push(payload.text);
+			else replacement.push(payload.text);
+		}
+
+		for (const text of above) {
+			this.#pushInsert({ kind: "before_anchor", anchor: { ...target.range.start } }, text, lineNum);
+		}
 
-		if (op.kind === "insert") {
-			for (const text of linesToInsert) {
-				this.#edits.push({
-					kind: "insert",
-					cursor: cloneCursor(op.cursor),
+		if (replacement.length > 0) {
+			for (const text of replacement) {
+				this.#pushInsert(
+					{ kind: "before_anchor", anchor: { ...target.range.start } },
 					text,
-					lineNum: op.lineNum,
-					index: this.#editIndex++,
-				});
+					lineNum,
+					"replacement",
+				);
 			}
-		} else {
-			for (const text of linesToInsert) {
-				this.#edits.push({
-					kind: "insert",
-					cursor: { kind: "before_anchor", anchor: { ...op.range.start } },
-					text,
-					lineNum: op.lineNum,
-					index: this.#editIndex++,
-				});
+			for (const anchor of expandRange(target.range)) {
+				this.#pushDelete(anchor, lineNum);
 			}
-			for (const anchor of expandRange(op.range)) {
-				this.#edits.push({ kind: "delete", anchor, lineNum: op.lineNum, index: this.#editIndex++ });
+		} else if (above.length === 0 && below.length === 0) {
+			for (const anchor of expandRange(target.range)) {
+				this.#pushDelete(anchor, lineNum);
 			}
 		}
 
+		for (const text of below) {
+			this.#pushInsert({ kind: "after_anchor", anchor: { ...target.range.end } }, text, lineNum);
+		}
+
 		this.#pending = undefined;
 	}
 }
@@ -348,3 +379,36 @@ export function parsePatch(diff: string): { edits: Edit[]; warnings: string[] }
 	drain(tokenizer.end());
 	return executor.end();
 }
+
+/**
+ * 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 block is malformed mid-stream — wait for the next
+ *   chunk),
+ * - the trailing pending block 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-block overlap validator, which catches conflicting
+ * shapes (two replacements/deletes 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());
+	return executor.endStreaming();
+}