@oh-my-pi/hashline 15.5.4 → 15.5.7

package/README.md

@@ -25,7 +25,9 @@ await fs.writeText(
 );
 
 const patcher = new Patcher({ fs });
-const patch = Patch.parse(`¶hello.ts\n1:\n+const greeting = "hello";`);
+const patch = Patch.parse(String.raw`¶hello.ts
+1:
+|const greeting = "hello";`);
 const result = await patcher.apply(patch);
 
 console.log(result.sections[0].op); // "update"
@@ -45,13 +47,11 @@ session-aware recovery).
 
 Inside a hunk:
 
-|Op|Meaning|
-|---|---|
-|`LINE↑`|Insert before LINE (or `BOF↑` for the beginning of file)|
-|`LINE↓`|Insert after LINE (or `EOF↓` for the end of file)|
-|`A-B:`|Replace lines A..B (single-anchor `A:` is sugar for `A-A:`)|
-|`A-B!`|Delete lines A..B (single-anchor `A!` is sugar for `A-A!`)|
-|`+TEXT`|Payload continuation. The `+` prefix is stripped|
+- `A-B:` — anchor lines A..B (single-anchor `A:` is sugar for `A-A:`).
+- `BOF:` / `EOF:` — virtual anchors at the beginning/end of file.
+- `|TEXT` — replace-bucket payload. A non-empty replace bucket replaces A..B.
+- `↑TEXT` — insert before A (`BOF:` treats `↑`/`↓` equivalently).
+- `↓TEXT` — insert after B (`EOF:` treats `↑`/`↓` equivalently).
 
 ## Abstractions
 

package/dist/types/apply.d.ts

@@ -4,7 +4,6 @@ import type { ApplyOptions, ApplyResult, Edit } from "./types";
  *
  * Returns the post-edit text, the first changed line number (1-indexed), and
  * any diagnostic warnings produced by the auto-absorb heuristics or by the
- * structural-boundary delete check. Throws if an anchor is out of bounds or a
- * blank-target replace is detected.
+ * structural-boundary delete check. Throws if an anchor is out of bounds.
  */
 export declare function applyEdits(text: string, edits: Edit[], options?: ApplyOptions): ApplyResult;

package/dist/types/format.d.ts

@@ -3,18 +3,16 @@
  * file-hash computation. These are the single source of truth for the
  * parser, the tokenizer, the prompt, and the formal grammar.
  */
-/** Op sigil used immediately after a line-number anchor to insert before it. */
-export declare const HL_OP_INSERT_BEFORE = "\u2191";
-/** Op sigil used immediately after a line-number anchor to insert after it. */
-export declare const HL_OP_INSERT_AFTER = "\u2193";
-/** Op sigil used after a range (or single anchor) to replace its lines. */
+/** Anchor terminator for every hashline operation block. */
 export declare const HL_OP_REPLACE = ":";
-/** Op sigil used after a range (or single anchor) to delete its lines. */
-export declare const HL_OP_DELETE = "!";
-/** All hashline edit op sigils, concatenated for fast membership tests. */
-export declare const HL_OP_CHARS = "\u2191\u2193:!";
-/** Prefix for payload continuation lines. The prefix itself is not written. */
-export declare const HL_PAYLOAD_PREFIX = "+";
+/** Payload sigil for lines that replace the anchored range in place. */
+export declare const HL_PAYLOAD_REPLACE = "|";
+/** Payload sigil for lines inserted before the anchored range. */
+export declare const HL_PAYLOAD_ABOVE = "\u2191";
+/** Payload sigil for lines inserted after the anchored range. */
+export declare const HL_PAYLOAD_BELOW = "\u2193";
+/** All hashline payload sigils, concatenated for fast membership tests. */
+export declare const HL_PAYLOAD_CHARS = "|\u2191\u2193";
 /** Hashline edit file-section header marker. */
 export declare const HL_FILE_PREFIX = "\u00B6";
 /** Separator between a hashline file path and its file hash. */

package/dist/types/input.d.ts

