@oh-my-pi/hashline 17.2.13 → 17.2.15

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [17.2.15] - 2026-08-12
+
+### Added
+
+- Added a post-apply parse advisory warning that alerts users when an applied edit fails to parse (despite the pre-edit content parsing successfully), helping catch balance-neutral misplacements that previously failed silently.
+
+### Fixed
+
+- Fixed a bug where Rust lifetimes (e.g., `'static`) were incorrectly parsed as starting a string literal, which blinded the delimiter-balance scanner and could lead to silent signature deletions. Single-quote lexing on `.rs` files is now language-aware and correctly distinguishes lifetimes from character literals.
+- Fixed an issue where terminal newlines in files were incorrectly exposed as editable blank rows.
+
 ## [17.2.12] - 2026-08-08
 
 ### Breaking Changes

package/dist/types/format.d.ts

@@ -77,5 +77,10 @@ export declare function describeAnchorExamples(linePrefix?: string): string;
 export declare function formatHashlineHeader(filePath: string, fileHash: string): string;
 /** Formats a single numbered line as `LINE:TEXT`. */
 export declare function formatNumberedLine(lineNumber: number, line: string): string;
+/**
+ * Split LF-delimited file text into lines hashline anchors can address.
+ * A terminal newline terminates the preceding line; it is not content.
+ */
+export declare function splitAddressableFileLines(text: string): string[];
 /** Format file text with hashline-mode line-number prefixes for display. */
 export declare function formatNumberedLines(text: string, startLine?: number): string;

package/dist/types/messages.d.ts

@@ -121,6 +121,17 @@ export declare function ambiguousLeadingCloserSpareMessage(startLine: number, en
  * be literal prose), so the edit applies as authored and the author decides.
  */
 export declare function midBlockRangeWarning(startLine: number, endLine: number, orphaned: number): string;
