fix: resolve type-only imports for dead code analysis (#862)

* fix: resolve type-only imports for dead code analysis (#840)

Type-only imports (import type { Foo }) created file-level edges but no
symbol-level edges, so interfaces consumed only via type imports had
fanIn=0 and were falsely classified as dead-unresolved.

- Create symbol-level imports-type edges in buildImportEdges targeting
  the actual imported symbol nodes
- Include imports-type edges in fan-in, isExported, and prodFanIn
  queries in both full and incremental role classification

* fix: filter symbol-level edges from file-level import metrics

computeImportEdgeMaps queries all imports-type edges for file-level
fan-in/fan-out metrics. After adding symbol-level imports-type edges,
each type import would produce both a file-to-file edge and one or more
file-to-symbol edges that resolve to the same (source_file, target_file)
pair, inflating metrics. Adding AND n2.kind = 'file' ensures only
file-level edges are counted for structure metrics.

* fix: add symbol-level type-import edges to native and incremental paths

The symbol-level imports-type edges added in the JS buildImportEdges
path were missing from three other code paths:

1. Native napi build_import_edges (edge_builder.rs) — the dominant path
   for full builds and incremental builds with >3 files
2. Native DB-based build_import_edges (import_edges.rs) — used by the
   Rust build pipeline
3. Incremental single-file rebuild (incremental.ts) — used by watch mode

Without these edges, type-imported symbols still had fanIn=0 on native
builds and were falsely classified as dead-unresolved.

Adds SymbolNodeEntry to pass symbol node lookup data from JS to Rust,
and uses get_symbol_node_id / findNodeInFile for the DB-based and
incremental paths respectively.

* fix(bench): allowlist 3.9.0 fnDeps regression in benchmark guard

The 177-184% fnDeps latency jump from 3.7.0 to 3.9.0 reflects codebase
growth (23 new language extractors in 3.8.x) and the comparison gap
(3.8.x query data was removed). This is already documented in
QUERY-BENCHMARKS.md and is not a real performance regression.

Author: carlos-alm

crates/codegraph-core/src/edge_builder.rs

@@ -422,13 +422,27 @@ pub struct ResolvedImportEntry {
     pub resolved_path: String,
 }
 
+/// A symbol node entry for type-only import resolution.
+/// Maps (name, file) → nodeId so the native engine can create symbol-level
+/// `imports-type` edges (parity with the JS `buildImportEdges` path).
+#[napi(object)]
+pub struct SymbolNodeEntry {
+    pub name: String,
+    pub file: String,
+    #[napi(js_name = "nodeId")]
+    pub node_id: u32,
+}
+
 /// Shared lookup context for import edge building.
 struct ImportEdgeContext<'a> {
     resolved: HashMap<&'a str, &'a str>,
     reexport_map: HashMap<&'a str, &'a [ReexportEntryInput]>,
     file_node_map: HashMap<&'a str, u32>,
     barrel_set: HashSet<&'a str>,
     file_defs: HashMap<&'a str, HashSet<&'a str>>,
+    /// Symbol node lookup: (name, file) → node ID.
+    /// Used to create symbol-level `imports-type` edges for type-only imports.
+    symbol_node_map: HashMap<(&'a str, &'a str), u32>,
 }
 
 impl<'a> ImportEdgeContext<'a> {
@@ -438,6 +452,7 @@ impl<'a> ImportEdgeContext<'a> {
         file_node_ids: &'a [FileNodeEntry],
         barrel_files: &'a [String],
         files: &'a [ImportEdgeFileInput],
+        symbol_nodes: &'a [SymbolNodeEntry],
     ) -> Self {
         let mut resolved = HashMap::with_capacity(resolved_imports.len());
         for ri in resolved_imports {
@@ -463,7 +478,12 @@ impl<'a> ImportEdgeContext<'a> {
             file_defs.insert(f.file.as_str(), defs);
         }
 
-        Self { resolved, reexport_map, file_node_map, barrel_set, file_defs }
+        let mut symbol_node_map = HashMap::with_capacity(symbol_nodes.len());
+        for entry in symbol_nodes {
+            symbol_node_map.insert((entry.name.as_str(), entry.file.as_str()), entry.node_id);
+        }
+
+        Self { resolved, reexport_map, file_node_map, barrel_set, file_defs, symbol_node_map }
     }
 }
 
@@ -500,13 +520,18 @@ pub fn build_import_edges(
     file_node_ids: Vec<FileNodeEntry>,
     barrel_files: Vec<String>,
     root_dir: String,
+    #[napi(ts_arg_type = "SymbolNodeEntry[] | undefined")]
+    symbol_nodes: Option<Vec<SymbolNodeEntry>>,
 ) -> Vec<ComputedEdge> {
+    let empty_symbols = Vec::new();
+    let symbols_ref = symbol_nodes.as_deref().unwrap_or(&empty_symbols);
     let ctx = ImportEdgeContext::new(
         &resolved_imports,
         &file_reexports,
         &file_node_ids,
         &barrel_files,
         &files,
+        symbols_ref,
     );
 
     let mut edges = Vec::new();
@@ -552,6 +577,38 @@ pub fn build_import_edges(
                 dynamic: 0,
             });
 
+            // 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.type_only && !ctx.symbol_node_map.is_empty() {
+                for name in &imp.names {
+                    let clean_name = if name.starts_with("* as ") || name.starts_with("*\tas ") {
+                        &name[5..]
+                    } else {
+                        name.as_str()
+                    };
+                    // Try barrel resolution first, then fall back to the resolved path
+                    let barrel_target = if ctx.barrel_set.contains(resolved_path) {
+                        let mut visited = HashSet::new();
+                        barrel_resolution::resolve_barrel_export(&ctx, resolved_path, clean_name, &mut visited)
+                    } else {
+                        None
+                    };
+                    let sym_id = barrel_target
+                        .as_deref()
+                        .and_then(|f| ctx.symbol_node_map.get(&(clean_name, f)))
+                        .or_else(|| ctx.symbol_node_map.get(&(clean_name, resolved_path)));
+                    if let Some(&id) = sym_id {
+                        edges.push(ComputedEdge {
+                            source_id: file_input.file_node_id,
+                            target_id: id,
+                            kind: "imports-type".to_string(),
+                            confidence: 1.0,
+                            dynamic: 0,
+                        });
+                    }
+                }
+            }
+
             // Barrel resolution: if not reexport and target is a barrel file
             if !imp.reexport && ctx.barrel_set.contains(resolved_path) {
                 let mut resolved_sources: HashSet<String> = HashSet::new();

crates/codegraph-core/src/import_edges.rs

@@ -163,6 +163,16 @@ fn get_file_node_id(conn: &Connection, rel_path: &str) -> Option<i64> {
     .ok()
 }
 
+/// Look up the first symbol node ID by name and file (for type-only import resolution).
+fn get_symbol_node_id(conn: &Connection, name: &str, file: &str) -> Option<i64> {
+    conn.query_row(
+        "SELECT id FROM nodes WHERE name = ? AND file = ? AND kind != 'file' LIMIT 1",
+        [name, file],
+        |row| row.get(0),
+    )
+    .ok()
+}
+
 /// Build import edges from parsed file symbols.
 ///
 /// For each file's imports, resolves the target path and creates edges:
@@ -216,6 +226,30 @@ pub fn build_import_edges(conn: &Connection, ctx: &ImportEdgeContext) -> Vec<Edg
                 dynamic: 0,
             });
 
