pi-supernova 0.5.0 → 0.7.0

package/src/context/ledger.js

@@ -39,19 +39,23 @@ function newHistory() {
 // Experimental candidate collection, not proof of provider-visible retention:
 // AgentMessage metadata and later context transformations can hide these strings.
 // Keep this optimization opt-in until exact outgoing citation targets are validated.
-function collectRetained(value, retained, depth = 0) {
-  if (isString(value)) {
-    // Every line, not only substantive ones. A run may span a blank or short line,
-    // so isRetained must be exact per line or the run truncates there. An oversized
-    // line is never stored: it cannot sit inside a six-line run, and this is what
-    // keeps base64 image payloads out of the retention set.
-    if (value.length > MAX_OBSERVED_LINE && !value.includes("\n")) return;
+function retainString(value, retained) {
+  // Every line, not only substantive ones. A run may span a blank or short line,
+  // so isRetained must be exact per line or the run truncates there. An oversized
+  // line is never stored: it cannot sit inside a six-line run, and this is what
+  // keeps base64 image payloads out of the retention set.
+  if (value.length > MAX_OBSERVED_LINE && !value.includes("\n")) return;
 
-    for (const line of value.split("\n")) {
-      if (retained.size >= MAX_STORED_LINES) return;
+  for (const line of value.split("\n")) {
+    if (retained.size >= MAX_STORED_LINES) return;
 
-      if (line.length <= MAX_OBSERVED_LINE) retained.add(line);
-    }
+    if (line.length <= MAX_OBSERVED_LINE) retained.add(line);
+  }
+}
+
+function collectRetained(value, retained, depth = 0) {
+  if (isString(value)) {
+    retainString(value, retained);
 
     return;
   }
@@ -174,7 +178,7 @@ export class SeenLedger {
     return count;
   }
 
-  longestRun(lines, hashes, index, call) {
+  bestCandidateRun(lines, hashes, index, call) {
     const candidates = this.occurrences.get(hashes[index]);
 
     if (!candidates) return null;
@@ -186,12 +190,23 @@ export class SeenLedger {
       if (length >= MIN_RUN && (!best || length > best.length)) best = { ...candidate, length };
     }
 
-    if (!best) return null;
+    return best;
+  }
+
+  substantiveCount(lines, index, length) {
     let count = 0;
 
-    for (let i = index; i < index + best.length; i++) if (collapsible(lines[i])) count++;
+    for (let i = index; i < index + length; i++) if (collapsible(lines[i])) count++;
 
-    return count >= MIN_SUBSTANTIVE ? best : null;
+    return count;
+  }
+
+  longestRun(lines, hashes, index, call) {
+    const best = this.bestCandidateRun(lines, hashes, index, call);
+
+    if (!best) return null;
+
+    return this.substantiveCount(lines, index, best.length) >= MIN_SUBSTANTIVE ? best : null;
   }
 
   citation(lines, index, run) {
@@ -245,19 +260,14 @@ export class SeenLedger {
     return sent;
   }
 
-  remember(call, lines) {
-    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
-
-    if (this.results.has(call)) this.forget(call);
-
+  evictForCapacity(incoming) {
     for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
-      if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
+      if (this.storedLines + incoming <= MAX_STORED_LINES) break;
       this.forget(old);
     }
+  }
 
-    const hashes = Uint32Array.from(lines, hashLine);
-    const origins = lines.map(line => this.origins.get(line));
-
+  indexCollapsible(lines, hashes, call) {
     for (let i = 0; i < lines.length; i++) {
       if (!collapsible(lines[i])) continue;
       let list = this.occurrences.get(hashes[i]);
@@ -265,7 +275,16 @@ export class SeenLedger {
       if (!list) this.occurrences.set(hashes[i], (list = []));
       list.push({ call, index: i });
     }
+  }
+
+  remember(call, lines) {
+    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
 
+    if (this.results.has(call)) this.forget(call);
+    this.evictForCapacity(lines.length);
+    const hashes = Uint32Array.from(lines, hashLine);
+    const origins = lines.map(line => this.origins.get(line));
+    this.indexCollapsible(lines, hashes, call);
     this.results.set(call, { hashes, lines, origins });
     this.history.storedLines += lines.length;
   }

package/src/context/outline.js

@@ -28,6 +28,7 @@ function relevance(span, lower, stems) {
 }
 
 function chooseExpanded(spans, lower, stems, raw, opts) {
+  if (stems.length === 0) return new Set();
   const scored = spans.map((s, i) => ({ i, r: relevance(s, lower, stems), chars: raw.slice(s.start - 1, s.end).join("\n").length }));
   scored.sort((a, b) => b.r - a.r || a.i - b.i);
   const expanded = new Set();
@@ -96,16 +97,7 @@ function focusedText(raw, lower, stems, relPath, opts) {
  * @param entry index entry (text + cached lines/surface)
  * @param about question or symbol; empty ⇒ pure skeleton (every body folded)
  */
-export function outlineFile(entry, relPath, about, options = {}) {
-  const opts = { ...OUTLINE_DEFAULTS, ...options };
-  const { raw, lower } = WorkspaceIndex.linesOf(entry);
-  const lineCount = raw.length;
-  const spans = WorkspaceIndex.spansOf(entry).map((s) => ({ ...s, signature: raw[s.start - 1].trim() }));
-  const stems = [...new Set(tokenizeQuery(about || "").tokens.map(stem))];
-
-  if (spans.length === 0) return about ? focusedText(raw, lower, stems, relPath, opts) : null;
-  const expanded = chooseExpanded(spans, lower, stems, raw, opts);
-
+function outlineHeader(spans, raw, opts) {
   const parts = [];
   const headerEnd = Math.min(spans[0].start - 1, opts.headerLines);
 
@@ -117,8 +109,30 @@ export function outlineFile(entry, relPath, about, options = {}) {
     if (spans[0].start - 1 > opts.headerLines) parts.push("      … " + (spans[0].start - 1 - opts.headerLines) + " more header lines");
   }
 
+  return parts;
+}
+
+function clipOutline(text, title, maxChars) {
+  if (text.length <= maxChars) return text;
+  const end = text.lastIndexOf("\n", Math.max(0, maxChars - 160));
+
+  return (end > title.length ? text.slice(0, end) : text.slice(0, maxChars)) + "\n      … outline truncated; use read(path, line, count) for later declarations";
+}
+
+export function outlineFile(entry, relPath, about, options = {}) {
+  const opts = { ...OUTLINE_DEFAULTS, ...options };
+  const { raw, lower } = WorkspaceIndex.linesOf(entry);
+  const lineCount = raw.length;
+  const spans = WorkspaceIndex.spansOf(entry).map((s) => ({ ...s, signature: raw[s.start - 1].trim() }));
+  const stems = [...new Set(tokenizeQuery(about || "").tokens.map(stem))];
+
+  if (spans.length === 0) return about ? focusedText(raw, lower, stems, relPath, opts) : null;
+  const expanded = chooseExpanded(spans, lower, stems, raw, opts);
+  const parts = outlineHeader(spans, raw, opts);
+
   for (let i = 0; i < spans.length; i++) parts.push(expanded.has(i) ? expandedBlock(spans[i], raw, opts) : foldedLine(spans[i]));
-  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (about ? " for \"" + about + "\"" : "") + " · read(path, line, count) for a folded body";
+  const label = about ? String(about).replace(/\s+/g, " ").slice(0, 120) : "";
+  const title = "// " + relPath + " · " + lineCount + " lines · " + spans.length + " declarations · " + expanded.size + " expanded" + (label ? " for \"" + label + "\"" : "") + " · read(path, line, count) for a folded body";
 
-  return { text: title + "\n" + parts.join("\n"), expanded: expanded.size, declarations: spans.length };
+  return { text: clipOutline(title + "\n" + parts.join("\n"), title, opts.maxChars), expanded: expanded.size, declarations: spans.length };
 }

package/src/context/repo-index.js

@@ -21,6 +21,7 @@ const WATCH_DEBOUNCE_MS = 150;
 const MAX_INDEXED_FILES = 4000;
 
 const MAX_FILE_BYTES = 512 * 1024;
+const MAX_ENTRY_CACHE_BYTES = 64 * 1024 * 1024;
 
 const BINARY_EXT = new Set([
   ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tgz", ".tar", ".bz2", ".xz", ".7z",
@@ -34,11 +35,13 @@ const IDENT_TOKEN = /[A-Za-z_$][\w$]*/g;
 
 const EMPTY = Object.freeze([]);
 
-const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)/;
+const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(?:(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)|([A-Z][A-Z0-9_$]*)\s*(?::[^=\n]+)?=)/;
 
-/** Declared identifier on a line (function/class/const/…), or ""; the same rule snap and grep use. */
+/** Declared identifier on a line (function/class/UPPER_CASE constant/…), or ""; the same rule snap and grep use. */
 export function declaredName(line) {
-  return DEF_PATTERN.exec(String(line).trim())?.[2] ?? "";
+  const match = DEF_PATTERN.exec(String(line).trim());
+
+  return match?.[2] ?? match?.[3] ?? "";
 }
 
 function isTextCandidate(filePath) {
@@ -71,7 +74,9 @@ function globGroup(glob, i, open) {
 
   if (end < 0) throw new SyntaxError("unclosed " + open + " in glob");
   const inner = glob.slice(i + 1, end);
-  const source = open === "{" ? "(?:" + inner.split(",").map(globBody).join("|") + ")" : "[" + inner + "]";
+  const source = open === "{"
+    ? "(?:" + inner.split(",").map(globBody).join("|") + ")"
+    : "[" + (inner.startsWith("!") ? "^" + inner.slice(1) : inner) + "]";
 
   return [source, end + 1];
 }
@@ -96,35 +101,41 @@ export function globToRegExp(glob) {
   return new RegExp(glob.includes("/") ? "^" + body + "$" : "(?:^|/)" + body + "$");
 }
 
-function declarationEnd(raw, lower, start, lineCount, ext) {
-  if (ext === ".py") {
-    const indentOf = (i) => raw[i].length - raw[i].trimStart().length;
-    const base = indentOf(start - 1);
-    let end = start;
-
-    for (let i = start; i < lineCount; i++) {
-      if (lower[i] === "") { end = i + 1; continue; }
-      if (indentOf(i) <= base) break;
-      end = i + 1;
-    }
+function lineIndent(raw, i) {
+  return raw[i].length - raw[i].trimStart().length;
+}
 
-    return Math.min(end, lineCount);
+function pythonDeclarationEnd(raw, lower, start, lineCount) {
+  const base = lineIndent(raw, start - 1);
+  let end = start;
+
+  for (let i = start; i < lineCount; i++) {
+    if (lower[i] === "") { end = i + 1; continue; }
+    if (lineIndent(raw, i) <= base) break;
+    end = i + 1;
   }
 
+  return Math.min(end, lineCount);
+}
+
+function braceDelta(text) {
   let depth = 0;
 
-  for (const ch of raw[start - 1] ?? "") {
+  for (const ch of text) {
     if (ch === "{") depth++;
     else if (ch === "}") depth--;
   }
 
+  return depth;
+}
+
+function braceDeclarationEnd(raw, start, lineCount) {
+  let depth = braceDelta(raw[start - 1] ?? "");
+
   if (depth <= 0) return start;
 
   for (let i = start; i < raw.length; i++) {
-    for (const ch of raw[i]) {
-      if (ch === "{") depth++;
-      else if (ch === "}") depth--;
-    }
+    depth += braceDelta(raw[i]);
 
     if (depth <= 0) return i + 1;
   }
@@ -132,11 +143,95 @@ function declarationEnd(raw, lower, start, lineCount, ext) {
   return lineCount;
 }
 
+function declarationEnd(raw, lower, start, lineCount, ext) {
+  if (ext === ".py") return pythonDeclarationEnd(raw, lower, start, lineCount);
+
+  return braceDeclarationEnd(raw, start, lineCount);
+}
+
+function readFdBuffer(fd, buffer) {
+  let offset = 0;
+
+  while (offset < buffer.length) {
+    const read = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+
+    if (read <= 0) break;
+    offset += read;
+  }
+
+  return offset;
+}
+
+function parseRgFiles(res, root) {
+  let error;
+
+  if (res.exitCode !== 0 && res.exitCode !== 1) error = res.stderr.trim() || "rg exited with status " + res.exitCode;
+  const truncated = res.outputTruncated === true;
+  const output = truncated && !res.stdout.endsWith("\n") ? res.stdout.slice(0, res.stdout.lastIndexOf("\n") + 1) : res.stdout;
+
+  return { files: output.split("\n").flatMap(f => f ? [path.resolve(root, f)] : []).sort(), error, truncated, missing: false };
+}
+
+function addPorcelainRow(rows, i, set) {
+  const row = rows[i];
+
+  if (row.length <= 3) return i;
+  const status = row.slice(0, 2);
+  const file = row.slice(3);
+
+  if (file) set.add(file);
+
+  if ((status.includes("R") || status.includes("C")) && i + 1 < rows.length) {
+    const target = rows[i + 1];
+
+    if (target) set.add(target);
+
+    return i + 1;
+  }
+
+  return i;
+}
+
+function ingestPorcelain(stdout, set) {
+  const rows = stdout.split("\0");
+
+  for (let i = 0; i < rows.length; i++) i = addPorcelainRow(rows, i, set);
+}
+
+function grepPendingHuge(pending, rel, regex, out) {
+  let start = 0;
+  let line = 0;
+
+  while (start <= pending.length) {
+    const end = pending.indexOf("\n", start);
+    const stop = end === -1 ? pending.length : end;
+    const text = pending.slice(start, stop).replace(/\r$/, "");
+
+    line++;
+    if (regex.test(text)) out.push({ rel, line, text, def: false });
+    if (end === -1) break;
+    start = end + 1;
+  }
+}
+
+function grepEntryRows(e, filePath, root, regex, nameRegex, out) {
+  const lineAnchored = /\^|\$/.test(regex.source.replace(/\\[\^$]|\[[^\]]*\]/g, ""));
+
+  if (!lineAnchored && !regex.test(e.text)) return;
+  const { raw, defNames } = WorkspaceIndex.linesOf(e);
+  const rel = relativeSlash(root, filePath);
+
+  for (let i = 0; i < raw.length; i++) {
+    if (regex.test(raw[i])) out.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && nameRegex.test(defNames[i]) });
+  }
+}
+
 export class WorkspaceIndex {
   constructor(runCommand) {
     this.runCommand = runCommand;
     this.lists = new Map();
     this.entries = new Map();
+    this.entryBytes = 0;
     this.watchers = new Map();
     this.frecency = new Frecency();
     this.gitModified = new Map(); // root → Set(relative "/"-joined paths)
@@ -145,6 +240,11 @@ export class WorkspaceIndex {
 
   invalidate() {
     this.lists.clear();
+    this.gitModified.clear();
+
+    for (const entry of this.entries.values()) this.entryBytes -= entry.weight ?? 0;
+    this.entries.clear();
+    this.entryBytes = 0;
   }
 
   /** fff frecency: every read/edit is an access; the newest one is the "current file" for distance penalties. */
@@ -153,6 +253,8 @@ export class WorkspaceIndex {
     this.lastTouched = relPath;
   }
 
+  getEntryBytes() { return this.entryBytes; }
+
   watch(root) {
     if (this.watchers.has(root)) return this.watchers.get(root);
     let ok = false;
@@ -166,12 +268,17 @@ export class WorkspaceIndex {
           timer = null;
           this.lists.clear();
           this.gitModified.delete(root);
+          this.entries.clear();
+          this.entryBytes = 0;
         }, WATCH_DEBOUNCE_MS);
+        timer.unref?.();
       });
 
       watcher.on("error", () => {
         this.watchers.set(root, false);
         this.lists.clear();
+        this.entries.clear();
+        this.entryBytes = 0;
       });
 
       if (isFunction(watcher.unref)) watcher.unref();
@@ -195,11 +302,7 @@ export class WorkspaceIndex {
     try {
       const res = await this.runCommand(["git", "status", "--porcelain", "-z", "--untracked-files=all"], { cwd: root, timeoutMs: 5_000 });
 
-      if (res.exitCode === 0) {
-        for (const row of res.stdout.split("\0")) {
-          if (row.length > 3) set.add(row.slice(3));
-        }
-      }
+      if (res.exitCode === 0) ingestPorcelain(res.stdout, set);
     } catch {}
 
     this.gitModified.set(root, set);
@@ -219,6 +322,21 @@ export class WorkspaceIndex {
     }
   }
 
+  async listFilesWithRg(root, includeHidden, signal) {
+    const args = ["rg", "--files"];
+
+    if (includeHidden) args.push("--hidden");
+    args.push("-g", "!.git/**", "-g", "!**/.git/**", "--", root);
+
+    try {
+      return parseRgFiles(await this.runCommand(args, { cwd: root, timeoutMs: 15_000, signal }), root);
+    } catch (err) {
+      signal?.throwIfAborted();
+
+      return { files: [], error: err.message, truncated: false, missing: !fs.existsSync(root) };
+    }
+  }
+
   /** Absolute, sorted file list for a root; gitignore-aware via rg; cached for LIST_TTL_MS. */
   async files(root, includeHidden = false, signal) {
     const key = root + "\0" + (includeHidden ? "h" : "");
@@ -226,65 +344,112 @@ export class WorkspaceIndex {
     const ttl = this.watch(root) ? WATCHED_TTL_MS : LIST_TTL_MS;
 
     if (cached && Date.now() - cached.at < ttl) return cached.files;
-    const args = ["rg", "--files"];
+    const listed = await this.listFilesWithRg(root, includeHidden, signal);
+    this.lists.set(key, { ...listed, at: Date.now() });
 
-    if (includeHidden) args.push("--hidden");
-    args.push("-g", "!.git/**", "-g", "!**/.git/**", root);
-    let files = [];
-    let error;
-    let truncated = false;
-    let missing = false;
+    return listed.files;
+  }
 
-    try {
-      const res = await this.runCommand(args, { cwd: root, timeoutMs: 15_000, signal });
+  dropCached(filePath) {
+    const previous = this.entries.get(filePath);
 
-      if (res.exitCode !== 0 && res.exitCode !== 1) error = res.stderr.trim() || "rg exited with status " + res.exitCode;
-      truncated = res.outputTruncated === true;
-      const output = truncated && !res.stdout.endsWith("\n") ? res.stdout.slice(0, res.stdout.lastIndexOf("\n") + 1) : res.stdout;
-      files = output.split("\n").filter(Boolean).map(f => path.resolve(root, f)).sort();
-    } catch (err) {
-      signal?.throwIfAborted();
-      error = err.message;
-      missing = !fs.existsSync(root);
-    }
+    if (previous) this.entryBytes -= previous.weight ?? 0;
+    this.entries.delete(filePath);
+  }
 
-    this.lists.set(key, { files, at: Date.now(), error, truncated, missing });
+  rejectEntry(filePath) {
+    this.dropCached(filePath);
 
-    return files;
+    return null;
   }
 
-  /** Cached {text, lower, ext, surface?} for a file, re-read when mtime/size changed. Null for unreadable, binary, or huge files. */
-  entry(filePath) {
-    if (!isTextCandidate(filePath)) return null;
-    let stat;
-
+  statOrNull(filePath) {
     try {
-      stat = fs.statSync(filePath);
+      return fs.statSync(filePath);
     } catch {
-      this.entries.delete(filePath);
-
       return null;
     }
+  }
 
-    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return null;
+  cachedHit(filePath, stat) {
     const cached = this.entries.get(filePath);
 
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached;
-    let text;
+    if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) return null;
+    this.entries.delete(filePath);
+    this.entries.set(filePath, cached);
+
+    return cached;
+  }
+
+  readFdText(filePath, fd) {
+    let actual = fs.fstatSync(fd);
+
+    if (!actual.isFile() || actual.size > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    // One reusable scratch read per index: allocating 512 KiB per file lets
+    // thousands of dead buffers pile up as RSS before a major GC notices.
+    this.scratchRead ??= Buffer.alloc(MAX_FILE_BYTES + 1);
+    const offset = readFdBuffer(fd, this.scratchRead);
+
+    if (offset > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    actual = fs.fstatSync(fd);
+
+    if (!actual.isFile() || actual.size !== offset) return this.rejectEntry(filePath);
+
+    return { text: this.scratchRead.subarray(0, offset).toString("utf8"), actual };
+  }
 
+  readIndexedText(filePath) {
     try {
-      text = fs.readFileSync(filePath, "utf8");
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NONBLOCK ?? 0));
+
+      try {
+        return this.readFdText(filePath, fd);
+      } finally { fs.closeSync(fd); }
     } catch {
-      return null;
+      return this.rejectEntry(filePath);
+    }
+  }
+
+  evictOverflow() {
+    while (this.entryBytes > MAX_ENTRY_CACHE_BYTES && this.entries.size > 1) {
+      const oldest = this.entries.keys().next().value;
+      const evicted = this.entries.get(oldest);
+
+      this.entries.delete(oldest);
+      this.entryBytes -= evicted?.weight ?? 0;
     }
+  }
 
-    if (text.includes("\0")) return null;
-    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+  storeCreated(filePath, loaded) {
+    const created = { text: loaded.text, lower: loaded.text.toLowerCase(), mtimeMs: loaded.actual.mtimeMs, size: loaded.actual.size, weight: Math.max(1, loaded.actual.size) * 2, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
+    this.dropCached(filePath);
     this.entries.set(filePath, created);
+    this.entryBytes += created.weight;
+    this.evictOverflow();
 
     return created;
   }
 
+  /** Cached {text, lower, ext, surface?} for a file, re-read when mtime/size changed. Null for unreadable, binary, or huge files. */
+  entry(filePath) {
+    if (!isTextCandidate(filePath)) return null;
+    const stat = this.statOrNull(filePath);
+
+    if (!stat) return this.rejectEntry(filePath);
+
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return this.rejectEntry(filePath);
+    const cached = this.cachedHit(filePath, stat);
+
+    if (cached) return cached;
+    const loaded = this.readIndexedText(filePath);
+
+    if (!loaded) return null;
+
+    if (loaded.text.includes("\0")) return this.rejectEntry(filePath);
+
+    return this.storeCreated(filePath, loaded);
+  }
+
   static fromText(filePath, text) {
     return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
   }
@@ -300,7 +465,8 @@ export class WorkspaceIndex {
     for (let i = 0; i < raw.length; i++) {
       const trimmed = raw[i].trim();
       lower[i] = trimmed.toLowerCase();
-      defNames[i] = DEF_PATTERN.exec(trimmed)?.[2].toLowerCase() ?? "";
+      const declared = DEF_PATTERN.exec(trimmed);
+      defNames[i] = (declared?.[2] ?? declared?.[3] ?? "").toLowerCase();
       idents[i] = trimmed.match(IDENT_TOKEN) || EMPTY;
     }
 
@@ -359,22 +525,27 @@ export class WorkspaceIndex {
     return hits;
   }
 
+  resolveGrepEntry(filePath, overlayText, root, regex, out) {
+    const pending = overlayText(filePath);
+
+    if (pending === undefined) return this.entry(filePath);
+
+    if (Buffer.byteLength(pending, "utf8") <= MAX_FILE_BYTES) return WorkspaceIndex.fromText(filePath, pending);
+    grepPendingHuge(pending, relativeSlash(root, filePath), regex, out);
+
+    return null;
+  }
+
   /** Structured grep rows {rel, line, text, def}; def marks lines whose declared name itself matches. */
   grepRows(files, regex, root, overlayText = () => undefined) {
     const out = [];
     const nameRegex = new RegExp(regex.source, "i");
 
     for (const filePath of files) {
-      const pending = overlayText(filePath);
-      const e = pending === undefined ? this.entry(filePath) : WorkspaceIndex.fromText(filePath, pending);
-
-      if (!e || !regex.test(e.text)) continue;
-      const { raw, defNames } = WorkspaceIndex.linesOf(e);
-      const rel = relativeSlash(root, filePath);
+      const e = this.resolveGrepEntry(filePath, overlayText, root, regex, out);
 
-      for (let i = 0; i < raw.length; i++) {
-        if (regex.test(raw[i])) out.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && nameRegex.test(defNames[i]) });
-      }
+      if (!e) continue;
+      grepEntryRows(e, filePath, root, regex, nameRegex, out);
     }
 
     return out;