@oh-my-pi/hashline 17.2.1 → 17.2.2

package/src/parser.ts

@@ -7,19 +7,28 @@ import { HL_PAYLOAD_REPLACE, HL_RANGE_SEP } from "./format";
 import {
 	type AbsoluteRangeOp,
 	BARE_BODY_AUTO_PIPED_WARNING,
+	BARE_RANGE_AUTO_PUT_WARNING,
+	COLON_ON_REGISTER_PUT,
+	COLONLESS_PUT_TAKES_NO_BODY,
+	COLONLESS_SPAN_PUT,
+	CUT_COLON_IGNORED_WARNING,
 	CUT_TAKES_NO_BODY,
-	EMPTY_BLOCK,
+	DIFF_OLD_ROWS_IGNORED_WARNING,
 	EMPTY_INSERT,
+	EMPTY_PUT_AUTO_CUT_WARNING,
 	invalidAbsoluteRangeMessage,
 	MINUS_BULLET_AUTO_PIPED_WARNING,
 	MINUS_ROW_REJECTED,
 	MOVE_TAKES_NO_BODY,
-	PASTE_TAKES_NO_BODY,
+	READ_METADATA_IGNORED_WARNING,
+	REGISTER_PUT_TAKES_NO_BODY,
 	REM_TAKES_NO_BODY,
+	REPLACE_PAIR_COALESCED_WARNING,
+	SNAPSHOT_ROWS_AUTO_PUT_WARNING,
 } from "./messages";
