ttsc 0.33.0 → 0.33.1

package/cmd/ttscgraph/serve_alternative_members_and_reads_refresh_test.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// Verifies reported graph facts survive resident edits and barrel imports.
+//
+// 1. Load namespace-private functions, a nested type member and a parameter property through a barrel.
+// 2. Rename the nested member and replace a class expression in the same resident session.
+// 3. Require current serialized nodes and uses, reject stale members and false namespace calls, and compare every generation with a full build.
+//
+// @evidence contracts/testing.md#behavioral-verification Resident shard publication must preserve lexical identities and actual value/member uses, then remove obsolete members after edits. Literal serialized endpoints test semantics independently of full-build equivalence.
+// @evidence contracts/testing.md#independent-expectations Source-authored deep/changed and render/replaced names prescribe current and stale nodes. Only B.hidden calls target, reader accesses num, change accesses the current Props.nested member, cost accesses Sale.price and draw calls the current Widget member.
+// @evidence contracts/testing.md#distinguishing-cases Initial and renamed generations cover cross-file barrel aliases, namespace-private declarations, value returns, nested type members, parameter properties and named/anonymous class expressions. Old member names and A.hidden-to-target provide negative controls; direct syntax cases belong to the graph package's source units.
+// @evidence contracts/testing.md#execution-ownership This Go source unit owns one temporary project and in-process graphSession, closes it and invokes native preparation/projection directly without building or launching a product process.
+func TestServeAlternativeMembersAndReadsRefresh(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{"compilerOptions":{"target":"ES2022","module":"commonjs","strict":true},"include":["src"]}`)
+  writeGraphFile(t, filepath.Join(root, "src", "barrel.ts"), "export * from './api';\n")
+  var session *graphSession
+  for _, state := range []struct{ field, method, className string }{{"deep", "render", "Internal"}, {"changed", "replaced", ""}} {
+    writeGraphFile(t, filepath.Join(root, "src", "api.ts"), `export const num = 1;
+export function target() { return 0; }
+export namespace A { function hidden() { return 1; } export const a = hidden(); }
+export namespace B { function hidden() { return target(); } export const b = hidden(); }
+export type Props = { nested: { `+state.field+`: number } };
+export class Sale { constructor(public readonly price: number) {} }
+export const Widget = class `+state.className+` { `+state.method+`() { return num; } };
+`)
+    writeGraphFile(t, filepath.Join(root, "src", "use.ts"), `import { num, Sale, Widget, type Props } from './barrel';
+export function reader() { return num; }
+export function change(props: Props) { return props.nested.`+state.field+`; }
+export function cost(sale: Sale) { return sale.price; }
+export function draw() { return new Widget().`+state.method+`(); }
+`)
+    if session == nil {
+      var err error
+      session, err = newGraphSession(root, "tsconfig.json")
+      if err != nil {
+        t.Fatal(err)
+      }
+      defer session.Close()
+    }
+    snapshot, _, _, err := snapshotGraphShardState(session)
+    if err != nil || snapshot == nil {
+      t.Fatalf("snapshot: %v", err)
+    }
+    assertServeShardFactsMatchFullDump(t, session)
+    dump, err := projectGraphDump(session)
+    if err != nil {
+      t.Fatal(err)
+    }
+    ids := map[string]string{}
+    for _, node := range dump.Nodes {
+      name := node.QualifiedName
+      if name == "" {
+        name = node.Name
+      }
+      ids[name] = node.ID
+      if (name == "Props.nested.deep" && state.field != "deep") || (name == "Widget.render" && state.method != "render") {
+        t.Errorf("stale declaration %s", name)
+      }
+    }
+    for _, pair := range []struct {
+      from, to, kind string
+      want           bool
+    }{
+      {"reader", "num", "accesses", true},
+      {"change", "Props.nested." + state.field, "accesses", true},
+      {"cost", "Sale.price", "accesses", true},
+      {"draw", "Widget." + state.method, "calls", true},
+      {"Widget." + state.method, "num", "accesses", true},
+      {"A.a", "A.hidden", "calls", true},
+      {"B.b", "B.hidden", "calls", true},
+      {"B.hidden", "target", "calls", true},
+      {"A.hidden", "target", "calls", false},
+    } {
+      if ids[pair.from] == "" || ids[pair.to] == "" {
+        t.Errorf("missing endpoint %s or %s", pair.from, pair.to)
+        continue
+      }
+      found := false
+      for _, edge := range dump.Edges {
+        if edge.From == ids[pair.from] && edge.To == ids[pair.to] && edge.Kind == pair.kind {
+          found = true
+        }
+      }
+      if found != pair.want {
+        t.Errorf("%s -> %s (%s) = %t, want %t", pair.from, pair.to, pair.kind, found, pair.want)
+      }
+    }
+  }
+}

package/internal/graph/alternative_member_declarations_resolve_uses_test.go

@@ -0,0 +1,145 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// Verifies equivalent member declarations produce usable endpoints.
+//
+// 1. Load type-literal intersections, nested properties, parameter properties and variable-bound class expressions.
+// 2. Build their nodes and checker-resolved calls and accesses alongside interface and class-body controls.
+// 3. Require precise members and reject unbound class identities and ordinary constructor parameters.
+//
+// @evidence contracts/testing.md#behavioral-verification Supported named literal members must have their own nodes, source spans and incoming uses. Class-expression bodies retain outgoing dependencies and internal constructor identity, while unindexed shadowing locals cannot borrow global endpoints.
+// @evidence contracts/testing.md#independent-expectations The authored declaration hierarchy supplies literal names Props.onChange, Props.nested.deep, Props.extra, Sale.price and Widget.render, with source-authored caller/target pairs and separate negative controls.
+// @evidence contracts/testing.md#distinguishing-cases Intersections, parenthesized/nested literals, quoted/computed-literal names, parameter-property modifiers, named class self-references, heritage and namespace owners contrast dynamic keys, normal parameters, unbound returned classes, shadowing local classes/objects and cross-owner calls. Existing tests own broader dispatch and object literals.
+// @evidence contracts/testing.md#execution-ownership This Go unit writes a temporary project, owns and closes an in-process compiler Program and calls Build directly without a product process or installed consumer.
+func TestAlternativeMemberDeclarationsResolveUses(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() { return 1; }
+const key = Symbol("key");
+export type Props = ({ onChange(): void; nested: { deep: number }; "quoted.key": number; [key]: number; ["computed"]: number }) & { extra: number };
+export class Sale {
+  constructor(public readonly price: number, ordinary: number, private secret = helper(), protected hidden = 1) {}
+  read() { return this.secret + this.hidden; }
+}
+export class Base { render() { return 0; } }
+export interface Drawable { render(): number }
+export const Widget = (class Internal extends Base implements Drawable {
+  render() { return helper(); }
+  field = helper();
+  static create() { return new Internal(); }
+  static identity() { return Internal; }
+});
+export const Other = class { render() { return 2; } };
+export const api = { run() { return helper(); } };
+export function localClass() {
+  const Widget = class Local { static create() { return new Local(); } };
+  return Widget.create();
+}
+export function localObject() {
+  const api = { run() { return 2; } };
+  return api.run();
+}
+export function change(props: Props) { props.onChange(); return props.nested.deep + props.extra + props["quoted.key"] + props.computed; }
+export function cost(sale: Sale) { return sale.price; }
+export function draw() { return new Widget().render(); }
+export function other() { return new Other().render(); }
+export function anonymous() { return class { render() { return helper(); } }; }
+export interface Control { run(): void }
+export class Body { price = 1; }
+export function control(input: Control, body: Body) { input.run(); return body.price; }
+export namespace Names {
+  export type Props = { nested: { deep: number } };
+  export const Widget = class { render() { return helper(); } };
+  export function read(props: Props) { new Widget().render(); return props.nested.deep; }
+}
+`)
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  g := Build(prog)
+  file := sourceFile(t, prog, "main.ts").FileName()
+  for _, item := range []struct {
+    caller, member string
+    kind           NodeKind
+    edge           EdgeKind
+  }{
+    {"change", "Props.onChange", NodeMethod, EdgeValueCall},
+    {"change", "Props.nested.deep", NodeVariable, EdgeValueAccess},
+    {"change", "Props.extra", NodeVariable, EdgeValueAccess},
+    {"change", `Props["quoted.key"]`, NodeVariable, EdgeValueAccess},
+    {"change", "Props.computed", NodeVariable, EdgeValueAccess},
+    {"cost", "Sale.price", NodeVariable, EdgeValueAccess},
+    {"draw", "Widget.render", NodeMethod, EdgeValueCall},
+    {"other", "Other.render", NodeMethod, EdgeValueCall},
+    {"control", "Control.run", NodeMethod, EdgeValueCall},
+    {"control", "Body.price", NodeVariable, EdgeValueAccess},
+    {"Names.read", "Names.Props.nested.deep", NodeVariable, EdgeValueAccess},
+    {"Names.read", "Names.Widget.render", NodeMethod, EdgeValueCall},
+  } {
+    target := nodeID(file, item.member, item.kind)
+    if node := g.Nodes[target]; node == nil || node.End <= node.Pos || node.Name != item.member {
+      t.Errorf("missing member %s", item.member)
+    }
+    if !hasEdge(g, nodeID(file, item.caller, NodeFunction), target, item.edge) {
+      t.Errorf("missing %s -> %s", item.caller, item.member)
+    }
+  }
+  for member, kind := range map[string]NodeKind{"Widget.render": NodeMethod, "Widget.field": NodeVariable, "Sale.secret": NodeVariable} {
+    if !hasEdge(g, nodeID(file, member, kind), nodeID(file, "helper", NodeFunction), EdgeValueCall) {
+      t.Errorf("%s lost helper call", member)
+    }
+  }
+  for _, target := range []struct {
+    name string
+    kind NodeKind
+  }{{"Base", NodeClass}, {"Drawable", NodeInterface}} {
+    if !hasEdge(g, nodeID(file, "Widget", NodeVariable), nodeID(file, target.name, target.kind), EdgeHeritage) {
+      t.Errorf("Widget lost heritage to %s", target.name)
+    }
+    if !hasEdge(g, nodeID(file, "Widget.render", NodeMethod), nodeID(file, target.name+".render", NodeMethod), EdgeMemberRelation) {
+      t.Errorf("Widget.render lost relation to %s.render", target.name)
+    }
+  }
+  for _, item := range []struct {
+    member string
+    kind   EdgeKind
+  }{{"Widget.create", EdgeValueCall}, {"Widget.identity", EdgeValueAccess}} {
+    if !hasEdge(g, nodeID(file, item.member, NodeMethod), nodeID(file, "Widget", NodeVariable), item.kind) {
+      t.Errorf("%s lost its bound class identity", item.member)
+    }
+  }
+  if hasEdge(g, nodeID(file, "draw", NodeFunction), nodeID(file, "Other.render", NodeMethod), EdgeValueCall) ||
+    hasEdge(g, nodeID(file, "other", NodeFunction), nodeID(file, "Widget.render", NodeMethod), EdgeValueCall) {
+    t.Error("class-expression calls crossed their lexical owners")
+  }
+  for _, item := range []struct {
+    caller, target string
+    kind           NodeKind
+  }{{"localClass", "Widget", NodeVariable}, {"localClass", "Widget.create", NodeMethod}, {"localObject", "api.run", NodeMethod}} {
+    if hasEdge(g, nodeID(file, item.caller, NodeFunction), nodeID(file, item.target, item.kind), EdgeValueCall) {
+      t.Errorf("%s borrowed unrelated top-level target %s", item.caller, item.target)
+    }
+  }
+  allowed := map[string]bool{"Props.onChange": true, "Props.nested": true, "Props.nested.deep": true, "Props.extra": true, `Props["quoted.key"]`: true, "Props.computed": true}
+  for _, node := range g.Nodes {
+    if node.Name == "Sale.ordinary" || node.Name == "__class.render" || node.Name == "Internal.render" {
+      t.Errorf("invented unowned identity %s", node.Name)
+    }
+    if (strings.HasPrefix(node.Name, "Props.") || strings.HasPrefix(node.Name, "Props[")) && !allowed[node.Name] {
+      t.Errorf("invented type member %s", node.Name)
+    }
+  }
+}

