@optave/codegraph 3.11.0 → 3.11.2

package/src/domain/graph/builder/incremental.ts

@@ -21,6 +21,12 @@ import type {
 } from '../../../types.js';
 import { parseFileIncremental } from '../../parser.js';
 import { computeConfidence, resolveImportPath } from '../resolve.js';
+import {
+  type CallNodeLookup,
+  findCaller,
+  resolveCallTargets,
+  resolveReceiverEdge,
+} from './call-resolver.js';
 import { BUILTIN_RECEIVERS, readFileSafe } from './helpers.js';
 
 // ── Local types ─────────────────────────────────────────────────────────
@@ -30,6 +36,7 @@ export interface IncrementalStmts {
   insertEdge: { run: (...params: unknown[]) => unknown };
   getNodeId: { get: (...params: unknown[]) => { id: number } | undefined };
   countNodes: { get: (...params: unknown[]) => { c: number } | undefined };
+  countEdges: { get: (...params: unknown[]) => { c: number } | undefined };
   listSymbols: { all: (...params: unknown[]) => unknown[] };
   findNodeInFile: { all: (...params: unknown[]) => unknown[] };
   findNodeByName: { all: (...params: unknown[]) => unknown[] };
@@ -40,6 +47,7 @@ interface RebuildResult {
   nodesAdded: number;
   nodesRemoved: number;
   edgesAdded: number;
+  edgesBefore: number;
   deleted?: boolean;
   event?: string;
   symbolDiff?: unknown;
@@ -183,8 +191,9 @@ function rebuildReverseDepEdges(
     aliases,
     skipBarrel ? null : db,
   );
-  const importedNames = buildImportedNamesMap(symbols, rootDir, depRelPath, aliases);
-  edgesAdded += buildCallEdges(stmts, depRelPath, symbols, fileNodeRow, importedNames);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, depRelPath, aliases, db);
+  edgesAdded += buildCallEdges(db, stmts, depRelPath, symbols, fileNodeRow, importedNames);
+  edgesAdded += buildClassHierarchyEdges(stmts, depRelPath, symbols);
   return edgesAdded;
 }
 
@@ -307,6 +316,69 @@ function resolveBarrelImportEdges(
   return edgesAdded;
 }
 
