pi-hashline-edit-pro 4.2.11 → 4.3.1

package/src/grep.ts

@@ -12,8 +12,8 @@ import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
 import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
-import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
-import { buildServedMap } from "./served";
+import { withAnchorSession } from "./anchor-registry";
+import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 import { expandHint, getResultText, reuseText, type CallT, type FgT } from "./replace-render";
 const GREP_KS = new Set(["pattern", "path", "glob", "context", "ignoreCase", "literal", "limit"]);
@@ -281,11 +281,8 @@ function makeHitFromIndices(
 }
 
 let cachedRgPath: string | undefined;
-export function clearRgPathCache(): void {
-  cachedRgPath = undefined;
-}
 
-async function resolveRgPath(): Promise<string> {
+export async function resolveRgPath(): Promise<string> {
   if (cachedRgPath !== undefined) return cachedRgPath;
   try {
     const r = spawnSync("rg", ["--version"], { stdio: "pipe" });
@@ -572,6 +569,12 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         const globRoot = baseStat.isFile() ? dirname(base) : base;
         const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
+        const matchesGlob = (absPath: string): boolean => {
+          if (globRegex === undefined) return true;
+          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
+          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+          return globRegex.test(globPath) || globRegex.test(displayPath);
+        };
         const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
         const rgPath = await resolveRgPath();
         const hits: FileHit[] = [];
@@ -607,11 +610,7 @@ export function regGrep(pi: ExtensionAPI): void {
           const sortedNums = [...allNums].sort((a, b) => a - b);
           const indices = sortedNums.map((n) => n - 1).filter((n) => n >= 0);
           if (countOnly) {
-            if (globRegex) {
-              const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
-              const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
-              if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
-            }
+            if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
             const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
@@ -633,15 +632,10 @@ export function regGrep(pi: ExtensionAPI): void {
             limitTruncated = true;
             break;
           }
-          if (globRegex) {
-            const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
-            const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
-            if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
-          }
+          if (!matchesGlob(absPath)) continue;
           const norm = await readGrepFile(absPath);
           if (!norm) continue;
           const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
-          if (!hit) continue;
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];
@@ -677,7 +671,7 @@ export function regGrep(pi: ExtensionAPI): void {
         }
         hits.sort((a, b) => cmp(a.displayPath, b.displayPath));
         for (const hit of hits) {
-          markServedScoped(hit.path, buildServedMap(hit.fileHashes, hit.fileLines, hit.hashes), new Set(hit.fileHashes));
+          serveRows(hit.path, hit.fileHashes, hit.fileLines, hit.hashes);
         }
         const blocks = hits
           .map((hit) => `=== ${hit.displayPath} ===\n${hit.rows.join("\n")}`)

package/src/hash-store/cache.ts

@@ -16,21 +16,3 @@ export function cacheSnapshot(path: string, checksum: string, lineCount: number,
     if (oldest !== undefined) snapshotCache.delete(oldest);
   }
 }
-
-let sessionSeq = 0;
-export const sessionTouched = new Map<string, number>();
-
-export function touchSession(path: string): void {
-  sessionSeq += 1;
-  sessionTouched.delete(path);
-  sessionTouched.set(path, sessionSeq);
-}
-
-export function clearSession(): void {
-  sessionTouched.clear();
-  sessionSeq = 0;
-}
-
-export function forgetSession(path: string): void {
-  sessionTouched.delete(path);
-}

package/src/hash-store/retry.ts

@@ -42,7 +42,3 @@ export function retriedWrite(stmt: { run(...params: (string | number | null)[]):
     withBusyRetry(() => { stmt.run(...params); });
   };
 }
-
-export async function openDbWithBusyRetryAsync<T>(fn: () => T): Promise<T> {
-  return withBusyRetryAsync(fn);
-}

package/src/hash-store/validation.ts

@@ -9,15 +9,6 @@ export function isValidHashList(value: unknown): value is string[] {
   return true;
 }
 
-export function isValidServedMap(value: unknown): value is Record<string, string> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-    if (typeof k !== "string" || !HASH_RE.test(k)) return false;
-    if (typeof v !== "string") return false;
-  }
-  return true;
-}
-
 export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
   let parsed: unknown;
   try {
@@ -35,33 +26,11 @@ export function parseHashList(raw: string, onInvalid: () => void, context?: stri
   return parsed;
 }
 
-export function parseServedMap(raw: string, onInvalid: () => void, context?: string): Map<string, string> | undefined {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    console.error(`[parseServedMap]${context ? ` ${context}:` : ""} failed to parse stored served JSON:`, error);
-    onInvalid();
-    return undefined;
-  }
-  if (!isValidServedMap(parsed)) {
-    console.error(`[parseServedMap]${context ? ` ${context}:` : ""} stored served did not pass validation:`, (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
-    onInvalid();
-    return undefined;
-  }
-  return new Map(Object.entries(parsed as Record<string, string>));
-}
-
 export function parseStoredHashes(row: Record<string, unknown> | undefined, onInvalid: () => void): string[] | undefined {
   if (!row) return undefined;
   return parseHashList(row.hashes as string, onInvalid);
 }
 
-export function parseStoredServed(row: Record<string, unknown> | undefined, onInvalid: () => void): Map<string, string> | undefined {
-  if (!row) return undefined;
-  return parseServedMap(row.hashes as string, onInvalid);
-}
-
 export function isValidSnapshot(value: unknown): value is { content: string; hashes: string[] } {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;

package/src/hash-store.ts

@@ -7,22 +7,19 @@ import { initHasher, contentChecksum } from "./hashline/hasher";
 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,
+  withBusyRetryAsync,
 } from "./hash-store/retry";
-import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT, touchSession, clearSession, forgetSession } from "./hash-store/cache";
+import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT } from "./hash-store/cache";
 
-export { isValidHashList, isValidServedMap, parseHashList, parseServedMap, parseStoredHashes, parseStoredServed, isCorruptionError };
+export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
 
@@ -283,19 +280,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => 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(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => openDb(storePath));
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = await openDbWithBusyRetryAsync(() => openDb(storePath));
+    opened = await withBusyRetryAsync(() => openDb(storePath));
   }
   const { db, stmts } = opened;
   try {
@@ -367,25 +364,28 @@ export function shutdownHashStore(): void {
     cachedDb = null;
   }
   snapshotCache.clear();
-  clearSession();
 }
 
