@oh-my-pi/hashline 15.5.4 → 15.5.7

package/src/prompt.md

@@ -1,83 +1,130 @@
 Your patch language is a compact, line-anchored edit format.
 
 <payload>
-Patch payload is a series of hunks: `¶PATH#HASH` header followed by any number of operations. `HASH` should be copied as is from read/search. Missing? Re-`read`.
-- No context rows, no gutters.
-- NEVER restate unchanged lines "for context".
-- Op lines carry NO payload. Every payload line lives on its own row and MUST start with `+`; that delimiter is stripped.
-- Payload indentation is literal.
+Patch payload = one or more file sections:
+
+```
+¶PATH#HASH
+A-B:
+|replacement line
+↑inserted above line
+↓inserted below line
+```
+
+- `HASH` comes from the latest `read`/`search` header. Missing? Re-`read`.
+- No context rows, no gutters, no unchanged lines.
+- Anchor rows are ALWAYS bare: `A-B:`, `A:`, `BOF:`, `EOF:`.
+- Payload rows MUST start with `|`, `↑`, or `↓`.
+- The first sigil is stripped; remaining bytes are file content.
 </payload>
 
-<ops>
-LINE↑    insert before (or BOF↑)
-LINE↓    insert after  (or EOF↓)
-A-B:     replace A..B  (or A: == A..A)
-A-B!     delete A..B   (or A! == A..A)
-+PAYLOAD payload line for the preceding op
-</ops>
-
-<rules>
-- **Payload is only what's NEW.** `:` replaces inside; `↑`/`↓` add at anchor. NEVER repeat anchor lines or neighbors.
-- **Use `+` for a blank payload line; use `++text` to write a line starting with `+text`.**
-- **Inserts add ONLY the rows you list.** The file's existing newlines around the anchor stay. NEVER tack a trailing `+` blank "for spacing" — it writes a literal blank line into the file, doubling whatever is already there.
-- **A bare `LINE↑`/`LINE↓` with no payload still inserts ONE blank line.** Not a no-op. Omit the op if you want nothing there.
-- **Go small.** Add → `↑`/`↓`; replace → `:`; delete → `!`.
-- **Line numbers are frozen references to what you have seen.** Later ops in the same hunk still use original line numbers; they do NOT shift as earlier ops apply.
-</rules>
+<anchors>
+`A-B:` — anchor A..B inclusive.
+`A:` — shorthand for `A-A:`.
+`BOF:` — virtual position before line 1.
+`EOF:` — virtual position after the last line.
+</anchors>
 
-<common-failures>
-- **NEVER replay past your range.** Stop before B+1; extend B if needed.
-- **Read lines look like replace ops.** `84:content` = "make line 84 content" — and inline content is rejected. Don't echo read-style rows.
-- **NEVER fabricate file hashes.** Missing? Re-`read`.
-</common-failures>
+<sigils>
+`|content` — replace A..B with `content`.
+`↑content` — insert `content` before A.
+`↓content` — insert `content` after B.
+</sigils>
 
-<example>
-```a.ts#1a2b
-1:const X = "a";
-2:
-3:export function f() { return X; }
-4:f();
-```
+<semantics>
+- **No payload → delete.** `5:` deletes line 5.
+- **Buckets combine.** `↑` before A, `|` in place, `↓` after B.
+- **Bucket order ignores interleaving.** Output order = all `↑`, then `|`/original, then all `↓`.
+- **Order within a bucket is preserved.** Two `↑` rows stack top-down.
+- **Blank payload = explicit.** Bare `|`, `↑`, or `↓` writes one blank line.
+- **Line numbers are frozen.** Later anchors still reference pre-edit lines.
+</semantics>
 
-# replace one line, insert after, delete
+<examples>
+# Replace line 1 with two lines; insert one line below the replacement.
 ```
 ¶a.ts#1a2b
 1:
-+const X = "b";
-+export const Y = X;
-1↓
-+const Z = Y;
-4!
+|const X = "b";
+|export const Y = X;
+↓const Z = Y;
+```
+
+# Insert above line 3. Line 3 survives because there is no `|` row.
+```
+¶a.ts#1a2b
+3:
+↑function helper() { return X; }
 ```
