ttsc 0.33.0 → 0.34.0

package/driver/rewrite.go

@@ -27,6 +27,7 @@ import (
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // Rewrite describes one emit-time patch: the replacement JS fragment a linked
@@ -97,7 +98,7 @@ func (rs *RewriteSet) Add(r Rewrite) {
   if r.File == nil {
     return
   }
-  path := filepath.ToSlash(r.File.FileName())
+  path := filepath.ToSlash(string(r.File.FileName()))
   rs.byPath[path] = append(rs.byPath[path], r)
 }
 
@@ -184,7 +185,7 @@ func (p *Program) EmitAllRaw(writeFile shimcompiler.WriteFile) (*shimcompiler.Em
   // lock contention are included in emission cost; this does not change the
   // native generation threading policy.
   var wfMu sync.Mutex
-  wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
+  wf := func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
     wfMu.Lock()
     defer wfMu.Unlock()
     if p.outputEscapesOutDir(fileName) {
@@ -198,7 +199,7 @@ func (p *Program) EmitAllRaw(writeFile shimcompiler.WriteFile) (*shimcompiler.Em
     if writeFile != nil {
       return writeFile(fileName, text, data)
     }
-    return DefaultWriteFile(fileName, text)
+    return DefaultWriteFile(string(fileName), text)
   }
   result := p.emitProgram(shimcompiler.EmitOptions{
     WriteFile: wf,
@@ -242,7 +243,7 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
   // output map) must likewise see one writer at a time. Rewriting, destination
   // work and lock contention remain part of this emission's cost.
   var wfMu sync.Mutex
-  wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
+  wf := func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
     wfMu.Lock()
     defer wfMu.Unlock()
     if p.outputEscapesOutDir(fileName) {
@@ -258,7 +259,7 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
     patched := text
     if !p.isBuildInfoOutput(fileName) {
       var err error
-      patched, err = applyRewrites(fileName, text, rs, cursors)
+      patched, err = applyRewrites(string(fileName), text, rs, cursors)
       if err != nil {
         return err
       }
@@ -266,13 +267,10 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
     if writeFile != nil {
       return writeFile(fileName, patched, data)
     }
-    return DefaultWriteFile(fileName, patched)
+    return DefaultWriteFile(string(fileName), patched)
   }
 
-  result := p.emitProgram(shimcompiler.EmitOptions{
-    TargetSourceFile: target,
-    WriteFile:        wf,
-  })
+  result := p.emitProgram(shimcompiler.TargetedEmitOptions(target, wf))
   return result, p.convertProgramDiagnostics(result.Diagnostics), nil
 }
 
@@ -290,11 +288,11 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
 //
 // A single-file emit stays on the plain lane. Build information describes a
 // whole program, and tsgo's incremental program returns early on a
-// `TargetSourceFile` request without writing any, so routing it there would
+// single-file request without writing any, so routing it there would
 // only add a snapshot computation nothing reads.
 func (p *Program) emitProgram(options shimcompiler.EmitOptions) *shimcompiler.EmitResult {
   ctx := context.Background()
-  if options.TargetSourceFile == nil && p.emitsBuildInfo() {
+  if shimcompiler.EmitsWholeProgram(options) && p.emitsBuildInfo() {
     return shimcompiler.EmitFreshWithBuildInfo(ctx, p.TSProgram, options)
   }
   return p.TSProgram.Emit(ctx, options)
@@ -359,7 +357,7 @@ func parseRewriteOutput(outputName, text string) *ast.SourceFile {
   if strings.EqualFold(filepath.Ext(outputName), ".jsx") {
     kind = shimcore.ScriptKindJSX
   }
-  return shimparser.ParseSourceFile(ast.SourceFileParseOptions{FileName: parseName}, text, kind)
+  return shimparser.ParseSourceFile(ast.SourceFileParseOptions{FileName: shimtspath.RootedFilePathFromAbsolute(parseName)}, text, kind)
 }
 
 // rewriteHeaderStart preserves the byte-order mark and interpreter directive.

package/driver/session.go

@@ -3,6 +3,7 @@ package driver
 import (
   "context"
 
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/samchon/ttsc/packages/ttsc/internal/e2etrace"
 )
@@ -76,7 +77,7 @@ func NewSession(cwd, tsconfig string, options LoadProgramOptions) (*Session, []D
 // @evidence contracts/common.md#clear-and-simple-design One operation owns buffer update, incremental compiler update and checker-lease replacement.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The compiler's update result determines reuse, with no filename-specific bypass or invented success.
 // @evidence contracts/common.md#meaningful-documentation Native prose explains true and false reuse results following the documentation skill.
-// @evidence contracts/portability.md#os-neutral-implementation Resident member spelling, supplied cwd and captured overlay case policy feed native ToPath; these are lexical compiler keys, not independent physical-alias or directory capability proofs.
+// @evidence contracts/portability.md#os-neutral-implementation Resident member spelling, the Program's base directory and its case policy produce the native path key; these are lexical compiler keys, not independent physical-alias or directory capability proofs.
 // @evidence contracts/performance.md#efficient-algorithms Overlay/key setup processes path bytes; SourceFile may run pending linked hooks before indexed lookup. Native update reads/parses the edited member and either clones file collections and initializes a new checker pool while sharing eligible data, or performs full reconstruction. File/reference/source populations and native host work therefore remain costs even on a reused-data result.
 // @evidence contracts/performance.md#reuse-equivalent-work Under the caller's existing-member/single-change contract, native parse options, import/reference/augmentation/ambient-name compatibility and package-redirect checks determine data reuse. Every successful result is a new Program generation; transformed mutable AST reuse is not supported by this type-check session contract.
 // @evidence contracts/performance.md#bound-retention-and-release-resources A returned replacement releases the old checker lease before acquiring/installing the new checker and host. Current native data and uncapped overlay text remain session-owned, with earlier generation data possibly shared or retained by other aliases; lease replacement does not bound bytes or reclaim all old state. Close and caller ownership govern later release.
@@ -84,11 +85,15 @@ func (s *Session) Apply(absPath, content string) bool {
   s.overlay.Set(absPath, content)
   name := absPath
   if file := s.prog.SourceFile(absPath); file != nil {
-    name = file.FileName()
+    name = string(file.FileName())
   }
-  changed := shimtspath.ToPath(name, s.cwd, s.overlay.caseSensitive)
-  newHost := DefaultHost(s.cwd, s.prog.FS)
-  newProg, reused := s.prog.TSProgram.UpdateProgram(changed, newHost, nil)
+  changed := shimcompiler.ProgramPathKey(s.prog.TSProgram, shimtspath.ToRootedFilePath(name, s.prog.TSProgram.GetCurrentDirectory()))
+  // The new host keeps the Program's content mappers, so a mapped file is
+  // still transformed by the processes the first generation started.
+  newHost := projectHost(s.prog.hosts, s.cwd, s.prog.FS)
+  // The second result is the changed file as newHost parsed it, returned so a
+  // host with a parse cache can release it; this host parses without one.
+  newProg, _, reused := shimcompiler.UpdateProgram(s.prog.TSProgram, changed, newHost)
   if newProg != nil {
     e2etrace.Program("program-construction", "driver-update", "constructor-returned", reused, newProg)
     if s.prog.checkerRelease != nil {
@@ -142,8 +147,9 @@ func (s *Session) SourceText(absPath string) (string, bool) {
   return file.Text(), true
 }
 
-// Close releases the current Program's checker lease. It does not clear the
-// resident Program or overlay, dispose all native data, or forbid later calls.
+// Close releases the current Program's checker lease and content-mapper
+// processes. It does not clear the resident Program or overlay, dispose all
+// native data, or forbid later calls.
 //
 // @evidence contracts/common.md#principled-implementation Closing the current Program releases its checker lease; an absent Program has no lease to release.
 // @evidence contracts/common.md#clear-and-simple-design Session cleanup delegates lease ownership to Program.Close without a second release ledger.

package/driver/target_ts70.go

@@ -0,0 +1,85 @@
+//go:build !ttsc_typescript_7_1
+
+package driver
+
+import (
+  "context"
+  "strings"
+
+  ast "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// TypeScript 7.0 compiler target.
+//
+// The driver's emit and diagnostic glue calls compiler APIs whose signatures
+// and semantics differ between the 7.0 and 7.1 compilers. Each function here
+// keeps the call the driver made on 7.0; target_ts71.go declares the same
+// functions over the 7.1 compiler. The ttsc_typescript_7_1 build tag selects
+// 7.1, and its absence selects this file.
+
+// UseCaseSensitiveFileNames is the 7.0 EmitHost case policy.
+func (h *pluginEmitHost) UseCaseSensitiveFileNames() bool {
+  return h.program.UseCaseSensitiveFileNames()
+}
+
+// GetCurrentDirectory is the 7.0 EmitHost working directory.
+func (h *pluginEmitHost) GetCurrentDirectory() string { return h.program.GetCurrentDirectory() }
+
+// GetEmitResolver is the 7.0 EmitHost resolver: the checker's single resolver,
+// guarded to the program's original member accesses.
+func (h *pluginEmitHost) GetEmitResolver() shimprinter.EmitResolver {
+  return guardedEmitResolver{h.checker.GetEmitResolver(), h.originalMembers}
+}
+
+// handleNoEmit applies noEmitOnError's whole-program diagnostic gate. A nil
+// result means emit may proceed.
+func handleNoEmit(ctx context.Context, program *shimcompiler.Program) *shimcompiler.EmitResult {
+  return shimcompiler.HandleNoEmitOnError(ctx, program, nil)
+}
+
+// applyScriptTransformers runs the compiler's script transformers for source
+// over tree, resolving through host's guarded emit resolver, and returns the
+// transformed tree.
+func applyScriptTransformers(emitContext *shimprinter.EmitContext, host *pluginEmitHost, source *ast.SourceFile, tree *ast.SourceFile) *ast.SourceFile {
+  for _, transformer := range shimcompiler.GetScriptTransformers(emitContext, host, source) {
+    tree = transformer.TransformSourceFile(tree)
+  }
+  return tree
+}
+
+// scriptWriteFileData is the WriteFileData the 7.0 emitter passes with a
+// JavaScript output: only its source-map URL position.
+func scriptWriteFileData(source *ast.SourceFile, sourceMapURLPos int) *shimcompiler.WriteFileData {
+  return &shimcompiler.WriteFileData{SourceMapUrlPos: sourceMapURLPos}
+}
+
+// sourceMapWriteFileData is the WriteFileData the 7.0 emitter passes with a
+// source map: none.
+func sourceMapWriteFileData(source *ast.SourceFile) *shimcompiler.WriteFileData {
+  return nil
+}
+
+// declarationShapeEmitOptions returns the forced declaration emit of one file
+// that the declaration-shape digest reads.
+func declarationShapeEmitOptions(file *ast.SourceFile, writeFile shimcompiler.WriteFile) shimcompiler.EmitOptions {
+  return shimcompiler.EmitOptions{TargetSourceFile: file, EmitOnly: shimcompiler.EmitOnlyForcedDts, WriteFile: writeFile}
+}
+
+// writeDeclarationShapeDiagnosticFile writes how upstream incremental names a
+// diagnostic's file relative to the file whose signature it belongs to.
+func writeDeclarationShapeDiagnosticFile(builder *strings.Builder, source *ast.SourceFile, diagnosticFile *ast.SourceFile) {
+  builder.WriteString(shimtspath.EnsurePathIsNonModuleName(shimtspath.GetRelativePathFromDirectory(
+    shimtspath.GetDirectoryPath(string(source.Path())),
+    string(diagnosticFile.Path()),
+    shimtspath.ComparePathsOptions{},
+  )))
+}
+
+// fileDiagnostics returns the bind and semantic diagnostics of one file under
+// the compiler's any-program diagnostic rules.
+func fileDiagnostics(ctx context.Context, program *shimcompiler.Program, file *ast.SourceFile) []*ast.Diagnostic {
+  return shimcompiler.GetDiagnosticsOfAnyProgram(ctx, program, file, false, program.GetBindDiagnostics, program.GetSemanticDiagnostics)
+}

package/driver/target_ts71.go

@@ -0,0 +1,97 @@
+//go:build ttsc_typescript_7_1
+
+package driver
+
+import (
+  "context"
+  "strings"
+
+  ast "github.com/microsoft/typescript-go/shim/ast"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// TypeScript 7.1 compiler target.
+//
+// The driver's emit and diagnostic glue calls compiler APIs whose signatures
+// and semantics differ between the 7.0 and 7.1 compilers. Each function here
+// makes the 7.1 call; target_ts70.go declares the same functions over the 7.0
+// compiler. The ttsc_typescript_7_1 build tag selects this file.
+
+// CaseSensitivity is the 7.1 EmitHost case policy.
+func (h *pluginEmitHost) CaseSensitivity() shimtspath.CaseSensitivity {
+  return shimcompiler.ProgramCaseSensitivity(h.program)
+}
+
+// BaseDirectory is the 7.1 EmitHost project directory.
+func (h *pluginEmitHost) BaseDirectory() shimtspath.RootedDirectoryPath {
+  return h.program.BaseDirectory()
+}
+
+// ContentMapperExtensions is the 7.1 EmitHost list of content-mapper extensions.
+func (h *pluginEmitHost) ContentMapperExtensions() []string {
+  return h.program.ContentMapperExtensions()
+}
+
+// ContentMapperExtensionRewrites is the 7.1 EmitHost list of content-mapper
+// output extension rewrites.
+func (h *pluginEmitHost) ContentMapperExtensionRewrites() []shimtspath.ExtensionRewrite {
+  return h.program.ContentMapperExtensionRewrites()
+}
+
+// NewEmitResolver is the 7.1 EmitHost resolver for one emit context, guarded
+// to the program's original member accesses.
+func (h *pluginEmitHost) NewEmitResolver(emitContext *shimprinter.EmitContext) shimprinter.EmitResolver {
+  return guardedEmitResolver{h.checker.NewEmitResolver(emitContext), h.originalMembers}
+}
+
+// handleNoEmit applies noEmitOnError's whole-program diagnostic gate. A nil
+// result means emit may proceed.
+func handleNoEmit(ctx context.Context, program *shimcompiler.Program) *shimcompiler.EmitResult {
+  return shimcompiler.HandleNoEmitOptions(ctx, program, nil, nil)
+}
+
+// applyScriptTransformers runs the compiler's script transformers for source
+// over tree, resolving through host's guarded emit resolver, and returns the
+// transformed tree.
+func applyScriptTransformers(emitContext *shimprinter.EmitContext, host *pluginEmitHost, source *ast.SourceFile, tree *ast.SourceFile) *ast.SourceFile {
+  for _, transformer := range shimcompiler.GetScriptTransformers(host.NewEmitResolver(emitContext), host, source) {
+    tree = transformer.TransformSourceFile(tree)
+  }
+  return tree
+}
+
+// scriptWriteFileData is the WriteFileData the 7.1 emitter passes with a
+// JavaScript output: its source-map URL position and its source file.
+func scriptWriteFileData(source *ast.SourceFile, sourceMapURLPos int) *shimcompiler.WriteFileData {
+  return &shimcompiler.WriteFileData{SourceMapUrlPos: sourceMapURLPos, SourceFile: source}
+}
+
+// sourceMapWriteFileData is the WriteFileData the 7.1 emitter passes with a
+// source map: only its source file.
+func sourceMapWriteFileData(source *ast.SourceFile) *shimcompiler.WriteFileData {
+  return &shimcompiler.WriteFileData{SourceFile: source}
+}
+
+// declarationShapeEmitOptions returns the forced declaration emit of one file
+// that the declaration-shape digest reads.
+func declarationShapeEmitOptions(file *ast.SourceFile, writeFile shimcompiler.WriteFile) shimcompiler.EmitOptions {
+  return shimcompiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}, EmitOnly: shimcompiler.EmitOnlyBuilderSignature, WriteFile: writeFile}
+}
+
+// writeDeclarationShapeDiagnosticFile writes how upstream incremental names a
+// diagnostic's file relative to the file whose signature it belongs to.
+func writeDeclarationShapeDiagnosticFile(builder *strings.Builder, source *ast.SourceFile, diagnosticFile *ast.SourceFile) {
+  if relative, ok := shimtspath.CaseInsensitive.RelativePathFromFile(source.FileName(), diagnosticFile.FileName()); ok {
+    builder.WriteString(string(relative.AsModuleSpecifier()))
+  } else {
+    builder.WriteString(string(diagnosticFile.FileName()))
+  }
+}
+
+// fileDiagnostics returns the bind and semantic diagnostics of one file under
+// the compiler's any-program diagnostic rules.
+func fileDiagnostics(ctx context.Context, program *shimcompiler.Program, file *ast.SourceFile) []*ast.Diagnostic {
+  return shimcompiler.GetDiagnosticsOfAnyProgram(ctx, program, []*ast.SourceFile{file}, false, program.GetBindDiagnostics, program.GetSemanticDiagnostics)
+}

package/driver/transform_dependencies.go

@@ -93,7 +93,7 @@ func (p *Program) TransformDependenciesFor(cwd string) TransformDependencies {
   files := p.sourceFilesRaw()
   keys := make([]string, 0, len(files))
   for _, file := range files {
-    keys = append(keys, TransformOutputKey(cwd, file.FileName()))
+    keys = append(keys, TransformOutputKey(cwd, string(file.FileName())))
   }
   return p.plugins.transformDependencies(keys)
 }

package/driver/transform_source_map.go

@@ -4,7 +4,6 @@ import (
   "encoding/base64"
   "encoding/json"
   "fmt"
-  "path"
   "strings"
   "unicode/utf16"
 
@@ -45,20 +44,20 @@ func (p *Program) AuthoredSourceMap(file *ast.SourceFile, sourceMap string) (aut
     return file.Text(), sourceMap, true
   }
   authored = file.Text()
-  if start, length, found := sourcePreambleRegion(file.FileName(), authored, p.SourcePreamble); found {
+  if start, length, found := sourcePreambleRegion(string(file.FileName()), authored, p.SourcePreamble); found {
     authored = authored[:start] + authored[start+length:]
   }
-  directory := path.Dir(file.FileName())
+  directory := shimtspath.FileDirectory(file.FileName())
   corrected, ok = correctAuthoredSourceMap(sourceMap, func(source string) *authoredRegion {
     name := sourceMapFileName(source, directory)
     target := file
-    if name != file.FileName() {
+    if name != string(file.FileName()) {
       target = p.SourceFile(name)
     }
     if target == nil {
       return nil
     }
-    return newAuthoredRegion(target.FileName(), target.Text(), p.SourcePreamble)
+    return newAuthoredRegion(string(target.FileName()), target.Text(), p.SourcePreamble)
   })
   return authored, corrected, ok
 }
@@ -99,40 +98,42 @@ func (p *Program) NewSourceMapCorrector() func(fileName, text string) (string, e
   if !options.SourceMap.IsTrue() && !options.InlineSourceMap.IsTrue() && !options.GetAreDeclarationMapsEnabled() {
     return func(_ string, text string) (string, error) { return text, nil }
   }
-  directories := map[shimtspath.Path]string{}
-  outputKey := func(name string) shimtspath.Path {
-    return shimtspath.ToPath(name, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames())
-  }
-  register := func(output, mapOutput string, source *ast.SourceFile) {
+  directories := map[shimtspath.PathKey]shimtspath.RootedDirectoryPath{}
+  register := func(output, mapOutput shimtspath.RootedFilePath, source *ast.SourceFile) {
     if output == "" {
       return
     }
     directory := shimcompiler.SourceMapDirectory(options, host, output, source)
-    directories[outputKey(output)] = directory
+    directories[shimcompiler.ProgramPathKey(program, output)] = directory
     if mapOutput != "" {
-      directories[outputKey(mapOutput)] = directory
+      directories[shimcompiler.ProgramPathKey(program, mapOutput)] = directory
     }
   }
-  for _, source := range shimcompiler.GetSourceFilesToEmit(host, nil, false) {
-    outputs := shimcompiler.GetOutputPathsFor(source, options, host, false)
+  for _, source := range shimcompiler.SourceFilesToEmit(host) {
+    outputs := shimcompiler.OutputPathsFor(source, options, host)
     register(outputs.JsFilePath(), outputs.SourceMapFilePath(), source)
     register(outputs.DeclarationFilePath(), outputs.DeclarationMapPath(), source)
   }
   regions := map[*ast.SourceFile]*authoredRegion{}
-  resolve := func(source, directory string) *authoredRegion {
-    target := program.GetSourceFile(sourceMapFileName(source, directory))
+  resolve := func(source string, directory shimtspath.RootedDirectoryPath) *authoredRegion {
+    name, rooted := shimtspath.TryRootedFilePathFromAbsolute(sourceMapFileName(source, directory))
+    if !rooted {
+      return nil
+    }
+    target := program.GetSourceFile(name)
     if target == nil {
       return nil
     }
     region, found := regions[target]
     if !found {
-      region = newAuthoredRegionWithText(target.FileName(), target.Text(), preamble, options.InlineSources.IsTrue())
+      region = newAuthoredRegionWithText(string(target.FileName()), target.Text(), preamble, options.InlineSources.IsTrue())
       regions[target] = region
     }
     return region
   }
   return func(fileName, text string) (string, error) {
-    if p.isBuildInfoOutput(fileName) {
+    output := shimtspath.ToRootedFilePath(fileName, program.GetCurrentDirectory())
+    if p.isBuildInfoOutput(output) {
       return text, nil
     }
     lower := strings.ToLower(fileName)
@@ -140,7 +141,7 @@ func (p *Program) NewSourceMapCorrector() func(fileName, text string) (string, e
     if !external && !isInlineSourceMapCarrier(lower) {
       return text, nil
     }
-    directory, known := directories[outputKey(fileName)]
+    directory, known := directories[shimcompiler.ProgramPathKey(program, output)]
     if !known {
       return "", fmt.Errorf("driver: source map output has no compiler source directory: %s", fileName)
     }
@@ -176,7 +177,7 @@ func (p *Program) NewSourceMapCorrector() func(fileName, text string) (string, e
 // sourceMapFileName reverses the pinned generator's raw file-URL spelling.
 // GetRelativePathToDirectoryOrUrl does not percent-encode source names, so a
 // literal '%' remains filename data and must not undergo URL unescaping.
-func sourceMapFileName(source, directory string) string {
+func sourceMapFileName(source string, directory shimtspath.RootedDirectoryPath) string {
   name := shimtspath.GetNormalizedAbsolutePath(source, directory)
   if strings.HasPrefix(name, "file:///") {
     drive := strings.TrimPrefix(name, "file:///")

package/go.mod

@@ -1,6 +1,6 @@
 module github.com/samchon/ttsc/packages/ttsc
 
-go 1.26
+go 1.27
 
 // Maintained shim sub-modules are resolved by these package-local replacements.
 // Their pinned typescript-go dependency is resolved through the Go module cache;
@@ -45,9 +45,9 @@ require (
 )
 
 require (
-	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260623181947-01eb4420fa68 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260708042240-2bd066d87f5b // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.21.0 // indirect
 	golang.org/x/text v0.38.0 // indirect

package/go.sum

@@ -1,11 +1,11 @@
-github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 h1:nxP4pPoyqOAgX8lYDFCfl3DyKeXErCvSvhcyzwGV9CE=
-github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/go-json-experiment/json v0.0.0-20260623181947-01eb4420fa68 h1:KZaTBSyshWX3MP5jukJcNSuXDQTO+rNpt0J564dX/eg=
+github.com/go-json-experiment/json v0.0.0-20260623181947-01eb4420fa68/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 h1:UUVrjTrD+7nkVvkJTjxwA5+SaZ5n1uyAffm2zX2gn+o=
-github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063/go.mod h1:s3yhRRZ7nzSZaiKicku520Tj9Mvewr9y2UtrvpwOmDE=
+github.com/microsoft/typescript-go v0.0.0-20260708042240-2bd066d87f5b h1:IgfPOv9pzPZ1sbyRHOKu3UCvhaTS0IyrkTcs6JLPqhY=
+github.com/microsoft/typescript-go v0.0.0-20260708042240-2bd066d87f5b/go.mod h1:gV4G6M8xxLNqQSRHiFOgKHlY+5YJgYPM6QwFLWllC+8=
 github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
 github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=

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(string(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(string(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(string(file), member, kind), nodeID(string(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(string(file), "Widget", NodeVariable), nodeID(string(file), target.name, target.kind), EdgeHeritage) {
+      t.Errorf("Widget lost heritage to %s", target.name)
+    }
+    if !hasEdge(g, nodeID(string(file), "Widget.render", NodeMethod), nodeID(string(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(string(file), item.member, NodeMethod), nodeID(string(file), "Widget", NodeVariable), item.kind) {
+      t.Errorf("%s lost its bound class identity", item.member)
+    }
+  }
+  if hasEdge(g, nodeID(string(file), "draw", NodeFunction), nodeID(string(file), "Other.render", NodeMethod), EdgeValueCall) ||
+    hasEdge(g, nodeID(string(file), "other", NodeFunction), nodeID(string(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(string(file), item.caller, NodeFunction), nodeID(string(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/assigned_implementations_of_declaration_file_symbols_leave_no_edge_source_test.go

@@ -74,8 +74,8 @@ patched = (message: string): void => {
     }
   }
 
-  module := moduleID(mainPath)
-  helper := nodeID(mainPath, "helper", NodeFunction)
+  module := moduleID(string(mainPath))
+  helper := nodeID(string(mainPath), "helper", NodeFunction)
   if !hasEdge(graph, module, helper, EdgeValueCall) {
     t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
   }

package/internal/graph/assigned_implementations_of_node_modules_symbols_leave_no_edge_source_test.go

@@ -83,8 +83,8 @@ patched = (message: string): void => {
     }
   }
 
-  module := moduleID(mainPath)
-  helper := nodeID(mainPath, "helper", NodeFunction)
+  module := moduleID(string(mainPath))
+  helper := nodeID(string(mainPath), "helper", NodeFunction)
   if !hasEdge(graph, module, helper, EdgeValueCall) {
     t.Fatalf("the assigned body's call to helper is not owned by the running module; edges: %v", graph.Edges)
   }