-export function withStore(fn: () => void): void {
-  if (!cachedDb || !cachedDb.db.isOpen) {
-    throw new Error(STORE_NOT_OPEN_MESSAGE);
-  }
+function withTransaction(db: RawDb, fn: () => void): void {
   withBusyRetry(() => {
-    cachedDb!.db.exec("BEGIN IMMEDIATE");
+    db.exec("BEGIN IMMEDIATE");
     try {
       fn();
-      cachedDb!.db.exec("COMMIT");
+      db.exec("COMMIT");
     } catch (e) {
-      try { cachedDb!.db.exec("ROLLBACK"); } catch {}
+      try { db.exec("ROLLBACK"); } catch {}
       throw e;
     }
   });
 }
 
+export function withStore(fn: () => void): void {
+  if (!cachedDb || !cachedDb.db.isOpen) {
+    throw new Error(STORE_NOT_OPEN_MESSAGE);
+  }
+  withTransaction(cachedDb.db, fn);
+}
+
 async function migrateLegacy(db: RawDb): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
@@ -431,18 +431,11 @@ async function migrateLegacy(db: RawDb): Promise<void> {
     ]);
   }
   if (rows.length > 0) {
-    withBusyRetry(() => {
-      db.exec("BEGIN IMMEDIATE");
-      try {
-        const stmt = db.prepare(
-          "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
-        );
-        for (const row of rows) stmt.run(...row);
-        db.exec("COMMIT");
-      } catch (e) {
-        try { db.exec("ROLLBACK"); } catch {}
-        throw e;
-      }
+    withTransaction(db, () => {
+      const stmt = db.prepare(
+        "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, line_checksums, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
+      );
+      for (const row of rows) stmt.run(...row);
     });
   }
 
@@ -487,7 +480,6 @@ export function upsertSnapshot(
 ): void {
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), lineChecksums ? JSON.stringify(lineChecksums) : "", Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
-  touchSession(path);
 }
 export function persistSnapshot(
   store: HashStore,
@@ -540,7 +532,6 @@ export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): v
     typeof entry.mode === "number" ? entry.mode : null,
     Date.now(),
   );
-  touchSession(path);
 }
 
 export function getUndoEntry(store: HashStore, path: string): UndoRecord | undefined {
@@ -600,7 +591,6 @@ export async function pruneMissing(store: HashStore): Promise<string[]> {
     }
   });
   for (const path of missing) snapshotCache.delete(path);
-  for (const path of missing) forgetSession(path);
   return missing;
 }
 

package/src/hashline/apply.ts

@@ -184,9 +184,9 @@ export function planEdit(
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];
 
-  const rangeFixed = swapReversedRanges(edit, fileHashes, warnings);
+  const rangeFixed = swapReversedRanges(edit, fileHashes);
   const prefixFixed = stripDiffPrefixes(
-    stripBarePrefixes(rangeFixed, fileHashes, warnings),
+    stripBarePrefixes(rangeFixed, warnings),
     warnings,
   );
 

package/src/hashline/hash.ts

@@ -2,7 +2,7 @@ import { splitLines, truncateToBytes, getCached } from "../utils";
 import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import { loadHashStore, type HashStore } from "../hash-store";
 import { allocateFileAnchors } from "../anchor-registry";