+/** Emit symbol-level `imports-type` edges for a single `import type` statement. */
+function emitTypeOnlySymbolEdges(
+  db: BetterSqlite3Database | null,
+  stmts: IncrementalStmts,
+  imp: ExtractorOutput['imports'][number],
+  resolvedPath: string,
+  fileNodeId: number,
+): number {
+  let edgesAdded = 0;
+  for (const name of imp.names) {
+    const cleanName = name.replace(/^\*\s+as\s+/, '');
+    let targetFile = resolvedPath;
+    if (db && isBarrelFile(db, resolvedPath)) {
+      const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
+      if (actual) targetFile = actual;
+    }
+    const candidates = stmts.findNodeInFile.all(cleanName, targetFile) as Array<{
+      id: number;
+      file: string;
+    }>;
+    if (candidates.length === 0) continue;
+    stmts.insertEdge.run(fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0);
+    edgesAdded++;
+  }
+  return edgesAdded;
+}
+
+/**
+ * Process a single import statement: emit the file→file edge, any
+ * symbol-level type-only edges, and barrel re-export edges.
+ */
+function emitEdgesForImport(
+  stmts: IncrementalStmts,
+  imp: ExtractorOutput['imports'][number],
+  fileNodeId: number,
+  relPath: string,
+  rootDir: string,
+  aliases: PathAliases,
+  db: BetterSqlite3Database | null,
+): number {
+  const resolvedPath = resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+  const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
+  if (!targetRow) return 0;
+
+  const edgeKind = imp.reexport
+    ? 'reexports'
+    : imp.typeOnly
+      ? 'imports-type'
+      : imp.dynamicImport
+        ? 'dynamic-imports'
+        : 'imports';
+  stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
+  let edgesAdded = 1;
+
+  if (imp.typeOnly) {
+    edgesAdded += emitTypeOnlySymbolEdges(db, stmts, imp, resolvedPath, fileNodeId);
+  }
+  if (!imp.reexport && db) {
+    edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeId, resolvedPath, imp);
+  }
+  return edgesAdded;
+}
+
 function buildImportEdges(
   stmts: IncrementalStmts,
   relPath: string,
@@ -318,44 +390,7 @@ function buildImportEdges(
 ): number {
   let edgesAdded = 0;
   for (const imp of symbols.imports) {
-    const resolvedPath = resolveImportPath(
-      path.join(rootDir, relPath),
-      imp.source,
-      rootDir,
-      aliases,
-    );
-    const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
-    if (targetRow) {
-      const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
-      stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
-      edgesAdded++;
-
-      // Type-only imports: create symbol-level edges so the target symbols
-      // get fan-in credit and aren't falsely classified as dead code.
-      if (imp.typeOnly) {
-        for (const name of imp.names) {
-          const cleanName = name.replace(/^\*\s+as\s+/, '');
-          let targetFile = resolvedPath;
-          if (db && isBarrelFile(db, resolvedPath)) {
-            const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
-            if (actual) targetFile = actual;
-          }
-          const candidates = stmts.findNodeInFile.all(cleanName, targetFile) as Array<{
-            id: number;
-            file: string;
-          }>;
-          if (candidates.length > 0) {
-            stmts.insertEdge.run(fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0);
-            edgesAdded++;
-          }
-        }
-      }
-
-      // Barrel resolution: create edges through re-export chains
-      if (!imp.reexport && db) {
-        edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeId, resolvedPath, imp);
-      }
-    }
+    edgesAdded += emitEdgesForImport(stmts, imp, fileNodeId, relPath, rootDir, aliases, db);
   }
   return edgesAdded;
 }
@@ -365,6 +400,7 @@ function buildImportedNamesMap(
   rootDir: string,
   relPath: string,
   aliases: PathAliases,
+  db: BetterSqlite3Database,
 ): Map<string, string> {
   const importedNames = new Map<string, string>();
   for (const imp of symbols.imports) {
@@ -375,78 +411,79 @@ function buildImportedNamesMap(
       aliases,
     );
     for (const name of imp.names) {
-      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
+      const cleanName = name.replace(/^\*\s+as\s+/, '');
+      // Mirror full-build's `buildImportedNamesMap`: follow barrel re-exports so
+      // `importedNames` maps to the *defining* file, not the barrel. This ensures
+      // `computeConfidence` gets `importedFrom === targetFile` and returns 1.0
+      // instead of the cross-directory fallback (0.3).
+      let targetFile = resolvedPath;
+      if (isBarrelFile(db, resolvedPath)) {
+        const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
+        if (actual) targetFile = actual;
+      }
+      importedNames.set(cleanName, targetFile);
     }
   }
   return importedNames;
 }
 
-// ── Call edge building ──────────────────────────────────────────────────
+// ── Class hierarchy edges ───────────────────────────────────────────────
 
-function findCaller(
-  call: ExtractorOutput['calls'][number],
-  definitions: ExtractorOutput['definitions'],
-  relPath: string,
-  stmts: IncrementalStmts,
-): { id: number } | null {
-  let caller: { id: number } | null = null;
-  let callerSpan = Infinity;
-  for (const def of definitions) {
-    if (def.line <= call.line) {
-      const end = def.endLine || Infinity;
-      if (call.line <= end) {
-        const span = end - def.line;
-        if (span < callerSpan) {
-          const row = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-          if (row) {
-            caller = row;
-            callerSpan = span;
-          }
-        }
-      }
-    }
-  }
-  return caller;
-}
+type NodeWithKind = { id: number; kind: string; file: string };
 