-import { stripOneLeadingHashlinePrefix } from "./prefixes";
+import { isReadMetadataLine, stripOneLeadingHashlinePrefix } from "./prefixes";
 import { type BlockTarget, cloneCursor, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
-import type { Anchor, BlockSpan, Cursor, Edit, FileOp } from "./types";
+import type { Anchor, BlockSpan, Cursor, Edit, FileOp, PasteTarget } from "./types";
 
 /** Bounds parser amplification before the target file's line count is available. */
 const MAX_EXPANDED_RANGE_LINES = 100_000;
@@ -33,23 +42,32 @@ export class InvalidAbsoluteRangeError extends Error {
 	readonly endLine: number;
 	/** Operation whose range was invalid. */
 	readonly op: AbsoluteRangeOp;
-
-	constructor(patchLine: number, startLine: number, endLine: number, op: AbsoluteRangeOp, block?: BlockSpan) {
-		super(invalidAbsoluteRangeMessage(patchLine, startLine, endLine, op, block));
+	readonly register?: string;
+
+	constructor(
+		patchLine: number,
+		startLine: number,
+		endLine: number,
+		op: AbsoluteRangeOp,
+		block?: BlockSpan,
+		register?: string,
+	) {
+		super(invalidAbsoluteRangeMessage(patchLine, startLine, endLine, op, block, register));
 		this.name = "InvalidAbsoluteRangeError";
 		this.patchLine = patchLine;
 		this.startLine = startLine;
 		this.endLine = endLine;
 		this.op = op;
+		this.register = register;
 	}
 
 	/** Rebuild this error with a proven syntactic-block endpoint suggestion. */
 	withBlock(block: BlockSpan): InvalidAbsoluteRangeError {
-		return new InvalidAbsoluteRangeError(this.patchLine, this.startLine, this.endLine, this.op, block);
+		return new InvalidAbsoluteRangeError(this.patchLine, this.startLine, this.endLine, this.op, block, this.register);
 	}
 }
 
-function validateRange(range: ParsedRange, lineNum: number, op: AbsoluteRangeOp): void {
+function validateRange(range: ParsedRange, lineNum: number, op: AbsoluteRangeOp, register?: string): void {
 	if (
 		!Number.isSafeInteger(range.start.line) ||
 		range.start.line < 1 ||
@@ -61,7 +79,7 @@ function validateRange(range: ParsedRange, lineNum: number, op: AbsoluteRangeOp)
 		);
 	}
 	if (range.end.line < range.start.line) {
-		throw new InvalidAbsoluteRangeError(lineNum, range.start.line, range.end.line, op);
+		throw new InvalidAbsoluteRangeError(lineNum, range.start.line, range.end.line, op, undefined, register);
 	}
 	const span = range.end.line - range.start.line + 1;
 	if (span > MAX_EXPANDED_RANGE_LINES) {
@@ -76,20 +94,15 @@ function isSkippableCommentLine(line: string): boolean {
 }
 
 /**
- * Body-row rejection message for targets that take no `+TEXT` rows, or `null`
- * for targets whose header is followed by a body.
+ * Body-row rejection message for ops that take no `+TEXT` rows, or `null`
+ * for ops whose header (`:`) promises 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;
-	}
+function bodylessTargetMessage(target: BlockTarget, hadColon: boolean): string | null {
+	if (target.kind === "cut" || target.kind === "cut_block") return CUT_TAKES_NO_BODY;
+	if (target.kind === "rem" || target.kind === "move") return null;
+	if (target.register !== undefined) return REGISTER_PUT_TAKES_NO_BODY;
+	if (!hadColon) return COLONLESS_PUT_TAKES_NO_BODY;
+	return null;
 }
 
 /**
@@ -99,6 +112,26 @@ function bodylessTargetMessage(target: BlockTarget): string | null {
  */
 const BARE_LITERAL_VALUE_RE = /^\s*(?:"[^"]*"|'[^']*'|[-+]?\d+(?:\.\d+)?)\s*,?\s*$/;
 
+const TOP_LEVEL_SNAPSHOT_ROW_RE = /^\s*([1-9]\d*):(.*)$/;
+
+function parseTopLevelSnapshotRow(text: string): { line: number; text: string } | null {
+	const match = TOP_LEVEL_SNAPSHOT_ROW_RE.exec(text);
+	if (match === null) return null;
+	const line = Number(match[1]);
+	if (!Number.isSafeInteger(line)) return null;
+	return { line, text: match[2] };
+}
+const TOP_LEVEL_BARE_RANGE_HEADER_RE = /^\s*([1-9]\d*)(?:\s|[-.=…])+([1-9]\d*)\s*:\s*$/;
+
+function parseTopLevelBareRangeHeader(text: string): ParsedRange | null {
+	const match = TOP_LEVEL_BARE_RANGE_HEADER_RE.exec(text);
+	if (match === null) return null;
+	const start = Number(match[1]);
+	const end = Number(match[2]);
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end)) return null;
+	return { start: { line: start }, end: { line: end } };
+}
+
 /**
  * Markdown-bullet shape: optional indent, `-`, exactly one space, then
  * content. Unified-diff `-` rows almost never match — code lines get the `-`
@@ -119,36 +152,30 @@ 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:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
+			`Use \`PUT N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`PUT <N:\`/\`PUT >N:\` 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:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`INS.PRE|POST|HEAD|TAIL:\` ops.`
+			`Use \`PUT N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`PUT <N:\`/\`PUT >N:\` ops.`
 		);
 	}
 	if (trimmed.startsWith("@@")) {
 		const preview = trimmed.length > 48 ? `${trimmed.slice(0, 48)}…` : trimmed;
 		return (
 			`\`@@\`-bracketed hunk header ${JSON.stringify(preview)} is not valid in hashline. ` +
-			`Drop the \`@@ ... @@\` brackets and write a verb header such as \`SWAP N${HL_RANGE_SEP}M:\`.`
+			`Drop the \`@@ ... @@\` brackets and write a header such as \`PUT N${HL_RANGE_SEP}M:\`.`
 		);
 	}
-	// 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 \`CUT ${trimmed}\` to delete.`;
+		return `hunk headers need a verb and both endpoints. Use \`PUT ${trimmed}${HL_RANGE_SEP}${trimmed}:\` to replace, or \`CUT ${trimmed}${HL_RANGE_SEP}${trimmed}\` to delete.`;
 	}
-	const bareRange = /^([1-9]\d*)\s*[-. …=]+\s*([1-9]\d*)\s*:?$/.exec(trimmed);
+	const bareRange = /^([1-9]\d*)\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 \`CUT ${bareRange[1]}${HL_RANGE_SEP}${bareRange[2]}\`.`
+			`Hunk headers need a verb: use \`PUT N${HL_RANGE_SEP}M:\` or \`CUT N${HL_RANGE_SEP}M\`.`
 		);
 	}
 	return null;
@@ -165,6 +192,8 @@ interface Pending {
 	target: BlockTarget;
 	lineNum: number;
 	payloads: PayloadRow[];
+	/** Whether the header carried `:` — the promise that body rows follow. */
+	hadColon: boolean;
 	/**
 	 * Blank rows seen after the body started. Interior blanks are committed to
 	 * the payload when the next non-blank row arrives; trailing blanks before
@@ -225,27 +254,45 @@ export class Executor {
 				this.#consumePendingSkippableComments();
 				this.#handleRaw(token.text, token.lineNum);
 				return;
-			case "op-block":
+			case "op-block": {
 				this.#discardPendingSkippableComments();
-				if (token.target.kind === "replace") {
-					validateRange(token.target.range, token.lineNum, "replace");
+				const target = token.target;
+				if (target.kind === "replace") {
+					validateRange(target.range, token.lineNum, "replace", target.register);
+				}
+				if (target.kind === "cut") {
+					validateRange(target.range, token.lineNum, "cut", target.register);
+				}
+				// `:` exclusively promises body rows; ops that never take a body
+				// reject it outright so the sigil keeps one meaning.
+				if (token.hadColon && (target.kind === "cut" || target.kind === "cut_block")) {
+					if (!this.#warnings.includes(CUT_COLON_IGNORED_WARNING)) {
+						this.#warnings.push(CUT_COLON_IGNORED_WARNING);
+					}
 				}
-				if (token.target.kind === "cut") {
-					validateRange(token.target.range, token.lineNum, "cut");
+				if (token.hadColon && target.kind !== "rem" && target.kind !== "move" && target.register !== undefined) {
+					throw new Error(`line ${token.lineNum}: ${COLON_ON_REGISTER_PUT}`);
 				}
-				if (token.target.kind === "rem") {
+				if (target.kind === "rem") {
 					this.#flushPending();
 					this.#setFileOp({ kind: "rem" }, token.lineNum);
 					return;
 				}
-				if (token.target.kind === "move") {
+				if (target.kind === "move") {
 					this.#flushPending();
-					this.#setFileOp({ kind: "move", dest: token.target.dest }, token.lineNum);
+					this.#setFileOp({ kind: "move", dest: target.dest }, token.lineNum);
 					return;
 				}
 				this.#flushPending();
-				this.#pending = { target: token.target, lineNum: token.lineNum, payloads: [], deferredBlanks: [] };
+				this.#pending = {
+					target,
+					lineNum: token.lineNum,
+					payloads: [],
+					hadColon: token.hadColon,
+					deferredBlanks: [],
+				};
 				return;
+			}
 		}
 	}
 
@@ -253,7 +300,7 @@ export class Executor {
 		this.#consumePendingSkippableComments();
 		this.#flushPending();
 		this.#validateFileOp();
-		this.#validateNoOverlappingDeletes();
+		this.#normalizeOverlappingRanges();
 		return {
 			edits: this.#edits,
 			...(this.#fileOp === undefined ? {} : { fileOp: this.#fileOp }),
@@ -263,11 +310,11 @@ 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 && bodylessTargetMessage(this.#pending.target) !== null) this.#flushPending();
+		const pending = this.#pending;
+		if (pending && (pending.payloads.length > 0 || this.#isCompleteBodylessOp(pending))) this.#flushPending();
 		else this.#pending = undefined;
 		this.#validateFileOp();
-		this.#validateNoOverlappingDeletes();
+		this.#normalizeOverlappingRanges();
 		return {
 			edits: this.#edits,
 			...(this.#fileOp === undefined ? {} : { fileOp: this.#fileOp }),
@@ -275,6 +322,27 @@ export class Executor {
 		};
 	}
 
+	/**
+	 * True when a payload-less pending op is already a complete, valid op —
+	 * safe to flush at the end of a streaming parse. A `:`-op still awaiting
+	 * body rows and the invalid colonless-span shape (possibly a truncated
+	 * `PUT 5-9 @reg` line) are dropped instead.
+	 */
+	#isCompleteBodylessOp(pending: Pending): boolean {
+		const { target, hadColon } = pending;
+		if (target.kind === "cut" || target.kind === "cut_block") return true;
+		if (target.kind === "rem" || target.kind === "move") return false;
+		if (target.register !== undefined) return true;
+		if (hadColon) return false;
+		return (
+			target.kind === "insert_before" ||
+			target.kind === "insert_after" ||
+			target.kind === "insert_after_block" ||
+			target.kind === "bof" ||
+			target.kind === "eof"
+		);
+	}
+
 	reset(): void {
 		this.#edits = [];
 		this.#warnings = [];
@@ -304,25 +372,78 @@ export class Executor {
 		}
 	}
 
-	#validateNoOverlappingDeletes(): void {
-		const sourceLinesByAnchor = new Map<number, number[]>();
+	#normalizeOverlappingRanges(): void {
+		type ConcreteHunk = {
+			lineNum: number;
+			sourceLines: Set<number>;
+			clipboardDependent: boolean;
+		};
+		const hunks = new Map<number, ConcreteHunk>();
+		const hunkFor = (lineNum: number): ConcreteHunk => {
+			let hunk = hunks.get(lineNum);
+			if (hunk === undefined) {
+				hunk = { lineNum, sourceLines: new Set(), clipboardDependent: false };
+				hunks.set(lineNum, hunk);
+			}
+			return hunk;
+		};
 		for (const edit of this.#edits) {
-			if (edit.kind !== "delete") continue;
-			let sourceLines = sourceLinesByAnchor.get(edit.anchor.line);
-			if (sourceLines === undefined) {
-				sourceLines = [];
-				sourceLinesByAnchor.set(edit.anchor.line, sourceLines);
+			if (edit.kind === "cut") {
+				hunkFor(edit.lineNum).clipboardDependent = true;
+				continue;
+			}
+			if (edit.kind === "paste" && edit.at.kind === "span") {
+				const hunk = hunkFor(edit.lineNum);
+				hunk.clipboardDependent = true;
+				for (let line = edit.at.range.start.line; line <= edit.at.range.end.line; line++) {
+					hunk.sourceLines.add(line);
+				}
+				continue;
 			}
-			if (!sourceLines.includes(edit.lineNum)) sourceLines.push(edit.lineNum);
+			if (edit.kind === "delete") hunkFor(edit.lineNum).sourceLines.add(edit.anchor.line);
 		}
-		for (const [anchorLine, sourceLines] of sourceLinesByAnchor) {
-			if (sourceLines.length < 2) continue;
-			const [firstBlock, secondBlock] = [...sourceLines].sort((a, b) => a - b);
+
+		const ownerByLine = new Map<number, ConcreteHunk>();
+		const dropped = new Set<number>();
+		const claim = (hunk: ConcreteHunk): void => {
+			for (const line of hunk.sourceLines) ownerByLine.set(line, hunk);
+		};
+		for (const hunk of hunks.values()) {
+			if (hunk.sourceLines.size === 0) continue;
+			const overlaps = new Set<ConcreteHunk>();
+			let firstOverlap: number | undefined;
+			for (const line of hunk.sourceLines) {
+				const owner = ownerByLine.get(line);
+				if (owner === undefined) continue;
+				overlaps.add(owner);
+				firstOverlap ??= line;
+			}
+			if (overlaps.size === 0) {
+				claim(hunk);
+				continue;
+			}
+			const previous = overlaps.size === 1 ? overlaps.values().next().value : undefined;
+			const exact =
+				previous !== undefined &&
+				previous.sourceLines.size === hunk.sourceLines.size &&
+				[...hunk.sourceLines].every(line => previous.sourceLines.has(line));
+			if (exact && !previous.clipboardDependent) {
+				dropped.add(previous.lineNum);
+				for (const line of previous.sourceLines) {
+					if (ownerByLine.get(line) === previous) ownerByLine.delete(line);
+				}
+				claim(hunk);
+				if (!this.#warnings.includes(REPLACE_PAIR_COALESCED_WARNING)) {
+					this.#warnings.push(REPLACE_PAIR_COALESCED_WARNING);
+				}
+				continue;
+			}
 			throw new Error(
-				`line ${secondBlock}: anchor line ${anchorLine} is already targeted by another hunk on line ${firstBlock}. ` +
+				`line ${hunk.lineNum}: anchor line ${firstOverlap} is already targeted by another hunk on line ${previous?.lineNum ?? "an earlier line"}. ` +
 					"Issue ONE hunk per range; payload is only the final desired content, never a before/after pair.",
 			);
 		}
+		if (dropped.size > 0) this.#edits = this.#edits.filter(edit => !dropped.has(edit.lineNum));
 	}
 
 	#handleLiteralPayload(text: string, lineNum: number): void {
@@ -334,13 +455,19 @@ export class Executor {
 					`Got ${JSON.stringify(`${HL_PAYLOAD_REPLACE}${text}`)}.`,
 			);
 		}
-		const noBodyOnLiteral = bodylessTargetMessage(pending.target);
+		const noBodyOnLiteral = bodylessTargetMessage(pending.target, pending.hadColon);
 		if (noBodyOnLiteral !== null) throw new Error(`line ${lineNum}: ${noBodyOnLiteral}`);
 		this.#commitDeferredBlanks(pending);
 		pending.payloads.push({ kind: "literal", text, lineNum });
 	}
 
 	#handleRaw(text: string, lineNum: number): void {
