ttsc 0.30.3 → 0.31.0

package/internal/graph/edges.go

@@ -52,10 +52,10 @@ func (g *Graph) addEdgeAt(from, to string, kind EdgeKind, origin string, pos, en
   // `extends` and an `implements` of the same base) are both kept, while
   // repeated uses of the same form collapse to one edge.
   //
-  // The key is a struct, not a concatenation. Concatenating allocated a fresh
-  // string per *candidate* edge — including the duplicates thrown away on the
-  // next line, which on a large program are most of them — and a comparable
-  // struct of the three fields hashes just as well for nothing.
+  // The key is a struct, not a concatenation: concatenating would allocate a
+  // fresh string per *candidate* edge, including the duplicates thrown away on
+  // the next line, while a comparable struct of the three fields hashes just as
+  // well at no allocation.
   key := edgeKey{from: from, to: to, kind: wireEdgeKind(kind, origin)}
   if _, exists := g.seen[key]; exists {
     return
@@ -136,11 +136,11 @@ func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *s
 }
 
 // memberRelationEdges records the directly declared member pairs that a
-// heritage clause makes checker-valid. The TypeScript loader used to infer
-// these from equal names after the dump was built. That made an authoritative
-// edge even when the checker rejected the container relation, and a method /
-// property kind guard could not repair it: same-kind signatures can be
-// incompatible while a method can validly satisfy a function-valued property.
+// heritage clause makes checker-valid. Inferring them from equal names after the
+// dump was built would make an authoritative edge even when the checker rejects
+// the container relation, and a method / property kind guard could not repair
+// it: same-kind signatures can be incompatible while a method can validly
+// satisfy a function-valued property.
 //
 // Each pair is checked independently. A whole-container assignability gate
 // would let one broken sibling erase a valid relation in the same partially
@@ -177,7 +177,7 @@ func (g *Graph) memberRelationEdges(
   }
   for _, derivedMember := range derivedMembers {
     derivedMemberSymbol := derivedMember.Symbol()
-    if derivedMemberSymbol == nil || derivedMemberSymbol.Name == "" ||
+    if derivedMemberSymbol == nil ||
       shimast.GetCombinedModifierFlags(derivedMember)&shimast.ModifierFlagsStatic != 0 ||
       derivedMember.Kind == shimast.KindConstructor {
       continue
@@ -195,9 +195,9 @@ func (g *Graph) memberRelationEdges(
       // `interface Child extends Root {}` with `class W implements Child`
       // resolves `W.execute` against `Root.execute`, and the program compiles
       // with no diagnostic — but the immediate base declares nothing, so
-      // requiring a directly declared member dropped a relation the checker
-      // had already established. Execution tracing follows these edges to
-      // reach an implementation, so the missing edge ends the trace at the
+      // requiring a directly declared member would drop a relation the checker
+      // has already established. Execution tracing follows these edges to
+      // reach an implementation, so a missing edge would end the trace at the
       // abstract declaration.
       baseMember = inheritedMemberForProperty(checker, baseProperty)
     }
@@ -282,7 +282,7 @@ func directMemberForProperty(
 ) *shimast.Node {
   for _, member := range members {
     symbol := member.Symbol()
-    if symbol == nil || symbol.Name == "" ||
+    if symbol == nil ||
       shimast.GetCombinedModifierFlags(member)&shimast.ModifierFlagsStatic != 0 ||
       member.Kind == shimast.KindConstructor {
       continue
@@ -375,9 +375,8 @@ func forEachContainerIn(path string, statements []*shimast.Node, fn func(string,
       if id := topLevelID(path, statement, NodeFunction); id != "" {
         fn(id, statement)
       }
-      // Closure nodes are not indexed (build.go): what a function body runs is
-      // implementation, and implementation is read from the file. The walker
-      // stays for the day the caller asks for them.
+      // Named closures have their own indexed nodes. Their direct relationships
+      // coexist with the enclosing callable's aggregate body relationships.
       forEachClosureIn(path, statement, fn)
     case shimast.KindTypeAliasDeclaration:
       if id := topLevelID(path, statement, NodeTypeAlias); id != "" {
@@ -402,8 +401,8 @@ func forEachContainerIn(path string, statements []*shimast.Node, fn func(string,
       // A statement that declares nothing still runs: a test suite's
       // `describe(() => it(() => schema.parse(x)))`, an entry file's
       // `bootstrap()`, a registration side effect. No declaration owns those
-      // calls, so attributing edges to owners alone dropped every one of them,
-      // and with them every test the graph could have pointed at. The module
+      // calls, so attributing edges to owners alone would drop every one of
+      // them, and with them every test the graph could point at. The module
       // runs them, so the module owns them.
       fn(moduleID(path), statement)
     }
@@ -431,7 +430,7 @@ func topLevelID(path string, statement *shimast.Node, kind NodeKind) string {
 // node. Property members are additive: their initializer/type subtree is walked
 // once for the property node, and once for the owner type node, so precise member
 // queries can land on `Class.prop` without making coarse class/interface queries
-// lose dependency edges they historically owned.
+// lose dependency edges the owner node carries.
 func forEachMember(path string, statement *shimast.Node, kind NodeKind, fn func(string, *shimast.Node)) {
   containerID := topLevelID(path, statement, kind)
   for _, member := range classMembers(statement) {
@@ -506,14 +505,16 @@ func forEachVariable(path string, statement *shimast.Node, fn func(string, *shim
       continue
     }
     fn(nodeID(path, qualifiedName(symbol), NodeVariable), binding)
+    if variable := binding.AsVariableDeclaration(); variable != nil {
+      forEachObjectDeclaration(path, variable.Initializer, fn)
+    }
     forEachClosureIn(path, binding, fn)
   }
 }
 
 // forEachClosureIn pairs each function a declaration's body declares with its
-// own node, and recurses: the renderer's `patch` owns the calls it makes, not the
-// factory it closes over. `callsWithin` stops at the same boundary, so no call is
-// attributed twice.
+// own node, and recurses. The closure records its direct body relationships;
+// enclosing callable nodes retain aggregate relationships through callsWithin.
 func forEachClosureIn(path string, declaration *shimast.Node, fn func(string, *shimast.Node)) {
   for _, closure := range ClosuresIn(declaration) {
     if id := closureID(path, closure); id != "" {
@@ -541,9 +542,8 @@ func closureID(path string, closure *shimast.Node) string {
 // value-call edges, and property or element access as value-access edges.
 func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shimast.Node) {
   node.ForEachChild(func(child *shimast.Node) bool {
-    // With closures unindexed, a body's calls belong to the declaration that
-    // owns the body — the walk does not stop at one. (When they are indexed, it
-    // must: a closure that is its own node owns the calls it makes.)
+    // The owning callable keeps aggregate body relationships across closures.
+    // forEachClosureIn also records each named closure's own relationships.
     switch child.Kind {
     case shimast.KindCallExpression:
       // A decorator's own factory call (`@Column()`, `@Entity()`) is metadata,
@@ -612,13 +612,12 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
 // …` against a `declare global { function assert(…) }`, or a patched member of
 // a dependency's `@types`, resolves to a symbol whose only declaration is in a
 // declaration file — which has no body, holds no facts, and enters the graph as
-// an external boundary leaf. Re-attributing the assigned body to it moved the
-// implementation's calls and type references onto a node that never ran them,
-// under offsets read against the wrong file: `recordImplementation` already
-// refuses an external node, so the evidence file stayed unset and the spans
-// pointed at neither the declaration nor the implementation. And the edge
-// itself was unassemblable, so every request against such a project failed at
-// shard partition.
+// an external boundary leaf. Re-attributing the assigned body to it would move
+// the implementation's calls and type references onto a node that never ran
+// them, under offsets read against the wrong file: `recordImplementation`
+// refuses an external node, so the evidence file would stay unset and the spans
+// would point at neither the declaration nor the implementation, and the edge
+// itself could not be assembled into a shard.
 func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string, node *shimast.Node) string {
   binary := node.AsBinaryExpression()
   if binary == nil ||
@@ -713,12 +712,9 @@ func (g *Graph) callEdge(checker *shimchecker.Checker, from string, callee *shim
 //
 // `React.memo(ExcalidrawBase)`, `forwardRef(Impl)`, `app.use(handler)`,
 // `pipe(map(project))` — the argument is not called here and is not a property
-// read, so the collector saw neither a call nor an access and recorded nothing.
-// The wrapper became a dead end: Excalidraw's public export, `export const
-// Excalidraw = React.memo(ExcalidrawBase)`, reached zero files in the graph while
-// the component behind it reached forty-four, so a tour of the public API opened
-// on an app-level export dialog instead, and the model went looking for the real
-// component by hand.
+// read, so neither the call nor the access collector would record it, and the
+// wrapper would be a dead end: `export const Excalidraw =
+// React.memo(ExcalidrawBase)` would reach nothing of the component behind it.
 //
 // A function handed to another function is a use of it, and it is the one the
 // runtime will run. Bounded to argument position: this is the callback, the
@@ -880,14 +876,15 @@ func (g *Graph) ensureTargetNode(target *Target) string {
     return ""
   }
   g.Nodes[id] = &Node{
-    ID:       id,
-    Name:     name,
-    Simple:   simpleName(target.Symbol),
-    Kind:     kind,
-    File:     target.File,
-    External: true,
-    Pos:      target.Pos,
-    End:      target.End,
+    ID:        id,
+    Name:      name,
+    Simple:    simpleName(target.Symbol),
+    HasSimple: target.Symbol != nil,
+    Kind:      kind,
+    File:      target.File,
+    External:  true,
+    Pos:       target.Pos,
+    End:       target.End,
   }
   return id
 }

package/internal/graph/edges_cover_class_level_references_test.go

@@ -7,23 +7,26 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestEdgesCoverClassLevelReferences verifies that the references living on a
-// class declaration itself — not in a member — are attributed to the class
-// node. The method-node split walks members one at a time, so without an
-// explicit class-level pass these edges are silently dropped:
+// TestEdgesCoverClassLevelReferences checks two type references on the authored
+// Service declaration, together with its heritage and decorator facts:
 //
 //   - a heritage type argument `extends Base<Payload>` -> type-ref to Payload
 //   - a type parameter constraint `<T extends Constraint>` -> type-ref to Constraint
 //
-// These are exactly the relationships generic-heavy codebases are built from, so
-// a top-level-only-then-per-member walk that forgot them would blind the graph
-// to generic-base edges.
+// The authored decorator produces metadata without a Service-to-Injectable
+// value-call edge. Other class-level syntax and runtime decorator effects are
+// not exercised by this entry.
 //
-// A decorator's own factory call (`@Injectable()`) is deliberately NOT a
-// value-call edge: the decoration is a fact on the node's decorators, and a
-// calls edge to the decorator function would make ubiquitous decorators the
-// busiest nodes in the graph. The test pins both halves of that contract.
+// 1. Load decorated Service with generic Constraint, Base heritage and Payload arguments.
+// 2. Build its class-level type, heritage and decorator facts.
+// 3. Require Payload and Constraint type references, Base heritage and Injectable metadata, without a spurious decorator factory value-call edge.
+//
+// @evidence contracts/testing.md#behavioral-verification Require Payload and Constraint type references, Base heritage and Injectable metadata, without a spurious decorator factory value-call edge.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over the Service class: type-ref edges to Payload (heritage type argument) and Constraint (type parameter constraint), a heritage edge to Base, a recorded Injectable decorator on Service, and no value-call edge from Service to Injectable. The checks are by presence or absence of edges and do not assert spans.
+// @evidence contracts/testing.md#distinguishing-cases Load decorated Service with generic Constraint, Base heritage and Payload arguments. Build its class-level type, heritage and decorator facts. Require Payload and Constraint type references, Base heritage and Injectable metadata, without a spurious decorator factory value-call edge.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native experimental-decorator project, constructs/closes its driver Program in-process and directly calls Build. Actual Program filenames and the shared nodeID formatter select literal-name endpoints; they are not an independent ID-grammar oracle. A restored empty linked-plugin manifest excludes ambient hooks; no emitted decorator code, installed consumer or product process runs.
 func TestEdgesCoverClassLevelReferences(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), `{
   "compilerOptions": {

package/internal/graph/enum_initializer_calls_are_edges_test.go

@@ -8,10 +8,20 @@ import (
 )
 
 // TestEnumInitializerCallsAreEdges pins that a value-call inside a (non-const)
-// enum member initializer is recorded as an edge from the enum node. build.go
-// records the enum as a node, but the edge pass must also walk the enum body, or
-// the call in `A = base()` is silently dropped — the gap a round-1 reviewer found.
+// enum member initializer is recorded as an edge from the enum node in the
+// authored E { A = base() } fixture. Other initializer forms and emitted enum
+// execution are not tested here.
+//
+// 1. Load enum E whose A initializer calls base.
+// 2. Build the enum and initializer relations.
+// 3. Require the E node and its value-call edge to base.
+//
+// @evidence contracts/testing.md#behavioral-verification Require the E node and its value-call edge to base.
+// @evidence contracts/testing.md#independent-expectations The expectation is literal: for export enum E { A = base() } the graph must hold the E enum node and a value-call edge from E to the base function; dropping the initializer walk fails the edge check.
+// @evidence contracts/testing.md#distinguishing-cases Load enum E whose A initializer calls base. Build the enum and initializer relations. Require the E node and its value-call edge to base.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native project, constructs/closes a driver Program in-process and calls Build. Actual Program filename and shared nodeID formatting select the literal E/base endpoints, not an independent ID grammar. A restored empty linked-plugin manifest excludes ambient hooks; no emit, installed consumer or product process runs.
 func TestEnumInitializerCallsAreEdges(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), `{
   "compilerOptions": {

package/internal/graph/enum_members_carry_their_names_on_the_enum_node_test.go

@@ -8,25 +8,22 @@ import (
 )
 
 // TestEnumMembersCarryTheirNamesOnTheEnumNode verifies that an enum records the
-// name and value of each member on its own node, and that nothing else does.
+// selected member pairs on enum nodes. Three authored enums cover string,
+// implicit numeric and duplicate-value declarations, with one class negative.
+// The member-node absence check is limited to two candidate IDs for Colors.Red.
 //
-// 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.
+//  1. Load a fixture with string, implicitly numbered and duplicate-value enums
+//     plus a class.
 //  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.
+//  3. Assert selected pairs, duplicate names and literal count, two absent Red
+//     variable IDs, and empty enum members on the class.
+//
+// @evidence contracts/testing.md#behavioral-verification Build must retain ordered Colors string pairs and Implicit numeric pairs, all three Dup names with a two-entry literal array, no variable node at either tested Colors.Red/Red ID, and no enum members on Cls. Dup literal contents and absence of every possible member-node ID are not asserted.
+// @evidence contracts/testing.md#independent-expectations Literal fixture expectations are Red/"red", Green/"green", First/0, Second/1 in order; Dup names A/B/C and Literals length two; absence of the two Colors.Red/Red variable IDs; and empty Cls.EnumMembers. Shared ID formatting is a selection dependency, while member names, values and counts are independent literals.
+// @evidence contracts/testing.md#distinguishing-cases Ordered string and implicit numeric pairs contrast explicit and inferred values; duplicate-value names must not collapse, while their literal array has two entries. Two Red variable IDs and Cls.EnumMembers provide bounded negative counterparts; other member forms are not tested here.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native project, constructs/closes a driver Program in-process and directly calls Build. A local helper copies reported member names for literal comparisons; a restored empty linked-plugin manifest excludes ambient hooks. No emit, consumer installation or product process runs.
 func TestEnumMembersCarryTheirNamesOnTheEnumNode(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   writeFile(t, filepath.Join(root, "src", "main.ts"), `export enum Colors {
@@ -77,8 +74,8 @@ export class Cls {
     }
   }
 
-  // The values exist only in the checker here, so a scrape of the source could
-  // not produce this pairing.
+  // The expected numeric values are not written as initializers in the fixture.
+  // This result check does not prove which acquisition method produced them.
   implicit := graph.Nodes[nodeID(path, "Implicit", NodeEnum)]
   if implicit == nil ||
     len(implicit.EnumMembers) != 2 ||
@@ -87,10 +84,7 @@ export class Cls {
     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.
+  // Three declared names must remain even when A and B share one value.
   dup := graph.Nodes[nodeID(path, "Dup", NodeEnum)]
   if dup == nil {
     t.Fatalf("missing Dup; nodes: %v", nodeIDSet(graph))
@@ -99,14 +93,13 @@ export class Cls {
     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.
+  // The reported literal array must have two entries; their contents are not
+  // asserted by this count check.
   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.
+  // Reject the two candidate variable-node IDs for the authored Red member.
   for id := range graph.Nodes {
     if id == nodeID(path, "Colors.Red", NodeVariable) ||
       id == nodeID(path, "Red", NodeVariable) {

package/internal/graph/exports.go

@@ -59,11 +59,9 @@ func (g *Graph) markExports(checker *shimchecker.Checker, file *shimast.SourceFi
 // Every source file gets one, exporting or not, because a module is also what
 // runs a file's top-level statements — and those statements are where a test
 // file keeps everything it does. `describe(() => it(() => schema.parse(x)))` is
-// a call the checker resolves and the graph used to drop on the floor: it sits
-// inside a callback, no declaration owns it, and edges are attributed to owners.
-// A whole test suite left no trace, which is why a tour that promised the tests
-// to read next could name two of zod's and none of NestJS's, and why the model
-// went off to glob for them.
+// a call the checker resolves and that no declaration owns: it sits inside a
+// callback, and edges are attributed to owners. Without a module node a whole
+// test suite would leave no trace in the graph.
 func (g *Graph) putModuleNode(file *shimast.SourceFile) *Node {
   path := file.FileName()
   id := nodeID(path, path, NodeModule)

package/internal/graph/file_diagnostics_match_tsgo_code_and_location_test.go

@@ -8,16 +8,21 @@ import (
 )
 
 // TestFileDiagnosticsMatchTsgoCodeAndLocation verifies that FileDiagnostics
-// surfaces the same semantic error code and line tsgo emits, scoped to one file.
-// This is validation gate 4 from issue #259: a deliberate type error must yield
-// the exact tsc code/location from the graph's shared Program, proving the
-// diagnostics path is the real checker and not a re-implementation.
+// retains the selected Program finding's literal code, line and queried file,
+// while an absent file returns none. FileDiagnostics queries whole-Program
+// diagnostics before exact-file filtering; this entry runs no reference CLI.
 //
 //  1. Compile a fixture whose only file assigns a string to a number binding.
 //  2. Ask FileDiagnostics for that file.
 //  3. Assert a TS2322 (not assignable) diagnostic on line 1, and that an
 //     unrelated path yields none.
+//
+// @evidence contracts/testing.md#behavioral-verification The actual FileDiagnostics result must include TS2322 at line 1 with File equal to the queried resident source; querying the absent src/absent.ts must return no records. Column, message, severity and complete finding count are not asserted here.
+// @evidence contracts/testing.md#independent-expectations The authored string-to-number assignment has literal TS2322 and line 1 expectations, while the absent-path expectation is zero findings. The queried resident filename is supplied by the actual Program; no separate tsgo process or complete independent diagnostic oracle authenticates acquisition.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture whose only file assigns a string to a number binding; Ask FileDiagnostics for that file; Assert a TS2322 (not assignable) diagnostic on line 1, and that an unrelated path yields none.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native one-file project, loads/closes its driver Program in-process and calls FileDiagnostics twice. The adapter acquires whole-Program diagnostics before exact File filtering, so the query path is not a checker-work boundary. A restored empty linked-plugin manifest excludes ambient hooks; no consumer installation or product process runs.
 func TestFileDiagnosticsMatchTsgoCodeAndLocation(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   writeFile(t, filepath.Join(root, "src", "main.ts"), `export const broken: number = "not a number";

package/internal/graph/file_diagnostics_report_code_column_and_message_test.go

@@ -9,14 +9,14 @@ import (
 )
 
 // TestFileDiagnosticsReportCodeColumnAndMessage verifies that FileDiagnostics
-// surfaces the full tsgo-reported location and text of a type error, not just
-// its code and line: the column points at the offending initializer and the
-// message carries the human-readable reason.
+// reports the literal code, line, binding column and message fragment expected
+// for the authored bad assignment. It does not compare complete diagnostic text
+// or invoke a separate tsgo reference process.
 //
 // The existing match-code-and-location probe pins Line and Code; this one
 // strengthens the contract to Column and Message so a regression that kept the
-// right code but lost the precise span (or the text) is caught. The oracle is
-// the real checker: tsgo attributes the assignability error to the declared
+// right code but lost the binding column or message fragment is caught.
+// The expected assignability location is the declared
 // binding, so on `export const broken: number = "nope";` the diagnostic sits at
 // `broken` — 1-based column 14 (`export const ` is 13 characters).
 //
@@ -24,7 +24,13 @@ import (
 //  2. Ask FileDiagnostics for that file.
 //  3. Assert the TS2322 diagnostic sits at line 1 / column 14 and its message
 //     contains "not assignable".
+//
+// @evidence contracts/testing.md#behavioral-verification Actual FileDiagnostics must include TS2322 at line 1 column 14 with a not assignable message fragment. Complete text, end positions, severity, record count and independent CLI equivalence are not asserted.
+// @evidence contracts/testing.md#independent-expectations Literal TS2322, line 1, column 14 and not assignable expectations follow the authored string-to-number assignment; the binding broken follows 13 source characters. They are not computed from FileDiagnostics, but this entry has no separate reference compiler output and cannot independently authenticate its entire acquisition path.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture whose only file assigns a string to a number binding; Ask FileDiagnostics for that file; Assert the TS2322 diagnostic sits at line 1 / column 14 and its message contains "not assignable".
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native one-file project, loads/closes its driver Program in-process and calls FileDiagnostics, which acquires whole-Program diagnostics then filters exact File. A restored empty linked-plugin manifest excludes ambient hooks; no consumer installation or product process runs. The match-code-and-location entry owns the absent-path counterpart.
 func TestFileDiagnosticsReportCodeColumnAndMessage(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   writeFile(t, filepath.Join(root, "src", "main.ts"), `export const broken: number = "nope";

package/internal/graph/function_locals_do_not_collide_test.go

@@ -7,13 +7,23 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestFunctionLocalsDoNotCollide verifies that a function-local declaration is
-// not minted as a graph node. Build records top-level declarations, namespace
-// members, and class/interface members only; a body-scoped local resolved as an
-// edge target has an unqualified, position-free id, so two same-named locals in
-// different scopes would key the same node and merge — fabricating a false edge
-// from each unrelated caller to one phantom callable.
+// TestFunctionLocalsDoNotCollide verifies distinct local callables do not share an unqualified graph identity.
+//
+// Two outer scopes each declare inner. An unqualified, position-free inner
+// identity would merge unrelated call targets; these assertions permit separately
+// scope-qualified callable facts.
+//
+//  1. Load outerA and outerB, each with its own inner declaration.
+//  2. Build declarations and their relations from the real compiler.
+//  3. Require each scoped inner and its owner's call, then reject the unqualified
+//     inner node and edges to that shared identity.
+//
+// @evidence contracts/testing.md#behavioral-verification Build must retain outerA.inner and outerB.inner with their respective outer-to-inner call edges, while creating neither an unqualified inner node nor an edge to an unqualified inner target. Empty or dropped-local graphs cannot satisfy the positive counterpart.
+// @evidence contracts/testing.md#independent-expectations The two literal named outer functions define separate lexical inner declarations. Literal scoped names and owner/target pairs follow that nesting; the shared ID formatter selects their coordinates rather than supplying an independent ID-grammar oracle. An unqualified inner identity would erase the tested scope distinction.
+// @evidence contracts/testing.md#distinguishing-cases Two same-named locals in separate named outer scopes require their own scoped nodes and call targets, contrasting a colliding unqualified node or edge. Anonymous owners, deeper scopes and source position identity are not asserted here.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native project, constructs/closes a driver Program in-process and directly calls Build. Actual Program filenames and shared nodeID formatting select literal scoped endpoints. A restored empty linked-plugin manifest excludes ambient hooks; no consumer installation or product process runs.
 func TestFunctionLocalsDoNotCollide(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), `{
   "compilerOptions": {
@@ -53,7 +63,17 @@ export function outerB(): number {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  // No function-local node is minted...
+  for _, owner := range []string{"outerA", "outerB"} {
+    localID := nodeID(path, owner+".inner", NodeFunction)
+    if local := graph.Nodes[localID]; local == nil || local.Name != owner+".inner" {
+      t.Fatalf("missing scoped local %s.inner; nodes: %v", owner, nodeIDSet(graph))
+    }
+    if !hasEdge(graph, nodeID(path, owner, NodeFunction), localID, EdgeValueCall) {
+      t.Fatalf("missing %s -> %s.inner call; edges: %v", owner, owner, graph.Edges)
+    }
+  }
+
+  // No unqualified function-local node is minted...
   if _, ok := graph.Nodes[nodeID(path, "inner", NodeFunction)]; ok {
     t.Fatalf("a function-local 'inner' was minted as a node (would collide across scopes)")
   }

package/internal/graph/gitignore.go

@@ -3,18 +3,29 @@ package graph
 import (
   "os/exec"
   "strings"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/e2etrace"
 )
 
 // GitIgnoredFiles returns the graph's source files that git ignores: generated
 // output an author does not navigate, such as a Prisma client or other codegen
-// emitted as real .ts into the source tree (the .d.ts emit is already dropped by
-// driver.SourceFiles, but a generated .ts becomes a node and, being large and
-// highly connected, otherwise dominates ranking and floods responses). Callers
-// de-surface them: the MCP matcher keeps them reachable as edge targets and by
-// exact name; the full-graph dump drops them from the viewer payload entirely.
+// emitted as real .ts into the source tree. Graph declaration classification
+// treats declaration files separately; driver.SourceFiles itself still exposes
+// loaded declaration files. Dump projection marks reported matches as Ignored
+// rather than dropping the nodes here; consumer presentation owns de-surfacing.
 //
 // Empty when cwd is unset, the tree is not a git work tree, or git is
-// unavailable, so a non-git project is unaffected.
+// unavailable. The default check-ignore invocation omits tracked files; empty
+// stdout also hides a failed query because this optional result has no error lane.
+//
+// @evidence contracts/common.md#principled-implementation Git check-ignore supplies membership for unique reported paths using NUL input/output and default tracked-file omission. This optional result preserves nonempty stdout without authenticating query success or acquisition stability.
+// @evidence contracts/common.md#clear-and-simple-design One subprocess batches the graph's unique physical files and returns a membership set for both navigation and dump consumers.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The function uses configured Git semantics rather than a generated-code name heuristic; unavailable Git supplies no invented ignored paths.
+// @evidence contracts/common.md#meaningful-documentation Native paragraphs state de-surfacing behavior and optional Git availability, with documentation-skill prose/tag separation.
+// @evidence contracts/portability.md#os-neutral-implementation Executable and arguments are passed separately through os/exec; the documented Git -z protocol handles filenames independently of OS quoting or separators.
+// @evidence contracts/performance.md#efficient-algorithms One graph-node scan deduplicates string keys and one command evaluates the batch. Path hashing, joined input, native Git index/ignore work, complete stdout capture and parsing contribute; enabled private tracing also adds its own bounded observations.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This acquisition does not own ignore-rule invalidation or cross-generation caching; a caller must refresh it when Git inputs change.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Cmd.Output owns child wait, copy goroutines and pipe closure when it returns. No context deadline, WaitDelay or stdout/population cap is set here, so a hung child or inherited output can prolong completion. Temporary input/maps are call-local; returned membership substrings can retain the complete decoded stdout backing string. No historical cache is owned, and tracing has a separate sink lifetime.
 func GitIgnoredFiles(cwd string, g *Graph) map[string]bool {
   if cwd == "" || g == nil {
     return nil
@@ -32,16 +43,18 @@ func GitIgnoredFiles(cwd string, g *Graph) map[string]bool {
   if len(paths) == 0 {
     return nil
   }
-  cmd := exec.Command("git", "-C", cwd, "check-ignore", "--stdin")
-  cmd.Stdin = strings.NewReader(strings.Join(paths, "\n") + "\n")
+  cmd := exec.Command("git", "-C", cwd, "check-ignore", "--stdin", "-z")
+  cmd.Stdin = strings.NewReader(strings.Join(paths, "\x00") + "\x00")
   // check-ignore exits 0 with the ignored paths on stdout, 1 (an error to
   // Output) with no output when none match, and 128 when git cannot run. Only
   // stdout matters: parse it whenever it is non-empty, ignore the exit code.
-  out, _ := cmd.Output()
+  observation := e2etrace.BeginCommand(cmd, "Output")
+  out, outputErr := cmd.Output()
+  observation.Result(outputErr)
   ignored := make(map[string]bool)
-  for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-    if line != "" {
-      ignored[line] = true
+  for _, path := range strings.Split(string(out), "\x00") {
+    if path != "" {
+      ignored[path] = true
     }
   }
   if len(ignored) == 0 {