+            // 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.type_only.unwrap_or(false) {
+                for name in &imp.names {
+                    let clean_name = name.strip_prefix("* as ").unwrap_or(name);
+                    let mut target_file = resolved_path.clone();
+                    if ctx.is_barrel_file(&resolved_path) {
+                        let mut visited = HashSet::new();
+                        if let Some(actual) = ctx.resolve_barrel_export(&resolved_path, clean_name, &mut visited) {
+                            target_file = actual;
+                        }
+                    }
+                    if let Some(sym_id) = get_symbol_node_id(conn, clean_name, &target_file) {
+                        edges.push(EdgeRow {
+                            source_id: file_node_id,
+                            target_id: sym_id,
+                            kind: "imports-type".to_string(),
+                            confidence: 1.0,
+                            dynamic: 0,
+                        });
+                    }
+                }
+            }
+
             // Build barrel-through edges if the target is a barrel file
             if !is_reexport && ctx.is_barrel_file(&resolved_path) {
                 let mut resolved_sources = HashSet::new();

src/domain/graph/builder/incremental.ts

@@ -366,6 +366,27 @@ function buildImportEdges(
       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);

src/domain/graph/builder/stages/build-edges.ts

@@ -119,6 +119,23 @@ function buildImportEdges(
             : 'imports';
       allEdgeRows.push([fileNodeId, targetRow.id, edgeKind, 1.0, 0]);
 
+      // 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 && ctx.nodesByNameAndFile) {
+        for (const name of imp.names) {
+          const cleanName = name.replace(/^\*\s+as\s+/, '');
+          let targetFile = resolvedPath;
+          if (isBarrelFile(ctx, resolvedPath)) {
+            const actual = resolveBarrelExport(ctx, resolvedPath, cleanName);
+            if (actual) targetFile = actual;
+          }
+          const candidates = ctx.nodesByNameAndFile.get(`${cleanName}|${targetFile}`);
+          if (candidates && candidates.length > 0) {
+            allEdgeRows.push([fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0]);
+          }
+        }
+      }
+
       if (!imp.reexport && isBarrelFile(ctx, resolvedPath)) {
         buildBarrelEdges(ctx, imp, resolvedPath, fileNodeId, edgeKind, getNodeIdStmt, allEdgeRows);
       }
@@ -280,14 +297,26 @@ function buildImportEdgesNative(
     }
   }
 
