ttsc 0.30.3 → 0.31.0

package/internal/graph/node_modifiers_emit_union_strings_test.go

@@ -8,23 +8,24 @@ import (
 )
 
 // TestNodeModifiersEmitUnionStrings verifies that the dump records a declaration's
-// syntactic modifiers as wire strings drawn only from the TtscGraphNodeModifier
-// union, mapping the combined modifier flags of a class, a static/readonly
-// property, an accessibility-qualified async method, and an exported const onto
-// their union members.
-//
-// The TypeScript loader runs `typia.assert<ITtscGraphDump>` over this dump, so a
-// modifier string outside the union would reject the whole graph. The assertion
-// pins both the exact strings emitted and the negative twin — a member with no
-// modifier must carry none — so an over-broad flag mapping cannot slip through.
+// selected syntactic modifiers in NewDump's returned records: class,
+// static/readonly property, private async method and exported const enum.
+// A plain method provides a negative counterpart; an authored eleven-name
+// allowlist checks only strings present in this fixture, not a live TS union.
 //
 //  1. Compile a fixture with `export abstract class`, a `static readonly`
 //     property, a `private async` method, a plain method, and `export const enum`
 //     (the `const` keyword that is a modifier, unlike a `const` variable).
-//  2. Build and marshal the dump.
+//  2. Build and construct the dump records without JSON serialization.
 //  3. Assert each node's modifiers are exactly the expected union strings, the
 //     plain method has none, and every emitted string is a union member.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual Build/NewDump records must hold the four exact ordered modifier arrays, no modifiers on Service.plain, and only names in the authored allowlist across this fixture. No JSON encoding, TS validator or unexercised modifier branch is authenticated.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal wire strings in the stable emitted order: Service {export, abstract}, Service.config {static, readonly}, Service.run {async, private}, Mode {export, const}, and none for Service.plain. The final check compares every emitted modifier with an eleven-name list written into the test as a copy of the TtscGraphNodeModifier union; that copy is not read from the TypeScript definition, so drift in the TypeScript union would not be noticed here.
