pi-hashline-edit-pro 0.17.14 → 0.18.1

package/README.md

@@ -13,7 +13,7 @@ The original uses 2-character hashes of a 16-character alphabet, with the hash b
 This fork makes two changes that compound:
 
 1. **3-character hash length** over a 64-char URL-safe base64 alphabet (up from 2 characters in the upstream), expanding the hash space from 256 to 262,144 buckets.
-2. **Perfect hashing (collision resolution).** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `:R{retry}`) until a unique hash is found. This ensures every line gets a unique anchor, even within a 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
+2. **Perfect hashing (collision resolution).** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the next available hash is assigned from a bitset (32KB, 262,144 bits) using a hint cursor for O(1) amortized lookup. This ensures every line gets a unique anchor, even within a 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
 
 ## Installation
 
@@ -156,7 +156,7 @@ The alphabet is sized for an LLM consumer. The model tokenizes, it doesn't squin
 
 Before hashing, each line is normalized: carriage returns are stripped and trailing whitespace is trimmed. This `canon()` normalization prevents insignificant whitespace changes from cascade-triggering hash churn across the file. Two lines that differ only in trailing spaces or `\r` characters produce the same hash, so anchor stability is preserved across editor-save cycles that add or remove trailing whitespace.
 
-**Perfect hashing (collision resolution):** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `:R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
+**Perfect hashing (collision resolution):** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the next available hash is assigned from a bitset (32KB, 262,144 bits) using a hint cursor for O(1) amortized lookup. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
 The runtime always precomputes the full per-line hash array for a file via `lineHashes(content, path)`, then looks up by line number during validation and during `read` / `replace` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read. When `path` is provided, `lineHashes` uses a persistent store to preserve hashes for unchanged lines across edits — see [Stable hashing across edits](#stable-hashing-across-edits).
 `HASH_LEN` in `src/hashline/hash.ts` sets the hash body length; bump it to 4 if you need even more entropy without collision resolution.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.14",
+  "version": "0.18.1",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
@@ -24,8 +24,7 @@
     "src",
     "prompts",
     "README.md",
-    "LICENSE",
-    "scripts"
+    "LICENSE"
   ],
   "pi": {
     "extensions": [
@@ -33,10 +32,8 @@
     ]
   },
   "dependencies": {
-    "better-sqlite3": "^13.0.1",
     "diff": "^8.0.2",
     "file-type": "^21.3.0",
-    "sql.js": "1.11",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {
@@ -47,23 +44,18 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint 'src/**/*.ts' 'index.ts'",
-    "typecheck": "tsc --noEmit",
-    "postinstall": "node scripts/ensure-better-sqlite3.cjs",
-    "preuninstall": "node scripts/cleanup-better-sqlite3.cjs"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0",
     "@eslint/js": "^10.0.1",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.0.0",
-    "@types/sql.js": "^1.4.11",
+    "@types/node": "^24.0.0",
     "eslint": "^10.7.0",
     "typescript": "^5.8.0",
     "typescript-eslint": "^8.65.0",
     "vitest": "^4.1.8"
   },
   "allowScripts": {
-    "better-sqlite3@13.0.1": true,
     "@google/genai@1.52.0": true,
     "koffi@2.16.2": true,
     "protobufjs@7.6.4": true

package/prompts/undo-last-replace-guidelines.md

@@ -1,2 +0,0 @@
-- `undo_last_replace`: call with the file path to revert the last replace on that file.
-- `undo_last_replace`: only the most recent replace per file is tracked.

package/src/constants.ts

@@ -6,7 +6,7 @@ export const MAX_HASH_LINES = 1_000_000;
 export const MAX_HASH_RETRIES = 262_144;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 2;
+export const HASH_STORE_VERSION = 3;
 export const CONTENT_LINES_NOT_STRING_MSG =
   `[E_BAD_SHAPE] "content_lines" must be a native JSON array of strings, not a JSON string.`
   + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`;

package/src/hash-store.ts

@@ -1,11 +1,10 @@
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { existsSync } from "fs";
 import { readFile, rename, mkdir, stat } from "fs/promises";