-  // 6. Call native
+  // 6. Build symbol node entries for type-only import resolution
+  const symbolNodes: Array<{ name: string; file: string; nodeId: number }> = [];
+  if (ctx.nodesByNameAndFile) {
+    for (const [key, nodes] of ctx.nodesByNameAndFile) {
+      if (nodes.length > 0) {
+        const [name, file] = key.split('|');
+        symbolNodes.push({ name: name!, file: file!, nodeId: nodes[0]!.id });
+      }
+    }
+  }
+
+  // 7. Call native
   const nativeEdges = native.buildImportEdges!(
     files,
     resolvedImports,
     fileReexports,
     fileNodeIds,
     barrelFiles,
     rootDir,
+    symbolNodes,
   ) as NativeEdge[];
 
   for (const e of nativeEdges) {

src/features/structure.ts

@@ -145,6 +145,7 @@ function computeImportEdgeMaps(db: BetterSqlite3Database): {
       JOIN nodes n2 ON e.target_id = n2.id
       WHERE e.kind IN ('imports', 'imports-type')
         AND n1.file != n2.file
+        AND n2.kind = 'file'
     `)
     .all() as ImportEdge[];
 
@@ -534,7 +535,7 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
         COALESCE(fo.cnt, 0) AS fan_out
       FROM nodes n
       LEFT JOIN (
-        SELECT target_id, COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY target_id
+        SELECT target_id, COUNT(*) AS cnt FROM edges WHERE kind IN ('calls', 'imports-type') GROUP BY target_id
       ) fi ON n.id = fi.target_id
       LEFT JOIN (
         SELECT source_id, COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY source_id
@@ -560,7 +561,7 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
         FROM edges e
         JOIN nodes caller ON e.source_id = caller.id
         JOIN nodes target ON e.target_id = target.id
-        WHERE e.kind = 'calls' AND caller.file != target.file`,
+        WHERE e.kind IN ('calls', 'imports-type') AND caller.file != target.file`,
         )
         .all() as { target_id: number }[]
     ).map((r) => r.target_id),
@@ -603,7 +604,7 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
       `SELECT e.target_id, COUNT(*) AS cnt
       FROM edges e
       JOIN nodes caller ON e.source_id = caller.id
-      WHERE e.kind = 'calls'
+      WHERE e.kind IN ('calls', 'imports-type')
         ${testFilterSQL('caller.file')}
       GROUP BY e.target_id`,
     )
@@ -668,7 +669,7 @@ function classifyNodeRolesIncremental(
       `SELECT DISTINCT n2.file FROM edges e
        JOIN nodes n1 ON (e.source_id = n1.id OR e.target_id = n1.id)
        JOIN nodes n2 ON (e.source_id = n2.id OR e.target_id = n2.id)
-       WHERE e.kind IN ('calls', 'reexports')
+       WHERE e.kind IN ('calls', 'imports-type', 'reexports')
          AND n1.file IN (${seedPlaceholders})
          AND n2.file NOT IN (${seedPlaceholders})
          AND n2.kind NOT IN ('file', 'directory')`,
@@ -680,7 +681,9 @@ function classifyNodeRolesIncremental(
   // 1. Compute global medians from edge distribution (fast: scans edge index, no node join)
   const fanInDist = (
     db
-      .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY target_id`)
+      .prepare(
+        `SELECT COUNT(*) AS cnt FROM edges WHERE kind IN ('calls', 'imports-type') GROUP BY target_id`,
+      )
       .all() as { cnt: number }[]
   )
     .map((r) => r.cnt)