+		if (this.#pending === undefined && isReadMetadataLine(text)) {
+			if (!this.#warnings.includes(READ_METADATA_IGNORED_WARNING)) {
+				this.#warnings.push(READ_METADATA_IGNORED_WARNING);
+			}
+			return;
+		}
 		const contamination = detectApplyPatchContamination(text, this.#pending !== undefined);
 		if (contamination !== null) throw new Error(`line ${lineNum}: ${contamination}`);
 		if (this.#fileOp !== undefined) throw new Error(`line ${lineNum}: ${MOVE_TAKES_NO_BODY}`);
@@ -349,7 +476,7 @@ export class Executor {
 				this.#handleBlank(text, lineNum);
 				return;
 			}
-			const noBodyOnRaw = bodylessTargetMessage(this.#pending.target);
+			const noBodyOnRaw = bodylessTargetMessage(this.#pending.target, this.#pending.hadColon);
 			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,
@@ -369,9 +496,40 @@ export class Executor {
 			return;
 		}
 		if (text.trim().length === 0) return;
+		const bareRange = parseTopLevelBareRangeHeader(text);
+		if (bareRange !== null) {
+			validateRange(bareRange, lineNum, "replace");
+			this.#pending = {
+				target: { kind: "replace", range: bareRange },
+				lineNum,
+				payloads: [],
+				hadColon: true,
+				deferredBlanks: [],
+			};
+			if (!this.#warnings.includes(BARE_RANGE_AUTO_PUT_WARNING)) {
+				this.#warnings.push(BARE_RANGE_AUTO_PUT_WARNING);
+			}
+			return;
+		}
+		const snapshotRow = parseTopLevelSnapshotRow(text);
+		if (snapshotRow !== null) {
+			const range = { start: { line: snapshotRow.line }, end: { line: snapshotRow.line } };
+			validateRange(range, lineNum, "replace");
+			this.#pushInsert(
+				{ kind: "before_anchor", anchor: { line: snapshotRow.line } },
+				snapshotRow.text,
+				lineNum,
+				"replacement",
+			);
+			this.#pushDeleteRange(range, lineNum);
+			if (!this.#warnings.includes(SNAPSHOT_ROWS_AUTO_PUT_WARNING)) {
+				this.#warnings.push(SNAPSHOT_ROWS_AUTO_PUT_WARNING);
+			}
+			return;
+		}
 		throw new Error(
 			`line ${lineNum}: payload line has no preceding hunk header. ` +
-				`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)}.`,
+				`Use \`PUT N${HL_RANGE_SEP}M:\`, \`CUT N${HL_RANGE_SEP}M\`, or \`PUT <N:\`/\`PUT >N:\` above the body. Got ${JSON.stringify(text)}.`,
 		);
 	}
 
@@ -385,7 +543,7 @@ export class Executor {
 	#handleBlank(text: string, lineNum: number): void {
 		const pending = this.#pending;
 		if (!pending) return;
-		if (bodylessTargetMessage(pending.target) !== null) return;
+		if (bodylessTargetMessage(pending.target, pending.hadColon) !== null) return;
 		if (pending.payloads.length === 0) return;
 		pending.deferredBlanks.push({ kind: "literal", text, lineNum, bare: true });
 	}
@@ -398,15 +556,13 @@ export class Executor {
 	}
 
 	/**
-	 * Judge bare `-` body rows once the whole hunk body is known. They are
-	 * usually unified-diff contamination (`-old` next to `+new`) and inserting
-	 * them would corrupt the file, so they are rejected — EXCEPT when the body
-	 * is unambiguously a Markdown bullet list: every `-` row is bullet-shaped
-	 * (`- item`) and the body is either fully bare or already contains an
-	 * explicit `+- item` sibling. Those rows are kept as literal content with a
-	 * warning instead of failing the patch.
+	 * Judge bare `-` body rows once the whole hunk body is known. Non-bullet
+	 * rows paired with explicit `+new` rows are unified-diff contamination, so
+	 * discard the redundant old rows. Unambiguously literal Markdown bullets
+	 * are kept. Other `-` rows remain rejected rather than silently corrupting
+	 * source.
 	 */
-	#resolveMinusRows(payloads: readonly PayloadRow[]): void {
+	#resolveMinusRows(payloads: PayloadRow[]): void {
 		let firstMinus: PayloadRow | undefined;
 		let allBulletShaped = true;
 		let hasExplicit = false;
@@ -426,6 +582,15 @@ export class Executor {
 				this.#warnings.push(MINUS_BULLET_AUTO_PIPED_WARNING);
 			return;
 		}
+		if (hasExplicit && !allBulletShaped) {
+			for (let i = payloads.length - 1; i >= 0; i--) {
+				if (payloads[i].minus) payloads.splice(i, 1);
+			}
+			if (!this.#warnings.includes(DIFF_OLD_ROWS_IGNORED_WARNING)) {
+				this.#warnings.push(DIFF_OLD_ROWS_IGNORED_WARNING);
+			}
+			return;
+		}
 		throw new Error(`line ${firstMinus.lineNum}: ${MINUS_ROW_REJECTED}`);
 	}
 
