ttsc 0.22.0 → 0.24.0

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)
+  }
+}

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))