ttsc 0.23.0 → 0.25.0

package/internal/graph/assigned_implementations_of_declaration_file_symbols_leave_no_edge_source_test.go

@@ -0,0 +1,84 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// ambientGlobalFixtureTSConfig compiles a project that declares an ambient
+// global in its own `.d.ts` and assigns the implementation in a sibling source.
+// Both files are named because a global augmentation only reaches the program
+// when its declaration file is an input.
+const ambientGlobalFixtureTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/globals.d.ts", "src/main.ts"]
+}
+`
+
+// TestAssignedImplementationsOfDeclarationFileSymbolsLeaveNoEdgeSource verifies
+// that assigning a function to a symbol declared in a declaration file records
+// no edge leaving the external boundary leaf that symbol enters the graph as.
+//
+// An external leaf has no outgoing side: the graph never walks a dependency's
+// internals, and no shard may hold an edge whose source is one — an external
+// node is owned by the non-source external shard, which is forbidden to own
+// edges. Attributing the assigned body to it therefore did not merely misplace
+// facts (with evidence offsets from the implementation read against the
+// declaration file); it produced a snapshot `ttscgraph serve` could not
+// assemble, so every request against such a project failed. The calls the body
+// makes are not lost by refusing it: the module that runs the assignment owns
+// them.
+//
+//  1. Compile a fixture whose `src/globals.d.ts` declares `var patched` in a
+//     global augmentation and whose `src/main.ts` assigns an arrow function to
+//     it that calls a local `helper`.
+//  2. Build the graph.
+//  3. Assert no edge leaves an external node, and that `main.ts`'s module node
+//     still owns the value-call edge to `helper`.
+func TestAssignedImplementationsOfDeclarationFileSymbolsLeaveNoEdgeSource(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), ambientGlobalFixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "globals.d.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  mainPath := sourceFile(t, prog, "main.ts").FileName()
+
+  for _, edge := range graph.Edges {
+    node, ok := graph.Nodes[edge.From]
+    if ok && node.External {
+      t.Fatalf("edge leaves the external boundary: %s -> %s (%s), source declared in %s", edge.From, edge.To, edge.Kind, node.File)
+    }
+  }
+
+  module := moduleID(mainPath)
+  helper := nodeID(mainPath, "helper", NodeFunction)
+  if !hasEdge(graph, module, helper, EdgeValueCall) {
+    t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/assigned_implementations_of_node_modules_symbols_leave_no_edge_source_test.go

@@ -0,0 +1,85 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// nodeModulesGlobalFixtureTSConfig compiles a project whose ambient global is
+// declared by a dependency's raw `.ts` source. Both inputs are named because
+// the declaring file is reached by neither an import nor a glob, and no
+// `rootDir` or `outDir` is set because a `node_modules` input under one would
+// be an input outside the root.
+const nodeModulesGlobalFixtureTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true
+  },
+  "files": ["node_modules/dep/globals.ts", "src/main.ts"]
+}
+`
+
+// TestAssignedImplementationsOfNodeModulesSymbolsLeaveNoEdgeSource verifies the
+// other half of the external boundary: a symbol declared under `node_modules`
+// gains no outgoing edge from an assignment either.
+//
+// `IsWorkspaceSourceFile` refuses a file for two disjoint reasons, and only one
+// of them is being a declaration file. A dependency that ships raw TypeScript
+// is not a declaration file and still owns no facts in this graph, so an
+// assignment to something it declares must be refused by the same rule. Without
+// this case the fix is pinned on one branch of the classifier and a change to
+// the other would pass.
+//
+//  1. Compile a fixture whose `node_modules/dep/globals.ts` declares `var
+//     patched` in a global augmentation and whose `src/main.ts` assigns an arrow
+//     function to it that calls a local `helper`.
+//  2. Build the graph.
+//  3. Assert no edge leaves an external node, and that `main.ts`'s module node
+//     still owns the value-call edge to `helper`.
+func TestAssignedImplementationsOfNodeModulesSymbolsLeaveNoEdgeSource(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), nodeModulesGlobalFixtureTSConfig)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "package.json"), `{
+  "name": "dep",
+  "version": "1.0.0"
+}
+`)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "globals.ts"), `declare global {
+  var patched: (message: string) => void;
+}
+export {};
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+patched = (message: string): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  mainPath := sourceFile(t, prog, "main.ts").FileName()
+
+  for _, edge := range graph.Edges {
+    node, ok := graph.Nodes[edge.From]
+    if ok && node.External {
+      t.Fatalf("edge leaves the external boundary: %s -> %s (%s), source declared in %s", edge.From, edge.To, edge.Kind, node.File)
+    }
+  }
+
+  module := moduleID(mainPath)
+  helper := nodeID(mainPath, "helper", NodeFunction)
+  if !hasEdge(graph, module, helper, EdgeValueCall) {
+    t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/build.go

@@ -8,23 +8,53 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// Build walks the program's user-authored source files and records a node for
-// each top-level declaration. driver.SourceFiles already drops declaration files
-// and the program never compiles a dependency's `.ts`, so every node Build emits
-// is workspace source: External is false. External boundary leaves enter the
-// graph only as the resolved target of an edge (see Resolve).
+// Build walks the program's workspace source files and records a node for
+// each top-level declaration. The checker can load a dependency's raw `.ts`
+// entry, so IsWorkspaceSourceFile owns the declaration boundary instead of
+// assuming every non-declaration source is authored here. External boundary
+// leaves enter the graph only as the resolved target of an edge (see Resolve).
 func Build(prog *driver.Program) *Graph {
+  return BuildFiles(prog, nil, nil)
+}
+
+// BuildFiles resolves graph facts owned by selected source files against one
+// immutable Program. A nil selection preserves Build's complete-project
+// behavior. A non-nil selection emits only replacement nodes and outgoing
+// facts for those files while using baseNodes as a read-only endpoint index.
+//
+// This is the semantic primitive a resident shard store needs: an ordinary edit
+// asks the new checker only about its invalidated closure instead of walking
+// every declaration again, while cross-file targets retain the exact stable IDs
+// established by the preceding committed generation.
+func BuildFiles(prog *driver.Program, selected []string, baseNodes map[string]*Node) *Graph {
+  selectedFiles := map[string]bool{}
+  if selected != nil {
+    for _, file := range selected {
+      selectedFiles[file] = true
+    }
+  }
   g := &Graph{
-    Nodes:     map[string]*Node{},
-    bodyNodes: map[string]bool{},
-    seen:      map[edgeKey]struct{}{},
-    resolved:  map[*shimast.Node]*Target{},
+    Nodes:                 map[string]*Node{},
+    bodyNodes:             map[string]bool{},
+    seen:                  map[edgeKey]struct{}{},
+    resolved:              map[*shimast.Node]*Target{},
+    edgeEvidenceFiles:     map[string]string{},
+    baseNodes:             baseNodes,
+    selectedFiles:         selectedFiles,
+    ExportedTargets:       map[string]bool{},
+    ImplementationSources: map[string]map[string]bool{},
   }
   for _, file := range prog.SourceFiles() {
+    if !IsWorkspaceSourceFile(file) {
+      continue
+    }
+    if selected != nil && !selectedFiles[file.FileName()] {
+      continue
+    }
     g.putModuleNode(file)
     collectDeclarations(g, file)
   }
-  g.addEdges(prog)
+  g.addEdges(prog, selectedFiles, selected != nil)
   return g
 }
 
@@ -49,6 +79,28 @@ func SourceTexts(prog *driver.Program) map[string]string {
   return out
 }
 
+// SourceTextsForFiles returns resident checker text only for the named source
+// files. It is the partial-build counterpart of SourceTexts: selected graph
+// shards still receive exact evidence and signatures, without walking or
+// retaining every unchanged source body again.
+func SourceTextsForFiles(prog *driver.Program, files []string) map[string]string {
+  if prog == nil || prog.TSProgram == nil {
+    return map[string]string{}
+  }
+  _ = prog.ApplyLinkedPlugins()
+  selected := make(map[string]bool, len(files))
+  for _, file := range files {
+    selected[file] = true
+  }
+  out := make(map[string]string, len(files))
+  for _, source := range prog.TSProgram.SourceFiles() {
+    if source != nil && selected[source.FileName()] {
+      out[source.FileName()] = source.Text()
+    }
+  }
+  return out
+}
+
 // collectDeclarations records a node for each declaration statement in file,
 // plus a method node for each callable member of a class or interface, so
 // method-to-method calls have both endpoints. It descends into namespace bodies

package/internal/graph/build_files_reuses_committed_cross_file_endpoints_test.go

@@ -0,0 +1,87 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestBuildFilesReusesCommittedCrossFileEndpoints verifies partial extraction
+// resolves selected-file facts against, but does not re-emit, the preceding
+// generation's unchanged declaration index.
+//
+// A member implementation edge is the boundary case: resolving the base class
+// alone is insufficient because the edge targets the base member node. If a
+// partial builder sees only its replacement file, that member disappears unless
+// the committed endpoint index participates in checker resolution. Conversely,
+// emitting the base and unrelated nodes again would turn a file edit back into
+// a whole-project graph replacement.
+//
+//  1. Compile a base interface, one implementation and an unrelated source.
+//  2. Build the complete generation, then rebuild only the implementation file
+//     against its node index.
+//  3. Require the implementation/member facts and cross-file edge while
+//     rejecting re-emission of the base and unrelated nodes.
+func TestBuildFilesReusesCommittedCrossFileEndpoints(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "base.ts"), `export interface Base {
+  run(): void;
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "impl.ts"), `import { Base } from "./base";
+export class Impl implements Base {
+  run(): void {}
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "unrelated.ts"), `export const unrelated = 1;
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  complete := Build(prog)
+  implFile := sourceFile(t, prog, "impl.ts").FileName()
+  baseFile := sourceFile(t, prog, "base.ts").FileName()
+  unrelatedFile := sourceFile(t, prog, "unrelated.ts").FileName()
+  partial := BuildFiles(prog, []string{implFile}, complete.Nodes)
+
+  implMethod := nodeID(implFile, "Impl.run", NodeMethod)
+  baseMethod := nodeID(baseFile, "Base.run", NodeMethod)
+  if partial.Nodes[implMethod] == nil {
+    t.Fatalf("partial build omitted selected method %s", implMethod)
+  }
+  for _, node := range partial.Nodes {
+    if node.File == baseFile || node.File == unrelatedFile {
+      t.Fatalf("partial build re-emitted unchanged node %s", node.ID)
+    }
+  }
+  found := false
+  for _, edge := range partial.Edges {
+    if edge.From == implMethod && edge.To == baseMethod &&
+      edge.Kind == EdgeMemberRelation && edge.Origin == "implements" {
+      found = true
+      break
+    }
+  }
+  if !found {
+    t.Fatalf("partial build omitted checker-valid member edge %s -> %s", implMethod, baseMethod)
+  }
+}

