@optave/codegraph 3.11.0 → 3.11.2

package/src/features/complexity.ts

@@ -31,44 +31,36 @@ const COMPLEXITY_EXTENSIONS = buildExtensionSet(COMPLEXITY_RULES);
 
 // ─── Halstead Metrics Computation ─────────────────────────────────────────
 
-export function computeHalsteadMetrics(
-  functionNode: TreeSitterNode,
-  language: string,
-): HalsteadDerivedMetrics | null {
-  const rules = HALSTEAD_RULES.get(language) as HalsteadRules | undefined;
-  if (!rules) return null;
-
-  const operators = new Map<string, number>(); // type -> count
-  const operands = new Map<string, number>(); // text -> count
-
-  function walk(node: TreeSitterNode | null): void {
-    if (!node) return;
-
-    // Skip type annotation subtrees
-    if (rules?.skipTypes.has(node.type)) return;
+/** Classify a tree-sitter node as a Halstead operator or operand,
+ *  updating the running counts. Pure helper extracted from computeHalsteadMetrics
+ *  to keep the dispatcher thin. */
+function classifyHalsteadToken(
+  node: TreeSitterNode,
+  rules: HalsteadRules,
+  operators: Map<string, number>,
+  operands: Map<string, number>,
+): void {
+  // Compound operators (non-leaf): count the node type as an operator
+  if (rules.compoundOperators.has(node.type)) {
+    operators.set(node.type, (operators.get(node.type) || 0) + 1);
+  }
 
-    // Compound operators (non-leaf): count the node type as an operator
-    if (rules?.compoundOperators.has(node.type)) {
+  // Leaf nodes: classify as operator or operand
+  if (node.childCount === 0) {
+    if (rules.operatorLeafTypes.has(node.type)) {
       operators.set(node.type, (operators.get(node.type) || 0) + 1);
-    }
-
-    // Leaf nodes: classify as operator or operand
-    if (node.childCount === 0) {
-      if (rules?.operatorLeafTypes.has(node.type)) {
-        operators.set(node.type, (operators.get(node.type) || 0) + 1);
-      } else if (rules?.operandLeafTypes.has(node.type)) {
-        const text = node.text;
-        operands.set(text, (operands.get(text) || 0) + 1);
-      }
-    }
-
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i));
+    } else if (rules.operandLeafTypes.has(node.type)) {
+      const text = node.text;
+      operands.set(text, (operands.get(text) || 0) + 1);
     }
   }
+}
 
-  walk(functionNode);
-
+/** Build a HalsteadDerivedMetrics summary from the raw operator/operand counts. */
+function summarizeHalsteadCounts(
+  operators: Map<string, number>,
+  operands: Map<string, number>,
+): HalsteadDerivedMetrics {
   const n1 = operators.size; // distinct operators
   const n2 = operands.size; // distinct operands
   let bigN1 = 0; // total operators
@@ -79,7 +71,6 @@ export function computeHalsteadMetrics(
   const vocabulary = n1 + n2;
   const length = bigN1 + bigN2;
 
-  // Guard against zero
   const volume = vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
   const difficulty = n2 > 0 ? (n1 / 2) * (bigN2 / n2) : 0;
   const effort = difficulty * volume;
@@ -99,6 +90,31 @@ export function computeHalsteadMetrics(
   };
 }
 
+export function computeHalsteadMetrics(
+  functionNode: TreeSitterNode,
+  language: string,
+): HalsteadDerivedMetrics | null {
+  const rules = HALSTEAD_RULES.get(language) as HalsteadRules | undefined;
+  if (!rules) return null;
+
+  const operators = new Map<string, number>(); // type -> count
+  const operands = new Map<string, number>(); // text -> count
+
+  function walk(node: TreeSitterNode | null): void {
+    if (!node) return;
+    // Skip type annotation subtrees
+    if (rules?.skipTypes.has(node.type)) return;
+    classifyHalsteadToken(node, rules as HalsteadRules, operators, operands);
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i));
+    }
+  }
+
+  walk(functionNode);
+
+  return summarizeHalsteadCounts(operators, operands);
+}
+
 // ─── LOC Metrics Computation ──────────────────────────────────────────────
 // Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
 export const computeLOCMetrics = _computeLOCMetrics;
