@oh-my-pi/hashline 17.2.14 → 17.3.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [17.3.0] - 2026-08-13
+
+### Fixed
+
+- Repaired mis-set replacement ranges using exact outside-row matches, indentation, tree-sitter structure, and a narrow pure-closer shape: opening comment fences and other syntax-essential edges are retained only when a parse-valid candidate satisfies those constraints; ambiguous placements are rejected.
+
+## [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/apply.d.ts

@@ -3,9 +3,10 @@
  * post-edit lines plus any diagnostic warnings. Pure function: no FS, no
  * mutation of the input.
  *
- * Replacement groups are first normalized by {@link repairReplacementBoundaries},
- * which absorbs common model mistakes where a payload restates unchanged range
- * boundaries or duplicates/drops structural closers.
+ * Mis-set replacement range boundaries are repaired by bounded candidate
+ * search. Exact line equality, indentation, tree-sitter structure, and a
+ * narrow pure-closer shape gate constrain candidates; tree-sitter validates
+ * the selected result.
  */
 import type { ApplyResult, Clipboard, Edit } from "./types.js";
 /** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
@@ -21,11 +22,10 @@ export interface ApplyEditsOptions {
     /** 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.
+     * Target path used to infer a language for the tree-sitter syntax probe.
+     * Required for syntax-essential boundary retention and post-apply syntax
+     * advisories. Without it, only exact-text boundary normalization and its
+     * evidence-complete rejections run.
      */
     path?: string;
 }
@@ -35,12 +35,10 @@ export interface ApplyEditsOptions {
  * 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.
+ * Mis-set replacement boundaries are repaired by {@link repairBoundaryVariants}
+ * when `options.path` lets tree-sitter judge the result. A parsing authored
+ * result is never second-guessed. For a broken result, only syntax-essential
+ * edge retention with matching indentation and exact outside-row echo removal
+ * are considered; every selected candidate must parse.
  */
 export declare function applyEdits(text: string, edits: readonly Edit[], options?: ApplyEditsOptions): ApplyResult;

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

@@ -86,46 +86,44 @@ export declare function pasteAfterBlockCloserLoweredWarning(line: number): strin
 /** Register `PUT >N*` anchor unresolvable; applied as `PUT >N`. */
 export declare function pasteAfterBlockUnresolvedLoweredWarning(line: number): string;
 /**
- * A one-sided boundary echo whose payload is too short to be the widened
- * range's full content: dropping the echo deletes range line(s) the payload
- * never restates (the "widened range" reading), while the "range shifted by
- * the echo" reading keeps them. The readings produce different files, so the
- * edit is rejected instead of repaired.
+ * A one-sided exact boundary echo cannot cover the selected range after the
+ * duplicated body rows are removed. Applying or dropping it would lose
+ * distinct range content, so the edit is rejected unless a parse-restoring
+ * boundary combination proves another reading.
  */
 export declare function ambiguousBoundaryEchoMessage(startLine: number, endLine: number, side: "leading" | "trailing", count: number): string;
 /**
- * A replacement range deletes trailing structural closer(s) the payload never
- * restates, and nothing anchors the payload inside the block those closers
- * terminate: the payload has no unmatched opener for them and its indentation
- * is not deeper than the closer. Sparing the closer would have to guess
- * whether the payload belongs before it (inside the block) or after it (a
- * sibling), so the edit is rejected instead of repaired.
+ * A syntax-essential selected edge can be retained on either side of the
+ * payload, but indentation does not establish which placement was intended.
  */
-export declare function ambiguousCloserSpareMessage(startLine: number, endLine: number, closerLine: number, count: number): string;
+export declare function ambiguousBoundaryPlacementMessage(startLine: number, endLine: 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.
+ * Exact-text boundary rows were removed because the remaining payload covers
+ * the selected range and the same rows already survive immediately outside it.
  */
-export declare function ambiguousLeadingCloserSpareMessage(startLine: number, endLine: number, count: number): string;
+export declare function textualBoundaryEchoWarning(startLine: number, leading: number, trailing: 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.
+ * A replacement range's boundary disposition was corrected by the
+ * syntax-probe-judged search: syntax-essential source boundary rows were
+ * retained, or exact body echoes of surviving outside rows were removed. The
+ * authored result did not parse and the selected result does.
  */
-export declare function midBlockRangeWarning(startLine: number, endLine: number, orphaned: number): string;
+export declare function boundaryVariantRepairWarning(startLine: number, kept: number, dropped: 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 by
+ * tree-sitter and surfaced in the same response instead of waiting for a
+ * compiler pass.
+ */
+export declare function editBrokeParseWarning(firstChangedLine: number | undefined): string;
 /**
  * Internal invariant: `applyEdits` received an unresolved block edit;
  * `resolveBlockEdits` must run first.
  */
 export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved block edit reached the applier (resolveBlockEdits was not run).";
+/** Internal invariant: clipboard edits must be concrete before application. */
+export declare const UNRESOLVED_CLIPBOARD_INTERNAL = "internal error: unresolved clipboard edit reached the applier (resolveClipboardEdits was not run).";
 /** `REM` received a body row or coexists with line edits. */
 export declare const REM_TAKES_NO_BODY = "`REM` deletes the whole file and takes no body rows or line ops. Issue it alone under the header.";
 /** `MV` received a body row. */

package/dist/types/syntax.d.ts

@@ -1,14 +1,15 @@
 /**
  * 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.
+ * Replacement-boundary repair uses parsing as its semantic filter: exact
+ * outside-row equality may justify dropping a duplicated payload edge, while
+ * retaining a selected source boundary additionally requires source-range
+ * structure, indentation, or a narrow pure-closer shape. An unrecognized
+ * language yields no structural proof, so only evidence-complete textual
+ * normalization remains available.
  */
+/** Syntactic node boundaries outside a visible source range. */
+export declare function enclosingBoundaries(lines: readonly string[], path: string, startLine: number, endLine: number): readonly number[];
 /**
  * `true` when `text` parses without a syntax error under the language inferred
  * from `path`. `false` covers "does not parse" and "cannot tell" alike — no

package/package.json

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