ttsc 0.19.1 → 0.19.3

package/driver/graph.go

@@ -0,0 +1,133 @@
+package driver
+
+import (
+  "path/filepath"
+  "sort"
+  "strings"
+
+  "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// bundledScheme prefixes the virtual paths of the TypeScript-Go standard
+// library files embedded in the binary. They are not filesystem inputs — they
+// change only with the compiler itself — so the reference graph excludes them.
+const bundledScheme = "bundled:///"
+
+// TransformGraph is the host-owned reference-graph section of a transform
+// envelope (`graph` in the stdout JSON). It carries the language-semantic
+// input set of a transform under `tsc --incremental` semantics, so cache
+// layers (bundler filesystem caches, watch graphs) can register every file
+// whose content can influence a transformed module's output:
+//
+//   - Edges maps each file to its direct resolved references — imports,
+//     re-exports, `/// <reference>` targets, type reference directives, and
+//     ambient-module declaration files, type-only edges included. Direct
+//     edges are the minimal sufficient statistic; consumers that need a flat
+//     per-file list compute the reachability closure themselves.
+//   - Globals lists the files that contribute to the global scope (ambient
+//     declaration files, script files, global augmentations, `typeRoots`
+//     entries). A change to any of them can affect every file.
+//   - Configs lists the project tsconfig followed by its `extends` ancestry.
+//
+// Keys and values use the same convention as the envelope's `typescript`
+// map: project-relative slash paths, falling back to slash-normalized
+// absolute paths outside the project root (see TransformOutputKey).
+type TransformGraph struct {
+  Edges   map[string][]string `json:"edges"`
+  Globals []string            `json:"globals"`
+  Configs []string            `json:"configs"`
+}
+
+// NewTransformGraph computes the reference graph of a loaded program, keyed
+// relative to cwd exactly like the transform envelope's `typescript` map.
+// Hosts stamp the result into their stdout envelope's `graph` field;
+// `cmd/ttsc api-transform` and the linked-plugin utility host both do.
+// Returns nil only for a nil or unloaded program.
+func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
+  if prog == nil || prog.TSProgram == nil {
+    return nil
+  }
+  graph := &TransformGraph{
+    Edges:   map[string][]string{},
+    Globals: []string{},
+    Configs: []string{},
+  }
+  for _, file := range prog.TSProgram.SourceFiles() {
+    fileName := file.FileName()
+    if strings.HasPrefix(fileName, bundledScheme) {
+      continue
+    }
+    key := TransformOutputKey(cwd, fileName)
+    if shimcompiler.FileAffectsGlobalScope(file) {
+      graph.Globals = append(graph.Globals, key)
+    }
+    targets := referenceTargets(prog, cwd, file)
+    if len(targets) != 0 {
+      graph.Edges[key] = targets
+    }
+  }
+  sort.Strings(graph.Globals)
+  graph.Configs = configChain(prog, cwd)
+  return graph
+}
+
+// referenceTargets resolves one file's direct reference set to sorted envelope
+// keys, dropping bundled library files and the file itself.
+func referenceTargets(prog *Program, cwd string, file *ast.SourceFile) []string {
+  paths := shimcompiler.GetReferencedFilePaths(prog.TSProgram, file)
+  targets := make([]string, 0, len(paths))
+  for _, path := range paths {
+    fileName := path
+    // Referenced paths are case-canonicalized tspath.Path values; recover the
+    // real spelling from the program so consumers can compare them against
+    // filesystem paths byte-for-byte.
+    if resolved := prog.TSProgram.GetSourceFileByPath(shimtspath.Path(path)); resolved != nil {
+      fileName = resolved.FileName()
+    }
+    if fileName == file.FileName() || strings.HasPrefix(fileName, bundledScheme) {
+      continue
+    }
+    targets = append(targets, TransformOutputKey(cwd, fileName))
+  }
+  sort.Strings(targets)
+  return targets
+}
+
+// configChain returns the project tsconfig followed by its `extends` ancestry
+// as envelope keys. An inferred (config-less) program yields an empty list.
+func configChain(prog *Program, cwd string) []string {
+  configs := []string{}
+  parsed := prog.ParsedConfig
+  if parsed == nil || parsed.ConfigFile == nil {
+    return configs
+  }
+  if source := parsed.ConfigFile.SourceFile; source != nil {
+    configs = append(configs, TransformOutputKey(cwd, source.FileName()))
+  }
+  for _, extended := range parsed.ExtendedSourceFiles() {
+    configs = append(configs, TransformOutputKey(cwd, extended))
+  }
+  return configs
+}
+
+// TransformOutputKey converts an absolute fileName to the key used by the
+// transform and compile envelopes: a slash-separated path relative to cwd,
+// falling back to the slash-normalized absolute path when the file lives
+// outside the project root. Every envelope section (`typescript`, `graph`,
+// `dependencies` producers) must share this one implementation so a consumer
+// can join sections by key.
+func TransformOutputKey(cwd, fileName string) string {
+  rel, err := filepath.Rel(cwd, fileName)
+  if err != nil || isOutsideRelativePath(rel) {
+    return filepath.ToSlash(fileName)
+  }
+  return filepath.ToSlash(rel)
+}
+
+// isOutsideRelativePath reports whether rel escapes the project root (starts
+// with ".." or is exactly "..").
+func isOutsideRelativePath(rel string) bool {
+  return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}