@@ -535,6 +551,89 @@ function upsertAstComplexity(
   return 1;
 }
 
+/** Decision outcome for a single definition during native bulk-row collection.
+ *  - 'skip': the definition is legitimately ignorable (non-function, missing line,
+ *            interface stub, unsupported language).
+ *  - 'fallback': a genuine function body is missing precomputed complexity —
+ *                the whole native fast path must abort to JS.
+ *  - 'emit': the definition has complexity data and a row was (or will be) appended. */
+type NativeRowDecision = 'skip' | 'fallback' | 'emit';
+
+/** Classify a definition relative to the native bulk path. Returns
+ *  'skip' to ignore it, 'fallback' to bail out, or 'emit' if the row should be added. */
+function classifyDefinitionForNativeBulk(
+  def: FileSymbols['definitions'][0],
+  langSupported: boolean,
+): NativeRowDecision {
+  if (def.kind !== 'function' && def.kind !== 'method') return 'skip';
+  if (!def.line) return 'skip';
+  if (!def.complexity) {
+    // Interface/type property signatures and single-line stubs are extracted
+    // as methods but the native engine correctly never assigns complexity.
+    // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
+    // of the native bulk-insert path for every TypeScript codebase (#846).
+    if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) return 'skip';
+    // Languages without complexity rules will never have data — skip them
+    // rather than bailing out of the entire native bulk path.
+    if (!langSupported) return 'skip';
+    return 'fallback'; // genuine function body missing complexity — needs JS fallback
+  }
+  return 'emit';
+}
+
+/** Build a single native-bulk row from a definition with complexity data. */
+function buildNativeBulkRow(
+  nodeId: number,
+  def: FileSymbols['definitions'][0],
+): Record<string, unknown> {
+  const ch = def.complexity?.halstead;
+  const cl = def.complexity?.loc;
+  return {
+    nodeId,
+    cognitive: def.complexity?.cognitive ?? 0,
+    cyclomatic: def.complexity?.cyclomatic ?? 0,
+    maxNesting: def.complexity?.maxNesting ?? 0,
+    loc: cl ? cl.loc : 0,
+    sloc: cl ? cl.sloc : 0,
+    commentLines: cl ? cl.commentLines : 0,
+    halsteadN1: ch ? ch.n1 : 0,
+    halsteadN2: ch ? ch.n2 : 0,
+    halsteadBigN1: ch ? ch.bigN1 : 0,
+    halsteadBigN2: ch ? ch.bigN2 : 0,
+    halsteadVocabulary: ch ? ch.vocabulary : 0,
+    halsteadLength: ch ? ch.length : 0,
+    halsteadVolume: ch ? ch.volume : 0,
+    halsteadDifficulty: ch ? ch.difficulty : 0,
+    halsteadEffort: ch ? ch.effort : 0,
+    halsteadBugs: ch ? ch.bugs : 0,
+    maintainabilityIndex: def.complexity?.maintainabilityIndex ?? 0,
+  };
+}
+
+/** Try to collect a single file's definitions into native-bulk rows.
+ *  Returns 'fallback' if any definition forces a JS fallback. */
+function collectFileBulkRows(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: FileSymbols,
+  rows: Array<Record<string, unknown>>,
+): NativeRowDecision {
+  const ext = path.extname(relPath).toLowerCase();
+  const langId = symbols._langId || '';
+  const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
+
+  for (const def of symbols.definitions) {
+    const decision = classifyDefinitionForNativeBulk(def, langSupported);
+    if (decision === 'skip') continue;
+    if (decision === 'fallback') return 'fallback';
+
+    const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+    if (!nodeId) continue;
+    rows.push(buildNativeBulkRow(nodeId, def));
+  }
+  return 'emit';
+}
+
 /** Collect native bulk-insert rows from precomputed complexity data.
  *  Returns the rows array, or null if any definition is missing complexity
  *  (signalling that JS fallback is needed). */
