fix(detector/typescript): emit anchor nodes for imports edges

The TypeScript structures detector was emitting imports edges with free-form
strings (file path → module name) as endpoints, but no matching CodeNode
existed for either side. Every imports edge got silently dropped at
GraphBuilder.Snapshot's phantom-edge filter.

On nuxt (1269 files, mostly TS): 3507 phantom edges out of 6923 total
emissions — half of all edges were dropped because the imports detector
was sending them into the void.

Fix:
- Emit a NodeModule for the current file (`ts:file:<path>`) once per file.
- Emit a NodeExternal for each imported module (`ts:external:<mod>`) once.
- Wire the imports edge through these node IDs.

Dedup via the GraphBuilder map collapses the per-file external nodes
across files (every file importing "react" gets one shared
ts:external:react target), so the graph also gets a real dependency
view at no extra cost.

Bench (nuxt re-index):
- Before: 4902 nodes, 2416 edges, 3507 phantom drops
- After:  5914 nodes, 4770 edges, 1153 phantom drops  (-67% phantoms)
- Deduped: 1807 nodes  (external modules collapsed across files)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

go/internal/detector/typescript/structures.go

@@ -143,10 +143,41 @@ func (d TypeScriptStructuresDetector) Detect(ctx *detector.Context) *detector.Re
 		nodes = append(nodes, mk(id, model.NodeEnum, name, base.FindLineNumber(text, m[0]), nil))
 	}
 
-	// Imports
+	// Imports — emit a SOURCE-side file node + an EXTERNAL/MODULE target node
+	// so the edge survives Snapshot's phantom-drop. Pre-fix, both endpoints
+	// were free-form strings (the file path and the module name) with no
+	// matching CodeNode anywhere, so every imports edge got dropped at
+	// snapshot. On large TypeScript repos (e.g. nuxt) that produced ~50%
+	// phantom-edge waste in the cache.
+	fileNodeID := "ts:file:" + fp
+	importTargets := make(map[string]bool)
 	for _, m := range tsImportRE.FindAllStringSubmatchIndex(text, -1) {
 		mod := text[m[2]:m[3]]
-		e := model.NewCodeEdge(fp+"->imports->"+mod, model.EdgeImports, fp, mod)
+		if importTargets[mod] {
+			continue
+		}
+		importTargets[mod] = true
+		// Ensure the file-as-source node exists once.
+		if !existing[fileNodeID] {
+			existing[fileNodeID] = true
+			fn := model.NewCodeNode(fileNodeID, model.NodeModule, fp)
+			fn.FilePath = fp
+			fn.Source = "TypeScriptStructuresDetector"
+			fn.Confidence = model.ConfidenceLexical
+			fn.Properties["module_type"] = "ts_file"
+			nodes = append(nodes, fn)
+		}
+		// Ensure the external module target node exists.
+		targetID := "ts:external:" + mod
+		if !existing[targetID] {
+			existing[targetID] = true
+			tn := model.NewCodeNode(targetID, model.NodeExternal, mod)
+			tn.Source = "TypeScriptStructuresDetector"
+			tn.Confidence = model.ConfidenceLexical
+			tn.Properties["module"] = mod
+			nodes = append(nodes, tn)
+		}
+		e := model.NewCodeEdge(fileNodeID+"->imports->"+targetID, model.EdgeImports, fileNodeID, targetID)
 		e.Source = "TypeScriptStructuresDetector"
 		e.Confidence = model.ConfidenceLexical
 		edges = append(edges, e)

go/internal/detector/typescript/structures_test.go

@@ -74,12 +74,25 @@ func TestTypeScriptStructuresPositive(t *testing.T) {
 	if enums != 1 {
 		t.Errorf("expected 1 enum, got %d", enums)
 	}
-	if modules != 1 {
-		t.Errorf("expected 1 module (namespace), got %d", modules)
+	// 1 namespace + 1 file-as-module (anchor for imports edges so they
+	// survive the GraphBuilder phantom-drop).
+	if modules != 2 {
+		t.Errorf("expected 2 modules (namespace + file), got %d", modules)
 	}
 	if len(r.Edges) != 2 {
 		t.Errorf("expected 2 imports, got %d", len(r.Edges))
 	}
+	// Each import target should also exist as an EXTERNAL node so the
+	// edge isn't dropped at snapshot.
+	var externals int
+	for _, n := range r.Nodes {
+		if n.Kind == model.NodeExternal {
+			externals++
+		}
+	}
+	if externals != 2 {
+		t.Errorf("expected 2 external module nodes (imports targets), got %d", externals)
+	}
 }
 
 func TestTypeScriptStructuresDeterminism(t *testing.T) {