ttsc 0.19.2 → 0.19.3

package/internal/graph/dump.go

@@ -56,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 {
@@ -69,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"`
@@ -148,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],
@@ -220,6 +235,19 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
   }
 }
 
+// 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, origin DumpOrigin, pretty bool) ([]byte, error) {

package/internal/graph/dump_schema_version_matches_the_typescript_client_test.go

@@ -29,7 +29,7 @@ func TestDumpSchemaVersionMatchesTheTypescriptClient(t *testing.T) {
   // 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)^const DUMP_SCHEMA_VERSION = (\d+);$`).FindSubmatch(source)
+  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)
   }

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

package/internal/graph/enum_members_carry_their_names_on_the_enum_node_test.go

@@ -0,0 +1,131 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestEnumMembersCarryTheirNamesOnTheEnumNode verifies that an enum records the
+// name and value of each member on its own node, and that nothing else does.
+//
+// The enum's node was always in the graph and had nothing in it (#738). Its
+// signature stops at the `{`, its members are not nodes, so the outline a class
+// gets is empty for an enum — and #732 gave it only values. The code writes
+// `Colors.Red`, never `"red"`, so a caller that had already named the enum
+// still opened the file for the one fact it came for.
+//
+// The names ride on the enum rather than on member nodes on purpose. A member
+// node would be indexing what `grep -rn "Colors.Red"` answers exactly, and it
+// would put leaves into tour flows to do it. Filling in a node the graph holds
+// is indexing; minting nodes to carry detail is not.
+//
+//  1. Compile a fixture with a string enum, an implicitly numbered one, and a
+//     class beside them.
+//  2. Build the graph.
+//  3. Assert each enum node carries its members name-and-value, that no member
+//     became a node, and that a class node carries none of this.
+func TestEnumMembersCarryTheirNamesOnTheEnumNode(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export enum Colors {
+  Red = 'red',
+  Green = 'green',
+}
+
+export enum Implicit {
+  First,
+  Second,
+}
+
+// Two members, one value: a type folds these together, a declaration does not.
+export enum Dup {
+  A = 'x',
+  B = 'x',
+  C = 'y',
+}
+
+export class Cls {
+  public value = 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() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  colors, ok := graph.Nodes[nodeID(path, "Colors", NodeEnum)]
+  if !ok {
+    t.Fatalf("missing enum node; nodes: %v", nodeIDSet(graph))
+  }
+  want := []EnumMember{{Name: "Red", Value: `"red"`}, {Name: "Green", Value: `"green"`}}
+  if len(colors.EnumMembers) != len(want) {
+    t.Fatalf("Colors reported %v, want %v", colors.EnumMembers, want)
+  }
+  for i, member := range want {
+    if colors.EnumMembers[i] != member {
+      t.Fatalf("Colors member %d is %v, want %v", i, colors.EnumMembers[i], member)
+    }
+  }
+
+  // The values exist only in the checker here, so a scrape of the source could
+  // not produce this pairing.
+  implicit := graph.Nodes[nodeID(path, "Implicit", NodeEnum)]
+  if implicit == nil ||
+    len(implicit.EnumMembers) != 2 ||
+    implicit.EnumMembers[0] != (EnumMember{Name: "First", Value: "0"}) ||
+    implicit.EnumMembers[1] != (EnumMember{Name: "Second", Value: "1"}) {
+    t.Fatalf("implicitly numbered enum did not pair its members: %v", implicit.EnumMembers)
+  }
+
+  // Two members carrying one value. The declared type folds them into a single
+  // constituent — a type is a set — so reading the list off the type reports A
+  // and C and drops B, silently, which is #732's defect from #732's instinct:
+  // taking a declaration fact from a type. The list is the declaration's.
+  dup := graph.Nodes[nodeID(path, "Dup", NodeEnum)]
+  if dup == nil {
+    t.Fatalf("missing Dup; nodes: %v", nodeIDSet(graph))
+  }
+  if names := memberNames(dup.EnumMembers); len(names) != 3 ||
+    names[0] != "A" || names[1] != "B" || names[2] != "C" {
+    t.Fatalf("a member sharing another's value was dropped: %v", names)
+  }
+  // And the value set is right to say `"x"` once: two members, two names, but
+  // the values they admit really are two.
+  if len(dup.Literals) != 2 {
+    t.Fatalf("the value set should hold each distinct value once: %v", dup.Literals)
+  }
+
+  // The line this fix holds: the members are facts on the enum, not nodes of
+  // their own. A node per member would index what grep already answers.
+  for id := range graph.Nodes {
+    if id == nodeID(path, "Colors.Red", NodeVariable) ||
+      id == nodeID(path, "Red", NodeVariable) {
+      t.Fatalf("an enum member became a node (%s); it is a fact on the enum", id)
+    }
+  }
+
+  // The negative twin: this rides on enums only. A class's fields are member
+  // nodes and its outline comes from those.
+  if cls := graph.Nodes[nodeID(path, "Cls", NodeClass)]; cls == nil ||
+    len(cls.EnumMembers) != 0 {
+    t.Fatalf("a class node carried enum members: %v", cls)
+  }
+}
+
+func memberNames(members []EnumMember) []string {
+  out := make([]string, 0, len(members))
+  for _, member := range members {
+    out = append(out, member.Name)
+  }
+  return out
+}

package/internal/graph/graph.go

@@ -58,6 +58,32 @@ type Node struct {
   // the declaration's combined modifier flags during the build pass and emitted
   // for projections that filter on visibility and shape.
   Modifiers []string
+  // Literals is the complete value set of a type alias or enum whose declared
+  // type the checker resolved to literals, each rendered in TypeScript source
+  // form ("a", 1, true, null). It is set only when every constituent is
+  // enumerable, so a present list is the whole type and never a sample of it;
+  // a union that mixes in `string`, a type parameter, or a computed enum member
+  // has no complete answer and gets none.
+  //
+  // It is a checker fact because nothing else is sound. The value set was read
+  // off the declaration's source text for a while, which made the answer a
+  // function of line wrapping rather than of the type: a union written one
+  // member per line reported the members that fit in the snippet, an enum
+  // written across lines reported nothing at all, and `type I = Kind | 'f'`
+  // reported `'f'` while the members reaching it through `Kind` vanished (#732).
+  // The checker has already resolved every one of them, indirection included.
+  Literals []string
+  // EnumMembers is what an enum declares, in checker order: the name a caller
+  // writes and the value it carries. Empty for every other kind.
+  //
+  // The enum's node was always here and had nothing in it. `literals` says what
+  // values the enum admits, which answers a serializer; the code says
+  // `Colors.Red`, so a caller that had already named the enum still opened the
+  // file to learn what to type (#738). The members are not nodes of their own —
+  // `Colors.Red` is a literal string a grep finds exactly, and minting a node
+  // per member would grow the graph and put leaves into tour flows to index
+  // what grep already does. This fills in the node that exists instead.
+  EnumMembers []EnumMember
   // Pos and End bound the declaration in its source file (byte offsets). They
   // are for display, never identity, so an edit that shifts them does not re-key
   // the node.
@@ -68,6 +94,14 @@ type Node struct {
   ImplementationEnd  int
 }
 
+// EnumMember is one member of an enum: the name a caller writes and the value
+// it carries, in TypeScript source form. Value is empty when the checker could
+// not fold the member's initializer to a constant.
+type EnumMember struct {
+  Name  string
+  Value string
+}
+
 // EdgeKind classifies a relationship between two nodes.
 type EdgeKind string
 

package/internal/graph/literals.go

@@ -0,0 +1,175 @@
+package graph
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// collectLiterals records the value set of every type alias and enum in file
+// whose declared type resolves to literals, so a consumer asking what values a
+// type admits is answered from the checker rather than from the declaration's
+// source text.
+//
+// It runs on the checker for the reason markExports does: the syntactic reading
+// is not the real answer. A union's members are only spelled out at the
+// declaration when nothing indirects — `type Indirect = Kind | 'f'` names one
+// literal and reaches five more through an alias, and only the checker has
+// resolved that. It has also already flattened nested unions, dropped
+// duplicates, and reduced subtypes, so the constituents it hands back are the
+// type's members exactly once each.
+//
+// Enums come here too, and they need it more. An enum's members are not nodes
+// of their own — the build pass records member nodes for classes and interfaces
+// only — so its node is the only place anything about them can ride. It carries
+// two facts, and they are not the same fact: the value set the enum admits,
+// deduped because a type is a set, and the members it declares, which is the
+// list a caller writes from and which nothing folds.
+func (g *Graph) collectLiterals(checker *shimchecker.Checker, file *shimast.SourceFile) {
+  if file.Statements == nil {
+    return
+  }
+  g.collectLiteralsIn(checker, file.FileName(), file.Statements.Nodes)
+}
+
+// collectLiteralsIn walks a statement list — a file's top level, or a namespace
+// body it recurses into — and records the value set of each type alias and enum
+// it holds. It mirrors collectStatements' descent so a `namespace X { type K =
+// … }` is resolved on the node the build pass keyed by its qualified name.
+func (g *Graph) collectLiteralsIn(checker *shimchecker.Checker, path string, statements []*shimast.Node) {
+  for _, statement := range statements {
+    switch statement.Kind {
+    case shimast.KindTypeAliasDeclaration:
+      g.putLiterals(checker, path, statement, NodeTypeAlias)
+    case shimast.KindEnumDeclaration:
+      g.putLiterals(checker, path, statement, NodeEnum)
+    case shimast.KindModuleDeclaration:
+      g.collectLiteralsIn(checker, path, moduleStatements(statement))
+    }
+  }
+}
+
+// putLiterals resolves the declared type of statement's symbol and records its
+// value set on the node the build pass recorded for it. A declaration the graph
+// does not hold a node for, or whose type has no complete literal answer, is
+// left alone rather than given a partial one.
+func (g *Graph) putLiterals(checker *shimchecker.Checker, path string, statement *shimast.Node, kind NodeKind) {
+  symbol := statement.Symbol()
+  if symbol == nil || symbol.Name == "" {
+    return
+  }
+  node, ok := g.Nodes[nodeID(path, qualifiedName(symbol), kind)]
+  if !ok {
+    return
+  }
+  declared := shimchecker.Checker_getDeclaredTypeOfSymbol(checker, symbol)
+  if declared == nil {
+    return
+  }
+  if values, ok := literalValues(declared); ok {
+    node.Literals = values
+  }
+  if kind == NodeEnum {
+    node.EnumMembers = enumMembers(checker, statement)
+  }
+}
+
+// enumMembers pairs each member an enum declares with the value it carries.
+//
+// The names are the half a caller writes. `literals` answers which values the
+// enum admits, the question a serializer asks, but the code says `Colors.Red`
+// and never `"red"` — so an enum whose node the graph already held still sent a
+// caller to the file to learn what to type (#738).
+//
+// The list comes from the declaration, not from the declared type's
+// constituents, and that is not a detail. A type is a set, so the checker folds
+// two members carrying one value into one constituent: `enum Dup { A = 'x', B =
+// 'x' }` resolves to a single type, and reading names off it reports `A` and
+// loses `B` — the same silent under-report as #732, out of the same instinct to
+// take a declaration fact from a type. The value set really is one value, which
+// is why `literals` is right to say `"x"` once; the member list is two members,
+// and only the declaration says so.
+//
+// Each member's value still comes from the checker, per member, so an implicit
+// `First` reports 0 with nothing reading the source. A member the checker
+// cannot fold to a constant keeps its name and drops its value, because the
+// name is the part this is for.
+func enumMembers(checker *shimchecker.Checker, statement *shimast.Node) []EnumMember {
+  declaration := statement.AsEnumDeclaration()
+  if declaration == nil || declaration.Members == nil {
+    return nil
+  }
+  out := make([]EnumMember, 0, len(declaration.Members.Nodes))
+  for _, node := range declaration.Members.Nodes {
+    symbol := node.Symbol()
+    if symbol == nil || symbol.Name == "" {
+      continue
+    }
+    member := EnumMember{Name: symbol.Name}
+    if t := shimchecker.Checker_getTypeOfSymbol(checker, symbol); t != nil {
+      if value, ok := literalValue(t); ok {
+        member.Value = value
+      }
+    }
+    out = append(out, member)
+  }
+  if len(out) == 0 {
+    return nil
+  }
+  return out
+}
+
+// literalValues renders every constituent of t in TypeScript source form,
+// reporting false unless all of them are enumerable.
+//
+// All-or-nothing is the contract. `type T = Kind | number` admits five literals
+// and every other number besides; answering with the five would describe a type
+// that does not exist, and the caller cannot tell that answer from a complete
+// one. So a type whose members cannot all be named yields no list, and its
+// signature carries the shape instead.
+func literalValues(t *shimchecker.Type) ([]string, bool) {
+  // Types() panics on anything that is not a union, an intersection, or a
+  // template literal, so the flag test is what makes the union branch safe. A
+  // single-literal alias (`type One = 'a'`) is not a union and is its own only
+  // constituent.
+  constituents := []*shimchecker.Type{t}
+  if t.Flags()&shimchecker.TypeFlagsUnion != 0 {
+    constituents = t.Types()
+  }
+  values := make([]string, 0, len(constituents))
+  for _, constituent := range constituents {
+    value, ok := literalValue(constituent)
+    if !ok {
+      return nil, false
+    }
+    values = append(values, value)
+  }
+  if len(values) == 0 {
+    return nil, false
+  }
+  return values, true
+}
+
+// literalValue renders one constituent in TypeScript source form, reporting
+// false when it names no single value a caller could write.
+func literalValue(t *shimchecker.Type) (string, bool) {
+  flags := t.Flags()
+  switch {
+  case flags&shimchecker.TypeFlagsNull != 0:
+    return "null", true
+  case flags&shimchecker.TypeFlagsUndefined != 0:
+    return "undefined", true
+  case flags&shimchecker.TypeFlagsLiteral != 0:
+    // TypeFlagsLiteral covers an enum member too: EnumLiteral is always paired
+    // with StringLiteral or NumberLiteral on a member, and with Union on the
+    // enum type itself, which the union branch above has already opened.
+    value := t.AsLiteralType().Value()
+    if value == nil {
+      // A computed enum member the checker could not fold to a constant. It has
+      // a value at runtime that nothing here can name, so the enum has no
+      // complete answer.
+      return "", false
+    }
+    return shimchecker.ValueToString(value), true
+  }
+  return "", false
+}

package/internal/graph/literals_are_absent_when_the_type_admits_more_than_it_can_name_test.go

@@ -0,0 +1,74 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsAreAbsentWhenTheTypeAdmitsMoreThanItCanName verifies the negative
+// twin of every literal case: a type whose members cannot all be named reports
+// none of them rather than the subset that can.
+//
+// This is what lets a present `literals` mean the whole type. `Widened` admits
+// four literals and every other string besides, and a caller cannot tell a
+// four-value answer for it from a four-value answer for a genuine four-member
+// union — so it must get no answer, and read the signature instead. Each fixture
+// here is one way a constituent stops being nameable: a primitive next to the
+// literals, an unresolved type parameter, a plain primitive alias, and a
+// computed enum member whose value the checker cannot fold to a constant.
+//
+//  1. Compile a fixture holding each non-enumerable shape.
+//  2. Build the graph.
+//  3. Assert none of them recorded a value set.
+func TestLiteralsAreAbsentWhenTheTypeAdmitsMoreThanItCanName(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `declare const compute: () => number;
+
+export type Narrow = 'a' | 'b' | 'c' | 'd';
+export type Widened = Narrow | string;
+export type Generic<T> = T | 'a';
+export type Primitive = string;
+
+export enum Computed {
+  A = 'a',
+  B = compute(),
+}
+`)
+
+  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)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  // The control: the shapes below differ from this one by exactly the property
+  // that makes them unnameable, so an empty result there is the rule acting and
+  // not the pass failing to run on this fixture at all.
+  if got := literalsOf(t, graph, nodeID(path, "Narrow", NodeTypeAlias)); len(got) != 4 {
+    t.Fatalf("control union did not report its four members: got %v", got)
+  }
+
+  for _, testCase := range []struct {
+    name string
+    kind NodeKind
+    why  string
+  }{
+    {"Widened", NodeTypeAlias, "a union with `string` in it admits values no list can name"},
+    {"Generic", NodeTypeAlias, "an unresolved type parameter names no value"},
+    {"Primitive", NodeTypeAlias, "a primitive is not a value set"},
+    {"Computed", NodeEnum, "a computed enum member has a value nothing here can name"},
+  } {
+    if got := literalsOf(t, graph, nodeID(path, testCase.name, testCase.kind)); len(got) != 0 {
+      t.Fatalf("%s reported a partial value set %v: %s", testCase.name, got, testCase.why)
+    }
+  }
+}