@@ -543,53 +642,9 @@ function collectNativeBulkRows(
   fileSymbols: Map<string, FileSymbols>,
 ): Array<Record<string, unknown>> | null {
   const rows: Array<Record<string, unknown>> = [];
-
   for (const [relPath, symbols] of fileSymbols) {
-    const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || '';
-    const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
-
-    for (const def of symbols.definitions) {
-      if (def.kind !== 'function' && def.kind !== 'method') continue;
-      if (!def.line) continue;
-      // Interface/type property signatures and single-line stubs are extracted
-      // as methods but the native engine correctly never assigns complexity.
-      // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
-      // of the native bulk-insert path for every TypeScript codebase (#846).
-      if (!def.complexity) {
-        if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
-        // Languages without complexity rules will never have data — skip them
-        // rather than bailing out of the entire native bulk path.
-        if (!langSupported) continue;
-        return null; // genuine function body missing complexity — needs JS fallback
-      }
-      const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-      if (!nodeId) continue;
-      const ch = def.complexity.halstead;
-      const cl = def.complexity.loc;
-      rows.push({
-        nodeId,
-        cognitive: def.complexity.cognitive ?? 0,
-        cyclomatic: def.complexity.cyclomatic ?? 0,
-        maxNesting: def.complexity.maxNesting ?? 0,
-        loc: cl ? cl.loc : 0,
-        sloc: cl ? cl.sloc : 0,
-        commentLines: cl ? cl.commentLines : 0,
-        halsteadN1: ch ? ch.n1 : 0,
-        halsteadN2: ch ? ch.n2 : 0,
-        halsteadBigN1: ch ? ch.bigN1 : 0,
-        halsteadBigN2: ch ? ch.bigN2 : 0,
-        halsteadVocabulary: ch ? ch.vocabulary : 0,
-        halsteadLength: ch ? ch.length : 0,
-        halsteadVolume: ch ? ch.volume : 0,
-        halsteadDifficulty: ch ? ch.difficulty : 0,
-        halsteadEffort: ch ? ch.effort : 0,
-        halsteadBugs: ch ? ch.bugs : 0,
-        maintainabilityIndex: def.complexity.maintainabilityIndex ?? 0,
-      });
-    }
+    if (collectFileBulkRows(db, relPath, symbols, rows) === 'fallback') return null;
   }
-
   return rows;
 }
 

package/src/features/dataflow.ts

@@ -675,6 +675,51 @@ interface BfsParentEntry {
   expression: string;
 }
 
