ttsc 0.23.0 → 0.25.0

package/internal/graph/dump_paths.go

@@ -2,6 +2,8 @@ package graph
 
 import (
   "fmt"
+  "path/filepath"
+  "runtime"
   "strings"
 
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
@@ -12,19 +14,26 @@ import (
 // reject both an unportable filesystem root and a non-injective projection
 // before any JSON is written.
 type dumpPathMapper struct {
+  rawProject    string
   project       string
   caseSensitive bool
+  canonicalize  func(string) string
 
+  rawToWire      map[string]string
   physicalToWire map[string]string
   wireToPhysical map[string]string
   mappingErr     error
 }
 
 func newDumpPathMapper(project string) *dumpPathMapper {
-  normalized := shimtspath.NormalizePath(shimtspath.NormalizeSlashes(project))
+  raw := shimtspath.NormalizePath(shimtspath.NormalizeSlashes(project))
+  normalized := canonicalDumpPath(raw)
   mapper := &dumpPathMapper{
+    rawProject:     raw,
     project:        normalized,
     caseSensitive:  dumpPathRootIsCaseSensitive(normalized),
+    canonicalize:   canonicalDumpPath,
+    rawToWire:      map[string]string{},
     physicalToWire: map[string]string{},
     wireToPhysical: map[string]string{},
   }
@@ -34,6 +43,62 @@ func newDumpPathMapper(project string) *dumpPathMapper {
   return mapper
 }
 
+// WireProject returns the canonical filesystem base that owns every relative
+// wire path emitted by this package.
+func WireProject(project string) (string, error) {
+  mapper := newDumpPathMapper(project)
+  return mapper.project, mapper.err()
+}
+
+// WirePath maps one compiler path into the portable schema-v6 vocabulary used
+// by dumps and resident graph shards. Callers that project a complete graph
+// keep one dumpPathMapper so collision detection spans every path; callers
+// shaping a single source/config coordinate use this helper and receive the
+// same filesystem-alias and cross-root behavior.
+func WirePath(project, file string) (string, error) {
+  mapper := newDumpPathMapper(project)
+  wire := mapper.mapPath(file)
+  return wire, mapper.err()
+}
+
+// WireNodeID maps the filesystem-bearing portions of one internal node ID into
+// the same portable vocabulary as NewDumpFacts. Resident stores use it when a
+// wire-level external reference count must be reconciled with the immutable
+// graph.Node cache, whose keys retain compiler-physical paths.
+func WireNodeID(project, id string) (string, error) {
+  ids, err := WireNodeIDs(project, []string{id})
+  return ids[id], err
+}
+
+// WireNodeIDs maps a set of internal node IDs through one path mapper. Sharing
+// the mapper preserves cross-ID collision detection and resolves each repeated
+// filesystem alias only once per snapshot generation.
+func WireNodeIDs(project string, ids []string) (map[string]string, error) {
+  mapper := newDumpPathMapper(project)
+  wireIDs := make(map[string]string, len(ids))
+  for _, id := range ids {
+    wire, err := wireNodeID(mapper, id)
+    if err != nil {
+      return nil, err
+    }
+    wireIDs[id] = wire
+  }
+  return wireIDs, mapper.err()
+}
+
+func wireNodeID(mapper *dumpPathMapper, id string) (string, error) {
+  parts, ok := parseNodeID(id)
+  if !ok {
+    return "", fmt.Errorf("ttscgraph: invalid internal graph node id %q", id)
+  }
+  name := parts.name
+  if parts.kind == NodeModule {
+    name = mapper.mapPath(name)
+  }
+  wire := nodeID(mapper.mapPath(parts.path), name, parts.kind)
+  return wire, nil
+}
+
 // mapPath returns one portable, slash-normalized coordinate:
 //
 //   - project files stay project-relative;
@@ -49,26 +114,30 @@ func (m *dumpPathMapper) mapPath(file string) string {
   if file == "" {
     return ""
   }
-  normalized := shimtspath.NormalizeSlashes(file)
+  normalized := shimtspath.NormalizePath(shimtspath.NormalizeSlashes(file))
   if strings.HasPrefix(normalized, "bundled:///") {
     return m.claim(normalized, normalized)
   }
-  normalized = shimtspath.NormalizePath(normalized)
   if m.project == "" || shimtspath.GetRootLength(m.project) == 0 {
     return normalized
   }
 
-  physical := normalized
-  if shimtspath.GetRootLength(physical) == 0 {
-    physical = shimtspath.GetNormalizedAbsolutePath(physical, m.project)
+  rawPhysical := normalized
+  if shimtspath.GetRootLength(rawPhysical) == 0 {
+    rawPhysical = shimtspath.GetNormalizedAbsolutePath(rawPhysical, m.rawProject)
   }
+  rawKey := m.pathKey(rawPhysical)
+  if wire, ok := m.rawToWire[rawKey]; ok {
+    return wire
+  }
+  physical := m.canonicalize(rawPhysical)
   if !dumpPathRootsEqual(m.project, physical, m.caseSensitive) {
     m.fail(fmt.Errorf(
       "ttscgraph: source path %q cannot be represented relative to project %q because they are on different filesystem roots",
-      normalized,
+      rawPhysical,
       m.project,
     ))
-    return normalized
+    return rawPhysical
   }
   options := shimtspath.ComparePathsOptions{
     CurrentDirectory:          m.project,
@@ -78,12 +147,21 @@ func (m *dumpPathMapper) mapPath(file string) string {
   if shimtspath.GetRootLength(wire) != 0 {
     m.fail(fmt.Errorf(
       "ttscgraph: source path %q cannot be represented relative to project %q because they are on different filesystem roots",
-      normalized,
+      rawPhysical,
       m.project,
     ))
-    return normalized
+    return rawPhysical
   }
-  return m.claim(physical, wire)
+  wire = m.claim(physical, wire)
+  m.rawToWire[rawKey] = wire
+  return wire
+}
+
+func (m *dumpPathMapper) pathKey(path string) string {
+  if !m.caseSensitive {
+    return strings.ToLower(path)
+  }
+  return path
 }
 
 // claim records both directions of the projection. The reverse map is the
@@ -127,6 +205,51 @@ func (m *dumpPathMapper) fail(err error) {
 
 func (m *dumpPathMapper) err() error { return m.mappingErr }
 
+// canonicalDumpPath collapses filesystem aliases for an existing path before
+// it enters the wire-coordinate mapper. TypeScript reports physical source
+// names, while a caller may select the same project through a symlink or a
+// Windows 8.3 spelling; comparing those raw strings would leak a producer-local
+// absolute path into an otherwise portable snapshot.
+//
+// Synthetic paths in mapper unit tests and missing paths retain their lexical
+// spelling. Real graph inputs exist by construction, so the best-effort branch
+// covers their physical identity without weakening the mapper's explicit
+// cross-root and collision checks.
+func canonicalDumpPath(location string) string {
+  normalized := shimtspath.NormalizePath(shimtspath.NormalizeSlashes(location))
+  if normalized == "" || shimtspath.GetRootLength(normalized) == 0 {
+    return normalized
+  }
+  if !dumpPathUsesHostFilesystem(normalized) {
+    return normalized
+  }
+  candidate := filepath.Clean(filepath.FromSlash(normalized))
+  suffix := []string{}
+  for {
+    physical, err := filepath.EvalSymlinks(candidate)
+    if err == nil {
+      for index := len(suffix) - 1; index >= 0; index-- {
+        physical = filepath.Join(physical, suffix[index])
+      }
+      return shimtspath.NormalizePath(shimtspath.NormalizeSlashes(physical))
+    }
+    parent := filepath.Dir(candidate)
+    if parent == candidate {
+      break
+    }
+    suffix = append(suffix, filepath.Base(candidate))
+    candidate = parent
+  }
+  return normalized
+}
+
+func dumpPathUsesHostFilesystem(path string) bool {
+  if runtime.GOOS == "windows" {
+    return strings.HasPrefix(path, "//") || (len(path) >= 2 && path[1] == ':')
+  }
+  return strings.HasPrefix(path, "/") && !strings.HasPrefix(path, "//")
+}
+
 // Windows drive and UNC roots use case-insensitive path comparison. POSIX
 // roots remain case-sensitive. This decision follows the path's own grammar so
 // synthetic Windows/UNC fixtures behave the same on every CI host.

package/internal/graph/dump_paths_canonicalize_windows_short_root_test.go

@@ -0,0 +1,39 @@
+//go:build windows
+
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestDumpPathMapperCanonicalizesWindowsShortRoot verifies that a project
+// selected through an 8.3 path still owns checker sources reported through the
+// expanded physical spelling.
+//
+//  1. Obtain the environment's temp spelling and its physical spelling.
+//  2. Skip hosts where Windows exposes only one spelling.
+//  3. Require a physical child source to retain a project-relative identity.
+func TestDumpPathMapperCanonicalizesWindowsShortRoot(t *testing.T) {
+  project := t.TempDir()
+  physical, err := filepath.EvalSymlinks(project)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if filepath.Clean(project) == filepath.Clean(physical) {
+    t.Skip("temporary directory has no alternate Windows path spelling")
+  }
+
+  mapper := newDumpPathMapper(project)
+  source := filepath.Join(physical, "src", "main.ts")
+  if got := mapper.mapPath(source); got != "src/main.ts" {
+    t.Fatalf("mapPath(%q) = %q, want project-relative identity", source, got)
+  }
+  missing := filepath.Join(project, "future", "main.ts")
+  if got := mapper.mapPath(missing); got != "future/main.ts" {
+    t.Fatalf("mapPath(%q) = %q, want stable missing-root identity", missing, got)
+  }
+  if err := mapper.err(); err != nil {
+    t.Fatal(err)
+  }
+}

package/internal/graph/dump_rejects_provenance_only_path_errors_test.go

@@ -0,0 +1,32 @@
+package graph
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestNewDumpRejectsProvenanceOnlyPathErrors verifies paths introduced after
+// fact projection still pass through the dump context's fail-closed boundary.
+//
+// Provenance inputs are mapped after graph facts. Without a final path-error
+// check, a cross-drive config could survive into otherwise valid JSON.
+//
+//  1. Build an empty graph under one synthetic Windows drive.
+//  2. Add a provenance-only config input from another drive.
+//  3. Require NewDump to reject the unrepresentable coordinate.
+func TestNewDumpRejectsProvenanceOnlyPathErrors(t *testing.T) {
+  _, err := NewDump(
+    &Graph{Nodes: map[string]*Node{}},
+    "C:/checkout/app",
+    "tsconfig.json",
+    nil,
+    nil,
+    DumpOrigin{Provenance: Provenance{Universe: Universe{Configs: []FileDigest{{
+      File:   "D:/shared/tsconfig.json",
+      Digest: "config-digest",
+    }}}}},
+  )
+  if err == nil || !strings.Contains(err.Error(), "different filesystem roots") {
+    t.Fatalf("provenance-only cross-root error = %v, want rejection before serialization", err)
+  }
+}

package/internal/graph/dump_serializes_the_full_graph_test.go

@@ -55,8 +55,8 @@ export function main(): void {
   if err := json.Unmarshal(data, &dump); err != nil {
     t.Fatalf("dump is not valid JSON: %v\n%s", err, data)
   }
-  if dump.Project != root || dump.Tsconfig != "tsconfig.json" {
-    t.Fatalf("project/tsconfig not echoed: %q / %q", dump.Project, dump.Tsconfig)
+  if dump.Project != canonicalDumpPath(root) || dump.Tsconfig != "tsconfig.json" {
+    t.Fatalf("project/tsconfig coordinates are not canonical: %q / %q", dump.Project, dump.Tsconfig)
   }
   if len(dump.Nodes) != len(g.Nodes) {
     t.Fatalf("dumped %d nodes, graph has %d", len(dump.Nodes), len(g.Nodes))

package/internal/graph/dump_symlink_project_publishes_matching_base_test.go

@@ -0,0 +1,82 @@
+package graph
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestDumpSymlinkProjectPublishesMatchingBase verifies relative wire paths and
+// the published project coordinate share one canonical filesystem base.
+//
+// A raw symlink cwd combined with canonical source paths makes `../` siblings,
+// missing literal roots and a symlinked relative tsconfig resolve incorrectly
+// unless project publication and path mapping use the same physical root.
+//
+//  1. Select a real project directory through a symlink and add sibling inputs.
+//  2. Map an existing sibling, a missing child and a relative config symlink.
+//  3. Require stable coordinates and a canonical published project base.
+func TestDumpSymlinkProjectPublishesMatchingBase(t *testing.T) {
+  root := t.TempDir()
+  realRoot := filepath.Join(root, "real")
+  project := filepath.Join(realRoot, "pkg")
+  configDir := filepath.Join(realRoot, "config")
+  if err := os.MkdirAll(project, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.MkdirAll(configDir, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  shared := filepath.Join(realRoot, "shared.ts")
+  config := filepath.Join(configDir, "tsconfig.json")
+  if err := os.WriteFile(shared, []byte("export const shared = true;\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(config, []byte("{}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  alias := filepath.Join(root, "project-link")
+  if err := os.Symlink(project, alias); err != nil {
+    t.Skipf("host cannot create directory symlink: %v", err)
+  }
+  if err := os.Symlink(config, filepath.Join(project, "tsconfig.json")); err != nil {
+    t.Skipf("host cannot create file symlink: %v", err)
+  }
+
+  mapper := newDumpPathMapper(alias)
+  if wire := mapper.mapPath(shared); wire != "../shared.ts" {
+    t.Fatalf("sibling wire path = %q, want ../shared.ts", wire)
+  }
+  if wire := mapper.mapPath(filepath.Join(alias, "src", "new.ts")); wire != "src/new.ts" {
+    t.Fatalf("missing-root wire path = %q, want src/new.ts", wire)
+  }
+  if wire := mapper.mapPath("tsconfig.json"); wire != "../config/tsconfig.json" {
+    t.Fatalf("relative config wire path = %q, want ../config/tsconfig.json", wire)
+  }
+  dump, err := NewDump(&Graph{Nodes: map[string]*Node{}}, alias, "tsconfig.json", nil, nil, DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  physicalProject, err := filepath.EvalSymlinks(alias)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if filepath.Clean(filepath.FromSlash(dump.Project)) != filepath.Clean(physicalProject) {
+    t.Fatalf("published project = %q, want %q", dump.Project, physicalProject)
+  }
+  resolvedSibling := filepath.Clean(filepath.Join(filepath.FromSlash(dump.Project), filepath.FromSlash("../shared.ts")))
+  resolvedSiblingInfo, err := os.Stat(resolvedSibling)
+  if err != nil {
+    t.Fatal(err)
+  }
+  sharedInfo, err := os.Stat(shared)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !os.SameFile(resolvedSiblingInfo, sharedInfo) {
+    t.Fatalf("published base resolves sibling to %q, want %q", resolvedSibling, shared)
+  }
+  if dump.Tsconfig != "../config/tsconfig.json" {
+    t.Fatalf("published tsconfig = %q, want ../config/tsconfig.json", dump.Tsconfig)
+  }
+}

package/internal/graph/edges.go

@@ -18,9 +18,15 @@ import (
 // it annotates, a literal value set on the type that admits it. Both need the
 // same checker and the same walk, so they are resolved here and written to the
 // node the build pass keyed.
-func (g *Graph) addEdges(prog *driver.Program) {
+func (g *Graph) addEdges(prog *driver.Program, selected map[string]bool, partial bool) {
   checker := prog.Checker
   for _, file := range prog.SourceFiles() {
+    if !IsWorkspaceSourceFile(file) {
+      continue
+    }
+    if partial && !selected[file.FileName()] {
+      continue
+    }
     g.markExports(checker, file)
     g.collectHeritage(checker, file)
     g.collectCalls(checker, file)
@@ -54,7 +60,8 @@ func (g *Graph) addEdgeAt(from, to string, kind EdgeKind, origin string, pos, en
     return
   }
   g.seen[key] = struct{}{}
-  g.Edges = append(g.Edges, &Edge{From: from, To: to, Kind: kind, Origin: origin, Pos: pos, End: end})
+  file := g.edgeEvidenceFiles[from]
+  g.Edges = append(g.Edges, &Edge{From: from, To: to, Kind: kind, Origin: origin, File: file, Pos: pos, End: end})
 }
 
 // collectHeritage adds a heritage edge for every base of every class and
@@ -320,7 +327,7 @@ func graphMemberNodeID(g *Graph, member *shimast.Node) string {
     return ""
   }
   id := nodeID(file.FileName(), name, kind)
-  stored, ok := g.Nodes[id]
+  stored, ok := g.lookupNode(id)
   if !ok {
     return ""
   }
@@ -576,8 +583,10 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       }
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
-        g.recordImplementation(target, child)
-        g.callsWithin(checker, target, child.AsBinaryExpression().Right)
+        file := g.recordImplementation(target, child)
+        g.withEdgeEvidenceFile(target, file, func() {
+          g.callsWithin(checker, target, child.AsBinaryExpression().Right)
+        })
       }
     case shimast.KindJsxSelfClosingElement:
       // `<Component />` is a use of the component; an intrinsic tag (`<div />`)
@@ -595,6 +604,20 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
   })
 }
 
+// assignedFunctionTarget returns the graph node an `x.y = function` assignment
+// implements, or "" when the assignment implements no node this graph owns.
+//
+// A declaration outside the workspace is not such a node. `globalThis.assert =
+// …` against a `declare global { function assert(…) }`, or a patched member of
+// a dependency's `@types`, resolves to a symbol whose only declaration is in a
+// declaration file — which has no body, holds no facts, and enters the graph as
+// an external boundary leaf. Re-attributing the assigned body to it moved the
+// implementation's calls and type references onto a node that never ran them,
+// under offsets read against the wrong file: `recordImplementation` already
+// refuses an external node, so the evidence file stayed unset and the spans
+// pointed at neither the declaration nor the implementation. And the edge
+// itself was unassemblable, so every request against such a project failed at
+// shard partition.
 func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string, node *shimast.Node) string {
   binary := node.AsBinaryExpression()
   if binary == nil ||
@@ -605,7 +628,7 @@ func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string
     return ""
   }
   target := g.resolve(checker, binary.Left)
-  if target == nil || target.Symbol == nil {
+  if target == nil || target.Symbol == nil || target.External {
     return ""
   }
   to := g.ensureTargetNode(target)
@@ -615,18 +638,45 @@ func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string
   return to
 }
 
-func (g *Graph) recordImplementation(id string, assignment *shimast.Node) {
-  node := g.Nodes[id]
-  if node == nil || node.External || node.ImplementationFile != "" {
-    return
+func (g *Graph) recordImplementation(id string, assignment *shimast.Node) string {
+  node, ok := g.lookupNode(id)
+  if !ok || node.External {
+    return ""
   }
   file := shimast.GetSourceFileOfNode(assignment)
   if file == nil {
+    return ""
+  }
+  sources := g.ImplementationSources[id]
+  if sources == nil {
+    sources = map[string]bool{}
+    g.ImplementationSources[id] = sources
+  }
+  sources[file.FileName()] = true
+  current := g.Nodes[id]
+  if current != nil && current.ImplementationFile == "" {
+    current.ImplementationFile = file.FileName()
+    current.ImplementationPos = assignment.Pos()
+    current.ImplementationEnd = assignment.End()
+  }
+  return file.FileName()
+}
+
+func (g *Graph) withEdgeEvidenceFile(from, file string, visit func()) {
+  if file == "" {
+    visit()
     return
   }
-  node.ImplementationFile = file.FileName()
-  node.ImplementationPos = assignment.Pos()
-  node.ImplementationEnd = assignment.End()
+  previous, existed := g.edgeEvidenceFiles[from]
+  g.edgeEvidenceFiles[from] = file
+  defer func() {
+    if existed {
+      g.edgeEvidenceFiles[from] = previous
+    } else {
+      delete(g.edgeEvidenceFiles, from)
+    }
+  }()
+  visit()
 }
 
 func isInvokedAccess(access *shimast.Node) bool {
@@ -745,7 +795,13 @@ func (g *Graph) typeRefsWithin(checker *shimchecker.Checker, from string, node *
       }
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
-        g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
+        file := ""
+        if source := shimast.GetSourceFileOfNode(child); source != nil {
+          file = source.FileName()
+        }
+        g.withEdgeEvidenceFile(target, file, func() {
+          g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
+        })
       }
     }
     g.typeRefsWithin(checker, from, child)
@@ -795,7 +851,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
       return ""
     }
     id := nodeID(target.File, name, NodeMethod)
-    if _, exists := g.Nodes[id]; exists {
+    if _, exists := g.lookupNode(id); exists {
       return id
     }
     return ""
@@ -805,7 +861,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   }
   name := qualifiedName(target.Symbol)
   id := nodeID(target.File, name, kind)
-  if _, exists := g.Nodes[id]; exists {
+  if _, exists := g.lookupNode(id); exists {
     return id
   }
   if !target.External {
@@ -851,7 +907,7 @@ func (g *Graph) closureTargetID(target *Target) string {
       kind = NodeVariable
     }
     id := nodeID(target.File, name, kind)
-    if _, exists := g.Nodes[id]; exists {
+    if _, exists := g.lookupNode(id); exists {
       return id
     }
   }

package/internal/graph/exports.go

@@ -108,10 +108,17 @@ func (g *Graph) markExportedSymbol(symbol *shimast.Symbol) (string, bool) {
   if name == "" {
     return "", false
   }
-  node, ok := g.Nodes[nodeID(file.FileName(), name, kind)]
+  node, ok := g.lookupNode(nodeID(file.FileName(), name, kind))
   if !ok {
     return "", false
   }
-  node.Exported = true
+  g.ExportedTargets[node.ID] = true
+  // A complete build and an invalidation transaction that includes the
+  // declaration owner both hold a fresh node and may stamp it directly. Never
+  // mutate a base node: it belongs to the last committed generation until the
+  // caller has assembled and validated every replacement shard.
+  if current, exists := g.Nodes[node.ID]; exists {
+    current.Exported = true
+  }
   return node.ID, true
 }

package/internal/graph/graph.go

@@ -171,9 +171,11 @@ const (
 )
 
 // Edge is a directed, checker-resolved relationship from one node to another,
-// both referenced by Node.ID. Pos and End bound the source expression in the
-// From node's file that produced the edge. They are evidence, not identity; a
-// duplicate relationship keeps the first source-order span.
+// both referenced by Node.ID. File, Pos, and End bound the source expression
+// that produced the edge. File is empty when the From node names it and is set
+// only when an assigned implementation attributes an expression in another
+// file to the declaration node it implements. They are evidence, not identity;
+// a duplicate relationship keeps the first source-order span.
 type Edge struct {
   From string
   To   string
@@ -186,6 +188,7 @@ type Edge struct {
   // "jsx", or "tagged"; for EdgeHeritage it is "extends" or "implements";
   // for EdgeMemberRelation it is "implements" or "overrides".
   Origin string
+  File   string
   Pos    int
   End    int
 }
@@ -196,10 +199,10 @@ type Graph struct {
   Nodes map[string]*Node
   Edges []*Edge
   // Decorators holds the decorators written on the workspace's declarations,
-  // captured syntactically so the JSON dump can emit `decorates` edges and a
-  // consumer can interpret `@Controller`/`@Get` conventions without re-parsing
-  // source. It is dump-only metadata, separate from Edges so the existing
-  // checker-resolved relationships are untouched.
+  // captured syntactically so the JSON dump can attach raw facts to each target
+  // node and a consumer can interpret `@Controller`/`@Get` conventions without
+  // re-parsing source. It is dump-only metadata, separate from Edges so the
+  // existing checker-resolved relationships are untouched.
   Decorators []*Decorator
   // bodyNodes tracks whether a callable node's display span is the overload
   // implementation rather than an overload signature. It is build-only metadata
@@ -213,6 +216,43 @@ type Graph struct {
   // build: the edge pass visits the same node several times, and a resolution
   // cannot change while the program is fixed.
   resolved map[*shimast.Node]*Target
+
+  // edgeEvidenceFiles temporarily overrides a declaration node's source while
+  // an assigned implementation in another file is walked. Builds are
+  // single-threaded, and the helper that installs an override restores it
+  // before the traversal returns.
+  edgeEvidenceFiles map[string]string
+
+  // baseNodes is the immutable endpoint index of the preceding committed
+  // generation during a partial build. Nodes owned by selectedFiles are never
+  // read through it: a changed file may delete or re-key a declaration, so its
+  // old nodes must disappear before the new checker walk begins.
+  baseNodes     map[string]*Node
+  selectedFiles map[string]bool
+
+  // ExportedTargets records every declaration reached through a selected
+  // module's checker export table. A partial caller uses it to add re-exported
+  // owner files to the same invalidation transaction before publishing.
+  ExportedTargets map[string]bool
+
+  // ImplementationSources records every source that assigns a function body
+  // to a modeled declaration, including candidates after the first assignment
+  // that supplied the node's display span. A partial caller uses the complete
+  // set to rebuild a declaration owner and all competing assignments together.
+  ImplementationSources map[string]map[string]bool
+}
+
+// lookupNode returns a node from this build, then from the preceding committed
+// endpoint index when that node's file is not being replaced.
+func (g *Graph) lookupNode(id string) (*Node, bool) {
+  if node, ok := g.Nodes[id]; ok {
+    return node, true
+  }
+  node, ok := g.baseNodes[id]
+  if !ok || g.selectedFiles[node.File] {
+    return nil, false
+  }
+  return node, true
 }
 
 // edgeKey identifies an edge by its two ends and the wire kind it will surface