-function resolveCallTargets(
+const HIERARCHY_SOURCE_KINDS = new Set(['class', 'struct', 'record', 'enum']);
+const EXTENDS_TARGET_KINDS = new Set(['class', 'struct', 'trait', 'record']);
+const IMPLEMENTS_TARGET_KINDS = new Set(['interface', 'trait', 'class']);
+
+function buildClassHierarchyEdges(
   stmts: IncrementalStmts,
-  call: ExtractorOutput['calls'][number],
   relPath: string,
-  importedNames: Map<string, string>,
-  typeMap: Map<string, unknown>,
-): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
-  const importedFrom = importedNames.get(call.name);
-  let targets: Array<{ id: number; file: string }> | undefined;
-  if (importedFrom) {
-    targets = stmts.findNodeInFile.all(call.name, importedFrom) as Array<{
-      id: number;
-      file: string;
-    }>;
-  }
-  if (!targets || targets.length === 0) {
-    targets = stmts.findNodeInFile.all(call.name, relPath) as Array<{ id: number; file: string }>;
-    if (targets.length === 0) {
-      targets = stmts.findNodeByName.all(call.name) as Array<{ id: number; file: string }>;
+  symbols: ExtractorOutput,
+): number {
+  let edgesAdded = 0;
+  for (const cls of symbols.classes) {
+    const sourceRow = (stmts.findNodeInFile.all(cls.name, relPath) as NodeWithKind[]).find((n) =>
+      HIERARCHY_SOURCE_KINDS.has(n.kind),
+    );
+    if (!sourceRow) continue;
+
+    if (cls.extends) {
+      for (const t of (stmts.findNodeByName.all(cls.extends) as NodeWithKind[]).filter((n) =>
+        EXTENDS_TARGET_KINDS.has(n.kind),
+      )) {
+        stmts.insertEdge.run(sourceRow.id, t.id, 'extends', 1.0, 0);
+        edgesAdded++;
+      }
     }
-  }
-  // Type-aware resolution: translate variable receiver to declared type
-  if ((!targets || targets.length === 0) && call.receiver && typeMap) {
-    const typeEntry = typeMap.get(call.receiver);
-    const typeName = typeEntry
-      ? typeof typeEntry === 'string'
-        ? typeEntry
-        : (typeEntry as { type?: string }).type
-      : null;
-    if (typeName) {
-      const qualified = `${typeName}.${call.name}`;
-      targets = stmts.findNodeByName.all(qualified) as Array<{ id: number; file: string }>;
+    if (cls.implements) {
+      for (const t of (stmts.findNodeByName.all(cls.implements) as NodeWithKind[]).filter((n) =>
+        IMPLEMENTS_TARGET_KINDS.has(n.kind),
+      )) {
+        stmts.insertEdge.run(sourceRow.id, t.id, 'implements', 1.0, 0);
+        edgesAdded++;
+      }
     }
   }
-  return { targets: targets ?? [], importedFrom };
+  return edgesAdded;
+}
+
+// ── Call edge building ──────────────────────────────────────────────────
+
+function makeIncrementalLookup(db: BetterSqlite3Database, stmts: IncrementalStmts): CallNodeLookup {
+  return {
+    byNameAndFile: (name, file) =>
+      stmts.findNodeInFile.all(name, file) as Array<{ id: number; file: string; kind?: string }>,
+    byName: (name) =>
+      stmts.findNodeByName.all(name) as Array<{ id: number; file: string; kind?: string }>,
+    isBarrel: (file) => isBarrelFile(db, file),
+    resolveBarrel: (barrelFile, symbolName) => resolveBarrelTarget(db, barrelFile, symbolName),
+    nodeId: (name, kind, file, line) =>
+      stmts.getNodeId.get(name, kind, file, line) as { id: number } | undefined,
+  };
 }
 
 function buildCallEdges(
+  db: BetterSqlite3Database,
   stmts: IncrementalStmts,
   relPath: string,
   symbols: ExtractorOutput,
@@ -465,13 +502,16 @@ function buildCallEdges(
             ]),
           )
         : new Map();
+  const seenCallEdges = new Set<string>();
+  const lookup = makeIncrementalLookup(db, stmts);
   let edgesAdded = 0;
+
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
-    const caller = findCaller(call, symbols.definitions, relPath, stmts) || fileNodeRow;
+    const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
     const { targets, importedFrom } = resolveCallTargets(
-      stmts,
+      lookup,
       call,
       relPath,
       importedNames,
@@ -479,18 +519,175 @@ function buildCallEdges(
     );
 
     for (const t of targets) {
-      if (t.id !== caller.id) {
+      const edgeKey = `${caller.id}|${t.id}`;
+      if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
+        seenCallEdges.add(edgeKey);
         const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
         stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
         edgesAdded++;
       }
     }
+
+    if (
+      call.receiver &&
+      !BUILTIN_RECEIVERS.has(call.receiver) &&
+      call.receiver !== 'this' &&
+      call.receiver !== 'self' &&
+      call.receiver !== 'super'
+    ) {
+      const recv = resolveReceiverEdge(
+        lookup,
+        { name: call.name, receiver: call.receiver },
+        caller,
+        relPath,
+        typeMap,
+        seenCallEdges,
+      );
+      if (recv) {
+        stmts.insertEdge.run(recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0);
+        edgesAdded++;
+      }
+    }
   }
   return edgesAdded;
 }
 
 // ── Main entry point ────────────────────────────────────────────────────
 
+/** Build the "this file was deleted" result returned by `rebuildFile`. */
+function buildDeletionResult(
+  relPath: string,
+  oldNodes: number,
+  edgesBefore: number,
+  oldSymbols: unknown[],
+  diffSymbols: ((old: unknown[], new_: unknown[]) => unknown) | undefined,
+): RebuildResult {
+  const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, []) : null;
+  return {
+    file: relPath,
+    nodesAdded: 0,
+    nodesRemoved: oldNodes,
+    edgesAdded: 0,
+    edgesBefore,
+    deleted: true,
+    event: 'deleted',
+    symbolDiff,
+    nodesBefore: oldNodes,
+    nodesAfter: 0,
+  };
+}
+
+/** Rebuild all edges originating in the single (just-parsed) target file. */
+function rebuildEdgesForTargetFile(
+  db: BetterSqlite3Database,
+  stmts: IncrementalStmts,
+  relPath: string,
+  symbols: ExtractorOutput,
+  fileNodeRow: { id: number },
+  rootDir: string,
+): number {
+  const aliases: PathAliases = { baseUrl: null, paths: {} };
+  let edgesAdded = buildContainmentEdges(db, stmts, relPath, symbols);
+  edgesAdded += rebuildDirContainment(db, stmts, relPath);
+  edgesAdded += buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeRow.id, aliases, db);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases, db);
+  edgesAdded += buildCallEdges(db, stmts, relPath, symbols, fileNodeRow, importedNames);
+  edgesAdded += buildClassHierarchyEdges(stmts, relPath, symbols);
+  return edgesAdded;
+}
+
+/**
+ * Re-parse the reverse-deps and delete their outgoing edges so the cascade
+ * can rebuild them. Returns the parsed symbols map together with the total
+ * edge count across all deps measured *before* deletion — callers add this
+ * to their own `edgesBefore` so the net delta stays correct even when the
+ * reverse-dep cascade re-inserts edges.
+ */
+async function parseReverseDeps(
+  db: BetterSqlite3Database,
+  rootDir: string,
+  reverseDeps: string[],
+  stmts: IncrementalStmts,
+  engineOpts: EngineOpts,
+  cache: unknown,
+): Promise<{ depSymbols: Map<string, ExtractorOutput>; reverseDepsEdgesBefore: number }> {
+  const depSymbols = new Map<string, ExtractorOutput>();
+  let reverseDepsEdgesBefore = 0;
+  for (const depRelPath of reverseDeps) {
+    const symbols_ = await parseReverseDep(rootDir, depRelPath, engineOpts, cache);
+    if (symbols_) {
+      reverseDepsEdgesBefore += stmts.countEdges.get(depRelPath)?.c ?? 0;
+      deleteOutgoingEdges(db, depRelPath);
+      depSymbols.set(depRelPath, symbols_);
+    }
+  }
+  return { depSymbols, reverseDepsEdgesBefore };
+}
+
+/**
+ * Pass 2 of the reverse-dep cascade: now that the changed file's `reexports`
+ * edges exist, resolve barrel imports for every reverse-dep so transitive
+ * call edges through the barrel still find their targets.
+ */
+function emitBarrelImportEdgesForReverseDeps(
+  db: BetterSqlite3Database,
+  stmts: IncrementalStmts,
+  depSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+): number {
+  let edgesAdded = 0;
+  for (const [depRelPath, symbols_] of depSymbols) {
+    const fileNodeRow_ = stmts.getNodeId.get(depRelPath, 'file', depRelPath, 0);
+    if (!fileNodeRow_) continue;
+    const aliases_: PathAliases = { baseUrl: null, paths: {} };
+    for (const imp of symbols_.imports) {
+      if (imp.reexport) continue;
+      const resolvedPath = resolveImportPath(
+        path.join(rootDir, depRelPath),
+        imp.source,
+        rootDir,
+        aliases_,
+      );
+      edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeRow_.id, resolvedPath, imp);
+    }
+  }
+  return edgesAdded;
+}
+
+/**
+ * Two-pass reverse-dep cascade:
+ *   1. Rebuild direct edges (creating `reexports` edges for barrels).
+ *   2. Add barrel import edges (which need `reexports` edges to exist).
+ * Returns both the gross edges-added count and the pre-deletion edge count
+ * for all reverse deps so callers can compute a true net delta.
+ */
+async function runReverseDepCascade(
+  db: BetterSqlite3Database,
+  rootDir: string,
+  reverseDeps: string[],
+  stmts: IncrementalStmts,
+  engineOpts: EngineOpts,
+  cache: unknown,
+): Promise<{ edgesAdded: number; reverseDepsEdgesBefore: number }> {
+  const { depSymbols, reverseDepsEdgesBefore } = await parseReverseDeps(
+    db,
+    rootDir,
+    reverseDeps,
+    stmts,
+    engineOpts,
+    cache,
+  );
+
+  let edgesAdded = 0;
+  // Pass 1: direct edges only (no barrel resolution) — creates reexports edges
+  for (const [depRelPath, symbols_] of depSymbols) {
+    edgesAdded += rebuildReverseDepEdges(db, rootDir, depRelPath, symbols_, stmts, true);
+  }
+  // Pass 2: add barrel import edges (reexports edges now exist)
+  edgesAdded += emitBarrelImportEdgesForReverseDeps(db, stmts, depSymbols, rootDir);
+  return { edgesAdded, reverseDepsEdgesBefore };
+}
+
 /**
  * Parse a single file and update the database incrementally.
  */
