@optave/codegraph 3.13.0 → 3.15.0

package/src/features/manifesto.ts

@@ -157,17 +157,27 @@ interface ManifestoOpts {
   offset?: number;
 }
 
-function evaluateFunctionRules(
-  db: BetterSqlite3Database,
+interface EvaluateRulesContext {
+  defs: RuleDef[];
+  rows: Array<Record<string, unknown>>;
+}
+
+/**
+ * Shared rule-evaluation loop used by both evaluateFunctionRules and evaluateFileRules.
+ * Iterates rows, applies threshold checks for each active rule definition, and
+ * accumulates violations + per-rule worst-status tracking into ruleResults.
+ */
+function evaluateRules(
+  ctx: EvaluateRulesContext,
   rules: ResolvedRules,
-  opts: ManifestoOpts,
   violations: Violation[],
   ruleResults: RuleResult[],
 ): void {
-  const functionDefs = RULE_DEFS.filter((d) => d.level === 'function');
-  const activeDefs = functionDefs.filter((d) => isEnabled(rules[d.name]!));
+  const { defs, rows } = ctx;
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
+
   if (activeDefs.length === 0) {
-    for (const def of functionDefs) {
+    for (const def of defs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
@@ -179,39 +189,9 @@ function evaluateFunctionRules(
     return;
   }
 
-  let where = "WHERE n.kind IN ('function','method')";
-  const params: unknown[] = [];
-  if (opts.noTests) where += NO_TEST_SQL;
-  {
-    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
-    where += fc.sql;
-    params.push(...fc.params);
-  }
-  if (opts.kind) {
-    where += ' AND n.kind = ?';
-    params.push(opts.kind);
-  }
-
-  let rows: Array<Record<string, unknown>>;
-  try {
-    rows = db
-      .prepare(
-        `SELECT n.name, n.kind, n.file, n.line,
-                fc.cognitive, fc.cyclomatic, fc.max_nesting
-         FROM function_complexity fc
-         JOIN nodes n ON fc.node_id = n.id
-         ${where}`,
-      )
-      .all(...params) as Array<Record<string, unknown>>;
-  } catch (err: unknown) {
-    debug(`manifesto function query failed: ${(err as Error).message}`);
-    rows = [];
-  }
-
-  // Track worst status per rule
   const worst: Record<string, string> = {};
   const counts: Record<string, number> = {};
-  for (const def of functionDefs) {
+  for (const def of defs) {
     worst[def.name] = 'pass';
     counts[def.name] = 0;
   }
@@ -234,7 +214,7 @@ function evaluateFunctionRules(
     }
   }
 
-  for (const def of functionDefs) {
+  for (const def of defs) {
     ruleResults.push({
       name: def.name,
       level: def.level,
@@ -245,6 +225,60 @@ function evaluateFunctionRules(
   }
 }
 
+function evaluateFunctionRules(
+  db: BetterSqlite3Database,
+  rules: ResolvedRules,
+  opts: ManifestoOpts,
+  violations: Violation[],
+  ruleResults: RuleResult[],
+): void {
+  const defs = RULE_DEFS.filter((d) => d.level === 'function');
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
+  if (activeDefs.length === 0) {
+    for (const def of defs) {
+      ruleResults.push({
+        name: def.name,
+        level: def.level,
+        status: 'pass',
+        thresholds: rules[def.name]!,
+        violationCount: 0,
+      });
+    }
+    return;
+  }
+
+  let where = "WHERE n.kind IN ('function','method')";
+  const params: unknown[] = [];
+  if (opts.noTests) where += NO_TEST_SQL;
+  {
+    const fc = buildFileConditionSQL(opts.file as string, 'n.file');
+    where += fc.sql;
+    params.push(...fc.params);
+  }
+  if (opts.kind) {
+    where += ' AND n.kind = ?';
+    params.push(opts.kind);
+  }
+
+  let rows: Array<Record<string, unknown>>;
+  try {
+    rows = db
+      .prepare(
+        `SELECT n.name, n.kind, n.file, n.line,
+                fc.cognitive, fc.cyclomatic, fc.max_nesting
+         FROM function_complexity fc
+         JOIN nodes n ON fc.node_id = n.id
+         ${where}`,
+      )
+      .all(...params) as Array<Record<string, unknown>>;
+  } catch (err: unknown) {
+    debug(`manifesto function query failed: ${(err as Error).message}`);
+    rows = [];
+  }
+
+  evaluateRules({ defs, rows }, rules, violations, ruleResults);
+}
+
 function evaluateFileRules(
   db: BetterSqlite3Database,
   rules: ResolvedRules,
@@ -252,10 +286,10 @@ function evaluateFileRules(
   violations: Violation[],
   ruleResults: RuleResult[],
 ): void {
-  const fileDefs = RULE_DEFS.filter((d) => d.level === 'file');
-  const activeDefs = fileDefs.filter((d) => isEnabled(rules[d.name]!));
+  const defs = RULE_DEFS.filter((d) => d.level === 'file');
+  const activeDefs = defs.filter((d) => isEnabled(rules[d.name]!));
   if (activeDefs.length === 0) {
-    for (const def of fileDefs) {
+    for (const def of defs) {
       ruleResults.push({
         name: def.name,
         level: def.level,
@@ -293,40 +327,7 @@ function evaluateFileRules(
     rows = [];
   }
 
-  const worst: Record<string, string> = {};
-  const counts: Record<string, number> = {};
-  for (const def of fileDefs) {
-    worst[def.name] = 'pass';
-    counts[def.name] = 0;
-  }
-
-  for (const row of rows) {
-    for (const def of activeDefs) {
-      const value = row[def.metric] as number | null;
-      if (value == null) continue;
-      const meta = {
-        name: row.name as string,
-        file: row.file as string,
-        line: row.line as number,
-      };
-      const status = checkThreshold(def.name, rules[def.name]!, value, meta, violations);
-      if (status !== 'pass') {
-        counts[def.name] = (counts[def.name] ?? 0) + 1;
-        if (status === 'fail') worst[def.name] = 'fail';
-        else if (worst[def.name] !== 'fail') worst[def.name] = 'warn';
-      }
-    }
-  }
-
-  for (const def of fileDefs) {
-    ruleResults.push({
-      name: def.name,
-      level: def.level,
-      status: worst[def.name]!,
-      thresholds: rules[def.name]!,
-      violationCount: counts[def.name] ?? 0,
-    });
-  }
+  evaluateRules({ defs, rows }, rules, violations, ruleResults);
 }
 
 function evaluateGraphRules(

package/src/features/sequence.ts

@@ -10,6 +10,34 @@ import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
 // ─── Alias generation ────────────────────────────────────────────────
 
+/** Build aliases for a group of paths that share the same basename.
+ *  Progressively adds parent dirs until all aliases are unique. */
+function resolveCollisionAliases(paths: string[], aliases: Map<string, string>): void {
+  for (let depth = 2; depth <= 10; depth++) {
+    const trial = new Map<string, string>();
+    let allUnique = true;
+    const seen = new Set<string>();
+
+    for (const p of paths) {
+      const parts = p.replace(/\.[^.]+$/, '').split('/');
+      const alias = parts
+        .slice(-depth)
+        .join('_')
+        .replace(/[^a-zA-Z0-9_-]/g, '_');
+      trial.set(p, alias);
+      if (seen.has(alias)) allUnique = false;
+      seen.add(alias);
+    }
+
+    if (allUnique || depth === 10) {
+      for (const [p, alias] of trial) {
+        aliases.set(p, alias);
+      }
+      break;
+    }
+  }
+}
+
 function buildAliases(files: string[]): Map<string, string> {
   const aliases = new Map<string, string>();
   const basenames = new Map<string, string[]>();
@@ -26,29 +54,7 @@ function buildAliases(files: string[]): Map<string, string> {
       aliases.set(paths[0]!, base);
     } else {
       // Collision — progressively add parent dirs until aliases are unique
-      for (let depth = 2; depth <= 10; depth++) {
-        const trial = new Map<string, string>();
-        let allUnique = true;
-        const seen = new Set<string>();
-
-        for (const p of paths) {
-          const parts = p.replace(/\.[^.]+$/, '').split('/');
-          const alias = parts
-            .slice(-depth)
-            .join('_')
-            .replace(/[^a-zA-Z0-9_-]/g, '_');
-          trial.set(p, alias);
-          if (seen.has(alias)) allUnique = false;
-          seen.add(alias);
-        }
-
-        if (allUnique || depth === 10) {
-          for (const [p, alias] of trial) {
-            aliases.set(p, alias);
-          }
-          break;
-        }
-      }
+      resolveCollisionAliases(paths, aliases);
     }
   }
 

package/src/features/snapshot.ts

@@ -25,6 +25,41 @@ interface SnapshotSaveOptions {
   force?: boolean;
 }
 
+/**
+ * Atomically place `tmp` at `dest`.
+ * - force=true: renameSync (overwrites any existing file).
+ * - force=false: linkSync so EEXIST is detected atomically; then unlink tmp.
+ * Callers are responsible for cleaning up `tmp` on any thrown error.
+ */
+function atomicPlaceFile(tmp: string, dest: string, name: string, force?: boolean): void {
+  if (force) {
+    // renameSync overwrites atomically — the correct semantics for --force.
+    fs.renameSync(tmp, dest);
+    return;
+  }
+
+  // Non-force path: linkSync fails atomically with EEXIST if dest exists,
+  // closing the TOCTOU window between existsSync above and the final
+  // placement. We then unlink the temp file; on POSIX and NTFS, link
+  // creates a second reference so tmp can safely be removed.
+  try {
+    fs.linkSync(tmp, dest);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
+      throw new ConfigError(`Snapshot "${name}" already exists. Use --force to overwrite.`);
+    }
+    throw err;
+  }
+  try {
+    fs.unlinkSync(tmp);
+  } catch (cleanupErr) {
+    // Best-effort — dest is already in place, so a leftover tmp file is
+    // harmless. Log at debug so repeated failures surface during
+    // troubleshooting without noising up normal operation.
+    debug(`snapshotSave: failed to remove temp file ${tmp}: ${cleanupErr}`);
+  }
+}
+
 export function snapshotSave(
   name: string,
   options: SnapshotSaveOptions = {},
@@ -73,31 +108,7 @@ export function snapshotSave(
   }
 
   try {
-    if (options.force) {
-      // renameSync overwrites atomically — the correct semantics for --force.
-      fs.renameSync(tmp, dest);
-    } else {
-      // Non-force path: linkSync fails atomically with EEXIST if dest exists,
-      // closing the TOCTOU window between existsSync above and the final
-      // placement. We then unlink the temp file; on POSIX and NTFS, link
-      // creates a second reference so tmp can safely be removed.
-      try {
-        fs.linkSync(tmp, dest);
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
-          throw new ConfigError(`Snapshot "${name}" already exists. Use --force to overwrite.`);
-        }
-        throw err;
-      }
-      try {
-        fs.unlinkSync(tmp);
-      } catch (cleanupErr) {
-        // Best-effort — dest is already in place, so a leftover tmp file is
-        // harmless. Log at debug so repeated failures surface during
-        // troubleshooting without noising up normal operation.
-        debug(`snapshotSave: failed to remove temp file ${tmp}: ${cleanupErr}`);
-      }
-    }
+    atomicPlaceFile(tmp, dest, name, options.force);
   } catch (err) {
     try {
       fs.unlinkSync(tmp);

package/src/features/structure.ts

@@ -90,6 +90,44 @@ interface SqliteStatement {
   run(...params: unknown[]): unknown;
 }
 
+/** Insert file→parent-directory contains edges (incremental-aware). */
+function insertFileToParentEdges(
+  insertEdge: SqliteStatement,
+  getNodeIdStmt: NodeIdStmt,
+  fileSymbols: Map<string, FileSymbolData>,
+  affectedDirs: Set<string> | null,
+): void {
+  for (const relPath of fileSymbols.keys()) {
+    const dir = normalizePath(path.dirname(relPath));
+    if (!dir || dir === '.') continue;
+    if (affectedDirs && !affectedDirs.has(dir)) continue;
+    const dirRow = getNodeIdStmt.get(dir, 'directory', dir, 0);
+    const fileRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (dirRow && fileRow) {
+      insertEdge.run(dirRow.id, fileRow.id, 'contains', 1.0, 0);
+    }
+  }
+}
+
+/** Insert child-directory→parent-directory contains edges (incremental-aware). */
+function insertDirToParentEdges(
+  insertEdge: SqliteStatement,
+  getNodeIdStmt: NodeIdStmt,
+  allDirs: Set<string>,
+  affectedDirs: Set<string> | null,
+): void {
+  for (const dir of allDirs) {
+    const parent = normalizePath(path.dirname(dir));
+    if (!parent || parent === '.' || parent === dir) continue;
+    if (affectedDirs && !affectedDirs.has(parent)) continue;
+    const parentRow = getNodeIdStmt.get(parent, 'directory', parent, 0);
+    const childRow = getNodeIdStmt.get(dir, 'directory', dir, 0);
+    if (parentRow && childRow) {
+      insertEdge.run(parentRow.id, childRow.id, 'contains', 1.0, 0);
+    }
+  }
+}
+
 function insertContainsEdges(
   db: BetterSqlite3Database,
   insertEdge: SqliteStatement,
@@ -102,26 +140,8 @@ function insertContainsEdges(
   const affectedDirs = isIncremental ? getAncestorDirs(changedFiles ?? []) : null;
 
   db.transaction(() => {
-    for (const relPath of fileSymbols.keys()) {
-      const dir = normalizePath(path.dirname(relPath));
-      if (!dir || dir === '.') continue;
-      if (affectedDirs && !affectedDirs.has(dir)) continue;
-      const dirRow = getNodeIdStmt.get(dir, 'directory', dir, 0);
-      const fileRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-      if (dirRow && fileRow) {
-        insertEdge.run(dirRow.id, fileRow.id, 'contains', 1.0, 0);
-      }
-    }
-    for (const dir of allDirs) {
-      const parent = normalizePath(path.dirname(dir));
-      if (!parent || parent === '.' || parent === dir) continue;
-      if (affectedDirs && !affectedDirs.has(parent)) continue;
-      const parentRow = getNodeIdStmt.get(parent, 'directory', parent, 0);
-      const childRow = getNodeIdStmt.get(dir, 'directory', dir, 0);
-      if (parentRow && childRow) {
-        insertEdge.run(parentRow.id, childRow.id, 'contains', 1.0, 0);
-      }
-    }
+    insertFileToParentEdges(insertEdge, getNodeIdStmt, fileSymbols, affectedDirs);
+    insertDirToParentEdges(insertEdge, getNodeIdStmt, allDirs, affectedDirs);
   })();
 }
 
@@ -249,40 +269,59 @@ function buildFileToAncestorDirs(dirFiles: Map<string, string[]>): Map<string, S
   return fileToAncestorDirs;
 }
 
+/** Initialise a zero-count map for all known directories. */
+function initDirEdgeCounts(
+  allDirs: Set<string>,
+): Map<string, { intra: number; fanIn: number; fanOut: number }> {
+  const m = new Map<string, { intra: number; fanIn: number; fanOut: number }>();
+  for (const dir of allDirs) m.set(dir, { intra: 0, fanIn: 0, fanOut: 0 });
+  return m;
+}
+
+/** Accumulate source-side (intra / fanOut) counts for one import edge. */
+function accumulateSrcDirCounts(
+  srcDirs: Set<string>,
+  tgtDirs: Set<string> | undefined,
+  dirEdgeCounts: Map<string, { intra: number; fanIn: number; fanOut: number }>,
+): void {
+  for (const dir of srcDirs) {
+    const counts = dirEdgeCounts.get(dir);
+    if (!counts) continue;
+    if (tgtDirs?.has(dir)) {
+      counts.intra++;
+    } else {
+      counts.fanOut++;
+    }
+  }
+}
+
+/** Accumulate target-side (fanIn) counts for one import edge. */
+function accumulateTgtDirCounts(
+  tgtDirs: Set<string>,
+  srcDirs: Set<string> | undefined,
+  dirEdgeCounts: Map<string, { intra: number; fanIn: number; fanOut: number }>,
+): void {
+  for (const dir of tgtDirs) {
+    if (srcDirs?.has(dir)) continue;
+    const counts = dirEdgeCounts.get(dir);
+    if (!counts) continue;
+    counts.fanIn++;
+  }
+}
+
 /** Count intra-directory, fan-in, and fan-out edges per directory. */
 function countDirectoryEdges(
   allDirs: Set<string>,
   importEdges: ImportEdge[],
   fileToAncestorDirs: Map<string, Set<string>>,
 ): Map<string, { intra: number; fanIn: number; fanOut: number }> {
-  const dirEdgeCounts = new Map<string, { intra: number; fanIn: number; fanOut: number }>();
-  for (const dir of allDirs) {
-    dirEdgeCounts.set(dir, { intra: 0, fanIn: 0, fanOut: 0 });
-  }
+  const dirEdgeCounts = initDirEdgeCounts(allDirs);
   for (const { source_file, target_file } of importEdges) {
     const srcDirs = fileToAncestorDirs.get(source_file);
     const tgtDirs = fileToAncestorDirs.get(target_file);
     if (!srcDirs && !tgtDirs) continue;
-
-    if (srcDirs) {
-      for (const dir of srcDirs) {
-        const counts = dirEdgeCounts.get(dir);
-        if (!counts) continue;
-        if (tgtDirs?.has(dir)) {
-          counts.intra++;
-        } else {
-          counts.fanOut++;
-        }
-      }
-    }
-    if (tgtDirs) {
-      for (const dir of tgtDirs) {
-        if (srcDirs?.has(dir)) continue;
-        const counts = dirEdgeCounts.get(dir);
-        if (!counts) continue;
-        counts.fanIn++;
-      }
-    }
+    if (srcDirs) accumulateSrcDirCounts(srcDirs, tgtDirs, dirEdgeCounts);
+    if (tgtDirs) accumulateTgtDirCounts(tgtDirs, srcDirs, dirEdgeCounts);
   }
   return dirEdgeCounts;
 }
@@ -541,15 +580,50 @@ interface CallableNodeRow {
   fan_out: number;
 }
 
-/** Build the activeFiles set: files with at least one callable connected to the graph. */
-function buildActiveFilesSet(rows: CallableNodeRow[]): Set<string> {
+/**
+ * Kinds that are consumed via annotations/references rather than calls.
+ * These do not count as "active callables" for the hasActiveFileSiblings heuristic.
+ */
+const ANNOTATION_ONLY_KINDS = new Set([
+  'constant',
+  'struct',
+  'enum',
+  'trait',
+  'type',
+  'interface',
+  'record',
+]);
+
+/**
+ * Build two active-files sets from callable rows:
+ *
+ * - `activeFiles`: files with at least one non-annotation-only callable with
+ *   `fan_in > 0 || fan_out > 0`. Used for annotation-only kinds (constants,
+ *   type defs) which have no callers by design.
+ *
+ * - `calledActiveFiles`: files with at least one non-annotation-only callable
+ *   with `fan_in > 0` (strictly called). Used for method/function kinds to
+ *   prevent a self-sibling loop: a function with `fanIn=0, fanOut>0` as the
+ *   only callable in its file must NOT count itself as an "active sibling" and
+ *   thus promote itself to `leaf`.
+ */
+function buildActiveFilesSet(rows: CallableNodeRow[]): {
+  activeFiles: Set<string>;
+  calledActiveFiles: Set<string>;
+} {
   const activeFiles = new Set<string>();
+  const calledActiveFiles = new Set<string>();
   for (const r of rows) {
-    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
-      activeFiles.add(r.file);
+    if (!ANNOTATION_ONLY_KINDS.has(r.kind)) {
+      if (r.fan_in > 0 || r.fan_out > 0) {
+        activeFiles.add(r.file);
+      }
+      if (r.fan_in > 0) {
+        calledActiveFiles.add(r.file);
+      }
     }
   }
-  return activeFiles;
+  return { activeFiles, calledActiveFiles };
 }
 
 /** Map callable rows to classifier input objects, attaching exported/prod-fan-in/active-file metadata. */
@@ -558,6 +632,7 @@ function buildClassifierInput(
   exportedIds: Set<number>,
   prodFanInMap: Map<number, number>,
   activeFiles: Set<string>,
+  calledActiveFiles: Set<string>,
 ): Array<{
   id: string;
   name: string;
@@ -578,7 +653,20 @@ function buildClassifierInput(
     fanOut: r.fan_out,
     isExported: exportedIds.has(r.id),
     productionFanIn: prodFanInMap.get(r.id) || 0,
-    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
+    // Set hasActiveFileSiblings for annotation-only kinds (constants, type defs)
+    // AND for method/function — the latter two can have fanIn === 0 due to
+    // untraced call-site patterns (interface dispatch, logical-or defaults).
+    // The classifier interprets this field differently per kind (see classifyUnreferencedNode).
+    //
+    // IMPORTANT: method/function use calledActiveFiles (fan_in > 0 only) to
+    // prevent a self-sibling false negative: a function with fanIn=0, fanOut>0
+    // as the sole callable in its file must NOT see its own file as "active"
+    // and promote itself to leaf.
+    hasActiveFileSiblings: ANNOTATION_ONLY_KINDS.has(r.kind)
+      ? activeFiles.has(r.file)
+      : r.kind === 'method' || r.kind === 'function'
+        ? calledActiveFiles.has(r.file)
+        : undefined,
   }));
 }
 
@@ -660,7 +748,8 @@ function readCachedMedians(db: BetterSqlite3Database): { fanIn: number; fanOut:
     )
       return null;
     return { fanIn: cached.fanIn, fanOut: cached.fanOut };
-  } catch {
+  } catch (e) {
+    debug(`readCachedMedians: failed to parse cached medians — ${e}`);
     return null;
   }
 }
@@ -761,6 +850,20 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
     .all() as { id: number }[];
   for (const r of reexportExported) exportedIds.add(r.id);
 
+  // Mark symbols with exported=1 as exported — the extractor sets this flag when the
+  // author writes `export interface Foo { }` / `export type Bar = ...` / `export function`.
+  // Cross-file edge inference misses these when the symbol is only used as a type annotation
+  // within the same file (no calls/imports-type edge is produced for same-file type usage).
+  // This fixes false dead-unresolved classification for exported interfaces with no external callers (#1583).
+  const explicitlyExported = db
+    .prepare(
+      `SELECT id FROM nodes
+      WHERE exported = 1
+        AND kind NOT IN ('file', 'directory', 'parameter', 'property')`,
+    )
+    .all() as { id: number }[];
+  for (const r of explicitlyExported) exportedIds.add(r.id);
+
   // Compute production fan-in (excluding callers in test files)
   const prodFanInMap = new Map<number, number>();
   const prodRows = db
@@ -781,8 +884,14 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
   // Compute medians from the already-loaded rows (no extra DB round-trip),
   // pass them as overrides to avoid recomputing inside classifyRoles,
   // and cache them for subsequent incremental builds.
-  const activeFiles = buildActiveFilesSet(rows);
-  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
+  const { activeFiles, calledActiveFiles } = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(
+    rows,
+    exportedIds,
+    prodFanInMap,
+    activeFiles,
+    calledActiveFiles,
+  );
   const nonZeroFanIn = classifierInput
     .filter((n) => n.fanIn > 0)
     .map((n) => n.fanIn)
@@ -928,6 +1037,21 @@ function classifyNodeRolesIncremental(
     .all(...allAffectedFiles) as { id: number }[];
   for (const r of reexportExported) exportedIds.add(r.id);
 
+  // 3c. Mark symbols with exported=1 as exported — the extractor sets this flag when the
+  // author writes `export interface Foo { }` / `export type Bar = ...` / `export function`.
+  // Cross-file edge inference misses these when the symbol is only used as a type annotation
+  // within the same file (no calls/imports-type edge is produced for same-file type usage).
+  // Scoped to affected files only for the incremental path (#1583).
+  const explicitlyExported = db
+    .prepare(
+      `SELECT id FROM nodes
+      WHERE exported = 1
+        AND kind NOT IN ('file', 'directory', 'parameter', 'property')
+        AND file IN (${placeholders})`,
+    )
+    .all(...allAffectedFiles) as { id: number }[];
+  for (const r of explicitlyExported) exportedIds.add(r.id);
+
   // 4. Production fan-in for affected nodes only
   const prodFanInMap = new Map<number, number>();
   const prodRows = db
@@ -947,8 +1071,14 @@ function classifyNodeRolesIncremental(
   }
 
   // 5. Classify affected nodes using global medians
-  const activeFiles = buildActiveFilesSet(rows);
-  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
+  const { activeFiles, calledActiveFiles } = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(
+    rows,
+    exportedIds,
+    prodFanInMap,
+    activeFiles,
+    calledActiveFiles,
+  );
   const roleMap = classifyRoles(classifierInput, globalMedians);
 
   // 6. Build summary (only for affected nodes) and update only those nodes