@oh-my-pi/hashline 17.2.11 → 17.2.13

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [17.2.12] - 2026-08-08
+
+### Breaking Changes
+
+- `PUT N.=M @name` over a *span* now throws when `@name` was never captured, instead of warning and deleting the range. Pasting a never-captured register over a span wrote nothing back, so a mistyped or hallucinated register name silently destroyed content. Gap pastes (`PUT >N @name`) keep the warned no-op behaviour from 17.2.11.
+
+### Added
+
+- `applyEdits` now takes a `path` and uses the native tree-sitter parser to decide every boundary repair that depends on delimiter *semantics*. The authored edits are materialized first: if that result parses, it is returned untouched, so a `}` inside a regex literal, a string, or Markdown prose is never mistaken for a block closer. A closer-spare repair lands only when the repaired result is *shown* to parse — never on delimiter arithmetic alone — so an unrecognized language or an unprovable candidate leaves the edit exactly as authored. Wired through the patcher, recovery, section apply, and the edit tool's preview.
+- Auto-repair for replacement ranges that start one line early on a structural closer (the `}` of the construct above): the closer is spared and the payload lands after it, gated on the same parse proof.
+- Warning for balanced payloads over ranges that end mid-block (deleting opener(s) whose closer(s) survive below), pointing at the block-op remedy (`PUT N*:`). Raised only when the baseline parsed and the authored result does not, so it cannot fire on prose or an unknown language.
+- Warning when a `+` body row is itself a valid hunk header (`+CUT 5.=9`). Such a row is literal content by definition and is inserted into the file as text; naming it at the moment it happens turns a silent source-file corruption into an actionable diagnostic.
+
+### Fixed
+
+- Rejected patches whose pasted `N:TEXT` read-output rows repeat a source line number. Each such row is recovered as a single-line `PUT N.=N:`, so a body written as consecutive lines under one number collapsed through the same-range coalescer, keeping only the last row and silently dropping the rest — in one incident replacing a block opener with `}` and deleting the following statement. The error now names the repeated line and teaches the explicit `PUT` form.
+
 ## [17.2.11] - 2026-08-07
 
 ### Changed

package/dist/types/apply.d.ts

@@ -20,11 +20,27 @@ export interface ApplyEditsOptions {
     clipboard?: Clipboard;
     /** Anonymous `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). An empty named-register paste never throws — it warns and pastes nothing. */
     onEmptyPaste?: "throw" | "drop";
+    /**
+     * Target file path, used only to infer a language for the tree-sitter
+     * syntax probe (see {@link parsesCleanly}). Supplying it lets the applier
+     * confirm that the edit as authored still parses, in which case no
+     * delimiter-shape repair or advisory may touch it. Omitted, the probe casts
+     * no veto and the delimiter heuristics decide alone.
+     */
+    path?: string;
 }
 /**
  * Apply a parsed list of edits to a text body. Pure function — no I/O.
  *
  * Returns the post-edit text and the first changed line number (1-indexed).
  * Throws if an anchor is out of bounds.
+ *
+ * Repairs that hinge on delimiter *semantics* (a range that swallowed the `}`
+ * closing the construct above or below it) are subject to a parser veto when
+ * `options.path` is supplied: the authored edits are materialized first, and if
+ * that result parses it is returned untouched. A `}` in prose, a string, or a
+ * regex literal is therefore never mistaken for a block closer. Only when the
+ * authored result does not parse — or the language is unknown to the parser, so
+ * balance arithmetic is the sole evidence — do the closer-spare repairs run.
  */
 export declare function applyEdits(text: string, edits: readonly Edit[], options?: ApplyEditsOptions): ApplyResult;

package/dist/types/index.d.ts

@@ -14,5 +14,6 @@ export * from "./prefixes.js";
 export * from "./recovery.js";
 export * from "./snapshots.js";
 export * from "./stream.js";
+export * from "./syntax.js";
 export * from "./tokenizer.js";
 export * from "./types.js";

package/dist/types/messages.d.ts

@@ -29,6 +29,20 @@ export declare const REPLACEMENT_INDENT_AUTO_SHIFT_WARNING = "Auto-indented a re
 export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines.";
 /** Top-level read-output rows recovered as single-line replacements. */
 export declare const SNAPSHOT_ROWS_AUTO_PUT_WARNING = "Recovered top-level `N:TEXT` snapshot row(s) as single-line `PUT N.=N:` replacements. Use explicit `PUT` headers for reliable edits.";
+/**
+ * Two or more top-level `N:TEXT` read-output rows named the same source line.
+ * Each recovered row lowers to a single-line `PUT N.=N:`, so the coalescer would
+ * keep only the last and silently drop the others — reject and teach the format
+ * instead.
+ */
+export declare function repeatedSnapshotRowMessage(line: number): string;
+/**
+ * A `+` body row whose text is itself a valid hunk header — the op was written
+ * with the payload prefix, so it is inserted into the file as literal text
+ * instead of executing. Warned rather than rejected: a literal `CUT …` line is
+ * legitimate content in documentation and test fixtures.
+ */
+export declare function literalOpRowWarning(line: number, text: string): string;
 /** Bare range header recovered as an implicit replacement hunk. */
 export declare const BARE_RANGE_AUTO_PUT_WARNING = "Recovered a bare `N.=M:` header as `PUT N.=M:`. Prefix replacement ranges with `PUT`.";
 /** Copied read-output elision rows were ignored rather than written as source. */
@@ -88,6 +102,25 @@ export declare function ambiguousBoundaryEchoMessage(startLine: number, endLine:
  * sibling), so the edit is rejected instead of repaired.
  */
 export declare function ambiguousCloserSpareMessage(startLine: number, endLine: number, closerLine: number, count: number): string;
