mixdog 0.9.151 → 0.9.152

package/src/runtime/agent/orchestrator/tools/builtin/native-search-client.mjs

@@ -1,18 +1,22 @@
 // Resident native search: forwards rg-style windowed line requests to ONE
-// long-lived `mixdog-graph --serve-search` process. The server embeds the
-// ripgrep matcher/searcher/printer crates and is the only local-search backend.
-// Unsupported requests and server failures are explicit errors at the caller.
+// long-lived engine that embeds the ripgrep matcher/searcher/printer crates
+// and is the only local-search backend. Unsupported requests and server
+// failures are explicit errors at the caller.
+//
+// The engine is reached through one crash-isolated
+// `mixdog-graph --serve-search` child process.
+//
 // MIXDOG_SEARCH_SERVER=0 disables; MIXDOG_SEARCH_SERVER_BIN overrides the
-// binary (dev builds).
-import { spawn } from 'node:child_process';
+// executable.
 import { existsSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import { hiddenSpawnOpts } from '../../../../shared/spawn-flags.mjs';
+import {
+  bindChildLifecycle,
+  createNativeSearchTransport,
+} from './native-search-transport.mjs';
 import { reportRuntimeWorkerUnhealthy } from '../../../../shared/session-runtime-health.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { getPluginData } from '../../config.mjs';
 import { ensureGraphBinary } from '../graph-binary-fetcher.mjs';
-import { fuzzyRank, prepareFuzzyItems } from './fuzzy-match.mjs';
 
 const RESTART_BACKOFF_MS = 30_000;
 // Default request budget. Deliberately BELOW the read-only I/O watchdog in
@@ -28,7 +32,7 @@ const PROCESS_FAILURES_BEFORE_BACKOFF = 2;
 const SEARCH_TIMEOUT_RECYCLE_WINDOW_MS = 30_000;
 const SEARCH_TIMEOUT_BURST_MS = 1_000;
 
-let _server = null; // { child, pending: Map, sequence }
+let _server = null; // { transport, exited, pending: Map, sequence }
 let _binaryPath = undefined; // undefined = unresolved, null = unavailable
 let _lastFailureAt = 0;
 let _lastFailure = null;
@@ -149,11 +153,7 @@ function unavailableError() {
 }
 
 function _setServerReferenced(server, referenced) {
-  const method = referenced ? 'ref' : 'unref';
-  try { server?.child?.[method]?.(); } catch {}
-  try { server?.child?.stdin?.[method]?.(); } catch {}
-  try { server?.child?.stdout?.[method]?.(); } catch {}
-  try { server?.child?.stderr?.[method]?.(); } catch {}
+  try { server?.transport?.[referenced ? 'ref' : 'unref']?.(); } catch {}
 }
 
 function _resolveBinary() {
@@ -201,18 +201,18 @@ function _teardown(error, { countFailure = true, detail = '' } = {}) {
   for (const timer of server.cancelWatchdogs?.values?.() || []) clearTimeout(timer);
   server.cancelWatchdogs?.clear?.();
   try { server.resolveReady?.(false); } catch {}
-  try { server.child.kill(); } catch {}
+  try { server.transport.kill(); } catch {}
 }
 
 export async function shutdownNativeSearchServer(reason = 'process-exit', timeoutMs = 1_000) {
   const server = _server;
   if (!server) return true;
-  const child = server.child;
-  const exited = new Promise((resolve) => {
-    child.once('exit', () => resolve(true));
-    child.once('error', () => resolve(true));
-  });
-  try { child.stdin?.end?.(); } catch {}
+  const transport = server.transport;
+  // The exit promise is armed at attach time rather than here: the transport
+  // routes each event to exactly one handler, so a second listener registered
+  // now would displace the teardown wiring.
+  const exited = server.exited;
+  try { transport.end(); } catch {}
   _teardown(new Error(`native search server shutdown (${reason})`), { countFailure: false });
   _warmPromise = null;
   let timer;
@@ -224,20 +224,12 @@ export async function shutdownNativeSearchServer(reason = 'process-exit', timeou
   ]);
   if (timer) clearTimeout(timer);
   if (!stopped) {
-    try { child.kill('SIGKILL'); } catch {}
+    try { transport.kill('SIGKILL'); } catch {}
   }
   return stopped;
 }
 
-export function _bindNativeSearchServerLifecycle(child, { onError, onExit } = {}) {
-  if (!child?.on) return;
-  child.on('error', onError);
-  child.on('exit', onExit);
-  // ChildProcess stdin emits write failures asynchronously. A sync try/catch
-  // around stdin.write cannot catch EPIPE; without this listener the session
-  // runtime worker itself terminates and every active/queued turn is recovered.
-  child.stdin?.on?.('error', onError);
-}
+export { bindChildLifecycle as _bindNativeSearchServerLifecycle };
 
 function _ensureServer() {
   if (_server) return _server;
@@ -245,22 +237,26 @@ function _ensureServer() {
     _consecutiveProcessFailures >= PROCESS_FAILURES_BEFORE_BACKOFF
     && Date.now() - _lastFailureAt < RESTART_BACKOFF_MS
   ) return null;
-  const binary = _resolveBinary();
-  if (!binary) return null;
-  let child;
+  let transport;
   try {
-    child = spawn(binary, [process.cwd(), '--serve-search'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      ...hiddenSpawnOpts,
+    transport = createNativeSearchTransport({
+      binaryPath: _resolveBinary(),
+      cwd: process.cwd(),
     });
   } catch (error) {
     noteProcessFailure(processFailure(error, null, 'spawn failed'));
     return null;
   }
+  if (!transport) return null;
   let resolveReady;
   const ready = new Promise((resolve) => { resolveReady = resolve; });
+  // Armed here, not at shutdown: the transport routes each event to exactly
+  // one handler, so a listener added later would displace the teardown wiring.
+  let markExited;
+  const exited = new Promise((resolve) => { markExited = resolve; });
   const server = {
-    child,
+    transport,
+    exited,
     pending: new Map(),
     cancelWatchdogs: new Map(),
     sequence: 0,
@@ -270,11 +266,10 @@ function _ensureServer() {
     readyWaiters: 0,
     resolveReady,
   };
-  child.stderr?.on?.('data', (chunk) => {
+  transport.on('stderr', (chunk) => {
     server.stderrTail = `${server.stderrTail}${String(chunk || '')}`.slice(-8192);
   });
-  const lines = createInterface({ input: child.stdout });
-  lines.on('line', (line) => {
+  transport.on('line', (line) => {
     let message;
     try { message = JSON.parse(line); } catch { return; }
     if (message?.ready === true) {
@@ -297,24 +292,27 @@ function _ensureServer() {
     clearProcessFailures();
     pending.resolve(message);
   });
-  _bindNativeSearchServerLifecycle(child, {
-    onError: (error) => { if (_server === server) _teardown(error); },
-    onExit: (code, signal) => {
-      if (_server === server) {
-        _teardown(null, {
-          // A clean code-0 exit is the server's own idle self-shutdown
-          // (MIXDOG_SEARCH_SERVER_IDLE_MS), not a fault. Counting it would let
-          // two quiet stretches trip the restart backoff and refuse the next
-          // real search for 30s.
-          countFailure: code !== 0,
-          detail: `exit code=${code ?? 'null'} signal=${signal ?? 'null'}`,
-        });
-      }
-    },
+  transport.on('error', (error) => {
+    markExited(true);
+    if (_server === server) _teardown(error);
+  });
+  transport.on('exit', (code, signal) => {
+    markExited(true);
+    if (_server === server) {
+      _teardown(null, {
+        // A clean code-0 exit is the server's own idle self-shutdown
+        // (MIXDOG_SEARCH_SERVER_IDLE_MS), not a fault. Counting it would let
+        // two quiet stretches trip the restart backoff and refuse the next
+        // real search for 30s.
+        countFailure: code !== 0,
+        detail: `exit code=${code ?? 'null'} signal=${signal ?? 'null'}`,
+      });
+    }
   });
-  // A detached child can still pin a one-shot CLI/test through its pipe
-  // handles. Keep the resident server idle-unreferenced, then ref all handles
-  // only while a request is awaiting a response.
+  // An attached engine must never be the reason a one-shot CLI or test stays
+  // alive — a child's pipe handles and the addon's keep-alive handle both do
+  // that. Keep the resident server idle-unreferenced, then reference it only
+  // while a request is awaiting a response.
   _setServerReferenced(server, false);
   _server = server;
   return server;
@@ -384,7 +382,7 @@ function armNativeCancellationWatchdog(server, request) {
     if (_server === server) {
       _teardown(error, { countFailure: false, detail: 'cancellation grace expired' });
     } else {
-      try { server.child.kill(); } catch {}
+      try { server.transport.kill(); } catch {}
     }
   }, graceMs);
   timer.unref?.();
@@ -464,7 +462,7 @@ async function requestNative(server, request, execOptions, deadlineMs) {
     let onAbort = null;
     let unsubscribeAbort = null;
     const cancelServerWork = () => {
-      try { server.child.stdin.write(`${JSON.stringify({ cancel: request.id })}\n`); } catch {}
+      try { server.transport.write(`${JSON.stringify({ cancel: request.id })}\n`); } catch {}
       armNativeCancellationWatchdog(server, request);
     };
     const settle = (value, cancel = false, error = null) => {
@@ -529,7 +527,7 @@ async function requestNative(server, request, execOptions, deadlineMs) {
     }
     unsubscribeAbort = subscribeAbortSignal(execOptions.signal, onAbort);
     try {
-      server.child.stdin.write(`${JSON.stringify(request)}\n`);
+      server.transport.write(`${JSON.stringify(request)}\n`);
     } catch (error) {
       if (_server === server) _teardown(error);
       else {
@@ -711,6 +709,10 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
       limit: Math.max(1, Math.min(1_000, Math.floor(Number(args?.limit) || 25))),
       hidden: args?.hidden !== false,
       includeNoise: args?.includeNoise === true,
+      // A fuzzy deadline returns a truthful partial window. Keep the one
+      // query-independent inventory walk alive so a retry can use its complete
+      // cache instead of starting a second whole-tree enumeration.
+      keepInventory: true,
       ...(Number.isFinite(Number(args?.maxDepth)) && Number(args.maxDepth) > 0
         ? { maxDepth: Math.floor(Number(args.maxDepth)) }
         : {}),
@@ -727,18 +729,8 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
     throw codedError('NATIVE_SEARCH_ERROR', String(response.error));
   }
   if (!Array.isArray(response?.matches)) throw unavailableError();
-  // Parity with the JS scorer's noise floor: the native matcher scores any
-  // subsequence, so a query with no real hit returns scattered junk paths
-  // (hash-named artifacts and the like). Re-rank the returned window through
-  // fuzzyRank, which keeps contiguous/basename hits unconditionally and
-  // drops sub-floor subsequence-only matches instead of surfacing noise.
-  const query = String(args?.query || '');
-  const filtered = query
-    ? fuzzyRank(query, prepareFuzzyItems(response.matches.map(String)))
-      .map((entry) => entry.item.path)
-    : response.matches.map(String);
   return {
-    matches: filtered,
+    matches: response.matches.map(String),
     hasMore: response.hasMore === true,
     totalMatches: Math.max(0, Number(response.totalMatches) || 0),
     totalSeen: Math.max(0, Number(response.totalSeen) || 0),

package/src/runtime/agent/orchestrator/tools/builtin/native-search-runner.mjs

@@ -17,11 +17,8 @@ async function serve(argsList, execOptions, opts) {
         recordLocalSearchBackend('native', performance.now() - startedAt, 'hit');
         return result;
     } catch (error) {
-        // A backend that cannot serve this request is a miss, not an error:
-        // the caller falls back and still returns a complete answer. Counting
-        // the fallback as a backend error made healthy calls read as silent
-        // failures in run telemetry (9 of them in one measured run, all of
-        // them ordinary fallbacks for paths outside the served inventory).
+        // Unsupported request shapes are classified separately in telemetry,
+        // but still throw: there is no alternate local-search backend.
         const code = String(error?.code || '');
         const outcome = code === 'NATIVE_SEARCH_UNAVAILABLE' || code === 'NATIVE_SEARCH_UNSUPPORTED'
             ? 'miss'

package/src/runtime/agent/orchestrator/tools/builtin/native-search-transport.mjs

@@ -0,0 +1,75 @@
+// Crash-isolated transport for the resident native search engine.
+//
+// Search runs as one long-lived `mixdog-graph --serve-search` child. Keeping
+// the Rust engine outside the daemon is intentional: a stuck native scan can
+// be killed and restarted without blocking every session on the daemon loop.
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { hiddenSpawnOpts } from '../../../../shared/spawn-flags.mjs';
+
+/** Minimal event fan-out: one transport feeds exactly one client. */
+function createEmitter() {
+  const handlers = { line: null, stderr: null, error: null, exit: null };
+  return {
+    handlers,
+    emit(name, ...args) {
+      const handler = handlers[name];
+      if (typeof handler !== 'function') return;
+      try { handler(...args); } catch { /* a listener fault must not kill the transport */ }
+    },
+  };
+}
+
+function createChildTransport(binaryPath, cwd) {
+  const child = spawn(binaryPath, [cwd, '--serve-search'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    ...hiddenSpawnOpts,
+  });
+  const { handlers, emit } = createEmitter();
+  child.stderr?.on?.('data', (chunk) => emit('stderr', chunk));
+  const lines = createInterface({ input: child.stdout });
+  lines.on('line', (line) => emit('line', line));
+  bindChildLifecycle(child, {
+    onError: (error) => emit('error', error),
+    onExit: (code, signal) => emit('exit', code, signal),
+  });
+  return {
+    kind: 'child',
+    child,
+    write(text) { child.stdin.write(text); },
+    end() { try { child.stdin?.end?.(); } catch { /* already closed */ } },
+    kill(signal) { try { child.kill(signal); } catch { /* already gone */ } },
+    ref() {
+      for (const handle of [child, child.stdin, child.stdout, child.stderr]) {
+        try { handle?.ref?.(); } catch { /* detached handle */ }
+      }
+    },
+    unref() {
+      for (const handle of [child, child.stdin, child.stdout, child.stderr]) {
+        try { handle?.unref?.(); } catch { /* detached handle */ }
+      }
+    },
+    on(name, handler) { handlers[name] = handler; },
+  };
+}
+
+/**
+ * ChildProcess stdin emits write failures asynchronously. A sync try/catch
+ * around stdin.write cannot catch EPIPE; without this listener the session
+ * runtime worker itself terminates and every active/queued turn is recovered.
+ */
+export function bindChildLifecycle(child, { onError, onExit } = {}) {
+  if (!child?.on) return;
+  child.on('error', onError);
+  child.on('exit', onExit);
+  child.stdin?.on?.('error', onError);
+}
+
+/**
+ * Attach to the engine. Returns null until the verified binary is available;
+ * throws only on an unexpected spawn failure, which the caller counts.
+ */
+export function createNativeSearchTransport({ binaryPath, cwd }) {
+  if (!binaryPath) return null;
+  return createChildTransport(binaryPath, cwd);
+}

package/src/runtime/agent/orchestrator/tools/builtin/native-search-transport.test.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  bindChildLifecycle,
+  createNativeSearchTransport,
+} from './native-search-transport.mjs';
+
+test('search transport stays unavailable until the verified child binary exists', () => {
+  assert.equal(createNativeSearchTransport({ binaryPath: null, cwd: process.cwd() }), null);
+});
+
+test('child stdin failures are routed through the lifecycle error handler', () => {
+  const errors = [];
+  const listeners = {};
+  const child = {
+    on(name, handler) { listeners[name] = handler; },
+    stdin: { on(name, handler) { listeners[`stdin:${name}`] = handler; } },
+  };
+  bindChildLifecycle(child, { onError: (error) => errors.push(error) });
+  const expected = new Error('EPIPE');
+  listeners['stdin:error'](expected);
+  assert.deepEqual(errors, [expected]);
+});

package/src/runtime/agent/orchestrator/tools/code-graph/build.mjs

@@ -419,6 +419,18 @@ export function _spawnCodeGraphWorker(
         _onSignalAbort = null;
       }
       if (_releaseSlot) { try { _releaseSlot(); } catch {} _releaseSlot = null; }
+      // The graph has already arrived, so the worker has nothing left to run.
+      // It cannot exit on its own either: reading its piped stdout/stderr
+      // below keeps the underlying MessagePort ref'd for the worker's whole
+      // lifetime (the same trap save-worker.mjs documents). Measured on a
+      // desktop session worker: 10 builds left 26 live threads and ~450 MB
+      // resident with no build in flight. The timeout and abort paths already
+      // terminate; this is the success path they were missing.
+      if (_worker) {
+        const finished = _worker;
+        _worker = null;
+        try { void finished.terminate(); } catch { /* already down */ }
+      }
       if (val instanceof Error) reject(val);
       else resolve(val);
     };

package/src/runtime/agent/orchestrator/tools/code-graph/constants.mjs

@@ -34,7 +34,10 @@ export const CODE_GRAPH_MEMORY_MAX_ENTRIES = Math.max(
   1,
   Math.floor(Number(process.env.MIXDOG_CODE_GRAPH_MEMORY_MAX_ENTRIES) || 6),
 );
-export const CODE_GRAPH_MEMORY_MAX_SOURCE_BYTES = Math.max(
+// Total retained graph memory, including nodes, symbols, indexes and source
+// caches. The previous source-cache-only accounting left the much larger base
+// graph unbounded across the six-entry LRU.
+export const CODE_GRAPH_MEMORY_MAX_BYTES = Math.max(
   1 * 1024 * 1024,
   Math.floor((Number(process.env.MIXDOG_CODE_GRAPH_MEMORY_MAX_MB) || 48) * 1024 * 1024),
 );

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -31,7 +31,8 @@ import {
 } from './project-root.mjs';
 import { buildCodeGraphAsync, prewarmCodeGraph, prewarmCodeGraphSymbols } from './build.mjs';
 import { _fileInfoFromRustRecord, _runGraphFiles } from './graph-binary.mjs';
-import { _attachGraphRuntimeCaches } from './graph-model.mjs';
+import { _attachGraphRuntimeCaches, _estimateGraphRetainedBytes } from './graph-model.mjs';
+import { _pruneCodeGraphMemoryCache } from './memory-cache.mjs';
 import {
   _isFilesystemRootPath,
   collectTrustedCodeGraphRoots,
@@ -93,6 +94,23 @@ function _outlineLanguageForPath(file) {
 const _exactFileGraphInflight = new Map();
 const _exactFileGraphCache = new Map();
 const EXACT_FILE_GRAPH_CACHE_MAX = 64;
+const EXACT_FILE_GRAPH_CACHE_MAX_BYTES = 8 * 1024 * 1024;
+
+function _pruneExactFileGraphCache() {
+  const rows = [..._exactFileGraphCache.entries()].map(([key, entry]) => ({
+    key,
+    retainedBytes: _estimateGraphRetainedBytes(entry?.graph),
+  }));
+  let totalRetainedBytes = rows.reduce((sum, row) => sum + row.retainedBytes, 0);
+  for (const row of rows) {
+    if (
+      _exactFileGraphCache.size <= EXACT_FILE_GRAPH_CACHE_MAX
+      && totalRetainedBytes <= EXACT_FILE_GRAPH_CACHE_MAX_BYTES
+    ) break;
+    _exactFileGraphCache.delete(row.key);
+    totalRetainedBytes -= row.retainedBytes;
+  }
+}
 
 async function _buildExactFileGraph(cwd, abs, signal = null) {
   const root = pathResolve(cwd);
@@ -144,9 +162,7 @@ async function _buildExactFileGraph(cwd, abs, signal = null) {
     });
     _exactFileGraphCache.delete(key);
     _exactFileGraphCache.set(key, { sourceHash, graph });
-    while (_exactFileGraphCache.size > EXACT_FILE_GRAPH_CACHE_MAX) {
-      _exactFileGraphCache.delete(_exactFileGraphCache.keys().next().value);
-    }
+    _pruneExactFileGraphCache();
     return graph;
   })();
   const inflight = { sourceHash, promise: pending };
@@ -1244,7 +1260,10 @@ async function executeCodeGraphToolRaw(name, args, cwd, signal = null, options =
       }
       default: throw new Error(`Unknown code-graph tool: ${name}`);
     }
-  })();
+  })().finally(() => {
+    _pruneCodeGraphMemoryCache();
+    _pruneExactFileGraphCache();
+  });
   if (!signal) return _work;
   let onAbort = null;
   const abortP = new Promise((_, reject) => {

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.test.mjs

@@ -1,10 +1,54 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { EventEmitter } from 'node:events';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 
 import { _resolveBoundedSentinelFreeAggregateRootForTest } from './dispatch.mjs';
+import { _spawnCodeGraphWorker } from './build.mjs';
+
+test('successful code-graph build terminates its worker and releases the spawn slot', async () => {
+  let worker = null;
+  let releases = 0;
+  class FakeWorker extends EventEmitter {
+    constructor() {
+      super();
+      this.stdout = new EventEmitter();
+      this.stderr = new EventEmitter();
+      this.terminations = 0;
+    }
+    terminate() {
+      this.terminations += 1;
+      return Promise.resolve(0);
+    }
+  }
+
+  const pending = _spawnCodeGraphWorker(
+    process.cwd(),
+    process.cwd(),
+    0,
+    null,
+    () => { releases += 1; },
+    null,
+    null,
+    {
+      createWorker() {
+        worker = new FakeWorker();
+        return worker;
+      },
+      getGeneration: () => 0,
+      setMemoryCache: () => {},
+      setDiskCache: () => {},
+    },
+  );
+  await new Promise((resolve) => setImmediate(resolve));
+  worker.emit('message', { ok: true, graph: { files: [] }, signature: 'sig' });
+
+  assert.deepEqual(await pending, { files: [] });
+  assert.equal(worker.terminations, 1);
+  assert.equal(releases, 1);
+});
 
 test('sentinel-free aggregate anchors adopt only their explicit bounded cwd', () => {
   const root = mkdtempSync(join(tmpdir(), 'mixdog-codegraph-bounded-'));

package/src/runtime/agent/orchestrator/tools/code-graph/graph-binary.mjs

@@ -216,13 +216,23 @@ async function _runGraphBinaryJsonl(absRoot, extraArgs, stdinLines = null, signa
       }
       const out = [];
       const buf = Buffer.concat(chunks).toString('utf8');
+      let lineNumber = 0;
       for (const line of buf.split('\n')) {
+        lineNumber += 1;
         const trimmed = line.trim();
         if (!trimmed) continue;
         try {
           const rec = JSON.parse(trimmed);
-          if (rec && typeof rec.rel === 'string') out.push(rec);
-        } catch { /* skip malformed line */ }
+          if (!rec || typeof rec.rel !== 'string') {
+            throw new Error('record is missing string rel');
+          }
+          out.push(rec);
+        } catch (error) {
+          reject(new Error(
+            `[code-graph] mixdog-graph emitted invalid JSONL at line ${lineNumber}: ${error?.message || error}`,
+          ));
+          return;
+        }
       }
       resolve(out);
     });

package/src/runtime/agent/orchestrator/tools/code-graph/graph-model.mjs

@@ -128,27 +128,41 @@ export function _attachGraphRuntimeCaches(graph) {
   return graph;
 }
 
-export function _estimateGraphRuntimeCacheBytes(graph) {
-  if (!graph) return 0;
-  let total = 0;
-  for (const entry of graph._sourceTextCache?.values() || []) {
-    total += Buffer.byteLength(String(entry?.text || ''), 'utf8');
-  }
-  for (const lines of graph._maskedLinesCache?.values() || []) {
-    if (!Array.isArray(lines)) continue;
-    for (const line of lines) total += Buffer.byteLength(String(line || ''), 'utf8');
-  }
-  for (const lines of graph._sourceLinesCache?.values() || []) {
-    if (!Array.isArray(lines)) continue;
-    for (const line of lines) total += Buffer.byteLength(String(line || ''), 'utf8');
-  }
-  for (const memo of graph._referenceSearchCache?.values() || []) {
-    total += Buffer.byteLength(String(memo || ''), 'utf8');
-  }
-  for (const memo of graph._keywordSearchCache?.values() || []) {
-    total += Buffer.byteLength(String(memo || ''), 'utf8');
-  }
-  return total;
+export function _estimateGraphRetainedBytes(graph) {
+  const seen = new WeakSet();
+  const estimate = (value) => {
+    if (value == null) return 0;
+    const type = typeof value;
+    if (type === 'string') return 16 + (value.length * 2);
+    if (type === 'number' || type === 'bigint') return 8;
+    if (type === 'boolean') return 4;
+    if (type !== 'object') return 0;
+    if (seen.has(value)) return 0;
+    seen.add(value);
+    if (ArrayBuffer.isView(value)) return 32 + value.byteLength;
+    if (value instanceof ArrayBuffer) return 24 + value.byteLength;
+    if (value instanceof Map) {
+      let bytes = 48 + (value.size * 24);
+      for (const [key, item] of value) bytes += estimate(key) + estimate(item);
+      return bytes;
+    }
+    if (value instanceof Set) {
+      let bytes = 48 + (value.size * 16);
+      for (const item of value) bytes += estimate(item);
+      return bytes;
+    }
+    if (Array.isArray(value)) {
+      let bytes = 24 + (value.length * 8);
+      for (const item of value) bytes += estimate(item);
+      return bytes;
+    }
+    let bytes = 48;
+    for (const [key, item] of Object.entries(value)) {
+      bytes += 8 + estimate(key) + estimate(item);
+    }
+    return bytes;
+  };
+  return estimate(graph);
 }
 
 export function _clearGraphRuntimeCaches(graph) {