ttsc 0.33.1 → 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

@@ -89,16 +89,16 @@ export namespace Names {
     {"Names.read", "Names.Props.nested.deep", NodeVariable, EdgeValueAccess},
     {"Names.read", "Names.Widget.render", NodeMethod, EdgeValueCall},
   } {
-    target := nodeID(file, item.member, item.kind)
+    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(file, item.caller, NodeFunction), target, item.edge) {
+    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(file, member, kind), nodeID(file, "helper", NodeFunction), EdgeValueCall) {
+    if !hasEdge(g, nodeID(string(file), member, kind), nodeID(string(file), "helper", NodeFunction), EdgeValueCall) {
       t.Errorf("%s lost helper call", member)
     }
   }
@@ -106,10 +106,10 @@ export namespace Names {
     name string
     kind NodeKind
   }{{"Base", NodeClass}, {"Drawable", NodeInterface}} {
-    if !hasEdge(g, nodeID(file, "Widget", NodeVariable), nodeID(file, target.name, target.kind), EdgeHeritage) {
+    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(file, "Widget.render", NodeMethod), nodeID(file, target.name+".render", NodeMethod), EdgeMemberRelation) {
+    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)
     }
   }
@@ -117,19 +117,19 @@ export namespace Names {
     member string
     kind   EdgeKind
   }{{"Widget.create", EdgeValueCall}, {"Widget.identity", EdgeValueAccess}} {
-    if !hasEdge(g, nodeID(file, item.member, NodeMethod), nodeID(file, "Widget", NodeVariable), item.kind) {
+    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(file, "draw", NodeFunction), nodeID(file, "Other.render", NodeMethod), EdgeValueCall) ||
-    hasEdge(g, nodeID(file, "other", NodeFunction), nodeID(file, "Widget.render", NodeMethod), EdgeValueCall) {
+  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(file, item.caller, NodeFunction), nodeID(file, item.target, item.kind), EdgeValueCall) {
+    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)
     }
   }

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)
   }