pi-hashline-edit-pro 2.7.1 → 2.8.0

package/src/fs-write.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import {
+	chmod,
 	lstat,
 	mkdir,
 	open,
@@ -11,6 +12,7 @@ import {
 	writeFile,
 } from "fs/promises";
 import { dirname, join, parse, resolve, sep } from "path";
+import { toCwd } from "./paths";
 import { errCode } from "./utils";
 
 export async function resolveTarget(path: string): Promise<string> {
@@ -25,7 +27,15 @@ export async function resolveTarget(path: string): Promise<string> {
   async function resParts(
     currentPath: string,
     remainingParts: string[],
+    symlinkDepth = 0,
   ): Promise<string> {
+    if (symlinkDepth > 40) {
+      const error = new Error(
+        `Too many symbolic links while resolving ${path}`,
+      ) as NodeJS.ErrnoException;
+      error.code = "ELOOP";
+      throw error;
+    }
     if (remainingParts.length === 0) {
       return currentPath;
     }
@@ -36,7 +46,7 @@ export async function resolveTarget(path: string): Promise<string> {
     try {
       const candidateStats = await lstat(candidatePath);
       if (!candidateStats.isSymbolicLink()) {
-        return resParts(candidatePath, tail);
+        return resParts(candidatePath, tail, symlinkDepth);
       }
 
       if (visitedSymlinks.has(candidatePath)) {
@@ -59,7 +69,7 @@ export async function resolveTarget(path: string): Promise<string> {
       return resParts(parse(linkTargetPath).root, [
         ...targetParts,
         ...tail,
-      ]);
+      ], symlinkDepth + 1);
     } catch (error: unknown) {
       if (errCode(error) === "ENOENT") {
         return join(candidatePath, ...tail);
@@ -110,6 +120,11 @@ async function syncDir(dir: string): Promise<void> {
   }
 }
 
+export async function resolveInCwd(path: string, cwd: string): Promise<{ absolute: string; resolved: string }> {
+  const absolute = toCwd(path, cwd);
+  const resolved = await resolveTarget(absolute);
+  return { absolute, resolved };
+}
 export async function writeAtomic(
   path: string,
   content: string,
@@ -127,6 +142,17 @@ export async function writeAtomic(
 
   if (existingStats && existingStats.nlink > 1) {
     await writeFile(targetPath, content, "utf-8");
+    try {
+      await chmod(targetPath, existingStats.mode & 0o7777);
+    } catch {}
+    try {
+      const handle = await open(targetPath, "r");
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+    } catch {}
     return;
   }
 

package/src/grep.ts

@@ -1,20 +1,24 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { readdir, stat } from "fs/promises";
 import { dirname, join, relative } from "path";
-import { loadFileKindAndText } from "./file-kind";
-import { readNormFile } from "./file-reader";
-import { MAX_HASH_LINES, fmtRow } from "./hashline";
+import { tryReadNormFile } from "./file-reader";
+import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
+import { MAX_GREP_LINE_BYTES } from "./constants";
 import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
-import { normReq } from "./replace-normalize";
+import { normReq } from "./payload-contract";
 import { recordServedSafe } from "./served";
-import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, visLines } from "./utils";
+import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
 const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", "coverage"]);
 const MAX_SCAN_FILES = 4000;
-const MAX_SHOWN_ROWS = 2000;
+
+function cmp(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 
 export interface GrepReq {
   pattern: string;
@@ -52,6 +56,7 @@ function buildRegex(pattern: string, literal: boolean, ignoreCase: boolean): Reg
 }
 
 function globToRegex(glob: string): RegExp {
+  if (glob.startsWith("/")) glob = glob.slice(1);
   let source = "";
   let i = 0;
   while (i < glob.length) {
@@ -78,12 +83,6 @@ function globToRegex(glob: string): RegExp {
   return new RegExp(`^${source}$`);
 }
 
-function isSkipableLoadError(error: unknown): boolean {
-  const code = errCode(error);
-  if (code === "EACCES" || code === "EPERM" || code === "ENOENT" || code === "ELOOP") return true;
-  return error instanceof Error && error.message.startsWith("[E_FILE_TOO_LARGE]");
-}
-
 interface FileHit {
   path: string;
   displayPath: string;
@@ -92,6 +91,42 @@ interface FileHit {
   hashes: string[];
   matchCount: number;
   totalMatchCount: number;
+  fragmented: boolean[];
+}
+
+const GREP_ROW_OVERHEAD_BYTES = HASH_LEN + Buffer.byteLength(HASH_SEP, "utf-8");
+const GREP_ROW_CONTENT_BYTES = MAX_GREP_LINE_BYTES - GREP_ROW_OVERHEAD_BYTES;
+
+function snapCharBoundaries(line: string, start: number, end: number): [number, number] {
+  let s = start;
+  let e = end;
+  if (s > 0 && s < line.length) {
+    const c = line.charCodeAt(s);
+    if (c >= 0xdc00 && c <= 0xdfff && line.charCodeAt(s - 1) >= 0xd800 && line.charCodeAt(s - 1) <= 0xdbff) s -= 1;
+  }
+  if (e > 0 && e < line.length) {
+    const c = line.charCodeAt(e - 1);
+    if (c >= 0xd800 && c <= 0xdbff && line.charCodeAt(e) >= 0xdc00 && line.charCodeAt(e) <= 0xdfff) e += 1;
+  }
+  return [s, e];
+}
+
+function grepMatchFragment(line: string, regex: RegExp): string {
+  const m = regex.exec(line);
+  const matchStart = m?.index ?? 0;
+  const matchLen = m?.[0].length ?? 0;
+  const budget = GREP_ROW_CONTENT_BYTES - 6;
+  const half = Math.floor((budget - Math.min(matchLen, budget)) / 2);
+  const [start, end] = snapCharBoundaries(line, Math.max(0, matchStart - half), Math.min(line.length, matchStart + matchLen + half));
+  const content = truncateToBytes(line.slice(start, end), budget);
+  const lead = start > 0 ? "..." : "";
+  const tail = end < line.length ? "..." : "";
+  return truncateToBytes(`${lead}${content}${tail}`, GREP_ROW_CONTENT_BYTES);
+}
+
+function grepHeadFragment(line: string): string {
+  const head = truncateToBytes(line, GREP_ROW_CONTENT_BYTES - 3);
+  return head.length < line.length ? `${head}...` : head;
 }
 
 interface ScanState {
@@ -105,14 +140,16 @@ async function walkFiles(
   onFile: (absPath: string) => Promise<void>,
 ): Promise<void> {
   const queue: string[] = [root];
-  while (queue.length > 0 && !state.stopped) {
-    const dir = queue.pop()!;
+  let head = 0;
+  while (head < queue.length && !state.stopped) {
+    const dir = queue[head++]!;
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
+    entries.sort((a, b) => cmp(a.name, b.name));
     for (const entry of entries) {
       if (state.stopped) break;
       const full = join(dir, entry.name);
@@ -143,23 +180,10 @@ async function searchFile(
   const displayPath = relative(cwd, absPath).replace(/\\/g, "/");
   if (globRegex) {
     const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
-    if (!globRegex.test(globPath)) return undefined;
-  }
-  let file;
-  try {
-    file = await loadFileKindAndText(absPath, { maxLines: MAX_HASH_LINES, displayPath });
-  } catch (error) {
-    if (isSkipableLoadError(error)) return undefined;
-    throw error;
-  }
-  if (file.kind !== "text") return undefined;
-  let norm;
-  try {
-    norm = await readNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, preloadedFile: file, noPersist: true });
-  } catch (error) {
-    if (isSkipableLoadError(error)) return undefined;
-    throw error;
+    if (!globRegex.test(globPath) && !globRegex.test(displayPath)) return undefined;
   }
+  const norm = await tryReadNormFile(absPath, cwd, { maxLines: MAX_HASH_LINES, noPersist: true });
+  if (!norm) return undefined;
   const lines = visLines(norm.normalized);
   const matchLines: number[] = [];
   for (let i = 0; i < lines.length; i++) {
@@ -172,11 +196,24 @@ async function searchFile(
     for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) shown.add(j);
   }
   const sorted = [...shown].sort((a, b) => a - b);
+  const matchSet = new Set(matchLines);
   const rows: string[] = [];
   const hashes: string[] = [];
+  const fragmented: boolean[] = [];
   for (const idx of sorted) {
-    rows.push(fmtRow(norm.fileHashes[idx]!, lines[idx]!));
-    hashes.push(norm.fileHashes[idx]!);
+    const hash = norm.fileHashes[idx]!;
+    const line = lines[idx]!;
+    const row = fmtRow(hash, line);
+    if (Buffer.byteLength(row, "utf-8") > MAX_GREP_LINE_BYTES) {
+      const content = matchSet.has(idx) ? grepMatchFragment(line, regex) : grepHeadFragment(line);
+      rows.push(fmtRow(hash, content));
+      hashes.push(hash);
+      fragmented.push(true);
+    } else {
+      rows.push(row);
+      hashes.push(hash);
+      fragmented.push(false);
+    }
   }
   return {
     path: norm.absolutePath,
@@ -186,6 +223,7 @@ async function searchFile(
     hashes,
     matchCount: keptMatches.length,
     totalMatchCount: matchLines.length,
+    fragmented,
   };
 }
 
@@ -201,7 +239,7 @@ const grepToolSchema = Type.Object(
     ),
     glob: Type.Optional(
       Type.String({
-        description: "Filter files by glob pattern; * matches across directories, e.g. '*.ts' or '**/*.spec.ts'",
+        description: "Filter files by glob pattern; * matches across directories, e.g. '*.ts' or '**/*.spec.ts'. A leading / is ignored; the pattern may be relative to the search root or to the current directory.",
       }),
     ),
     ignoreCase: Type.Optional(
@@ -239,6 +277,7 @@ export function regGrep(pi: ExtensionAPI): void {
     promptGuidelines: loadGuide("../prompts/grep-guidelines.md"),
     prepareArguments: makePrepareArguments(),
     parameters: grepToolSchema,
+    executionMode: "sequential",
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
@@ -268,14 +307,36 @@ export function regGrep(pi: ExtensionAPI): void {
         await walkFiles(base, state, async (absPath) => {
           files.push(absPath);
         });
+        files.sort(cmp);
       }
       const hits: FileHit[] = [];
       let matches = 0;
       let limitTruncated = false;
       let rowTruncated = false;
       let rowCount = 0;
-      for (const absPath of files) {
+      let byteCount = 0;
+      let totalRows = 0;
+      let totalBytes = 0;
+      let truncatedBy: "lines" | "bytes" | null = null;
+      let linesReplaced = 0;
+      let countOnly = false;
+      for (let f = 0; f < files.length; f++) {
         abortIf(signal);
+        const absPath = files[f]!;
+        if (countOnly) {
+          const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, Number.MAX_SAFE_INTEGER);
+          if (!hit) continue;
+          totalRows += hit.rows.length;
+          for (const row of hit.rows) totalBytes += Buffer.byteLength(row, "utf-8") + 1;
+          const remaining = limit - matches;
+          if (remaining > 0) {
+            matches += Math.min(hit.matchCount, remaining);
+            if (hit.matchCount > remaining) limitTruncated = true;
+          } else {
+            limitTruncated = true;
+          }
+          continue;
+        }
         const remaining = limit - matches;
         if (remaining <= 0) {
           limitTruncated = true;
@@ -283,19 +344,34 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         const hit = await searchFile(absPath, globRoot, ctx.cwd, regex, globRegex, context, remaining);
         if (!hit) continue;
-        const rowBudget = MAX_SHOWN_ROWS - rowCount;
-        if (rowBudget <= 0) {
-          rowTruncated = true;
-          break;
+        const keptRows: string[] = [];
+        const keptHashes: string[] = [];
+        for (let i = 0; i < hit.rows.length; i++) {
+          const row = hit.rows[i]!;
+          const rowBytes = Buffer.byteLength(row, "utf-8") + 1;
+          if (rowCount >= DEFAULT_MAX_LINES || byteCount + rowBytes > DEFAULT_MAX_BYTES) {
+            rowTruncated = true;
+            if (truncatedBy === null) truncatedBy = byteCount + rowBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines";
+            for (let j = i; j < hit.rows.length; j++) {
+              totalRows += 1;
+              totalBytes += Buffer.byteLength(hit.rows[j]!, "utf-8") + 1;
+            }
+            break;
+          }
+          keptRows.push(row);
+          keptHashes.push(hit.hashes[i]);
+          if (hit.fragmented[i]) linesReplaced += 1;
+          rowCount += 1;
+          byteCount += rowBytes;
+          totalRows += 1;
+          totalBytes += rowBytes;
         }
-        const keptRows = hit.rows.slice(0, rowBudget);
-        const keptHashes = hit.hashes.slice(0, rowBudget);
-        rowCount += keptRows.length;
         if (hit.totalMatchCount > hit.matchCount) limitTruncated = true;
-        if (keptRows.length < hit.rows.length) rowTruncated = true;
         matches += hit.matchCount;
         hits.push({ ...hit, rows: keptRows, hashes: keptHashes });
+        if (rowTruncated) countOnly = true;
       }
+      hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
       for (const hit of hits) {
         await recordServedSafe(hit.path, hit.hashes, "grep", new Set(hit.fileHashes));
       }
@@ -303,14 +379,32 @@ export function regGrep(pi: ExtensionAPI): void {
         .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)
         .join("\n");
       const notes: string[] = [];
-      if (rowTruncated) notes.push(`[grep: output truncated at ${MAX_SHOWN_ROWS} rows; refine the pattern to see more.]`);
+      if (rowTruncated) notes.push(`[grep: output truncated at ${DEFAULT_MAX_LINES} rows or ${formatSize(DEFAULT_MAX_BYTES)}; refine the pattern to see more.]`);
       if (limitTruncated) notes.push(`[grep: showing first ${limit} matches; increase limit to see more.]`);
       if (state.stopped) notes.push(`[grep: scan cap of ${MAX_SCAN_FILES} files reached; results may be incomplete.]`);
+      if (linesReplaced > 0) notes.push(`[grep: ${linesReplaced} line(s) exceed ${formatSize(MAX_GREP_LINE_BYTES)} and are shown as truncated fragments; use read to see the full lines.]`);
       const truncated = limitTruncated || rowTruncated;
+      const truncation: TruncationResult | undefined = rowTruncated
+        ? {
+            content: blocks,
+            truncated: true,
+            truncatedBy,
+            totalLines: totalRows,
+            totalBytes,
+            outputLines: rowCount,
+            outputBytes: byteCount,
+            lastLinePartial: false,
+            firstLineExceedsLimit: false,
+            maxLines: DEFAULT_MAX_LINES,
+            maxBytes: DEFAULT_MAX_BYTES,
+          }
+        : undefined;
       const text = blocks.length > 0 ? `${blocks}${notes.length > 0 ? `\n${notes.join("\n")}` : ""}` : "No matches found.";
       return {
         content: [{ type: "text", text }],
         details: {
+          ...(truncation ? { truncation } : {}),
+          ...(linesReplaced > 0 ? { linesTruncated: true as const } : {}),
           metrics: {
             matches,
             files: hits.length,

package/src/hash-store.ts

@@ -6,6 +6,8 @@ import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
 
+export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
+
 type SqlParams = (string | number)[];
 
 interface RawStatement {
@@ -104,21 +106,22 @@ export function isValidHashList(value: unknown): value is string[] {
   return true;
 }
 
-export function parseHashList(raw: string, onInvalid: () => void): string[] | undefined {
+export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw);
-  } catch {
+  } catch (error) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} failed to parse stored hashes JSON:`, error);
     onInvalid();
     return undefined;
   }
   if (!isValidHashList(parsed)) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} stored hashes did not pass validation:`, Array.isArray(parsed) ? `length=${parsed.length} sample=${JSON.stringify(parsed.slice(0, 3))}` : (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
     onInvalid();
     return undefined;
   }
   return parsed;
 }
-
 export function parseStoredHashes(
   row: Record<string, unknown> | undefined,
   onInvalid: () => void,
@@ -157,13 +160,14 @@ function isBusyError(error: unknown): boolean {
   return error instanceof Error && /busy|locked/i.test(error.message);
 }
 
+const sleepSab = new Int32Array(new SharedArrayBuffer(4));
+
 function sleepSync(ms: number): void {
-  const sab = new Int32Array(new SharedArrayBuffer(4));
-  Atomics.wait(sab, 0, 0, ms);
+  Atomics.wait(sleepSab, 0, 0, ms);
 }
 
 const BUSY_RETRIES = 3;
-const BUSY_RETRY_DELAY_MS = 100;
+const BUSY_RETRY_DELAY_MS = 50;
 
 function withBusyRetry<T>(fn: () => T): T {
   let lastError: unknown;
@@ -173,14 +177,28 @@ function withBusyRetry<T>(fn: () => T): T {
     } catch (error) {
       lastError = error;
       if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
-      sleepSync(BUSY_RETRY_DELAY_MS);
+      sleepSync(BUSY_RETRY_DELAY_MS * (1 << attempt));
     }
   }
   throw lastError;
 }
 
-function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared } {
-  return withBusyRetry(() => openDb(storePath));
+async function withBusyRetryAsync<T>(fn: () => T): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      await new Promise<void>((r) => setTimeout(r, BUSY_RETRY_DELAY_MS * (1 << attempt)));
+    }
+  }
+  throw lastError;
+}
+
+async function openDbWithBusyRetryAsync(storePath: string): Promise<{ db: RawDb; stmts: Prepared }> {
+  return withBusyRetryAsync(() => openDb(storePath));
 }
 
 function retriedWrite(
@@ -341,19 +359,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   } catch (error) {
     if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   }
   const { db, stmts } = opened;
 
@@ -403,9 +421,9 @@ export function shutdownHashStore(): void {
   snapshotCache.clear();
 }
 
-function withStore(fn: () => void): void {
+export function withStore(fn: () => void): void {
   if (!cachedDb) {
-    throw new Error("Hash store is not open; transactional update aborted");
+    throw new Error(STORE_NOT_OPEN_MESSAGE);
   }
   withBusyRetry(() => {
     cachedDb!.db.exec("BEGIN IMMEDIATE");
@@ -528,6 +546,14 @@ export function upsertSnapshot(
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
 }
+export function persistSnapshot(
+  store: HashStore,
+  path: string,
+  content: string,
+  hashes: string[],
+): void {
+  upsertSnapshot(store, path, contentChecksum(content), splitLines(content).length, hashes);
+}
 
 export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
   store.stmts.undoUpsert(
@@ -570,7 +596,11 @@ async function statMissing(rows: { path: string }[]): Promise<string[]> {
         try {
           await stat(row.path);
           return undefined;
-        } catch {
+        } catch (error: unknown) {
+          if (errCode(error) !== "ENOENT") {
+            console.error("Failed to stat hash store path:", row.path, error);
+            return undefined;
+          }
           return row.path;
         }
       }),
@@ -589,22 +619,32 @@ export async function pruneMissing(store: HashStore): Promise<void> {
   withStore(() => {
     for (const path of missing) {
       store.stmts.deleteOne(path);
-      snapshotCache.delete(path);
       store.stmts.servedDelete(path);
     }
   });
+  for (const path of missing) snapshotCache.delete(path);
 }
 
 function matchPathsByHashes(
   rows: { path: string; hashes: string }[],
   hashes: string[],
 ): string[] {
+  const needed = new Set(hashes);
+  if (needed.size === 0) return [];
   const matches: string[] = [];
   for (const row of rows) {
     try {
       const parsed = JSON.parse(row.hashes) as unknown;
       if (!isValidHashList(parsed)) continue;
-      if (hashes.every((h) => parsed.includes(h))) matches.push(row.path);
+      const parsedSet = new Set(parsed);
+      let ok = true;
+      for (const h of needed) {
+        if (!parsedSet.has(h)) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) matches.push(row.path);
     } catch {
       continue;
     }

package/src/hashline/hash.ts

@@ -1,11 +1,12 @@
-import { splitLines } from "../utils";
+import { splitLines, truncateToBytes, getCached } from "../utils";
+import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import {
   loadHashStore,
   type HashStore,
   getSnapshot,
-  upsertSnapshot,
+  persistSnapshot,
 } from "../hash-store";
-import { xxh32, contentChecksum, initHasher } from "./hasher";
+import { xxh32, initHasher } from "./hasher";
 import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS, HASH_RUN };
 
@@ -75,6 +76,10 @@ export function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
+export function hashSource(line: string): string {
+	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
+}
+
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {
@@ -115,9 +120,10 @@ export function _lineHashesPure(content: string): string[] {
   const hashes = new Array<string>(lines.length);
   const used = new Uint32Array(BITSET_WORDS);
   const hint = { value: 0 };
+  const hashSourceCache = new Map<string, string>();
 
   for (let i = 0; i < lines.length; i++) {
-    const c = canon(lines[i]!);
+    const c = getCached(hashSourceCache, lines[i]!, hashSource);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     hashes[i] = assignHash(used, baseIdx, hint);
   }
@@ -146,7 +152,7 @@ export async function lineHashes(
     );
     if (persist !== false) {
       try {
-        upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+        persistSnapshot(hashStore, path, content, newHashes);
       } catch (error) {
         console.error("Failed to persist hash snapshot:", error);
       }
@@ -167,7 +173,7 @@ export async function lineHashes(
   const newHashes = _lineHashesPure(content);
   if (persist !== false) {
     try {
-      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      persistSnapshot(hashStore, path, content, newHashes);
     } catch (error) {
       console.error("Failed to persist hash snapshot:", error);
     }
@@ -219,6 +225,7 @@ function mapStableHashes(
   const newHashes = new Array<string>(newLines.length);
   const used = new Uint32Array(BITSET_WORDS);
   const hint = { value: 0 };
+  const hashSourceCache = new Map<string, string>();
   const removed = removedHashes ?? new Set<string>();
 
   const oldHashIndex = new Map<string, number>();
@@ -255,7 +262,7 @@ function mapStableHashes(
 
   const newByContent = new Map<string, number[]>();
   for (let i = 0; i < newLines.length; i++) {
-    const key = canon(newLines[i]!);
+    const key = getCached(hashSourceCache, newLines[i]!, hashSource);
     const list = newByContent.get(key);
     if (list) list.push(i);
     else newByContent.set(key, [i]);
@@ -270,7 +277,7 @@ function mapStableHashes(
   };
 
   for (const entry of survivors) {
-    const candidates = newByContent.get(canon(oldLines[entry.index]!));
+    const candidates = newByContent.get(getCached(hashSourceCache, oldLines[entry.index]!, hashSource));
     if (!candidates || candidates.length === 0) continue;
     const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
     const pos = nearestNew(candidates, target);
@@ -301,7 +308,7 @@ function mapStableHashes(
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
-    const c = canon(newLines[i]!);
+    const c = getCached(hashSourceCache, newLines[i]!, hashSource);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }

package/src/hashline/index.ts

@@ -11,6 +11,7 @@ export {
 	_lineHashesPure,
 	initHasher,
 	canon,
+	hashSource,
 } from "./hash";
 
 export {