package/internal/graph/diagnostics.go

@@ -8,11 +8,12 @@ import "github.com/samchon/ttsc/packages/ttsc/driver"
 // over the warm checker, not a second compile.
 //
 // This is the compiler-only slice: it carries the TypeScript semantic
-// diagnostics, not @ttsc/lint or transform-plugin findings. Nothing in the
-// graph pipeline calls it yet; the dump and MCP results carry no diagnostics.
-// This helper and its tests pin the compiler-diagnostic conversion (code,
-// column, message) so a future diagnostics integration starts from a proven
-// producer.
+// diagnostics, not @ttsc/lint or transform-plugin findings.
+//
+// This is the per-file view. The dump publishes the whole-program view through
+// NewDiagnostics, which groups and relativizes the same driver.Diagnostic values
+// in one pass; prefer it when every file is wanted, because filtering per file
+// here rescans the program's diagnostics once per call.
 func FileDiagnostics(prog *driver.Program, path string) []driver.Diagnostic {
   out := make([]driver.Diagnostic, 0)
   for _, diagnostic := range prog.Diagnostics() {

package/internal/graph/dump.go

@@ -17,7 +17,6 @@ import (
 //   - internal node kinds map straight through (NodeTypeAlias is already "type");
 //   - one EdgeValueCall splits by Origin into "calls" / "instantiates" /
 //     "renders", and EdgeHeritage into "extends" / "implements";
-//   - every edge is tagged checker-resolved / high (the graph's whole contract);
 //   - byte spans become 1-based line/col Evidence ranges;
 //   - decorator facts ride on their target node;
 //   - file paths are project-relative and the output is sorted, so the dump is
@@ -57,6 +56,15 @@ type DumpDecorator struct {
   Arguments []DumpDecoratorArgument `json:"arguments"`
 }
 
+// DumpEnumMember is one member of an enum on the wire: the name a caller writes
+// and the value it carries. `value` is omitted for a member the checker could
+// not fold to a constant — the name still stands, and the name is what a caller
+// asking about the enum came for.
+type DumpEnumMember struct {
+  Name  string `json:"name"`
+  Value string `json:"value,omitempty"`
+}
+
 // DumpNode is the wire shape of a graph node. Lowercase json keys are the
 // contract; the Go field names are not.
 type DumpNode struct {
@@ -70,6 +78,8 @@ type DumpNode struct {
   Exported       bool            `json:"exported,omitempty"`
   Closure        bool            `json:"closure,omitempty"`
   Modifiers      []string        `json:"modifiers,omitempty"`
+  Literals       []string         `json:"literals,omitempty"`
+  EnumMembers    []DumpEnumMember `json:"enumMembers,omitempty"`
   Evidence       *DumpEvidence   `json:"evidence,omitempty"`
   Implementation *DumpEvidence   `json:"implementation,omitempty"`
   Decorators     []DumpDecorator `json:"decorators,omitempty"`
@@ -84,21 +94,46 @@ type DumpEdge struct {
   Evidence *DumpEvidence `json:"evidence,omitempty"`
 }
 
-// Dump is the IGraphDump envelope: the project it was built for and the full
-// node and edge sets with none of the MCP response caps.
+// Dump is the IGraphDump envelope: the project it was built for, the evidence
+// about the program that produced it, and the full node and edge sets with none
+// of the MCP response caps.
 type Dump struct {
-  Project  string     `json:"project"`
-  Tsconfig string     `json:"tsconfig"`
-  Nodes    []DumpNode `json:"nodes"`
-  Edges    []DumpEdge `json:"edges"`
+  Project  string `json:"project"`
+  Tsconfig string `json:"tsconfig"`
+  // Provenance proves the rest of this dump came from one Program. It rides the
+  // body rather than the serve envelope so a dump written to a file by the
+  // one-shot command keeps its evidence, and so a consumer holding only the
+  // parsed dump never has to ask where it came from.
+  Provenance Provenance `json:"provenance"`
+  // Diagnostics are the compiler's findings for the same program generation
+  // that produced Nodes and Edges. Empty means the program had none, not that
+  // they were not collected; the producer states that in its capabilities.
+  Diagnostics []Diagnostic `json:"diagnostics"`
+  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
+// produce it, while the graph projection below is pure.
+type DumpOrigin struct {
+  // Provenance identifies the producing program. NewDump always stamps the
+  // schema version itself, so a caller cannot publish a wrong one.
+  Provenance Provenance
+
+  // Diagnostics are the compiler findings for the producing generation, or nil
+  // when the caller did not collect them.
+  Diagnostics []Diagnostic
 }
 
 // NewDump projects a built graph onto the export shape. project is the absolute
 // project root used to relativize file paths and node ids; ignored is the
 // git-ignored source set (nil for a non-git project); sources maps a source
 // file's path to its text so byte spans become line/col evidence (nil omits
-// evidence).
-func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string) Dump {
+// evidence); origin is the snapshot evidence that proves where the facts came
+// from.
+func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin) Dump {
   ctx := newDumpContext(project, sources)
 
   // Decorators ride on their target node; group by the internal node id before
@@ -124,16 +159,20 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
       name, qualified = ctx.rel(name), ""
     }
     nodes = append(nodes, DumpNode{
-      ID:             ctx.relID(n.ID),
-      Kind:           string(n.Kind),
-      Name:           name,
-      QualifiedName:  qualified,
-      File:           ctx.rel(n.File),
-      External:       n.External,
-      Ignored:        ignored[n.File],
-      Exported:       n.Exported,
-      Closure:        n.Closure,
-      Modifiers:      n.Modifiers,
+      ID:            ctx.relID(n.ID),
+      Kind:          string(n.Kind),
+      Name:          name,
+      QualifiedName: qualified,
+      File:          ctx.rel(n.File),
+      External:      n.External,
+      Ignored:       ignored[n.File],
+      Exported:      n.Exported,
+      Closure:       n.Closure,
+      Modifiers:     n.Modifiers,
+      // Uncapped, like every other fact here: the dump is the whole graph and
+      // the MCP layer is what applies a response cap and marks it.
+      Literals:       n.Literals,
+      EnumMembers:    dumpEnumMembers(n.EnumMembers),
       Evidence:       withoutFile(ctx.evidence(n.File, n.Pos, n.End)),
       Implementation: ctx.evidence(n.ImplementationFile, n.ImplementationPos, n.ImplementationEnd),
       Decorators:     decByNode[n.ID],
@@ -160,18 +199,59 @@ 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 := 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 := origin.Diagnostics
+  if diagnostics == nil {
+    diagnostics = []Diagnostic{}
+  }
+
   return Dump{
-    Project:  project,
-    Tsconfig: tsconfig,
-    Nodes:    nodes,
-    Edges:    edges,
+    Project:     project,
+    Tsconfig:    tsconfig,
+    Provenance:  provenance,
+    Diagnostics: diagnostics,
+    Nodes:       nodes,
+    Edges:       edges,
+  }
+}
+
+// dumpEnumMembers projects an enum's members onto the wire shape, nil for a
+// node that declares none so the key stays off every other kind.
+func dumpEnumMembers(members []EnumMember) []DumpEnumMember {
+  if len(members) == 0 {
+    return nil
+  }
+  out := make([]DumpEnumMember, 0, len(members))
+  for _, member := range members {
+    out = append(out, DumpEnumMember{Name: member.Name, Value: member.Value})
   }
+  return out
 }
 
 // MarshalDump serializes a built graph to the export JSON, indented when pretty.
 // See NewDump for the parameters.
-func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, pretty bool) ([]byte, error) {
-  d := NewDump(g, project, tsconfig, ignored, sources)
+func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin, pretty bool) ([]byte, error) {
+  d := NewDump(g, project, tsconfig, ignored, sources, origin)
   if pretty {
     return json.MarshalIndent(d, "", "  ")
   }
@@ -186,13 +266,13 @@ func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, so
 // string. On VS Code the document is 323 MB, so the conversion was a second full
 // copy of it held live beside the first — half a gigabyte of peak heap that
 // bought nothing, because the bytes were already exactly what stdout wanted.
-func EncodeDump(w io.Writer, g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, pretty bool) error {
+func EncodeDump(w io.Writer, g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin, pretty bool) error {
   buffered := bufio.NewWriterSize(w, 1<<20)
   encoder := json.NewEncoder(buffered)
   if pretty {
     encoder.SetIndent("", "  ")
   }
-  if err := encoder.Encode(NewDump(g, project, tsconfig, ignored, sources)); err != nil {
+  if err := encoder.Encode(NewDump(g, project, tsconfig, ignored, sources, origin)); err != nil {
     return err
   }
   return buffered.Flush()

package/internal/graph/dump_diagnostics_ride_the_generation_that_built_it_test.go

@@ -0,0 +1,79 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestDumpDiagnosticsRideTheGenerationThatBuiltIt verifies the dump carries the
+// compiler's findings for the same program that produced its nodes and edges,
+// relativized like every other path on the wire.
+//
+// FileDiagnostics was written, tested, and then called by nothing: its own
+// comment said "the dump and MCP results carry no diagnostics", so a consumer
+// that wanted to know whether the code it was reading even compiles had to run a
+// second compile to find out — against a program that, by then, was not this one.
+// The value of riding along is precisely that the answer belongs to this
+// snapshot; a diagnostics list assembled separately would be a different
+// program's opinion.
+//
+//  1. Build a fixture whose only file assigns a string to a number binding.
+//  2. Dump it.
+//  3. Assert the TS2322 sits in the dump, at the location tsgo reports, against
+//     a project-relative path.
+func TestDumpDiagnosticsRideTheGenerationThatBuiltIt(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export const broken: number = "nope";
+`)
+
+  prog, _, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+
+  dump := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{
+    Diagnostics: NewDiagnostics(prog, root),
+  })
+
+  var match *Diagnostic
+  for i := range dump.Diagnostics {
+    if dump.Diagnostics[i].Code == 2322 {
+      match = &dump.Diagnostics[i]
+      break
+    }
+  }
+  if match == nil {
+    t.Fatalf("the dump carried no TS2322 for the bad assignment: %v", dump.Diagnostics)
+  }
+  // The same oracle the FileDiagnostics probe uses: tsgo attributes the
+  // assignability error to the declared binding, 1-based column 14.
+  if match.Line != 1 || match.Column != 14 {
+    t.Fatalf("TS2322 at line %d column %d, expected line 1 column 14", match.Line, match.Column)
+  }
+  if !strings.Contains(match.Message, "not assignable") {
+    t.Fatalf("TS2322 message %q does not mention 'not assignable'", match.Message)
+  }
+  if match.Category != "error" {
+    t.Fatalf("TS2322 category %q, want error", match.Category)
+  }
+  // Paths on the wire are project-relative; an absolute one would leak the
+  // producer's disk layout into a document a consumer reads elsewhere.
+  if match.File != "src/main.ts" {
+    t.Fatalf("diagnostic file %q, want the project-relative src/main.ts", match.File)
+  }
+
+  // The negative twin: a caller that does not collect diagnostics publishes an
+  // empty list, never a nil that would encode as JSON null.
+  quiet := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if quiet.Diagnostics == nil {
+    t.Fatal("an uncollected diagnostics list is nil, so it serializes as null rather than []")
+  }
+  if len(quiet.Diagnostics) != 0 {
+    t.Fatalf("an uncollected diagnostics list invented %d entries", len(quiet.Diagnostics))
+  }
+}

package/internal/graph/dump_evidence_skips_leading_trivia_test.go

@@ -46,7 +46,7 @@ export function main(): void {
   defer func() { _ = prog.Close() }()
 
   g := Build(prog)
-  data, err := MarshalDump(g, root, "tsconfig.json", nil, SourceTexts(prog), false)
+  data, err := MarshalDump(g, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{}, false)
   if err != nil {
     t.Fatalf("MarshalDump: %v", err)
   }

package/internal/graph/dump_is_a_function_of_the_source_test.go

@@ -63,7 +63,7 @@ func dumpBytes(t *testing.T, root string) []byte {
   }
   defer func() { _ = prog.Close() }()
 
-  data, err := MarshalDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), false)
+  data, err := MarshalDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{}, false)
   if err != nil {
     t.Fatalf("MarshalDump: %v", err)
   }

package/internal/graph/dump_never_serializes_a_list_as_null_test.go

@@ -0,0 +1,76 @@
+package graph
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestDumpNeverSerializesAListAsNull verifies every list the provenance contract
+// declares reaches the wire as a list, even when the producer filled none of it.
+//
+// A nil Go slice encodes as `null`, and the TypeScript mirror types these as
+// `string[]` / `T[]`, so a nil would fail validation at the consumer rather than
+// here — and a consumer that did not validate would have to guess whether `null`
+// meant "empty" or "absent". The distinction the contract actually uses for
+// absence is `capabilities`, not the difference between `null` and `[]`, so the
+// wire must never offer the second question.
+//
+//  1. Build a dump whose origin declares nothing at all.
+//  2. Assert it still parses into lists, not nulls.
+func TestDumpNeverSerializesAListAsNull(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), "export const value = 1;\n")
+
+  prog, _, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+
+  // The emptiest origin a caller can pass: every list below is nil in Go.
+  data, err := MarshalDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{}, false)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if strings.Contains(string(data), ":null") {
+    t.Fatalf("dump serialized a null where a list belongs:\n%s", data)
+  }
+
+  var parsed struct {
+    Provenance struct {
+      Capabilities []string `json:"capabilities"`
+      Sources      []any    `json:"sources"`
+      Universe     struct {
+        Configs []any `json:"configs"`
+        Roots   []any `json:"roots"`
+      } `json:"universe"`
+    } `json:"provenance"`
+    Diagnostics []any `json:"diagnostics"`
+  }
+  if err := json.Unmarshal(data, &parsed); err != nil {
+    t.Fatal(err)
+  }
+  for name, list := range map[string]any{
+    "provenance.capabilities":     parsed.Provenance.Capabilities,
+    "provenance.sources":          parsed.Provenance.Sources,
+    "provenance.universe.configs": parsed.Provenance.Universe.Configs,
+    "provenance.universe.roots":   parsed.Provenance.Universe.Roots,
+    "diagnostics":                 parsed.Diagnostics,
+  } {
+    switch typed := list.(type) {
+    case []string:
+      if typed == nil {
+        t.Fatalf("%s came back nil, so it rode the wire as null", name)
+      }
+    case []any:
+      if typed == nil {
+        t.Fatalf("%s came back nil, so it rode the wire as null", name)
+      }
+    }
+  }
+}

package/internal/graph/dump_schema_version_matches_the_typescript_client_test.go

@@ -0,0 +1,48 @@
+package graph
+
+import (
+  "bytes"
+  "os"
+  "path/filepath"
+  "regexp"
+  "strconv"
+  "testing"
+)
+
+// TestDumpSchemaVersionMatchesTheTypescriptClient verifies the Go producer and
+// the TypeScript reader agree on the dump schema version.
+//
+// The dump body is mirrored by hand: Dump here, ITtscGraphDump in @ttsc/graph.
+// A dump also outlives the process that wrote it — the one-shot command writes
+// JSON to a file that any later build may read — so the version is what tells a
+// reader whether the document in front of it is the document it understands. It
+// can only do that while both sides mean the same number by it.
+//
+//  1. Read DUMP_SCHEMA_VERSION out of the TypeScript reader's source.
+//  2. Compare it to DumpSchemaVersion.
+func TestDumpSchemaVersionMatchesTheTypescriptClient(t *testing.T) {
+  reader := filepath.Join("..", "..", "..", "graph", "src", "model", "loadGraph.ts")
+  source, err := os.ReadFile(reader)
+  if err != nil {
+    t.Fatalf("read the TypeScript reader: %v", err)
+  }
+  // The checkout is CRLF on Windows, and a line-anchored match would never
+  // see the end of a line that ends in a carriage return.
+  source = bytes.ReplaceAll(source, []byte("\r\n"), []byte("\n"))
+  match := regexp.MustCompile(`(?m)^(?:export )?const DUMP_SCHEMA_VERSION = (\d+);$`).FindSubmatch(source)
+  if match == nil {
+    t.Fatalf("no `const DUMP_SCHEMA_VERSION = <n>;` in %s; if it moved, this gate must follow it", reader)
+  }
+  declared, err := strconv.Atoi(string(match[1]))
+  if err != nil {
+    t.Fatalf("DUMP_SCHEMA_VERSION is not a number: %v", err)
+  }
+  if declared != DumpSchemaVersion {
+    t.Fatalf(
+      "dump schema drifted: Go produces v%d, %s reads v%d",
+      DumpSchemaVersion,
+      reader,
+      declared,
+    )
+  }
+}

package/internal/graph/dump_serializes_the_full_graph_test.go

@@ -46,7 +46,7 @@ export function main(): void {
   g := Build(prog)
   sources := SourceTexts(prog)
 
-  data, err := MarshalDump(g, root, "tsconfig.json", nil, sources, false)
+  data, err := MarshalDump(g, root, "tsconfig.json", nil, sources, DumpOrigin{}, false)
   if err != nil {
     t.Fatalf("MarshalDump: %v", err)
   }
@@ -138,17 +138,31 @@ export function main(): void {
       t.Fatalf("dump leaked Go field name %s:\n%s", leaked, s)
     }
   }
-  // The dump carries no ceremony keys: it is wholly checker-resolved, so it has
-  // no per-edge trust flags and no schema version to negotiate. It also carries
-  // no keys the schema stopped promising: no inlined evidence text and no
-  // diagnostics array.
-  for _, gone := range []string{`"schemaVersion"`, `"provenance":`, `"confidence":`, `"text":`, `"diagnostics":`} {
+  // Every edge is checker-resolved by construction, so no record carries a
+  // per-edge trust flag saying so — that is the `provenance`/`confidence` pair
+  // 6d74a88c3 removed, and it stays removed. The dump's own `provenance` is a
+  // different thing at a different level: it describes the one program that
+  // produced every record, which no record can state about itself.
+  //
+  // No source body text rides the wire either. The manifest names its fields
+  // `checkerDigest` and `diskDigest` precisely so a digest can never be read as
+  // the text it stands for.
+  for _, gone := range []string{`"confidence":`, `"text":`} {
     if strings.Contains(s, gone) {
       t.Fatalf("dump still emits removed key %s:\n%s", gone, s)
     }
   }
+  for _, edge := range dump.Edges {
+    encoded, err := json.Marshal(edge)
+    if err != nil {
+      t.Fatalf("marshal edge %s->%s: %v", edge.From, edge.To, err)
+    }
+    if strings.Contains(string(encoded), `"provenance"`) {
+      t.Fatalf("edge regained a per-edge trust flag:\n%s", encoded)
+    }
+  }
 
-  pretty, err := MarshalDump(g, root, "tsconfig.json", nil, sources, true)
+  pretty, err := MarshalDump(g, root, "tsconfig.json", nil, sources, DumpOrigin{}, true)
   if err != nil {
     t.Fatalf("MarshalDump pretty: %v", err)
   }

package/internal/graph/edges.go

@@ -7,11 +7,17 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// addEdges resolves the relationships between the declaration nodes Build
-// recorded. It walks each source file again and, for every class or interface,
-// resolves its heritage bases through the checker (unwrapping barrel re-exports
-// to the real declaration) and links the declaration to that base, materializing
-// an external boundary-leaf node when the base lives in node_modules or a `.d.ts`.
+// addEdges is the checker pass over the declaration nodes Build recorded. It
+// walks each source file again and, for every class or interface, resolves its
+// heritage bases through the checker (unwrapping barrel re-exports to the real
+// declaration) and links the declaration to that base, materializing an external
+// boundary-leaf node when the base lives in node_modules or a `.d.ts`.
+//
+// Not everything it resolves is an edge. A fact that belongs to one declaration
+// rather than to a pair of them rides on its own node: a decorator on the target
+// 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) {
   checker := prog.Checker
   for _, file := range prog.SourceFiles() {
@@ -19,6 +25,7 @@ func (g *Graph) addEdges(prog *driver.Program) {
     g.collectHeritage(checker, file)
     g.collectCalls(checker, file)
     g.collectTypeRefs(checker, file)
+    g.collectLiterals(checker, file)
     if file.Statements != nil {
       g.collectDecorators(file.FileName(), file.Statements.Nodes)
     }