@@ -51,6 +51,14 @@ export declare class PatchSection {
      * just want the result.
      */
     applyTo(text: string, options?: ApplyOptions): ApplyResult;
+    /**
+     * Streaming-tolerant counterpart to {@link applyTo}. Uses
+     * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+     * or a per-token parse error mid-stream) does not throw or emit a phantom
+     * empty-payload edit. Intended for incremental diff previews; the writer
+     * path should always use {@link applyTo}.
+     */
+    applyPartialTo(text: string, options?: ApplyOptions): ApplyResult;
 }
 /**
  * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted

package/dist/types/messages.d.ts

@@ -20,37 +20,25 @@ export declare const ABORT_MARKER = "*** Abort";
 /** Warning text appended to the tool result when {@link ABORT_MARKER} terminates parsing. */
 export declare 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 declare 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 \u2014 the 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 declare 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.";
-/**
- * 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 declare 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 `+` \u2014 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 declare const INLINE_PAYLOAD_ACCEPTED_WARNING = "Accepted inline payload on the op line (e.g. `LINE:CONTENT`, `LINE\u2191CONTENT`). Canonical syntax is the bare op followed by `+`-prefixed payload rows on the next line(s). Prefer the explicit form.";
+export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected two identical-range hashline blocks; kept only the second block. Issue ONE block per range \u2014 payload is the final desired content, never both old and new.";
+/** Error text prefix emitted when an anchor line carries inline payload. */
+export declare const INLINE_PAYLOAD_REJECTED_PREFIX = "Inline payload on the anchor line is rejected.";
+/** Error text emitted when `|` replacement payload targets BOF/EOF. */
+export declare const VIRTUAL_REPLACE_REJECTED_MESSAGE = "BOF:/EOF: anchors are virtual positions and cannot use `|` replacement payload. Use `\u2191` or `\u2193` payload lines.";
 /** Warning text emitted by `Recovery` when an external write fits a cached snapshot. */
 export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
 /** Warning text emitted by `Recovery` when a prior in-session edit advanced the hash. */
 export declare 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 declare const RECOVERY_SESSION_REPLAY_WARNING = "Recovered by replaying your edits onto the current file content \u2014 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/dist/types/parser.d.ts

@@ -4,8 +4,8 @@ import type { Edit } from "./types";
  * 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.
  */
@@ -15,25 +15,33 @@ export declare class Executor {
     get terminated(): boolean;
     /**
      * 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;
     /**
-     * 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[];
     };
+    /**
+     * 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[];
+    };
     /** Reset to a fresh state so the same instance can drive another parse. */
     reset(): void;
 }
@@ -48,3 +56,21 @@ export declare function parsePatch(diff: string): {
     edits: Edit[];
     warnings: string[];
 };
+/**
+ * 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 declare function parsePatchStreaming(diff: string): {
+    edits: Edit[];
+    warnings: string[];
+};

package/dist/types/recovery.d.ts

@@ -22,8 +22,12 @@ export interface RecoveryResult {
  *
  * 1. Apply on the cached `fullText` snapshot, then 3-way-merge onto current.
  * 2. (Session chain) If the snapshot wasn't the head, retry on current text
- *    when line counts match — the user's previous edit advanced the hash but
- *    didn't shift line numbers.
+ *    when line counts match AND every edit's anchor line content is unchanged
+ *    between snapshot and current — the previous in-session edit advanced
+ *    the hash and the model's anchors still name the same logical rows. Emits
+ *    a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because even with
+ *    both guards a coincidental insert+delete pair on duplicate rows can
+ *    still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
  * 3. Reconstruct from a sparse snapshot (lines map only), verify the rebuilt
  *    text hashes to the expected value, then 3-way-merge.
  */

package/dist/types/tokenizer.d.ts

@@ -10,7 +10,7 @@
  * The tokenizer is intentionally permissive about decorations and prefixes
  * the model may echo back from `read`/`search` output — leading `*`/`>`/`-`
  * markers, CR-terminated lines, leading whitespace before line numbers, and
- * so on are all stripped before classification.
+ * so on are all stripped before anchor classification.
  */
 import type { Anchor, Cursor, ParsedRange } from "./types";
 /**
@@ -24,14 +24,17 @@ import type { Anchor, Cursor, ParsedRange } from "./types";
  */
 export declare function splitHashlineLines(text: string): string[];
 export declare function cloneCursor(cursor: Cursor): Cursor;
