pi-hashline-edit-pro 2.8.0 → 2.8.2

package/src/hash-store.ts

@@ -1,11 +1,32 @@
 import { existsSync } from "fs";
-import { readFile, rename, mkdir, stat } from "fs/promises";
+import { chmod, readFile, rename, mkdir, stat } from "fs/promises";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode, isRec, splitLines } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
-import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
-
+import {
+  isValidHashList,
+  isValidServedMap,
+  parseStoredHashes,
+  parseStoredServed,
+  isValidSnapshot,
+  isCorruptionError,
+  parseHashList,
+  parseServedMap,
+} from "./hash-store/validation";
+import {
+  withBusyRetry,
+  retriedWrite,
+  openDbWithBusyRetryAsync,
+} from "./hash-store/retry";
+import {
+  snapshotCache,
+  cacheSnapshot,
+  SNAPSHOT_CACHE_LIMIT,
+} from "./hash-store/cache";
+
+export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
+export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
 type SqlParams = (string | number)[];
@@ -92,133 +113,10 @@ export interface UndoRecord {
   resultContent: string;
 }
 
-interface LegacySnapshot {
-  content: string;
-  hashes: string[];
-}
-
-export function isValidHashList(value: unknown): value is string[] {
-  if (!Array.isArray(value)) return false;
-  for (const hash of value) {
-    if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
-  }
-  if (new Set(value).size !== value.length) return false;
-  return true;
-}
-
-export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } 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,
-): string[] | undefined {
-  if (!row) return undefined;
-  return parseHashList(row.hashes as string, onInvalid);
-}
-
-function isValidSnapshot(value: unknown): value is LegacySnapshot {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value as Record<string, unknown>;
-  if (typeof v.content !== "string") return false;
-  return isValidHashList(v.hashes);
-}
-
-export function isCorruptionError(error: unknown): boolean {
-  if (error && typeof error === "object") {
-    const errcode = (error as { errcode?: unknown }).errcode;
-    if (typeof errcode === "number") {
-      return errcode === 11 || errcode === 24 || errcode === 26;
-    }
-    const code = (error as { code?: unknown }).code;
-    if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
-  }
-  return (
-    error instanceof Error &&
-    /corrupt|not a database|malformed|database disk image/i.test(error.message)
-  );
-}
-
-function isBusyError(error: unknown): boolean {
-  if (error && typeof error === "object") {
-    const errcode = (error as { errcode?: unknown }).errcode;
-    if (typeof errcode === "number") return errcode === 5 || errcode === 6;
-  }
-  return error instanceof Error && /busy|locked/i.test(error.message);
-}
-
-const sleepSab = new Int32Array(new SharedArrayBuffer(4));
-
-function sleepSync(ms: number): void {
-  Atomics.wait(sleepSab, 0, 0, ms);
-}
-
-const BUSY_RETRIES = 3;
-const BUSY_RETRY_DELAY_MS = 50;
-
-function withBusyRetry<T>(fn: () => T): 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;
-      sleepSync(BUSY_RETRY_DELAY_MS * (1 << attempt));
-    }
-  }
-  throw lastError;
-}
-
-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(
-  stmt: { run(...params: SqlParams): unknown },
-): (...params: SqlParams) => void {
-  return (...params) => {
-    withBusyRetry(() => { stmt.run(...params); });
-  };
-}
-
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
-interface SnapshotCacheEntry {
-  checksum: string;
-  lineCount: number;
-  hashes: string[];
-}
-const snapshotCache = new Map<string, SnapshotCacheEntry>();
-export const SNAPSHOT_CACHE_LIMIT = 256;
+
 function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   const db = openDbFn(storePath);
   try {
@@ -231,9 +129,7 @@ function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   }
 }
 