-</example>
+
+# Delete lines 5..7.
+```
+¶a.ts#1a2b
+5-7:
+```
+
+# Replace line 5 with one blank line.
+```
+¶a.ts#1a2b
+5:
+|
+```
+</examples>
+
+<common-failures>
+- **NEVER use inline payload.** `5:content` is invalid; write `5:` then `|content`.
+- **Do not repeat preserved lines.** If line 5 should survive, omit `|`.
+- **`↑`/`↓` payloads are new bytes only.** Never echo the anchor or a neighbor line — that line already exists; copying it into a `↓` row appends a duplicate.
+- **Do not echo read gutters.** `84:content` is not payload.
+- **Do not replay past B.** Stop before B+1; widen the anchor if B+1 changes.
+- **NEVER fabricate file hashes.** Missing? Re-`read`.
+</common-failures>
 
 <anti-pattern>
-# WRONG — inline payload after the sigil is rejected
-1:const X = "b";
-1↓const Z = Y;
-1-2:const X = "b";
-+export const Y = X;
-# WRONG — INSERT used to change a line (old line survives)
-1↓
-+const X = "b";
-# WRONG — echoing read-style lines as context before the real op
-1:const X = "a";
-1-2:
-+const X = "b";
-+export const Y = X;
-# WRONG — trailing `+` blank writes a literal empty line; the new blank lands right next to the orig blank at line 2, doubling it
-1↓
-+const Y = X;
-+
-# WRONG — `2↓` still anchors at PRE-EDIT line 2 (frozen), NOT at the line just inserted by `1↓`. Both inserts land at their own anchors, giving three consecutive blanks (new from `1↓`, orig blank line 2, new from `2↓`).
-1↓
-2↓
+# WRONG — inline payload after anchor.
+5:const X = "b";
+# RIGHT
+5:
+|const X = "b";
+
+# WRONG — replacing line 5 just to keep it while inserting above.
+5:
+↑const Y = X;
+|const X = "a";
+# RIGHT — no `|`; line 5 survives automatically.
+5:
+↑const Y = X;
+
+# WRONG — echoing the anchor into a ↓ payload duplicates it.
+# Line 5 already contains `const X = 1;`.
+5:
+↓const X = 1;
+↓const Y = 2;
+# RIGHT — payload is only the new line; the anchor survives automatically.
+5:
+↓const Y = 2;
+
+# WRONG — read-output gutters inside payload.
+5-6:
+5:const X = "b";
+6:export const Y = X;
+# RIGHT
+5-6:
+|const X = "b";
+|export const Y = X;
+
+# WRONG — line numbers shifted mentally after the first block.
+1:
+↓new line
+2:
+↓another new line
+# `2:` still targets original line 2, not `new line`.
 </anti-pattern>
 
 <critical>
-- One op per range, ever.
-- Pick op precisely. Update: `:`, add: `↑`/`↓`, remove: `!`.
-- Payload always lives on its own `+`-prefixed line — never inline with the op.
-- Payload is only what's NEW; never repeat anchor lines or neighbors.
-- Anchor exactly; don't anchor neighbors.
+- Anchor rows are bare ranges ending in `:`.
+- Payload rows start with `|`, `↑`, or `↓`.
+- `|` means replace anchored lines.
+- Only `↑`/`↓` means preserve anchored lines.
+- Payload is only new content; no context rows.
 </critical>

package/src/recovery.ts

@@ -13,7 +13,7 @@ import { applyEdits } from "./apply";
 import { computeFileHash } from "./format";
 import { RECOVERY_EXTERNAL_WARNING, RECOVERY_SESSION_CHAIN_WARNING, RECOVERY_SESSION_REPLAY_WARNING } from "./messages";
 import type { Snapshot, SnapshotStore } from "./snapshots";
-import type { ApplyOptions, ApplyResult, Edit } from "./types";
+import type { Anchor, ApplyOptions, ApplyResult, Edit } from "./types";
 
 // Section hashes are line-precise; never let Diff.applyPatch slide a hunk
 // onto a duplicate closer 100+ lines away. If snapshot replay does not
@@ -63,16 +63,72 @@ function applyEditsToSnapshot(
 	return { text: merged, firstChangedLine, warnings };
 }
 