+/**
+ * A replacement range starts by deleting structural closer(s) the payload
+ * never restates — the "range started one line early, on the `}` that ends
+ * the construct above" mistake — but the payload's indentation claims a depth
+ * inside the block those closers terminate, so whether the new content
+ * belongs before or after the spared closer is ambiguous. Rejected instead of
+ * repaired; the at-or-above-depth reading is auto-repaired by sparing the
+ * closer ahead of the payload.
+ */
+export declare function ambiguousLeadingCloserSpareMessage(startLine: number, endLine: number, count: number): string;
+/**
+ * A replacement range deletes more opening delimiter(s) than the payload
+ * reopens while the matching closer(s) survive below the range — the
+ * "payload is a complete construct but the range ends mid-block" mistake.
+ * Surfaced as a warning, never a rejection: the applier is language-agnostic
+ * and opener/closer text shape cannot prove a syntactic block (the braces may
+ * be literal prose), so the edit applies as authored and the author decides.
+ */
+export declare function midBlockRangeWarning(startLine: number, endLine: number, orphaned: number): string;
 /**
  * Internal invariant: `applyEdits` received an unresolved block edit;
  * `resolveBlockEdits` must run first.
@@ -109,8 +142,14 @@ export declare const COLONLESS_PUT_TAKES_NO_BODY = "`PUT` without `:` is clipboa
 export declare const COLONLESS_SPAN_PUT = "Colonless `PUT` is clipboard-backed, and span targets need a named register (`PUT 5.=9 @name`); the anonymous register pastes only at gaps (`PUT >40`). To write literal content, add `:` and `+TEXT` body rows.";
 /** Anonymous paste ran with an empty anonymous register. */
 export declare const EMPTY_PASTE = "Nothing to paste: no unlabeled `CUT` precedes this `PUT` in this call, and the anonymous register never carries across calls. Put `CUT N.=M` / `CUT N*` above it, or use named registers (`CUT \u2026 @name` \u2192 `PUT \u2026 @name`) for cross-call moves.";
-/** Named paste read a register that holds nothing; the paste applied as empty (span targets are still removed). */
+/** Named paste read a register that holds nothing; a gap paste applies as empty. */
 export declare function emptyRegisterPasteWarning(name: string, known: readonly string[]): string;
+/**
+ * Named paste over a *span* read a register that holds nothing. Pasting empty
+ * would delete the span, which the author never asked for — almost always a
+ * mistyped or never-captured register name — so the edit is rejected instead.
+ */
+export declare function emptyRegisterSpanPasteMessage(name: string, known: readonly string[]): string;
 /** Unlabeled paste with two or more unlabeled cuts pending. */
 export declare function ambiguousAnonymousPasteMessage(pending: readonly string[]): string;
 /**

package/dist/types/syntax.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Syntax probe for candidate edit results, via the native tree-sitter parser.
+ *
+ * Delimiter-balance arithmetic cannot tell a block closer from a `}` inside a
+ * regex literal, a string, or Markdown prose. A parser can, so it holds veto
+ * power over every repair whose justification is "this line closes a syntactic
+ * block": when the edit the author actually wrote still parses, no such repair
+ * may rewrite it. The probe never *forces* a repair — an unrecognized language
+ * or an already-broken file simply yields no veto, leaving the delimiter
+ * heuristics as the only available evidence.
+ */
+/**
+ * `true` when `text` parses without a syntax error under the language inferred
+ * from `path`. `false` covers "does not parse" and "cannot tell" alike — no
+ * path, an unrecognized language, or a native failure — because both mean the
+ * probe has nothing to prove with. Callers must therefore never treat `false`
+ * as evidence *about the edit*: it only withholds permission to rewrite.
+ *
+ * Uses `enclosingBlockBoundaries` over a whole-file window: no node can cross
+ * that window, so the boundary walk is trivial and the tree-sitter parse is the
+ * only real cost. It returns `null` for an unrecognized language and for a
+ * source that fails to parse, which this predicate deliberately conflates.
+ */
+export declare function parsesCleanly(path: string | undefined, text: string): boolean;

package/dist/types/tokenizer.d.ts

@@ -43,6 +43,12 @@ export type BlockTarget = {
     kind: "move";
     dest: string;
 };
+/**
+ * Whether `text` would parse as a hunk header on its own (`PUT …`, `CUT …`,
+ * `REM`, `MV …`). Used to catch an op row mistakenly written as a `+` body row,
+ * which the applier would otherwise insert into the file as literal text.
+ */
+export declare function isHunkHeaderText(text: string): boolean;
 interface TokenBase {
     lineNum: number;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "17.2.11",
+	"version": "17.2.13",
 	"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",
@@ -33,8 +33,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.2.11",
-		"@oh-my-pi/pi-utils": "17.2.11"
+		"@oh-my-pi/pi-natives": "17.2.13",
+		"@oh-my-pi/pi-utils": "17.2.13"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/apply.ts

@@ -13,10 +13,13 @@ import {
 	afterInsertLandingShiftWarning,
 	ambiguousBoundaryEchoMessage,
 	ambiguousCloserSpareMessage,
+	ambiguousLeadingCloserSpareMessage,
 	blockInsertLandingShiftWarning,
+	midBlockRangeWarning,
 	REPLACEMENT_INDENT_AUTO_SHIFT_WARNING,
 	UNRESOLVED_BLOCK_INTERNAL,
 } from "./messages";
+import { parsesCleanly } from "./syntax";
 import { cloneCursor } from "./tokenizer";
 import type { Anchor, ApplyResult, Clipboard, Cursor, Edit } from "./types";
 
@@ -120,6 +123,19 @@ function bucketAnchorEditsByLine(edits: IndexedEdit[]): Map<number, IndexedEdit[
 	}
 	return byLine;
 }
+/**
+ * A closer-spare repair could not tell which side of a spared delimiter the
+ * payload belongs on. Distinct from the evidence-complete textual rejections
+ * (a one-sided boundary echo) so {@link applyEdits} can withhold *only* this
+ * delimiter-semantics verdict on a file the parser cannot vouch for, while
+ * every other rejection propagates unconditionally.
+ */
+class CloserSpareAmbiguityError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "CloserSpareAmbiguityError";
+	}
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Replacement-boundary repair
@@ -661,12 +677,91 @@ function findDroppedSuffixClosers(
 	}
 	return { startLine: suffixStartLine + keepStart, count: keepEnd - keepStart, balance: keptBalance };
 }
+interface DroppedPrefixClosers {
+	readonly count: number;
+	readonly balance: DelimiterBalance;
+}
 
