ttsc 0.16.3 → 0.16.6

package/internal/graph/value_access_edges_cover_properties_test.go

@@ -0,0 +1,96 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  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.
+func TestValueAccessEdgesCoverPropertiesAndAccessors(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function seed(): string[] {
+  return []
+}
+
+export class Store {
+  protected items: string[] = seed()
+
+  get count(): number {
+    return this.items.length
+  }
+
+  set count(value: number) {
+    this.items = Array(value).fill("")
+  }
+
+  read(): number {
+    return this.count + this.items.length + this["count"] + this["items"].length
+  }
+
+  write(): void {
+    this.count = 1
+    this["count"] = 2
+    this.items = []
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  read := nodeID(path, "Store.read", NodeMethod)
+  write := nodeID(path, "Store.write", NodeMethod)
+  count := nodeID(path, "Store.count", NodeMethod)
+  items := nodeID(path, "Store.items", NodeVariable)
+  seed := nodeID(path, "seed", NodeFunction)
+
+  if _, ok := graph.Nodes[items]; !ok {
+    t.Fatalf("Build did not record Store.items; have %v", nodeIDSet(graph))
+  }
+  if !hasEdge(graph, read, count, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.read -> Store.count; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, read, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.read -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, count, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.count -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, write, count, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.write -> Store.count; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, write, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.write -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, items, seed, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Store.items -> seed; edges: %v", graph.Edges)
+  }
+  if hasEdge(graph, read, count, EdgeValueCall) {
+    t.Fatalf("getter read was also recorded as value-call Store.read -> Store.count; edges: %v", graph.Edges)
+  }
+  if hasEdge(graph, write, count, EdgeValueCall) {
+    t.Fatalf("setter write was also recorded as value-call Store.write -> Store.count; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_attribute_function_assignments_to_members_test.go

@@ -0,0 +1,59 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  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`.
+func TestValueCallEdgesAttributeFunctionAssignmentsToMembers(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+export class Service {
+  run(): void {}
+}
+export function install(inst: Service): void {
+  inst.run = (): void => {
+    helper();
+  };
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  run := nodeID(path, "Service.run", NodeMethod)
+  helper := nodeID(path, "helper", NodeFunction)
+
+  if !hasEdge(graph, run, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Service.run -> helper (assigned implementation); edges: %v", graph.Edges)
+  }
+  if graph.Nodes[run].ImplementationFile != path ||
+    graph.Nodes[run].ImplementationPos <= 0 ||
+    graph.Nodes[run].ImplementationEnd <= graph.Nodes[run].ImplementationPos {
+    t.Fatalf("Service.run missing assigned implementation span: %+v", graph.Nodes[run])
+  }
+}

package/internal/graph/value_call_edges_cover_jsx_components_test.go

@@ -0,0 +1,82 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  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.
+func TestValueCallEdgesCoverJsxComponents(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "jsx": "preserve",
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.tsx"]
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.tsx"), `declare namespace JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    div: {};
+  }
+}
+export function Child(): JSX.Element {
+  return null as unknown as JSX.Element;
+}
+export function Parent(): JSX.Element {
+  return (
+    <div>
+      <Child />
+    </div>
+  );
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.tsx").FileName()
+
+  parent := nodeID(path, "Parent", NodeFunction)
+  child := nodeID(path, "Child", NodeFunction)
+
+  if !hasEdge(graph, parent, child, EdgeValueCall) {
+    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.
+  for _, edge := range graph.Edges {
+    if edge.From != parent {
+      continue
+    }
+    if to := graph.Nodes[edge.To]; to != nil && to.Name == "div" {
+      t.Fatalf("intrinsic <div> produced a spurious value-call edge from Parent: %v", edge)
+    }
+  }
+}

package/internal/graph/value_call_edges_cover_methods_and_constructors_test.go

@@ -0,0 +1,70 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesCoverMethodsAndConstructors verifies that the value-call walk
+// reaches what the checker resolves but the first cut dropped: 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.
+//
+//  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
+//     (the new-expression constructor edge) both exist.
+func TestValueCallEdgesCoverMethodsAndConstructors(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Service {
+  run(): void {}
+}
+export class Controller {
+  handle(s: Service): void {
+    s.run();
+    const made = new Service();
+    made.run();
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handle := nodeID(path, "Controller.handle", NodeMethod)
+  run := nodeID(path, "Service.run", NodeMethod)
+  service := nodeID(path, "Service", NodeClass)
+
+  // The callee method node both endpoints need must exist as a real node.
+  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.
+  if !hasEdge(graph, handle, run, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Controller.handle -> Service.run; edges: %v", graph.Edges)
+  }
+  // Constructor: `new Service()` is a value-call from handle to the class node.
+  if !hasEdge(graph, handle, service, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Controller.handle -> Service (new); edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_cover_variable_bound_callables_test.go

@@ -0,0 +1,46 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  1. Compile a fixture where `const handler = () => { helper(); }`.
+//  2. Build the graph.
+//  3. Assert a handler -> helper value-call edge exists.
+func TestValueCallEdgesCoverVariableBoundCallables(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+export const handler = (): void => {
+  helper();
+};
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handler := nodeID(path, "handler", NodeVariable)
+  helper := nodeID(path, "helper", NodeFunction)
+
+  if !hasEdge(graph, handler, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge handler -> helper (variable-bound callable body); edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_do_not_double_record_invoked_member_access_test.go

@@ -0,0 +1,65 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  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.
+func TestValueCallEdgesDoNotDoubleRecordInvokedMemberAccess(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), "export namespace Providers {\n"+
+    "  export class Service {\n"+
+    "    run(): void {}\n"+
+    "  }\n"+
+    "}\n"+
+    "export namespace Tags {\n"+
+    "  export function html(strings: TemplateStringsArray): string {\n"+
+    "    return strings[0]\n"+
+    "  }\n"+
+    "}\n"+
+    "export function handle(service: Providers.Service): string {\n"+
+    "  service.run()\n"+
+    "  new Providers.Service()\n"+
+    "  return Tags.html`ok`\n"+
+    "}\n")
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  handle := nodeID(path, "handle", NodeFunction)
+  run := nodeID(path, "Providers.Service.run", NodeMethod)
+  service := nodeID(path, "Providers.Service", NodeClass)
+  html := nodeID(path, "Tags.html", NodeFunction)
+
+  for _, target := range []string{run, service, html} {
+    if !hasEdge(graph, handle, target, EdgeValueCall) {
+      t.Fatalf("missing value-call edge handle -> %s; edges: %v", target, graph.Edges)
+    }
+    if hasEdge(graph, handle, target, EdgeValueAccess) {
+      t.Fatalf("invoked member access was also recorded as value-access handle -> %s; edges: %v", target, graph.Edges)
+    }
+  }
+}

package/internal/graph/value_call_edges_record_construct_versus_call_origin_test.go

@@ -0,0 +1,75 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "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".
+//
+// 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.
+//
+//  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".
+func TestValueCallEdgesRecordConstructVersusCallOrigin(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Service {
+  run(): void {}
+}
+export class Controller {
+  handle(s: Service): void {
+    s.run();
+    const made = new Service();
+    void made;
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  handle := nodeID(path, "Controller.handle", NodeMethod)
+  run := nodeID(path, "Service.run", NodeMethod)
+  service := nodeID(path, "Service", NodeClass)
+
+  if got := edgeOrigin(graph, handle, run, EdgeValueCall); got != "call" {
+    t.Fatalf("Controller.handle -> Service.run: want Origin \"call\", got %q; edges: %v", got, graph.Edges)
+  }
+  if got := edgeOrigin(graph, handle, service, EdgeValueCall); got != "new" {
+    t.Fatalf("Controller.handle -> Service (new): want Origin \"new\", got %q; edges: %v", got, graph.Edges)
+  }
+}
+
+// edgeOrigin returns the Origin of the first from->to edge of kind, or the
+// sentinel "<missing>" when no such edge exists, so a test distinguishes a wrong
+// origin from an absent edge.
+func edgeOrigin(graph *Graph, from, to string, kind EdgeKind) string {
+  for _, edge := range graph.Edges {
+    if edge.From == from && edge.To == to && edge.Kind == kind {
+      return edge.Origin
+    }
+  }
+  return "<missing>"
+}

package/internal/graph/value_call_edges_resolve_across_files_and_dedupe_test.go

@@ -0,0 +1,55 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// 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.
+//
+//  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.
+func TestValueCallEdgesResolveAcrossFilesAndDedupe(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "util.ts"), `export function helper(): number {
+  return 1;
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { helper } from "./util";
+export function caller(): number {
+  return helper() + helper();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  caller := nodeID(sourceFile(t, prog, "main.ts").FileName(), "caller", NodeFunction)
+  helper := nodeID(sourceFile(t, prog, "util.ts").FileName(), "helper", NodeFunction)
+
+  count := 0
+  for _, edge := range graph.Edges {
+    if edge.From == caller && edge.To == helper && edge.Kind == EdgeValueCall {
+      count++
+    }
+  }
+  if count != 1 {
+    t.Fatalf("expected exactly one caller -> helper value-call edge, got %d; edges: %v", count, graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_skip_self_and_unresolved_test.go

@@ -0,0 +1,74 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "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.
+//
+// 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
+// are specific to a self-call and an unresolved callee, not a blanket failure to
+// emit value-call edges.
+//
+//  1. Compile a fixture with `rec()` returning `rec()`, `caller()` calling a
+//     separate `helper()`, and `dynamic(host: any)` calling `host.run()`.
+//  2. Build the graph.
+//  3. Assert no rec->rec edge and no edge out of dynamic, but a caller->helper
+//     value-call edge.
+func TestValueCallEdgesSkipSelfAndUnresolved(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function rec(): unknown {
+  return rec();
+}
+export function helper(): void {}
+export function caller(): void {
+  helper();
+}
+export function dynamic(host: any): void {
+  host.run();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  rec := nodeID(path, "rec", NodeFunction)
+  helper := nodeID(path, "helper", NodeFunction)
+  caller := nodeID(path, "caller", NodeFunction)
+  dynamic := nodeID(path, "dynamic", NodeFunction)
+
+  // 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)
+  }
+  // Unresolved callee: `host.run()` binds to no declaration, so dynamic gains no
+  // outgoing value-call edge.
+  for _, edge := range graph.Edges {
+    if edge.From == dynamic && edge.Kind == EdgeValueCall {
+      t.Fatalf("an unresolved callee recorded a value-call edge out of dynamic: %+v", edge)
+    }
+  }
+  // Positive twin: an ordinary cross-call is still recorded, proving the skips
+  // above are specific and not a blanket suppression.
+  if !hasEdge(graph, caller, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge caller -> helper; edges: %v", graph.Edges)
+  }
+}

package/lib/TtscService.d.ts

@@ -0,0 +1,55 @@
+import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
+/**
+ * Resident, incremental transform service for the `ttsc` TypeScript-Go
+ * pipeline.
+ *
+ * Where {@link TtscCompiler.transform} spawns a fresh process and recompiles the
+ * whole project on every call, `TtscService` keeps one long-lived host warm: it
+ * compiles the project once and then answers per-file transform requests from
+ * that warm program. A single service instance transforms many files (a watch
+ * server, an editor session, a codegen tool) while paying the project compile
+ * once instead of once per file. Sharing one host across separate worker
+ * processes (a Metro worker pool) is tracked in samchon/ttsc#255.
+ *
+ * The shape mirrors a legacy TypeScript `LanguageService`: construct it against
+ * a project context, ask it to transform individual files, and dispose it when
+ * done. Construction is synchronous (it launches the host); the host compiles
+ * in the background, so the first {@link transformFile} resolves once that
+ * compile lands.
+ *
+ * Resident mode runs through the linked-plugin shared host, so the project must
+ * declare at least one transform-stage plugin; the constructor throws
+ * otherwise. It does not run check-stage plugins (unlike
+ * {@link TtscCompiler.transform}); only the program's own type-checking gates an
+ * {@link updateFile}.
+ */
+export declare class TtscService {
+    private readonly resident;
+    private readonly projectRoot;
+    /**
+     * Create a service bound to the given project context and launch its resident
+     * host. The context is the same shape {@link TtscCompiler} accepts; it is not
+     * replaceable per call.
+     */
+    constructor(context?: ITtscCompilerContext);
+    /**
+     * Return the transformed TypeScript source for one file, or `undefined` when
+     * the resident program does not contain it (for example a file excluded from
+     * the tsconfig). A relative `fileName` is resolved against the project root.
+     *
+     * Rejects when the resident host failed to compile the project; the rejection
+     * carries the host's diagnostics so callers can surface a real build error.
+     */
+    transformFile(fileName: string): Promise<string | undefined>;
+    /**
+     * Apply new in-memory content for one file and re-transform the project, so a
+     * subsequent {@link transformFile} reflects the edit without restarting the
+     * host. Returns whether the re-transform succeeded; `false` means the edit
+     * did not compile and the previous transform is still in effect. A relative
+     * `fileName` is resolved against the project root.
+     */
+    updateFile(fileName: string, content: string): Promise<boolean>;
+    /** Terminate the resident host and reject any in-flight requests. */
+    dispose(): void;
+    private absolutePath;
+}