pi-hashline-edit-pro 3.0.4 → 4.0.0

package/src/anchor-registry.ts

@@ -0,0 +1,605 @@
+import { appendFile, mkdir, readFile, readdir, rm, stat } from "fs/promises";
+import { join } from "path";
+import { createHash } from "crypto";
+import { sessionClaimsDir } from "./paths";
+import { contentChecksum } from "./hashline/hasher";
+import { ANCHOR_COUNT, anchorAt } from "./hashline/alphabet";
+import { HASH_PROBE_STRIDE } from "./hashline/hash";
+import { errCode, splitLines } from "./utils";
+import { hashSource } from "./hashline";
+import * as Diff from "diff";
+import { getAllocatedState, persistSnapshot, type HashStore } from "./hash-store";
+import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
+
+export type RegistryEvent =
+  | { kind: "session"; sessionFile: string }
+  | { kind: "allocate"; path: string; rows: [string, string][] }
+  | { kind: "free"; path: string; anchors?: string[] }
+  | { kind: "clear" };
+
+export interface OwnedAnchor {
+  path: string;
+  checksum: string;
+}
+
+interface SessionState {
+	owned: Map<string, OwnedAnchor>;
+	served: Map<string, Map<string, string>>;
+	everMinted: Set<string>;
+	probe: number;
+}
+
+const SIDECAR_SUFFIX = ".registry.jsonl";
+
+let currentKey: string | undefined;
+let currentSidecar: string | undefined;
+const registries = new Map<string, SessionState>();
+
+function newSessionState(seed?: string): SessionState {
+	let probe = 0;
+	if (seed) {
+		for (const byte of createHash("sha256").update(seed).digest()) {
+			probe = (probe * 256 + byte) % ANCHOR_COUNT;
+		}
+	}
+	return { owned: new Map(), served: new Map(), everMinted: new Set(), probe };
+}
+
+function seedServedFromOwned(state: SessionState): void {
+	for (const [anchor, entry] of state.owned) {
+		let served = state.served.get(entry.path);
+		if (!served) {
+			served = new Map();
+			state.served.set(entry.path, served);
+		}
+		served.set(anchor, entry.checksum);
+	}
+}
+
+export function foldRegistryEvents(events: RegistryEvent[]): SessionState {
+  const state = newSessionState();
+  for (const event of events) {
+    if (event.kind === "clear") {
+      state.owned.clear();
+    } else if (event.kind === "allocate") {
+      for (const [anchor, checksum] of event.rows) {
+        state.owned.set(anchor, { path: event.path, checksum });
+      }
+    } else if (event.kind === "free") {
+      if (event.anchors) {
+        for (const anchor of event.anchors) {
+          state.owned.delete(anchor);
+        }
+      } else {
+        for (const [anchor, entry] of [...state.owned]) {
+          if (entry.path === event.path) {
+            state.owned.delete(anchor);
+          }
+        }
+      }
+    }
+  }
+  return state;
+}
+
+export function parseRegistryLog(raw: string): RegistryEvent[] {
+  const events: RegistryEvent[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line) as RegistryEvent;
+      if (parsed && (parsed.kind === "allocate" || parsed.kind === "free" || parsed.kind === "clear" || parsed.kind === "session")) {
+        events.push(parsed);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+
+function sidecarPath(key: string): string {
+  return join(sessionClaimsDir(), `${key}${SIDECAR_SUFFIX}`);
+}
+
+function sidecarKeyFor(sessionFile: string): string {
+  return createHash("sha256").update(sessionFile).digest("hex").slice(0, 24);
+}
+
+export async function initRegistry(sessionFile: string | undefined): Promise<void> {
+  if (!sessionFile) {
+    currentKey = `__ephemeral__-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    currentSidecar = undefined;
+    registries.set(currentKey, newSessionState());
+    return;
+  }
+  const key = sidecarKeyFor(sessionFile);
+  currentKey = key;
+  currentSidecar = sidecarPath(key);
+  let events: RegistryEvent[] = [];
+  try {
+    const raw = await readFile(currentSidecar, "utf-8");
+    events = parseRegistryLog(raw);
+  } catch (error) {
+    if (errCode(error) !== "ENOENT") {
+      console.error("Failed to read anchor registry sidecar:", error);
+    }
+  }
+  const folded = foldRegistryEvents(events);
+  seedServedFromOwned(folded);
+  registries.set(key, folded);
+  try {
+    await mkdir(sessionClaimsDir(), { recursive: true });
+    await appendFile(currentSidecar, JSON.stringify({ kind: "session", sessionFile } satisfies RegistryEvent) + "\n", "utf-8");
+  } catch (error) {
+    console.error("Failed to initialize anchor registry sidecar:", error);
+  }
+}
+
+function current(): SessionState | undefined {
+  if (!currentKey) return undefined;
+  return registries.get(currentKey);
+}
+
+function appendEvent(event: RegistryEvent): void {
+  appendFile(currentSidecar!, JSON.stringify(event) + "\n", "utf-8").catch((error) => {
+    console.error("Failed to append registry event:", error);
+  });
+}
+
+function fingerprintIndex(state: SessionState, path: string): Map<string, string[]> {
+  const index = new Map<string, string[]>();
+  for (const [anchor, entry] of state.owned) {
+    if (entry.path !== path) continue;
+    const list = index.get(entry.checksum) ?? [];
+    list.push(anchor);
+    index.set(entry.checksum, list);
+  }
+  return index;
+}
+
+const MINT_PROBE_LIMIT = 8192;
+
+export function mintAnchor(state: SessionState): string {
+  for (let probe = 0; probe < MINT_PROBE_LIMIT; probe++) {
+    state.probe = (state.probe + HASH_PROBE_STRIDE) % ANCHOR_COUNT;
+    const candidate = anchorAt(state.probe);
+    if (!state.owned.has(candidate) && !state.everMinted.has(candidate)) {
+      return candidate;
+    }
+  }
+  for (let step = 1; step <= ANCHOR_COUNT; step++) {
+    const candidate = anchorAt((state.probe + step) % ANCHOR_COUNT);
+    if (!state.owned.has(candidate)) {
+      for (const served of state.served.values()) served.delete(candidate);
+      return candidate;
+    }
+  }
+  throw new Error(
+    `${ANCHOR_POOL_EXHAUSTED_PREFIX}; free anchors with /clear-anchors or use write for very large files.`,
+  );
+}
+
+export function allocateAnchor(path: string, checksum: string): string {
+  const state = current();
+  if (!state) {
+    throw new Error("[E_REGISTRY] The anchor registry is not initialized; call initRegistry on session_start first.");
+  }
+  const anchor = mintAnchor(state);
+  state.everMinted.add(anchor);
+  state.owned.set(anchor, { path, checksum });
+  if (currentSidecar) {
+    appendEvent({ kind: "allocate", path, rows: [[anchor, checksum]] });
+  }
+  return anchor;
+}
+
+
+
+export function freeAnchors(path: string, anchors?: string[]): void {
+	const state = current();
+	if (!state) return;
+	const freed: string[] = [];
+	if (anchors) {
+		for (const anchor of anchors) {
+			if (state.owned.has(anchor)) {
+				freed.push(anchor);
+				state.owned.delete(anchor);
+				state.served.get(path)?.delete(anchor);
+			}
+		}
+	} else {
+		for (const [anchor, entry] of [...state.owned]) {
+			if (entry.path === path) {
+				freed.push(anchor);
+				state.owned.delete(anchor);
+			}
+		}
+		state.served.delete(path);
+	}
+	if (freed.length > 0 && currentSidecar) {
+		appendEvent({ kind: "free", path, anchors: anchors ?? undefined });
+	}
+}
+
+export function clearRegistry(): void {
+	const state = current();
+	if (!state) return;
+	state.owned.clear();
+	state.served.clear();
+	if (!currentSidecar) return;
+	appendEvent({ kind: "clear" });
+}
+
+export function servedForPath(path: string): Map<string, string> | undefined {
+	return current()?.served.get(path);
+}
+
+export function markServed(
+	path: string,
+	entries: Array<[string, string]>,
+	scope?: ReadonlySet<string>,
+): void {
+	const state = current();
+	if (!state) return;
+	if (!state.served.has(path) && entries.length === 0 && !scope) return;
+	let served = state.served.get(path);
+	if (!served) {
+		served = new Map();
+		state.served.set(path, served);
+	}
+	if (scope) {
+		for (const anchor of [...served.keys()]) {
+			if (!scope.has(anchor)) served.delete(anchor);
+		}
+	}
+	for (const [anchor, checksum] of entries) {
+		served.set(anchor, checksum);
+	}
+}
+
+export function ownerOf(anchor: string): OwnedAnchor | undefined {
+  return current()?.owned.get(anchor);
+}
+
+export function ownersForPath(path: string): Map<string, string> {
+  const claims = new Map<string, string>();
+  const state = current();
+  if (!state) return claims;
+  for (const [anchor, entry] of state.owned) {
+    if (entry.path === path) claims.set(anchor, entry.checksum);
+  }
+  return claims;
+}
+
+export function ensureRegistry(): void {
+  if (currentKey && registries.has(currentKey)) return;
+  initRegistry(undefined).catch(() => undefined);
+}
+
+function cloneState(state: SessionState): SessionState {
+	return {
+		owned: new Map(state.owned),
+		served: new Map([...state.served].map(([path, served]) => [path, new Map(served)])),
+		everMinted: new Set(state.everMinted),
+		probe: state.probe,
+	};
+}
+
+export interface Aligned {
+  anchors: string[];
+  freed: string[];
+  minted: string[];
+}
+
+interface MintedAt {
+  index: number;
+  anchor: string;
+  checksum: string;
+}
+
+function computeParts(
+  prevChecksums: string[] | undefined,
+  newChecksums: string[],
+): Diff.ArrayChange<string>[] {
+  if (!prevChecksums) {
+    return [{ count: newChecksums.length, added: true, removed: false, value: [] } as unknown as Diff.ArrayChange<string>];
+  }
+  const min = Math.min(prevChecksums.length, newChecksums.length);
+  let prefix = 0;
+  while (prefix < min && prevChecksums[prefix] === newChecksums[prefix]) prefix++;
+  let suffix = 0;
+  while (
+    suffix < min - prefix &&
+    prevChecksums[prevChecksums.length - 1 - suffix] === newChecksums[newChecksums.length - 1 - suffix]
+  ) {
+    suffix++;
+  }
+  if (prefix + suffix >= min && prevChecksums.length === newChecksums.length) {
+    return [{ count: newChecksums.length, value: [], added: false, removed: false } as unknown as unknown as Diff.ArrayChange<string>];
+  }
+  const prevMid = prevChecksums.slice(prefix, prevChecksums.length - suffix);
+  const newMid = newChecksums.slice(prefix, newChecksums.length - suffix);
+  if (prevMid.length === 0) {
+    return [
+      { count: prefix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+      { count: newMid.length, added: true, removed: false, value: [] } as unknown as Diff.ArrayChange<string>,
+      { count: suffix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+    ];
+  }
+  if (newMid.length === 0) {
+    return [
+      { count: prefix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+      { count: prevMid.length, removed: true, added: false, value: [] } as unknown as Diff.ArrayChange<string>,
+      { count: suffix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+    ];
+  }
+  if (prevMid.length * newMid.length > 4_000_000) {
+    return [
+      { count: prefix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+      { count: prevMid.length, removed: true, added: false, value: [] } as unknown as Diff.ArrayChange<string>,
+      { count: newMid.length, added: true, removed: false, value: [] } as unknown as Diff.ArrayChange<string>,
+      { count: suffix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>,
+    ];
+  }
+  const midParts = Diff.diffArrays(prevMid, newMid) as unknown as Diff.ArrayChange<string>[];
+  const parts: Diff.ArrayChange<string>[] = [];
+  if (prefix > 0) parts.push({ count: prefix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>);
+  parts.push(...midParts);
+  if (suffix > 0) parts.push({ count: suffix, value: [], added: false, removed: false } as unknown as Diff.ArrayChange<string>);
+  return parts;
+}
+
+export function alignOwnershipWithSpans(
+  path: string,
+  prevAnchors: string[],
+  prevChecksums: string[],
+  newChecksums: string[],
+  spans: { start: number; end: number; replacementCount: number }[],
+  options?: { shadow?: boolean },
+): Aligned {
+  const state = options?.shadow ? cloneState(current()!) : current()!;
+  const freed: { anchor: string; checksum: string }[] = [];
+  const minted: MintedAt[] = [];
+  const log = (event: RegistryEvent): void => {
+    if (!options?.shadow && currentSidecar) appendEvent(event);
+  };
+
+  const sorted = [...spans].sort((a, b) => a.start - b.start);
+  const anchors = [...prevAnchors];
+  let offset = 0;
+  for (const span of sorted) {
+    const prevStart = span.start;
+    const start = span.start + offset;
+    const end = span.end + offset;
+    const spanLength = end - start + 1;
+    const spanFreed: { anchor: string; checksum: string }[] = [];
+    for (let i = start; i <= end; i++) {
+      const anchor = anchors[i]!;
+      if (state.owned.has(anchor)) {
+        state.owned.delete(anchor);
+        const checksum = prevChecksums[i - offset] ?? "";
+        spanFreed.push({ anchor, checksum });
+        freed.push(spanFreed[spanFreed.length - 1]!);
+      }
+    }
+    const replacement: (string | undefined)[] = new Array(span.replacementCount);
+    for (let k = 0; k < span.replacementCount; k++) {
+      const positional = k < spanLength ? prevAnchors[prevStart + k] : undefined;
+      if (
+        positional !== undefined &&
+        prevChecksums[prevStart + k] === newChecksums[start + k] &&
+        (!state.owned.has(positional) || state.owned.get(positional)!.path === path)
+      ) {
+        replacement[k] = positional;
+        const freedAt = freed.findIndex((candidate) => candidate.anchor === positional);
+        if (freedAt >= 0) freed.splice(freedAt, 1);
+        const pooledAt = spanFreed.findIndex((candidate) => candidate.anchor === positional);
+        if (pooledAt >= 0) spanFreed.splice(pooledAt, 1);
+      }
+    }
+    for (let k = 0; k < span.replacementCount; k++) {
+      if (replacement[k] !== undefined) continue;
+      const anchor = mintAnchor(state);
+      const checksum = newChecksums[start + k]!;
+      minted.push({ index: start + k, anchor, checksum });
+      state.owned.set(anchor, { path, checksum });
+      replacement[k] = anchor;
+    }
+    const settled = replacement as string[];
+    for (let k = 0; k < span.replacementCount; k++) {
+      state.everMinted.add(settled[k]!);
+      state.owned.set(settled[k]!, { path, checksum: newChecksums[start + k]! });
+    }
+    anchors.splice(start, spanLength, ...settled);
+    offset += span.replacementCount - spanLength;
+  }
+  const rows: [string, string][] = minted.map((m) => [m.anchor, m.checksum]);
+  if (rows.length > 0) log({ kind: "allocate", path, rows });
+  if (freed.length > 0) log({ kind: "free", path, anchors: freed.map((f) => f.anchor) });
+  return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
+}
+
+export function alignOwnership(
+  path: string,
+  prevAnchors: string[] | undefined,
+  prevChecksums: string[] | undefined,
+  newChecksums: string[],
+  options?: { shadow?: boolean },
+): Aligned {
+  const state = options?.shadow ? cloneState(current()!) : current()!;
+  const anchors: string[] = new Array(newChecksums.length);
+  const freed: { anchor: string; checksum: string }[] = [];
+  const minted: MintedAt[] = [];
+  const log = (event: RegistryEvent): void => {
+    if (!options?.shadow && currentSidecar) appendEvent(event);
+  };
+  if (prevAnchors) {
+    for (const anchor of prevAnchors) state.everMinted.add(anchor);
+  }
+
+  const parts: Diff.ArrayChange<string>[] = computeParts(prevChecksums, newChecksums);
+  let prevIdx = 0;
+  let newIdx = 0;
+  for (const part of parts) {
+    const count = part.count ?? 0;
+    if (part.added) {
+      for (let k = 0; k < count; k++) {
+        const checksum = newChecksums[newIdx + k]!;
+        const anchor = mintAnchor(state);
+        state.everMinted.add(anchor);
+        state.owned.set(anchor, { path, checksum });
+        minted.push({ index: newIdx + k, anchor, checksum });
+        anchors[newIdx + k] = anchor;
+      }
+      newIdx += count;
+    } else if (part.removed) {
+      for (let k = 0; k < count; k++) {
+        const anchor = prevAnchors![prevIdx + k]!;
+        const entry = state.owned.get(anchor);
+        if (entry && entry.path === path) {
+          state.owned.delete(anchor);
+          freed.push({ anchor, checksum: prevChecksums![prevIdx + k]! });
+        }
+      }
+      prevIdx += count;
+    } else {
+      for (let k = 0; k < count; k++) {
+        const anchor = prevAnchors![prevIdx + k]!;
+        const entry = state.owned.get(anchor);
+        const checksum = newChecksums[newIdx + k]!;
+        if (entry && entry.path !== path) {
+          const fresh = mintAnchor(state);
+          state.owned.set(fresh, { path, checksum });
+          anchors[newIdx + k] = fresh;
+        } else {
+          state.owned.set(anchor, { path, checksum });
+          anchors[newIdx + k] = anchor;
+        }
+      }
+      newIdx += count;
+      prevIdx += count;
+    }
+  }
+
+  const rows: [string, string][] = [];
+  for (let i = 0; i < anchors.length; i++) {
+    rows.push([anchors[i]!, newChecksums[i]!]);
+  }
+  if (minted.length > 0) log({ kind: "allocate", path, rows: rows.filter(([anchor]) => minted.some((m) => m.anchor === anchor)) });
+  if (freed.length > 0) log({ kind: "free", path, anchors: freed.map((f) => f.anchor) });
+  return { anchors, freed: freed.map((f) => f.anchor), minted: minted.map((m) => m.anchor) };
+}
+
+export async function allocateFileAnchors(
+  store: HashStore,
+  path: string,
+  content: string,
+  options?: {
+    persist?: boolean;
+    shadow?: boolean;
+    previous?: { content: string; hashes: string[]; spans?: { start: number; end: number; replacementCount: number }[] };
+  },
+): Promise<string[]> {
+  ensureRegistry();
+  const shadow = options?.shadow === true;
+  const lines = splitLines(content);
+  const checksums = lines.map((line) => contentChecksum(hashSource(line)));
+  if (options?.previous?.spans) {
+    const sessionState = current()!;
+    const prevChecksums = splitLines(options.previous.content).map((line) => contentChecksum(hashSource(line)));
+    const aligned = alignOwnershipWithSpans(path, options.previous.hashes, prevChecksums, checksums, options.previous.spans, { shadow });
+    for (let i = 0; i < aligned.anchors.length; i++) {
+      sessionState.owned.set(aligned.anchors[i]!, { path, checksum: checksums[i]! });
+    }
+    if (!shadow && options.persist !== false) {
+      persistSnapshot(store, path, content, aligned.anchors, checksums);
+    }
+    return aligned.anchors;
+  }
+  let prevAnchors: string[] | undefined;
+  let prevChecksums: string[] | undefined;
+  if (options?.previous) {
+    prevAnchors = options.previous.hashes;
+    prevChecksums = splitLines(options.previous.content).map((line) => contentChecksum(hashSource(line)));
+  } else {
+    const previousState = getAllocatedState(store, path, !shadow);
+    if (previousState) {
+      prevAnchors = previousState.anchors;
+      prevChecksums = previousState.checksums;
+      if (!prevChecksums && previousState.contentChecksum === contentChecksum(content)) {
+        prevChecksums = checksums;
+      }
+    }
+  }
+  const aligned: Aligned = prevAnchors
+    ? alignOwnership(path, prevAnchors, prevChecksums, checksums, { shadow })
+    : (() => {
+        const state = shadow ? cloneState(current()!) : current()!;
+        const reuseIndex = fingerprintIndex(state, path);
+        const anchors: string[] = checksums.map((checksum) => {
+          const candidates = reuseIndex.get(checksum) ?? [];
+          const anchor = candidates.length > 0 ? candidates.shift()! : mintAnchor(state);
+          state.everMinted.add(anchor);
+          state.owned.set(anchor, { path, checksum });
+          return anchor;
+        });
+        if (!shadow && currentSidecar) {
+          appendEvent({ kind: "allocate", path, rows: anchors.map((a, i) => [a, checksums[i]!]) });
+        }
+        return { anchors, freed: [], minted: anchors };
+      })();
+  if (!shadow && options?.persist !== false) {
+    persistSnapshot(store, path, content, aligned.anchors, checksums);
+  }
+  return aligned.anchors;
+}
+
+export function adoptAnchors(path: string, entries: Map<string, string>): void {
+	ensureRegistry();
+	const state = current()!;
+	let served = state.served.get(path);
+	if (!served) {
+		served = new Map();
+		state.served.set(path, served);
+	}
+	for (const [anchor, checksum] of entries) {
+		state.owned.set(anchor, { path, checksum });
+		served.set(anchor, checksum);
+	}
+	if (currentSidecar && entries.size > 0) {
+		appendEvent({ kind: "allocate", path, rows: [...entries] });
+	}
+}
+
+export function resetRegistryForTests(): void {
+  currentKey = undefined;
+  currentSidecar = undefined;
+  registries.clear();
+}
+
+export async function gcRegistrySidecars(): Promise<void> {
+  let names: string[];
+  try {
+    names = await readdir(sessionClaimsDir());
+  } catch (error) {
+    if (errCode(error) !== "ENOENT") console.error("Failed to list registry sidecars:", error);
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith(SIDECAR_SUFFIX)) continue;
+    const sidecar = join(sessionClaimsDir(), name);
+    try {
+      const raw = await readFile(sidecar, "utf-8");
+      const header = JSON.parse(raw.split("\n")[0] ?? "{}") as { kind?: string; sessionFile?: string };
+      if (header.kind !== "session" || !header.sessionFile) continue;
+      await stat(header.sessionFile);
+    } catch (error) {
+      if (errCode(error) === "ENOENT") {
+        await rm(sidecar, { force: true });
+      } else {
+        console.error("Failed to inspect registry sidecar:", error);
+      }
+    }
+  }
+}

package/src/commit.ts

@@ -6,11 +6,14 @@ import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-res
 import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { recordServedSafe, buildServedMap, servedHashesFromDiff } from "./served";
+import { servedHashesFromDiff, buildServedMap } from "./served";
+import { lineHashes } from "./hashline";
+import { hashSpan } from "./replace";
 import { restoreEndings } from "./normalize";
 import { splitLines } from "./utils";
-
+import { markServed as markServedScoped } from "./anchor-registry";
 export interface CommitMeta {
+  editAnchors?: [string, string];
   path: string;
   absolutePath: string;
   mutationTargetPath: string;
@@ -102,12 +105,22 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     removedLines: pipe.totalRemovedLines,
   };
 
+  const span = meta.editAnchors ? hashSpan(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1]) : undefined;
+  const resultCount = splitLines(pipe.result).length;
+  const replacementCount = span ? resultCount - (pipe.originalHashes.length - (span[1] - span[0] + 1)) : 0;
+  const resultHashes = pipe.result === pipe.originalNormalized
+    ? pipe.originalHashes
+    : await lineHashes(pipe.result, mutationTargetPath, {
+        content: pipe.originalNormalized,
+        hashes: pipe.originalHashes,
+        spans: span ? [{ start: span[0], end: span[1], replacementCount }] : undefined,
+      });
   const successInput = {
     path,
     originalNormalized: pipe.originalNormalized,
     originalHashes: pipe.originalHashes,
     result: pipe.result,
-    resultHashes: pipe.resultHashes,
+    resultHashes,
     warnings,
     snapshotId: updatedSnapshotId,
     editMeta,
@@ -116,10 +129,11 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   };
   const changed = buildChanged(successInput, meta.verb);
   if (changed.details.diff) {
-    const diffHashes = servedHashesFromDiff(changed.details.diff);
-    const resultLines = splitLines(pipe.result);
-    const servedMap = buildServedMap(pipe.resultHashes, resultLines, diffHashes);
-    await recordServedSafe(mutationTargetPath, servedMap, "post-edit diff", new Set(pipe.resultHashes));
+    markServedScoped(
+      mutationTargetPath,
+      buildServedMap(resultHashes, splitLines(pipe.result), servedHashesFromDiff(changed.details.diff)),
+      new Set(resultHashes),
+    );
   }
   return changed;
 }

package/src/constants.ts

@@ -9,8 +9,11 @@ export const MAX_GREP_LINE_BYTES = 500;
 export const MAX_DIFF_INPUT_BYTES = 1024 * 1024;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 7;
+export const HASH_STORE_VERSION = 8;
 export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "replacement_lines" must be an array of strings, one per line (use [] to delete).`;
 
+export const ANCHOR_POOL_EXHAUSTED_PREFIX =
+  "[E_FILE_TOO_LARGE] The session's anchor pool is exhausted";
+
 export const DEDUP_ANCHOR = "dedup";