+// @evidence contracts/testing.md#distinguishing-cases Class, property, method and const-enum modifier combinations have independent exact arrays; the plain method must remain empty. The allowlist is a guard on emitted names, not positive coverage of all eleven allowed names.
+// @evidence contracts/testing.md#execution-ownership This Go source-unit writes a native project, constructs/closes its driver Program in-process and directly calls Build, NewDump and SourceTexts. Local ordered-slice and failure-ID helpers inspect returned records; a restored empty linked-plugin manifest excludes ambient hooks. No serialization, installed consumer, validator or product process runs.
 func TestNodeModifiersEmitUnionStrings(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 abstract class Service {
@@ -82,8 +83,8 @@ export const enum Mode {
     t.Fatalf("plain method modifiers = %v, want none", plain.Modifiers)
   }
 
-  // Every emitted modifier is a member of the TtscGraphNodeModifier union, since
-  // an unknown string would reject the dump under typia.assert.
+  // Every returned modifier in this fixture must belong to this authored list;
+  // no TypeScript definition or consumer validator is consulted here.
   union := map[string]bool{
     "export": true, "default": true, "declare": true, "abstract": true,
     "static": true, "readonly": true, "async": true, "const": true,

package/internal/graph/nodes_are_marked_exported_through_the_export_table_test.go

@@ -7,22 +7,22 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestNodesAreMarkedExportedThroughTheExportTable verifies that markExports flags
-// a node as Exported from the checker's module export table, not from a syntactic
-// `export` modifier — so a declaration exported by a separate `export { Service }`
-// statement counts, while an unexported sibling does not.
-//
-// The export surface drives the public-API projection, and the codebases the
-// graph targets export most of their surface through `export { … }` and barrel
-// re-exports rather than inline modifiers. A modifier-only scan would miss
-// Service here; the export-table walk must catch it, and must still leave the
-// unexported Internal alone.
+// TestNodesAreMarkedExportedThroughTheExportTable checks the Exported flags of
+// two resident class nodes. Service is exported by a separate export statement;
+// Internal remains unexported. This distinguishes an inline-modifier-only scan,
+// without authenticating the acquisition algorithm or a public-API consumer.
 //
 //  1. Compile a fixture declaring `class Service` and `class Internal`, exporting
 //     only Service through a trailing `export { Service }` statement.
 //  2. Build the graph.
 //  3. Assert the Service node is Exported and the Internal node is not.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires both class nodes to exist, then checks Service.Exported true and Internal.Exported false for a separate export statement. It does not assert export edges, barrel resolution, public-API projection, or exclusive use of the checker table.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over classes Service and Internal with only export { Service } at the end: the Service node must have Exported true and the Internal node Exported false, which a scan for an inline export modifier would get wrong for Service.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture declaring `class Service` and `class Internal`, exporting only Service through a trailing `export { Service }` statement; Build the graph; Assert the Service node is Exported and the Internal node is not.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config/source files and a directly loaded library Program, closes the Program, and restores an empty linked-plugin manifest. Build and flag observations execute in this process; node selection uses the actual Program filename and shared nodeID encoder, not an independent identity oracle. No consumer installation, product CLI, or emitted JavaScript is executed.
 func TestNodesAreMarkedExportedThroughTheExportTable(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"), `class Service {}
@@ -48,13 +48,11 @@ export { Service };
     t.Fatalf("Build did not record both classes; have %v", nodeIDSet(graph))
   }
 
-  // Exported via a separate `export { Service }` statement — no inline modifier,
-  // so only the checker export table reveals it.
+  // The separate export statement must affect this resident class node.
   if !service.Exported {
     t.Fatalf("Service should be marked Exported through the export table")
   }
-  // Negative twin: Internal is never exported, so the public-API projection must
-  // not surface it.
+  // The resident unexported sibling must retain a false flag.
   if internal.Exported {
     t.Fatalf("Internal is not exported but was marked Exported")
   }

package/internal/graph/object_literal_declarations_resolve_calls_test.go

@@ -0,0 +1,170 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestObjectLiteralDeclarationsResolveCalls verifies statically bound object
+// members have their own identities, source spans and checker-resolved callers.
+//
+//  1. Load methods, callable properties, nested objects, static and dynamic keys,
+//     accessors, aliases and ordinary function/class controls in one Program.
+//  2. Build the native graph and require precise member-to-helper and
+//     caller-to-member relationships.
+//  3. Reject unnamed callback object members and dynamic-key declarations.
+//
+// @evidence contracts/testing.md#behavioral-verification Build must publish each named object member and resolve actual alias/property calls to it, including its own helper dependency and positive source span.
+// @evidence contracts/testing.md#independent-expectations The literal API names and call sites prescribe endpoints independently of extraction; dynamic computed keys and anonymous returned literals have no stable lexical declaration name.
+// @evidence contracts/testing.md#distinguishing-cases Shorthand/generic, arrow/function, nested, quoted/computed-literal, getter/setter, transparent wrappers and alias calls contrast dynamic keys and unbound literals. Literal bracket text remains distinct from a nested empty key, including namespace-prefixed objects. Numeric/Unicode/empty keys retain their names; private-looking public literals in object and class methods/properties/accessors remain distinct from actual private members and ordinary function/class controls.
+// @evidence contracts/testing.md#execution-ownership Owns one native temporary project and directly loaded compiler Program, closes it, and calls Build in the Go test process without installing or launching a product host.
+func TestObjectLiteralDeclarationsResolveCalls(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 helper(): number { return 1; }
+const dynamic: string = "unknown";
+export const api = ({
+  create<T>(input: T): number { return helper(); },
+  arrow: (): number => helper(),
+  classic: function (): number { return helper(); },
+  nested: { run(): number { return helper(); } },
+  "quoted.key"(): number { return helper(); },
+  quoted: { key(): number { return helper(); } },
+  'a[""]'(): number { return helper(); },
+  a: { ""(): number { return helper(); } },
+  "["(): number { return helper(); },
+  "]"(): number { return helper(); },
+  "__#41@#value"(): number { return helper(); },
+  nestedPrivate: { "prefix__#7@#read"(): number { return helper(); } },
+  1.0(): number { return helper(); },
+  "\u00FEkey"(): number { return helper(); },
+  ""(): number { return helper(); },
+  ["computed"](): number { return helper(); },
+  [dynamic](): number { return helper(); },
+  get value(): number { return helper(); },
+  set value(input: number) { helper(); },
+} satisfies Record<string, unknown>);
+const alias = api;
+export function caller(): number {
+  alias.create(1); api.arrow(); api.classic(); api.nested.run();
+  api["quoted.key"](); api.quoted.key(); api.computed(); api.value = 1;
+  api['a[""]'](); api.a[""](); api["["](); api["]"]();
+  api["__#41@#value"](); api.nestedPrivate["prefix__#7@#read"]();
+  api[1](); api["\u00FEkey"](); api[""]();
+  return api.value;
+}
+export class Control {
+  #value(): number { return helper(); }
+  "__#41@#value"(): number { return this.#value(); }
+  "__#7@#property" = (): number => helper();
+  get "prefix__#7@#read"(): number { return helper(); }
+  set "prefix__#7@#read"(input: number) { helper(); }
+  run(): number { return helper(); }
+}
+export function control(input: Control): number {
+  input["__#41@#value"](); input["__#7@#property"]();
+  input["prefix__#7@#read"] = 1; return input.run();
+}
+export function anonymous() { return { skipped(): number { return helper(); } }; }
+export namespace Names {
+  export const api = { 'a[""]'(): number { return helper(); }, a: { ""(): number { return helper(); } } };
+  export function caller(): number { api['a[""]'](); return api.a[""](); }
+}
+`)
+  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)
+  }
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  caller := nodeID(path, "caller", NodeFunction)
+  helper := nodeID(path, "helper", NodeFunction)
+  for _, item := range []struct {
+    name     string
+    kind     NodeKind
+    relation EdgeKind
+  }{
+    {"api.create", NodeMethod, EdgeValueCall},
+    {"api.arrow", NodeVariable, EdgeValueCall},
+    {"api.classic", NodeVariable, EdgeValueCall},
+    {"api.nested.run", NodeMethod, EdgeValueCall},
+    {"api[\"quoted.key\"]", NodeMethod, EdgeValueCall},
+    {"api.quoted.key", NodeMethod, EdgeValueCall},
+    {`api["a[\"\"]"]`, NodeMethod, EdgeValueCall},
+    {`api.a[""]`, NodeMethod, EdgeValueCall},
+    {`api["["]`, NodeMethod, EdgeValueCall},
+    {`api["]"]`, NodeMethod, EdgeValueCall},
+    {"api.__#41@#value", NodeMethod, EdgeValueCall},
+    {"api.nestedPrivate.prefix__#7@#read", NodeMethod, EdgeValueCall},
+    {"api.1", NodeMethod, EdgeValueCall},
+    {"api.þkey", NodeMethod, EdgeValueCall},
+    {"api[\"\"]", NodeMethod, EdgeValueCall},
+    {"api.computed", NodeMethod, EdgeValueCall},
+    {"api.value", NodeMethod, EdgeValueAccess},
+  } {
+    id := nodeID(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)
+      continue
+    }
+    if !hasEdge(graph, caller, id, item.relation) {
+      t.Errorf("missing caller relation to %s", item.name)
+    }
+    if !hasEdge(graph, id, helper, EdgeValueCall) {
+      t.Errorf("missing member-to-helper relation from %s", item.name)
+    }
+  }
+  if !hasEdge(graph, nodeID(path, "control", NodeFunction), nodeID(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) {
+      t.Errorf("namespace object identity/relationships missing: %s", name)
+    }
+  }
+  for _, item := range []struct {
+    qualified, simple string
+    kind              NodeKind
+    relation          EdgeKind
+  }{
+    {"api.__#41@#value", "__#41@#value", NodeMethod, EdgeValueCall},
+    {"api.nestedPrivate.prefix__#7@#read", "prefix__#7@#read", NodeMethod, EdgeValueCall},
+    {"api.1", "1", NodeMethod, EdgeValueCall},
+    {"api.þkey", "þkey", NodeMethod, EdgeValueCall},
+    {"api[\"\"]", "", NodeMethod, EdgeValueCall},
+    {"Control.__#41@#value", "__#41@#value", NodeMethod, EdgeValueCall},
+    {"Control.__#7@#property", "__#7@#property", NodeVariable, EdgeValueCall},
+    {"Control.prefix__#7@#read", "prefix__#7@#read", NodeMethod, EdgeValueAccess},
+    {"Control.#value", "#value", NodeMethod, EdgeValueCall},
+  } {
+    id := nodeID(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) {
+        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) {
+        t.Errorf("missing control caller relation to %q", item.qualified)
+      }
+    }
+  }
+  for _, node := range graph.Nodes {
+    if node.Name == "api.unknown" || node.Name == "skipped" || node.Name == "anonymous.skipped" {
+      t.Errorf("unnameable member acquired guessed identity: %s", node.Name)
+    }
+  }
+}

package/internal/graph/object_literal_members_ride_on_the_snapshot_test.go

@@ -8,25 +8,26 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestObjectLiteralMembersRideOnTheSnapshot verifies that object-literal
-// member identity is captured from the compiler AST and projected from the
-// same source snapshot as the graph.
+// TestObjectLiteralMembersRideOnTheSnapshot checks selected direct object-member
+// names, kinds, spans, and dump outlines from one authored Program snapshot.
+// Comment braces, static computed names, accessors, spread, dynamic keys, and
+// nested bodies distinguish the expected twenty records. The source file is not
+// changed after loading, so this does not independently reject live-file reads
+// or authenticate exclusive AST acquisition, and no details server is invoked.
 //
-// The details server used to reopen the live file and reconstruct this list
-// with a brace counter and regular expressions. A brace inside a block comment
-// changed that counter, while valid shorthand, literal-keyed, computed, and
-// multiline members depended on which line happened to match. This test pins
-// the ownership boundary instead: the native graph records direct AST members,
-// and the dump renders snapshot-owned, body-bounded compact signatures from
-// Program-owned text.
-//
-//  1. Compile a wrapped object literal containing comment braces, every direct
-//     static member shape, a dynamic key, a spread, and a nested object.
+//  1. Load a wrapped object literal containing the selected static member shapes,
+//     comment braces, a dynamic key, a spread, and a nested object.
 //  2. Assert the variable node records only its direct statically named members
 //     in declaration order, with method/property kinds independent of trivia.
 //  3. Dump the graph and assert member lines/signatures come from the snapshot,
 //     while spread and nested members are not fabricated as outer identity.
+//
+// @evidence contracts/testing.md#behavioral-verification Checks twenty ordered graph member names/kinds with positive spans, then selected direct dump lines, outline signatures, forbidden body markers, and a 160-rune truncation. No JSON serialization, changed-disk snapshot distinction, details-server execution, or exclusive acquisition algorithm is authenticated.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over one wrapped object literal: the node must list exactly the 20 direct static members in declaration order with the given names and variable/method kinds (shorthand, string-keyed, empty-string and numeric keys, accessors counted once each), each with a span, and not the dynamic key, the spread's fromSpread or the nested inner; the dump must give the first member real at line 7 with signature real: 1 (comment braces not counted), the last afterSpread: true, head-only signatures for method, arrow, function, class, array and object members, none of the eight marker body strings, and a 160-rune bounded signature ending in ... for the long member.
+// @evidence contracts/testing.md#distinguishing-cases The authored getter and setter each produce a value record; literal computed names survive while the dynamic key, spread contents, and nested inner do not become outer members. The first line/signature, last signature, seven body-outline literals, eight forbidden markers, and long-signature rune bound are independent expectations. Other dump member names/kinds are not exhaustively compared to the graph list.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config/source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and NewDump execute in this process with SourceTexts from that Program; graph node selection shares the nodeID encoder while the dump node ID is a literal. No product CLI, consumer installation, emitted JavaScript, or details server runs.
 func TestObjectLiteralMembersRideOnTheSnapshot(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   source := `const shorthand = 1;

package/internal/graph/object_member_signatures_preserve_literal_whitespace_test.go

@@ -7,18 +7,22 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestObjectMemberSignaturesPreserveLiteralWhitespace verifies that compact
-// display text never rewrites whitespace owned by a lexical value.
-//
-// strings.Fields treated quoted and template contents as trivia. It changed
-// string and regular-expression values, and its first-line cut left a multiline
-// template without a closing backtick. The outline may compact surrounding
-// syntax only when the literal itself remains byte-identical and complete.
+// TestObjectMemberSignaturesPreserveLiteralWhitespace checks four authored dump
+// signatures: double and single quotes, a regular expression, and a multiline
+// template. Exact literals distinguish whitespace collapsing and first-line
+// truncation; escaped delimiters, substitutions, and all lexical values are not
+// certified by this corpus. The source is unchanged after Program loading.
 //
 //  1. Compile object members with spaced strings, a regexp, and a template.
 //  2. Dump the graph from the Program-owned source snapshot.
 //  3. Assert literal whitespace and the complete template delimiter survive.
+//
+// @evidence contracts/testing.md#behavioral-verification Compares four direct NewDump signatures to independent literal strings, including two interior spaces and the multiline template's newline, indentation, and closing backtick. It does not assert all lexical forms, JSON serialization, or rejection of live-file reads.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal source strings: the dumped signatures of the four members must be exactly double: "a  b", single: 'c  d', regexp: /e  f/ and the two-line template literal with its interior newline and spaces and closing backtick, so whitespace owned by a lexical value is not collapsed.
+// @evidence contracts/testing.md#distinguishing-cases Compile object members with spaced strings, a regexp, and a template; Dump the graph from the Program-owned source snapshot; Assert literal whitespace and the complete template delimiter survive.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config/source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and NewDump use its SourceTexts in this process; the selected dump node ID and expected signatures are authored literals. No consumer installation, product CLI, emitted JavaScript evaluation, or details server runs.
 func TestObjectMemberSignaturesPreserveLiteralWhitespace(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   source := `export const shape = {

package/internal/graph/object_members.go

@@ -1,6 +1,11 @@
 package graph
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  "encoding/json"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
 
 // collectObjectMembers records the direct, statically named members of the
 // object literal bound by declaration on the variable node Build already owns.
@@ -38,12 +43,106 @@ func (g *Graph) collectObjectMembers(path string, declaration *shimast.Node) {
       SignatureBoundary: signatureBoundary,
       SignatureTokenLen: signatureTokenLen,
     })
+    collectObjectDeclaration(g, path, property)
   }
   if len(members) > 0 {
     node.ObjectMembers = members
   }
 }
 
+// collectObjectDeclaration indexes each statically named property under its
+// lexical binding. Nested literals use their property as the next owner; a
+// dynamic key or unbound literal supplies no stable declaration identity.
+func collectObjectDeclaration(g *Graph, path string, property *shimast.Node) {
+  name, ok := objectDeclarationName(property)
+  if !ok || property.Symbol() == nil {
+    return
+  }
+  _, kind, ok := objectMemberIdentity(property)
+  if !ok {
+    return
+  }
+  putDeclaredNode(g, path, name, kind, property)
+  collectClosures(g, path, property)
+  if property.Kind == shimast.KindPropertyAssignment {
+    assignment := property.AsPropertyAssignment()
+    if object := objectLiteralInitializer(assignment.Initializer); object != nil && object.Properties != nil {
+      for _, child := range object.Properties.Nodes {
+        collectObjectDeclaration(g, path, child)
+      }
+    }
+  }
+}
+
+// objectDeclarationName follows AST ownership to a named variable rather than
+// using the binder's anonymous object-type symbol as a public name. Every
+// segment must be statically declared; aliases resolve to these same nodes.
+func objectDeclarationName(property *shimast.Node) (string, bool) {
+  if property == nil || property.Parent == nil || property.Parent.Kind != shimast.KindObjectLiteralExpression {
+    return "", false
+  }
+  name, _, ok := objectMemberIdentity(property)
+  if !ok {
+    return "", false
+  }
+  owner := property.Parent.Parent
+  for owner != nil {
+    switch owner.Kind {
+    case shimast.KindAsExpression, shimast.KindSatisfiesExpression, shimast.KindParenthesizedExpression,
+      shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      owner = owner.Parent
+      continue
+    case shimast.KindVariableDeclaration:
+      if owner.Symbol() != nil {
+        return appendObjectMemberName(qualifiedName(owner.Symbol()), name), true
+      }
+    case shimast.KindPropertyAssignment:
+      if prefix, ok := objectDeclarationName(owner); ok {
+        return appendObjectMemberName(prefix, name), true
+      }
+    }
+    break
+  }
+  return "", false
+}
+
+// appendObjectMemberName keeps lexical member segments distinct from nested
+// ownership. JSON bracket spelling quotes empty keys and reserved dot/bracket
+// characters, so literal text cannot impersonate another ownership boundary.
+func appendObjectMemberName(owner, name string) string {
+  if name == "" || strings.ContainsAny(name, ".[]") {
+    encoded, _ := json.Marshal(name)
+    return owner + "[" + string(encoded) + "]"
+  }
+  return owner + "." + name
+}
+
+// forEachObjectDeclaration attributes relationships to the same static members
+// indexed by collectObjectDeclaration. The variable's existing aggregate walk
+// remains available alongside precise member queries.
+func forEachObjectDeclaration(path string, initializer *shimast.Node, fn func(string, *shimast.Node)) {
+  object := objectLiteralInitializer(initializer)
+  if object == nil || object.Properties == nil {
+    return
+  }
+  for _, property := range object.Properties.Nodes {
+    name, ok := objectDeclarationName(property)
+    if !ok || property.Symbol() == nil {
+      continue
+    }
+    _, kind, ok := objectMemberIdentity(property)
+    if !ok {
+      continue
+    }
+    fn(nodeID(path, name, kind), property)
+    forEachClosureIn(path, property, fn)
+    if property.Kind == shimast.KindPropertyAssignment {
+      assignment := property.AsPropertyAssignment()
+      forEachObjectDeclaration(path, assignment.Initializer, fn)
+    }
+  }
+}
+
 // objectMemberSignatureSpan finds the earliest AST boundary after which source
 // belongs to a value body rather than the member outline. It keeps compact
 // scalar initializers such as `real: 1`, but stops before function bodies,

package/internal/graph/overload_implementation_replaces_signature_test.go

@@ -10,9 +10,20 @@ import (
 
 // TestOverloadImplementationReplacesSignature verifies that an overload set's
 // graph node points at the executable implementation, not the first signature.
-// Overload-heavy APIs otherwise force agents to re-open the file to see the
-// calls that the graph already attributed to the node.
+// A selected implementation span and a selected body call are observed for this
+// method overload. Other overload shapes and downstream agent behavior are not
+// exercised; the span substring does not authenticate exact declaration bounds.
+//
+// 1. Load Query.join overload signatures followed by its implementation calling realJoin.
+// 2. Build the method node and body relations.
+// 3. Require the retained join source to contain return this.realJoin and the join-to-realJoin value-call edge.
+//
+// @evidence contracts/testing.md#behavioral-verification Require the retained join source to contain return this.realJoin and the join-to-realJoin value-call edge.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over the Query.join overload: the node's source span (from Pos to End) must contain return this.realJoin, which appears only in the implementation, and a value-call edge from Query.join to Query.realJoin must exist.
+// @evidence contracts/testing.md#distinguishing-cases Load Query.join overload signatures followed by its implementation calling realJoin. Build the method node and body relations. Require the retained join source to contain return this.realJoin and the join-to-realJoin value-call edge.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config/source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build runs in this process; source slicing uses that Program's text and node selection shares its filename and the nodeID encoder. No independent identity oracle, consumer installation, product CLI, or emitted method execution runs.
 func TestOverloadImplementationReplacesSignature(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 class Query {

package/internal/graph/property_member_edges_remain_owner_visible_test.go

@@ -10,16 +10,22 @@ import (
 // TestPropertyMemberEdgesRemainOwnerVisible verifies property-member nodes are
 // additive rather than replacing class/interface owner-level edges.
 //
-// Property nodes give MCP precise evidence for state/property flows, but broad
-// architecture questions still need `Service -> Dep` and `Service -> makeDep`
-// without already knowing `Service.dep`.
+// This authored class and interface require both property-level and owner-level
+// dependency triples. No MCP consumer or architecture-query result is observed,
+// and the assertions do not compare source spans or exact edge counts.
 //
 //  1. Compile a class property with both a type reference and initializer call,
 //     plus an interface property signature.
 //  2. Build the graph.
 //  3. Assert both the owner node and the property node expose the same
 //     dependency evidence.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies property-member nodes are additive rather than replacing class/interface owner-level edges.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over Service.dep and Contract.dep: the property nodes must exist and carry type-ref edges to Dep (and Service.dep a value-call edge to makeDep), and the owners Service and Contract must carry the same type-ref edges and Service the value-call edge, so adding property nodes does not remove owner-level edges.
+// @evidence contracts/testing.md#distinguishing-cases Compile a class property with both a type reference and initializer call, plus an interface property signature; Build the graph; Assert both the owner node and the property node expose the same dependency evidence.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config/source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and six edge-presence observations run in this process; node selection shares the actual Program filename and nodeID encoder. No independent identity oracle, consumer installation, product CLI, MCP query, or emitted initializer execution runs.
 func TestPropertyMemberEdgesRemainOwnerVisible(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 interface Dep {