fix: address code review findings

- graph: replace silent `if (existing)` guard with invariant assertion
- graph: extract merge values as consts for order-safe mutation
- test: assert `main` is dead in same-file call test (negative case)
- test: add call-graph-only class test (no import edge)
- test: verify all graphology attrs in edge merge sync test

Author: bntvllnt

src/analyzer/index.test.ts

@@ -327,6 +327,8 @@ describe("dead export detection", () => {
 
     const dead = result.fileMetrics.get("module.ts")?.deadExports;
     expect(dead).not.toContain("helper");
+    // main is exported but never called by anyone — should be dead
+    expect(dead).toContain("main");
   });
 
   it("class method calls mark the class as consumed", () => {
@@ -346,6 +348,23 @@ describe("dead export detection", () => {
     expect(dead).not.toContain("AuthService");
   });
 
+  it("class consumed via call graph only (no import edge)", () => {
+    const files = [
+      makeFile("service.ts", {
+        exports: [exp("MyClass", "class")],
+      }),
+      makeFile("caller.ts", {
+        // No import edge — only a call site references the class
+        callSites: [callSite("caller.ts", "init", "service.ts", "MyClass.create")],
+      }),
+    ];
+    const built = buildGraph(files);
+    const result = analyzeGraph(built, files);
+
+    const dead = result.fileMetrics.get("service.ts")?.deadExports;
+    expect(dead).not.toContain("MyClass");
+  });
+
   it("mixed dead and alive exports only flags dead ones", () => {
     const files = [
       makeFile("mixed.ts", {
@@ -393,8 +412,12 @@ describe("dead export detection", () => {
 
     // graphology edge attrs should match
     const graphSymbols = built.graph.getEdgeAttribute("source.ts", "target.ts", "symbols") as string[];
+    const graphWeight = built.graph.getEdgeAttribute("source.ts", "target.ts", "weight") as number;
+    const graphIsTypeOnly = built.graph.getEdgeAttribute("source.ts", "target.ts", "isTypeOnly") as boolean;
     expect(graphSymbols).toContain("valFn");
     expect(graphSymbols).toContain("TypeB");
+    expect(graphWeight).toBe(2);
+    expect(graphIsTypeOnly).toBe(false);
   });
 });
 

src/graph/index.ts

@@ -79,16 +79,19 @@ export function buildGraph(files: ParsedFile[]): BuiltGraph {
       } else {
         // Merge symbols from duplicate import into existing edge
         const existing = edges.find((e) => e.source === file.relativePath && e.target === target);
-        if (existing) {
-          const merged = [...new Set([...existing.symbols, ...imp.symbols])];
-          existing.symbols = merged;
-          existing.weight = merged.length || 1;
-          existing.isTypeOnly = existing.isTypeOnly && imp.isTypeOnly;
-          // Sync graphology edge attributes
-          graph.setEdgeAttribute(file.relativePath, target, "symbols", merged);
-          graph.setEdgeAttribute(file.relativePath, target, "weight", merged.length || 1);
-          graph.setEdgeAttribute(file.relativePath, target, "isTypeOnly", existing.isTypeOnly);
+        if (!existing) {
+          throw new Error(`Invariant violation: edge ${file.relativePath} → ${target} exists in graph but missing from edges[]`);
         }
+        const merged = [...new Set([...existing.symbols, ...imp.symbols])];
+        const mergedWeight = merged.length || 1;
+        const mergedIsTypeOnly = existing.isTypeOnly && imp.isTypeOnly;
+        existing.symbols = merged;
+        existing.weight = mergedWeight;
+        existing.isTypeOnly = mergedIsTypeOnly;
+        // Sync graphology edge attributes
+        graph.setEdgeAttribute(file.relativePath, target, "symbols", merged);
+        graph.setEdgeAttribute(file.relativePath, target, "weight", mergedWeight);
+        graph.setEdgeAttribute(file.relativePath, target, "isTypeOnly", mergedIsTypeOnly);
       }
     }
   }