@@ -476,10 +641,11 @@ export class Executor {
 		for (let line = range.start.line; line <= range.end.line; line++) this.#pushDelete({ line }, lineNum);
 	}
 
-	#pushCut(range: ParsedRange, lineNum: number): void {
+	#pushCut(range: ParsedRange, lineNum: number, register: string | undefined): void {
 		this.#edits.push({
 			kind: "cut",
 			range: { start: { ...range.start }, end: { ...range.end } },
+			...(register === undefined ? {} : { register }),
 			lineNum,
 			index: this.#editIndex++,
 		});
@@ -488,17 +654,29 @@ export class Executor {
 		this.#pushDeleteRange(range, lineNum);
 	}
 
+	#pushPaste(at: PasteTarget, register: string | undefined, lineNum: number): void {
+		this.#edits.push({
+			kind: "paste",
+			at,
+			...(register === undefined ? {} : { register }),
+			lineNum,
+			index: this.#editIndex++,
+		});
+	}
+
 	#pushBlock(
 		anchor: Anchor,
 		payloads: readonly PayloadRow[],
 		lineNum: number,
 		mode?: "insert_after" | "cut" | "paste_after",
+		register?: string,
 	): void {
 		this.#edits.push({
 			kind: "block",
 			anchor: { ...anchor },
 			payloads: payloads.map(payload => payload.text),
 			...(mode === undefined ? {} : { mode }),
+			...(register === undefined ? {} : { register }),
 			lineNum,
 			index: this.#editIndex++,
 		});
