ttsc 0.33.0 → 0.34.0

package/internal/graph/heritage_edges_record_extends_versus_implements_origin_test.go

@@ -47,9 +47,9 @@ export class Sub extends Sup implements Iface {}
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  sub := nodeID(path, "Sub", NodeClass)
-  sup := nodeID(path, "Sup", NodeClass)
-  iface := nodeID(path, "Iface", NodeInterface)
+  sub := nodeID(string(path), "Sub", NodeClass)
+  sup := nodeID(string(path), "Sup", NodeClass)
+  iface := nodeID(string(path), "Iface", NodeInterface)
 
   if got := edgeOrigin(graph, sub, sup, EdgeHeritage); got != "extends" {
     t.Fatalf("Sub -> Sup: want heritage Origin \"extends\", got %q; edges: %v", got, graph.Edges)

package/internal/graph/heritage_edges_traverse_barrels_and_stop_at_external_leaves_test.go

@@ -63,11 +63,11 @@ export class SubExt extends Ext {}
   implPath := sourceFile(t, prog, "impl.ts").FileName()
 
   // Barrel traversal: the base resolved to the sibling source, not the index.
-  base := nodeID(implPath, "Base", NodeClass)
+  base := nodeID(string(implPath), "Base", NodeClass)
   if node, ok := graph.Nodes[base]; !ok || node.External {
     t.Fatalf("Base node missing or misclassified external (barrel not traversed): %+v", node)
   }
-  sub := nodeID(mainPath, "Sub", NodeClass)
+  sub := nodeID(string(mainPath), "Sub", NodeClass)
   if !hasEdge(graph, sub, base, EdgeHeritage) {
     t.Fatalf("missing heritage edge Sub -> Base@impl.ts; edges: %v", graph.Edges)
   }
@@ -81,7 +81,7 @@ export class SubExt extends Ext {}
   if !ext.External || !strings.Contains(ext.File, "/node_modules/") {
     t.Fatalf("Ext should be an external node_modules leaf: %+v", ext)
   }
-  subExt := nodeID(mainPath, "SubExt", NodeClass)
+  subExt := nodeID(string(mainPath), "SubExt", NodeClass)
   if !hasEdge(graph, subExt, ext.ID, EdgeHeritage) {
     t.Fatalf("missing heritage edge SubExt -> Ext (external); edges: %v", graph.Edges)
   }

package/internal/graph/literals.go

@@ -28,7 +28,7 @@ func (g *Graph) collectLiterals(checker *shimchecker.Checker, file *shimast.Sour
   if file.Statements == nil {
     return
   }
-  g.collectLiteralsIn(checker, file.FileName(), file.Statements.Nodes)
+  g.collectLiteralsIn(checker, string(file.FileName()), file.Statements.Nodes)
 }
 
 // collectLiteralsIn walks a statement list — a file's top level, or a namespace
@@ -54,7 +54,7 @@ func (g *Graph) collectLiteralsIn(checker *shimchecker.Checker, path string, sta
 // 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 == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return
   }
   node, ok := g.Nodes[nodeID(path, qualifiedName(symbol), kind)]
@@ -103,7 +103,7 @@ func enumMembers(checker *shimchecker.Checker, statement *shimast.Node) []EnumMe
     if symbol == nil {
       continue
     }
-    member := EnumMember{Name: symbol.Name}
+    member := EnumMember{Name: shimast.SymbolNameOf(symbol)}
     if t := shimchecker.Checker_getTypeOfSymbol(checker, symbol); t != nil {
       if value, ok := literalValue(t); ok {
         member.Value = value

package/internal/graph/literals_are_absent_when_the_type_admits_more_than_it_can_name_test.go

@@ -58,7 +58,7 @@ export enum Computed {
 
   // A nonempty control detects omission of the entire literal pass; this count
   // does not independently check the control's four values.
-  if got := literalsOf(t, graph, nodeID(path, "Narrow", NodeTypeAlias)); len(got) != 4 {
+  if got := literalsOf(t, graph, nodeID(string(path), "Narrow", NodeTypeAlias)); len(got) != 4 {
     t.Fatalf("control union did not report its four members: got %v", got)
   }
 
@@ -72,7 +72,7 @@ export enum Computed {
     {"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 {
+    if got := literalsOf(t, graph, nodeID(string(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

@@ -54,24 +54,24 @@ export enum Implicit {
   path := sourceFile(t, prog, "main.ts").FileName()
 
   // Multiline declaration with independent literal expected values.
-  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeEnum))
+  wrapped := literalsOf(t, graph, nodeID(string(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))
+  flat := literalsOf(t, graph, nodeID(string(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 have literal semantic expectations; no numeric
   // initializers are written, but this does not certify the acquisition method.
-  implicit := literalsOf(t, graph, nodeID(path, "Implicit", NodeEnum))
+  implicit := literalsOf(t, graph, nodeID(string(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)
   }
   // Reject this particular method-node identity; other enum detail fields and
   // member-node spellings are not examined.
-  if node, ok := graph.Nodes[nodeID(path, "Wrapped.A", NodeMethod)]; ok {
+  if node, ok := graph.Nodes[nodeID(string(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

@@ -57,8 +57,8 @@ export type Flat = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
   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))
+  wrapped := literalsOf(t, graph, nodeID(string(path), "Wrapped", NodeTypeAlias))
+  flat := literalsOf(t, graph, nodeID(string(path), "Flat", NodeTypeAlias))
 
   if !slices.Equal(wrapped, want) {
     t.Fatalf("wrapped union under-reported its members: got %v, want %v", wrapped, want)

package/internal/graph/literals_render_every_value_in_typescript_source_form_test.go

@@ -69,7 +69,7 @@ export type Mixed = 'a' | 1 | true;
     // 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))
+    got := literalsOf(t, graph, nodeID(string(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

@@ -46,18 +46,18 @@ export type Duplicated = Narrow | 'a';
   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))
+  wide := literalsOf(t, graph, nodeID(string(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 authored hops; this result check does not measure resolution cost.
-  wider := literalsOf(t, graph, nodeID(path, "Wider", NodeTypeAlias))
+  wider := literalsOf(t, graph, nodeID(string(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))
+  duplicated := literalsOf(t, graph, nodeID(string(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/member_relation_edges_follow_checker_validity_test.go

@@ -71,11 +71,11 @@ export class Derived extends Base {
     to     string
     origin string
   }{
-    {nodeID(path, "Implementation.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod), "implements"},
-    {nodeID(path, "Implementation.name", NodeMethod), nodeID(path, "Contract.name", NodeVariable), "implements"},
-    {nodeID(path, "Implementation.callback", NodeMethod), nodeID(path, "Contract.callback", NodeVariable), "implements"},
-    {nodeID(path, "Derived.act", NodeMethod), nodeID(path, "Base.act", NodeMethod), "overrides"},
-    {nodeID(path, "Derived.property", NodeVariable), nodeID(path, "Base.property", NodeVariable), "overrides"},
+    {nodeID(string(path), "Implementation.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod), "implements"},
+    {nodeID(string(path), "Implementation.name", NodeMethod), nodeID(string(path), "Contract.name", NodeVariable), "implements"},
+    {nodeID(string(path), "Implementation.callback", NodeMethod), nodeID(string(path), "Contract.callback", NodeVariable), "implements"},
+    {nodeID(string(path), "Derived.act", NodeMethod), nodeID(string(path), "Base.act", NodeMethod), "overrides"},
+    {nodeID(string(path), "Derived.property", NodeVariable), nodeID(string(path), "Base.property", NodeVariable), "overrides"},
   }
   for _, assertion := range assertions {
     if got := edgeOrigin(built, assertion.from, assertion.to, EdgeMemberRelation); got != assertion.origin {
@@ -83,8 +83,8 @@ export class Derived extends Base {
     }
   }
 
-  derivedConstructor := nodeID(path, "Derived.__constructor", NodeMethod)
-  baseConstructor := nodeID(path, "Base.__constructor", NodeMethod)
+  derivedConstructor := nodeID(string(path), "Derived.__constructor", NodeMethod)
+  baseConstructor := nodeID(string(path), "Base.__constructor", NodeMethod)
   if built.Nodes[derivedConstructor] == nil || built.Nodes[baseConstructor] == nil {
     t.Fatalf("missing fixture constructor nodes; nodes: %v", nodeIDSet(built))
   }

package/internal/graph/member_relation_edges_preserve_checker_boundaries_test.go

@@ -149,8 +149,8 @@ export class ProtectedPretender implements ProtectedBase {
   built := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
   for _, id := range []string{
-    nodeID(path, "MixedFlagDerived.item", NodeMethod),
-    nodeID(path, "MixedFlagBase.item", NodeVariable),
+    nodeID(string(path), "MixedFlagDerived.item", NodeMethod),
+    nodeID(string(path), "MixedFlagBase.item", NodeVariable),
   } {
     if _, ok := built.Nodes[id]; !ok {
       t.Fatalf("mixed-symbol boundary node %s is missing; nodes: %v", id, built.Nodes)
@@ -161,17 +161,17 @@ export class ProtectedPretender implements ProtectedBase {
     to     string
     origin string
   }{
-    {nodeID(path, "StringGeneric.map", NodeMethod), nodeID(path, "Generic.map", NodeMethod), "implements"},
-    {nodeID(path, "StringGeneric.required", NodeVariable), nodeID(path, "Generic.required", NodeVariable), "implements"},
-    {nodeID(path, "WrongGeneric.required", NodeVariable), nodeID(path, "Generic.required", NodeVariable), "implements"},
-    {nodeID(path, "ParserImpl.parse", NodeMethod), nodeID(path, "Parser.parse", NodeMethod), "implements"},
-    {nodeID(path, "RequiredGood.value", NodeVariable), nodeID(path, "OptionalContract.value", NodeVariable), "implements"},
-    {nodeID(path, "PropertyDerived.run", NodeVariable), nodeID(path, "MethodBase.run", NodeMethod), "overrides"},
-    {nodeID(path, "AbstractPropertyDerived.label", NodeVariable), nodeID(path, "AbstractAccessorBase.label", NodeMethod), "overrides"},
-    {nodeID(path, "SplitDerived.alpha", NodeMethod), nodeID(path, "SplitBase.alpha", NodeMethod), "overrides"},
-    {nodeID(path, "SplitDerived.beta", NodeMethod), nodeID(path, "SplitBase.beta", NodeMethod), "overrides"},
-    {nodeID(path, "MergedDerived.augment", NodeMethod), nodeID(path, "MergedBase.augment", NodeMethod), "overrides"},
-    {nodeID(path, "ProtectedGood.token", NodeVariable), nodeID(path, "ProtectedBase.token", NodeVariable), "overrides"},
+    {nodeID(string(path), "StringGeneric.map", NodeMethod), nodeID(string(path), "Generic.map", NodeMethod), "implements"},
+    {nodeID(string(path), "StringGeneric.required", NodeVariable), nodeID(string(path), "Generic.required", NodeVariable), "implements"},
+    {nodeID(string(path), "WrongGeneric.required", NodeVariable), nodeID(string(path), "Generic.required", NodeVariable), "implements"},
+    {nodeID(string(path), "ParserImpl.parse", NodeMethod), nodeID(string(path), "Parser.parse", NodeMethod), "implements"},
+    {nodeID(string(path), "RequiredGood.value", NodeVariable), nodeID(string(path), "OptionalContract.value", NodeVariable), "implements"},
+    {nodeID(string(path), "PropertyDerived.run", NodeVariable), nodeID(string(path), "MethodBase.run", NodeMethod), "overrides"},
+    {nodeID(string(path), "AbstractPropertyDerived.label", NodeVariable), nodeID(string(path), "AbstractAccessorBase.label", NodeMethod), "overrides"},
+    {nodeID(string(path), "SplitDerived.alpha", NodeMethod), nodeID(string(path), "SplitBase.alpha", NodeMethod), "overrides"},
+    {nodeID(string(path), "SplitDerived.beta", NodeMethod), nodeID(string(path), "SplitBase.beta", NodeMethod), "overrides"},
+    {nodeID(string(path), "MergedDerived.augment", NodeMethod), nodeID(string(path), "MergedBase.augment", NodeMethod), "overrides"},
+    {nodeID(string(path), "ProtectedGood.token", NodeVariable), nodeID(string(path), "ProtectedBase.token", NodeVariable), "overrides"},
   }
   for _, pair := range expected {
     if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != pair.origin {
@@ -183,12 +183,12 @@ export class ProtectedPretender implements ProtectedBase {
     from string
     to   string
   }{
-    {nodeID(path, "WrongGeneric.map", NodeMethod), nodeID(path, "Generic.map", NodeMethod)},
-    {nodeID(path, "OptionalWrong.value", NodeVariable), nodeID(path, "RequiredContract.value", NodeVariable)},
-    {nodeID(path, "MethodWrong.run", NodeMethod), nodeID(path, "PropertyBase.run", NodeVariable)},
-    {nodeID(path, "ConcretePropertyWrong.label", NodeVariable), nodeID(path, "ConcreteAccessorBase.label", NodeMethod)},
-    {nodeID(path, "MixedFlagDerived.item", NodeMethod), nodeID(path, "MixedFlagBase.item", NodeVariable)},
-    {nodeID(path, "ProtectedPretender.token", NodeVariable), nodeID(path, "ProtectedBase.token", NodeVariable)},
+    {nodeID(string(path), "WrongGeneric.map", NodeMethod), nodeID(string(path), "Generic.map", NodeMethod)},
+    {nodeID(string(path), "OptionalWrong.value", NodeVariable), nodeID(string(path), "RequiredContract.value", NodeVariable)},
+    {nodeID(string(path), "MethodWrong.run", NodeMethod), nodeID(string(path), "PropertyBase.run", NodeVariable)},
+    {nodeID(string(path), "ConcretePropertyWrong.label", NodeVariable), nodeID(string(path), "ConcreteAccessorBase.label", NodeMethod)},
+    {nodeID(string(path), "MixedFlagDerived.item", NodeMethod), nodeID(string(path), "MixedFlagBase.item", NodeVariable)},
+    {nodeID(string(path), "ProtectedPretender.token", NodeVariable), nodeID(string(path), "ProtectedBase.token", NodeVariable)},
   }
   for _, pair := range rejected {
     if built.Nodes[pair.from] == nil || built.Nodes[pair.to] == nil {

package/internal/graph/member_relation_edges_reject_checker_invalid_pairs_test.go

@@ -84,12 +84,12 @@ export class InvalidDerived extends Base {
     from string
     to   string
   }{
-    {nodeID(path, "WrongKind.value", NodeMethod), nodeID(path, "Contract.value", NodeVariable)},
-    {nodeID(path, "WrongKind.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
-    {nodeID(path, "StaticOnly.value", NodeVariable), nodeID(path, "Contract.value", NodeVariable)},
-    {nodeID(path, "StaticOnly.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
-    {nodeID(path, "InvalidDerived.value", NodeMethod), nodeID(path, "Base.value", NodeVariable)},
-    {nodeID(path, "InvalidDerived.run", NodeMethod), nodeID(path, "Base.run", NodeMethod)},
+    {nodeID(string(path), "WrongKind.value", NodeMethod), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "WrongKind.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
+    {nodeID(string(path), "StaticOnly.value", NodeVariable), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "StaticOnly.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
+    {nodeID(string(path), "InvalidDerived.value", NodeMethod), nodeID(string(path), "Base.value", NodeVariable)},
+    {nodeID(string(path), "InvalidDerived.run", NodeMethod), nodeID(string(path), "Base.run", NodeMethod)},
   }
   for _, pair := range absent {
     if built.Nodes[pair.from] == nil || built.Nodes[pair.to] == nil {
@@ -104,9 +104,9 @@ export class InvalidDerived extends Base {
     from string
     to   string
   }{
-    {nodeID(path, "WrongKind.kept", NodeVariable), nodeID(path, "Contract.kept", NodeVariable)},
-    {nodeID(path, "Valid.value", NodeVariable), nodeID(path, "Contract.value", NodeVariable)},
-    {nodeID(path, "Valid.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
+    {nodeID(string(path), "WrongKind.kept", NodeVariable), nodeID(string(path), "Contract.kept", NodeVariable)},
+    {nodeID(string(path), "Valid.value", NodeVariable), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "Valid.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
   }
   for _, pair := range valid {
     if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != "implements" {
@@ -115,8 +115,8 @@ export class InvalidDerived extends Base {
   }
   if got := edgeOrigin(
     built,
-    nodeID(path, "InvalidDerived.kept", NodeVariable),
-    nodeID(path, "Base.kept", NodeVariable),
+    nodeID(string(path), "InvalidDerived.kept", NodeVariable),
+    nodeID(string(path), "Base.kept", NodeVariable),
     EdgeMemberRelation,
   ); got != "overrides" {
     t.Fatalf("valid override sibling in an invalid class was suppressed: got %q; edges: %v", got, built.Edges)

package/internal/graph/namespace_dotted_form_qualifies_deeply_test.go

@@ -57,8 +57,8 @@ export function caller(): void {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  deep := nodeID(path, "A.B.C.deep", NodeFunction)
-  caller := nodeID(path, "caller", NodeFunction)
+  deep := nodeID(string(path), "A.B.C.deep", NodeFunction)
+  caller := nodeID(string(path), "caller", NodeFunction)
 
   if _, ok := graph.Nodes[deep]; !ok {
     t.Fatalf("missing deeply-namespaced node %q; nodes: %v", deep, graph.Nodes)

package/internal/graph/namespace_members_become_qualified_nodes_and_edges_test.go

@@ -77,13 +77,13 @@ export type WorkerRef = Service.Worker;
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  serviceHelper := nodeID(path, "Service.helper", NodeFunction)
-  serviceRun := nodeID(path, "Service.run", NodeFunction)
-  serviceWorker := nodeID(path, "Service.Worker", NodeClass)
-  workerProcess := nodeID(path, "Service.Worker.process", NodeMethod)
-  bootstrap := nodeID(path, "bootstrap", NodeFunction)
-  workerRef := nodeID(path, "WorkerRef", NodeTypeAlias)
-  payload := nodeID(path, "Payload", NodeInterface)
+  serviceHelper := nodeID(string(path), "Service.helper", NodeFunction)
+  serviceRun := nodeID(string(path), "Service.run", NodeFunction)
+  serviceWorker := nodeID(string(path), "Service.Worker", NodeClass)
+  workerProcess := nodeID(string(path), "Service.Worker.process", NodeMethod)
+  bootstrap := nodeID(string(path), "bootstrap", NodeFunction)
+  workerRef := nodeID(string(path), "WorkerRef", NodeTypeAlias)
+  payload := nodeID(string(path), "Payload", NodeInterface)
 
   // The namespaced declarations are nodes in their own right.
   for _, id := range []string{serviceHelper, serviceRun, serviceWorker, workerProcess} {

package/internal/graph/namespace_private_declarations_keep_lexical_identity_test.go

@@ -0,0 +1,85 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// Verifies private namespace declarations retain their lexical owners.
+//
+// 1. Load repeated private functions, classes, aliases and variables in two namespaces alongside top-level controls.
+// 2. Build the graph and inspect declaration spans and resolved calls.
+// 3. Require separate identities and reject calls borrowed from another scope.
+//
+// @evidence contracts/testing.md#behavioral-verification Build must retain each lexical declaration and connect only its actual callers and callees, exposing the false union of dependencies caused by a shared private name.
+// @evidence contracts/testing.md#independent-expectations Literal A.hidden, B.hidden and hidden names follow the source's three distinct lexical scopes; only B.hidden calls target. Selected declarations must retain nonempty spans, without an independent byte-offset oracle.
+// @evidence contracts/testing.md#distinguishing-cases Private functions, variables, classes, interfaces, aliases, nested namespaces and named closures contrast exported members and a top-level function of the same name. Moving source offsets is covered by the existing position-invariance tests.
+// @evidence contracts/testing.md#execution-ownership This Go unit owns a temporary project and in-process compiler Program, closes it and calls Build directly without installing or launching a product host.
+func TestNamespacePrivateDeclarationsKeepLexicalIdentity(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 function target() { return 0; }
+export namespace A {
+  function hidden() { return 1; }
+  class Local { method() { return hidden(); } }
+  interface Shape { value: number }
+  type Alias = Shape;
+  const local = hidden();
+  export const a = hidden();
+  export namespace Deep { function hidden() { return 4; } export const d = hidden(); }
+  export function factory() { function hidden() { return 5; } return hidden(); }
+}
+export namespace B {
+  function hidden() { return target(); }
+  class Local { method() { return hidden(); } }
+  interface Shape { value: number }
+  type Alias = Shape;
+  const local = hidden();
+  export const b = hidden();
+}
+function hidden() { return 3; }
+export const c = hidden();
+`)
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  g := Build(prog)
+  file := sourceFile(t, prog, "main.ts").FileName()
+  for _, prefix := range []string{"A", "B"} {
+    for name, kind := range map[string]NodeKind{
+      "hidden": NodeFunction, "Local": NodeClass, "Local.method": NodeMethod,
+      "Shape": NodeInterface, "Shape.value": NodeVariable, "Alias": NodeTypeAlias, "local": NodeVariable,
+    } {
+      if node := g.Nodes[nodeID(string(file), prefix+"."+name, kind)]; node == nil || node.Name != prefix+"."+name || node.End <= node.Pos {
+        t.Errorf("missing lexical declaration %s.%s", prefix, name)
+      }
+    }
+  }
+  for _, name := range []string{"A.hidden", "B.hidden", "hidden", "A.Deep.hidden", "A.factory.hidden"} {
+    id := nodeID(string(file), name, NodeFunction)
+    if g.Nodes[id] == nil {
+      t.Errorf("missing %s", name)
+    }
+    if got := hasEdge(g, id, nodeID(string(file), "target", NodeFunction), EdgeValueCall); got != (name == "B.hidden") {
+      t.Errorf("%s calls target = %t, want %t", name, got, name == "B.hidden")
+    }
+  }
+  for caller, target := range map[string]string{"A.a": "A.hidden", "B.b": "B.hidden", "c": "hidden", "A.Deep.d": "A.Deep.hidden"} {
+    for _, candidate := range []string{"A.hidden", "B.hidden", "hidden", "A.Deep.hidden", "A.factory.hidden"} {
+      if got := hasEdge(g, nodeID(string(file), caller, NodeVariable), nodeID(string(file), candidate, NodeFunction), EdgeValueCall); got != (candidate == target) {
+        t.Errorf("%s -> %s = %t, want %t", caller, candidate, got, candidate == target)
+      }
+    }
+  }
+  if !hasEdge(g, nodeID(string(file), "A.factory", NodeFunction), nodeID(string(file), "A.factory.hidden", NodeFunction), EdgeValueCall) {
+    t.Error("factory lost its own hidden closure")
+  }
+}

package/internal/graph/nodes_are_marked_exported_through_the_export_table_test.go

@@ -42,8 +42,8 @@ export { Service };
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  service := graph.Nodes[nodeID(path, "Service", NodeClass)]
-  internal := graph.Nodes[nodeID(path, "Internal", NodeClass)]
+  service := graph.Nodes[nodeID(string(path), "Service", NodeClass)]
+  internal := graph.Nodes[nodeID(string(path), "Internal", NodeClass)]
   if service == nil || internal == nil {
     t.Fatalf("Build did not record both classes; have %v", nodeIDSet(graph))
   }

package/internal/graph/object_literal_declarations_resolve_calls_test.go

@@ -84,8 +84,8 @@ export namespace Names {
   }
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  caller := nodeID(path, "caller", NodeFunction)
-  helper := nodeID(path, "helper", NodeFunction)
+  caller := nodeID(string(path), "caller", NodeFunction)
+  helper := nodeID(string(path), "helper", NodeFunction)
   for _, item := range []struct {
     name     string
     kind     NodeKind
@@ -109,7 +109,7 @@ export namespace Names {
     {"api.computed", NodeMethod, EdgeValueCall},
     {"api.value", NodeMethod, EdgeValueAccess},
   } {
-    id := nodeID(path, item.name, item.kind)
+    id := nodeID(string(path), item.name, item.kind)
     node := graph.Nodes[id]
     if node == nil || node.Pos <= 0 || node.End <= node.Pos {
       t.Errorf("missing member/span %s: %+v", item.name, node)
@@ -122,12 +122,12 @@ export namespace Names {
       t.Errorf("missing member-to-helper relation from %s", item.name)
     }
   }
-  if !hasEdge(graph, nodeID(path, "control", NodeFunction), nodeID(path, "Control.run", NodeMethod), EdgeValueCall) {
+  if !hasEdge(graph, nodeID(string(path), "control", NodeFunction), nodeID(string(path), "Control.run", NodeMethod), EdgeValueCall) {
     t.Error("ordinary class method call was lost")
   }
   for _, name := range []string{`Names.api["a[\"\"]"]`, `Names.api.a[""]`} {
-    id := nodeID(path, name, NodeMethod)
-    if graph.Nodes[id] == nil || !hasEdge(graph, nodeID(path, "Names.caller", NodeFunction), id, EdgeValueCall) || !hasEdge(graph, id, helper, EdgeValueCall) {
+    id := nodeID(string(path), name, NodeMethod)
+    if graph.Nodes[id] == nil || !hasEdge(graph, nodeID(string(path), "Names.caller", NodeFunction), id, EdgeValueCall) || !hasEdge(graph, id, helper, EdgeValueCall) {
       t.Errorf("namespace object identity/relationships missing: %s", name)
     }
   }
@@ -146,18 +146,18 @@ export namespace Names {
     {"Control.prefix__#7@#read", "prefix__#7@#read", NodeMethod, EdgeValueAccess},
     {"Control.#value", "#value", NodeMethod, EdgeValueCall},
   } {
-    id := nodeID(path, item.qualified, item.kind)
+    id := nodeID(string(path), item.qualified, item.kind)
     node := graph.Nodes[id]
     if node == nil || node.Simple != item.simple || node.Pos <= 0 || node.End <= node.Pos {
       t.Errorf("literal/private identity %q: %+v, want simple %q", item.qualified, node, item.simple)
       continue
     }
     if item.qualified == "Control.#value" {
-      if !hasEdge(graph, nodeID(path, "Control.__#41@#value", NodeMethod), id, EdgeValueCall) {
+      if !hasEdge(graph, nodeID(string(path), "Control.__#41@#value", NodeMethod), id, EdgeValueCall) {
         t.Error("public literal method lost its distinct private call target")
       }
     } else if len(item.qualified) >= len("Control.") && item.qualified[:len("Control.")] == "Control." {
-      if !hasEdge(graph, nodeID(path, "control", NodeFunction), id, item.relation) {
+      if !hasEdge(graph, nodeID(string(path), "control", NodeFunction), id, item.relation) {
         t.Errorf("missing control caller relation to %q", item.qualified)
       }
     }

package/internal/graph/object_literal_members_ride_on_the_snapshot_test.go

@@ -82,7 +82,7 @@ export const shape = (({
 
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  node := graph.Nodes[nodeID(path, "shape", NodeVariable)]
+  node := graph.Nodes[nodeID(string(path), "shape", NodeVariable)]
   if node == nil {
     t.Fatalf("missing shape variable; nodes: %v", nodeIDSet(graph))
   }

package/internal/graph/overload_implementation_replaces_signature_test.go

@@ -50,7 +50,7 @@ func TestOverloadImplementationReplacesSignature(t *testing.T) {
   graph := Build(prog)
   file := sourceFile(t, prog, "main.ts")
   path := file.FileName()
-  id := nodeID(path, "Query.join", NodeMethod)
+  id := nodeID(string(path), "Query.join", NodeMethod)
   node := graph.Nodes[id]
   if node == nil {
     t.Fatalf("missing node Query.join; have %v", nodeIDSet(graph))
@@ -59,7 +59,7 @@ func TestOverloadImplementationReplacesSignature(t *testing.T) {
   if !strings.Contains(source, "return this.realJoin") {
     t.Fatalf("expected Query.join node to cover the implementation body, got:\n%s", source)
   }
-  if !hasEdge(graph, id, nodeID(path, "Query.realJoin", NodeMethod), EdgeValueCall) {
+  if !hasEdge(graph, id, nodeID(string(path), "Query.realJoin", NodeMethod), EdgeValueCall) {
     t.Fatalf("missing value-call edge Query.join -> Query.realJoin; edges: %v", graph.Edges)
   }
 }

package/internal/graph/property_member_edges_remain_owner_visible_test.go

@@ -56,12 +56,12 @@ export interface Contract {
 
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  dep := nodeID(path, "Dep", NodeInterface)
-  makeDep := nodeID(path, "makeDep", NodeFunction)
-  service := nodeID(path, "Service", NodeClass)
-  serviceDep := nodeID(path, "Service.dep", NodeVariable)
-  contract := nodeID(path, "Contract", NodeInterface)
-  contractDep := nodeID(path, "Contract.dep", NodeVariable)
+  dep := nodeID(string(path), "Dep", NodeInterface)
+  makeDep := nodeID(string(path), "makeDep", NodeFunction)
+  service := nodeID(string(path), "Service", NodeClass)
+  serviceDep := nodeID(string(path), "Service.dep", NodeVariable)
+  contract := nodeID(string(path), "Contract", NodeInterface)
+  contractDep := nodeID(string(path), "Contract.dep", NodeVariable)
 
   for _, id := range []string{serviceDep, contractDep} {
     if _, ok := graph.Nodes[id]; !ok {