@oh-my-pi/hashline 17.2.9 → 17.2.11

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [17.2.11] - 2026-08-07
+
+### Changed
+
+- Pasting an empty named register (`PUT … @name` with no matching capture) now surfaces a warning listing available registers and removes the span target instead of throwing an error.
+
+### Fixed
+
+- Fixed an issue where pipe-numbered `read`/`search` rows copied into top-level and bare-body patch payloads were not properly recovered (#7905).
+
+## [17.2.10] - 2026-08-06
+
+### Changed
+
+- Updated internal caching dependency to use `@oh-my-pi/pi-utils/lru`.
+
 ## [17.2.2] - 2026-07-31
 
 ### Breaking Changes

package/dist/types/apply.d.ts

@@ -18,7 +18,7 @@ export interface ApplyEditsOptions {
      * across files; omitted, the call gets a private register.
      */
     clipboard?: Clipboard;
-    /** `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). */
+    /** 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";
 }
 /**

package/dist/types/clipboard.d.ts

@@ -3,8 +3,10 @@ import type { Clipboard, Edit } from "./types.js";
 export declare function hasClipboardEdit(edits: readonly Edit[]): boolean;
 /** Optional knobs for {@link resolveClipboardEdits}. */
 export interface ResolveClipboardEditsOptions {
-    /** `PUT` with an empty register: `throw` (default) or `drop` (streaming previews). */
+    /** `PUT` with an empty register: `throw` (default) or `drop` (streaming previews). Named registers never throw — an empty named paste warns and pastes nothing. */
     onEmptyPaste?: "throw" | "drop";
+    /** Receives non-fatal diagnostics (e.g. an empty named-register paste). */
+    onWarning?: (message: string) => void;
 }
 /**
  * Resolve clipboard edits against the original file lines in authored order.
@@ -18,7 +20,8 @@ export declare function forkClipboard(source?: Clipboard): Clipboard;
 /** Publish a clipboard fork back to its source register (only named registers persist across batches). */
 export declare function commitClipboard(fork: Clipboard, target: Clipboard): void;
 /**
- * Validate that every paste has a preceding or persisted capture without
- * mutating the register or reading file content.
+ * Validate anonymous clipboard sequencing (empty or ambiguous unlabeled paste)
+ * without mutating the register or reading file content. Empty named-register
+ * pastes are non-fatal — they surface as apply-time warnings instead.
  */
 export declare function validateClipboardSequence(edits: readonly Edit[], clipboard: Clipboard): void;

package/dist/types/messages.d.ts

@@ -109,8 +109,8 @@ 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. */
-export declare function unknownRegisterMessage(name: string, known: readonly string[]): string;
+/** Named paste read a register that holds nothing; the paste applied as empty (span targets are still removed). */
+export declare function emptyRegisterPasteWarning(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/prefixes.d.ts

@@ -1,8 +1,8 @@
 /**
- * When a hashline payload is authored against `read`/`search` output, each
- * line is prefixed with either a hashline-mode line number (`123:`) or, for
- * diff-style echoes, a leading `+`. These helpers detect that and recover
- * the raw text. Two strip modes are exposed:
+ * When a payload is authored against `read`/`search` output, each line is
+ * prefixed with either a line number (`123:` in hashline mode or `123|`
+ * otherwise) or, for diff-style echoes, a leading `+`. These helpers detect
+ * that and recover the raw text. Two strip modes are exposed:
  *
  * - {@link stripNewLinePrefixes} — opportunistic: strips when the input
  *   clearly carries hashline or diff prefixes, leaves it alone otherwise.
@@ -17,15 +17,15 @@
 export declare function isReadMetadataLine(line: string): boolean;
 /**
  * Single-pass variant of {@link stripLeadingHashlinePrefixes} that strips at
- * most one leading hashline prefix (`N:`, `>>>N:`, `+N:` etc.) and does NOT
- * loop. Use this when the input carries at most one snapshot prefix (e.g. a
- * bare body row paste from `read` output) — recursive stripping would corrupt
- * content whose own text starts with `digits:`.
+ * most one leading line-number prefix (`N:`, `N|`, `>>>N:`, `+N:` etc.) and
+ * does NOT loop. Use this when the input carries at most one snapshot prefix
+ * (e.g. a bare body row paste from `read` output) — recursive stripping would
+ * corrupt content whose own text starts with a line-number prefix.
  */
 export declare function stripOneLeadingHashlinePrefix(line: string): string;
 /**
  * Strip whichever prefix scheme the lines appear to be carrying:
- * - hashline line-number prefixes (`123:`) when every content line has one
+ * - line-number prefixes (`123:` or `123|`) when every content line has one
  * - leading `+` (diff style) when at least half the lines have one
  * - mixed `+<n>:` form when present
  *

package/dist/types/snapshots.d.ts

@@ -88,7 +88,7 @@ export interface InMemorySnapshotStoreOptions {
     maxTotalBytes?: number;
 }
 /**
- * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a
+ * In-memory {@link SnapshotStore} backed by a bounded LRU. Per-path history is a
  * short ring of full-file versions (oldest dropped first); per-session path
  * tracking is LRU-bounded so cold paths age out automatically.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "17.2.9",
+	"version": "17.2.11",
 	"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.9",
-		"lru-cache": "11.5.2"
+		"@oh-my-pi/pi-natives": "17.2.11",
+		"@oh-my-pi/pi-utils": "17.2.11"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/apply.ts

@@ -1301,7 +1301,7 @@ export interface ApplyEditsOptions {
 	 * across files; omitted, the call gets a private register.
 	 */
 	clipboard?: Clipboard;
-	/** `PASTE` with an empty register: `throw` (default) or `drop` (streaming previews). */
+	/** 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";
 }
 
@@ -1318,8 +1318,10 @@ export function applyEdits(text: string, edits: readonly Edit[], options: ApplyE
 
 	// 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
@@ -1345,7 +1347,7 @@ export function applyEdits(text: string, edits: readonly Edit[], options: ApplyE
 	const indentationWarnings = repairReplacementIndentation(targetEdits, fileLines);
 	const { edits: repaired, warnings: boundaryWarnings } = repairReplacementBoundaries(targetEdits, fileLines);
 	const { edits: landed, warnings: landingWarnings } = repairAfterInsertLandings(repaired, fileLines);
-	const warnings = [...indentationWarnings, ...boundaryWarnings, ...landingWarnings];
+	const warnings = [...clipboardWarnings, ...indentationWarnings, ...boundaryWarnings, ...landingWarnings];
 
 	// Partition edits into bof, eof, and anchor-targeted buckets.
 	const bofLines: string[] = [];

package/src/clipboard.ts

@@ -8,7 +8,7 @@
  * (`lines`) is batch-local and resets between calls.
  */
 import { HL_CUT_KEYWORD, HL_PUT_KEYWORD, HL_RANGE_SEP } from "./format";
-import { ambiguousAnonymousPasteMessage, EMPTY_PASTE, unknownRegisterMessage } from "./messages";
+import { ambiguousAnonymousPasteMessage, EMPTY_PASTE, emptyRegisterPasteWarning } from "./messages";
 import { cloneCursor } from "./tokenizer";
 import type { Clipboard, Edit } from "./types";
 
@@ -33,25 +33,30 @@ export function hasClipboardEdit(edits: readonly Edit[]): boolean {
 
 /** Optional knobs for {@link resolveClipboardEdits}. */
 export interface ResolveClipboardEditsOptions {
-	/** `PUT` with an empty register: `throw` (default) or `drop` (streaming previews). */
+	/** `PUT` with an empty register: `throw` (default) or `drop` (streaming previews). Named registers never throw — an empty named paste warns and pastes nothing. */
 	onEmptyPaste?: "throw" | "drop";
+	/** Receives non-fatal diagnostics (e.g. an empty named-register paste). */
+	onWarning?: (message: string) => void;
 }
 
 /**
- * Read lines from a register. Throws on missing/ambiguous register unless `onEmptyPaste === "drop"`.
+ * Read lines from a register. A missing named register warns and reads as
+ * empty; anonymous misuse throws unless `onEmptyPaste === "drop"`.
  */
 function readRegister(
 	register: string | undefined,
 	clipboard: Clipboard,
 	lineNum: number,
 	onEmptyPaste: "throw" | "drop",
+	onWarning?: (message: string) => void,
 ): readonly string[] | null {
 	if (register !== undefined) {
 		const lines = clipboard.named?.get(register);
 		if (lines !== undefined) return lines;
 		if (onEmptyPaste === "drop") return null;
 		const known = clipboard.named ? [...clipboard.named.keys()] : [];
-		throw new Error(`line ${lineNum}: ${unknownRegisterMessage(register, known)}`);
+		onWarning?.(`line ${lineNum}: ${emptyRegisterPasteWarning(register, known)}`);
+		return [];
 	}
 
 	const pending = clipboard.pendingAnonCuts ?? [];
@@ -112,7 +117,7 @@ export function resolveClipboardEdits(
 			continue;
 		}
 		if (edit.kind === "paste") {
-			const lines = readRegister(edit.register, clipboard, edit.lineNum, onEmptyPaste);
+			const lines = readRegister(edit.register, clipboard, edit.lineNum, onEmptyPaste, options.onWarning);
 			if (lines === null) continue;
 
 			if (edit.at.kind === "gap") {
@@ -187,8 +192,9 @@ export function commitClipboard(fork: Clipboard, target: Clipboard): void {
 }
 
 /**
- * Validate that every paste has a preceding or persisted capture without
- * mutating the register or reading file content.
+ * Validate anonymous clipboard sequencing (empty or ambiguous unlabeled paste)
+ * without mutating the register or reading file content. Empty named-register
+ * pastes are non-fatal — they surface as apply-time warnings instead.
  */
 export function validateClipboardSequence(edits: readonly Edit[], clipboard: Clipboard): void {
 	const fork = forkClipboard(clipboard);

package/src/messages.ts

@@ -331,9 +331,9 @@ 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. */
-export function unknownRegisterMessage(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.`;
+/** Named paste read a register that holds nothing; the paste applied as empty (span targets are still removed). */
+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).`;
 	return known.length === 0 ? base : `${base} Available registers: ${known.map(k => `\`@${k}\``).join(", ")}.`;
 }
 

package/src/parser.ts

@@ -112,7 +112,7 @@ function bodylessTargetMessage(target: BlockTarget, hadColon: boolean): string |
  */
 const BARE_LITERAL_VALUE_RE = /^\s*(?:"[^"]*"|'[^']*'|[-+]?\d+(?:\.\d+)?)\s*,?\s*$/;
 
-const TOP_LEVEL_SNAPSHOT_ROW_RE = /^\s*([1-9]\d*):(.*)$/;
+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);
@@ -595,11 +595,11 @@ export class Executor {
 	}
 
 	/**
-	 * Strip a single read-output line-number prefix (`N:`) from every bare body
-	 * row, but only when *all* bare rows carry one. A uniform set of prefixes is
-	 * the signature of content pasted straight from `read`/`search` output; a
-	 * mixed set means the `N:` is genuine payload content and must stay. Rows
-	 * authored with an explicit `+` are not bare and are never touched.
+	 * Strip a single read-output line-number prefix (`N:` or `N|`) from every
+	 * bare body row, but only when *all* bare rows carry one. A uniform set of
+	 * prefixes is the signature of content pasted straight from `read`/`search`
+	 * output; a mixed set means the prefix is genuine payload content and must
+	 * stay. Rows authored with an explicit `+` are not bare and are never touched.
 	 */
 	#stripBarePrefixesIfUniform(payloads: PayloadRow[]): void {
 		let sawBare = false;

package/src/prefixes.ts

@@ -1,8 +1,8 @@
 /**
- * When a hashline payload is authored against `read`/`search` output, each
- * line is prefixed with either a hashline-mode line number (`123:`) or, for
- * diff-style echoes, a leading `+`. These helpers detect that and recover
- * the raw text. Two strip modes are exposed:
+ * When a payload is authored against `read`/`search` output, each line is
+ * prefixed with either a line number (`123:` in hashline mode or `123|`
+ * otherwise) or, for diff-style echoes, a leading `+`. These helpers detect
+ * that and recover the raw text. Two strip modes are exposed:
  *
  * - {@link stripNewLinePrefixes} — opportunistic: strips when the input
  *   clearly carries hashline or diff prefixes, leaves it alone otherwise.
@@ -16,7 +16,7 @@
 
 import { HL_FILE_HASH_LENGTH } from "./format";
 
-const HL_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:[+*-]\s*)?\d+:/;
+const HL_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:[+*-]\s*)?\d+[:|]/;
 const HL_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*\d+:/;
 const HL_HEADER_RE = new RegExp(`^\\s*\\[[^#\\r\\n]+#[0-9a-fA-F]{${HL_FILE_HASH_LENGTH}}\\]\\s*$`);
 const DIFF_PLUS_RE = /^[+](?![+])/;
@@ -41,10 +41,10 @@ function stripLeadingHashlinePrefixes(line: string): string {
 }
 /**
  * Single-pass variant of {@link stripLeadingHashlinePrefixes} that strips at
- * most one leading hashline prefix (`N:`, `>>>N:`, `+N:` etc.) and does NOT
- * loop. Use this when the input carries at most one snapshot prefix (e.g. a
- * bare body row paste from `read` output) — recursive stripping would corrupt
- * content whose own text starts with `digits:`.
+ * most one leading line-number prefix (`N:`, `N|`, `>>>N:`, `+N:` etc.) and
+ * does NOT loop. Use this when the input carries at most one snapshot prefix
+ * (e.g. a bare body row paste from `read` output) — recursive stripping would
+ * corrupt content whose own text starts with a line-number prefix.
  */
 export function stripOneLeadingHashlinePrefix(line: string): string {
 	return line.replace(HL_PREFIX_RE, "");
@@ -90,7 +90,7 @@ function collectLinePrefixStats(lines: string[]): LinePrefixStats {
 
 /**
  * Strip whichever prefix scheme the lines appear to be carrying:
- * - hashline line-number prefixes (`123:`) when every content line has one
+ * - line-number prefixes (`123:` or `123|`) when every content line has one
  * - leading `+` (diff style) when at least half the lines have one
  * - mixed `+<n>:` form when present
  *

package/src/snapshots.ts

@@ -15,11 +15,11 @@
  *
  * The abstract base class lets callers plug in whatever storage they like
  * (LRU, persistent SQLite, etc.). {@link InMemorySnapshotStore} ships as a
- * sensible default backed by `lru-cache`: a bounded set of paths, each with a
+ * sensible default backed by a bounded LRU: a limited set of paths, each with a
  * short history of full-file versions so in-session edit chains can still
  * recover against the version a stale tag names.
  */
-import { LRUCache } from "lru-cache/raw";
+import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import { computeFileHash } from "./format";
 
 /**
@@ -137,7 +137,7 @@ export interface InMemorySnapshotStoreOptions {
 }
 
 /**
- * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a
+ * In-memory {@link SnapshotStore} backed by a bounded LRU. Per-path history is a
  * short ring of full-file versions (oldest dropped first); per-session path
  * tracking is LRU-bounded so cold paths age out automatically.
  *