ttsc 0.30.3 → 0.31.0

package/internal/graph/source.go

@@ -1,23 +1,33 @@
 package graph
 
 import (
+  "path/filepath"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // IsWorkspaceSourceFile reports whether file owns declarations and outgoing
-// facts in the project graph. Declaration files and sources physically resident
-// under node_modules are external boundary inputs even when the checker loads a
+// facts in the project graph. Declaration files and reported filenames with an
+// exact lowercase node_modules segment are external boundary inputs even when the checker loads a
 // package's raw TypeScript entry for type checking.
 //
-// Symlinked workspace packages remain authored source: the checker resolves the
-// default preserveSymlinks=false path to their real workspace location before
-// this predicate sees it.
+// Classification follows the supplied compiler spelling. Compiler symlink
+// settings can affect that spelling; this predicate neither resolves physical
+// aliases nor proves where an existing file resides.
+//
+// @evidence contracts/common.md#principled-implementation The compiler's declaration-file flag and path-segment boundary distinguish authored declarations from loaded dependency inputs.
+// @evidence contracts/common.md#clear-and-simple-design One predicate owns the build and resolution boundary without reopening source files.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts node_modules is a package-resolution boundary, not a consumer or fixture exception; no foreign compiler state is changed.
+// @evidence contracts/common.md#meaningful-documentation Native prose states declaration-file and exact path-segment classification, reported spelling and physical alias limits under the documentation skill.
+// @evidence contracts/portability.md#os-neutral-implementation filepath.ToSlash converts native separators for segment comparison while retaining literal POSIX backslashes; physical symlink resolution remains the compiler host's responsibility.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This predicate owns no retained cache or handle; temporary normalized/joined filename storage becomes unreachable when its boolean result returns.
+// @evidence contracts/performance.md#efficient-algorithms The early nil/declaration-file guard is fixed work; normalization, prefix construction and segment search scan filename bytes and can allocate temporary path strings. No directory traversal occurs.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This per-source predicate coordinates no shared generation computation or invalidation; callers own reuse of compiler filenames and classification results.
 func IsWorkspaceSourceFile(file *shimast.SourceFile) bool {
   if file == nil || file.IsDeclarationFile {
     return false
   }
-  normalized := strings.ReplaceAll(file.FileName(), "\\", "/")
+  normalized := filepath.ToSlash(file.FileName())
   return !strings.Contains("/"+strings.TrimPrefix(normalized, "/"), "/node_modules/")
 }

package/internal/graph/source_texts_cover_every_resident_program_source_test.go

@@ -10,19 +10,23 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestSourceTextsCoverEveryResidentProgramSource verifies that snapshot
-// evidence includes every class of source the checker loaded.
-//
-// External graph leaves still carry checker-derived facts and spans. Omitting
-// their resident text from the source manifest leaves those facts without the
-// byte identity that the sourceDigests capability promises. Virtual bundled
-// libraries need the same checker digest even though they have no disk digest.
+// TestSourceTextsCoverEveryResidentProgramSource observes an authored outside
+// declaration and the presence of at least one bundled library in SourceTexts.
+// The declaration text is compared exactly; bundled content, every resident
+// source, digest capabilities, and physical/checker byte identity are not
+// authenticated by these selected observations.
 //
 //  1. Compile a project that calls a function declared by an outside `.d.ts`.
 //  2. Build the graph and capture the resident program's source texts.
 //  3. Assert both the outside declaration and a virtual bundled library are in
 //     the checker-text manifest.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires an external graph fact at the authored declaration path, its exact SourceTexts value, and at least one bundled:/// key. It does not enumerate all resident files, inspect bundled values, compute digests, or serialize a provenance manifest.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal: the graph must hold an external node declared in the outside dependency d.ts, SourceTexts must hold exactly the text export declare function external(): number; for that declaration path, and SourceTexts must hold at least one bundled:/// path. The bundled library's text is not compared with anything.
+// @evidence contracts/testing.md#distinguishing-cases Compile a project that calls a function declared by an outside `.d.ts`; Build the graph and capture the resident program's source texts; Assert both the outside declaration and a virtual bundled library are in the checker-text manifest.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config, project source, and outside declaration files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and SourceTexts execute in this process, with the declaration expectation keyed by shimtspath.ResolvePath. No product CLI, installed dependency, emitted JavaScript evaluation, or digest consumer runs.
 func TestSourceTextsCoverEveryResidentProgramSource(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   workspace := t.TempDir()
   root := filepath.Join(workspace, "app")
   declaration := filepath.Join(workspace, "dependency", "index.d.ts")

package/internal/graph/type_ref_edges_cover_typeof_as_satisfies_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 // TestTypeRefEdgesCoverTypeofAsSatisfies verifies that the type-position shapes
-// beyond a plain `Foo` annotation are all resolved to type-ref edges:
+// beyond a plain `Foo` annotation produce the selected type-ref edges:
 //
 //   - `typeof value`      -> the value it queries (an EntityName, not a TypeReference)
 //   - `x as Target`       -> Target (the assertion's type)
@@ -17,8 +17,20 @@ import (
 // `as` and `satisfies` carry an ordinary TypeReference the recursion already
 // reaches; `typeof` names its value through an EntityName, which a
 // TypeReference-only walk would miss. All three must produce an edge so an
-// impact query sees the dependency.
+// graph records the selected dependency. No downstream impact query runs.
+// coerce also has a Target return annotation, so its edge alone cannot prove
+// assertion traversal; assertionOnly supplies the same expression without it.
+//
+// 1. Load typeof settings, an as Target assertion and a satisfies Config expression.
+// 2. Build the type-reference relations.
+// 3. Require SettingsShape-to-settings, coerce-to-Target and config-to-Config type references.
+//
+// @evidence contracts/testing.md#behavioral-verification Require SettingsShape-to-settings, coerce-to-Target and config-to-Config type references.
+// @evidence contracts/testing.md#independent-expectations Literal triples require SettingsShape to settings, coerce and assertionOnly to Target, and config to Config. assertionOnly has no Target return annotation, distinguishing assertion traversal that the original coerce edge alone cannot authenticate. The typeof and satisfies inputs likewise name their selected targets.
+// @evidence contracts/testing.md#distinguishing-cases Load typeof settings, an as Target assertion and a satisfies Config expression. Build the type-reference relations. Require SettingsShape-to-settings, coerce-to-Target and config-to-Config type references.
+// @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 edge-presence checks run in this process using its actual filename and shared nodeID encoder; this is not an independent identity or span oracle. No product CLI, installation, emitted expression evaluation, or downstream impact query runs.
 func TestTypeRefEdgesCoverTypeofAsSatisfies(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), `{
   "compilerOptions": {
@@ -42,6 +54,10 @@ export function coerce(x: unknown): Target {
   return x as Target;
 }
 
+export function assertionOnly(x: unknown) {
+  return x as Target;
+}
+
 export const config = { a: 1 } satisfies Config;
 `)
 
@@ -70,6 +86,9 @@ export const config = { a: 1 } satisfies Config;
   if !hasEdge(graph, coerce, target, EdgeTypeRef) {
     t.Errorf("missing type-ref edge coerce -> Target (as assertion)")
   }
+  if !hasEdge(graph, nodeID(path, "assertionOnly", NodeFunction), target, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge assertionOnly -> Target without a return annotation")
+  }
   if !hasEdge(graph, config, configType, EdgeTypeRef) {
     t.Errorf("missing type-ref edge config -> Config (satisfies)")
   }

package/internal/graph/type_ref_edges_resolve_named_types_across_files_test.go

@@ -9,15 +9,20 @@ import (
 
 // TestTypeRefEdgesResolveNamedTypesAcrossFiles verifies that a type-position
 // reference to a named type in another file is recorded as a type-ref edge to
-// that type's real declaration, and is kept distinct from a value-call. Treating
-// type references as first-class edges lets an impact query separate "uses this
-// at runtime" from "depends on this type", which fits the ttsc thesis.
+// that authored declaration, and is kept distinct from a value-call. This checks
+// one parameter annotation; no downstream impact query or runtime use executes.
 //
 //  1. Compile a fixture where use(c: Config) annotates a parameter with an
 //     interface declared in another file.
 //  2. Build the graph.
 //  3. Assert a use -> Config type-ref edge exists and is not a value-call.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires the selected use-to-Config type-ref triple and rejects a value-call triple between the same endpoints. It does not assert exact edge counts, spans, all cross-file type forms, independent physical identity, or downstream impact-query behavior.
+// @evidence contracts/testing.md#independent-expectations The expectation is literal: for use(c: Config) in main.ts with Config declared in types.ts, a type-ref edge must run from the use function to the Config interface node of types.ts and no value-call edge may run between the same two nodes.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture where use(c: Config) annotates a parameter with an interface declared in another file; Build the graph; Assert a use -> Config type-ref edge exists and is not a value-call.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config and two source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and both edge observations run in this process; selected endpoints share its actual filenames and the nodeID encoder. No product CLI, installation, emitted function evaluation, or downstream impact query runs.
 func TestTypeRefEdgesResolveNamedTypesAcrossFiles(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   writeFile(t, filepath.Join(root, "src", "types.ts"), `export interface Config {

package/internal/graph/value_access_edges_cover_properties_test.go

@@ -10,16 +10,24 @@ import (
 // TestValueAccessEdgesCoverPropertiesAndAccessors verifies property and
 // accessor reads/writes become value-access edges, not value-call edges.
 //
-// Lazy getters and state properties are part of the runtime flow an agent
-// needs, but they are not invocations. The graph must expose them without
-// corrupting call-flow semantics.
+// The mixed dotted/bracket fixture observes five selected access triples and
+// one initializer-call triple, with two negative accessor-call controls.
+// Dotted and bracket uses share endpoints, and getter/setter share one node,
+// so these deduplicated edges do not independently authenticate each syntax or
+// accessor body. No runtime flow or downstream agent query executes.
 //
 //  1. Compile a class with a property initializer, getter, setter, dotted access,
 //     and string-literal bracket access.
 //  2. Build the graph.
 //  3. Assert property/getter/setter uses are value-access edges while the
 //     property initializer's real function call stays a value-call edge.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires five selected value-access triples and the Store.items-to-seed value-call, and rejects read/write-to-count value-calls. Shared endpoints limit independent dotted-versus-bracket and getter-versus-setter attribution; no exact counts, spans, runtime effects, or downstream consumer are asserted.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over class Store: value-access edges must exist from Store.read to Store.count and Store.items, from Store.count to Store.items, and from Store.write to Store.count and Store.items (dotted and string-literal bracket forms, getter and setter); a value-call edge must run from Store.items to seed; and no value-call edge may run from Store.read or Store.write to Store.count.
+// @evidence contracts/testing.md#distinguishing-cases Compile a class with a property initializer, getter, setter, dotted access, and string-literal bracket access; Build the graph; Assert property/getter/setter uses are value-access edges while the property initializer's real function call stays a 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 and literal edge-presence observations run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, emitted getter/setter evaluation, or agent query runs.
 func TestValueAccessEdgesCoverPropertiesAndAccessors(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 seed(): string[] {

package/internal/graph/value_call_edges_attribute_function_assignments_to_members_test.go

@@ -10,16 +10,22 @@ import (
 // TestValueCallEdgesAttributeFunctionAssignmentsToMembers verifies function
 // assignments to resolved members are walked as that member's implementation.
 //
-// Libraries sometimes attach methods by assigning an arrow/function expression
-// to a typed property instead of declaring a class method body. The class-level
-// walk sees the assignment, but graph flow still needs the assigned member node
-// to own calls made inside the RHS function.
+// This fixture assigns an arrow to an existing method from install. It observes
+// the member-to-helper call and an ordered, positive implementation span in that
+// file. Function expressions, alternate assignment forms, exact RHS bounds, and
+// runtime installation effects are not authenticated by this one example.
 //
 //  1. Compile a fixture where `inst.run = () => helper()` assigns a typed class
 //     method implementation.
 //  2. Build the graph.
 //  3. Assert the `Service.run` method has a value-call edge to `helper`.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies function assignments to resolved members are walked as that member's implementation.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal: after inst.run = () => helper(), a value-call edge must run from the Service.run method node to helper, and the Service.run node must carry an implementation span in the same file with a positive start and an end after it.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture where `inst.run = () => helper()` assigns a typed class method implementation; Build the graph; Assert the `Service.run` method has a value-call edge to `helper`.
+// @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 member-call/span observations run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, or emitted assignment evaluation runs.
 func TestValueCallEdgesAttributeFunctionAssignmentsToMembers(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(): void {}

package/internal/graph/value_call_edges_cover_jsx_components_test.go

@@ -8,15 +8,21 @@ import (
 )
 
 // TestValueCallEdgesCoverJsxComponents verifies that a JSX component use
-// (`<Child />`) is a value-call edge to the component — the relationship a React
-// codebase is built from, which a call-expression-only walk silently dropped. An
-// intrinsic tag (`<div />`) resolves to nothing and adds no edge, so the walk
-// distinguishes a component use from a host element.
+// (`<Child />`) yields the selected Parent-to-Child value-call triple.
+// The authored intrinsic negative rejects only a target named exactly div;
+// qualified intrinsic property targets, JSX origin, rendered runtime behavior,
+// and all component forms are not authenticated by these observations.
 //
 //  1. Compile a .tsx fixture where Parent renders <Child /> inside a <div>.
 //  2. Build the graph.
 //  3. Assert a Parent -> Child value-call edge exists.
+//
+// @evidence contracts/testing.md#behavioral-verification A JSX component use <Child /> inside <div> becomes a value-call edge from Parent to Child. The negative check only rejects an edge from Parent to a node whose Name is exactly div, so it would not catch an edge to the qualified JSX.IntrinsicElements.div property node.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over a .tsx fixture: a value-call edge must run from Parent to Child, and no edge from Parent may target a node whose Name is div.
+// @evidence contracts/testing.md#distinguishing-cases Compile a .tsx fixture where Parent renders <Child /> inside a <div>; Build the graph; Assert a Parent -> Child value-call edge exists.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config and TSX source with authored JSX declarations and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and edge observations run in this process using its actual filename and shared nodeID encoder. No React installation, product CLI, emitted JSX evaluation, or rendered runtime executes.
 func TestValueCallEdgesCoverJsxComponents(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), `{
   "compilerOptions": {
@@ -67,10 +73,8 @@ export function Parent(): JSX.Element {
     t.Fatalf("missing value-call edge Parent -> Child (JSX component use); edges: %v", graph.Edges)
   }
 
-  // The intrinsic `<div>` host element resolves to nothing and must add no edge.
-  // Without this negative twin, a regression that started resolving intrinsic
-  // tags would fill every React codebase's call graph with host-element noise
-  // while the positive assertion above still passed.
+  // This negative observes only targets named exactly div; it cannot reject a
+  // qualified JSX.IntrinsicElements.div target.
   for _, edge := range graph.Edges {
     if edge.From != parent {
       continue

package/internal/graph/value_call_edges_cover_methods_and_constructors_test.go

@@ -8,22 +8,26 @@ import (
 )
 
 // TestValueCallEdgesCoverMethodsAndConstructors verifies that the value-call walk
-// reaches what the checker resolves but the first cut dropped: a method-to-method
+// records the selected authored relationships: a method-to-method
 // call lands on the callee's method node, and a `new T()` lands on T's class node,
 // both attributed to the calling method.
 //
-// Before method nodes existed, a callee that resolved to a method symbol was
-// dropped (no node to point at) and a `new` expression was never visited, so a
-// class whose logic lived in method bodies showed almost no outgoing edges. This
-// pins that gap closed — the load-bearing reason a model could trust the graph
-// for an architecture question instead of re-reading the source.
+// Both run calls share endpoints, so presence cannot authenticate each call or
+// deduplication. The new-expression triple does not assert its origin or wire
+// kind. No runtime call, construction, or architecture-query consumer executes.
 //
 //  1. Compile a fixture where Controller.handle calls Service.run (via a parameter
 //     and a constructed value) and constructs a Service.
 //  2. Build the graph.
-//  3. Assert handle -> Service.run (value-call, deduped) and handle -> Service
+//  3. Assert handle -> Service.run (value-call presence) and handle -> Service
 //     (the new-expression constructor edge) both exist.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires the Service.run node and two selected handle value-call triples, to that method and to Service. Exact counts, each of the two run call sites, source spans, new origin, and wire instantiates kind are not asserted.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over Controller.handle: the Service.run method node must exist, a value-call edge must run from Controller.handle to Service.run (reached through s.run() and made.run()), and a value-call edge must run from Controller.handle to the Service class node (new Service()). The test checks edge presence only, not that the two run() calls collapse to one edge.
+// @evidence contracts/testing.md#distinguishing-cases The method call and construction have different authored target kinds, while the parameter and constructed-value run calls share one expected triple. Presence distinguishes missing method/class relationships but does not authenticate deduplication.
+// @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 literal edge observations run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, emitted construction/calls, or architecture-query consumer runs.
 func TestValueCallEdgesCoverMethodsAndConstructors(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 Service {
@@ -58,8 +62,7 @@ export class Controller {
   if _, ok := graph.Nodes[run]; !ok {
     t.Fatalf("Build did not record the method node Service.run; have %v", nodeIDSet(graph))
   }
-  // Method-to-method: handle calls Service.run (from s.run() and made.run(),
-  // deduped to a single edge) — the call the first cut dropped.
+  // Method-to-method presence; both authored calls share this triple.
   if !hasEdge(graph, handle, run, EdgeValueCall) {
     t.Fatalf("missing value-call edge Controller.handle -> Service.run; edges: %v", graph.Edges)
   }

package/internal/graph/value_call_edges_cover_variable_bound_callables_test.go

@@ -9,14 +9,20 @@ import (
 
 // TestValueCallEdgesCoverVariableBoundCallables verifies that a call made inside a
 // top-level variable-bound function (a `const fn = () => …`) is an edge from that
-// variable node. The first cut never walked a variable initializer, so an
-// arrow-const that called a function produced no edge — a common modern-TS shape
-// the graph silently missed.
+// variable node. This is one exported arrow initializer and one call-presence
+// observation; other callable forms, spans, exact counts, and runtime handler
+// effects are not exercised.
 //
 //  1. Compile a fixture where `const handler = () => { helper(); }`.
 //  2. Build the graph.
 //  3. Assert a handler -> helper value-call edge exists.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires the authored handler-variable-to-helper-function value-call triple for one arrow initializer. It does not authenticate other callable forms, exact counts or spans, historical failures, or executed handler behavior.
+// @evidence contracts/testing.md#independent-expectations The expectation is literal: for export const handler = () => { helper(); } a value-call edge must run from the handler variable node to the helper function node.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture where `const handler = () => { helper(); }`; Build the graph; Assert a handler -> helper value-call edge exists.
+// @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 the literal triple observation run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, or emitted handler evaluation runs.
 func TestValueCallEdgesCoverVariableBoundCallables(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(): void {}

package/internal/graph/value_call_edges_do_not_double_record_invoked_member_access_test.go

@@ -10,16 +10,23 @@ import (
 // TestValueCallEdgesDoNotDoubleRecordInvokedMemberAccess verifies a property
 // access used as an invocation target remains only a value-call edge.
 //
-// Splitting value-call from value-access is useful only if method calls and
-// tagged-template calls do not also look like plain property reads. Otherwise MCP
-// flow ranking cannot tell invoked behavior from state/accessor evidence.
+// Three authored dotted property targets cover method call, construction, and
+// tagged template. Each has a positive value-call and negative value-access
+// triple. This is not an exact edge-count, invocation-origin, bracket-access,
+// runtime-effect, or MCP-ranking oracle.
 //
 //  1. Compile method, constructor, and tagged-template calls whose callee/tag is
 //     a property access expression.
 //  2. Build the graph.
 //  3. Assert each target has a value-call edge and no duplicate value-access
 //     edge from the same caller.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies a property access used as an invocation target remains only a value-call edge.
+// @evidence contracts/testing.md#independent-expectations The expectations are literal over service.run(), new Providers.Service() and Tags.html tagged template inside handle: for each of Providers.Service.run, Providers.Service and Tags.html there must be a value-call edge from handle and no value-access edge from handle to the same target.
+// @evidence contracts/testing.md#distinguishing-cases Compile method, constructor, and tagged-template calls whose callee/tag is a property access expression; Build the graph; Assert each target has a value-call edge and no duplicate value-access edge from the same caller.
+// @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 three literal positive/negative pairs run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, emitted invocation, or MCP-ranking consumer runs.
 func TestValueCallEdgesDoNotDoubleRecordInvokedMemberAccess(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 namespace Providers {\n"+

package/internal/graph/value_call_edges_record_construct_versus_call_origin_test.go

@@ -7,23 +7,26 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestValueCallEdgesRecordConstructVersusCallOrigin verifies that a value-call
-// edge carries the syntactic Origin the dump splits into the schema's `calls`
-// versus `instantiates` kinds: a plain call records "call", a `new T()` records
-// "new".
+// TestValueCallEdgesRecordConstructVersusCallOrigin checks that selected
+// internal value-call edges report "call" for a method call and "new" for a
+// class construction. This test does not invoke the dump's wire-kind mapping.
 //
-// The internal model keeps one EdgeValueCall kind so the existing MCP stays
-// untouched; the finer distinction the redesigned graph schema requires
-// (`new Foo()` is an instantiation, not a call) rides on Edge.Origin. Without it
-// the dump could not recover a constructor from an invocation after the fact, so
-// this pins the discriminator at its source.
+// The two targets also have different node kinds, so these selected origins do
+// not independently reject origin inference from target kind. Exact counts,
+// all matching edges, emitted execution, and MCP consumption are unobserved.
 //
 //  1. Compile a fixture where Controller.handle both calls Service.run and
 //     constructs `new Service()`.
 //  2. Build the graph.
 //  3. Assert the handle->Service.run edge has Origin "call" and the
 //     handle->Service edge has Origin "new".
+//
+// @evidence contracts/testing.md#behavioral-verification Requires literal call/new origins on the first matching internal value-call triples. The target kinds differ too, so exclusive syntax acquisition is not authenticated; wire calls/instantiates mapping and exact edge counts are not asserted.
+// @evidence contracts/testing.md#independent-expectations The explicit input facts and supported graph/command contract establish "call", "new"; the handle->Service.run edge has Origin "call" and the handle->Service edge has Origin "new".
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture where Controller.handle both calls Service.run and constructs `new Service()`; Build the graph; Assert the handle->Service.run edge has Origin "call" and the handle->Service edge has Origin "new".
+// @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 first-match edgeOrigin observations run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, dump serialization, product CLI, installation, emitted invocation, or MCP consumer runs.
 func TestValueCallEdgesRecordConstructVersusCallOrigin(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 Service {

package/internal/graph/value_call_edges_resolve_across_files_and_dedupe_test.go

@@ -9,15 +9,22 @@ import (
 
 // TestValueCallEdgesResolveAcrossFilesAndDedupe verifies that a runtime call is
 // recorded as a single value-call edge to the callee's real declaration, even
-// when the caller invokes it from several sites. Cross-file resolution proves the
-// edge rides the checker; the dedup keeps the call graph one-edge-per-pair so an
-// impact query is not skewed by how many times a function is called.
+// when the authored caller contains two call sites. The count distinguishes
+// missing and duplicate selected edges, but does not authenticate exclusive
+// checker acquisition, every call site, retained evidence span, all graph pairs,
+// runtime invocation, or downstream impact ranking.
 //
 //  1. Compile a fixture where caller() calls helper() (declared in another file)
 //     twice.
 //  2. Build the graph.
 //  3. Assert exactly one caller -> helper value-call edge.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires exactly one selected caller-to-helper value-call triple for two authored cross-file call sites. This distinguishes absent or duplicate triples, not exclusive acquisition, each site's independent traversal, retained source evidence, every graph pair, or downstream impact-query behavior.
+// @evidence contracts/testing.md#independent-expectations The explicit input facts and supported graph/command contract establish exactly one caller -> helper value-call edge.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture where caller() calls helper() (declared in another file) twice; Build the graph; Assert exactly one caller -> helper value-call edge.
+// @evidence contracts/testing.md#execution-ownership Owns temporary native config and two source files and a directly loaded library Program, closes it, and restores an empty linked-plugin manifest. Build and the literal triple count run in this process using its actual filenames and shared nodeID encoder. No independent identity oracle, product CLI, installation, emitted caller evaluation, or downstream impact query runs.
 func TestValueCallEdgesResolveAcrossFilesAndDedupe(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
   root := t.TempDir()
   writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
   writeFile(t, filepath.Join(root, "src", "util.ts"), `export function helper(): number {

package/internal/graph/value_call_edges_skip_self_and_unresolved_test.go

@@ -7,11 +7,10 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
-// TestValueCallEdgesSkipSelfAndUnresolved verifies that callEdge drops the two
-// edges it is documented to skip while still recording an ordinary cross-call:
-// a self-call (`rec` calling `rec`) yields no edge because `to == from`, and a
-// call whose callee the checker cannot bind to a declaration (a method on an
-// `any`-typed value) yields no edge because Resolve returns nil.
+// TestValueCallEdgesSkipSelfAndUnresolved checks an absent self-call and absent
+// dynamic-host value calls alongside an ordinary cross-call. All four authored
+// function nodes must exist; otherwise dropping the negative owners would pass.
+// The flags and return values of private acquisition helpers are not observed.
 //
 // The positive caller->helper edge is the load-bearing twin: without it the test
 // would also pass if callEdge recorded nothing at all, so it proves the two skips
@@ -23,7 +22,13 @@ import (
 //  2. Build the graph.
 //  3. Assert no rec->rec edge and no edge out of dynamic, but a caller->helper
 //     value-call edge.
+//
+// @evidence contracts/testing.md#behavioral-verification Requires all four resident function nodes, rejects rec-to-rec value-call and all dynamic-owner value-calls, and requires caller-to-helper. The cross-call rejects blanket suppression; resident-owner premises reject erased negative declarations. No direct Resolve-nil premise, all callee forms, or runtime recursion is asserted.
+// @evidence contracts/testing.md#independent-expectations The explicit input facts and supported graph/command contract establish no rec->rec edge and no edge out of dynamic, but a caller->helper value-call edge.
+// @evidence contracts/testing.md#distinguishing-cases Compile a fixture with `rec()` returning `rec()`, `caller()` calling a separate `helper()`, and `dynamic(host: any)` calling `host.run()`; Build the graph; Assert no rec->rec edge and no edge out of dynamic, but a caller->helper 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 and literal node/edge observations run in this process using its actual filename and shared nodeID encoder. No independent identity oracle, product CLI, installation, or emitted recursive/dynamic invocation runs.
 func TestValueCallEdgesSkipSelfAndUnresolved(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 rec(): unknown {
@@ -55,6 +60,12 @@ export function dynamic(host: any): void {
   caller := nodeID(path, "caller", NodeFunction)
   dynamic := nodeID(path, "dynamic", NodeFunction)
 
+  for _, id := range []string{rec, helper, caller, dynamic} {
+    if graph.Nodes[id] == nil {
+      t.Fatalf("missing authored function node %s; nodes: %v", id, nodeIDSet(graph))
+    }
+  }
+
   // Self-call: callEdge skips `to == from`, so rec never points at itself.
   if hasEdge(graph, rec, rec, EdgeValueCall) {
     t.Fatalf("a self-call recorded a rec -> rec value-call edge; edges: %v", graph.Edges)

package/internal/graph/wire_node_ids_share_alias_resolution_test.go

@@ -3,14 +3,20 @@ package graph
 import "testing"
 
 // TestWireNodeIDsShareAliasResolution verifies the public resident shard
-// helper keeps declarations from one physical source distinct and stable.
+// helper keeps two supplied declaration IDs from one path distinct and gives
+// both the literal relative source coordinate.
 //
-// External declarations commonly share a package source file. Mapping the IDs
-// as one batch must preserve the shared source coordinate without collisions.
+// No source file or alias is authored here. Physical ownership, repeated-run
+// stability, symlink resolution, and exact full wire-ID spellings are unasserted.
 //
-//  1. Build two declaration IDs owned by one physical dependency source.
+//  1. Supply two declaration IDs naming the same dependency path.
 //  2. Map both IDs through the public batch helper.
 //  3. Require distinct IDs with the same portable source coordinate.
+//
+// @evidence contracts/testing.md#behavioral-verification WireNodeIDs maps two node IDs that name different declarations in one dependency source file to two different wire IDs that both carry the same project-relative source coordinate; the test uses a single project-root-relative spelling and does not build an alias, so it does not exercise symlink canonicalization.
+// @evidence contracts/testing.md#independent-expectations The explicit input facts and supported graph/command contract establish distinct IDs with the same portable source coordinate.
+// @evidence contracts/testing.md#distinguishing-cases First and Second share one supplied source path but must have different resulting IDs and the literal node_modules/pkg/index.d.ts coordinate. No actual alias, repeated invocation, physical file ownership, or full-ID literal comparison is exercised.
+// @evidence contracts/testing.md#execution-ownership Directly supplies strings through nodeID and calls WireNodeIDs; nodeFile uses the shared decoder for coordinate observations. Host-compatible canonicalization can inspect native path/ancestor metadata even though the test creates no fixture. It does not load a Program, install a consumer, build a product, start a process, or authenticate physical source identity.
 func TestWireNodeIDsShareAliasResolution(t *testing.T) {
   source := "C:/checkout/app/node_modules/pkg/index.d.ts"
   first := nodeID(source, "First", NodeClass)

package/internal/graphsymbols/position_helpers_follow_ecma_line_terminators_test.go

@@ -11,14 +11,21 @@ import (
 // TestPositionHelpersFollowECMALineTerminators verifies graph-backed LSP
 // positions use the compiler's LF, CRLF, CR, LS, and PS line boundaries.
 //
-// The old offset-to-position helper counted only LF while its inverse counted
-// CR too, so an editor cursor could map to a graph offset that returned on a
-// different line. The test walks every valid UTF-8 cursor boundary on each
-// logical line, including a surrogate-pair column, and requires a round trip.
+// An offset-to-position helper that counted only LF while its inverse counted
+// CR too would map an editor cursor to a graph offset that returns on a
+// different line. Literal starts and ends establish three authored logical
+// lines; the test walks their UTF-8 boundaries, including an emoji, and requires
+// a round trip. Columns are not compared to literal UTF-16 counts, so symmetric
+// column mistakes can pass. No editor/server request is exercised.
 //
 // 1. Build three lines with each ECMAScript terminator.
 // 2. Enumerate every valid cursor boundary before each terminator.
 // 3. Convert each offset to UTF-16 LSP position and back to the same offset.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies graph-backed LSP positions use the compiler's LF, CRLF, CR, LS, and PS line boundaries.
+// @evidence contracts/testing.md#independent-expectations Each case embeds one ECMAScript terminator (LF, CRLF, CR, LS or PS) in a three-line literal, so the expected line count (three) and the line of every offset follow from the language's line-terminator definition. Columns are checked only by an offset -> position -> offset round trip over every UTF-8 rune boundary (including the two-unit emoji), not against literal UTF-16 column numbers, so a column error made symmetrically by both helpers would not be detected.
+// @evidence contracts/testing.md#distinguishing-cases Build three lines with each ECMAScript terminator; Enumerate every valid cursor boundary before each terminator; Convert each offset to UTF-16 LSP position and back to the same offset; the five terminator subtests differ only in the terminator, and a position on the line index just past the last line must not resolve (negative case). No empty-text or out-of-range-column input is exercised here.
+// @evidence contracts/testing.md#execution-ownership Directly calls the maintained line and position helpers on authored UTF-8 strings in this process. Literal byte boundaries establish enumeration; round-trip column expectations share the two converters and are not a separate UTF-16 oracle. It creates no native fixture, loads no Program, installs no consumer, and starts no product process or editor/server connection.
 func TestPositionHelpersFollowECMALineTerminators(t *testing.T) {
   cases := []struct {
     name       string
@@ -37,8 +44,13 @@ func TestPositionHelpersFollowECMALineTerminators(t *testing.T) {
       if len(starts) != 3 {
         t.Fatalf("line starts = %v, want three lines", starts)
       }
+      expectedStarts := []int{0, 9 + len(tc.terminator), 13 + 2*len(tc.terminator)}
+      expectedEnds := []int{9, 13 + len(tc.terminator), len(text)}
       for line, start := range starts {
         end := graph.LineEnd(text, starts, line)
+        if start != expectedStarts[line] || end != expectedEnds[line] {
+          t.Fatalf("line %d boundaries = (%d, %d), want (%d, %d)", line, start, end, expectedStarts[line], expectedEnds[line])
+        }
         for offset := start; ; {
           position := offsetToPosition(text, offset)
           if position.Line != line {