package/internal/graph/build_keeps_source_distributed_dependencies_at_the_external_boundary_test.go

@@ -0,0 +1,74 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestBuildKeepsSourceDistributedDependenciesAtTheExternalBoundary proves a
+// package whose public entry is raw TypeScript remains a referenced leaf rather
+// than becoming authored graph content. The resident source text is retained as
+// provenance evidence even though its declarations are not walked.
+//
+// 1. Load one workspace source that imports a raw TypeScript package entry.
+// 2. Assert only the referenced dependency symbol becomes an external leaf.
+// 3. Assert provenance retains the dependency source text without its facts.
+func TestBuildKeepsSourceDistributedDependenciesAtTheExternalBoundary(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "files": ["src/main.ts"]
+}
+`)
+  writeFile(t, filepath.Join(root, "node_modules", "dep-src", "package.json"), `{
+  "name": "dep-src",
+  "version": "1.0.0",
+  "main": "src/index.ts"
+}
+`)
+  writeFile(t, filepath.Join(root, "node_modules", "dep-src", "src", "index.ts"), `export function dependencyValue(): number { return 1; }
+export function dependencyInternal(): number { return dependencyValue(); }
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { dependencyValue } from "dep-src";
+export function workspaceValue(): number { return dependencyValue() + 1; }
+`)
+
+  program, diagnostics, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diagnostics) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diagnostics)
+  }
+  defer func() { _ = program.Close() }()
+
+  built := Build(program)
+  dependency := findNodeByName(built, "dependencyValue")
+  if dependency == nil || !dependency.External || !strings.Contains(filepath.ToSlash(dependency.File), "/node_modules/dep-src/") {
+    t.Fatalf("dependencyValue should be one external boundary leaf: %+v", dependency)
+  }
+  if internal := findNodeByName(built, "dependencyInternal"); internal != nil {
+    t.Fatalf("unreferenced dependency implementation leaked into the authored graph: %+v", internal)
+  }
+  workspace := findNodeByName(built, "workspaceValue")
+  if workspace == nil || workspace.External {
+    t.Fatalf("workspaceValue should remain authored source: %+v", workspace)
+  }
+  if !hasEdge(built, workspace.ID, dependency.ID, EdgeValueCall) {
+    t.Fatalf("missing workspaceValue -> dependencyValue boundary call: %v", built.Edges)
+  }
+
+  dependencyTextRetained := false
+  for file := range SourceTexts(program) {
+    if strings.Contains(filepath.ToSlash(file), "/node_modules/dep-src/") {
+      dependencyTextRetained = true
+      break
+    }
+  }
+  if !dependencyTextRetained {
+    t.Fatal("resident dependency source was removed from provenance text")
+  }
+}

package/internal/graph/dump.go

@@ -30,7 +30,8 @@ import (
 // expression. It is display/expansion only, never identity.
 //
 // File is omitted when the reader reconstructs it exactly: a node's span is in
-// the node's file, and an edge's span is in the file its `from` id names. The
+// the node's file, and an ordinary edge's span is in the file its `from` id
+// names. Cross-file assigned implementations keep the actual evidence file. The
 // path is long, it rode the wire once per node and once per edge, and on VS Code
 // those two copies are 55 MB of a 323 MB document that then has to be encoded,
 // piped, parsed and validated. An `implementation` span keeps its file — that one
@@ -131,6 +132,14 @@ type Dump struct {
   Edges       []DumpEdge   `json:"edges"`
 }
 
+// DumpFacts is the path-normalized fact payload of one graph shard. It omits
+// project-wide provenance and diagnostics so an incremental producer can
+// project one invalidated closure without reconstructing a complete Dump.
+type DumpFacts struct {
+  Nodes []DumpNode `json:"nodes"`
+  Edges []DumpEdge `json:"edges"`
+}
+
 // DumpOrigin is the snapshot evidence a caller attaches to a dump: who built it
 // and what the same program generation had to say about the code. It is a
 // separate struct because only the commands that own a compiler session can
@@ -153,6 +162,61 @@ type DumpOrigin struct {
 // error before serialization when a path is on another filesystem root or two
 // physical sources would collide at one wire identity.
 func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin) (Dump, error) {
+  facts, ctx, err := newDumpFacts(g, project, ignored, sources)
+  if err != nil {
+    return Dump{}, err
+  }
+
+  // The schema version describes this code, not the caller's belief about it,
+  // so stamp it here rather than trusting what came in.
+  provenance := ctx.provenance(origin.Provenance)
+  provenance.SchemaVersion = DumpSchemaVersion
+
+  // A nil slice encodes as JSON null, and null is not an empty list: a reader
+  // validating `string[]` rejects it, and a reader that does not would have to
+  // guess which of the two the producer meant. Every list on the wire is a list.
+  if provenance.Capabilities == nil {
+    provenance.Capabilities = []string{}
+  }
+  if provenance.Sources == nil {
+    provenance.Sources = []SourceDigest{}
+  }
+  if provenance.Universe.Configs == nil {
+    provenance.Universe.Configs = []FileDigest{}
+  }
+  if provenance.Universe.Roots == nil {
+    provenance.Universe.Roots = []RootFile{}
+  }
+
+  diagnostics := ctx.diagnostics(origin.Diagnostics)
+  if diagnostics == nil {
+    diagnostics = []Diagnostic{}
+  }
+  target := ctx.rel(tsconfig)
+  if err := ctx.pathError(); err != nil {
+    return Dump{}, err
+  }
+
+  return Dump{
+    Project:     ctx.paths.project,
+    Tsconfig:    target,
+    Provenance:  provenance,
+    Diagnostics: diagnostics,
+    Nodes:       facts.Nodes,
+    Edges:       facts.Edges,
+  }, nil
+}
+
+// NewDumpFacts projects only one graph's nodes and edges through the complete
+// dump path/evidence codec. The caller may pass a partial graph produced by
+// BuildFiles; no project-wide provenance, diagnostic walk or full Dump is
+// constructed.
+func NewDumpFacts(g *Graph, project string, ignored map[string]bool, sources map[string]string) (DumpFacts, error) {
+  facts, _, err := newDumpFacts(g, project, ignored, sources)
+  return facts, err
+}
+
+func newDumpFacts(g *Graph, project string, ignored map[string]bool, sources map[string]string) (DumpFacts, *dumpContext, error) {
   ctx := newDumpContext(project, sources)
 
   // Decorators ride on their target node; group by the internal node id before
@@ -203,11 +267,13 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
 
   edges := make([]DumpEdge, 0, len(g.Edges))
   for _, e := range g.Edges {
+    includeEvidenceFile := e.File != "" && e.File != nodeFile(e.From)
+    evidence := ctx.edgeEvidence(e, includeEvidenceFile)
     edges = append(edges, DumpEdge{
       From:     ctx.relID(e.From),
       To:       ctx.relID(e.To),
       Kind:     dumpEdgeKind(e),
-      Evidence: withoutFile(ctx.edgeEvidence(e)),
+      Evidence: evidence,
     })
   }
   sort.Slice(edges, func(i, j int) bool {
@@ -220,44 +286,10 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
     return edges[i].Kind < edges[j].Kind
   })
 
-  // The schema version describes this code, not the caller's belief about it,
-  // so stamp it here rather than trusting what came in.
-  provenance := ctx.provenance(origin.Provenance)
-  provenance.SchemaVersion = DumpSchemaVersion
-
-  // A nil slice encodes as JSON null, and null is not an empty list: a reader
-  // validating `string[]` rejects it, and a reader that does not would have to
-  // guess which of the two the producer meant. Every list on the wire is a list.
-  if provenance.Capabilities == nil {
-    provenance.Capabilities = []string{}
-  }
-  if provenance.Sources == nil {
-    provenance.Sources = []SourceDigest{}
-  }
-  if provenance.Universe.Configs == nil {
-    provenance.Universe.Configs = []FileDigest{}
-  }
-  if provenance.Universe.Roots == nil {
-    provenance.Universe.Roots = []RootFile{}
-  }
-
-  diagnostics := ctx.diagnostics(origin.Diagnostics)
-  if diagnostics == nil {
-    diagnostics = []Diagnostic{}
-  }
-
-  dump := Dump{
-    Project:     project,
-    Tsconfig:    ctx.rel(tsconfig),
-    Provenance:  provenance,
-    Diagnostics: diagnostics,
-    Nodes:       nodes,
-    Edges:       edges,
-  }
   if err := ctx.pathError(); err != nil {
-    return Dump{}, err
+    return DumpFacts{}, ctx, err
   }
-  return dump, nil
+  return DumpFacts{Nodes: nodes, Edges: edges}, ctx, nil
 }
 
 // dumpEnumMembers projects an enum's members onto the wire shape, nil for a
@@ -443,6 +475,10 @@ func (c *dumpContext) relID(id string) string {
 // evidence builds the line/col span for a byte range in file, or nil when the
 // span is absent or no source is available.
 func (c *dumpContext) evidence(file string, pos, end int) *DumpEvidence {
+  return c.evidenceWithFile(file, pos, end, true)
+}
+
+func (c *dumpContext) evidenceWithFile(file string, pos, end int, includeFile bool) *DumpEvidence {
   if pos < 0 || c.sources == nil {
     return nil
   }
@@ -464,7 +500,10 @@ func (c *dumpContext) evidence(file string, pos, end int) *DumpEvidence {
   // or its indentation.
   pos = FirstCodeOffset(text, pos)
   sl, sc := ls.at(pos)
-  ev := &DumpEvidence{File: c.rel(file), StartLine: sl, StartCol: sc}
+  ev := &DumpEvidence{StartLine: sl, StartCol: sc}
+  if includeFile {
+    ev.File = c.rel(file)
+  }
   if end > pos && end <= len(text) {
     ev.EndLine, ev.EndCol = ls.at(end)
   }
@@ -646,13 +685,15 @@ func regularExpressionEnd(text string, start int) int {
 }
 
 // edgeEvidence is the evidence range for an edge's source expression.
-func (c *dumpContext) edgeEvidence(e *Edge) *DumpEvidence {
-  // The edge's span lives in the From node's file.
-  file := nodeFile(e.From)
+func (c *dumpContext) edgeEvidence(e *Edge, includeFile bool) *DumpEvidence {
+  file := e.File
+  if file == "" {
+    file = nodeFile(e.From)
+  }
   if file == "" {
     return nil
   }
-  return c.evidence(file, e.Pos, e.End)
+  return c.evidenceWithFile(file, e.Pos, e.End, includeFile)
 }
 
 // withoutFile drops a span file the reader reconstructs from the node or edge

package/internal/graph/dump_path_mapper_caches_alias_resolution_test.go

@@ -0,0 +1,29 @@
+package graph
+
+import "testing"
+
+// TestDumpPathMapperCachesAliasResolution verifies repeated graph facts do not
+// repeat filesystem canonicalization for the same raw source path.
+//
+// A large graph maps one source through its node, IDs and many edge endpoints;
+// caching only after EvalSymlinks would turn those facts into repeated syscalls.
+//
+//  1. Install a counting canonicalizer on one mapper.
+//  2. Map the same absolute source path repeatedly.
+//  3. Require one canonicalization and one stable wire coordinate.
+func TestDumpPathMapperCachesAliasResolution(t *testing.T) {
+  mapper := newDumpPathMapper("C:/checkout/app")
+  calls := 0
+  mapper.canonicalize = func(path string) string {
+    calls++
+    return path
+  }
+  for range 100 {
+    if wire := mapper.mapPath("C:/checkout/app/src/main.ts"); wire != "src/main.ts" {
+      t.Fatalf("wire path = %q, want src/main.ts", wire)
+    }
+  }
+  if calls != 1 {
+    t.Fatalf("canonicalizer calls = %d, want 1", calls)
+  }
+}