package/internal/graph/build.go

@@ -187,11 +187,9 @@ func collectDeclarations(g *Graph, file *shimast.SourceFile) {
   collectStatements(g, file.FileName(), file.Statements.Nodes)
 }
 
-// collectStatements records the nodes for a statement list — the file's top
-// level, or the body of a namespace it recurses into. A member's id is built
-// from its symbol, which already carries the enclosing namespace in its parent
-// chain, so a node recorded here and an edge target resolved later agree without
-// the walk having to thread the namespace name through.
+// collectStatements records a file or namespace statement list. qualifiedName
+// combines compiler symbol ownership with lexical namespaces for private
+// declarations, keeping indexed nodes and later resolved targets consistent.
 func collectStatements(g *Graph, path string, statements []*shimast.Node) {
   for _, statement := range statements {
     switch statement.Kind {
@@ -214,6 +212,7 @@ func collectStatements(g *Graph, path string, statements []*shimast.Node) {
       collectMembers(g, path, statement)
     case shimast.KindTypeAliasDeclaration:
       addNode(g, path, statement, NodeTypeAlias)
+      collectMembers(g, path, statement)
     case shimast.KindEnumDeclaration:
       addNode(g, path, statement, NodeEnum)
     case shimast.KindVariableStatement:
@@ -242,6 +241,9 @@ func collectVariables(g *Graph, path string, statement *shimast.Node) {
   for _, binding := range list.Declarations.Nodes {
     addNode(g, path, binding, NodeVariable)
     g.collectObjectMembers(path, binding)
+    if expression := boundClassExpression(binding); expression != nil {
+      collectMembers(g, path, expression)
+    }
     collectClosures(g, path, binding)
   }
 }
@@ -533,9 +535,9 @@ func addNode(g *Graph, path string, node *shimast.Node, kind NodeKind) {
   putDeclaredNode(g, path, qualifiedName(symbol), kind, node)
 }
 
-// collectMembers records callable members (method, constructor, accessor) and
-// property members of a class or interface declaration, keyed by their
-// class-qualified names so resolved member references land on the same node.
+// collectMembers records callable and property members of modeled type and
+// class declarations. Structural and lexical owner names are shared with
+// checker-resolved targets, including parameter properties and bound literals.
 func collectMembers(g *Graph, path string, statement *shimast.Node) {
   for _, member := range classMembers(statement) {
     name := methodName(member.Symbol())
@@ -650,20 +652,44 @@ func declarationHasImplementation(declaration *shimast.Node, kind NodeKind) bool
   }
 }
 
-// classMembers returns the member nodes of a class or interface declaration, or
-// nil for anything else.
+// classMembers returns direct class/interface members, constructor parameter
+// properties and named nested type-literal members. Type aliases and bound class
+// expressions use the same member surface for indexing and edge attribution.
 func classMembers(statement *shimast.Node) []*shimast.Node {
+  var members []*shimast.Node
   switch statement.Kind {
   case shimast.KindClassDeclaration:
     if decl := statement.AsClassDeclaration(); decl != nil && decl.Members != nil {
-      return decl.Members.Nodes
+      members = decl.Members.Nodes
+    }
+  case shimast.KindClassExpression:
+    if decl := statement.AsClassExpression(); decl != nil && decl.Members != nil {
+      members = decl.Members.Nodes
     }
   case shimast.KindInterfaceDeclaration:
     if decl := statement.AsInterfaceDeclaration(); decl != nil && decl.Members != nil {
-      return decl.Members.Nodes
+      members = decl.Members.Nodes
+    }
+  case shimast.KindTypeAliasDeclaration:
+    return typeLiteralMembers(statement.Type())
+  }
+  var extra []*shimast.Node
+  for _, member := range members {
+    if member.Kind == shimast.KindConstructor {
+      for _, parameter := range member.Parameters() {
+        if isParameterProperty(parameter) {
+          extra = append(extra, parameter)
+        }
+      }
     }
+    extra = append(extra, typeLiteralMembers(member.Type())...)
   }
-  return nil
+  if len(extra) == 0 {
+    return members
+  }
+  result := make([]*shimast.Node, 0, len(members)+len(extra))
+  result = append(result, members...)
+  return append(result, extra...)
 }
 
 // isMethodMember reports whether a class/interface member kind is a callable the
@@ -680,7 +706,7 @@ func isMethodMember(kind shimast.Kind) bool {
 
 func isPropertyMember(kind shimast.Kind) bool {
   switch kind {
-  case shimast.KindPropertyDeclaration, shimast.KindPropertySignature:
+  case shimast.KindPropertyDeclaration, shimast.KindPropertySignature, shimast.KindParameter:
     return true
   default:
     return false
@@ -693,6 +719,9 @@ func isPropertyMember(kind shimast.Kind) bool {
 // symbol.Parent is the class/interface symbol, set by the binder for every
 // member.
 func methodName(symbol *shimast.Symbol) string {
+  if name, ok := structuralMemberName(symbol); ok {
+    return name
+  }
   if symbol == nil || symbol.Parent == nil || symbol.Parent.Name == "" {
     return ""
   }
@@ -763,6 +792,9 @@ func qualifiedName(symbol *shimast.Symbol) string {
       return name
     }
   }
+  if name, ok := structuralMemberName(symbol); ok {
+    return name
+  }
   name := simpleName(symbol)
   if prefix := containerPrefix(symbol); prefix != "" {
     return prefix + "." + name
@@ -776,12 +808,22 @@ func qualifiedName(symbol *shimast.Symbol) string {
 // `namespace` block — so a top-level declaration gets no prefix.
 func containerPrefix(symbol *shimast.Symbol) string {
   parent := symbol.Parent
-  if parent == nil || parent.Name == "" {
-    return ""
-  }
-  if isNamespaceSymbol(parent) || isTypeContainerSymbol(parent) {
+  if parent != nil && parent.Name != "" && (isNamespaceSymbol(parent) || isTypeContainerSymbol(parent)) {
     return qualifiedName(parent)
   }
+  // The binder does not assign Symbol.Parent to private namespace locals.
+  // Their lexical namespace still owns their identity. Stop at a callable so
+  // ClosureName remains the owner of function-local qualification.
+  for _, declaration := range symbol.Declarations {
+    for owner := declaration.Parent; owner != nil; owner = owner.Parent {
+      if isFunctionLike(owner) {
+        break
+      }
+      if owner.Kind == shimast.KindModuleDeclaration && owner.Symbol() != nil && isNamespaceSymbol(owner.Symbol()) {
+        return qualifiedName(owner.Symbol())
+      }
+    }
+  }
   return ""
 }
 

package/internal/graph/declaration_members.go

@@ -0,0 +1,143 @@
+package graph
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// structuralMemberName replaces anonymous type/class binder containers with
+// the declaration that names them. An unbound literal has no stable owner.
+func structuralMemberName(symbol *shimast.Symbol) (string, bool) {
+  if symbol == nil {
+    return "", false
+  }
+  for _, declaration := range symbol.Declarations {
+    parent := declaration.Parent
+    if parent == nil {
+      continue
+    }
+    var owner string
+    switch {
+    case parent.Kind == shimast.KindTypeLiteral:
+      owner = typeLiteralOwner(parent)
+    case parent.Kind == shimast.KindClassExpression:
+      owner = classExpressionOwner(parent)
+    case isParameterProperty(declaration):
+      class := parent.Parent
+      if class != nil && class.Kind == shimast.KindClassExpression {
+        owner = classExpressionOwner(class)
+      } else if class != nil && class.Symbol() != nil {
+        owner = qualifiedName(class.Symbol())
+      }
+    }
+    if owner != "" {
+      return appendObjectMemberName(owner, simpleName(symbol)), true
+    }
+  }
+  return "", false
+}
+
+// typeLiteralOwner follows only type structure with a named declaration owner;
+// a function return or parameter type is not a property of that function.
+func typeLiteralOwner(literal *shimast.Node) string {
+  for node := literal.Parent; node != nil; node = node.Parent {
+    switch node.Kind {
+    case shimast.KindUnionType, shimast.KindIntersectionType, shimast.KindParenthesizedType:
+      continue
+    case shimast.KindTypeAliasDeclaration, shimast.KindPropertySignature, shimast.KindPropertyDeclaration:
+      if node.Symbol() != nil {
+        return qualifiedName(node.Symbol())
+      }
+    }
+    break
+  }
+  return ""
+}
+
+// typeLiteralMembers enumerates statically owned literal members once in AST
+// order, including literals nested under named properties and intersections.
+func typeLiteralMembers(typeNode *shimast.Node) []*shimast.Node {
+  if typeNode == nil {
+    return nil
+  }
+  var members []*shimast.Node
+  var walk func(*shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node.Kind == shimast.KindTypeLiteral {
+      literal := node.AsTypeLiteralNode()
+      if typeLiteralOwner(node) == "" || literal.Members == nil {
+        return
+      }
+      for _, member := range literal.Members.Nodes {
+        if _, ok := staticObjectMemberName(member.Name()); !ok {
+          continue
+        }
+        members = append(members, member)
+        walkType := member.Type()
+        if walkType != nil {
+          walk(walkType)
+        }
+      }
+      return
+    }
+    switch node.Kind {
+    case shimast.KindUnionType, shimast.KindIntersectionType, shimast.KindParenthesizedType:
+      node.ForEachChild(func(child *shimast.Node) bool { walk(child); return false })
+    }
+  }
+  walk(typeNode)
+  return members
+}
+
+// isParameterProperty admits constructor parameters with a property modifier,
+// leaving ordinary parameters local to their constructor.
+func isParameterProperty(node *shimast.Node) bool {
+  return node.Kind == shimast.KindParameter && node.Parent != nil && node.Parent.Kind == shimast.KindConstructor &&
+    shimast.GetCombinedModifierFlags(node)&shimast.ModifierFlagsParameterPropertyModifier != 0
+}
+
+// boundClassExpression unwraps the transparent expression forms around a
+// variable's class initializer, without guessing classes returned by factories.
+func boundClassExpression(binding *shimast.Node) *shimast.Node {
+  variable := binding.AsVariableDeclaration()
+  if variable == nil {
+    return nil
+  }
+  node := variable.Initializer
+  for node != nil {
+    switch node.Kind {
+    case shimast.KindClassExpression:
+      return node
+    case shimast.KindParenthesizedExpression, shimast.KindAsExpression, shimast.KindSatisfiesExpression,
+      shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      node = node.Expression()
+    default:
+      return nil
+    }
+  }
+  return nil
+}
+
+// classExpressionOwner uses the outer binding even for a named expression;
+// its internal class name is private to that expression's body.
+func classExpressionOwner(expression *shimast.Node) string {
+  if binding := classExpressionBinding(expression); binding != nil {
+    return qualifiedName(binding.Symbol())
+  }
+  return ""
+}
+
+// classExpressionBinding preserves the actual declaration behind an owner
+// name, so a shadowing local cannot borrow a same-named indexed value.
+func classExpressionBinding(expression *shimast.Node) *shimast.Node {
+  for parent := expression.Parent; parent != nil; parent = parent.Parent {
+    switch parent.Kind {
+    case shimast.KindParenthesizedExpression, shimast.KindAsExpression, shimast.KindSatisfiesExpression,
+      shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      continue
+    case shimast.KindVariableDeclaration:
+      if parent.Symbol() != nil && boundClassExpression(parent) == expression {
+        return parent
+      }
+    }
+    break
+  }
+  return nil
+}

package/internal/graph/edges.go

@@ -90,6 +90,17 @@ func (g *Graph) collectHeritageIn(checker *shimchecker.Checker, path string, sta
       if decl != nil && decl.HeritageClauses != nil {
         g.heritageEdges(checker, path, statement, NodeInterface, decl.HeritageClauses.Nodes)
       }
+    case shimast.KindVariableStatement:
+      variables := statement.AsVariableStatement().DeclarationList
+      if variables != nil && variables.AsVariableDeclarationList().Declarations != nil {
+        for _, binding := range variables.AsVariableDeclarationList().Declarations.Nodes {
+          if expression := boundClassExpression(binding); expression != nil {
+            if clauses := expression.AsClassExpression().HeritageClauses; clauses != nil {
+              g.heritageEdges(checker, path, expression, NodeClass, clauses.Nodes)
+            }
+          }
+        }
+      }
     case shimast.KindModuleDeclaration:
       g.collectHeritageIn(checker, path, moduleStatements(statement))
     }
@@ -104,6 +115,13 @@ func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *s
     return
   }
   from := nodeID(path, qualifiedName(symbol), kind)
+  if node.Kind == shimast.KindClassExpression {
+    owner := classExpressionOwner(node)
+    if owner == "" {
+      return
+    }
+    from = nodeID(path, owner, NodeVariable)
+  }
   for _, clauseNode := range clauses {
     clause := clauseNode.AsHeritageClause()
     if clause == nil || clause.Types == nil {
@@ -332,12 +350,8 @@ func graphMemberNodeID(g *Graph, member *shimast.Node) string {
   if !ok {
     return ""
   }
-  for _, declaration := range member.Symbol().Declarations {
-    declarationFile := shimast.GetSourceFileOfNode(declaration)
-    if declarationFile != nil && declarationFile.FileName() == stored.File &&
-      declaration.Pos() == stored.Pos && declaration.End() == stored.End {
-      return id
-    }
+  if nodeDeclaresSymbol(stored, member.Symbol()) {
+    return id
   }
   return ""
 }
@@ -382,6 +396,7 @@ func forEachContainerIn(path string, statements []*shimast.Node, fn func(string,
       if id := topLevelID(path, statement, NodeTypeAlias); id != "" {
         fn(id, statement)
       }
+      forEachMember(path, statement, NodeTypeAlias, fn)
     case shimast.KindEnumDeclaration:
       // An enum is a recorded node (build.go), and a member initializer can call a
       // function (`enum E { A = base() }`) or reference a type, so walk its body
@@ -433,6 +448,12 @@ func topLevelID(path string, statement *shimast.Node, kind NodeKind) string {
 // lose dependency edges the owner node carries.
 func forEachMember(path string, statement *shimast.Node, kind NodeKind, fn func(string, *shimast.Node)) {
   containerID := topLevelID(path, statement, kind)
+  if statement.Kind == shimast.KindClassExpression {
+    containerID = ""
+    if owner := classExpressionOwner(statement); owner != "" {
+      containerID = nodeID(path, owner, NodeVariable)
+    }
+  }
   for _, member := range classMembers(statement) {
     forEachClosureIn(path, member, fn)
     if isMethodMember(member.Kind) {
@@ -479,6 +500,10 @@ func heritageClauses(statement *shimast.Node) []*shimast.Node {
     if decl := statement.AsClassDeclaration(); decl != nil && decl.HeritageClauses != nil {
       return decl.HeritageClauses.Nodes
     }
+  case shimast.KindClassExpression:
+    if decl := statement.AsClassExpression(); decl != nil && decl.HeritageClauses != nil {
+      return decl.HeritageClauses.Nodes
+    }
   case shimast.KindInterfaceDeclaration:
     if decl := statement.AsInterfaceDeclaration(); decl != nil && decl.HeritageClauses != nil {
       return decl.HeritageClauses.Nodes
@@ -505,6 +530,9 @@ func forEachVariable(path string, statement *shimast.Node, fn func(string, *shim
       continue
     }
     fn(nodeID(path, qualifiedName(symbol), NodeVariable), binding)
+    if expression := boundClassExpression(binding); expression != nil {
+      forEachMember(path, expression, NodeVariable, fn)
+    }
     if variable := binding.AsVariableDeclaration(); variable != nil {
       forEachObjectDeclaration(path, variable.Initializer, fn)
     }
@@ -542,6 +570,11 @@ func closureID(path string, closure *shimast.Node) string {
 // value-call edges, and property or element access as value-access edges.
 func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shimast.Node) {
   node.ForEachChild(func(child *shimast.Node) bool {
+    // Computed names and typeof inside a type surface are type dependencies,
+    // even when the language-service expression predicate accepts their names.
+    if shimast.IsPartOfTypeNode(child) || child.Kind == shimast.KindTypeQuery {
+      return false
+    }
     // The owning callable keeps aggregate body relationships across closures.
     // forEachClosureIn also records each named closure's own relationships.
     switch child.Kind {
@@ -557,7 +590,6 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       }
       if call := child.AsCallExpression(); call != nil && call.Expression != nil {
         g.callEdge(checker, from, call.Expression, "call")
-        g.handedOffValues(checker, from, call)
       }
     case shimast.KindNewExpression:
       if newExpr := child.AsNewExpression(); newExpr != nil && newExpr.Expression != nil {
@@ -582,6 +614,12 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       if !isInvokedAccess(child) {
         g.accessEdge(checker, from, child)
       }
+    case shimast.KindIdentifier:
+      if isValueIdentifier(child) {
+        g.accessEdge(checker, from, child)
+      }
+    case shimast.KindShorthandPropertyAssignment, shimast.KindBindingElement, shimast.KindJsxAttribute:
+      g.accessEdge(checker, from, child)
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
         file := g.recordImplementation(target, child)
@@ -707,29 +745,22 @@ func (g *Graph) callEdge(checker *shimchecker.Checker, from string, callee *shim
   g.valueUseEdge(checker, from, callee, EdgeValueCall, origin)
 }
 
-// handedOffValues records the workspace functions a call is handed, as uses of
-// them.
-//
-// `React.memo(ExcalidrawBase)`, `forwardRef(Impl)`, `app.use(handler)`,
-// `pipe(map(project))` — the argument is not called here and is not a property
-// read, so neither the call nor the access collector would record it, and the
-// wrapper would be a dead end: `export const Excalidraw =
-// React.memo(ExcalidrawBase)` would reach nothing of the component behind it.
-//
-// A function handed to another function is a use of it, and it is the one the
-// runtime will run. Bounded to argument position: this is the callback, the
-// wrapped component, the registered handler — not every identifier in every
-// expression.
-func (g *Graph) handedOffValues(checker *shimchecker.Checker, from string, call *shimast.CallExpression) {
-  if call.Arguments == nil {
-    return
+// isValueIdentifier uses the compiler's expression classification and excludes
+// names already represented by their enclosing access, call or JSX expression.
+// Type queries are expressions to the language service but remain type edges here.
+func isValueIdentifier(node *shimast.Node) bool {
+  parent := node.Parent
+  if parent == nil || !shimast.IsExpressionNode(node) || shimast.IsDeclarationNameOrImportPropertyName(node) || isInvokedAccess(node) {
+    return false
   }
-  for _, argument := range call.Arguments.Nodes {
-    switch argument.Kind {
-    case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
-      g.valueUseEdge(checker, from, argument, EdgeValueAccess, "")
-    }
+  switch parent.Kind {
+  case shimast.KindPropertyAccessExpression:
+    return parent.AsPropertyAccessExpression().Name() != node
+  case shimast.KindJsxOpeningElement, shimast.KindJsxSelfClosingElement, shimast.KindJsxClosingElement,
+    shimast.KindTypeQuery, shimast.KindQualifiedName:
+    return false
   }
+  return true
 }
 
 // accessEdge resolves a property or element access to its declaration and
@@ -746,6 +777,17 @@ func (g *Graph) valueUseEdge(checker *shimchecker.Checker, from string, targetEx
   if target == nil || target.Symbol == nil {
     return
   }
+  // Enum members remain outline facts on their enum rather than separate nodes.
+  // Their reads therefore depend on that enum's existing identity.
+  if kind == EdgeValueAccess && target.Symbol.Flags&shimast.SymbolFlagsEnumMember != 0 {
+    if parent := target.Symbol.Parent; parent != nil {
+      if declaration := declarationNode(parent); declaration != nil {
+        if file := declarationFile(parent); file != nil {
+          target = &Target{Symbol: parent, File: file.FileName(), External: !IsWorkspaceSourceFile(file), Pos: declaration.Pos(), End: declaration.End()}
+        }
+      }
+    }
+  }
   to := g.ensureTargetNode(target)
   if to == "" || to == from {
     return
@@ -838,6 +880,21 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   if target.File == "" {
     return ""
   }
+  if kind == NodeClass && !target.External {
+    // A named class expression's internal name denotes the same constructor
+    // its variable binds. Keep those self-references on the existing value node.
+    for _, declaration := range target.Symbol.Declarations {
+      if declaration.Kind != shimast.KindClassExpression {
+        continue
+      }
+      if binding := classExpressionBinding(declaration); binding != nil {
+        id := nodeID(target.File, qualifiedName(binding.Symbol()), NodeVariable)
+        if stored, exists := g.lookupNode(id); exists && nodeDeclaresSymbol(stored, binding.Symbol()) {
+          return id
+        }
+      }
+    }
+  }
   if kind == NodeMethod {
     // A method node is class-qualified and only modeled when it belongs to the
     // workspace (Build recorded it). A call into a dependency's method stops at
@@ -848,7 +905,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
       return ""
     }
     id := nodeID(target.File, name, NodeMethod)
-    if _, exists := g.lookupNode(id); exists {
+    if stored, exists := g.lookupNode(id); exists && nodeDeclaresSymbol(stored, target.Symbol) {
       return id
     }
     return ""
@@ -857,17 +914,19 @@ func (g *Graph) ensureTargetNode(target *Target) string {
     return ""
   }
   name := qualifiedName(target.Symbol)
-  id := nodeID(target.File, name, kind)
-  if _, exists := g.lookupNode(id); exists {
-    return id
-  }
   if !target.External {
-    // A closure Build recorded is keyed by its scoped name
-    // (`baseCreateRenderer.patch`), which the symbol alone does not spell, so
-    // resolve it from the declaration the checker pointed at.
+    // A scoped callable must resolve before any same-named top-level node.
     if id := g.closureTargetID(target); id != "" {
       return id
     }
+  }
+  id := nodeID(target.File, name, kind)
+  if stored, exists := g.lookupNode(id); exists {
+    if nodeDeclaresSymbol(stored, target.Symbol) {
+      return id
+    }
+  }
+  if !target.External {
     // Any other workspace target Build did not record is body-scoped and
     // unnameable without collisions (a local of an anonymous callback), so its
     // name would key the same id as a same-named local of another scope and
@@ -889,6 +948,19 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   return id
 }
 
+// nodeDeclaresSymbol verifies the indexed display declaration belongs to the
+// resolved symbol. Names alone cannot distinguish unindexed shadowing locals;
+// overloads and merged symbols may legitimately carry several declarations.
+func nodeDeclaresSymbol(node *Node, symbol *shimast.Symbol) bool {
+  for _, declaration := range symbol.Declarations {
+    file := shimast.GetSourceFileOfNode(declaration)
+    if file != nil && file.FileName() == node.File && declaration.Pos() == node.Pos && declaration.End() == node.End {
+      return true
+    }
+  }
+  return false
+}
+
 // closureTargetID returns the node id of a closure the checker resolved to, or ""
 // when the target is not one Build recorded.
 func (g *Graph) closureTargetID(target *Target) string {

package/internal/graph/namespace_private_declarations_keep_lexical_identity_test.go

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

package/internal/graph/resolve.go

@@ -67,14 +67,15 @@ func (g *Graph) resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target
   return target
 }
 
-// Resolve uses the checker's external GetSymbolAtLocation API, then requests an
-// aliased symbol when one is reported. That API deliberately returns a contextual
+// Resolve uses the checker's external symbol APIs, including source-value lookup
+// for shorthand properties and contextual property lookup for destructuring and
+// JSX attributes, then unwraps aliases. These APIs return a contextual
 // symbol, not a universal type-checking binding guarantee. A valid checker and
 // parented source-tree ref are required. Nil means no reported symbol; a symbol
 // without a source declaration can instead return a target with empty File.
 //
-// @evidence contracts/common.md#principled-implementation The supported external symbol API and alias API supply a contextual endpoint; representative declaration selection prefers non-declaration-file bodies without certifying physical ownership or every expression's type-checking binding.
-// @evidence contracts/common.md#clear-and-simple-design Symbol lookup, alias unwrapping and declaration classification form one endpoint adapter shared by graph relation passes.
+// @evidence contracts/common.md#principled-implementation Supported upstream symbol, shorthand-value and contextual-type/property queries supply endpoints for their respective syntax. Alias unwrapping and representative declaration selection prefer workspace bodies without certifying physical ownership or every expression's type-checking binding.
+// @evidence contracts/common.md#clear-and-simple-design Syntax-specific supported checker queries feed shared alias unwrapping and declaration classification in one endpoint adapter.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Barrel resolution uses the supported checker API rather than guessing export files or rewriting foreign state.
 // @evidence contracts/common.md#meaningful-documentation Native prose states alias behavior, unresolved outcomes and source ownership, with documentation-skill tag spacing.
 // @evidence contracts/performance.md#efficient-algorithms Delegated contextual lookup/alias resolution can perform lazy semantic work beyond the returned symbol. Up to three declaration passes, source ancestry and filename classification add declaration-count/depth/string costs; this adapter itself performs no repository scan.
@@ -97,7 +98,31 @@ func Resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target {
       return nil
     }
   }
-  symbol := checker.GetSymbolAtLocation(ref)
+  var symbol *shimast.Symbol
+  switch ref.Kind {
+  case shimast.KindShorthandPropertyAssignment:
+    symbol = checker.GetShorthandAssignmentValueSymbol(ref)
+  case shimast.KindBindingElement:
+    binding := ref.AsBindingElement()
+    if ref.Parent != nil && ref.Parent.Kind == shimast.KindObjectBindingPattern && binding.DotDotDotToken == nil {
+      name := binding.PropertyName
+      if name == nil {
+        name = binding.Name()
+      }
+      if property, ok := staticObjectMemberName(name); ok {
+        symbol = checker.GetPropertyOfType(checker.GetTypeAtLocation(ref.Parent), property)
+      }
+    }
+  case shimast.KindJsxAttribute:
+    if property, ok := staticObjectMemberName(ref.Name()); ok && ref.Parent != nil {
+      // Zero requests the upstream API's ordinary contextual type, with no flags.
+      if contextual := checker.GetContextualType(ref.Parent, 0); contextual != nil {
+        symbol = checker.GetPropertyOfType(contextual, property)
+      }
+    }
+  default:
+    symbol = checker.GetSymbolAtLocation(ref)
+  }
   if symbol == nil {
     return nil
   }

package/internal/graph/value_reads_cover_expression_positions_test.go

@@ -0,0 +1,88 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// Verifies named value uses survive their expression position.
+//
+// 1. Load isolated readers, destructuring and JSX properties with invocation and type-only controls.
+// 2. Build checker-resolved relations from one TSX Program.
+// 3. Require each actual reader and reject type-only, label and declaration-name dependencies.
+//
+// @evidence contracts/testing.md#behavioral-verification Build must record accesses to num, Props.label and Color from every authored reader, while preserving call edges without duplicate accesses and excluding type-only syntax.
+// @evidence contracts/testing.md#independent-expectations Each literal function body independently determines whether it reads the named module value or property. Expected relationships are authored pairs rather than a snapshot of the extractor's output.
+// @evidence contracts/testing.md#distinguishing-cases Return, arithmetic, condition, array, object, shorthand, template, assignment, anonymous closure, destructured aliases/defaults/parameters, JSX and enum uses contrast declaration names, labels, shadowed locals, type queries and direct calls. Existing tests own ordinary dotted and bracket access, dispatch and external leaves.
+// @evidence contracts/testing.md#execution-ownership This Go unit owns a temporary TSX project, loads and closes its compiler Program and calls Build directly; no native binary, installed consumer or agent query is launched.
+func TestValueReadsCoverExpressionPositions(t *testing.T) {
+  t.Setenv(driver.LinkedPluginsEnv, "")
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{"compilerOptions":{"strict":true,"target":"ES2022","module":"commonjs","jsx":"preserve"},"include":["src"]}`)
+  writeFile(t, filepath.Join(root, "src", "main.tsx"), "declare global { namespace JSX { type Element = unknown; interface IntrinsicElements {} } }\n"+`export const num = 1;
+export enum Color { Red }
+export interface Props { label: number }
+export function Badge(props: Props) { return null; }
+export function asArgument() { return String(num); }
+export function returned() { return num; }
+export function added() { return num + 1; }
+export function tested() { if (num) return 1; return 0; }
+export function inArray() { return [num]; }
+export function inObject() { return { key: num }; }
+export function shorthand() { return { num }; }
+export function inTemplate() { return `+"`${num}`"+`; }
+export function assigned() { const copy = num; return copy; }
+export function closure() { return () => num; }
+export function dotted(props: Props) { return props.label; }
+export function destructured(props: Props) { const { label } = props; return label; }
+export function renamed(props: Props) { const { label: renamed = num } = props; return renamed; }
+export function parameter({ label }: Props) { return label; }
+export function jsxAttribute() { return <Badge label={1} />; }
+export function enumMember() { return Color.Red; }
+export function enumBracket() { return Color["Red"]; }
+export function invoked() { return Badge({ label: 1 }); }
+export function onlyTypes(value: typeof num): Props { return { label: value }; }
+export type OnlyType = { [num]: typeof num };
+export function shadowed() { const num = 2; return num; }
+export function labels() { num: for (;;) { break num; } }
+`)
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  g := Build(prog)
+  file := sourceFile(t, prog, "main.tsx").FileName()
+  for _, reader := range []string{"asArgument", "returned", "added", "tested", "inArray", "inObject", "shorthand", "inTemplate", "assigned", "closure", "renamed"} {
+    if !hasEdge(g, nodeID(file, reader, NodeFunction), nodeID(file, "num", NodeVariable), EdgeValueAccess) {
+      t.Errorf("%s lost num read", reader)
+    }
+  }
+  for _, reader := range []string{"dotted", "destructured", "renamed", "parameter", "jsxAttribute"} {
+    if !hasEdge(g, nodeID(file, reader, NodeFunction), nodeID(file, "Props.label", NodeVariable), EdgeValueAccess) {
+      t.Errorf("%s lost Props.label read", reader)
+    }
+  }
+  for _, reader := range []string{"enumMember", "enumBracket"} {
+    if !hasEdge(g, nodeID(file, reader, NodeFunction), nodeID(file, "Color", NodeEnum), EdgeValueAccess) {
+      t.Errorf("%s lost enum read", reader)
+    }
+  }
+  for _, reader := range []string{"onlyTypes", "shadowed", "labels"} {
+    if hasEdge(g, nodeID(file, reader, NodeFunction), nodeID(file, "num", NodeVariable), EdgeValueAccess) {
+      t.Errorf("%s invented num read", reader)
+    }
+  }
+  if hasEdge(g, nodeID(file, "OnlyType", NodeTypeAlias), nodeID(file, "num", NodeVariable), EdgeValueAccess) {
+    t.Error("type-literal computed name invented a runtime read")
+  }
+  from, to := nodeID(file, "invoked", NodeFunction), nodeID(file, "Badge", NodeFunction)
+  if !hasEdge(g, from, to, EdgeValueCall) || hasEdge(g, from, to, EdgeValueAccess) {
+    t.Error("direct invocation must retain only its call edge")
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.33.0",
+  "version": "0.33.1",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -61,13 +61,13 @@
   },
   "optionalDependencies": {
     "fsevents": "^2.3.3",
-    "@ttsc/linux-x64": "0.33.0",
-    "@ttsc/linux-arm": "0.33.0",
-    "@ttsc/linux-arm64": "0.33.0",
-    "@ttsc/darwin-x64": "0.33.0",
-    "@ttsc/darwin-arm64": "0.33.0",
-    "@ttsc/win32-x64": "0.33.0",
-    "@ttsc/win32-arm64": "0.33.0"
+    "@ttsc/linux-x64": "0.33.1",
+    "@ttsc/linux-arm": "0.33.1",
+    "@ttsc/linux-arm64": "0.33.1",
+    "@ttsc/darwin-arm64": "0.33.1",
+    "@ttsc/win32-x64": "0.33.1",
+    "@ttsc/darwin-x64": "0.33.1",
+    "@ttsc/win32-arm64": "0.33.1"
   },
   "sideEffects": [
     "./lib/register.js",