@@ -506,6 +703,7 @@ export async function rebuildFile(
   const { diffSymbols } = options;
   const relPath = normalizePath(path.relative(rootDir, filePath));
   const oldNodes = stmts.countNodes.get(relPath)?.c || 0;
+  const edgesBefore = stmts.countEdges.get(relPath)?.c || 0;
   const oldSymbols: unknown[] = diffSymbols ? stmts.listSymbols.all(relPath) : [];
 
   // Find reverse-deps BEFORE purging (edges still reference the old nodes)
@@ -519,18 +717,7 @@ export async function rebuildFile(
 
   if (!fs.existsSync(filePath)) {
     if (cache) (cache as { remove(p: string): void }).remove(filePath);
-    const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, []) : null;
-    return {
-      file: relPath,
-      nodesAdded: 0,
-      nodesRemoved: oldNodes,
-      edgesAdded: 0,
-      deleted: true,
-      event: 'deleted',
-      symbolDiff,
-      nodesBefore: oldNodes,
-      nodesAfter: 0,
-    };
+    return buildDeletionResult(relPath, oldNodes, edgesBefore, oldSymbols, diffSymbols);
   }
 
   let code: string;
@@ -551,47 +738,28 @@ export async function rebuildFile(
 
   const fileNodeRow = stmts.getNodeId.get(relPath, 'file', relPath, 0);
   if (!fileNodeRow)
-    return { file: relPath, nodesAdded: newNodes, nodesRemoved: oldNodes, edgesAdded: 0 };
-
-  const aliases: PathAliases = { baseUrl: null, paths: {} };
-
-  let edgesAdded = buildContainmentEdges(db, stmts, relPath, symbols);
-  edgesAdded += rebuildDirContainment(db, stmts, relPath);
-  edgesAdded += buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeRow.id, aliases, db);
-  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases);
-  edgesAdded += buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames);
+    return {
+      file: relPath,
+      nodesAdded: newNodes,
+      nodesRemoved: oldNodes,
+      edgesAdded: 0,
+      edgesBefore,
+    };
 