-import { xxh32, initHasher } from "./hasher";
+import { xxh32, initHasher, contentChecksum } from "./hasher";
 import { HASH_LEN, ANCHOR_COUNT, anchorAt, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, HASH_CLASS, HASH_RUN };
 
@@ -15,11 +15,6 @@ export const MAX_HASH_LINES = HASH_SPACE;
 
 export const HASH_PROBE_STRIDE = 836286;
 
-
-function hashAt(idx: number): string {
-  return anchorAt(idx);
-}
-
 export const HL_PREFIX_PLUS_RE = new RegExp(
 	`^\\+${HASH_RUN}│`,
 );
@@ -61,6 +56,10 @@ export function hashSource(line: string): string {
 	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
 }
 
+export function lineChecksum(line: string): string {
+	return contentChecksum(hashSource(line));
+}
+
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {
@@ -88,12 +87,12 @@ function assignHash(used: Uint32Array, baseIdx: number, hint: { value: number })
   if (!getBit(used, baseIdx)) {
     setBit(used, baseIdx);
     hint.value = baseIdx + HASH_PROBE_STRIDE;
-    return hashAt(baseIdx);
+    return anchorAt(baseIdx);
   }
   const nextIdx = nextZeroBit(used, hint.value);
   setBit(used, nextIdx);
   hint.value = nextIdx + HASH_PROBE_STRIDE;
-  return hashAt(nextIdx);
+  return anchorAt(nextIdx);
 }
 
 export function _lineHashesPure(content: string): string[] {

package/src/hashline/index.ts

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

package/src/hashline/parse.ts

@@ -55,43 +55,30 @@ export const parseHashRef = parseRef;
 
 const JSON_ENVELOPE_RE = /^\s*\["(.*)"\]\.\s*$/;
 
-function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
+function unwrapJsonEnvelope(line: string): string {
   const match = line.match(JSON_ENVELOPE_RE);
   if (!match) return line;
   const withoutDot = line.trim().slice(0, -1);
   try {
     const parsed: unknown = JSON.parse(withoutDot);
     if (Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string") {
-      warnings?.push(
-        '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
-      );
       return parsed[0];
     }
     return line;
   } catch {
-    warnings?.push(
-      '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
-    );
     return match[1]!;
   }
 }
 
-export function parseText(edit: string[], warnings?: string[]): string[] {
+export function parseText(edit: string[]): string[] {
   if (!Array.isArray(edit) || edit.some((line) => typeof line !== "string")) {
     throw new Error(NEW_CONTENT_NOT_ARRAY_MSG);
   }
   const out: string[] = [];
-  let split = false;
   for (const line of edit) {
-    const unwrapped = unwrapJsonEnvelope(line, warnings);
+    const unwrapped = unwrapJsonEnvelope(line);
     const normalized = unwrapped.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-    if (normalized.includes("\n")) split = true;
     out.push(...normalized.split("\n"));
   }
-  if (split) {
-    warnings?.push(
-      "[W_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
-    );
-  }
   return out;
 }

package/src/hashline/resolve.ts

@@ -1,10 +1,8 @@
 import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached, decodeStringArray, assertNoNul } from "../utils";
 import { parseHashRef, parseText, type Anchor } from "./parse";
-import { HASH_SEP, stripRowPrefix, canon } from "./hash";
+import { HASH_SEP, stripRowPrefix, canon, lineChecksum, type RowPrefixKind } from "./hash";
 import { HASH_RUN } from "./alphabet";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
-import { contentChecksum } from "./hasher";
-import { hashSource } from "./hash";
 
 export type RAnchor = {
 	line: number;
@@ -110,7 +108,7 @@ export function fmtMismatchWithHashes(
         const h = fileHashes[ln - 1]!;
         const c = fileLines[ln - 1] ?? "";
         hashes.push(h);
-        servedMap.set(h, contentChecksum(hashSource(c)));
+        servedMap.set(h, lineChecksum(c));
         rows.push(`    ${ln}: ${h}│${clipLine(c)}`);
       }
       out.push("");
@@ -171,7 +169,7 @@ export function stripAnchorRow(
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines, warnings);
+  const replaceLines = parseText(decodeStringArray(edit.replacement_lines, warnings) ?? edit.replacement_lines);
   assertNoNul(replaceLines);
   const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     return stripAnchorRow(ref.trim(), "remove_from/remove_to entry", warnings);
@@ -193,52 +191,37 @@ function warnUnicodeEsc(
   }
 }
 
-export function stripBarePrefixes(
-	edit: HEdit,
-	fileHashes: string[],
-	warnings: string[],
-): HEdit {
-	const fileHashSet = new Set(fileHashes);
-	const stripped: { lineIndex: number; matched: boolean }[] = [];
-	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const result = stripRowPrefix(line);
-		if (result.kind !== "bare") return line;
-		stripped.push({ lineIndex, matched: fileHashSet.has(result.hash ?? "") });
-		return result.text;
-	});
-	if (stripped.length === 0) return edit;
-	const locations = stripped
-		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
-		.join(", ");
-	warnings.push(
-    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
-	);
-	return { ...edit, content_lines: contentLines };
-}
-
-export function stripDiffPrefixes(
+function stripRowPrefixes(
 	edit: HEdit,
 	warnings: string[],
+	kinds: RowPrefixKind[],
+	code: string,
+	marker: string,
 ): HEdit {
 	const stripped: number[] = [];
 	const contentLines = edit.content_lines.map((line, lineIndex) => {
 		const result = stripRowPrefix(line);
-		if (result.kind !== "plus" && result.kind !== "minus") return line;
+		if (result.kind === null || !kinds.includes(result.kind)) return line;
 		stripped.push(lineIndex);
 		return result.text;
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
-	warnings.push(
-    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
-	);
+	warnings.push(`${code} Stripped ${marker} from ${locations}.`);
 	return { ...edit, content_lines: contentLines };
 }
 
+export function stripBarePrefixes(edit: HEdit, warnings: string[]): HEdit {
+	return stripRowPrefixes(edit, warnings, ["bare"], "[W_BARE_HASH_PREFIX]", '"anchor│" prefix');
+}
+
+export function stripDiffPrefixes(edit: HEdit, warnings: string[]): HEdit {
+	return stripRowPrefixes(edit, warnings, ["plus", "minus"], "[W_INVALID_PATCH]", "diff-preview marker");
+}
+
 export function swapReversedRanges(
 	edit: HEdit,
 	fileHashes: string[],
-	warnings: string[],
 ): HEdit {
 	const lineByHash = new Map<string, number>();
 	for (let i = 0; i < fileHashes.length; i++) {
@@ -254,9 +237,6 @@ export function swapReversedRanges(
 	) {
 		return edit;
 	}
-	warnings.push(
-    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
-	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }
 
@@ -515,7 +495,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     const servedContent = served?.get(hash);
-    if (servedContent === undefined || servedContent !== contentChecksum(hashSource(content))) mismatchLines.push(line);
+    if (servedContent === undefined || servedContent !== lineChecksum(content)) mismatchLines.push(line);
   }
   if (mismatchLines.length === 0) return;
   const rangeLength = endLine - startLine + 1;
@@ -527,7 +507,7 @@ export function assertRangeServed(
     const hash = fileHashes[line - 1]!;
     const content = fileLines[line - 1]!;
     shownHashes.push(hash);
-    shownMap.set(hash, contentChecksum(hashSource(content)));
+    shownMap.set(hash, lineChecksum(content));
     rows.push(fmtRow(hash, clipLine(content)));
   }
   const location = filePath ? ` in ${filePath}` : "";

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields, assertNoNul } from "./utils";
+import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -8,7 +8,7 @@ const replacementLinesSchema = Type.Array(
   }),
   {
     description:
-      "One string per line. Use [] to delete the range.",
+      "One string per line. Use [] to delete the range; [\"\"] is a single blank line.",
   },
 );
 
@@ -77,20 +77,12 @@ export function assertReq(request: unknown): asserts request is ReqParams {
   assertNoNul(request.replacement_lines);
 }
 
-export function normReq(input: unknown): unknown {
-  if (!isRec(input)) {
-    return input;
-  }
-  const record: Record<string, unknown> = { ...input };
-  normalizeFilePath(record);
-  normalizeAnchors(record);
-  return record;
-}
+export { normalizeRequest as normReq } from "./utils";
 
 export function getPreviewInput(args: unknown): { path?: string; remove_from: string; remove_to: string; replacement_lines: string[] } | null {
   let normalized: unknown;
   try {
-    normalized = normReq(args);
+    normalized = normalizeRequest(args);
   } catch {
     return null;
   }

package/src/read.ts

@@ -17,8 +17,8 @@ import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } fro
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { markServed as markServedScoped, withAnchorSession } from "./anchor-registry";
-import { buildServedMap } from "./served";
+import { withAnchorSession } from "./anchor-registry";
+import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
@@ -237,7 +237,7 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 					fileHashes,
 					resolvedPath,
 				);
-				markServedScoped(resolvedPath, buildServedMap(fileHashes, fileLines, preview.servedHashes), new Set(fileHashes));
+				serveRows(resolvedPath, fileHashes, fileLines, preview.servedHashes);
 				const snapshotId = await safeSnapId(absolutePath, "read");
 				const previewText =
 					hadUtf8DecodeErrors