@oh-my-pi/hashline 17.1.7 → 17.2.0

package/src/messages.ts

@@ -31,7 +31,19 @@ export function formatAnchoredContext(anchorLines: readonly number[], fileLines:
 	return rows;
 }
 /** Concrete range operation rejected because its absolute end precedes its start. */
-export type AbsoluteRangeOp = "replace" | "delete";
+export type AbsoluteRangeOp = "replace" | "cut";
+
+/** Header forms per concrete-range op, used to compose retry suggestions. */
+const RANGE_OP_FORMS: Record<AbsoluteRangeOp, { keyword: string; colon: string; blockKeyword: string }> = {
+	replace: { keyword: "SWAP", colon: ":", blockKeyword: "SWAP.BLK" },
+	cut: { keyword: "CUT", colon: "", blockKeyword: "CUT.BLK" },
+};
+
+/** `OP.BLK N`-style header for a concrete-range op (`SWAP.BLK 5:` / `CUT.BLK 5`). */
+function blockFormAt(op: AbsoluteRangeOp, line: number): string {
+	const forms = RANGE_OP_FORMS[op];
+	return `${forms.blockKeyword} ${line}${forms.colon}`;
+}
 
 /** Explain absolute range endpoints and provide safe, non-applying retry forms. */
 export function invalidAbsoluteRangeMessage(
@@ -41,15 +53,14 @@ export function invalidAbsoluteRangeMessage(
 	op: AbsoluteRangeOp,
 	block?: BlockSpan,
 ): string {
-	const single = op === "replace" ? `SWAP ${start}${HL_RANGE_SEP}${start}:` : `DEL ${start}`;
+	const forms = RANGE_OP_FORMS[op];
+	const single = op === "replace" ? `SWAP ${start}${HL_RANGE_SEP}${start}:` : `${forms.keyword} ${start}`;
 	const countedEnd = start + end - 1;
 	const counted =
 		Number.isSafeInteger(countedEnd) && countedEnd >= start
-			? op === "replace"
-				? `SWAP ${start}${HL_RANGE_SEP}${countedEnd}:`
-				: `DEL ${start}${HL_RANGE_SEP}${countedEnd}`
+			? `${forms.keyword} ${start}${HL_RANGE_SEP}${countedEnd}${forms.colon}`
 			: null;
-	const blockForm = op === "replace" ? `SWAP.BLK ${start}:` : `DEL.BLK ${start}`;
+	const blockForm = blockFormAt(op, start);
 	let message =
 		`line ${patchLine}: Invalid absolute range: start ${start}, end ${end}. ` +
 		`The value after \`${HL_RANGE_SEP}\` is an absolute source line, not a line count or replacement length. ` +
@@ -99,10 +110,10 @@ export const MINUS_ROW_REJECTED =
 	"`-` rows are not valid; the range already names the lines being changed. For Markdown bullets or other literal `-` lines, prefix the literal row with `+`: `+- item`.";
 
 /** Replace hunk with no body. */
-export const EMPTY_REPLACE = `\`SWAP N${HL_RANGE_SEP}M:\` needs at least one \`+TEXT\` body row. To delete lines, use \`DEL N${HL_RANGE_SEP}M\`.`;
+export const EMPTY_REPLACE = `\`SWAP N${HL_RANGE_SEP}M:\` needs at least one \`+TEXT\` body row. To delete lines, use \`CUT N${HL_RANGE_SEP}M\`.`;
 
-/** `replace_block N:` hunk with no body. */
-export const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
+/** `SWAP.BLK N:` hunk with no body. */
+export const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `CUT.BLK N`.";
 
 /** Optional source-aware suggestions appended to block-anchor diagnostics. */
 export interface BlockDiagnosticSuggestions {
@@ -113,26 +124,24 @@ export interface BlockDiagnosticSuggestions {
 }
 
 /**
- * Block-anchored replace/delete could not resolve to a syntactic block
- * (unsupported language, blank/out-of-range line, no node beginning on N, or
- * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert_after_block N:` never reaches this — it is
- * lowered to plain `insert after N:` instead (see
- * {@link insertAfterBlockUnresolvedLoweredWarning}).
+ * A block-anchored replace/cut could not resolve to a syntactic block.
+ * Appends a {@link formatAnchoredContext} preview when `fileLines` is given.
+ * `INS.BLK.POST N:` never reaches this path; it lowers to `INS.POST N:`.
  */
 export function blockUnresolvedMessage(
 	line: number,
-	op: "replace" | "delete" = "replace",
+	op: AbsoluteRangeOp = "replace",
 	fileLines?: readonly string[],
 	suggestions: BlockDiagnosticSuggestions = {},
 ): string {
-	const phrase = op === "delete" ? `DEL.BLK ${line}` : `SWAP.BLK ${line}:`;
-	const fallback = op === "delete" ? `DEL ${line}${HL_RANGE_SEP}M` : `SWAP ${line}${HL_RANGE_SEP}M:`;
+	const forms = RANGE_OP_FORMS[op];
+	const phrase = blockFormAt(op, line);
+	const fallback = `${forms.keyword} ${line}${HL_RANGE_SEP}M${forms.colon}`;
 	const anchorText = fileLines?.[line - 1];
 	const nextBlock = suggestions.nextBlock;
 	let message: string;
 	if (anchorText !== undefined && anchorText.trim().length === 0 && nextBlock) {
-		const retry = op === "delete" ? `DEL.BLK ${nextBlock.start}` : `SWAP.BLK ${nextBlock.start}:`;
+		const retry = blockFormAt(op, nextBlock.start);
 		message =
 			`Line ${line} is blank; no syntactic block can begin there. ` +
 			`The next multi-line block begins at line ${nextBlock.start} and ends at line ${nextBlock.end}. ` +
@@ -144,7 +153,7 @@ export function blockUnresolvedMessage(
 	}
 	const enclosingBlock = suggestions.enclosingBlock;
 	if (enclosingBlock) {
-		const retry = op === "delete" ? `DEL.BLK ${enclosingBlock.start}` : `SWAP.BLK ${enclosingBlock.start}:`;
+		const retry = blockFormAt(op, enclosingBlock.start);
 		message +=
 			` The nearest enclosing multi-line block begins at line ${enclosingBlock.start} ` +
 			`and ends at line ${enclosingBlock.end}; use \`${retry}\` to target it.`;
@@ -156,26 +165,46 @@ export function blockUnresolvedMessage(
 	return message;
 }
 
-/** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
+/** Block-anchored edit reached a path with no {@link BlockResolver} wired in. */
 export const BLOCK_RESOLVER_UNAVAILABLE =
-	"`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
+	"Block ops (`SWAP.BLK`, `INS.BLK.POST`, `CUT.BLK`, `PASTE.BLK.POST`) are not available here (no block resolver configured). Use a concrete line range.";
 
 /**
- * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
- * plain `insert after N:` — the closer ends a block, and inserting after it
- * is exactly what the plain form does.
+ * An after-block op anchored on a closing-delimiter line, lowered to its
+ * plain after-line form — the closer ends a block, and inserting after it is
+ * exactly what the plain form does.
  */
-export function insertAfterBlockCloserLoweredWarning(line: number): string {
-	return `\`INS.BLK.POST ${line}:\` anchors on a closing delimiter, so it was applied as plain \`INS.POST ${line}:\`. Anchor on the line that OPENS the construct.`;
+function closerLoweredWarning(blockForm: string, plainForm: string): string {
+	return `\`${blockForm}\` anchors on a closing delimiter, so it was applied as plain \`${plainForm}\`. Anchor on the line that OPENS the construct.`;
 }
 
 /**
- * `insert_after_block N:` anchor unresolvable (unsupported language, blank
- * line, parse error, or no resolver), lowered to plain `insert after N:` —
- * applying with a warning beats failing the patch.
+ * An after-block op whose anchor was unresolvable (unsupported language,
+ * blank line, parse error, or no resolver), lowered to its plain after-line
+ * form — applying with a warning beats failing the patch.
  */
+function unresolvedLoweredWarning(blockForm: string, line: number, plainForm: string): string {
+	return `\`${blockForm}\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`${plainForm}\`. Verify the landing line; anchor on a line that OPENS a construct.`;
+}
+
+/** `INS.BLK.POST N:` anchored on a closing-delimiter line; applied as `INS.POST N:`. */
+export function insertAfterBlockCloserLoweredWarning(line: number): string {
+	return closerLoweredWarning(`INS.BLK.POST ${line}:`, `INS.POST ${line}:`);
+}
+
+/** `INS.BLK.POST N:` anchor unresolvable; applied as `INS.POST N:`. */
 export function insertAfterBlockUnresolvedLoweredWarning(line: number): string {
-	return `\`INS.BLK.POST ${line}:\` could not resolve a syntactic block on line ${line}, so it was applied as plain \`INS.POST ${line}:\`. Verify the landing line; anchor on a line that OPENS a construct.`;
+	return unresolvedLoweredWarning(`INS.BLK.POST ${line}:`, line, `INS.POST ${line}:`);
+}
+
+/** `PASTE.BLK.POST N` anchored on a closing-delimiter line; applied as `PASTE.POST N`. */
+export function pasteAfterBlockCloserLoweredWarning(line: number): string {
+	return closerLoweredWarning(`PASTE.BLK.POST ${line}`, `PASTE.POST ${line}`);
+}
+
+/** `PASTE.BLK.POST N` anchor unresolvable; applied as `PASTE.POST N`. */
+export function pasteAfterBlockUnresolvedLoweredWarning(line: number): string {
+	return unresolvedLoweredWarning(`PASTE.BLK.POST ${line}`, line, `PASTE.POST ${line}`);
 }
 /**
  * A one-sided boundary echo whose payload is too short to be the widened
@@ -228,14 +257,11 @@ export function ambiguousCloserSpareMessage(
 }
 
 /**
- * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
- * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
+ * Internal invariant: `applyEdits` received an unresolved block edit;
+ * `resolveBlockEdits` must run first.
  */
 export const UNRESOLVED_BLOCK_INTERNAL =
-	"internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
-
-/** Delete hunk received a body row. */
-export const DELETE_TAKES_NO_BODY = `\`DEL N${HL_RANGE_SEP}M\` does not take body rows. Remove the body, or use \`SWAP N${HL_RANGE_SEP}M:\`.`;
+	"internal error: unresolved block edit reached the applier (resolveBlockEdits was not run).";
 
 /** `REM` received a body row or coexists with line edits. */
 export const REM_TAKES_NO_BODY =
@@ -245,8 +271,23 @@ export const REM_TAKES_NO_BODY =
 export const MOVE_TAKES_NO_BODY =
 	"`MV DEST` does not take body rows. Put line edits above the `MV` row; the destination path follows `MV` on the same line.";
 
-/** `delete_block N` hunk received a body row. */
-export const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
+/** `CUT N.=M` hunk received a body row. */
+export const CUT_TAKES_NO_BODY = `\`CUT N${HL_RANGE_SEP}M\` captures + deletes lines and takes no body rows. To replace lines with new content, use \`SWAP N${HL_RANGE_SEP}M:\`.`;
+
+/** `PASTE` hunk received a body row. */
+export const PASTE_TAKES_NO_BODY =
+	"`PASTE` inserts the clipboard content and takes no `+` body rows. To insert literal text, use `INS`.";
+
+/** `PASTE` ran with an empty clipboard register. */
+export const EMPTY_PASTE = `\`PASTE\` found nothing in the clipboard. Ops run top-to-bottom across the whole patch (sections included): put \`CUT N${HL_RANGE_SEP}M\` or \`CUT.BLK N\` above the \`PASTE\`.`;
+
+/**
+ * Clipboard ops inside a same-path section that was merged across another
+ * file's section. Same-path sections coalesce into their first occurrence, so
+ * an interleaved layout would silently reorder the register sequence.
+ */
+export const CLIPBOARD_INTERLEAVED_SECTIONS =
+	"`CUT`/`PASTE` cannot be used in a file whose sections are interleaved with another file's: same-path sections merge into the first occurrence, which would reorder the clipboard sequence. Keep each file's ops under ONE `[path#TAG]` header.";
 
 /** Insert hunk with no body. */
 export const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
@@ -289,6 +330,23 @@ export const RECOVERY_LINE_REMAP_WARNING =
 export const HEADTAIL_DRIFT_WARNING =
 	"Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) — head/tail position is content-independent. Re-read if the drift was unexpected.";
 
+/**
+ * The `Filesystem` reported that what actually landed on disk differs from
+ * what was written (see `WriteResult.text`) — most commonly an ACP-connected
+ * editor reformatting the buffer on save (e.g. `format_on_save` with tab/space
+ * settings that don't match the file). The recorded snapshot is re-keyed on
+ * the real, post-write content so the next edit's tag validation matches
+ * reality instead of silently drifting.
+ */
+export function writeDriftWarning(path: string): string {
+	return (
+		`${path}: the file on disk after this write differs from what was sent — the client ` +
+		"(editor/IDE) likely reformatted it on save (e.g. format-on-save, tab/space settings). " +
+		"The returned snapshot reflects the actual file; re-read before further edits if the " +
+		"extra changes were unexpected."
+	);
+}
+
 /**
  * Section omitted the mandatory snapshot tag. Shared by the apply
  * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
@@ -396,33 +454,29 @@ export function unseenLinesMessage(
 }
 
 /** Op kind of a deferred block edit, for {@link blockSingleLineMessage}. */
-export type BlockOp = "replace" | "delete" | "insert_after";
+export type BlockOp = "replace" | "insert_after" | "cut" | "paste_after";
+
+/** Display forms per deferred-block op: block keyword, trailing colon, and single-line plain form. */
+const BLOCK_OP_FORMS: Record<BlockOp, { keyword: string; colon: string; plain: (line: number) => string }> = {
+	replace: { keyword: "SWAP.BLK", colon: ":", plain: line => `SWAP ${line}${HL_RANGE_SEP}${line}:` },
+	insert_after: { keyword: "INS.BLK.POST", colon: ":", plain: line => `INS.POST ${line}:` },
+	cut: { keyword: "CUT.BLK", colon: "", plain: line => `CUT ${line}` },
+	paste_after: { keyword: "PASTE.BLK.POST", colon: "", plain: line => `PASTE.POST ${line}` },
+};
 
 /**
- * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
- * single line — almost always a bare statement the model mis-anchored, not a
- * multi-line construct. The plain op is unambiguous for one line; the block
- * form only earns its keep when it spares counting a closing line you cannot
- * see. Reject and point at both fixes.
+ * A block-op anchor resolved to a single line: line N is a bare statement,
+ * not the opening line of a multi-line construct. The plain op is exact for
+ * one line, so reject and point at it.
  */
 export function blockSingleLineMessage(line: number, op: BlockOp, enclosingBlock?: BlockSpan): string {
-	const blockForm = op === "insert_after" ? "INS.BLK.POST" : op === "delete" ? "DEL.BLK" : "SWAP.BLK";
-	const plainForm =
-		op === "insert_after"
-			? `INS.POST ${line}:`
-			: op === "delete"
-				? `DEL ${line}`
-				: `SWAP ${line}${HL_RANGE_SEP}${line}:`;
+	const forms = BLOCK_OP_FORMS[op];
+	const plainForm = forms.plain(line);
 	let message =
-		`\`${blockForm} ${line}\` resolved a single-line block — line ${line} is a bare statement, not the opening line ` +
+		`\`${forms.keyword} ${line}\` resolved a single-line block — line ${line} is a bare statement, not the opening line ` +
 		`of a multi-line construct. For only this statement use \`${plainForm}\`.`;
 	if (enclosingBlock) {
-		const enclosingForm =
-			op === "insert_after"
-				? `INS.BLK.POST ${enclosingBlock.start}:`
-				: op === "delete"
-					? `DEL.BLK ${enclosingBlock.start}`
-					: `SWAP.BLK ${enclosingBlock.start}:`;
+		const enclosingForm = `${forms.keyword} ${enclosingBlock.start}${forms.colon}`;
 		message +=
 			` The nearest enclosing multi-line block begins at line ${enclosingBlock.start} ` +
 			`and ends at line ${enclosingBlock.end}; use \`${enclosingForm}\` to target it.`;

package/src/parser.ts

@@ -7,19 +7,22 @@ import { HL_PAYLOAD_REPLACE, HL_RANGE_SEP } from "./format";
 import {
 	type AbsoluteRangeOp,
 	BARE_BODY_AUTO_PIPED_WARNING,
-	DELETE_BLOCK_TAKES_NO_BODY,
-	DELETE_TAKES_NO_BODY,
+	CUT_TAKES_NO_BODY,
 	EMPTY_BLOCK,
 	EMPTY_INSERT,
 	invalidAbsoluteRangeMessage,
 	MINUS_BULLET_AUTO_PIPED_WARNING,
 	MINUS_ROW_REJECTED,
 	MOVE_TAKES_NO_BODY,
+	PASTE_TAKES_NO_BODY,
 	REM_TAKES_NO_BODY,
 } from "./messages";
 import { stripOneLeadingHashlinePrefix } from "./prefixes";
 import { type BlockTarget, cloneCursor, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
 import type { Anchor, BlockSpan, Cursor, Edit, FileOp } from "./types";
+
+/** Bounds parser amplification before the target file's line count is available. */
+const MAX_EXPANDED_RANGE_LINES = 100_000;
 /** Parser error carrying enough range metadata for source-aware diagnostic enrichment. */
 export class InvalidAbsoluteRangeError extends Error {
 	/** Patch-language line containing the invalid range header. */
@@ -46,22 +49,49 @@ export class InvalidAbsoluteRangeError extends Error {
 	}
 }
 
-function validateRangeOrder(range: ParsedRange, lineNum: number, op: AbsoluteRangeOp): void {
+function validateRange(range: ParsedRange, lineNum: number, op: AbsoluteRangeOp): void {
+	if (
+		!Number.isSafeInteger(range.start.line) ||
+		range.start.line < 1 ||
+		!Number.isSafeInteger(range.end.line) ||
+		range.end.line < 1
+	) {
+		throw new Error(
+			`line ${lineNum}: ${op} range endpoints must be positive safe integers; got ${range.start.line} and ${range.end.line}.`,
+		);
+	}
 	if (range.end.line < range.start.line) {
 		throw new InvalidAbsoluteRangeError(lineNum, range.start.line, range.end.line, op);
 	}
-}
-
-function expandRange(range: ParsedRange): Anchor[] {
-	const anchors: Anchor[] = [];
-	for (let line = range.start.line; line <= range.end.line; line++) anchors.push({ line });
-	return anchors;
+	const span = range.end.line - range.start.line + 1;
+	if (span > MAX_EXPANDED_RANGE_LINES) {
+		throw new Error(
+			`line ${lineNum}: ${op} range spans ${span} lines; the maximum is ${MAX_EXPANDED_RANGE_LINES}. Split it into smaller hunks.`,
+		);
+	}
 }
 
 function isSkippableCommentLine(line: string): boolean {
 	return line.trimStart().startsWith("#");
 }
 
+/**
+ * Body-row rejection message for targets that take no `+TEXT` rows, or `null`
+ * for targets whose header is followed by a body.
+ */
+function bodylessTargetMessage(target: BlockTarget): string | null {
+	switch (target.kind) {
+		case "cut":
+		case "cut_block":
+			return CUT_TAKES_NO_BODY;
+		case "paste":
+		case "paste_after_block":
+			return PASTE_TAKES_NO_BODY;
+		default:
+			return null;
+	}
+}
+
 /**
  * Stripped remainder of a bare `N: <value>` row that is a lone quoted or
  * numeric literal (optionally comma-terminated) — the shape of a numeric-keyed
@@ -89,13 +119,13 @@ 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). " +
-			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
+			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|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. " +
-			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
+			`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
 		);
 	}
 	if (trimmed.startsWith("@@")) {
@@ -105,17 +135,20 @@ function detectApplyPatchContamination(text: string, _hasPending: boolean): stri
 			`Drop the \`@@ ... @@\` brackets and write a verb header such as \`SWAP N${HL_RANGE_SEP}M:\`.`
 		);
 	}
-	if (/^DEL\s+[1-9]\d*(?:\s*(?:\.\.|\.=|-|…|\s)\s*[1-9]\d*)?\s*:/.test(trimmed)) {
-		return `\`DEL N${HL_RANGE_SEP}M\` has no colon and no body. Remove the colon and body rows.`;
+	// Bare `PASTE` (optionally `PASTE 5` / `PASTE:`) — the op requires an
+	// explicit position suffix; a bare form would otherwise surface as a
+	// confusing body-row rejection under the preceding hunk.
+	if (/^PASTE(?:\s+[1-9]\d*)?\s*:?\s*$/.test(trimmed)) {
+		return "`PASTE` needs a position: use `PASTE.PRE N` / `PASTE.POST N` / `PASTE.HEAD` / `PASTE.TAIL` / `PASTE.BLK.POST N`.";
 	}
 	if (/^[1-9]\d*\s*$/.test(trimmed)) {
-		return `hunk headers need a verb. Use \`SWAP ${trimmed}${HL_RANGE_SEP}${trimmed}:\` to replace, or \`DEL ${trimmed}\` to delete.`;
+		return `hunk headers need a verb. Use \`SWAP ${trimmed}${HL_RANGE_SEP}${trimmed}:\` to replace, or \`CUT ${trimmed}\` to delete.`;
 	}
 	const bareRange = /^([1-9]\d*)\s*[-. …=]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
 	if (bareRange !== null) {
 		return (
 			`bare range hunk header ${JSON.stringify(trimmed)} is not valid. ` +
-			`Hunk headers need a verb: write \`SWAP ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}:\` or \`DEL ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}\`.`
+			`Hunk headers need a verb: write \`SWAP ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}:\` or \`CUT ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}\`.`
 		);
 	}
 	return null;
@@ -194,8 +227,11 @@ export class Executor {
 				return;
 			case "op-block":
 				this.#discardPendingSkippableComments();
-				if (token.target.kind === "replace" || token.target.kind === "delete") {
-					validateRangeOrder(token.target.range, token.lineNum, token.target.kind);
+				if (token.target.kind === "replace") {
+					validateRange(token.target.range, token.lineNum, "replace");
+				}
+				if (token.target.kind === "cut") {
+					validateRange(token.target.range, token.lineNum, "cut");
 				}
 				if (token.target.kind === "rem") {
 					this.#flushPending();
@@ -228,8 +264,7 @@ export class Executor {
 	endStreaming(): { edits: Edit[]; fileOp?: FileOp; warnings: string[] } {
 		this.#consumePendingSkippableComments();
 		if (this.#pending && this.#pending.payloads.length > 0) this.#flushPending();
-		else if (this.#pending?.target.kind === "delete" || this.#pending?.target.kind === "delete_block")
-			this.#flushPending();
+		else if (this.#pending && bodylessTargetMessage(this.#pending.target) !== null) this.#flushPending();
 		else this.#pending = undefined;
 		this.#validateFileOp();
 		this.#validateNoOverlappingDeletes();
@@ -299,8 +334,8 @@ export class Executor {
 					`Got ${JSON.stringify(`${HL_PAYLOAD_REPLACE}${text}`)}.`,
 			);
 		}
-		if (pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
-		if (pending.target.kind === "delete_block") throw new Error(`line ${lineNum}: ${DELETE_BLOCK_TAKES_NO_BODY}`);
+		const noBodyOnLiteral = bodylessTargetMessage(pending.target);
+		if (noBodyOnLiteral !== null) throw new Error(`line ${lineNum}: ${noBodyOnLiteral}`);
 		this.#commitDeferredBlanks(pending);
 		pending.payloads.push({ kind: "literal", text, lineNum });
 	}
@@ -314,9 +349,8 @@ export class Executor {
 				this.#handleBlank(text, lineNum);
 				return;
 			}
-			if (this.#pending.target.kind === "delete") throw new Error(`line ${lineNum}: ${DELETE_TAKES_NO_BODY}`);
-			if (this.#pending.target.kind === "delete_block")
-				throw new Error(`line ${lineNum}: ${DELETE_BLOCK_TAKES_NO_BODY}`);
+			const noBodyOnRaw = bodylessTargetMessage(this.#pending.target);
+			if (noBodyOnRaw !== null) throw new Error(`line ${lineNum}: ${noBodyOnRaw}`);
 			const row: PayloadRow = { kind: "literal", text, lineNum, bare: true };
 			// `-` rows are held and judged at flush time by #resolveMinusRows,
 			// once the whole body is visible.
@@ -337,7 +371,7 @@ export class Executor {
 		if (text.trim().length === 0) return;
 		throw new Error(
 			`line ${lineNum}: payload line has no preceding hunk header. ` +
-				`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`DEL N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` above the body. Got ${JSON.stringify(text)}.`,
+				`Use \`SWAP N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` above the body. Got ${JSON.stringify(text)}.`,
 		);
 	}
 
@@ -351,7 +385,7 @@ export class Executor {
 	#handleBlank(text: string, lineNum: number): void {
 		const pending = this.#pending;
 		if (!pending) return;
-		if (pending.target.kind === "delete" || pending.target.kind === "delete_block") return;
+		if (bodylessTargetMessage(pending.target) !== null) return;
 		if (pending.payloads.length === 0) return;
 		pending.deferredBlanks.push({ kind: "literal", text, lineNum, bare: true });
 	}
@@ -438,7 +472,28 @@ export class Executor {
 		this.#edits.push({ kind: "delete", anchor: { ...anchor }, lineNum, index: this.#editIndex++ });
 	}
 
-	#pushBlock(anchor: Anchor, payloads: readonly PayloadRow[], lineNum: number, mode?: "insert_after"): void {
+	#pushDeleteRange(range: ParsedRange, lineNum: number): void {
+		for (let line = range.start.line; line <= range.end.line; line++) this.#pushDelete({ line }, lineNum);
+	}
+
+	#pushCut(range: ParsedRange, lineNum: number): void {
+		this.#edits.push({
+			kind: "cut",
+			range: { start: { ...range.start }, end: { ...range.end } },
+			lineNum,
+			index: this.#editIndex++,
+		});
+		// Capture before ordinary per-line deletes are applied. Keeping deletion
+		// as low-level edits preserves overlap validation and recovery remapping.
+		this.#pushDeleteRange(range, lineNum);
+	}
+
+	#pushBlock(
+		anchor: Anchor,
+		payloads: readonly PayloadRow[],
+		lineNum: number,
+		mode?: "insert_after" | "cut" | "paste_after",
+	): void {
 		this.#edits.push({
 			kind: "block",
 			anchor: { ...anchor },
@@ -460,13 +515,20 @@ export class Executor {
 		this.#resolveMinusRows(payloads);
 		this.#stripBarePrefixesIfUniform(payloads);
 		this.#pending = undefined;
-		if (target.kind === "delete") {
-			for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);
+		if (target.kind === "cut") {
+			this.#pushCut(target.range, lineNum);
+			return;
+		}
+		if (target.kind === "cut_block") {
+			this.#pushBlock(target.anchor, [], lineNum, "cut");
+			return;
+		}
+		if (target.kind === "paste") {
+			this.#edits.push({ kind: "paste", cursor: cloneCursor(target.cursor), lineNum, index: this.#editIndex++ });
 			return;
 		}
-		if (target.kind === "delete_block") {
-			// A block edit with no payloads resolves to a pure block deletion.
-			this.#pushBlock(target.anchor, [], lineNum);
+		if (target.kind === "paste_after_block") {
+			this.#pushBlock(target.anchor, [], lineNum, "paste_after");
 			return;
 		}
 		if (target.kind === "block") {
@@ -481,7 +543,7 @@ export class Executor {
 		}
 		if (payloads.length === 0) {
 			if (target.kind === "replace") {
-				for (const anchor of expandRange(target.range)) this.#pushDelete(anchor, lineNum);
+				this.#pushDeleteRange(target.range, lineNum);
 				return;
 			}
 			throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
@@ -489,7 +551,7 @@ export class Executor {
 		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);
+			this.#pushDeleteRange(target.range, lineNum);
 			return;
 		}
 		if (target.kind === "insert_before") {