@@ -511,58 +689,84 @@ export class Executor {
 	#flushPending(): void {
 		const pending = this.#pending;
 		if (!pending) return;
-		const { target, lineNum, payloads } = pending;
+		const { target, lineNum, payloads, hadColon } = pending;
 		this.#resolveMinusRows(payloads);
 		this.#stripBarePrefixesIfUniform(payloads);
 		this.#pending = undefined;
+		if (target.kind === "rem" || target.kind === "move") return;
 		if (target.kind === "cut") {
-			this.#pushCut(target.range, lineNum);
+			this.#pushCut(target.range, lineNum, target.register);
 			return;
 		}
 		if (target.kind === "cut_block") {
-			this.#pushBlock(target.anchor, [], lineNum, "cut");
+			this.#pushBlock(target.anchor, [], lineNum, "cut", target.register);
 			return;
 		}
-		if (target.kind === "paste") {
-			this.#edits.push({ kind: "paste", cursor: cloneCursor(target.cursor), lineNum, index: this.#editIndex++ });
-			return;
-		}
-		if (target.kind === "paste_after_block") {
-			this.#pushBlock(target.anchor, [], lineNum, "paste_after");
+		// Span targets: body writes, register pastes over the span; the
+		// anonymous register never pastes over a span (too easy to fire by
+		// forgetting `:` + body on a replace).
+		if (target.kind === "replace") {
+			if (target.register !== undefined) {
+				this.#pushPaste(
+					{ kind: "span", range: { start: { ...target.range.start }, end: { ...target.range.end } } },
+					target.register,
+					lineNum,
+				);
+				return;
+			}
+			if (payloads.length === 0) {
+				if (!hadColon) throw new Error(`line ${lineNum}: ${COLONLESS_SPAN_PUT}`);
+				this.#pushDeleteRange(target.range, lineNum);
+				if (!this.#warnings.includes(EMPTY_PUT_AUTO_CUT_WARNING)) {
+					this.#warnings.push(EMPTY_PUT_AUTO_CUT_WARNING);
+				}
+				return;
+			}
+			const cursor: Cursor = { kind: "before_anchor", anchor: { ...target.range.start } };
+			this.#emitPayloadRows(cursor, payloads, lineNum, "replacement");
+			this.#pushDeleteRange(target.range, lineNum);
 			return;
 		}
 		if (target.kind === "block") {
-			if (payloads.length === 0) throw new Error(`line ${lineNum}: ${EMPTY_BLOCK}`);
+			if (target.register !== undefined) {
+				this.#pushBlock(target.anchor, [], lineNum, undefined, target.register);
+				return;
+			}
+			if (payloads.length === 0) {
+				if (!hadColon) throw new Error(`line ${lineNum}: ${COLONLESS_SPAN_PUT}`);
+				this.#pushBlock(target.anchor, [], lineNum);
+				if (!this.#warnings.includes(EMPTY_PUT_AUTO_CUT_WARNING)) {
+					this.#warnings.push(EMPTY_PUT_AUTO_CUT_WARNING);
+				}
+				return;
+			}
 			this.#pushBlock(target.anchor, payloads, lineNum);
 			return;
 		}
+		// Gap targets: body inserts, register pastes, and the colonless
+		// bodyless form is an anonymous paste.
 		if (target.kind === "insert_after_block") {
-			if (payloads.length === 0) throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
-			this.#pushBlock(target.anchor, payloads, lineNum, "insert_after");
-			return;
-		}
-		if (payloads.length === 0) {
-			if (target.kind === "replace") {
-				this.#pushDeleteRange(target.range, lineNum);
+			if (target.register !== undefined || (!hadColon && payloads.length === 0)) {
+				this.#pushBlock(target.anchor, [], lineNum, "paste_after", target.register);
 				return;
 			}
-			throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
-		}
-		if (target.kind === "replace") {
-			const cursor: Cursor = { kind: "before_anchor", anchor: { ...target.range.start } };
-			this.#emitPayloadRows(cursor, payloads, lineNum, "replacement");
-			this.#pushDeleteRange(target.range, lineNum);
-			return;
-		}
-		if (target.kind === "insert_before") {
-			this.#emitPayloadRows({ kind: "before_anchor", anchor: { ...target.anchor } }, payloads, lineNum);
+			if (payloads.length === 0) throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
+			this.#pushBlock(target.anchor, payloads, lineNum, "insert_after");
 			return;
 		}
-		if (target.kind === "insert_after") {
-			this.#emitPayloadRows({ kind: "after_anchor", anchor: { ...target.anchor } }, payloads, lineNum);
+		const cursor: Cursor =
+			target.kind === "insert_before"
+				? { kind: "before_anchor", anchor: { ...target.anchor } }
+				: target.kind === "insert_after"
+					? { kind: "after_anchor", anchor: { ...target.anchor } }
+					: target.kind === "bof"
+						? { kind: "bof" }
+						: { kind: "eof" };
+		if (target.register !== undefined || (!hadColon && payloads.length === 0)) {
+			this.#pushPaste({ kind: "gap", cursor }, target.register, lineNum);
 			return;
 		}
-		const cursor: Cursor = target.kind === "bof" ? { kind: "bof" } : { kind: "eof" };
+		if (payloads.length === 0) throw new Error(`line ${lineNum}: ${EMPTY_INSERT}`);
 		this.#emitPayloadRows(cursor, payloads, lineNum);
 	}
 }