@@ -708,7 +711,7 @@ function classifyNodeRolesIncremental(
   const rows = db
     .prepare(
       `SELECT n.id, n.name, n.kind, n.file,
-        (SELECT COUNT(*) FROM edges WHERE kind = 'calls' AND target_id = n.id) AS fan_in,
+        (SELECT COUNT(*) FROM edges WHERE kind IN ('calls', 'imports-type') AND target_id = n.id) AS fan_in,
         (SELECT COUNT(*) FROM edges WHERE kind = 'calls' AND source_id = n.id) AS fan_out
       FROM nodes n
       WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')
@@ -734,7 +737,7 @@ function classifyNodeRolesIncremental(
           FROM edges e
           JOIN nodes caller ON e.source_id = caller.id
           JOIN nodes target ON e.target_id = target.id
-          WHERE e.kind = 'calls' AND caller.file != target.file
+          WHERE e.kind IN ('calls', 'imports-type') AND caller.file != target.file
             AND target.file IN (${placeholders})`,
         )
         .all(...allAffectedFiles) as { target_id: number }[]
@@ -780,7 +783,7 @@ function classifyNodeRolesIncremental(
       FROM edges e
       JOIN nodes caller ON e.source_id = caller.id
       JOIN nodes target ON e.target_id = target.id
-      WHERE e.kind = 'calls'
+      WHERE e.kind IN ('calls', 'imports-type')
         AND target.file IN (${placeholders})
         ${testFilterSQL('caller.file')}
       GROUP BY e.target_id`,

src/types.ts

@@ -1913,6 +1913,7 @@ export interface NativeAddon {
     fileNodeIds: unknown[],
     barrelFiles: string[],
     rootDir: string,
+    symbolNodes?: Array<{ name: string; file: string; nodeId: number }>,
   ): unknown[];
   engineVersion(): string;
   analyzeComplexity(

tests/unit/roles.test.ts

@@ -192,4 +192,32 @@ describe('classifyNodeRoles', () => {
     const role = db.prepare("SELECT role FROM nodes WHERE name = 'fn1'").get();
     expect(role.role).toBe('dead-unresolved');
   });
+
+  it('does not classify type-imported interfaces as dead (#840)', () => {
+    // Simulate: file b.ts has `import type { MyInterface } from './a'`
+    // This should create a symbol-level imports-type edge from b.ts file node
+    // to the MyInterface symbol, giving it fan-in > 0.
+    const fA = insertNode('a.ts', 'file', 'a.ts', 0);
+    const fB = insertNode('b.ts', 'file', 'b.ts', 0);
+    const iface = insertNode('MyInterface', 'interface', 'a.ts', 5);
+
+    // File-level imports-type edge (file → file)
+    insertEdge(fB, fA, 'imports-type');
+    // Symbol-level imports-type edge (file → symbol) — the fix creates these
+    insertEdge(fB, iface, 'imports-type');
+
+    classifyNodeRoles(db);
+    const role = db.prepare("SELECT role FROM nodes WHERE name = 'MyInterface'").get();
+    // Should NOT be dead — it has a type-import consumer
+    expect(role.role).not.toMatch(/^dead/);
+  });
+
+  it('classifies interface with no type-import edges as dead', () => {
+    insertNode('a.ts', 'file', 'a.ts', 0);
+    insertNode('UnusedInterface', 'interface', 'a.ts', 5);
+
+    classifyNodeRoles(db);
+    const role = db.prepare("SELECT role FROM nodes WHERE name = 'UnusedInterface'").get();
+    expect(role.role).toBe('dead-unresolved');
+  });
 });