package/internal/graph/literals_cover_enum_members_the_graph_has_no_nodes_for_test.go

@@ -0,0 +1,79 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsCoverEnumMembersTheGraphHasNoNodesFor verifies that an enum
+// reports its member values, string-valued, numeric, and implicitly numbered
+// alike, however the declaration is laid out.
+//
+// An enum needed this more than a union did (#732). Its members are not nodes —
+// the build pass records member nodes for classes and interfaces only — so
+// nothing else in a details result carries them, and the old source-text scrape
+// stopped at the line holding `{`, which is the first line of every enum written
+// the ordinary way. A multi-line enum therefore reported no members at all,
+// through `literals` or otherwise, and only a single-line one answered. The
+// implicit fixture pins that the values come from the checker rather than the
+// text: nothing in `Implicit`'s source spells out 0 and 1.
+//
+//  1. Compile a fixture with a multi-line string enum, a single-line one, and an
+//     enum whose members are implicitly numbered.
+//  2. Build the graph.
+//  3. Assert each reports its resolved member values, and that the enum still
+//     has no member nodes so `literals` is genuinely the only carrier.
+func TestLiteralsCoverEnumMembersTheGraphHasNoNodesFor(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export enum Wrapped {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+
+export enum Flat { A = 'a', B = 'b', C = 'c' }
+
+export enum Implicit {
+  First,
+  Second,
+}
+`)
+
+  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)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  // The declaration whose members the old scrape could never reach.
+  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeEnum))
+  if want := []string{`"a"`, `"b"`, `"c"`}; !slices.Equal(wrapped, want) {
+    t.Fatalf("multi-line enum under-reported its members: got %v, want %v", wrapped, want)
+  }
+  // Layout is not the fact; the single-line twin must agree exactly.
+  flat := literalsOf(t, graph, nodeID(path, "Flat", NodeEnum))
+  if !slices.Equal(flat, wrapped) {
+    t.Fatalf("enum layout changed the value set: wrapped %v, flat %v", wrapped, flat)
+  }
+  // Implicitly numbered members: the values exist only in the checker, never in
+  // the source text, so a scrape of any kind cannot produce this list.
+  implicit := literalsOf(t, graph, nodeID(path, "Implicit", NodeEnum))
+  if want := []string{"0", "1"}; !slices.Equal(implicit, want) {
+    t.Fatalf("implicitly numbered enum did not report its resolved values: got %v, want %v", implicit, want)
+  }
+  // The premise: no member node exists to carry these instead, so dropping
+  // `literals` for an enum would take its members out of the graph entirely.
+  if node, ok := graph.Nodes[nodeID(path, "Wrapped.A", NodeMethod)]; ok {
+    t.Fatalf("enum member unexpectedly modeled as a node (%v); literals may no longer be the only carrier", node.ID)
+  }
+}

package/internal/graph/literals_do_not_depend_on_declaration_line_wrapping_test.go

@@ -0,0 +1,84 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsDoNotDependOnDeclarationLineWrapping verifies that collectLiterals
+// answers with the union's members whatever the declaration's layout: the same
+// eight-member type written one member per line and written on one line both
+// report all eight.
+//
+// This is the #732 regression. The value set used to be scraped out of the
+// declaration's first four lines of source text and cut to six, so completeness
+// was a function of line wrapping and of member count rather than of the type:
+// the wrapped form reported the three members that fit in the snippet, and the
+// flat form reported six of eight. Both cuts were silent. Eight members is the
+// boundary that pins both at once — it is past the old six-member cap, so a
+// reintroduced cap fails here on the flat twin instead of hiding behind a small
+// fixture.
+//
+//  1. Compile a fixture with a wrapped union and a flat union of the same eight
+//     string literals.
+//  2. Build the graph.
+//  3. Assert both nodes carry all eight values, in source form, and that the two
+//     lists are identical.
+func TestLiteralsDoNotDependOnDeclarationLineWrapping(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Wrapped =
+  | 'a' // a trailing comment the old snippet scrape also had to survive
+  | 'b'
+  | 'c'
+  | 'd'
+  | 'e'
+  | 'f'
+  | 'g'
+  | 'h';
+
+export type Flat = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+`)
+
+  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)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  want := []string{`"a"`, `"b"`, `"c"`, `"d"`, `"e"`, `"f"`, `"g"`, `"h"`}
+  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeTypeAlias))
+  flat := literalsOf(t, graph, nodeID(path, "Flat", NodeTypeAlias))
+
+  if !slices.Equal(wrapped, want) {
+    t.Fatalf("wrapped union under-reported its members: got %v, want %v", wrapped, want)
+  }
+  if !slices.Equal(flat, want) {
+    t.Fatalf("flat union under-reported its members: got %v, want %v", flat, want)
+  }
+  // The point of the fix stated directly: layout is not allowed to change the
+  // answer for one and the same type.
+  if !slices.Equal(wrapped, flat) {
+    t.Fatalf("line wrapping changed the value set: wrapped %v, flat %v", wrapped, flat)
+  }
+}
+
+// literalsOf returns the recorded value set of the node id names, failing the
+// test when the graph holds no such node.
+func literalsOf(t *testing.T, graph *Graph, id string) []string {
+  t.Helper()
+  node, ok := graph.Nodes[id]
+  if !ok {
+    t.Fatalf("graph has no node %q; nodes: %v", id, nodeIDSet(graph))
+  }
+  return node.Literals
+}