+/**
+ * Leading run of the range's deleted structural-closer line(s) that the
+ * payload never restates — the mirror of {@link findDroppedSuffixClosers} for
+ * the "range started one line early, on the `}` that ends the construct
+ * above" mistake. Fires only when the group's own delta and the whole-patch
+ * residual are both missing exactly those closers, no deleted lines above the
+ * range account for their opener, and dangling opener(s) actually survive
+ * above the range in the projected file.
+ */
+function findDroppedPrefixClosers(
+	group: ReplacementGroup,
+	fileLines: readonly string[],
+	delta: DelimiterBalance,
+	remainingDelta: DelimiterBalance,
+	deletedPrefixBalance: DelimiterBalance,
+	deletedLines: ReadonlySet<number>,
+	insertedByLine: ReadonlyMap<number, readonly string[]>,
+): DroppedPrefixClosers | undefined {
+	let prefixLength = 0;
+	while (
+		prefixLength < group.deleteIndices.length &&
+		STRUCTURAL_CLOSER_RE.test(fileLines[group.startLine + prefixLength - 1] ?? "")
+	) {
+		prefixLength++;
+	}
+	if (prefixLength === 0 || prefixLength >= group.deleteIndices.length) return undefined;
+	// A payload that opens with a closer restates the boundary itself; that is
+	// an echo/duplicate mistake with a different reading — leave it alone.
+	if (group.payload.length === 0 || isStructuralCloserLine(group.payload[0])) return undefined;
+	const prefixLines = fileLines.slice(group.startLine - 1, group.startLine - 1 + prefixLength);
+	const balance = computeDelimiterBalance(prefixLines);
+	if (balanceIsZero(balance)) return undefined;
+	const neededOpeners = balanceNegate(balance);
+	if (!balanceCovers(delta, neededOpeners)) return undefined;
+	if (balanceCovers(deletedPrefixBalance, neededOpeners)) return undefined;
+	if (!balanceCovers(remainingDelta, neededOpeners)) return undefined;
+	// The spared closers need dangling opener(s) above the range in the
+	// projected file; the payload cannot supply them — it lands below the
+	// closers either way.
+	const above: string[] = [];
+	for (let line = 1; line < group.startLine; line++) {
+		const inserted = insertedByLine.get(line);
+		if (inserted) above.push(...inserted);
+		if (!deletedLines.has(line)) above.push(fileLines[line - 1] ?? "");
+	}
+	if (!balanceCovers(computeDelimiterBalance(above), neededOpeners)) return undefined;
+	return { count: prefixLength, balance };
+}
+
+/**
+ * Total opening delimiters the range deletes without the payload reopening
+ * them while their matching closer(s) survive below — the "payload is a
+ * complete construct but the range ends mid-block" mistake, which orphans the
+ * surviving closers. A balance-only signal, so it is advisory input rather
+ * than proof: {@link applyEdits} surfaces it only once the tree-sitter probe
+ * confirms the authored edit broke the file, which is what separates a real
+ * mid-block range from a `}` living in prose or a regex literal. Zero when the
+ * payload is itself net-closing (deliberate rebalancing of a broken file) or
+ * when another hunk removes the surplus (whole-patch residual clean).
+ */
+function countOrphanedOpeners(
+	group: ReplacementGroup,
+	delta: DelimiterBalance,
+	remainingDelta: DelimiterBalance,
+	fileLines: readonly string[],
+): number {
+	const deletedBalance = computeDelimiterBalance(fileLines.slice(group.startLine - 1, group.endLine));
+	const payloadBalance = computeDelimiterBalance(group.payload);
+	let orphaned = 0;
+	for (const key of ["paren", "bracket", "brace"] as const) {
+		if (payloadBalance[key] < 0) return 0;
+		if (delta[key] >= 0 || deletedBalance[key] <= 0 || remainingDelta[key] >= 0) continue;
+		orphaned += Math.min(-delta[key], deletedBalance[key], -remainingDelta[key]);
+	}
+	return orphaned;
+}
 interface BoundaryEcho {
 	leading: number;
 	trailing: number;
 }