-/** Parse a bare line-number anchor (used by insert ops). Throws on malformed input. */
+/** Parse a bare line-number anchor. Throws on malformed input. */
 export declare function parseLid(raw: string, lineNum: number): Anchor;
-/**
- * Returns true when the line scans as `LINE!payload` (delete sigil followed
- * by additional content). The parser uses this for the dedicated "deletes
- * only" diagnostic, separate from the standard "unrecognized op" path.
- */
-export declare function isDeleteOpWithPayload(line: string): boolean;
+export type BlockTarget = {
+    kind: "range";
+    range: ParsedRange;
+} | {
+    kind: "bof";
+} | {
+    kind: "eof";
+};
+export type PayloadBucket = "above" | "replace" | "below";
 interface TokenBase {
     /** 1-indexed line number in the original input stream. */
     lineNum: number;
@@ -49,19 +52,12 @@ export type Token = (TokenBase & {
     path: string;
     fileHash?: string;
 }) | (TokenBase & {
-    kind: "op-insert";
-    cursor: Cursor;
-    inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-replace";
-    range: ParsedRange;
+    kind: "op-block";
+    target: BlockTarget;
     inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-delete";
-    range: ParsedRange;
-    trailingPayload: boolean;
 }) | (TokenBase & {
     kind: "payload";
+    bucket: PayloadBucket;
     text: string;
 }) | (TokenBase & {
     kind: "raw";

package/dist/types/types.d.ts

@@ -22,7 +22,9 @@ export type Cursor = {
 /**
  * A single low-level edit produced by the parser and consumed by the applier.
  * Multi-line replacements decompose to one `insert` per replacement line plus
- * one `delete` per consumed line.
+ * one `delete` per consumed line. Replacement inserts are tagged so the applier
+ * can distinguish "insert above this deleted line" from "new content for this
+ * deleted line" when a source block carries both buckets.
  */
 export type Edit = {
     kind: "insert";
@@ -30,6 +32,7 @@ export type Edit = {
     text: string;
     lineNum: number;
     index: number;
+    mode?: "replacement";
 } | {
     kind: "delete";
     anchor: Anchor;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "15.5.4",
+	"version": "15.5.7",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",

package/src/apply.ts

@@ -3,10 +3,8 @@
  * post-edit lines plus any diagnostic warnings. Pure function: no FS, no
  * mutation of the input.
  *
- * The applier is conservative about edits that look like authoring mistakes:
+ * The applier normalizes common model boundary mistakes:
  *
- * - Replace ops on a blank line with non-empty payload are rejected outright
- *   (the model almost certainly miscounted; recommend `↑`/`↓` instead).
  * - Multi-line replacement-boundary duplicates are auto-absorbed (model
  *   echoed surrounding context as if it were payload).
  * - Single-line structural-boundary duplicates (`}`, `)`, `];`, …) are
@@ -35,11 +33,24 @@ interface ReplacementGroup {
 	deletes: DeleteEdit[];
 }
 
+function isReplacementInsert(edit: Edit): edit is Extract<Edit, { kind: "insert" }> & { mode: "replacement" } {
+	return edit.kind === "insert" && edit.mode === "replacement";
+}
+
 function getEditAnchors(edit: Edit): 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 [];
+	switch (edit.cursor.kind) {
+		case "before_anchor":
+		case "after_anchor":
+			return [edit.cursor.anchor];
+		case "bof":
+		case "eof":
+			return [];
+		default: {
+			const _exhaustive: never = edit.cursor;
+			return _exhaustive;
+		}
+	}
 }
 
 /**
@@ -56,57 +67,6 @@ function validateLineBounds(edits: Edit[], fileLines: string[]): void {
 	}
 }
 
-/**
- * Refuse a single-line replace whose target line is blank and whose payload is
- * non-empty. The author is almost certainly miscounting: `A:CONTENT` overwrites
- * the existing line, so applying it to a blank target deletes the blank cadence
- * and inserts content in its place. To insert content at a blank line, use
- * `A↑` (insert before) or `A↓` (insert after) instead.
- *
- * Only fires for the simple shape: exactly one `insert(before_anchor A)` + one
- * `delete(A)` sharing the same source op line, no other inserts/deletes from
- * that op.
- */
-function detectReplaceOnBlankTarget(edits: Edit[], fileLines: string[]): string | null {
-	interface Pair {
-		insert?: Extract<Edit, { kind: "insert" }>;
-		delete?: Extract<Edit, { kind: "delete" }>;
-		multi?: boolean;
-	}
-	const byOpLine = new Map<number, Pair>();
-	for (const edit of edits) {
-		const pair = byOpLine.get(edit.lineNum) ?? {};
-		if (pair.multi) continue;
-		if (edit.kind === "insert") {
-			if (pair.insert) pair.multi = true;
-			else pair.insert = edit;
-		} else {
-			if (pair.delete) pair.multi = true;
-			else pair.delete = edit;
-		}
-		byOpLine.set(edit.lineNum, pair);
-	}
-	for (const pair of byOpLine.values()) {
-		if (pair.multi || !pair.insert || !pair.delete) continue;
-		const insert = pair.insert;
-		const del = pair.delete;
-		if (insert.cursor.kind !== "before_anchor") continue;
-		if (insert.cursor.anchor.line !== del.anchor.line) continue;
-		if (insert.text.includes("\n")) continue;
-		if (insert.text.trim().length === 0) continue;
-		const targetLine = del.anchor.line;
-		const oldLine = fileLines[targetLine - 1];
-		if (oldLine === undefined || oldLine.trim().length !== 0) continue;
-		return (
-			`Edit rejected: replace at line ${targetLine} targets a blank line but the payload is non-empty. ` +
-			`'A:CONTENT' overwrites the line at A; to insert content next to a blank line, use 'A${"\u2191"}' (insert before) ` +
-			`or 'A${"\u2193"}' (insert after) instead. If you really meant to replace this blank with content, ` +
-			`widen the range to include surrounding non-blank lines so the intent is explicit.`
-		);
-	}
-	return null;
-}
-
 function insertAtStart(fileLines: string[], lineOrigins: LineOrigin[], lines: string[]): void {
 	if (lines.length === 0) return;
 	const origins = lines.map((): LineOrigin => "insert");
@@ -152,14 +112,14 @@ function collectAnchorTargetLines(edits: Edit[]): Set<number> {
 
 function findReplacementGroup(edits: Edit[], startIndex: number): ReplacementGroup | undefined {
 	const first = edits[startIndex];
-	if (first?.kind !== "insert" || first.cursor.kind !== "before_anchor") return undefined;
+	if (!isReplacementInsert(first) || 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;
+		if (!isReplacementInsert(edit) || edit.lineNum !== sourceLineNum || edit.cursor.kind !== "before_anchor") break;
 		replacement.push(edit.text);
 		index++;
 	}
@@ -318,10 +278,9 @@ function countMatchingSingleStructuralSuffixBoundary(
 /**
  * Single-line non-structural boundary duplicate detector for replacement
  * groups. Mirrors the same boundary check the pure-insert absorber uses for
- * `ANCHOR↓` (leading) / `ANCHOR↑` (trailing) inserts, but applied to the
- * top/bottom edges of an `A-B:payload` range. Catches mistakes like
- * `103-138:const X = …` where line 102 already reads `const X = …` and the
- * user really meant `103-138!` (delete only).
+ * `A:` + `↓` (leading) / `A:` + `↑` (trailing) inserts, but applied to the
+ * top/bottom edges of an `A-B:` replacement payload. Catches mistakes like
+ * `103-138:` + `|const X = …` where line 102 already reads `const X = …`.
  *
  * Gated by `options.autoDropPureInsertDuplicates`: the existing 2+-line block
  * absorb already runs unconditionally, and the structural single-line
@@ -400,7 +359,7 @@ function cursorMatches(a: Cursor, b: Cursor): boolean {
  */
 function findPureInsertGroup(edits: Edit[], startIndex: number): PureInsertGroup | undefined {
 	const first = edits[startIndex];
-	if (first?.kind !== "insert") return undefined;
+	if (first?.kind !== "insert" || isReplacementInsert(first)) return undefined;
 
 	const sourceLineNum = first.lineNum;
 	const cursor = first.cursor;
@@ -408,7 +367,7 @@ function findPureInsertGroup(edits: Edit[], startIndex: number): PureInsertGroup
 	let index = startIndex;
 	while (index < edits.length) {
 		const edit = edits[index];
-		if (edit.kind !== "insert" || edit.lineNum !== sourceLineNum) break;
+		if (edit.kind !== "insert" || isReplacementInsert(edit) || edit.lineNum !== sourceLineNum) break;
 		if (!cursorMatches(edit.cursor, cursor)) break;
 		payload.push(edit.text);
 		index++;
@@ -676,8 +635,7 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
  *
  * Returns the post-edit text, the first changed line number (1-indexed), and
  * any diagnostic warnings produced by the auto-absorb heuristics or by the
- * structural-boundary delete check. Throws if an anchor is out of bounds or a
- * blank-target replace is detected.
+ * structural-boundary delete check. Throws if an anchor is out of bounds.
  */
 export function applyEdits(text: string, edits: Edit[], options: ApplyOptions = {}): ApplyResult {
 	if (edits.length === 0) return { text, firstChangedLine: undefined };
@@ -693,9 +651,6 @@ export function applyEdits(text: string, edits: Edit[], options: ApplyOptions =
 
 	validateLineBounds(edits, fileLines);
 
-	const blankTargetError = detectReplaceOnBlankTarget(edits, fileLines);
-	if (blankTargetError !== null) throw new Error(blankTargetError);
-
 	const normalizedEdits = absorbReplacementBoundaryDuplicates(edits, fileLines, warnings, options);
 	const targetEdits: Edit[] = [];
 
@@ -744,20 +699,23 @@ export function applyEdits(text: string, edits: Edit[], options: ApplyOptions =
 
 		const idx = line - 1;
 		const currentLine = fileLines[idx] ?? "";
-		const beforeLines: string[] = [];
+		const insertLines: string[] = [];
+		const replacementLines: string[] = [];
 		let deleteLine = false;
 
 		for (const { edit } of bucket) {
-			if (edit.kind === "insert") {
-				beforeLines.push(edit.text);
+			if (isReplacementInsert(edit)) {
+				replacementLines.push(edit.text);
+			} else if (edit.kind === "insert") {
+				insertLines.push(edit.text);
 			} else if (edit.kind === "delete") {
 				deleteLine = true;
 			}
 		}
-		if (beforeLines.length === 0 && !deleteLine) continue;
+		if (insertLines.length === 0 && replacementLines.length === 0 && !deleteLine) continue;
 
-		const replaceMode = beforeLines.length > 0;
-		if (deleteLine && !replaceMode) {
+		const hasReplacementPayload = replacementLines.length > 0;
+		if (deleteLine && !hasReplacementPayload) {
 			const balance = computeDelimiterBalance([currentLine]);
 			const trimmedCurrentLine = currentLine.trim();
 			const touchesStructuralBoundary =
@@ -769,15 +727,17 @@ export function applyEdits(text: string, edits: Edit[], options: ApplyOptions =
 				trimmedCurrentLine.endsWith("{");
 			if (balance.paren !== 0 || balance.bracket !== 0 || balance.brace !== 0 || touchesStructuralBoundary) {
 				warnings.push(
-					`Deleted line ${line} contains a structural bracket/brace boundary (${JSON.stringify(trimmedCurrentLine)}); verify the file is still balanced or use 'A:<replacement>' to keep the boundary intact.`,
+					`Deleted line ${line} contains a structural bracket/brace boundary (${JSON.stringify(trimmedCurrentLine)}); verify the file is still balanced or use '|replacement' payload to keep the boundary intact.`,
 				);
 			}
 		}
-		const replacement = deleteLine ? beforeLines : [...beforeLines, currentLine];
-		const origins = replacement.map((): LineOrigin => (deleteLine ? "replacement" : "insert"));
-		if (!deleteLine) {
-			origins[origins.length - 1] = lineOrigins[idx] ?? "original";
-		}
+		const replacement = deleteLine
+			? [...insertLines, ...replacementLines]
+			: [...insertLines, ...replacementLines, currentLine];
+		const origins: LineOrigin[] = [];
+		for (let i = 0; i < insertLines.length; i++) origins.push("insert");
+		for (let i = 0; i < replacementLines.length; i++) origins.push(deleteLine ? "replacement" : "insert");
+		if (!deleteLine) origins.push(lineOrigins[idx] ?? "original");
 
 		fileLines.splice(idx, 1, ...replacement);
 		lineOrigins.splice(idx, 1, ...origins);

package/src/format.ts

@@ -4,20 +4,18 @@
  * parser, the tokenizer, the prompt, and the formal grammar.
  */
 
-/** Op sigil used immediately after a line-number anchor to insert before it. */
-export const HL_OP_INSERT_BEFORE = "↑";
-/** Op sigil used immediately after a line-number anchor to insert after it. */
-export const HL_OP_INSERT_AFTER = "↓";
-/** Op sigil used after a range (or single anchor) to replace its lines. */
+/** Anchor terminator for every hashline operation block. */
 export const HL_OP_REPLACE = ":";
-/** Op sigil used after a range (or single anchor) to delete its lines. */
-export const HL_OP_DELETE = "!";
 
-/** All hashline edit op sigils, concatenated for fast membership tests. */
-export const HL_OP_CHARS = `${HL_OP_INSERT_BEFORE}${HL_OP_INSERT_AFTER}${HL_OP_REPLACE}${HL_OP_DELETE}`;
+/** Payload sigil for lines that replace the anchored range in place. */
+export const HL_PAYLOAD_REPLACE = "|";
+/** Payload sigil for lines inserted before the anchored range. */
+export const HL_PAYLOAD_ABOVE = "↑";
+/** Payload sigil for lines inserted after the anchored range. */
+export const HL_PAYLOAD_BELOW = "↓";
 
-/** Prefix for payload continuation lines. The prefix itself is not written. */
-export const HL_PAYLOAD_PREFIX = "+";
+/** All hashline payload sigils, concatenated for fast membership tests. */
+export const HL_PAYLOAD_CHARS = `${HL_PAYLOAD_REPLACE}${HL_PAYLOAD_ABOVE}${HL_PAYLOAD_BELOW}`;
 
 /** Hashline edit file-section header marker. */
 export const HL_FILE_PREFIX = "¶";

package/src/grammar.lark

@@ -3,19 +3,18 @@ begin_patch: "*** Begin Patch" LF
 end_patch: "*** End Patch" LF?
 
 hunk: update_hunk
-update_hunk: "¶" filename ("#" file_hash)? LF line_op*
+update_hunk: "¶" filename ("#" file_hash)? LF block*
 
 filename: /([^\s#]+)/
 file_hash: /[0-9a-f]{4}/
 
-line_op: insert_before | insert_after | replace | delete
-insert_before: anchor "↑" LF payload*
-insert_after: anchor "↓" LF payload*
-replace: range ":" LF payload*
-delete: range "!" LF
-payload: "+" /[^\n]*/ LF
+block: anchor ":" LF payload*
+payload: above_payload | replace_payload | below_payload
+above_payload: "↑" /[^\n]*/ LF
+replace_payload: "|" /[^\n]*/ LF
+below_payload: "↓" /[^\n]*/ LF
 
-anchor: LID | "EOF" | "BOF"
+anchor: range | "BOF" | "EOF"
 range: LID ("-" LID)?
 LID: /[1-9]\d*/
 

package/src/input.ts

@@ -10,7 +10,7 @@
 import * as path from "node:path";
 import { applyEdits } from "./apply";
 import { HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./format";
-import { parsePatch } from "./parser";
+import { parsePatch, parsePatchStreaming } from "./parser";
 import { Tokenizer } from "./tokenizer";
 import type { ApplyOptions, ApplyResult, Edit, SplitOptions } from "./types";
 
@@ -235,6 +235,22 @@ export class PatchSection {
 			? { ...result, warnings: merged }
 			: { text: result.text, firstChangedLine: result.firstChangedLine };
 	}
+
+	/**
+	 * Streaming-tolerant counterpart to {@link applyTo}. Uses
+	 * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+	 * or a per-token parse error mid-stream) does not throw or emit a phantom
+	 * empty-payload edit. Intended for incremental diff previews; the writer
+	 * path should always use {@link applyTo}.
+	 */
+	applyPartialTo(text: string, options: ApplyOptions = {}): ApplyResult {
+		const { edits, warnings } = parsePatchStreaming(this.diff);
+		const result = applyEdits(text, [...edits], options);
+		const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
+		return merged && merged.length > 0
+			? { ...result, warnings: merged }
+			: { text: result.text, firstChangedLine: result.firstChangedLine };
+	}
 }
 
 /**