+/**
+ * The applied result no longer parses while the pre-edit content did: the
+ * patch introduced a syntax error. Advisory, never a rejection — the applier
+ * honors the authored edit — but the breakage is machine-confirmed (the
+ * tree-sitter probe parsed the original and rejects the result), so it is
+ * surfaced in the same response instead of waiting for a compiler pass. The
+ * classic trigger is a balance-neutral misplacement: a statement landed on
+ * the wrong line number with no delimiter anomaly for the repair heuristics
+ * to notice.
+ */
+export declare function editBrokeParseWarning(firstChangedLine: number | undefined): string;
 /**
  * Internal invariant: `applyEdits` received an unresolved block edit;
  * `resolveBlockEdits` must run first.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "17.2.13",
+	"version": "17.2.15",
 	"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.13",
-		"@oh-my-pi/pi-utils": "17.2.13"
+		"@oh-my-pi/pi-natives": "17.2.15",
+		"@oh-my-pi/pi-utils": "17.2.15"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/apply.ts

@@ -15,6 +15,7 @@ import {
 	ambiguousCloserSpareMessage,
 	ambiguousLeadingCloserSpareMessage,
 	blockInsertLandingShiftWarning,
+	editBrokeParseWarning,
 	midBlockRangeWarning,
 	REPLACEMENT_INDENT_AUTO_SHIFT_WARNING,
 	UNRESOLVED_BLOCK_INTERNAL,
@@ -257,13 +258,38 @@ interface DelimiterBalance {
 	brace: number;
 }
 
+/**
+ * Single-quote lexing mode for {@link computeDelimiterBalance}. `"literal"`:
+ * `'…'` is a same-line string (JS/Python/C-like default, the original
+ * behavior). `"rust"`: `'` opens a literal only when it lexes as a Rust char
+ * literal (`'a'`, `'\n'`, `'\u{7FFF}'`); any other `'` is a lifetime or
+ * apostrophe and stays an ordinary character — pairing arbitrary apostrophes
+ * would swallow real delimiters between two lifetimes (`<'a>(x: &'a str)`
+ * loses the `(`), and quote-state-to-EOL hides the opener on signature lines
+ * (`&'static str {` — the `extension()` incident).
+ *
+ * Module-scoped rather than threaded: the scan helpers are a dozen pure free
+ * functions all rooted in the synchronous `applyEdits` call, which sets the
+ * mode from its target path on every entry.
+ */
+let singleQuoteMode: "literal" | "rust" = "literal";
+
+/** Set {@link singleQuoteMode} from the target file's extension. */
+function setDelimiterScanLanguage(path: string | undefined): void {
+	singleQuoteMode = path?.endsWith(".rs") ? "rust" : "literal";
+}
+
+/** Rust char literal at one position: `'a'`, `'\n'`, `'\x41'`, `'\u{7FFF}'`. */
+const RUST_CHAR_LITERAL_RE = /^'(?:\\u\{[0-9a-fA-F_]{1,6}\}|\\x[0-9a-fA-F]{2}|\\.|[^\\'])'/;
+
 /**
  * Net `()` / `[]` / `{}` delta across `lines`, skipping delimiters inside line
  * comments (`//`), block comments, and string/template literals. Block-comment
  * and backtick-template state carry across lines; `"` / `'` reset at EOL since
- * they cannot span lines. Deliberately language-light: constructs it cannot
- * classify (e.g. regex literals) are counted naively, which can only suppress a
- * repair (the safe direction), never force one.
+ * they cannot span lines. Single-quote handling follows the target language
+ * (see {@link singleQuoteMode}). Deliberately language-light otherwise:
+ * constructs it cannot classify (e.g. regex literals) are counted naively,
+ * which can only suppress a repair (the safe direction), never force one.
  */
 function computeDelimiterBalance(lines: readonly string[]): DelimiterBalance {
 	const balance: DelimiterBalance = { paren: 0, bracket: 0, brace: 0 };
@@ -284,6 +310,13 @@ function computeDelimiterBalance(lines: readonly string[]): DelimiterBalance {
 				else if (ch === quote) quote = "";
 				continue;
 			}
+			if (ch === "'" && singleQuoteMode === "rust") {
+				// A real char literal is skipped whole; a lifetime (`'static`,
+				// `<'a>`) or apostrophe is an ordinary character.
+				const literal = RUST_CHAR_LITERAL_RE.exec(line.slice(i));
+				if (literal) i += literal[0].length - 1;
+				continue;
+			}
 			if (ch === '"' || ch === "'" || ch === "`") {
 				quote = ch;
 				continue;
@@ -1600,6 +1633,7 @@ function materializeEdits(originalLines: readonly string[], edits: readonly Appl
  */
 export function applyEdits(text: string, edits: readonly Edit[], options: ApplyEditsOptions = {}): ApplyResult {
 	if (edits.length === 0) return { text, firstChangedLine: undefined };
+	setDelimiterScanLanguage(options.path);
 
 	const fileLines = text.split("\n");
 
@@ -1633,6 +1667,14 @@ export function applyEdits(text: string, edits: readonly Edit[], options: ApplyE
 	const authored = repairReplacementBoundaries(targetEdits, fileLines, false);
 	const finish = (result: Materialized, warnings: string[]): ApplyResult => {
 		const merged = [...warnings, ...result.warnings];
+		// Post-apply syntax advisory: the result stopped parsing while the
+		// pre-edit text parsed, so this patch demonstrably introduced the
+		// error. Catches balance-neutral misplacements (a statement swapped
+		// onto the wrong line) that no delimiter heuristic can see. Both
+		// probes are content-cached; a pathless call short-circuits to false.
+		if (!parsesCleanly(options.path, result.text) && parsesCleanly(options.path, text)) {
+			merged.push(editBrokeParseWarning(result.firstChangedLine));
+		}
 		return {
 			text: result.text,
 			firstChangedLine: result.firstChangedLine,

package/src/format.ts

@@ -139,8 +139,20 @@ export function formatNumberedLine(lineNumber: number, line: string): string {
 	return `${lineNumber}${HL_LINE_BODY_SEP}${line}`;
 }
 
+/**
+ * Split LF-delimited file text into lines hashline anchors can address.
+ * A terminal newline terminates the preceding line; it is not content.
+ */
+export function splitAddressableFileLines(text: string): string[] {
+	const lines = text.split("\n");
+	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+
 /** Format file text with hashline-mode line-number prefixes for display. */
 export function formatNumberedLines(text: string, startLine = 1): string {
-	const lines = text.split("\n");
-	return lines.map((line, i) => formatNumberedLine(startLine + i, line)).join("\n");
+	return text
+		.split("\n")
+		.map((line, i) => formatNumberedLine(startLine + i, line))
+		.join("\n");
 }

package/src/messages.ts

@@ -366,6 +366,25 @@ export function midBlockRangeWarning(startLine: number, endLine: number, orphane
 	);
 }
 
+/**
+ * The applied result no longer parses while the pre-edit content did: the
+ * patch introduced a syntax error. Advisory, never a rejection — the applier
+ * honors the authored edit — but the breakage is machine-confirmed (the
+ * tree-sitter probe parsed the original and rejects the result), so it is
+ * surfaced in the same response instead of waiting for a compiler pass. The
+ * classic trigger is a balance-neutral misplacement: a statement landed on
+ * the wrong line number with no delimiter anomaly for the repair heuristics
+ * to notice.
+ */
+export function editBrokeParseWarning(firstChangedLine: number | undefined): string {
+	const at = firstChangedLine === undefined ? "" : ` near line ${firstChangedLine}`;
+	return (
+		`This edit introduced a syntax error${at}: the file parsed before the patch and no longer does. ` +
+		`It was applied exactly as written, so a line number or range endpoint is likely wrong — ` +
+		`re-read the touched region and re-issue a correcting edit.`
+	);
+}
+
 /**
  * Internal invariant: `applyEdits` received an unresolved block edit;
  * `resolveBlockEdits` must run first.

package/src/prompt.md

@@ -1,38 +1,38 @@
-Line-anchored patch language: name original lines/gaps to replace, insert, cut, or paste, then list new content. A header ending in `:` takes `+` body rows; colonless `PUT` (paste), `CUT`, `REM`, `MV` take none.
+Line-anchored patch language: name original lines/gaps to replace, insert, cut, or paste; then give new content. `:` headers take `+` body rows; colonless paste `PUT`, `CUT`, `REM`, `MV` take none.
 
 <headers>
-Every file section starts `[PATH#TAG]`. `TAG` = 4-hex snapshot tag from your latest `read`/`search` — REQUIRED on every section. Create new files with `write`; hashline only edits existing files.
+Section: `[PATH#TAG]`; `TAG`: 4-hex snapshot from latest `read`/`search`, REQUIRED each section. New files: `write`; hashline edits existing files only.
 </headers>
 
 <ops>
-`PUT N.=M:` — replace original lines N through M (INCLUSIVE) with body rows.
-`PUT N*:` — replace the syntactic block BEGINNING on line N; its closing line is resolved for you.
-`PUT <N:` / `PUT >N:` — insert body rows before / after line N (`PUT <1:` = file head, `PUT >$:` = file tail).
-`PUT >N*:` — insert body rows after the END of the block beginning at N (at sibling depth). Append inside a block → `PUT >M:`.
-`PUT <N` / `PUT >N` / `PUT N.=M @name` / `PUT N* @name` — paste a captured register at a gap, over a range, or over a resolved block (no `:` header, no body rows). Unlabeled gap `PUT` pastes the anonymous register; span/block paste requires `@name`.
-`CUT N.=M` / `CUT N*` — delete lines N through M / block N and capture them (anonymous, or `@name` when given).
-`REM` — delete the whole section file. `MV DEST` — move/rename to `DEST` (quote paths with spaces); edits above `MV` land on the source first, final content written at `DEST`.
-Single line: `PUT N.=N:` / `CUT N.=N`. Range = ORIGINAL lines touched (`N.=M`, inclusive); body length irrelevant.
+`PUT N.=M:`: replace original inclusive lines N–M with body.
+`PUT N*:`: replace syntactic block beginning N; closing line resolved.
+`PUT <N:` / `PUT >N:`: insert before/after N; `<1` head, `>$` tail.
+`PUT >N*:`: insert after block N's end, at sibling depth. Append inside block: `PUT >M:`.
+`PUT <N` / `PUT >N` / `PUT N.=M @name` / `PUT N* @name`: paste captured register at gap/range/resolved block; no `:` or body. Unlabeled gap paste: anonymous register; range/block paste: `@name` required.
+`CUT N.=M` / `CUT N*`: delete and capture inclusive lines N–M / block N; anonymous or given `@name`.
+`REM`: delete section file. `MV DEST`: move/rename (quote paths with spaces); prior edits apply to source, final content to `DEST`.
+Single line: `PUT N.=N:` / `CUT N.=N`. Ranges name original inclusive touched lines; body length irrelevant.
 </ops>
 
 <body-rows>
-Only under a `:` header. Every row is `+TEXT`, verbatim (leading whitespace kept); `+` alone = blank line. NEVER `-old` or bare/context rows — the range deletes; the body is only the final content. Keep a line: leave it out of every range. Literal leading `-`/`+` keeps the prefix: `- item` → `+- item`, `+ item` → `++ item`.
+Only below `:` headers. Row: verbatim `+TEXT` (leading whitespace preserved); `+`: blank. NEVER `-old`, bare, or context rows: range deletes; body is final content. Keep line: exclude it from every range. Literal initial `-`/`+`: `- item` → `+- item`; `+ item` → `++ item`.
 </body-rows>
 
 <rules>
-- Line numbers + `#TAG` come from your latest `read`/`search` (`LINE:TEXT` rows); numbers name ORIGINAL lines, never shifted by applied hunks.
-- Applied edits renumber the file and change the `#TAG` — take the next edit's numbers from the edit response or a fresh `read`.
-- Touch only displayed lines — hunks on undisplayed lines are REJECTED. Far from your read window? Re-`read`; confirm numbers map to the intended construct.
-- Elided regions are UNSEEN (`…`/`..` markers, collapsed `N-M:` summary rows) — NEVER place or span a hunk inside one; `read` the range first.
-- NEVER start or end a range mid-expression or mid-block.
-- Ranges cover ONLY changed lines — never widen over keepers. Non-adjacent changes = separate hunks.
-- Whole construct → `PUT N*:`; lines inside one → `PUT N.=M:`.
-- `PUT N*:` resolves EXACTLY the node at N: leading decorators/attributes/doc-comments are separate nodes — point N at the FIRST decorator to sweep both; standalone line-comments are never swept (use `PUT N.=M:`).
-- Block ops anchor the OPENING line of a MULTI-LINE construct — never the closer, last line, or a bare inner statement; one statement → plain op (`PUT N.=N:` / `CUT N.=N` / `PUT >N:`). Saw the closer? `PUT >M:`.
-- Markdown: a heading IS a block opener — block ops on `##`/`###` resolve the WHOLE section (through deeper nested headings, up to the next same-or-higher heading). `PUT >N*:` after a section: end the body with a blank line to keep the next heading separated.
-- Pure additions → `PUT <N:` / `PUT >N:`, never a widened `PUT N.=M:`.
-- Move code with `CUT`+`PUT`: `CUT 5.=9 @fn` captures into `@fn`; `PUT >40 @fn` pastes it. Unlabeled `CUT` + `PUT >40` works for a single call-local move. Named registers persist across edit calls.
-- NEVER format/restyle code with this tool; run the project formatter.
+- Numbers and `#TAG`: latest `read`/`search` `LINE:TEXT`; numbers are original, never shifted by hunks.
+- Each edit renumbers and changes `#TAG` → next numbers from edit response or fresh `read`.
+- Touch displayed lines only; undisplayed hunks REJECTED. Far from read window: re-`read`; confirm construct.
+- Elisions UNSEEN: `…`, `..`, collapsed `N-M:` rows. NEVER hunk in/across one; `read` first.
+- NEVER start/end range mid-expression or mid-block.
+- Ranges: changed lines only; NEVER widen over keepers. Non-adjacent changes: separate hunks.
+- Whole construct: `PUT N*:`; internal lines: `PUT N.=M:`.
+- `PUT N*:` resolves exactly node N. Leading decorators/attributes/doc-comments are separate nodes: point N at first decorator to include both. Standalone line-comments never swept: use `PUT N.=M:`.
+- Block ops: opening line of multi-line construct, NEVER closer, last line, bare inner statement. One statement: plain `PUT N.=N:` / `CUT N.=N` / `PUT >N:`. At closer: `PUT >M:`.
+- Markdown headings are block openers. Block op on `##`/`###`: whole section through deeper headings to next same/higher heading. After section `PUT >N*:`: end body with blank line to separate next heading.
+- Pure addition: `PUT <N:` / `PUT >N:`, NEVER widened `PUT N.=M:`.
+- Move: `CUT`+`PUT`; `CUT 5.=9 @fn` → `@fn`, `PUT >40 @fn` pastes. Single call-local move: unlabeled `CUT` + `PUT >40`. Named registers persist across edit calls.
+- NEVER format/restyle with this tool; run project formatter.
 </rules>
 
 <example>
@@ -54,7 +54,7 @@ PUT 1.=3:
 MV lib/greet.py
 ```
 
-Markdown bullets — the file receives `- task`:
+Markdown bullets — file receives `- task`:
 ```
 [PLAN.md#A1B2]
 PUT >2:
@@ -62,7 +62,7 @@ PUT >2:
 +  - nested task
 ```
 
-Move `greet` to a sibling file using a named register — flows across sections:
+Move `greet` to sibling file via named register; flows across sections:
 ```
 [greet.py#A1B2]
 CUT 1* @fn
@@ -70,7 +70,7 @@ CUT 1* @fn
 PUT <1 @fn
 ```
 
-`PUT 1*:` resolves lines 1–3 (`def` header through `print(msg)`); line 4 is a separate statement and stays:
+`PUT 1*:` resolves lines 1–3 (`def` through `print(msg)`); line 4 separate, remains:
 ```
 [greet.py#A1B2]
 PUT 1*:
@@ -78,7 +78,7 @@ PUT 1*:
 +    print(f"Hello, {name}")
 ```
 
-Decorator/doc-comment = SEPARATE block — point N at the decorator to take both; anchoring the `def` (line 2) would orphan `@cache`:
+Decorator/doc-comment separate block: point N at decorator to include both; anchoring `def` line 2 orphans `@cache`:
 ```
 [svc.py#C3D4]
 PUT 1*:
@@ -127,7 +127,7 @@ PUT >20 @fn:
 </anti-patterns>
 
 <critical>
-1. RE-GROUND AFTER EVERY EDIT — applied edits renumber the file and change the `#TAG`; take next numbers from the edit response or a fresh `read`. Stale tag or surprise? STOP, re-`read`.
-2. RANGES ARE TIGHT — cover only lines that change. Whole construct → `PUT N*:`.
-3. BODY = FINAL CONTENT — every body row starts with `+`; Markdown bullets use `+- item`, not `- item`.
+1. RE-GROUND AFTER EVERY EDIT: edits renumber and change `#TAG`; take next numbers from edit response or fresh `read`. Stale tag/surprise: STOP; re-`read`.
+2. RANGES TIGHT: changed lines only. Whole construct: `PUT N*:`.
+3. BODY FINAL CONTENT: every row starts `+`; Markdown bullet: `+- item`, not `- item`.
 </critical>