+import { DatabaseSync } from "node:sqlite";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
-import { errCode } from "./utils";
+import { errCode, splitLines } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
-import initSqlJs from "sql.js";
-
 type SqlParams = (string | number)[];
 
 interface Prepared {
@@ -17,7 +16,7 @@ interface Prepared {
 
 export interface HashStore {
   readonly stmts: Prepared;
-  readonly engine: "better-sqlite3" | "sql.js";
+  readonly engine: "node:sqlite";
 }
 
 interface LegacySnapshot {
@@ -36,38 +35,15 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
-
-
-interface BackendHandle {
-  store: HashStore;
-  close: () => void;
-  transact: (fn: () => void) => void;
-  prepare: (sql: string) => { run: (...params: unknown[]) => void; free: () => void };
-}
-
-let cachedHandle: { path: string; handle: BackendHandle } | null = null;
-
-
-
-let BetterDatabase: any = undefined;
-
-async function tryLoadBetter(): Promise<boolean> {
-  if (BetterDatabase !== undefined) return BetterDatabase !== null;
-  try {
-    const mod = await import("better-sqlite3");
-    BetterDatabase = mod.default || mod;
-    return true;
-  } catch {
-    BetterDatabase = null;
-    return false;
-  }
-}
-
-function openBetterDb(storePath: string): BackendHandle {
-  const db = new BetterDatabase(storePath);
-  db.pragma("journal_mode = WAL");
-  db.pragma("synchronous = NORMAL");
-  db.pragma(`busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
+let exitHandlerRegistered = false;
+function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+  const db = new DatabaseSync(storePath, {
+    timeout: HASH_STORE_BUSY_TIMEOUT,
+    defensive: false,
+  } as any);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
     "CREATE TABLE IF NOT EXISTS snapshots (" +
       "path TEXT PRIMARY KEY, " +
@@ -93,169 +69,70 @@ function openBetterDb(storePath: string): BackendHandle {
     upsert: (...params) => { upsertStmt.run(...params); },
   };
 
-  return {
-    store: { stmts, engine: "better-sqlite3" },
-    close: () => { db.close(); },
-    transact: (fn) => { db.transaction(fn).immediate(); },
-    prepare: (sql) => {
-      const stmt = db.prepare(sql);
-      return { run: (...params) => stmt.run(...params), free: () => {} };
-    },
-  };
-}
-
-
-
-let SqlJsDatabase: any = null;
-let sqlJsPromise: Promise<void> | null = null;
-
-async function ensureSqlJs(): Promise<void> {
-  if (sqlJsPromise) return sqlJsPromise;
-  sqlJsPromise = initSqlJs().then((SQL) => { SqlJsDatabase = SQL.Database; });
-  return sqlJsPromise;
-}
-
-function openSqlJsDb(storePath: string): BackendHandle {
-  const data = existsSync(storePath) ? new Uint8Array(readFileSync(storePath)) : undefined;
-  const db = new SqlJsDatabase(data);
-
-  db.run(
-    "CREATE TABLE IF NOT EXISTS snapshots (" +
-      "path TEXT PRIMARY KEY, " +
-      "checksum TEXT NOT NULL, " +
-      "line_count INTEGER NOT NULL, " +
-      "hashes TEXT NOT NULL, " +
-      "updated_at INTEGER NOT NULL" +
-    ")"
-  );
-
-  function save() {
-    writeFileSync(storePath, Buffer.from(db.export()));
-  }
-
-  save();
-
-  const stmts: Prepared = {
-    get: (...params) => {
-      const stmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
-      stmt.bind(params);
-      let result: Record<string, unknown> | undefined;
-      if (stmt.step()) result = stmt.getAsObject() as Record<string, unknown>;
-      stmt.free();
-      return result;
-    },
-    allPaths: (...params) => {
-      const stmt = db.prepare("SELECT path FROM snapshots");
-      if (params.length > 0) stmt.bind(params);
-      const results: Record<string, unknown>[] = [];
-      while (stmt.step()) results.push(stmt.getAsObject() as Record<string, unknown>);
-      stmt.free();
-      return results;
-    },
-    deleteOne: (...params) => {
-      if (params.length > 0) db.run("DELETE FROM snapshots WHERE path = ?", params);
-      else db.run("DELETE FROM snapshots WHERE path = ?");
-    },
-    upsert: (...params) => {
-      db.run(
-        "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
-        "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at",
-        params
-      );
-    },
-  };
-
-  return {
-    store: { stmts, engine: "sql.js" },
-    close: () => { db.close(); },
-    transact: (fn) => {
-      db.run("BEGIN IMMEDIATE");
-      try { fn(); db.run("COMMIT"); save(); } catch (e) { db.run("ROLLBACK"); throw e; }
-    },
-    prepare: (sql) => {
-      const stmt = db.prepare(sql);
-      return {
-        run: (...params) => { stmt.bind(params); stmt.step(); stmt.reset(); },
-        free: () => { stmt.free(); },
-      };
-    },
-  };
+  return { db, stmts };
 }
 
-
-
-let backendPromise: Promise<void> | null = null;
-
-async function initBackend(): Promise<void> {
-  if (backendPromise) return backendPromise;
-  backendPromise = (async () => {
-    const hasBetter = await tryLoadBetter();
-    if (!hasBetter) await ensureSqlJs();
-  })();
-  return backendPromise;
-}
-
-
-
 export async function loadHashStore(): Promise<HashStore> {
   const storePath = hashStorePath();
-  if (cachedHandle && cachedHandle.path === storePath) {
-    return cachedHandle.handle.store;
+  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
+    return { stmts: cachedDb.stmts, engine: "node:sqlite" };
   }
 
   shutdownHashStore();
 
   await initHasher();
   await mkdir(hashStoreDir(), { recursive: true });
-  await initBackend();
 
   const existed = existsSync(storePath);
+  const { db, stmts } = openDb(storePath);
 
-  let handle: BackendHandle;
-  if (BetterDatabase) {
-    try {
-      handle = openBetterDb(storePath);
-    } catch {
-      const debug = process.env.PI_HASHLINE_DEBUG === "1" || process.env.PI_HASHLINE_DEBUG === "true";
-      if (debug) {
-        console.error('better-sqlite3 native binding failed, falling back to sql.js');
-      }
-      BetterDatabase = null;
-      await ensureSqlJs();
-      handle = openSqlJsDb(storePath);
-    }
-  } else {
-    await ensureSqlJs();
-    handle = openSqlJsDb(storePath);
+  if (!existed) {
+    await migrateLegacy(db);
   }
 
-  if (!existed) {
-    await migrateLegacy(handle);
+  cachedDb = { path: storePath, db, stmts };
+
+  if (!exitHandlerRegistered) {
+    exitHandlerRegistered = true;
+    process.once("exit", () => shutdownHashStore());
+    for (const sig of ["SIGINT", "SIGTERM"] as const) {
+      process.once(sig, () => {
+        shutdownHashStore();
+        process.kill(process.pid, sig);
+      });
+    }
   }
 
-  cachedHandle = { path: storePath, handle };
-  return handle.store;
+  return { stmts, engine: "node:sqlite" };
 }
 
 export function shutdownHashStore(): void {
-  if (cachedHandle) {
-    cachedHandle.handle.close();
-    cachedHandle = null;
+  if (cachedDb) {
+    try {
+      cachedDb.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    } catch {
+    }
+    cachedDb.db.close();
+    cachedDb = null;
   }
 }
 
-
-
-function withStore(store: HashStore, fn: () => void): void {
-  const h = cachedHandle?.handle;
-  if (h && h.store === store) {
-    h.transact(fn);
+function withStore(fn: () => void): void {
+  if (cachedDb) {
+    cachedDb.db.exec("BEGIN IMMEDIATE");
+    try {
+      fn();
+      cachedDb.db.exec("COMMIT");
+    } catch (e) {
+      cachedDb.db.exec("ROLLBACK");
+      throw e;
+    }
   } else {
     fn();
   }
 }
 
-async function migrateLegacy(handle: BackendHandle): Promise<void> {
+async function migrateLegacy(db: DatabaseSync): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
   try {
@@ -283,20 +160,23 @@ async function migrateLegacy(handle: BackendHandle): Promise<void> {
     rows.push([
       key,
       contentChecksum(value.content),
-      value.content.split("\n").length,
+      splitLines(value.content).length,
       JSON.stringify(value.hashes),
       Date.now(),
     ]);
   }
-
   if (rows.length > 0) {
-    handle.transact(() => {
-      const stmt = handle.prepare(
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const stmt = db.prepare(
         "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
       );
       for (const row of rows) stmt.run(...row);
-      stmt.free();
-    });
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
   }
 
   try {
@@ -306,15 +186,13 @@ async function migrateLegacy(handle: BackendHandle): Promise<void> {
   }
 }
 
-
-
 export function getSnapshot(
   store: HashStore,
   path: string,
   content: string,
 ): string[] | undefined {
   const checksum = contentChecksum(content);
-  const lineCount = content.split("\n").length;
+  const lineCount = splitLines(content).length;
   const row = store.stmts.get(path, checksum, lineCount);
   return row ? (JSON.parse(row.hashes as string) as string[]) : undefined;
 }
@@ -327,13 +205,13 @@ export function upsertSnapshot(
   hashes: string[],
 ): void {
   const hashesJson = JSON.stringify(hashes);
-  withStore(store, () => {
+  withStore(() => {
     store.stmts.upsert(path, checksum, lineCount, hashesJson, Date.now());
   });
 }
 
 export function deleteSnapshot(store: HashStore, path: string): void {
-  withStore(store, () => {
+  withStore(() => {
     store.stmts.deleteOne(path);
   });
 }
@@ -349,7 +227,7 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     }
   }
   if (missing.length === 0) return;
-  withStore(store, () => {
+  withStore(() => {
     for (const path of missing) store.stmts.deleteOne(path);
   });
 }

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf, visLines, lastNonEmptyIndex, firstNonEmptyIndex } from "../utils";
+import { abortIf, splitLines, lastNonEmptyIndex, firstNonEmptyIndex } from "../utils";
 import { _lineHashesPure, HASH_SEP } from "./hash";
 import {
 	valEdits,
@@ -18,22 +18,22 @@ type LIdx = {
 };
 
 export function buildIdx(content: string): LIdx {
-	const fileLines = content.split("\n");
-	const lineStarts: number[] = [];
-	let offset = 0;
-
-	for (let index = 0; index < fileLines.length; index++) {
-		lineStarts.push(offset);
-		offset += fileLines[index]!.length;
-		if (index < fileLines.length - 1) {
-			offset += 1;
-		}
-	}
+  const fileLines = splitLines(content);
+  const lineStarts: number[] = [];
+  let offset = 0;
+
+  for (let index = 0; index < fileLines.length; index++) {
+    lineStarts.push(offset);
+    offset += fileLines[index]!.length;
+    if (index < fileLines.length - 1) {
+      offset += 1;
+    }
+  }
 
-	return {
-		fileLines,
-		lineStarts,
-	};
+  return {
+    fileLines,
+    lineStarts,
+  };
 };
 
 type RESpan = {
@@ -124,16 +124,26 @@ function resToSpan(
     };
   }
 
+  if (content.endsWith("\n")) {
+    return {
+      kind: "replace",
+      index,
+      label,
+      start: lineStarts[startLine - 1]!,
+      end: content.length,
+      replacement: "",
+    };
+  }
+
   return {
     kind: "replace",
     index,
     label,
     start: Math.max(0, lineStarts[startLine - 1]! - 1),
-    end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
+    end: content.length,
     replacement: "",
   };
 }
-
 function assertNoConflict(spans: RESpan[]): void {
 	for (let leftIndex = 0; leftIndex < spans.length; leftIndex++) {
 		const left = spans[leftIndex]!;
@@ -375,14 +385,14 @@ export function changedRange(
 	if (original.length === 0) {
 		return {
 			firstChangedLine: 1,
-			lastChangedLine: visLines(result).length,
+			lastChangedLine: splitLines(result).length,
 		};
 	}
 
 	if (result.startsWith(original) && original.endsWith("\n")) {
 		return {
-			firstChangedLine: visLines(original).length + 1,
-			lastChangedLine: visLines(result).length,
+			firstChangedLine: splitLines(original).length + 1,
+			lastChangedLine: splitLines(result).length,
 		};
 	}
 
@@ -415,7 +425,7 @@ export function changedRange(
 	const firstChangedLine = idxToLine(firstDiff + 1, result);
 	let lastChangedLine: number;
 	if (lastRes < firstDiff) {
-		lastChangedLine = result.length === 0 ? 1 : visLines(result).length;
+		lastChangedLine = result.length === 0 ? 1 : splitLines(result).length;
 	} else if (
 		firstDiff === 0 &&
 		original.length > 0 &&

package/src/hashline/hash.ts

@@ -1,4 +1,4 @@
-import { MAX_HASH_RETRIES } from "../constants";
+import { splitLines } from "../utils";
 import {
   loadHashStore,
   type HashStore,
@@ -6,7 +6,6 @@ import {
   upsertSnapshot,
 } from "../hash-store";
 import { xxh32, contentChecksum, initHasher } from "./hasher";
-
 export { initHasher };
 
 export const HASH_LEN = 3;
@@ -22,21 +21,19 @@ const ALPH_SAFE = ALPH.replace(/-/g, "\\-");
 const ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);
 export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
 
-function h2s(h: number): string {
-	const totalBits = HASH_LEN * ALPH_BITS;
-	const shift = 32 - totalBits;
-	const n = h >>> shift;
-	let out = "";
-	for (let j = 0; j < HASH_LEN; j++) {
-		out +=
-			ALPH[
-				(n >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) &
-					ALPH_MASK
-			]!;
-	}
-	return out;
+function idxToHash(idx: number): string {
+  let out = "";
+  for (let j = 0; j < HASH_LEN; j++) {
+    out += ALPH[(idx >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) & ALPH_MASK]!;
+  }
+  return out;
 }
 
+const HASH_TABLE: string[] = Array.from(
+  { length: 262_144 },
+  (_, i) => idxToHash(i),
+);
+
 export const HL_PREFIX_RE = new RegExp(
 	`^\\s*(?:>>>|>>)?\\s*${HASH_CLASS}│`,
 );
@@ -47,33 +44,85 @@ export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
 
-
 function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
-function nextUniqueHash(content: string, used: Set<string>): string {
-	let retry = 0;
-	let hash = h2s(xxh32(content));
-	while (used.has(hash)) {
-		retry++;
-		if (retry > MAX_HASH_RETRIES) throw new Error("Hash space exhausted");
-		hash = h2s(xxh32(`${content}:R${retry}`));
-	}
-	used.add(hash);
-	return hash;
+const BITSET_WORDS = 8192;
+
+function getBit(bits: Uint32Array, idx: number): boolean {
+  return (bits[idx >>> 5] >>> (idx & 31) & 1) !== 0;
+}
+
+function setBit(bits: Uint32Array, idx: number): void {
+  bits[idx >>> 5] |= 1 << (idx & 31);
+}
+
+function nextZeroBit(bits: Uint32Array, start: number): number {
+  const totalWords = bits.length;
+  const totalBits = totalWords * 32;
+
+  if (start >= totalBits) start = 0;
+
+  const wordIdx = start >>> 5;
+  const bitOffset = start & 31;
+
+  let word = bits[wordIdx];
+  for (let b = bitOffset; b < 32; b++) {
+    if ((word >>> b & 1) === 0) return wordIdx * 32 + b;
+  }
+
+  for (let w = wordIdx + 1; w < totalWords; w++) {
+    word = bits[w];
+    if (~word !== 0) {
+      for (let b = 0; b < 32; b++) {
+        if ((word >>> b & 1) === 0) return w * 32 + b;
+      }
+    }
+  }
+
+  for (let w = 0; w < wordIdx; w++) {
+    word = bits[w];
+    if (~word !== 0) {
+      for (let b = 0; b < 32; b++) {
+        if ((word >>> b & 1) === 0) return w * 32 + b;
+      }
+    }
+  }
+
+  word = bits[wordIdx];
+  for (let b = 0; b < bitOffset; b++) {
+    if ((word >>> b & 1) === 0) return wordIdx * 32 + b;
+  }
+
+  throw new Error("Hash space exhausted");
+}
+
+function assignHash(used: Uint32Array, baseIdx: number, hint: { value: number }): string {
+  if (!getBit(used, baseIdx)) {
+    setBit(used, baseIdx);
+    hint.value = baseIdx + 1;
+    return HASH_TABLE[baseIdx];
+  }
+  const start = hint.value > baseIdx + 1 ? hint.value : baseIdx + 1;
+  const nextIdx = nextZeroBit(used, start);
+  setBit(used, nextIdx);
+  hint.value = nextIdx + 1;
+  return HASH_TABLE[nextIdx];
 }
 
 export function _lineHashesPure(content: string): string[] {
-	const lines = content.split("\n");
-	const hashes = new Array<string>(lines.length);
-	const assigned = new Set<string>();
-	for (let i = 0; i < lines.length; i++) {
-		const c = canon(lines[i]!);
-		const hash = nextUniqueHash(c, assigned);
-		hashes[i] = hash;
-	}
-	return hashes;
+  const lines = splitLines(content);
+  const hashes = new Array<string>(lines.length);
+  const used = new Uint32Array(BITSET_WORDS);
+  const hint = { value: 0 };
+
+  for (let i = 0; i < lines.length; i++) {
+    const c = canon(lines[i]!);
+    const baseIdx = xxh32(c) >>> 14;
+    hashes[i] = assignHash(used, baseIdx, hint);
+  }
+  return hashes;
 }
 
 export async function lineHashes(
@@ -96,7 +145,7 @@ export async function lineHashes(
       previous.removedHashes,
     );
     if (persist !== false) {
-      upsertSnapshot(hashStore, path, contentChecksum(content), content.split("\n").length, newHashes);
+      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
     }
     return newHashes;
   }
@@ -108,23 +157,41 @@ export async function lineHashes(
 
   const newHashes = _lineHashesPure(content);
   if (persist !== false) {
-    upsertSnapshot(hashStore, path, contentChecksum(content), content.split("\n").length, newHashes);
+    upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
   }
   return newHashes;
 }
 
+function hashToIndex(hash: string): number {
+  let idx = 0;
+  for (let j = 0; j < HASH_LEN; j++) {
+    const charIdx = ALPH.indexOf(hash[j]!);
+    if (charIdx < 0) return -1;
+    idx = (idx << ALPH_BITS) | charIdx;
+  }
+  return idx;
+}
+
 function mapStableHashes(
   oldContent: string,
   oldHashes: string[],
   newContent: string,
   removedHashes?: Set<string>,
 ): string[] {
-  const newLines = newContent.split("\n");
+  const newLines = splitLines(newContent);
   const newHashes = new Array<string>(newLines.length);
-  const used = new Set<string>();
+  const used = new Uint32Array(BITSET_WORDS);
+  const hint = { value: 0 };
+
+  if (removedHashes) {
+    for (const hash of removedHashes) {
+      const idx = hashToIndex(hash);
+      if (idx >= 0) setBit(used, idx);
+    }
+  }
 
   const contentMap = new Map<string, { index: number; hash: string }[]>();
-  const oldLines = oldContent.split("\n");
+  const oldLines = splitLines(oldContent);
   for (let i = 0; i < oldLines.length; i++) {
     const line = oldLines[i]!;
     const entry = { index: i, hash: oldHashes[i]! };
@@ -155,14 +222,18 @@ function mapStableHashes(
     if (removedHashes?.has(candidates[bestIdx]!.hash)) continue;
     const match = candidates.splice(bestIdx, 1)[0]!;
     newHashes[i] = match.hash;
-    used.add(match.hash);
+    const matchIdx = hashToIndex(match.hash);
+    if (matchIdx >= 0) {
+      setBit(used, matchIdx);
+      if (matchIdx + 1 > hint.value) hint.value = matchIdx + 1;
+    }
   }
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
     const c = canon(newLines[i]!);
-    const hash = nextUniqueHash(c, used);
-    newHashes[i] = hash;
+    const baseIdx = xxh32(c) >>> 14;
+    newHashes[i] = assignHash(used, baseIdx, hint);
   }
   return newHashes;
 }

package/src/replace-undo.ts

@@ -7,7 +7,7 @@ import { contentChecksum } from "./hashline/hasher";
 import { resolveTarget, writeAtomic } from "./fs-write";
 import { toCwd } from "./paths";
 import { toLF, stripBOM, genDiff, restoreEndings } from "./replace-diff";
-import { cntDiff } from "./utils";
+import { cntDiff, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { buildMetrics } from "./replace-response";
 export interface UndoEntry {
@@ -84,7 +84,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         );
 
         const store = await loadHashStore();
-        upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), undo.content.split("\n").length, undo.hashes);
+        upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
 
         clearUndo(mutationTargetPath);
 

package/src/replace.ts

@@ -148,6 +148,7 @@ export function assertReq(
     throw new Error('[E_BAD_SHAPE] Edit request requires a "changes" array. Each change is { content_lines: [...], hash_range_inclusive: ["<START>", "<END>"] }.');
   }
 }
+
 export interface ExecPipelineOptions {
   accessMode?: number;
   signal?: AbortSignal;
@@ -155,6 +156,46 @@ export interface ExecPipelineOptions {
   noPersist?: boolean;
 }
 
+function collectRemovedHashes(
+  resolved: { hash_range_inclusive: [{ hash: string }, { hash: string }] }[],
+  originalHashes: string[],
+): Set<string> {
+  const removedHashes = new Set<string>();
+  for (const edit of resolved) {
+    const startHash = edit.hash_range_inclusive[0].hash;
+    const endHash = edit.hash_range_inclusive[1].hash;
+    const startLine = originalHashes.indexOf(startHash);
+    const endLine = originalHashes.indexOf(endHash);
+    if (startLine >= 0 && endLine >= 0) {
+      for (let i = startLine; i <= endLine; i++) {
+        removedHashes.add(originalHashes[i]!);
+      }
+    }
+  }
+  return removedHashes;
+}
+
+function countLineChanges(
+  resolved: { hash_range_inclusive: [{ hash: string }, { hash: string }]; content_lines: string[] }[],
+  originalHashes: string[],
+  noopEdits: { editIndex: number }[] | undefined,
+): { totalAddedLines: number; totalRemovedLines: number } {
+  let totalAddedLines = 0;
+  let totalRemovedLines = 0;
+  const noopIndices = new Set(noopEdits?.map((n) => n.editIndex) ?? []);
+  for (let i = 0; i < resolved.length; i++) {
+    if (noopIndices.has(i)) continue;
+    const edit = resolved[i]!;
+    const startLine = originalHashes.indexOf(edit.hash_range_inclusive[0].hash);
+    const endLine = originalHashes.indexOf(edit.hash_range_inclusive[1].hash);
+    if (startLine >= 0 && endLine >= 0) {
+      totalRemovedLines += endLine - startLine + 1;
+    }
+    totalAddedLines += edit.content_lines.length;
+  }
+  return { totalAddedLines, totalRemovedLines };
+}
+
 export async function execPipeline(
   params: ReqParams,
   cwd: string,
@@ -187,18 +228,7 @@ export async function execPipeline(
 
   const result = anchorResult.content;
 
-  const removedHashes = new Set<string>();
-  for (const edit of resolved) {
-    const startHash = edit.hash_range_inclusive[0].hash;
-    const endHash = edit.hash_range_inclusive[1].hash;
-    const startLine = originalHashes.indexOf(startHash);
-    const endLine = originalHashes.indexOf(endHash);
-    if (startLine >= 0 && endLine >= 0) {
-      for (let i = startLine; i <= endLine; i++) {
-        removedHashes.add(originalHashes[i]!);
-      }
-    }
-  }
+  const removedHashes = collectRemovedHashes(resolved, originalHashes);
 
   const noPersist = options?.noPersist;
   const resultHashes = await lineHashes(result, absolutePath, {
@@ -209,19 +239,9 @@ export async function execPipeline(
 
   const warnings = [...(anchorResult.warnings ?? [])];
 
-  let totalAddedLines = 0;
-  let totalRemovedLines = 0;
-  const noopIndices = new Set(anchorResult.noopEdits?.map((n) => n.editIndex) ?? []);
-  for (let i = 0; i < resolved.length; i++) {
-    if (noopIndices.has(i)) continue;
-    const edit = resolved[i]!;
-    const startLine = originalHashes.indexOf(edit.hash_range_inclusive[0].hash);
-    const endLine = originalHashes.indexOf(edit.hash_range_inclusive[1].hash);
-    if (startLine >= 0 && endLine >= 0) {
-      totalRemovedLines += endLine - startLine + 1;
-    }
-    totalAddedLines += edit.content_lines.length;
-  }
+  const { totalAddedLines, totalRemovedLines } = countLineChanges(
+    resolved, originalHashes, anchorResult.noopEdits,
+  );
 
   return {
     path,
@@ -289,6 +309,7 @@ export function reuseMarkdown(context: any, content: string, theme: any): Markdo
   m.setText(content);
   return m;
 }
+
 const MODE_CFG = {
   flat: {
     desc: " Only one edit per call. The `hash_range_inclusive` and `content_lines` fields sit at the top level of the request object.",
@@ -435,7 +456,6 @@ export function buildToolDef(opts: { flat: boolean; autoRead?: boolean }): ToolD
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
 
-
       const normalizedParams = canonical as { path: string; changes: HTEdit[] };
       const path = normalizedParams.path;
       const absolutePath = toCwd(path, ctx.cwd);

package/src/utils.ts

@@ -6,6 +6,12 @@ export function has(record: Record<string, unknown>, key: string): boolean {
 	return Object.hasOwn(record, key);
 }
 
+export function splitLines(text: string): string[] {
+  if (text.length === 0) return [""];
+  const lines = text.split("\n");
+  return text.endsWith("\n") ? lines.slice(0, -1) : lines;
+}
+
 export function visLines(text: string): string[] {
   if (text.length === 0) return [];
   const lines = text.split("\n");

package/scripts/cleanup-better-sqlite3.cjs

@@ -1,21 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-function cleanNodeModules(nm) {
-  if (!fs.existsSync(nm)) return;
-  const entries = fs.readdirSync(nm, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".better-sqlite3-")) {
-      const full = path.join(nm, entry.name);
-      try {
-        fs.rmSync(full, { recursive: true, force: true });
-        console.error("Cleaned up stale better-sqlite3 build artifact:", entry.name);
-      } catch {
-      }
-    }
-  }
-}
-
-const pkgDir = path.resolve(__dirname, "..");
-cleanNodeModules(path.resolve(pkgDir, "node_modules"));
-cleanNodeModules(path.resolve(pkgDir, ".."));

package/scripts/ensure-better-sqlite3.cjs

@@ -1,60 +0,0 @@
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const root = path.resolve(__dirname, "..");
-const bsqlDir = path.join(root, "node_modules", "better-sqlite3");
-
-function removeStaleArtifacts() {
-  for (const dir of [root, bsqlDir]) {
-    if (!fs.existsSync(dir)) continue;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".better-sqlite3-")) {
-        const full = path.join(dir, entry.name);
-        try {
-          fs.rmSync(full, { recursive: true, force: true });
-          console.error("Removed stale artifact:", entry.name);
-        } catch {
-        }
-      }
-    }
-  }
-  const buildDir = path.join(bsqlDir, "build");
-  if (fs.existsSync(buildDir)) {
-    fs.rmSync(buildDir, { recursive: true, force: true });
-  }
-}
-
-try {
-  require(bsqlDir);
-  process.exit(0);
-} catch (e) {
-  const msg = e && typeof e.message === "string" ? e.message : String(e);
-  if (/GLIBC|Cannot find module|dlo|not found/i.test(msg)) {
-    console.error("better-sqlite3 prebuilt incompatible, rebuilding from source...");
-    removeStaleArtifacts();
-    const prebuildDir = path.join(bsqlDir, "prebuilds");
-    if (fs.existsSync(prebuildDir)) {
-      const platform = process.platform + "-" + process.arch;
-      const prebuilt = path.join(prebuildDir, platform + ".node");
-      if (fs.existsSync(prebuilt)) {
-        fs.unlinkSync(prebuilt);
-        console.error("Removed incompatible prebuilt:", platform + ".node");
-      }
-    }
-
-    try {
-      execSync("npx --yes node-gyp rebuild", {
-        cwd: bsqlDir,
-        stdio: "inherit",
-        timeout: 300000,
-      });
-      console.error("better-sqlite3 rebuilt successfully from source.");
-    } catch (rebuildErr) {
-      console.error("better-sqlite3 rebuild failed:", rebuildErr.message);
-      console.error("Will fall back to sql.js at runtime.");
-      process.exit(0);
-    }
-  }
-}