-  // Cascade: rebuild outgoing edges for reverse-dep files.
-  // Two-pass approach: first rebuild direct edges (creating reexports edges for barrels),
-  // then add barrel import edges (which need reexports edges to exist for resolution).
-  const depSymbols = new Map<string, ExtractorOutput>();
-  for (const depRelPath of reverseDeps) {
-    const symbols_ = await parseReverseDep(rootDir, depRelPath, engineOpts, cache);
-    if (symbols_) {
-      deleteOutgoingEdges(db, depRelPath);
-      depSymbols.set(depRelPath, symbols_);
-    }
-  }
-  // Pass 1: direct edges only (no barrel resolution) — creates reexports edges
-  for (const [depRelPath, symbols_] of depSymbols) {
-    edgesAdded += rebuildReverseDepEdges(db, rootDir, depRelPath, symbols_, stmts, true);
-  }
-  // Pass 2: add barrel import edges (reexports edges now exist)
-  for (const [depRelPath, symbols_] of depSymbols) {
-    const fileNodeRow_ = stmts.getNodeId.get(depRelPath, 'file', depRelPath, 0);
-    if (!fileNodeRow_) continue;
-    const aliases_: PathAliases = { baseUrl: null, paths: {} };
-    for (const imp of symbols_.imports) {
-      if (imp.reexport) continue;
-      const resolvedPath = resolveImportPath(
-        path.join(rootDir, depRelPath),
-        imp.source,
-        rootDir,
-        aliases_,
-      );
-      edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeRow_.id, resolvedPath, imp);
-    }
-  }
+  let edgesAdded = rebuildEdgesForTargetFile(db, stmts, relPath, symbols, fileNodeRow, rootDir);
+  const { edgesAdded: cascadeEdges, reverseDepsEdgesBefore } = await runReverseDepCascade(
+    db,
+    rootDir,
+    reverseDeps,
+    stmts,
+    engineOpts,
+    cache,
+  );
+  edgesAdded += cascadeEdges;
+  // Include pre-deletion edge counts from reverse deps so the net delta
+  // (edgesAdded - edgesBefore) is correct even when the cascade re-inserts
+  // their edges unchanged.
+  const totalEdgesBefore = edgesBefore + reverseDepsEdgesBefore;
 
   const symbolDiff = diffSymbols ? diffSymbols(oldSymbols, newSymbols) : null;
   const event = oldNodes === 0 ? 'added' : 'modified';
@@ -601,6 +769,7 @@ export async function rebuildFile(
     nodesAdded: newNodes,
     nodesRemoved: oldNodes,
     edgesAdded,
+    edgesBefore: totalEdgesBefore,
     deleted: false,
     event,
     symbolDiff,