-
 function hasNonWhitespace(text: string): boolean {
 	for (let i = 0; i < text.length; i++) {
 		const code = text.charCodeAt(i);
@@ -870,24 +965,40 @@ function slotPatchDelta(slot: RepairSlot, fileLines: readonly string[]): Delimit
 /**
  * Normalize replacement groups so common off-by-one boundaries do not duplicate
  * unchanged surrounding lines or wrongly drop/keep structural closers. Local
- * repairs run in pass 1; the missing-closer repair is deferred to pass 2 and
- * weighed against the whole-patch delimiter residual, so a closer the range
- * deleted is only kept when the patch as a whole is missing it — never when
- * another hunk already removed the matching opener. Returns the repaired edits
- * plus one warning per repaired group.
+ * repairs run in pass 1; the missing-closer repairs (a closer the range
+ * deleted at its trailing or leading edge) are deferred to pass 2 and weighed
+ * against the whole-patch delimiter residual, so a closer is only kept when
+ * the patch as a whole is missing it — never when another hunk already
+ * removed the matching opener.
+ *
+ * Textual repairs (boundary echoes, payload lines duplicated from just outside
+ * the range) are evidence-complete on their own and always applied. The
+ * closer-spare repairs are not: they claim a lone `}` is syntax. They run only
+ * when `applySpares` is set, which {@link applyEdits} does only after the
+ * tree-sitter probe shows the authored edits broke a file that previously
+ * parsed. With `applySpares` false the same detections are reported through
+ * `suspicious` / `advisories` and nothing is rewritten.
  *
- * Repairs fire only when exactly one reading explains the mistake. When the
- * evidence is ambiguous — a one-sided echo whose payload is too short for the
- * widened range, or a spared closer the payload neither opens nor indents
- * into — the function throws instead of guessing, so the author re-issues the
- * edit rather than shipping silently corrupted content.
+ * When the spares do run, they fire only if exactly one reading explains the
+ * mistake; ambiguous evidence — a one-sided echo whose payload is too short
+ * for the widened range, a spared trailing closer the payload neither opens
+ * nor indents into, or a spared leading closer whose payload claims the block
+ * interior — throws instead of guessing, so the author re-issues the edit
+ * rather than shipping silently corrupted content.
  */
 function repairReplacementBoundaries(
 	edits: readonly AppliedEdit[],
 	fileLines: readonly string[],
+	applySpares: boolean,
 ): {
 	edits: AppliedEdit[];
 	warnings: string[];
+	/** A delimiter-semantics anomaly was detected: worth a parse to confirm. */
+	suspicious: boolean;
+	/** A swallowed block closer was detected and a spare repair is available. */
+	sparesProposed: boolean;
+	/** Diagnostics to surface only if the result is kept unrepaired. */
+	advisories: string[];
 } {
 	// Pass 1: apply every repair whose correctness is local to one group
 	// (boundary echo, duplicate prefix/suffix). Defer the missing-closer repair:
@@ -1015,6 +1126,9 @@ function repairReplacementBoundaries(
 
 	const out: AppliedEdit[] = [];
 	const warnings: string[] = [];
+	const advisories: string[] = [];
+	let suspicious = false;
+	let sparesProposed = false;
 	for (const slot of slots) {
 		if (slot.kind !== "candidate") {
 			if (slot.warning !== undefined) warnings.push(slot.warning);
@@ -1033,6 +1147,15 @@ function repairReplacementBoundaries(
 			insertedLineMaps,
 		);
 		if (droppedClosers) {
+			suspicious = true;
+			sparesProposed = true;
+			if (!applySpares) {
+				// A lone `}` is only syntax if the parser says so. Keep the
+				// authored edit; `sparesProposed` tells the caller a repair is
+				// available should the probe decline to vouch for it.
+				out.push(...slot.inserts, ...slot.deletes);
+				continue;
+			}
 			// Sparing a closer re-inserts it *after* the payload, which claims
 			// the payload lives inside the block the closer terminates. That
 			// claim needs evidence: the payload carries the closer's unmatched
@@ -1047,7 +1170,7 @@ function repairReplacementBoundaries(
 				balanceNegate(droppedClosers.balance),
 			);
 			if (!payloadOpens && !(payloadIndent !== undefined && isIndentDeeper(payloadIndent, keptIndent))) {
-				throw new Error(
+				throw new CloserSpareAmbiguityError(
 					ambiguousCloserSpareMessage(
 						slot.group.startLine,
 						slot.group.endLine,
@@ -1077,9 +1200,64 @@ function repairReplacementBoundaries(
 			remainingDelta = balanceSum(remainingDelta, droppedClosers.balance);
 			continue;
 		}
+		const droppedPrefix = findDroppedPrefixClosers(
+			slot.group,
+			fileLines,
+			slot.delta,
+			remainingDelta,
+			deletedPrefixBalance,
+			deletedLines,
+			insertedByLine,
+		);
+		if (droppedPrefix) {
+			suspicious = true;
+			sparesProposed = true;
+			if (!applySpares) {
+				out.push(...slot.inserts, ...slot.deletes);
+				continue;
+			}
+			// Sparing a leading closer re-inserts it *before* the payload,
+			// which claims the payload lives outside (after) the block the
+			// closer terminates. The payload's indentation makes that call:
+			// at-or-above the closer's depth is sibling position; a deeper or
+			// incomparable claim would put the payload inside the block the
+			// range just closed — reject rather than guess.
+			const closerIndent = leadingIndent(fileLines[slot.group.startLine - 1] ?? "");
+			const payloadIndent = bodyTargetIndent(slot.group.payload);
+			if (payloadIndent !== undefined) {
+				if (!closerIndent.startsWith(payloadIndent)) {
+					throw new CloserSpareAmbiguityError(
+						ambiguousLeadingCloserSpareMessage(slot.group.startLine, slot.group.endLine, droppedPrefix.count),
+					);
+				}
+				const spareEnd = slot.group.startLine + droppedPrefix.count;
+				warnings.push(
+					describeBoundaryRepair(
+						slot.group,
+						`kept ${droppedPrefix.count} leading structural closing line(s) the range deleted without restating; the payload lands after them`,
+					),
+				);
+				out.push(
+					...slot.inserts.map(edit =>
+						edit.kind === "insert"
+							? { ...edit, cursor: { kind: "before_anchor" as const, anchor: { line: spareEnd } } }
+							: edit,
+					),
+					...slot.deletes.filter(edit => edit.kind !== "delete" || edit.anchor.line >= spareEnd),
+				);
+				for (let line = slot.group.startLine; line < spareEnd; line++) deletedLines.delete(line);
+				remainingDelta = balanceSum(remainingDelta, droppedPrefix.balance);
+				continue;
+			}
+		}
+		const orphanedOpeners = countOrphanedOpeners(slot.group, slot.delta, remainingDelta, fileLines);
+		if (orphanedOpeners > 0) {
+			suspicious = true;
+			advisories.push(midBlockRangeWarning(slot.group.startLine, slot.group.endLine, orphanedOpeners));
+		}
 		out.push(...slot.inserts, ...slot.deletes);
 	}
-	return { edits: out, warnings };
+	return { edits: out, warnings, suspicious, sparesProposed, advisories };
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1303,35 +1481,31 @@ export interface ApplyEditsOptions {
 	clipboard?: Clipboard;
 	/** Anonymous `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). An empty named-register paste never throws — it warns and pastes nothing. */
 	onEmptyPaste?: "throw" | "drop";
+	/**
+	 * Target file path, used only to infer a language for the tree-sitter
+	 * syntax probe (see {@link parsesCleanly}). Supplying it lets the applier
+	 * confirm that the edit as authored still parses, in which case no
+	 * delimiter-shape repair or advisory may touch it. Omitted, the probe casts
+	 * no veto and the delimiter heuristics decide alone.
+	 */
+	path?: string;
+}
+
+interface Materialized {
+	text: string;
+	firstChangedLine: number | undefined;
+	warnings: string[];
 }
 
 /**
- * Apply a parsed list of edits to a text body. Pure function — no I/O.
- *
- * Returns the post-edit text and the first changed line number (1-indexed).
- * Throws if an anchor is out of bounds.
+ * Splice one candidate edit list into `originalLines` and return the resulting
+ * text. Pure and repeatable: the caller materializes the authored edits, probes
+ * that result, and only materializes a repaired candidate if the probe casts no
+ * veto.
  */
-export function applyEdits(text: string, edits: readonly Edit[], options: ApplyEditsOptions = {}): ApplyResult {
-	if (edits.length === 0) return { text, firstChangedLine: undefined };
-
-	const fileLines = text.split("\n");
-
-	// Clipboard pre-pass: capture `cut` ranges from the original lines and
-	// expand `paste` edits into plain inserts in authored order.
-	const clipboardWarnings: string[] = [];
-	const concrete = resolveClipboardEdits(edits, fileLines, options.clipboard ?? {}, {
-		...(options.onEmptyPaste === undefined ? {} : { onEmptyPaste: options.onEmptyPaste }),
-		onWarning: message => clipboardWarnings.push(message),
-	});
-
-	// Block edits are deferred until `resolveBlockEdits` expands them into
-	// concrete inserts + deletes. Reaching the applier with one still present
-	// is an internal wiring bug, not authored-input error.
-	for (const edit of concrete) {
-		if (edit.kind === "block") throw new Error(UNRESOLVED_BLOCK_INTERNAL);
-	}
-	const appliedEdits = concrete as readonly AppliedEdit[];
-
+function materializeEdits(originalLines: readonly string[], edits: readonly AppliedEdit[]): Materialized {
+	const { edits: landed, warnings } = repairAfterInsertLandings(edits, originalLines);
+	const fileLines = [...originalLines];
 	const lineOrigins: LineOrigin[] = fileLines.map(() => "original");
 
 	let firstChangedLine: number | undefined;
@@ -1339,16 +1513,6 @@ export function applyEdits(text: string, edits: readonly Edit[], options: ApplyE
 		if (firstChangedLine === undefined || line < firstChangedLine) firstChangedLine = line;
 	};
 
-	const targetEdits = dropTrailingPhantomDeletes(
-		appliedEdits.map((edit, index) => cloneAppliedEdit(edit, index)),
-		fileLines,
-	);
-	validateLineBounds(targetEdits, fileLines);
-	const indentationWarnings = repairReplacementIndentation(targetEdits, fileLines);
-	const { edits: repaired, warnings: boundaryWarnings } = repairReplacementBoundaries(targetEdits, fileLines);
-	const { edits: landed, warnings: landingWarnings } = repairAfterInsertLandings(repaired, fileLines);
-	const warnings = [...clipboardWarnings, ...indentationWarnings, ...boundaryWarnings, ...landingWarnings];
-
 	// Partition edits into bof, eof, and anchor-targeted buckets.
 	const bofLines: string[] = [];
 	const eofLines: string[] = [];
@@ -1417,9 +1581,94 @@ export function applyEdits(text: string, edits: readonly Edit[], options: ApplyE
 	const eofChangedLine = insertAtEnd(fileLines, lineOrigins, eofLines);
 	if (eofChangedLine !== undefined) trackFirstChanged(eofChangedLine);
 
-	return {
-		text: fileLines.join("\n"),
-		firstChangedLine,
-		...(warnings.length > 0 ? { warnings } : {}),
+	return { text: fileLines.join("\n"), firstChangedLine, warnings };
+}
+
+/**
+ * Apply a parsed list of edits to a text body. Pure function — no I/O.
+ *
+ * Returns the post-edit text and the first changed line number (1-indexed).
+ * Throws if an anchor is out of bounds.
+ *
+ * Repairs that hinge on delimiter *semantics* (a range that swallowed the `}`
+ * closing the construct above or below it) are subject to a parser veto when
+ * `options.path` is supplied: the authored edits are materialized first, and if
+ * that result parses it is returned untouched. A `}` in prose, a string, or a
+ * regex literal is therefore never mistaken for a block closer. Only when the
+ * authored result does not parse — or the language is unknown to the parser, so
+ * balance arithmetic is the sole evidence — do the closer-spare repairs run.
+ */
+export function applyEdits(text: string, edits: readonly Edit[], options: ApplyEditsOptions = {}): ApplyResult {
+	if (edits.length === 0) return { text, firstChangedLine: undefined };
+
+	const fileLines = text.split("\n");
+
+	// Clipboard pre-pass: capture `cut` ranges from the original lines and
+	// expand `paste` edits into plain inserts in authored order.
+	const clipboardWarnings: string[] = [];
+	const concrete = resolveClipboardEdits(edits, fileLines, options.clipboard ?? {}, {
+		...(options.onEmptyPaste === undefined ? {} : { onEmptyPaste: options.onEmptyPaste }),
+		onWarning: message => clipboardWarnings.push(message),
+	});
+
+	// Block edits are deferred until `resolveBlockEdits` expands them into
+	// concrete inserts + deletes. Reaching the applier with one still present
+	// is an internal wiring bug, not authored-input error.
+	for (const edit of concrete) {
+		if (edit.kind === "block") throw new Error(UNRESOLVED_BLOCK_INTERNAL);
+	}
+	const appliedEdits = concrete as readonly AppliedEdit[];
+
+	const targetEdits = dropTrailingPhantomDeletes(
+		appliedEdits.map((edit, index) => cloneAppliedEdit(edit, index)),
+		fileLines,
+	);
+	validateLineBounds(targetEdits, fileLines);
+	const indentationWarnings = repairReplacementIndentation(targetEdits, fileLines);
+	const leading = [...clipboardWarnings, ...indentationWarnings];
+
+	// Pass 1: the authored edits, with every delimiter-semantics repair held
+	// back. Textual repairs (boundary echoes, duplicated payload lines) are
+	// evidence-complete on their own and already applied here.
+	const authored = repairReplacementBoundaries(targetEdits, fileLines, false);
+	const finish = (result: Materialized, warnings: string[]): ApplyResult => {
+		const merged = [...warnings, ...result.warnings];
+		return {
+			text: result.text,
+			firstChangedLine: result.firstChangedLine,
+			...(merged.length > 0 ? { warnings: merged } : {}),
+		};
 	};
+	const authoredWarnings = [...leading, ...authored.warnings];
+	if (!authored.suspicious) return finish(materializeEdits(fileLines, authored.edits), authoredWarnings);
+	const authoredResult = materializeEdits(fileLines, authored.edits);
+	// The authored edit keeps the file parsing, so no delimiter heuristic may
+	// second-guess its boundaries. This is what keeps a `}` in prose, in a
+	// string, or in a regex literal from ever being mistaken for a block closer.
+	if (parsesCleanly(options.path, authoredResult.text)) return finish(authoredResult, authoredWarnings);
+
+	// The authored result does not parse — or the parser does not know this
+	// language, in which case nothing below can be proven and nothing is
+	// rewritten. A repair lands only when it is *shown* to restore a parsing
+	// file, never on delimiter arithmetic alone.
+	const baselineParses = parsesCleanly(options.path, text);
+	if (authored.sparesProposed) {
+		try {
+			const spared = repairReplacementBoundaries(targetEdits, fileLines, true);
+			const sparedResult = materializeEdits(fileLines, spared.edits);
+			if (parsesCleanly(options.path, sparedResult.text)) {
+				return finish(sparedResult, [...leading, ...spared.warnings, ...spared.advisories]);
+			}
+		} catch (error) {
+			// Only the closer-spare verdict is the parser's business, and only on
+			// a file it can vouch for. Every other rejection — notably the
+			// evidence-complete one-sided boundary echo, which is proven by exact
+			// line equality and would otherwise delete range lines the body never
+			// restates — propagates regardless of what the parser knows.
+			if (baselineParses || !(error instanceof CloserSpareAmbiguityError)) throw error;
+		}
+	}
+	// Nothing proven: leave the authored edit exactly as written. Report the
+	// damage only when the baseline parsed, so this edit demonstrably caused it.
+	return finish(authoredResult, baselineParses ? [...authoredWarnings, ...authored.advisories] : authoredWarnings);
 }

package/src/clipboard.ts

@@ -8,7 +8,12 @@
  * (`lines`) is batch-local and resets between calls.
  */
 import { HL_CUT_KEYWORD, HL_PUT_KEYWORD, HL_RANGE_SEP } from "./format";
-import { ambiguousAnonymousPasteMessage, EMPTY_PASTE, emptyRegisterPasteWarning } from "./messages";
+import {
+	ambiguousAnonymousPasteMessage,
+	EMPTY_PASTE,
+	emptyRegisterPasteWarning,
+	emptyRegisterSpanPasteMessage,
+} from "./messages";
 import { cloneCursor } from "./tokenizer";
 import type { Clipboard, Edit } from "./types";
 
@@ -40,11 +45,14 @@ export interface ResolveClipboardEditsOptions {
 }
 
 /**
- * Read lines from a register. A missing named register warns and reads as
- * empty; anonymous misuse throws unless `onEmptyPaste === "drop"`.
+ * Read lines from a register. A missing named register reads as empty for a gap
+ * paste (a harmless no-op, warned) but throws for a `span` target, where pasting
+ * empty would delete the range; anonymous misuse throws unless
+ * `onEmptyPaste === "drop"`.
  */
 function readRegister(
 	register: string | undefined,
+	target: "gap" | "span",
 	clipboard: Clipboard,
 	lineNum: number,
 	onEmptyPaste: "throw" | "drop",
@@ -55,6 +63,9 @@ function readRegister(
 		if (lines !== undefined) return lines;
 		if (onEmptyPaste === "drop") return null;
 		const known = clipboard.named ? [...clipboard.named.keys()] : [];
+		if (target === "span") {
+			throw new Error(`line ${lineNum}: ${emptyRegisterSpanPasteMessage(register, known)}`);
+		}
 		onWarning?.(`line ${lineNum}: ${emptyRegisterPasteWarning(register, known)}`);
 		return [];
 	}
@@ -117,7 +128,14 @@ export function resolveClipboardEdits(
 			continue;
 		}
 		if (edit.kind === "paste") {
-			const lines = readRegister(edit.register, clipboard, edit.lineNum, onEmptyPaste, options.onWarning);
+			const lines = readRegister(
+				edit.register,
+				edit.at.kind,
+				clipboard,
+				edit.lineNum,
+				onEmptyPaste,
+				options.onWarning,
+			);
 			if (lines === null) continue;
 
 			if (edit.at.kind === "gap") {
@@ -209,7 +227,7 @@ export function validateClipboardSequence(edits: readonly Edit[], clipboard: Cli
 				fork.pendingAnonCuts.push(describeCutEdit(edit));
 			}
 		} else if (edit.kind === "paste") {
-			readRegister(edit.register, fork, edit.lineNum, "throw");
+			readRegister(edit.register, edit.at.kind, fork, edit.lineNum, "throw");
 		}
 	}
 }

package/src/index.ts

@@ -14,5 +14,6 @@ export * from "./prefixes";
 export * from "./recovery";
 export * from "./snapshots";
 export * from "./stream";
+export * from "./syntax";
 export * from "./tokenizer";
 export * from "./types";

package/src/input.ts

@@ -361,7 +361,7 @@ export class PatchSection {
 			onUnresolved: "throw",
 			onWarning: warning => resolveWarnings.push(warning),
 		});
-		const result = applyEdits(text, resolved, { clipboard: clipboard ?? {} });
+		const result = applyEdits(text, resolved, { clipboard: clipboard ?? {}, path: this.path });
 		// Preserve parse warnings so consumers don't need to call `parse()`
 		// separately.
 		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
@@ -388,7 +388,11 @@ export class PatchSection {
 			onUnresolved: "drop",
 			onWarning: warning => resolveWarnings.push(warning),
 		});
-		const result = applyEdits(text, resolved, { clipboard: clipboard ?? {}, onEmptyPaste: "drop" });
+		const result = applyEdits(text, resolved, {
+			clipboard: clipboard ?? {},
+			onEmptyPaste: "drop",
+			path: this.path,
+		});
 		const merged = [...warnings, ...resolveWarnings, ...(result.warnings ?? [])];
 		return merged.length > 0
 			? { ...result, warnings: merged }

package/src/messages.ts

@@ -1,6 +1,13 @@
 /** Centralized error/warning text for the hashline parser, applier, and patcher. */
 
-import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX, HL_RANGE_SEP } from "./format";
+import {
+	formatNumberedLine,
+	HL_FILE_HASH_SEP,
+	HL_FILE_PREFIX,
+	HL_FILE_SUFFIX,
+	HL_PAYLOAD_REPLACE,
+	HL_RANGE_SEP,
+} from "./format";
 import type { BlockSpan } from "./types";
 
 /** Lines of context shown either side of a hash mismatch. */
@@ -118,6 +125,34 @@ export const BARE_BODY_AUTO_PIPED_WARNING =
 
 /** Top-level read-output rows recovered as single-line replacements. */
 export const SNAPSHOT_ROWS_AUTO_PUT_WARNING = `Recovered top-level \`N:TEXT\` snapshot row(s) as single-line \`PUT N${HL_RANGE_SEP}N:\` replacements. Use explicit \`PUT\` headers for reliable edits.`;
+/**
+ * Two or more top-level `N:TEXT` read-output rows named the same source line.
+ * Each recovered row lowers to a single-line `PUT N.=N:`, so the coalescer would
+ * keep only the last and silently drop the others — reject and teach the format
+ * instead.
+ */
+export function repeatedSnapshotRowMessage(line: number): string {
+	return (
+		`two or more pasted \`${line}:TEXT\` read-output rows name line ${line}. ` +
+		`Such rows are recovered as single-line \`PUT ${line}${HL_RANGE_SEP}${line}:\` replacements, so repeating a ` +
+		`number would keep only the last row and drop the rest. Write the hunk explicitly: one ` +
+		`\`PUT ${line}${HL_RANGE_SEP}M:\` header covering exactly the lines that change, followed by \`+TEXT\` body ` +
+		`rows holding their complete final content.`
+	);
+}
+/**
+ * A `+` body row whose text is itself a valid hunk header — the op was written
+ * with the payload prefix, so it is inserted into the file as literal text
+ * instead of executing. Warned rather than rejected: a literal `CUT …` line is
+ * legitimate content in documentation and test fixtures.
+ */
+export function literalOpRowWarning(line: number, text: string): string {
+	return (
+		`line ${line}: body row \`${HL_PAYLOAD_REPLACE}${text}\` is itself a valid hunk header, so it was inserted ` +
+		`into the file as literal text rather than executed. Ops are never \`${HL_PAYLOAD_REPLACE}\`-prefixed — drop ` +
+		`the \`${HL_PAYLOAD_REPLACE}\` to run it, and re-issue if this line landed in the file by mistake.`
+	);
+}
 /** Bare range header recovered as an implicit replacement hunk. */
 export const BARE_RANGE_AUTO_PUT_WARNING = `Recovered a bare \`N${HL_RANGE_SEP}M:\` header as \`PUT N${HL_RANGE_SEP}M:\`. Prefix replacement ranges with \`PUT\`.`;
 
@@ -294,6 +329,42 @@ export function ambiguousCloserSpareMessage(
 		`or use \`PUT <${closerLine}:\` / \`PUT >${closerLine}:\` instead.`
 	);
 }
+/**
+ * A replacement range starts by deleting structural closer(s) the payload
+ * never restates — the "range started one line early, on the `}` that ends
+ * the construct above" mistake — but the payload's indentation claims a depth
+ * inside the block those closers terminate, so whether the new content
+ * belongs before or after the spared closer is ambiguous. Rejected instead of
+ * repaired; the at-or-above-depth reading is auto-repaired by sparing the
+ * closer ahead of the payload.
+ */
+export function ambiguousLeadingCloserSpareMessage(startLine: number, endLine: number, count: number): string {
+	const closers = count === 1 ? `line ${startLine}` : `lines ${startLine}-${startLine + count - 1}`;
+	return (
+		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` rejected: the range starts by deleting the closing-delimiter ` +
+		`${closers} but the body never restates it, and the body's indentation claims a depth inside the block that ` +
+		`closer terminates — whether the new content belongs before or after the closer is ambiguous. ` +
+		`Start the range on the first line that actually changes, or restate the closer in the body at the intended position.`
+	);
+}
+
+/**
+ * A replacement range deletes more opening delimiter(s) than the payload
+ * reopens while the matching closer(s) survive below the range — the
+ * "payload is a complete construct but the range ends mid-block" mistake.
+ * Surfaced as a warning, never a rejection: the applier is language-agnostic
+ * and opener/closer text shape cannot prove a syntactic block (the braces may
+ * be literal prose), so the edit applies as authored and the author decides.
+ */
+export function midBlockRangeWarning(startLine: number, endLine: number, orphaned: number): string {
+	return (
+		`\`PUT ${startLine}${HL_RANGE_SEP}${endLine}:\` deleted ${orphaned} opening delimiter(s) the body never ` +
+		`reopens. If this file is brace-structured code, the matching closing line(s) below the range are now ` +
+		`orphaned — the range likely ended mid-block. If the body was the construct's complete new content, ` +
+		`re-issue with a block op on the construct's opening line (\`PUT N*:\`) so the closing line resolves ` +
+		`automatically; if the delimiters are literal text, ignore this warning.`
+	);
+}
 
 /**
  * Internal invariant: `applyEdits` received an unresolved block edit;
@@ -331,9 +402,22 @@ export const COLONLESS_SPAN_PUT = `Colonless \`PUT\` is clipboard-backed, and sp
 /** Anonymous paste ran with an empty anonymous register. */
 export const EMPTY_PASTE = `Nothing to paste: no unlabeled \`CUT\` precedes this \`PUT\` in this call, and the anonymous register never carries across calls. Put \`CUT N${HL_RANGE_SEP}M\` / \`CUT N*\` above it, or use named registers (\`CUT … @name\` → \`PUT … @name\`) for cross-call moves.`;
 
-/** Named paste read a register that holds nothing; the paste applied as empty (span targets are still removed). */
+/** Named paste read a register that holds nothing; a gap paste applies as empty. */
 export function emptyRegisterPasteWarning(name: string, known: readonly string[]): string {
-	const base = `\`@${name}\` was empty — no \`CUT … @${name}\` precedes this op in this call and no persisted register has that name — so nothing was pasted (a span target is still removed).`;
+	const base = `\`@${name}\` was empty — no \`CUT … @${name}\` precedes this op in this call and no persisted register has that name — so nothing was pasted.`;
+	return known.length === 0 ? base : `${base} Available registers: ${known.map(k => `\`@${k}\``).join(", ")}.`;
+}
+
+/**
+ * Named paste over a *span* read a register that holds nothing. Pasting empty
+ * would delete the span, which the author never asked for — almost always a
+ * mistyped or never-captured register name — so the edit is rejected instead.
+ */
+export function emptyRegisterSpanPasteMessage(name: string, known: readonly string[]): string {
+	const base =
+		`\`@${name}\` is empty — no \`CUT … @${name}\` precedes this op in this call and no persisted register ` +
+		`has that name — so pasting it over a range would delete those lines and write nothing back. ` +
+		`Capture the register first (\`CUT … @${name}\`), or use \`CUT\` if deleting the range is what you meant.`;
 	return known.length === 0 ? base : `${base} Available registers: ${known.map(k => `\`@${k}\``).join(", ")}.`;
 }
 

package/src/parser.ts

@@ -17,6 +17,7 @@ import {
 	EMPTY_INSERT,
 	EMPTY_PUT_AUTO_CUT_WARNING,
 	invalidAbsoluteRangeMessage,
+	literalOpRowWarning,
 	MINUS_BULLET_AUTO_PIPED_WARNING,
 	MINUS_ROW_REJECTED,
 	MOVE_TAKES_NO_BODY,
@@ -24,10 +25,11 @@ import {
 	REGISTER_PUT_TAKES_NO_BODY,
 	REM_TAKES_NO_BODY,
 	REPLACE_PAIR_COALESCED_WARNING,
+	repeatedSnapshotRowMessage,
 	SNAPSHOT_ROWS_AUTO_PUT_WARNING,
 } from "./messages";
 import { isReadMetadataLine, stripOneLeadingHashlinePrefix } from "./prefixes";
-import { type BlockTarget, cloneCursor, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
+import { type BlockTarget, cloneCursor, isHunkHeaderText, type ParsedRange, type Token, Tokenizer } from "./tokenizer";
 import type { Anchor, BlockSpan, Cursor, Edit, FileOp, PasteTarget } from "./types";
 
 /** Bounds parser amplification before the target file's line count is available. */
@@ -210,6 +212,8 @@ export class Executor {
 	#fileOp: FileOp | undefined;
 	#terminated = false;
 	#skippableComments: PendingComment[] = [];
+	/** Source lines already recovered from top-level `N:TEXT` rows in this section. */
+	#recoveredSnapshotLines = new Set<number>();
 
 	#discardPendingSkippableComments(): void {
 		this.#skippableComments = [];
@@ -458,6 +462,10 @@ export class Executor {
 		const noBodyOnLiteral = bodylessTargetMessage(pending.target, pending.hadColon);
 		if (noBodyOnLiteral !== null) throw new Error(`line ${lineNum}: ${noBodyOnLiteral}`);
 		this.#commitDeferredBlanks(pending);
+		// An op written with the payload prefix is inserted as literal text. That
+		// is the correct reading of `+TEXT`, but it silently plants a `CUT …` line
+		// in the file, so name it at the moment it happens.
+		if (isHunkHeaderText(text)) this.#warnings.push(literalOpRowWarning(lineNum, text));
 		pending.payloads.push({ kind: "literal", text, lineNum });
 	}
 
@@ -513,6 +521,14 @@ export class Executor {
 		}
 		const snapshotRow = parseTopLevelSnapshotRow(text);
 		if (snapshotRow !== null) {
+			// Each recovered row becomes a single-line replacement, so a repeated
+			// line number is never a set of replacements — it is a body written as
+			// consecutive lines under one number. Collapsing it would silently keep
+			// only the last row and drop the rest.
+			if (this.#recoveredSnapshotLines.has(snapshotRow.line)) {
+				throw new Error(`line ${lineNum}: ${repeatedSnapshotRowMessage(snapshotRow.line)}`);
+			}
+			this.#recoveredSnapshotLines.add(snapshotRow.line);
 			const range = { start: { line: snapshotRow.line }, end: { line: snapshotRow.line } };
 			validateRange(range, lineNum, "replace");
 			this.#pushInsert(

package/src/patcher.ts

@@ -732,7 +732,7 @@ export class Patcher {
 			if (expected !== undefined && this.#enforceSeenLines) {
 				this.#assertSeenLines(section, expected, matchedSnapshot);
 			}
-			const result = applyEdits(normalized, resolved, { clipboard });
+			const result = applyEdits(normalized, resolved, { clipboard, path: canonicalPath });
 			return withResolveWarnings(blockResolutions.length > 0 ? { ...result, blockResolutions } : result);
 		}
 		// Head/tail-only inserts are position-stable: "start"/"end" cannot move
@@ -740,7 +740,7 @@ export class Patcher {
 		// content and warn instead of hard-failing — unlike an anchored
 		// mismatch, which cannot be safely relocated and must reject.
 		if (!hasAnchorScopedEdit(resolved)) {
-			const result = applyEdits(normalized, resolved, { clipboard });
+			const result = applyEdits(normalized, resolved, { clipboard, path: canonicalPath });
 			return withResolveWarnings({ ...result, warnings: [HEADTAIL_DRIFT_WARNING, ...(result.warnings ?? [])] });
 		}
 		// File drifted: map every anchor from the tagged snapshot to unchanged

package/src/recovery.ts

@@ -308,12 +308,16 @@ function replayRemappedAnchorsOnCurrent(
 	edits: readonly Edit[],
 	recoveryWarning: string,
 	clipboard: Clipboard | undefined,
+	path: string,
 ): RecoveryResult | null {
 	const remapped = remapEditsToCurrent(previousText, currentText, edits);
 	if (remapped === null) return null;
 	let applied: ApplyResult;
 	try {
-		applied = applyEdits(currentText, remapped.edits, clipboard === undefined ? {} : { clipboard });
+		applied = applyEdits(currentText, remapped.edits, {
+			...(clipboard === undefined ? {} : { clipboard }),
+			path,
+		});
 	} catch {
 		return null;
 	}
@@ -348,6 +352,6 @@ export class Recovery {
 		if (!snapshot) return null;
 		const recoveryWarning =
 			this.store.head(path) === snapshot ? RECOVERY_EXTERNAL_WARNING : RECOVERY_SESSION_CHAIN_WARNING;
-		return replayRemappedAnchorsOnCurrent(snapshot.text, currentText, edits, recoveryWarning, clipboard);
+		return replayRemappedAnchorsOnCurrent(snapshot.text, currentText, edits, recoveryWarning, clipboard, path);
 	}
 }

package/src/syntax.ts

@@ -0,0 +1,49 @@
+/**
+ * Syntax probe for candidate edit results, via the native tree-sitter parser.
+ *
+ * Delimiter-balance arithmetic cannot tell a block closer from a `}` inside a
+ * regex literal, a string, or Markdown prose. A parser can, so it holds veto
+ * power over every repair whose justification is "this line closes a syntactic
+ * block": when the edit the author actually wrote still parses, no such repair
+ * may rewrite it. The probe never *forces* a repair — an unrecognized language
+ * or an already-broken file simply yields no veto, leaving the delimiter
+ * heuristics as the only available evidence.
+ */
+
+import { enclosingBlockBoundaries } from "@oh-my-pi/pi-natives";
+
+/** Parse-result cache keyed by content hash + path; FIFO-bounded. */
+const parseCache = new Map<string, boolean>();
+const PARSE_CACHE_MAX = 256;
+
+/**
+ * `true` when `text` parses without a syntax error under the language inferred
+ * from `path`. `false` covers "does not parse" and "cannot tell" alike — no
+ * path, an unrecognized language, or a native failure — because both mean the
+ * probe has nothing to prove with. Callers must therefore never treat `false`
+ * as evidence *about the edit*: it only withholds permission to rewrite.
+ *
+ * Uses `enclosingBlockBoundaries` over a whole-file window: no node can cross
+ * that window, so the boundary walk is trivial and the tree-sitter parse is the
+ * only real cost. It returns `null` for an unrecognized language and for a
+ * source that fails to parse, which this predicate deliberately conflates.
+ */
+export function parsesCleanly(path: string | undefined, text: string): boolean {
+	if (path === undefined) return false;
+	const key = `${Bun.hash(text).toString(36)}:${text.length}:${path}`;
+	const cached = parseCache.get(key);
+	if (cached !== undefined) return cached;
+	const lineCount = text.length === 0 ? 1 : text.split("\n").length;
+	let ok: boolean;
+	try {
+		ok = enclosingBlockBoundaries({ code: text, path, ranges: [{ startLine: 1, endLine: lineCount }] }) !== null;
+	} catch {
+		ok = false;
+	}
+	if (parseCache.size >= PARSE_CACHE_MAX) {
+		const oldest = parseCache.keys().next().value;
+		if (oldest !== undefined) parseCache.delete(oldest);
+	}
+	parseCache.set(key, ok);
+	return ok;
+}

package/src/tokenizer.ts

@@ -428,6 +428,21 @@ function tryParseHunkHeader(line: string): ParsedHunkHeader | null {
 	if (scan.nextIndex !== end) return null;
 	return { target: scan.target, hadColon: scan.hadColon };
 }
+/**
+ * Whether `text` would parse as a hunk header on its own (`PUT …`, `CUT …`,
+ * `REM`, `MV …`). Used to catch an op row mistakenly written as a `+` body row,
+ * which the applier would otherwise insert into the file as literal text.
+ */
+export function isHunkHeaderText(text: string): boolean {
+	const end = trimEndIndex(text);
+	const lead = skipWhitespace(text, 0, end);
+	const isHunkLead =
+		text.startsWith(HL_PUT_KEYWORD, lead) ||
+		text.startsWith(HL_CUT_KEYWORD, lead) ||
+		text.startsWith(HL_REM_KEYWORD, lead) ||
+		text.startsWith(HL_MOVE_KEYWORD, lead);
+	return isHunkLead && tryParseHunkHeader(text) !== null;
+}
 
 function tryParseHeader(line: string): { path: string; fileHash?: string } | null {
 	if (!line.startsWith(HL_FILE_PREFIX)) return null;