package/internal/graph/literals_render_every_value_in_typescript_source_form_test.go

@@ -0,0 +1,77 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsRenderEveryValueInTypescriptSourceForm verifies that each kind of
+// literal a union can hold reaches the wire as the way it is written, and that
+// the rendering is the checker's own rather than this package's.
+//
+// Source form is what makes the list readable as the type: it is the only
+// rendering that tells `1` from `"1"` and `true` from `"true"`, which bare
+// contents cannot, and the old string-only scrape could not report a numeric
+// union at all. The escaping fixture is why the checker's `ValueToString` is
+// used instead of a local formatter — a quote inside a value has to come back
+// escaped the way TypeScript escapes it, and Go's own quoting is not that.
+//
+//  1. Compile a fixture with a string, numeric, boolean, bigint, nullable, and
+//     escaped-string union.
+//  2. Build the graph.
+//  3. Assert each value set renders in TypeScript source form.
+func TestLiteralsRenderEveryValueInTypescriptSourceForm(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Strings = 'a' | 'b';
+export type Numbers = 1 | 2 | 3;
+export type Bools = true | false;
+export type Bigints = 1n | 2n;
+export type Nullable = 'a' | null;
+export type Optional = 'a' | undefined;
+export type Escaped = 'he said "hi"' | "it's" | 'tab\there';
+export type Mixed = 'a' | 1 | true;
+`)
+
+  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)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  for _, testCase := range []struct {
+    name string
+    want []string
+  }{
+    // A string keeps its quotes, so the list reads as the type does.
+    {"Strings", []string{`"a"`, `"b"`}},
+    // Numbers were absent entirely under the string-only scrape.
+    {"Numbers", []string{"1", "2", "3"}},
+    {"Bools", []string{"false", "true"}},
+    {"Bigints", []string{"1n", "2n"}},
+    // A unit type that is not a literal still names one value a caller writes,
+    // so the set stays complete rather than dropping to nothing.
+    {"Nullable", []string{"null", `"a"`}},
+    {"Optional", []string{"undefined", `"a"`}},
+    // The checker's escaping, not Go's: an inner double quote is backslashed,
+    // an apostrophe is not re-quoted, and a tab stays an escape rather than a
+    // raw control character.
+    {"Escaped", []string{`"he said \"hi\""`, `"it's"`, `"tab\there"`}},
+    // Kinds mix in one union, and source form is what keeps them apart.
+    {"Mixed", []string{`"a"`, "1", "true"}},
+  } {
+    got := literalsOf(t, graph, nodeID(path, testCase.name, NodeTypeAlias))
+    if !slices.Equal(got, testCase.want) {
+      t.Fatalf("%s rendered %v, want %v", testCase.name, got, testCase.want)
+    }
+  }
+}

package/internal/graph/literals_resolve_through_alias_indirection_test.go

@@ -0,0 +1,64 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsResolveThroughAliasIndirection verifies that a union assembled out
+// of other unions reports every member it admits, including the ones no token of
+// its own declaration names.
+//
+// This is the half of #732 that was not truncation but a wrong answer of the
+// right shape. Reading `type Wide = Narrow | 'd'` off the source text finds one
+// quoted token and reports `'d'`, a complete-looking three-member type reduced
+// to one, with nothing marking the loss. Only the checker has followed Narrow.
+// The nested case (`Wider = Wide | 'e'`) pins that the resolution is not one hop
+// deep, and the checker also flattens and dedups, so `Duplicated` must report
+// `'a'` once rather than twice.
+//
+//  1. Compile a fixture whose aliases build on each other, one of them
+//     re-listing a member an aliased union already has.
+//  2. Build the graph.
+//  3. Assert each alias reports the full set it admits, deduplicated.
+func TestLiteralsResolveThroughAliasIndirection(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Narrow = 'a' | 'b' | 'c';
+export type Wide = Narrow | 'd';
+export type Wider = Wide | 'e';
+export type Duplicated = Narrow | 'a';
+`)
+
+  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)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  // One hop: the three members reaching Wide through Narrow are Wide's too.
+  wide := literalsOf(t, graph, nodeID(path, "Wide", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`, `"d"`}; !slices.Equal(wide, want) {
+    t.Fatalf("alias indirection lost members: got %v, want %v", wide, want)
+  }
+  // Two hops: resolution is the type's, so depth costs nothing.
+  wider := literalsOf(t, graph, nodeID(path, "Wider", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`, `"d"`, `"e"`}; !slices.Equal(wider, want) {
+    t.Fatalf("nested alias indirection lost members: got %v, want %v", wider, want)
+  }
+  // A member named twice is one member; the checker has already deduped, so the
+  // list must not report `"a"` once per mention.
+  duplicated := literalsOf(t, graph, nodeID(path, "Duplicated", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`}; !slices.Equal(duplicated, want) {
+    t.Fatalf("a member named twice was reported twice: got %v, want %v", duplicated, want)
+  }
+}

package/internal/graph/provenance.go

@@ -14,7 +14,7 @@ import (
 // field is added, removed, or given a new meaning, independently of the serve
 // envelope's protocol version: a one-shot `ttscgraph dump` written to a file has
 // a schema but never rode the protocol.
-const DumpSchemaVersion = 1
+const DumpSchemaVersion = 3
 
 // The capabilities a snapshot can declare. Each names one class of evidence a
 // consumer may rely on when, and only when, the snapshot lists it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -35,13 +35,13 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.19.2",
-    "@ttsc/linux-arm": "0.19.2",
-    "@ttsc/linux-arm64": "0.19.2",
-    "@ttsc/darwin-x64": "0.19.2",
-    "@ttsc/win32-x64": "0.19.2",
-    "@ttsc/win32-arm64": "0.19.2",
-    "@ttsc/darwin-arm64": "0.19.2"
+    "@ttsc/linux-x64": "0.19.3",
+    "@ttsc/linux-arm64": "0.19.3",
+    "@ttsc/linux-arm": "0.19.3",
+    "@ttsc/darwin-arm64": "0.19.3",
+    "@ttsc/win32-x64": "0.19.3",
+    "@ttsc/darwin-x64": "0.19.3",
+    "@ttsc/win32-arm64": "0.19.3"
   },
   "sideEffects": false,
   "files": [

package/shim/checker/shim.go

@@ -49,6 +49,19 @@ func Checker_getRegularTypeOfLiteralType(recv *innerchecker.Checker, t *innerche
   return checkerGetRegularTypeOfLiteralType(recv, t)
 }
 
+// ValueToString renders a literal type's value in TypeScript source form: a
+// string as a double-quoted, escaped literal, a number, boolean, or bigint as
+// the way it is written. It is the checker's own renderer, so a consumer
+// enumerating a literal union reports the values the way the compiler prints
+// them, including numeric formatting and string escaping it should not re-derive.
+//
+// It panics on a value it does not handle — notably the nil a computed enum
+// member carries — so a caller holding a `LiteralType.Value()` must reject nil
+// before calling this.
+func ValueToString(value any) string {
+  return innerchecker.ValueToString(value)
+}
+
 // Checker_typeToStringFullyQualified formats a type with the same stable,
 // alias-aware flags TypeScript uses in diagnostics that name union members.
 // Keeping the flag bundle inside the shim avoids leaking checker-internal enum