-function buildStore(
-  db: RawDb,
-): { db: RawDb; stmts: Prepared } {
+function buildStore(db: RawDb): { db: RawDb; stmts: Prepared } {
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
@@ -351,29 +247,58 @@ function shutdownDb(db: RawDb): void {
 }
 
 async function openStore(storePath: string): Promise<HashStore> {
-  shutdownHashStore();
-
+  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
+    return { stmts: cachedDb.stmts, engine: sqliteEngine };
+  }
+  if (cachedDb) shutdownHashStore();
   await initHasher();
-  await mkdir(hashStoreDir(), { recursive: true });
+  await mkdir(hashStoreDir(), { recursive: true, mode: 0o700 });
+  if (process.platform !== "win32") {
+    await chmod(hashStoreDir(), 0o700);
+  }
 
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   } catch (error) {
     if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(storePath);
+    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
   }
   const { db, stmts } = opened;
+  try {
+    const autoVacuum = (db.prepare("PRAGMA auto_vacuum").get() as { auto_vacuum: number }).auto_vacuum;
+    const pageCount = (db.prepare("PRAGMA page_count").get() as { page_count: number }).page_count;
+    const freelist = (db.prepare("PRAGMA freelist_count").get() as { freelist_count: number }).freelist_count;
+    if (autoVacuum === 0 && !existed) {
+      db.exec("PRAGMA auto_vacuum=INCREMENTAL");
+    } else if (freelist > 50 && freelist * 5 > pageCount) {
+      try {
+        db.exec("PRAGMA incremental_vacuum(50)");
+      } catch {
+        db.exec("VACUUM");
+      }
+    }
+  } catch {}
+
+  if (process.platform !== "win32") {
+    for (const candidate of [storePath, `${storePath}-wal`, `${storePath}-shm`]) {
+      try {
+        await chmod(candidate, 0o600);
+      } catch (error) {
+        if (errCode(error) !== "ENOENT") throw error;
+      }
+    }
+  }
 
   if (!existed) {
     try {
@@ -422,7 +347,7 @@ export function shutdownHashStore(): void {
 }
 
 export function withStore(fn: () => void): void {
-  if (!cachedDb) {
+  if (!cachedDb || !cachedDb.db.isOpen) {
     throw new Error(STORE_NOT_OPEN_MESSAGE);
   }
   withBusyRetry(() => {
@@ -503,15 +428,6 @@ async function migrateLegacy(db: RawDb): Promise<void> {
   }
 }
 
-function cacheSnapshot(path: string, checksum: string, lineCount: number, hashes: string[]): void {
-  snapshotCache.delete(path);
-  snapshotCache.set(path, { checksum, lineCount, hashes: hashes.slice() });
-  if (snapshotCache.size > SNAPSHOT_CACHE_LIMIT) {
-    const oldest = snapshotCache.keys().next().value;
-    if (oldest !== undefined) snapshotCache.delete(oldest);
-  }
-}
-
 export function getSnapshot(
   store: HashStore,
   path: string,
@@ -652,10 +568,37 @@ function matchPathsByHashes(
   return matches;
 }
 
+function matchPathsByServed(
+  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 (!isValidServedMap(parsed)) continue;
+      const keySet = new Set(Object.keys(parsed as Record<string, unknown>));
+      let ok = true;
+      for (const h of needed) {
+        if (!keySet.has(h)) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) matches.push(row.path);
+    } catch {
+      continue;
+    }
+  }
+  return matches;
+}
+
 export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
   return matchPathsByHashes(store.stmts.allHashes() as { path: string; hashes: string }[], hashes);
 }
 
 export function findServedPaths(store: HashStore, hashes: string[]): string[] {
-  return matchPathsByHashes(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
+  return matchPathsByServed(store.stmts.allServed() as { path: string; hashes: string }[], hashes);
 }

package/src/hashline/apply.ts

@@ -154,7 +154,7 @@ export function applyEdit(
 	signal?: AbortSignal,
 	precomputedHashes?: string[],
 	filePath?: string,
-	servedHashes?: ReadonlySet<string>,
+	servedHashes?: ReadonlyMap<string, string>,
 	skipBoundaryDedup?: boolean,
 	): {
 	content: string;
@@ -190,7 +190,7 @@ export function applyEdit(
 			fileHashes,
 			filePath,
 		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes);
+		throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
 	}
 
 	warnUnicodeEsc(prefixFixed, warnings);
@@ -233,7 +233,7 @@ export function applyEdit(
 				fileHashes,
 				filePath,
 			);
-			throw new AnchorMismatchError(feedback.text, feedback.hashes);
+			throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
 		}
 		resolved = correctedResult.resolved;
 	}

package/src/hashline/resolve.ts

@@ -2,6 +2,7 @@ import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, cl
 import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
+import { contentChecksum } from "./hasher";
 
 export type RAnchor = {
 	line: number;
@@ -90,14 +91,13 @@ export function fmtMismatchWithHashes(
   fileLines: string[],
   fileHashes: string[],
   filePath?: string,
-): { text: string; hashes: string[] } {
+): { text: string; hashes: string[]; servedMap: Map<string, string> } {
   assertAligned(fileLines, fileHashes, "fmtMismatch");
-
   const out: string[] = [];
   const hashes: string[] = [];
+  const servedMap = new Map<string, string>();
   const notFound = mismatches.filter((m) => m.kind === "not_found");
   const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
-
   const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
   if (notFound.length > 0) {
     out.push(
@@ -110,8 +110,11 @@ export function fmtMismatchWithHashes(
       const to = Math.min(fileLines.length, ctx.line + 1);
       const rows: string[] = [];
       for (let ln = from; ln <= to; ln++) {
-        hashes.push(fileHashes[ln - 1]!);
-        rows.push(`    ${ln}: ${fileHashes[ln - 1]}│${clipLine(fileLines[ln - 1] ?? "")}`);
+        const h = fileHashes[ln - 1]!;
+        const c = fileLines[ln - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+        rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
       out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
@@ -128,7 +131,12 @@ export function fmtMismatchWithHashes(
         (m.candidates?.length ?? 0) > sample.length
           ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)`
           : "";
-      for (const line of sample) hashes.push(fileHashes[line - 1]!);
+      for (const line of sample) {
+        const h = fileHashes[line - 1]!;
+        const c = fileLines[line - 1] ?? "";
+        hashes.push(h);
+        servedMap.set(h, contentChecksum(c));
+      }
       const lines = sample
         .map((line) => {
           const content = clipLine(fileLines[line - 1] ?? "");
@@ -140,8 +148,7 @@ export function fmtMismatchWithHashes(
         );
     }
   }
-
-  return { text: out.join("\n"), hashes };
+  return { text: out.join("\n"), hashes, servedMap };
 }
 
 
@@ -482,45 +489,49 @@ export function valEdit(
 }
 
 export function resolveAnchorLine(
-	ref: Anchor,
-	fileLines: string[],
-	fileHashes: string[],
-	filePath?: string,
+  ref: Anchor,
+  fileLines: string[],
+  fileHashes: string[],
+  filePath?: string,
 ): number {
-	const { resolved, mismatches } = valEdit(
-		{ hash_bounds: [ref, ref], content_lines: [] },
-		fileLines,
-		fileHashes,
-		[],
-		undefined,
-	);
-	if (mismatches.length > 0 || !resolved) {
-		const feedback = fmtMismatchWithHashes(
-			mismatches,
-			fileLines,
-			fileHashes,
-			filePath,
-		);
-		throw new AnchorMismatchError(feedback.text, feedback.hashes);
-	}
-	return resolved.hash_bounds[0].line;
+  const { resolved, mismatches } = valEdit(
+    { hash_bounds: [ref, ref], content_lines: [] },
+    fileLines,
+    fileHashes,
+    [],
+    undefined,
+  );
+  if (mismatches.length > 0 || !resolved) {
+    const feedback = fmtMismatchWithHashes(
+      mismatches,
+      fileLines,
+      fileHashes,
+      filePath,
+    );
+    throw new AnchorMismatchError(feedback.text, feedback.hashes, feedback.servedMap);
+  }
+  return resolved.hash_bounds[0].line;
 }
 
 export class RangeStaleError extends Error {
   readonly rangeHashes: string[];
-  constructor(message: string, rangeHashes: string[]) {
+  readonly rangeServedMap: Map<string, string>;
+  constructor(message: string, rangeHashes: string[], rangeServedMap: Map<string, string>) {
     super(message);
     this.name = "RangeStaleError";
     this.rangeHashes = rangeHashes;
+    this.rangeServedMap = rangeServedMap;
   }
 }
 
 export class AnchorMismatchError extends Error {
   readonly feedbackHashes: string[];
-  constructor(message: string, feedbackHashes: string[]) {
+  readonly feedbackMap: Map<string, string>;
+  constructor(message: string, feedbackHashes: string[], feedbackMap: Map<string, string>) {
     super(message);
     this.name = "AnchorMismatchError";
     this.feedbackHashes = feedbackHashes;
+    this.feedbackMap = feedbackMap;
   }
 }
 
@@ -528,7 +539,7 @@ export function assertRangeServed(
   resolved: RHEdit,
   fileLines: string[],
   fileHashes: string[],
-  served: ReadonlySet<string>,
+  served: ReadonlyMap<string, string> | undefined,
   filePath?: string,
 ): void {
   assertAligned(fileLines, fileHashes, "assertRangeServed");
@@ -536,18 +547,23 @@ export function assertRangeServed(
   const endLine = resolved.hash_bounds[1].line;
   const mismatchLines: number[] = [];
   for (let line = startLine; line <= endLine; line++) {
-    if (!served.has(fileHashes[line - 1]!)) mismatchLines.push(line);
+    const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
+    const servedContent = served?.get(hash);
+    if (servedContent === undefined || servedContent !== contentChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
-
   const rangeLength = endLine - startLine + 1;
   const shownLength = Math.min(rangeLength, MAX_RANGE_STALE_LINES);
   const rows: string[] = [];
   const shownHashes: string[] = [];
+  const shownMap = new Map<string, string>();
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
+    const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
+    shownMap.set(hash, contentChecksum(content));
+    rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;
@@ -561,7 +577,7 @@ export function assertRangeServed(
       : "";
   const message =
     `[E_RANGE_STALE] ${mismatchText} what was shown. Nothing was modified. Current range with fresh anchors:\n\n${rows.join("\n")}${capHint}`;
-  throw new RangeStaleError(message, shownHashes);
+  throw new RangeStaleError(message, shownHashes, shownMap);
 }
 
 export { warnUnicodeEsc };

package/src/insert.ts

@@ -1,18 +1,17 @@
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { constants } from "fs";
 import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, type NormFile } from "./file-reader";
-import { resolveInCwd } from "./fs-write";
 import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
-import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
+import type { RPreview, RRState } from "./replace-render";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
 const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
 
@@ -158,32 +157,17 @@ export function buildInsertToolDef(): InsertToolDef {
     description: loadP("../prompts/insert.md"),
     promptSnippet: loadP("../prompts/insert-snippet.md"),
     promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
-    prepareArguments: makePrepareArguments(),
-    executionMode: "sequential",
+    ...editToolBase,
     parameters: insertToolSchema,
-    renderShell: "default",
-    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
-    renderResult(result, { isPartial, expanded }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        { isPartial, expanded },
-        theme,
-        context,
-      );
-    },
-
+    renderCall: editRenderCallWrapper(insertPreview, getInsertInput, "insert"),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       assertInsertReq(canonical);
       const req = canonical;
       const path = req.path;
       const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      const { absolute: absolutePath, resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
         const preload = await readNormFile(path, ctx.cwd, {
           signal,
           accessMode: constants.R_OK | constants.W_OK,

package/src/normalize.ts

@@ -0,0 +1,27 @@
+export type LineEnding = "\r\n" | "\n" | "\r";
+
+export function detectEnding(content: string): LineEnding {
+  const crIdx = content.indexOf("\r");
+  const lfIdx = content.indexOf("\n");
+  if (crIdx === -1 && lfIdx === -1) return "\n";
+  if (crIdx === -1) return "\n";
+  if (lfIdx === -1) return "\r";
+  if (crIdx < lfIdx) return content[crIdx + 1] === "\n" ? "\r\n" : "\r";
+  return "\n";
+}
+
+export function toLF(text: string): string {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function restoreEndings(text: string, ending: LineEnding): string {
+  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
+  if (ending === "\r") return text.replace(/\n/g, "\r");
+  return text;
+}
+
+export function stripBOM(content: string): { bom: string; text: string } {
+  return content.startsWith("\uFEFF")
+    ? { bom: "\uFEFF", text: content.slice(1) }
+    : { bom: "", text: content };
+}

package/src/read.ts

@@ -13,8 +13,8 @@ import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
 import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, makePrepareArguments, numberedRead, visLines } from "./utils";
-import { recordServedSafe } from "./served";
+import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } from "./utils";
+import { recordServedSafe, buildServedMap } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
 import { Text } from "@earendil-works/pi-tui";
@@ -236,7 +236,9 @@ export function regRead(pi: ExtensionAPI): void {
 				fileHashes,
 				resolvedPath,
 			);
-			await recordServedSafe(resolvedPath, preview.servedHashes, "read", new Set(fileHashes));
+			const fileLines = splitLines(normalized);
+			const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
+			await recordServedSafe(resolvedPath, servedMap, "read", new Set(fileHashes));
 			const snapshotId = await safeSnapId(absolutePath, "read");
 			const previewText =
 				hadUtf8DecodeErrors

package/src/replace-diff.ts

@@ -5,37 +5,15 @@ import {
   ANCHOR_LEN,
   HASH_SEP,
 } from "./hashline";
+import {
+  detectEnding,
+  toLF,
+  restoreEndings,
+  stripBOM,
+  type LineEnding,
+} from "./normalize";
 
-export type LineEnding = "\r\n" | "\n" | "\r";
-
-export function detectEnding(content: string): LineEnding {
-  const crIdx = content.indexOf("\r");
-  const lfIdx = content.indexOf("\n");
-  if (crIdx === -1 && lfIdx === -1) return "\n";
-  if (crIdx === -1) return "\n";
-  if (lfIdx === -1) return "\r";
-  if (crIdx < lfIdx) return content[crIdx + 1] === "\n" ? "\r\n" : "\r";
-  return "\n";
-}
-
-export function toLF(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-export function restoreEndings(
-  text: string,
-  ending: LineEnding,
-): string {
-  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
-  if (ending === "\r") return text.replace(/\n/g, "\r");
-  return text;
-}
-
-export function stripBOM(content: string): { bom: string; text: string } {
-  return content.startsWith("\uFEFF")
-    ? { bom: "\uFEFF", text: content.slice(1) }
-    : { bom: "", text: content };
-}
+export { detectEnding, toLF, restoreEndings, stripBOM, type LineEnding };
 
 function fmtDiffLine(
   prefix: " " | "+" | "-",