+function collectAnchorLines(edits: readonly Edit[]): number[] {
+	const lines: number[] = [];
+	for (const edit of edits) {
+		for (const anchor of getEditAnchors(edit)) lines.push(anchor.line);
+	}
+	return lines;
+}
+
+function getEditAnchors(edit: Edit): Anchor[] {
+	if (edit.kind === "delete") return [edit.anchor];
+	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;
+		}
+	}
+}
+
+/**
+ * Returns true when every anchor line in `edits` has identical content in
+ * `previousText` and `currentText`. The session-chain replay fast-path
+ * requires this: if the prior in-session edit rewrote the line the model is
+ * now re-targeting with a stale hash, replaying onto current would silently
+ * overwrite the new content with whatever the model authored against the
+ * old content — a corruption window, not a recovery.
+ */
+function verifyAnchorContent(previousText: string, currentText: string, edits: readonly Edit[]): boolean {
+	const lines = collectAnchorLines(edits);
+	if (lines.length === 0) return true;
+	const prev = previousText.split("\n");
+	const curr = currentText.split("\n");
+	for (const line of lines) {
+		const idx = line - 1;
+		if (idx < 0 || idx >= prev.length || idx >= curr.length) return false;
+		if (prev[idx] !== curr[idx]) return false;
+	}
+	return true;
+}
+
 function replaySessionChainOnCurrent(
 	previousText: string,
 	currentText: string,
 	edits: readonly Edit[],
 	options: ApplyOptions,
 ): RecoveryResult | null {
-	// Only safe when no insert/delete shifted line counts in the prior edit
-	// chain: if total line counts match, every line number in `edits` still
-	// resolves to the same logical row.
+	// Two guards narrow the corruption window. Neither alone is sufficient,
+	// and even together they don't fully prove correctness — replay is the
+	// less-certain recovery mode and emits RECOVERY_SESSION_REPLAY_WARNING
+	// so the caller can verify the diff.
+	//   - Equal line counts: every line number in `edits` still resolves to
+	//     SOME logical row (no net shift across the prior chain). A
+	//     coincidental insert+delete pair can still leave indices pointing
+	//     at different logical rows than the model anchored against.
+	//   - Anchor-content alignment: the row at each anchor's line index has
+	//     identical content in previous and current. Catches the common
+	//     case of a prior edit rewriting the targeted line; can still be
+	//     coincidentally satisfied by a duplicated row at the shifted
+	//     index.
 	if (previousText.split("\n").length !== currentText.split("\n").length) return null;
+	if (!verifyAnchorContent(previousText, currentText, edits)) return null;
 	let applied: ApplyResult;
 	try {
 		applied = applyEdits(currentText, [...edits], options);
@@ -123,8 +179,12 @@ function isHeadSnapshot(head: Snapshot | null, snapshot: Snapshot): boolean {
  *
  * 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.
  */
@@ -148,10 +208,10 @@ export class Recovery {
 		if (snapshot.fullText !== undefined) {
 			const merged = applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
 			if (merged !== null) return merged;
-			// Session-chain fast-path: prior in-session edit changed the same
-			// line(s) the user is now re-targeting with the stale hash. When
-			// line counts match, the edits' line numbers still resolve to the
-			// right rows — replay onto the current text directly.
+			// Session-chain fallback: the 3-way merge on the snapshot refused.
+			// Replay onto current is gated by line-count equality AND
+			// anchor-content alignment — see `replaySessionChainOnCurrent`
+			// for why both guards together still don't fully prove correctness.
 			if (isSessionChain) return replaySessionChainOnCurrent(snapshot.fullText, currentText, edits, options);
 			return null;
 		}

package/src/tokenizer.ts

@@ -10,18 +10,17 @@
  * 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 {
 	describeAnchorExamples,
 	HL_FILE_HASH_SEP,
 	HL_FILE_PREFIX,
-	HL_OP_DELETE,
-	HL_OP_INSERT_AFTER,
-	HL_OP_INSERT_BEFORE,
 	HL_OP_REPLACE,
-	HL_PAYLOAD_PREFIX,
+	HL_PAYLOAD_ABOVE,
+	HL_PAYLOAD_BELOW,
+	HL_PAYLOAD_REPLACE,
 } from "./format";
 import { ABORT_MARKER, BEGIN_PATCH_MARKER, END_PATCH_MARKER } from "./messages";
 import type { Anchor, Cursor, ParsedRange } from "./types";
@@ -33,10 +32,14 @@ const CHAR_NINE = 57;
 const CHAR_HASH = 35;
 const CHAR_TAB = 9;
 const CHAR_SPACE = 32;
+const CHAR_HYPHEN = 45;
 const CHAR_LOWER_A = 97;
 const CHAR_LOWER_F = 102;
 const CHAR_PILCROW = HL_FILE_PREFIX.charCodeAt(0);
-const CHAR_PAYLOAD_PREFIX = HL_PAYLOAD_PREFIX.charCodeAt(0);
+const CHAR_OP_REPLACE = HL_OP_REPLACE.charCodeAt(0);
+const CHAR_PAYLOAD_REPLACE = HL_PAYLOAD_REPLACE.charCodeAt(0);
+const CHAR_PAYLOAD_ABOVE = HL_PAYLOAD_ABOVE.charCodeAt(0);
+const CHAR_PAYLOAD_BELOW = HL_PAYLOAD_BELOW.charCodeAt(0);
 const FILE_HASH_LENGTH = 4;
 
 function isDigitCode(code: number): boolean {
@@ -48,7 +51,7 @@ function isNonZeroDigitCode(code: number): boolean {
 }
 
 function isDecorationCode(code: number): boolean {
-	return code === 42 || code === 45 || code === 62;
+	return code === 42 || code === CHAR_HYPHEN || code === 62;
 }
 
 function isHexDigitCode(code: number): boolean {
@@ -109,7 +112,7 @@ export function cloneCursor(cursor: Cursor): Cursor {
 
 // Leniently accept anchors copied from read/search output:
 //   - optional leading line-marker decoration (`*`, `>`, `-`)
-//   - the required bare line number
+//   - the required bare line number / BOF / EOF anchor
 function skipDecoratedAnchorPrefix(line: string, end = trimEndIndex(line)): number {
 	let index = skipWhitespace(line, 0, end);
 	while (index < end && isDecorationCode(line.charCodeAt(index))) index++;
@@ -135,7 +138,7 @@ function scanLineNumber(line: string, index: number, end: number): NumberScan |
 	return { line: lineNumber, nextIndex };
 }
 
-/** 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 function parseLid(raw: string, lineNum: number): Anchor {
 	const end = trimEndIndex(raw);
 	const numberStart = skipDecoratedAnchorPrefix(raw, end);
@@ -161,7 +164,7 @@ function scanRange(line: string, end = trimEndIndex(line)): RangeScan | null {
 
 	let nextIndex = start.nextIndex;
 	let rangeEnd = start.line;
-	if (nextIndex < end && line.charCodeAt(nextIndex) === 45) {
+	if (nextIndex < end && line.charCodeAt(nextIndex) === CHAR_HYPHEN) {
 		const endNumber = scanLineNumber(line, nextIndex + 1, end);
 		if (endNumber === null) return null;
 		rangeEnd = endNumber.line;
@@ -182,103 +185,55 @@ function startsWithWord(line: string, index: number, end: number, word: string):
 	return true;
 }
 
-function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after"): Cursor {
-	const end = trimEndIndex(raw);
-	const targetStart = skipDecoratedAnchorPrefix(raw, end);
+export type BlockTarget = { kind: "range"; range: ParsedRange } | { kind: "bof" } | { kind: "eof" };
 
-	if (startsWithWord(raw, targetStart, end, "BOF") && skipWhitespace(raw, targetStart + 3, end) === end) {
-		return { kind: "bof" };
-	}
-	if (startsWithWord(raw, targetStart, end, "EOF") && skipWhitespace(raw, targetStart + 3, end) === end) {
-		return { kind: "eof" };
-	}
+export type PayloadBucket = "above" | "replace" | "below";
 
-	const cursorKind = kind === "before" ? "before_anchor" : "after_anchor";
-	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
+interface TargetScan {
+	target: BlockTarget;
+	nextIndex: number;
 }
 
-function scanInlineBody(line: string, index: number): string | undefined {
-	const end = trimEndIndex(line);
-	return index < end ? line.slice(index, end) : undefined;
-}
+function scanBlockTarget(line: string, end = trimEndIndex(line)): TargetScan | null {
+	const targetStart = skipDecoratedAnchorPrefix(line, end);
+	if (startsWithWord(line, targetStart, end, "BOF")) {
+		const nextIndex = skipWhitespace(line, targetStart + 3, end);
+		return { target: { kind: "bof" }, nextIndex };
+	}
+	if (startsWithWord(line, targetStart, end, "EOF")) {
+		const nextIndex = skipWhitespace(line, targetStart + 3, end);
+		return { target: { kind: "eof" }, nextIndex };
+	}
 
-interface ParsedInsertOp {
-	kind: "insert";
-	cursor: Cursor;
-	inlineBody: string | undefined;
+	const range = scanRange(line, end);
+	return range === null ? null : { target: { kind: "range", range: range.range }, nextIndex: range.nextIndex };
 }
 
-interface ParsedReplaceOp {
-	kind: "replace";
-	range: ParsedRange;
+interface ParsedBlockOp {
+	target: BlockTarget;
 	inlineBody: string | undefined;
 }
 
-interface ParsedDeleteOp {
-	kind: "delete";
-	range: ParsedRange;
-	trailingPayload: boolean;
-}
-
-type ParsedOp = ParsedInsertOp | ParsedReplaceOp | ParsedDeleteOp;
-
-function tryParseInsertOp(line: string, sigil: string, kind: "before" | "after"): ParsedInsertOp | null {
+function tryParseBlockOp(line: string): ParsedBlockOp | null {
 	const end = trimEndIndex(line);
-	const targetStart = skipDecoratedAnchorPrefix(line, end);
+	const target = scanBlockTarget(line, end);
+	if (target === null) return null;
 
-	let targetEnd: number;
-	if (startsWithWord(line, targetStart, end, "BOF") || startsWithWord(line, targetStart, end, "EOF")) {
-		targetEnd = targetStart + 3;
-	} else {
-		const anchor = scanLineNumber(line, targetStart, end);
-		if (anchor === null) return null;
-		targetEnd = anchor.nextIndex;
-	}
+	const opIndex = skipWhitespace(line, target.nextIndex, end);
+	if (opIndex >= end || line.charCodeAt(opIndex) !== CHAR_OP_REPLACE) return null;
 
-	const opIndex = skipWhitespace(line, targetEnd, end);
-	if (opIndex >= end || line[opIndex] !== sigil) return null;
-
-	// parseInsertTarget can only throw on inputs that already passed the
-	// BOF/EOF/line-number scan above, but guard the throw anyway — the
-	// tokenizer contract forbids it and a future refactor of the prefix
-	// scan must not silently start raising here.
-	try {
-		return {
-			kind: "insert",
-			cursor: parseInsertTarget(line.slice(0, opIndex), 0, kind),
-			inlineBody: scanInlineBody(line, opIndex + sigil.length),
-		};
-	} catch {
-		return null;
-	}
-}
-
-function tryParseReplaceOp(line: string): ParsedReplaceOp | null {
-	const end = trimEndIndex(line);
-	const range = scanRange(line, end);
-	if (range === null || range.nextIndex >= end || line[range.nextIndex] !== HL_OP_REPLACE) return null;
+	const inlineStart = opIndex + HL_OP_REPLACE.length;
 	return {
-		kind: "replace",
-		range: range.range,
-		inlineBody: scanInlineBody(line, range.nextIndex + HL_OP_REPLACE.length),
+		target: target.target,
+		inlineBody: skipWhitespace(line, inlineStart, end) === end ? undefined : line.slice(inlineStart, end),
 	};
 }
 
-function tryParseDeleteOp(line: string): ParsedDeleteOp | null {
-	const end = trimEndIndex(line);
-	const range = scanRange(line, end);
-	if (range === null || range.nextIndex >= end || line[range.nextIndex] !== HL_OP_DELETE) return null;
-	const afterSigil = range.nextIndex + HL_OP_DELETE.length;
-	return { kind: "delete", range: range.range, trailingPayload: afterSigil !== end };
-}
-
-function tryParseOp(line: string): ParsedOp | null {
-	return (
-		tryParseInsertOp(line, HL_OP_INSERT_BEFORE, "before") ??
-		tryParseInsertOp(line, HL_OP_INSERT_AFTER, "after") ??
-		tryParseReplaceOp(line) ??
-		tryParseDeleteOp(line)
-	);
+function payloadBucketForCode(code: number): PayloadBucket | undefined {
+	if (code === CHAR_PAYLOAD_ABOVE) return "above";
+	if (code === CHAR_PAYLOAD_REPLACE) return "replace";
+	if (code === CHAR_PAYLOAD_BELOW) return "below";
+	return undefined;
 }
 
 /**
@@ -323,21 +278,6 @@ function tryParseHeader(line: string): { path: string; fileHash?: string } | nul
 	return fileHash !== undefined ? { path, fileHash } : { path };
 }
 
-/**
- * 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 function isDeleteOpWithPayload(line: string): boolean {
-	const range = scanRange(line, line.length);
-	return (
-		range !== null &&
-		range.nextIndex < line.length &&
-		line[range.nextIndex] === HL_OP_DELETE &&
-		range.nextIndex + HL_OP_DELETE.length < line.length
-	);
-}
-
 interface TokenBase {
 	/** 1-indexed line number in the original input stream. */
 	lineNum: number;
@@ -349,10 +289,8 @@ export type Token =
 	| (TokenBase & { kind: "envelope-end" })
 	| (TokenBase & { kind: "abort" })
 	| (TokenBase & { kind: "header"; path: string; fileHash?: string })
-	| (TokenBase & { kind: "op-insert"; cursor: Cursor; inlineBody: string | undefined })
-	| (TokenBase & { kind: "op-replace"; range: ParsedRange; inlineBody: string | undefined })
-	| (TokenBase & { kind: "op-delete"; range: ParsedRange; trailingPayload: boolean })
-	| (TokenBase & { kind: "payload"; text: string })
+	| (TokenBase & { kind: "op-block"; target: BlockTarget; inlineBody: string | undefined })
+	| (TokenBase & { kind: "payload"; bucket: PayloadBucket; text: string })
 	| (TokenBase & { kind: "raw"; text: string });
 
 function classifyLine(line: string, lineNum: number): Token {
@@ -370,20 +308,14 @@ function classifyLine(line: string, lineNum: number): Token {
 		}
 	}
 
-	if (line.charCodeAt(0) === CHAR_PAYLOAD_PREFIX) {
-		return { kind: "payload", lineNum, text: line.slice(HL_PAYLOAD_PREFIX.length) };
-	}
-	const op = tryParseOp(line);
-	if (op !== null) {
-		if (op.kind === "insert") {
-			return { kind: "op-insert", lineNum, cursor: op.cursor, inlineBody: op.inlineBody };
-		}
-		if (op.kind === "replace") {
-			return { kind: "op-replace", lineNum, range: op.range, inlineBody: op.inlineBody };
-		}
-		return { kind: "op-delete", lineNum, range: op.range, trailingPayload: op.trailingPayload };
+	const payloadBucket = payloadBucketForCode(line.charCodeAt(0));
+	if (payloadBucket !== undefined) {
+		return { kind: "payload", lineNum, bucket: payloadBucket, text: line.slice(1) };
 	}
 
+	const op = tryParseBlockOp(line);
+	if (op !== null) return { kind: "op-block", lineNum, target: op.target, inlineBody: op.inlineBody };
+
 	return { kind: "raw", lineNum, text: line };
 }
 
@@ -452,7 +384,7 @@ export class Tokenizer {
 	}
 
 	isOp(line: string): boolean {
-		return tryParseOp(line) !== null;
+		return tryParseBlockOp(line) !== null;
 	}
 
 	isHeader(line: string): boolean {

package/src/types.ts

@@ -19,10 +19,19 @@ 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"; cursor: Cursor; text: string; lineNum: number; index: number }
+	| {
+			kind: "insert";
+			cursor: Cursor;
+			text: string;
+			lineNum: number;
+			index: number;
+			mode?: "replacement";
+	  }
 	| { kind: "delete"; anchor: Anchor; lineNum: number; index: number; oldAssertion?: string };
 
 /** Result of applying a parsed set of edits to a text body. */