+type DataflowNeighbor = {
+  id: number;
+  file: string;
+  edge_kind: string;
+  expression: string;
+};
+
+interface DataflowBfsState {
+  visited: Set<number>;
+  parent: Map<number, BfsParentEntry>;
+  nextQueue: number[];
+  found: boolean;
+}
+
+/**
+ * Process a single neighbor in the dataflow BFS. Returns true once the target
+ * has been reached so the caller can stop expanding.
+ */
+function processDataflowNeighbor(
+  n: DataflowNeighbor,
+  currentId: number,
+  targetId: number,
+  noTests: boolean,
+  state: DataflowBfsState,
+): boolean {
+  if (noTests && isTestFile(n.file)) return false;
+  const entry: BfsParentEntry = {
+    parentId: currentId,
+    edgeKind: n.edge_kind,
+    expression: n.expression,
+  };
+  if (n.id === targetId) {
+    if (!state.found) {
+      state.found = true;
+      state.parent.set(n.id, entry);
+    }
+    return true;
+  }
+  if (state.visited.has(n.id)) return false;
+  state.visited.add(n.id);
+  state.parent.set(n.id, entry);
+  state.nextQueue.push(n.id);
+  return false;
+}
+
 /** BFS through dataflow edges to find a path from source to target. */
 function bfsDataflowPath(
   db: BetterSqlite3Database,
@@ -689,50 +734,28 @@ function bfsDataflowPath(
      WHERE d.source_id = ? AND d.kind IN ('flows_to', 'returns')`,
   );
 
-  const visited = new Set<number>([sourceId]);
-  const parent = new Map<number, BfsParentEntry>();
+  const state: DataflowBfsState = {
+    visited: new Set<number>([sourceId]),
+    parent: new Map<number, BfsParentEntry>(),
+    nextQueue: [],
+    found: false,
+  };
   let queue = [sourceId];
-  let found = false;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
-    const nextQueue: number[] = [];
+    state.nextQueue = [];
     for (const currentId of queue) {
-      const neighbors = neighborStmt.all(currentId) as Array<{
-        id: number;
-        file: string;
-        edge_kind: string;
-        expression: string;
-      }>;
+      const neighbors = neighborStmt.all(currentId) as DataflowNeighbor[];
       for (const n of neighbors) {
-        if (noTests && isTestFile(n.file)) continue;
-        if (n.id === targetId) {
-          if (!found) {
-            found = true;
-            parent.set(n.id, {
-              parentId: currentId,
-              edgeKind: n.edge_kind,
-              expression: n.expression,
-            });
-          }
-          continue;
-        }
-        if (!visited.has(n.id)) {
-          visited.add(n.id);
-          parent.set(n.id, {
-            parentId: currentId,
-            edgeKind: n.edge_kind,
-            expression: n.expression,
-          });
-          nextQueue.push(n.id);
-        }
+        processDataflowNeighbor(n, currentId, targetId, noTests, state);
       }
     }
-    if (found) break;
-    queue = nextQueue;
+    if (state.found) break;
+    queue = state.nextQueue;
     if (queue.length === 0) break;
   }
 
-  return found ? parent : null;
+  return state.found ? state.parent : null;
 }
 
 /** Reconstruct a path from BFS parent map. */

package/src/features/flow.ts

@@ -133,6 +133,41 @@ interface BfsState {
   truncated: boolean;
 }
 
+interface FlowBfsFrame {
+  visited: Set<number>;
+  cycles: Array<{ from: string; to: string; depth: number }>;
+  nodeDepths: Map<number, number>;
+  idToNode: Map<number, NodeInfo>;
+  nextFrontier: number[];
+  levelNodes: NodeInfo[];
+}
+
+/** Process one callee row, recording cycle hits or expanding frontier. */
+function processFlowCallee(
+  c: CalleeRow,
+  fid: number,
+  depth: number,
+  noTests: boolean,
+  frame: FlowBfsFrame,
+): void {
+  if (noTests && isTestFile(c.file)) return;
+
+  if (frame.visited.has(c.id)) {
+    const fromNode = frame.idToNode.get(fid);
+    if (fromNode) {
+      frame.cycles.push({ from: fromNode.name, to: c.name, depth });
+    }
+    return;
+  }
+
+  frame.visited.add(c.id);
+  frame.nextFrontier.push(c.id);
+  const nodeInfo: NodeInfo = toSymbolRef(c);
+  frame.levelNodes.push(nodeInfo);
+  frame.nodeDepths.set(c.id, depth);
+  frame.idToNode.set(c.id, nodeInfo);
+}
+
 /** Forward BFS through callees, collecting steps, cycles, and node depth info. */
 function bfsCallees(
   db: ReturnType<typeof openReadonlyOrFail>,
@@ -157,37 +192,26 @@ function bfsCallees(
   );
 
   for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier: number[] = [];
-    const levelNodes: NodeInfo[] = [];
+    const frame: FlowBfsFrame = {
+      visited,
+      cycles,
+      nodeDepths,
+      idToNode,
+      nextFrontier: [],
+      levelNodes: [],
+    };
 
     for (const fid of frontier) {
-      const callees = calleesStmt.all(fid);
-
-      for (const c of callees) {
-        if (noTests && isTestFile(c.file)) continue;
-
-        if (visited.has(c.id)) {
-          const fromNode = idToNode.get(fid);
-          if (fromNode) {
-            cycles.push({ from: fromNode.name, to: c.name, depth: d });
-          }
-          continue;
-        }
-
-        visited.add(c.id);
-        nextFrontier.push(c.id);
-        const nodeInfo: NodeInfo = toSymbolRef(c);
-        levelNodes.push(nodeInfo);
-        nodeDepths.set(c.id, d);
-        idToNode.set(c.id, nodeInfo);
+      for (const c of calleesStmt.all(fid)) {
+        processFlowCallee(c, fid, d, noTests, frame);
       }
     }
 
-    if (levelNodes.length > 0) {
-      steps.push({ depth: d, nodes: levelNodes });
+    if (frame.levelNodes.length > 0) {
+      steps.push({ depth: d, nodes: frame.levelNodes });
     }
 
-    frontier = nextFrontier;
+    frontier = frame.nextFrontier;
     if (frontier.length === 0) break;
     if (d === maxDepth && frontier.length > 0) truncated = true;
   }

package/src/features/graph-enrichment.ts

@@ -336,13 +336,13 @@ interface FileLevelEdge {
   target: string;
 }
 
-function prepareFileLevelData(
+/** Load file-level import/call edges from the DB and optionally exclude test files. */
+function loadFileLevelEdges(
   db: BetterSqlite3Database,
   noTests: boolean,
   minConf: number,
-  cfg: PlotConfig,
-): GraphData {
-  let edges = db
+): FileLevelEdge[] {
+  const edges = db
     .prepare<FileLevelEdge>(
       `
       SELECT DISTINCT n1.file AS source, n2.file AS target
@@ -354,73 +354,118 @@ function prepareFileLevelData(
     `,
     )
     .all(minConf);
-  if (noTests) edges = edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target));
-
-  const files = new Set<string>();
-  for (const { source, target } of edges) {
-    files.add(source);
-    files.add(target);
-  }
-
-  const fileIds = new Map<string, number>();
-  let idx = 0;
-  for (const f of files) fileIds.set(f, idx++);
+  return noTests ? edges.filter((e) => !isTestFile(e.source) && !isTestFile(e.target)) : edges;
+}
 
-  // Fan-in/fan-out
+/** Compute fan-in and fan-out for each file from a list of edges. */
+function computeFileFanCounts(edges: FileLevelEdge[]): {
+  fanInCount: Map<string, number>;
+  fanOutCount: Map<string, number>;
+} {
   const fanInCount = new Map<string, number>();
   const fanOutCount = new Map<string, number>();
   for (const { source, target } of edges) {
     fanOutCount.set(source, (fanOutCount.get(source) || 0) + 1);
     fanInCount.set(target, (fanInCount.get(target) || 0) + 1);
   }
+  return { fanInCount, fanOutCount };
+}
 
-  // Communities via graph subsystem
+/** Run Louvain community detection on the file-level graph. Returns empty map on failure. */
+function detectFileCommunities(files: Set<string>, edges: FileLevelEdge[]): Map<string, number> {
   const communityMap = new Map<string, number>();
-  if (files.size > 0) {
-    try {
-      const fileGraph = new CodeGraph();
-      for (const f of files) fileGraph.addNode(f);
-      for (const { source, target } of edges) {
-        if (source !== target && !fileGraph.hasEdge(source, target))
-          fileGraph.addEdge(source, target);
-      }
-      const { assignments } = louvainCommunities(fileGraph);
-      for (const [file, cid] of assignments) communityMap.set(file, cid);
-    } catch {
-      // ignore
+  if (files.size === 0) return communityMap;
+  try {
+    const fileGraph = new CodeGraph();
+    for (const f of files) fileGraph.addNode(f);
+    for (const { source, target } of edges) {
+      if (source !== target && !fileGraph.hasEdge(source, target))
+        fileGraph.addEdge(source, target);
     }
+    const { assignments } = louvainCommunities(fileGraph);
+    for (const [file, cid] of assignments) communityMap.set(file, cid);
+  } catch {
+    // louvain can fail on disconnected graphs
   }
+  return communityMap;
+}
 
-  const visNodes: VisNode[] = [...files].map((f) => {
-    const id = fileIds.get(f)!;
-    const community = communityMap.get(f) ?? null;
-    const fanIn = fanInCount.get(f) || 0;
-    const fanOut = fanOutCount.get(f) || 0;
-    const directory = path.dirname(f);
-    const color: string =
-      cfg.colorBy === 'community' && community !== null
-        ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
-        : cfg.nodeColors?.file || (DEFAULT_NODE_COLORS as Record<string, string>).file || '#ccc';
-
-    return {
-      id,
-      label: path.basename(f),
-      title: f,
-      color,
-      kind: 'file',
-      role: '',
-      file: f,
-      line: 0,
-      community,
-      cognitive: null,
-      cyclomatic: null,
-      maintainabilityIndex: null,
-      fanIn,
-      fanOut,
-      directory,
-      risk: [],
-    };
-  });
+/** Build a VisNode for a single file, applying color based on cfg.colorBy. */
+function buildFileVisNode(
+  file: string,
+  id: number,
+  community: number | null,
+  fanIn: number,
+  fanOut: number,
+  cfg: PlotConfig,
+): VisNode {
+  const color: string =
+    cfg.colorBy === 'community' && community !== null
+      ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
+      : cfg.nodeColors?.file || (DEFAULT_NODE_COLORS as Record<string, string>).file || '#ccc';
+
+  return {
+    id,
+    label: path.basename(file),
+    title: file,
+    color,
+    kind: 'file',
+    role: '',
+    file,
+    line: 0,
+    community,
+    cognitive: null,
+    cyclomatic: null,
+    maintainabilityIndex: null,
+    fanIn,
+    fanOut,
+    directory: path.dirname(file),
+    risk: [],
+  };
+}
+
+/** Select seed node IDs for the file-level graph based on configured strategy. */
+function selectFileSeedNodes(visNodes: VisNode[], cfg: PlotConfig): (number | string)[] {
+  if (cfg.seedStrategy === 'top-fanin') {
+    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
+    return sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
+  }
+  // Both 'entry' and the default fallback include every node — file-level graphs
+  // don't track per-file roles, so 'entry' has no meaningful filter.
+  return visNodes.map((n) => n.id);
+}
+
+function prepareFileLevelData(
+  db: BetterSqlite3Database,
+  noTests: boolean,
+  minConf: number,
+  cfg: PlotConfig,
+): GraphData {
+  const edges = loadFileLevelEdges(db, noTests, minConf);
+
+  const files = new Set<string>();
+  for (const { source, target } of edges) {
+    files.add(source);
+    files.add(target);
+  }
+
+  const fileIds = new Map<string, number>();
+  let idx = 0;
+  for (const f of files) fileIds.set(f, idx++);
+
+  const { fanInCount, fanOutCount } = computeFileFanCounts(edges);
+  const communityMap = detectFileCommunities(files, edges);
+
+  const visNodes: VisNode[] = [...files].map((f) =>
+    buildFileVisNode(
+      f,
+      fileIds.get(f)!,
+      communityMap.get(f) ?? null,
+      fanInCount.get(f) || 0,
+      fanOutCount.get(f) || 0,
+      cfg,
+    ),
+  );
 
   const visEdges: VisEdge[] = edges.map(({ source, target }, i) => ({
     id: `e${i}`,
@@ -428,17 +473,7 @@ function prepareFileLevelData(
     to: fileIds.get(target)!,
   }));
 
-  let seedNodeIds: (number | string)[];
-  if (cfg.seedStrategy === 'top-fanin') {
-    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
-    seedNodeIds = sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
-  } else if (cfg.seedStrategy === 'entry') {
-    seedNodeIds = visNodes.map((n) => n.id);
-  } else {
-    seedNodeIds = visNodes.map((n) => n.id);
-  }
-
-  return { nodes: visNodes, edges: visEdges, seedNodeIds };
+  return { nodes: visNodes, edges: visEdges, seedNodeIds: selectFileSeedNodes(visNodes, cfg) };
 }
 
 // ─── HTML Generation (thin wrapper) ──────────────────────────────────