ttsc 0.33.1 → 0.34.0

package/driver/program.go

@@ -150,7 +150,7 @@ func NewLintDiagnostic(
   }
   if file != nil {
     pos = lint.Pos()
-    d.File = file.FileName()
+    d.File = string(file.FileName())
     length := lint.Len()
     d.Start = &pos
     d.Length = &length
@@ -186,7 +186,10 @@ func (p *Program) SourceFile(filename string) *ast.SourceFile {
   // for an apply failure, and growing one would ripple through every caller.
   // `Diagnostics` reports it, and the emit path checks the error directly.
   _ = p.ApplyLinkedPlugins()
-  return p.TSProgram.GetSourceFile(filename)
+  if filename == "" {
+    return nil
+  }
+  return p.TSProgram.GetSourceFile(tspath.ToRootedFilePath(filename, p.TSProgram.GetCurrentDirectory()))
 }
 
 // String returns message alone without File, file/message without a positive
@@ -318,6 +321,9 @@ type Program struct {
 
   // Host is the compiler host for this generation.
   Host shimcompiler.CompilerHost
+  // hosts builds every generation's Host and owns the content-mapper processes
+  // those hosts share; Close releases it.
+  hosts *shimcompiler.ProjectHosts
 
   // FS is the input-observing filesystem, including any source preamble layer.
   FS            vfs.FS
@@ -390,22 +396,26 @@ type LoadProgramOptions struct {
   FS vfs.FS
 }
 
-// Close releases the checker pool lease acquired by LoadProgram.
+// Close releases the checker pool lease acquired by LoadProgram and, on the
+// TypeScript 7.1 target, stops the project's content-mapper processes. Its
+// error is the content mappers' close error.
 //
-// @evidence contracts/common.md#principled-implementation The recorded release callback returns the checker lease once and is cleared after release.
-// @evidence contracts/common.md#clear-and-simple-design Checker ownership has one cleanup operation instead of independent releases by each consumer.
-// @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup invokes the owned callback rather than patching the checker pool or fabricating success after another operation fails.
-// @evidence contracts/common.md#meaningful-documentation Native prose names the lease acquired by LoadProgram following the documentation skill.
-// @evidenceExclude contracts/portability.md#os-neutral-implementation Checker release is an in-process pool operation without native path or process representation.
-// @evidenceExclude contracts/performance.md#efficient-algorithms Releasing one recorded lease involves no input-processing algorithm.
-// @evidenceExclude contracts/performance.md#reuse-equivalent-work Pool lease cleanup does not determine whether compiler outputs may be reused.
-// @evidence contracts/performance.md#bound-retention-and-release-resources Program owns one checker lease, clears its release callback on Close and leaves facade memory lifetime to the caller; repeated Close does not release twice.
+// @evidence contracts/common.md#principled-implementation The recorded release callback returns the checker lease once and is cleared after release; the project hosts then close the mapper project and processes the Program's hosts shared.
+// @evidence contracts/common.md#clear-and-simple-design Checker and content-mapper ownership share one cleanup operation instead of independent releases by each consumer.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup invokes the owned callbacks rather than patching the checker pool, and returns the mapper close error instead of fabricating success.
+// @evidence contracts/common.md#meaningful-documentation Native prose names the lease and the mapper processes released and the error returned, following the documentation skill.
+// @evidence contracts/portability.md#os-neutral-implementation Checker release is in-process; stopping a mapper process goes through the shim's os/exec boundary.
+// @evidenceExclude contracts/performance.md#efficient-algorithms Releasing two recorded owners involves no input-processing algorithm.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work Cleanup does not determine whether compiler outputs may be reused.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Program owns one checker lease and its project hosts; Close clears both, so repeated Close releases neither twice, and leaves facade memory lifetime to the caller.
 func (p *Program) Close() error {
   if p.checkerRelease != nil {
     p.checkerRelease()
     p.checkerRelease = nil
   }
-  return nil
+  hosts := p.hosts
+  p.hosts = nil
+  return hosts.Close()
 }
 
 // ParseTSConfig parses a tsconfig.json file via tsgo's native JSONC parser.
@@ -443,14 +453,21 @@ func ParseTSConfig(fs vfs.FS, cwd, tsconfigPath string, host shimcompiler.Compil
 // config's own location survives. ttsc forwards exactly these resets to keep a
 // private build's outputs in one directory (`isolatedTsgoOutputArgs`).
 func parseTSConfig(fs vfs.FS, cwd, tsconfigPath string, host shimcompiler.CompilerHost, cliOptions *core.CompilerOptions, commandLine *tsoptions.ParsedCommandLine) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
-  resolved := tspath.ResolvePath(cwd, tsconfigPath)
+  directory, err := rootedWorkingDirectory(cwd)
+  if err != nil {
+    return nil, nil, err
+  }
+  if tsconfigPath == "" {
+    return nil, nil, fmt.Errorf("tsconfig not found: %s", string(directory))
+  }
+  resolved := tspath.ToRootedFilePath(tsconfigPath, directory)
   if !fs.FileExists(resolved) {
-    return nil, nil, fmt.Errorf("tsconfig not found: %s", resolved)
+    return nil, nil, fmt.Errorf("tsconfig not found: %s", string(resolved))
   }
   if cliOptions == nil {
     cliOptions = &core.CompilerOptions{}
   }
-  parsed, diags := tsoptions.GetParsedCommandLineOfConfigFile(resolved, cliOptions, tsoptions.CommandLineRawOptions(commandLine), host, nil)
+  parsed, diags := tsoptions.GetParsedCommandLineOfConfigFile(resolved, cliOptions, tsoptions.CommandLineRawOptions(commandLine), tsoptions.NewParseConfigHost(host.FS(), directory), nil)
   allDiags := diags
   if parsed != nil {
     // Read failures are returned separately; recoverable JSON syntax errors
@@ -486,11 +503,11 @@ func resolveTsgoArgs(explicit []string) ([]string, error) {
 // constructs its Program in-process rather than shelling out to `tsgo` — still
 // honors flags like `ttsc --strict`. Returns (nil, nil, nil) when there are no
 // forwarded flags.
-func parseTsgoArgs(args []string, host shimcompiler.CompilerHost) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
+func parseTsgoArgs(args []string, host shimcompiler.CompilerHost, cwd tspath.RootedDirectoryPath) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
   if len(args) == 0 {
     return nil, nil, nil
   }
-  cli := tsoptions.ParseCommandLine(args, host)
+  cli := tsoptions.ParseCommandLineAt(args, host.FS(), cwd)
   if cli == nil {
     return nil, nil, fmt.Errorf("driver: tsgo argument parser returned nil")
   }
@@ -531,11 +548,7 @@ func CreateProgramFromConfig(parsed *tsoptions.ParsedCommandLine, host shimcompi
     return nil, nil, fmt.Errorf("driver: nil parsed command line")
   }
   forceSingleChecker(parsed)
-  opts := shimcompiler.ProgramOptions{
-    Config:                      parsed,
-    Host:                        host,
-    UseSourceOfProjectReference: true,
-  }
+  opts := shimcompiler.NewProgramOptions(parsed, host, true)
   p := shimcompiler.NewProgram(opts)
   if p != nil {
     e2etrace.Program("program-construction", "driver-create", "constructor-returned", false, p)
@@ -583,6 +596,10 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
     }
   }
   cwd = tspath.ResolvePath(cwd)
+  directory, err := rootedWorkingDirectory(cwd)
+  if err != nil {
+    return nil, nil, err
+  }
   pluginState, err := loadLinkedPluginState(cwd, tsconfigPath)
   if err != nil {
     return nil, nil, err
@@ -616,14 +633,13 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
   if argumentCwd == "" && options.TsgoArgs == nil && len(tsgoArgs) != 0 {
     argumentCwd = os.Getenv(TsgoArgsCwdEnv)
   }
-  argumentHost := host
+  // Forwarded flags convert relative values against their own argv base; the
+  // host is cwd-less, so only the parser's directory changes.
+  argumentDirectory := directory
   if argumentCwd != "" {
-    argumentCwd = tspath.ResolvePath(cwd, argumentCwd)
-    if argumentCwd != cwd {
-      argumentHost = DefaultHost(argumentCwd, fs)
-    }
+    argumentDirectory = tspath.ToRootedDirectoryPath(argumentCwd, directory)
   }
-  commandLine, cliDiags, err := parseTsgoArgs(tsgoArgs, argumentHost)
+  commandLine, cliDiags, err := parseTsgoArgs(tsgoArgs, host, argumentDirectory)
   if err != nil {
     return nil, nil, err
   }
@@ -633,16 +649,24 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
 
   // Config identity is explicit; argument conversion uses the original argv
   // base, while the Program and linked plugin state retain their selected cwd.
-  selectedConfig := tspath.ResolvePath(cwd, tsconfigPath)
-  parsed, diags, err := parseTSConfig(fs, cwd, selectedConfig, argumentHost, commandLine.CompilerOptions(), commandLine)
+  semanticConfig, err := semanticConfigFile(options.SemanticConfigPath)
+  if err != nil {
+    return nil, nil, err
+  }
+  parsed, diags, err := parseTSConfig(fs, cwd, tsconfigPath, host, commandLine.CompilerOptions(), commandLine)
   if err != nil {
     return nil, nil, err
   }
   if len(diags) > 0 {
     return nil, diags, nil
   }
-  if err := applySemanticConfigPath(parsed, options.SemanticConfigPath); err != nil {
-    return nil, nil, err
+  if semanticConfig != "" {
+    if parsed, diags, err = parseSemanticConfig(fs, cwd, semanticConfig, host, parsed, commandLine); err != nil {
+      return nil, nil, err
+    }
+    if len(diags) > 0 {
+      return nil, diags, nil
+    }
   }
   if options.ForceNoEmit {
     forceNoEmit(parsed)
@@ -651,10 +675,14 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
     forceEmit(parsed)
   }
   if options.OutDir != "" {
-    overrideOutDir(cwd, parsed, options.OutDir)
+    overrideOutDir(directory, parsed, options.OutDir)
   }
   applyThreadingOptions(parsed, options.SingleThreaded, options.Checkers)
 
+  // The parsed project decides whether its content mappers run, so the
+  // Program's host is built only now, over the same filesystem.
+  hosts := shimcompiler.NewProjectHosts(parsed)
+  host = projectHost(hosts, cwd, fs)
   tsProgram, _, _ := CreateProgramFromConfig(parsed, host)
 
   checker, done := tsProgram.GetTypeChecker(context.Background())
@@ -664,6 +692,7 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
     Checker:        checker,
     checkerRelease: done,
     Host:           host,
+    hosts:          hosts,
     FS:             fs,
     inputObserver:  inputObserver,
     SourcePreamble: options.SourcePreamble,
@@ -673,16 +702,34 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
   return prog, nil, nil
 }
 
-func applySemanticConfigPath(parsed *tsoptions.ParsedCommandLine, semanticConfigPath string) error {
+// parseSemanticConfig makes the user-authored config the parsed project. A
+// generated wrapper extends it from a scratch directory to add a compiler
+// option overlay; TypeScript-Go anchors resolution, automatic type discovery
+// and the Program's current directory at the directory of the config file it
+// parsed, so the wrapper itself must not become the project. The wrapper's
+// merged options, which already carry the user config's own options, the
+// overlay and the command line, take command-line precedence over a fresh
+// parse of the user config; the command line's raw options keep its resets.
+func parseSemanticConfig(fs vfs.FS, cwd string, semanticConfig tspath.RootedFilePath, host shimcompiler.CompilerHost, wrapper *tsoptions.ParsedCommandLine, commandLine *tsoptions.ParsedCommandLine) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
+  caseSensitivity := vfs.CaseSensitivityOf(fs)
+  wrapperConfig := wrapper.CompilerOptions().ConfigFilePath
+  if wrapperConfig != "" && tspath.CompareFilePaths(caseSensitivity, wrapperConfig, semanticConfig) == 0 {
+    return wrapper, nil, nil
+  }
+  return parseTSConfig(fs, cwd, string(semanticConfig), host, wrapper.CompilerOptions().Clone(), commandLine)
+}
+
+// semanticConfigFile validates the user-authored config a generated wrapper
+// stands for; an empty path means the parsed config is its own semantic owner.
+func semanticConfigFile(semanticConfigPath string) (tspath.RootedFilePath, error) {
   configured := strings.TrimSpace(semanticConfigPath)
   if configured == "" {
-    return nil
+    return "", nil
   }
   if !filepath.IsAbs(configured) {
-    return fmt.Errorf("driver: semantic config path must be absolute: %s", configured)
+    return "", fmt.Errorf("driver: semantic config path must be absolute: %s", configured)
   }
-  parsed.ParsedConfig.CompilerOptions.ConfigFilePath = tspath.ResolvePath(configured)
-  return nil
+  return tspath.RootedFilePathFromAbsolute(configured), nil
 }
 
 // forceEmit clears noEmit and emitDeclarationOnly so the program always
@@ -700,8 +747,19 @@ func forceNoEmit(parsed *tsoptions.ParsedCommandLine) {
 
 // overrideOutDir resolves outDir against cwd and applies it to the parsed
 // config, replacing any outDir already set in tsconfig.json.
-func overrideOutDir(cwd string, parsed *tsoptions.ParsedCommandLine, outDir string) {
-  parsed.ParsedConfig.CompilerOptions.OutDir = tspath.ResolvePath(cwd, outDir)
+func overrideOutDir(cwd tspath.RootedDirectoryPath, parsed *tsoptions.ParsedCommandLine, outDir string) {
+  parsed.ParsedConfig.CompilerOptions.OutDir = tspath.ToRootedDirectoryPath(outDir, cwd)
+}
+
+// rootedWorkingDirectory converts the caller's working directory to the
+// rooted directory the compiler's command-line and tsconfig parsers resolve
+// against. A relative or empty directory has no such anchor and is an error.
+func rootedWorkingDirectory(cwd string) (tspath.RootedDirectoryPath, error) {
+  path, ok := tspath.TryRootedPathFromAbsolute(cwd)
+  if !ok {
+    return "", fmt.Errorf("driver: working directory must be absolute: %q", cwd)
+  }
+  return tspath.RootedDirectoryPathFromPath(path), nil
 }
 
 // applyThreadingOptions forwards the CLI threading knobs onto the parsed
@@ -734,12 +792,12 @@ type sourcePreambleFS struct {
   preamble string
 }
 
-func (fs sourcePreambleFS) ReadFile(filePath string) (string, bool) {
+func (fs sourcePreambleFS) ReadFile(filePath tspath.RootedFilePath) (string, bool) {
   contents, ok := fs.FS.ReadFile(filePath)
   if !ok {
     return contents, ok
   }
-  return ApplySourcePreambleToFile(filePath, contents, fs.preamble), true
+  return ApplySourcePreambleToFile(string(filePath), contents, fs.preamble), true
 }
 
 // isSourcePreambleTarget reports whether the preamble should be injected into
@@ -1062,14 +1120,7 @@ func (p *Program) diagnostics(files []*ast.SourceFile) []Diagnostic {
     )
   } else {
     for _, file := range files {
-      raw = append(raw, shimcompiler.GetDiagnosticsOfAnyProgram(
-        ctx,
-        p.TSProgram,
-        file,
-        false,
-        p.TSProgram.GetBindDiagnostics,
-        p.TSProgram.GetSemanticDiagnostics,
-      )...)
+      raw = append(raw, fileDiagnostics(ctx, p.TSProgram, file)...)
     }
   }
   raw = filterDiagnostics(raw)
@@ -1142,7 +1193,7 @@ func convertDiagnostics(in []*ast.Diagnostic) []Diagnostic {
 func convertDiagnostic(d *ast.Diagnostic) Diagnostic {
   diag := Diagnostic{Code: d.Code(), Message: d.String(), raw: d}
   if file := d.File(); file != nil {
-    diag.File = file.FileName()
+    diag.File = string(file.FileName())
     if pos := d.Pos(); pos >= 0 {
       length := d.Len()
       diag.Start = &pos

package/driver/resolution_candidates.go

@@ -4,9 +4,11 @@ import (
   "sort"
   "strings"
 
+  "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimtsoptions "github.com/microsoft/typescript-go/shim/tsoptions"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  shimvfs "github.com/microsoft/typescript-go/shim/vfs"
 )
 
 // ProgramResolutionInput is one reported lexical filesystem input from
@@ -93,7 +95,7 @@ func ObserveProgramResolutions(prog *Program, cwd string) ProgramResolutionObser
   if prog == nil || prog.TSProgram == nil || prog.FS == nil || prog.inputObserver == nil {
     return output
   }
-  caseSensitive := prog.FS.UseCaseSensitiveFileNames()
+  caseSensitivity := shimvfs.CaseSensitivityOf(prog.FS)
   tasks := shimcompiler.ProgramResolutionTasks(prog.TSProgram)
   sort.Slice(tasks, func(left, right int) bool {
     a, b := tasks[left], tasks[right]
@@ -116,7 +118,7 @@ func ObserveProgramResolutions(prog *Program, cwd string) ProgramResolutionObser
   })
 
   if !prog.TSProgram.Options().NoResolve.IsTrue() {
-    observeProgramPathReferences(prog, cwd, caseSensitive, &output)
+    observeProgramPathReferences(prog, cwd, caseSensitivity, &output)
   }
 
   // Automatic type discovery is a separate compiler operation that enumerates
@@ -125,7 +127,7 @@ func ObserveProgramResolutions(prog *Program, cwd string) ProgramResolutionObser
   // package invalidates a resident program without an importer edit.
   automatic := newInputObservationFS(prog.FS)
   shimcompiler.ReplayAutomaticTypeDirectiveDiscovery(prog.TSProgram, automatic)
-  output.Universal = appendResolutionPaths(output.Universal, cwd, automatic, nil, caseSensitive, &output.Inputs)
+  output.Universal = appendResolutionPaths(output.Universal, cwd, automatic, nil, caseSensitivity, &output.Inputs)
   prog.inputObserver.mergeFrom(automatic)
 
   for first := 0; first < len(tasks); {
@@ -143,18 +145,18 @@ func ObserveProgramResolutions(prog *Program, cwd string) ProgramResolutionObser
       // leave a successful resolution outside the graph; retain those targets
       // as resolver inputs instead of silently dropping them.
       if task.TargetFile != "" {
-        selected = append(selected, task.TargetFile)
+        selected = append(selected, string(task.TargetFile))
       }
     }
     owner := group[0]
     if owner.Universal {
-      output.Universal = appendResolutionPaths(output.Universal, cwd, replay, selected, caseSensitive, &output.Inputs)
+      output.Universal = appendResolutionPaths(output.Universal, cwd, replay, selected, caseSensitivity, &output.Inputs)
       if !matches {
         output.universalFailure = true
       }
     } else if owner.SourceFile != "" {
-      source := TransformOutputKey(cwd, owner.SourceFile)
-      output.Candidates[source] = appendResolutionPaths(output.Candidates[source], cwd, replay, selected, caseSensitive, &output.Inputs)
+      source := TransformOutputKey(cwd, string(owner.SourceFile))
+      output.Candidates[source] = appendResolutionPaths(output.Candidates[source], cwd, replay, selected, caseSensitivity, &output.Inputs)
       if !matches {
         output.Failures[source] = string(inputProofResolutionChanged)
       }
@@ -184,21 +186,25 @@ func sameResolutionTaskOwner(left, right shimcompiler.ProgramResolutionTask) boo
 // observeProgramPathReferences replays the file predicates for triple-slash
 // path references. These use the compiler's supported-extension list directly
 // rather than the module resolver cache covered by ProgramResolutionTasks.
-func observeProgramPathReferences(prog *Program, cwd string, caseSensitive bool, output *ProgramResolutionObservation) {
+func observeProgramPathReferences(prog *Program, cwd string, caseSensitivity shimtspath.CaseSensitivity, output *ProgramResolutionObservation) {
   supported := shimtsoptions.GetSupportedExtensions(prog.TSProgram.Options(), nil)
   supported = shimtsoptions.GetSupportedExtensionsWithJsonIfResolveJsonModule(prog.TSProgram.Options(), supported)
   for _, source := range prog.TSProgram.SourceFiles() {
-    if source == nil || source.FileName() == "" || strings.HasPrefix(source.FileName(), bundledScheme) {
+    if source == nil || source.FileName() == "" || strings.HasPrefix(string(source.FileName()), bundledScheme) {
       continue
     }
-    sourceKey := TransformOutputKey(cwd, source.FileName())
+    sourceKey := TransformOutputKey(cwd, string(source.FileName()))
     for _, reference := range source.ReferencedFiles {
       replay := newInputObservationFS(prog.FS)
       selected := []string(nil)
-      for _, candidate := range pathReferenceCandidates(source.FileName(), reference.FileName, prog.TSProgram.Options().AllowNonTsExtensions.IsTrue(), supported, caseSensitive) {
-        if replay.FileExists(candidate) {
-          if resident := prog.TSProgram.GetSourceFileForResolvedModule(candidate); resident != nil {
-            selected = []string{resident.FileName()}
+      for _, candidate := range pathReferenceCandidates(string(source.FileName()), reference.FileName, prog.TSProgram.Options().AllowNonTsExtensions.IsTrue(), supported, caseSensitivity) {
+        candidateFile, rooted := shimtspath.TryRootedFilePathFromAbsolute(candidate)
+        if !rooted {
+          continue
+        }
+        if replay.FileExists(candidateFile) {
+          if resident := residentSourceWithRedirect(prog.TSProgram, candidateFile); resident != nil {
+            selected = []string{string(resident.FileName())}
           }
           break
         }
@@ -207,30 +213,42 @@ func observeProgramPathReferences(prog *Program, cwd string, caseSensitive bool,
         // predicates so a later output appearance or source disappearance
         // invalidates the same resolution without turning either spelling into
         // a realized graph edge.
-        outputPath := shimtspath.ToPath(candidate, prog.TSProgram.GetCurrentDirectory(), caseSensitive)
-        redirect := prog.TSProgram.GetProjectReferenceFromOutputDts(outputPath)
+        redirect := prog.TSProgram.GetProjectReferenceFromOutputDts(shimcompiler.ProgramPathKey(prog.TSProgram, candidateFile))
         if redirect == nil || !replay.FileExists(redirect.Source) {
           continue
         }
         if resident := prog.TSProgram.GetSourceFile(redirect.Source); resident != nil {
-          selected = []string{resident.FileName()}
+          selected = []string{string(resident.FileName())}
         }
         break
       }
-      output.Candidates[sourceKey] = appendResolutionPaths(output.Candidates[sourceKey], cwd, replay, selected, caseSensitive, &output.Inputs)
+      output.Candidates[sourceKey] = appendResolutionPaths(output.Candidates[sourceKey], cwd, replay, selected, caseSensitivity, &output.Inputs)
       prog.inputObserver.mergeFrom(replay)
     }
   }
 }
 
-func pathReferenceCandidates(containingFile, reference string, allowNonTsExtensions bool, supported [][]string, caseSensitive bool) []string {
+// residentSourceWithRedirect is the Program's lookup of a resolved file: the
+// resident source at that name, else the source its project-reference
+// redirect loaded in its place.
+func residentSourceWithRedirect(program *shimcompiler.Program, file shimtspath.RootedFilePath) *ast.SourceFile {
+  if resident := program.GetSourceFile(file); resident != nil {
+    return resident
+  }
+  if redirect := program.GetParseFileRedirect(file); redirect != "" {
+    return program.GetSourceFile(redirect)
+  }
+  return nil
+}
+
+func pathReferenceCandidates(containingFile, reference string, allowNonTsExtensions bool, supported [][]string, caseSensitivity shimtspath.CaseSensitivity) []string {
   base := reference
   if !shimtspath.IsRootedDiskPath(base) {
     base = shimtspath.CombinePaths(shimtspath.GetDirectoryPath(containingFile), base)
   }
   base = shimtspath.NormalizePath(base)
   if shimtspath.HasExtension(base) {
-    canonicalBase := shimtspath.GetCanonicalFileName(base, caseSensitive)
+    canonicalBase := shimtspath.Canonicalize(caseSensitivity, base)
     if allowNonTsExtensions || supportedFileExtension(canonicalBase, supported) {
       return []string{base}
     }
@@ -282,18 +300,18 @@ func appendResolutionPaths(
   cwd string,
   observer *inputObservationFS,
   selected []string,
-  caseSensitive bool,
+  caseSensitivity shimtspath.CaseSensitivity,
   flat *[]ProgramResolutionInput,
 ) []string {
   for _, candidate := range observer.observedPaths() {
-    selectedPath := slicesContainResolutionPath(selected, candidate, caseSensitive)
-    identityOnly := selectedPath && observedResolutionPathHasDistinctIdentity(observer, candidate, caseSensitive)
+    selectedPath := slicesContainResolutionPath(selected, candidate, caseSensitivity)
+    identityOnly := selectedPath && observedResolutionPathHasDistinctIdentity(observer, candidate, caseSensitivity)
     if selectedPath && !identityOnly {
       continue
     }
     if !identityOnly {
       for _, target := range selected {
-        if observedResolutionAlias(observer, candidate, target, caseSensitive) {
+        if observedResolutionAlias(observer, candidate, target, caseSensitivity) {
           identityOnly = true
           break
         }
@@ -309,36 +327,36 @@ func appendResolutionPaths(
   return target
 }
 
-func observedResolutionPathHasDistinctIdentity(observer *inputObservationFS, candidate string, caseSensitive bool) bool {
+func observedResolutionPathHasDistinctIdentity(observer *inputObservationFS, candidate string, caseSensitivity shimtspath.CaseSensitivity) bool {
   if observer == nil || candidate == "" {
     return false
   }
   observation, failure := observer.predicateProof(candidate)
-  return failure == "" && observation.Realpath != nil && observation.Realpath.OK && !sameResolutionPath(observation.Realpath.Path, candidate, caseSensitive)
+  return failure == "" && observation.Realpath != nil && observation.Realpath.OK && !sameResolutionPath(observation.Realpath.Path, candidate, caseSensitivity)
 }
 
-func slicesContainResolutionPath(paths []string, candidate string, caseSensitive bool) bool {
+func slicesContainResolutionPath(paths []string, candidate string, caseSensitivity shimtspath.CaseSensitivity) bool {
   for _, path := range paths {
-    if sameResolutionPath(candidate, path, caseSensitive) {
+    if sameResolutionPath(candidate, path, caseSensitivity) {
       return true
     }
   }
   return false
 }
 
-func sameResolutionPath(left, right string, caseSensitive bool) bool {
+func sameResolutionPath(left, right string, caseSensitivity shimtspath.CaseSensitivity) bool {
   if left == "" || right == "" {
     return false
   }
-  return shimtspath.GetCanonicalFileName(shimtspath.NormalizePath(left), caseSensitive) == shimtspath.GetCanonicalFileName(shimtspath.NormalizePath(right), caseSensitive)
+  return shimtspath.Canonicalize(caseSensitivity, shimtspath.NormalizePath(left)) == shimtspath.Canonicalize(caseSensitivity, shimtspath.NormalizePath(right))
 }
 
-func observedResolutionAlias(observer *inputObservationFS, candidate, target string, caseSensitive bool) bool {
+func observedResolutionAlias(observer *inputObservationFS, candidate, target string, caseSensitivity shimtspath.CaseSensitivity) bool {
   if observer == nil || candidate == "" || target == "" {
     return false
   }
   observation, failure := observer.predicateProof(candidate)
-  return failure == "" && observation.Realpath != nil && observation.Realpath.OK && sameResolutionPath(observation.Realpath.Path, target, caseSensitive)
+  return failure == "" && observation.Realpath != nil && observation.Realpath.OK && sameResolutionPath(observation.Realpath.Path, target, caseSensitivity)
 }
 
 func compactResolutionInputs(inputs []ProgramResolutionInput) []ProgramResolutionInput {

package/driver/resolution_candidates_test.go

@@ -6,6 +6,10 @@ import (
   "path/filepath"
   "slices"
   "testing"
+
+  "github.com/microsoft/typescript-go/shim/core"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  shimvfs "github.com/microsoft/typescript-go/shim/vfs"
 )
 
 // TestTransformGraphReplaysCompilerResolutionSemantics loads authored native
@@ -14,8 +18,8 @@ import (
 // Required candidate membership is checked rather than an exact candidate set;
 // the same maintained compiler supplies the Program and resolution replay.
 //
-// @evidence contracts/testing.md#behavioral-verification Actual LoadProgram and NewTransformGraph expose the asserted package/import/suffix/reference candidate paths and type-root listing. Additional fixtures check JSON-reference admission, a noResolve target outside the Program, unbuilt project-reference resident versus nonresident edges, and explicit versus absent or relative semantic config selection.
-// @evidence contracts/testing.md#independent-expectations Required candidate paths, project-reference edge presence/absence, and selected config filenames are authored literals. The explicit wildcard type root contains exactly fixture-types and no files; independent native EvalSymlinks supplies its expected directory identity. Candidates are not checked for exact equality, and the uppercase JSON expectation uses the Program's filesystem case policy; this does not independently certify that policy or the compiler's full resolver semantics. Wildcard type enumeration is not claimed for an omitted types option.
+// @evidence contracts/testing.md#behavioral-verification Actual LoadProgram and NewTransformGraph expose the asserted package/import/suffix/reference candidate paths and type-root listing. Additional fixtures check JSON-reference admission, a noResolve target outside the Program, unbuilt project-reference resident versus nonresident edges, and explicit versus absent or relative semantic config selection; an explicit semantic config must also own the Program's current directory while the generated wrapper's strict overlay still applies.
+// @evidence contracts/testing.md#independent-expectations Required candidate paths, project-reference edge presence/absence, selected config filenames, the semantic project directory and the wrapper's authored strict option are authored literals. The explicit wildcard type root contains exactly fixture-types and no files; independent native EvalSymlinks supplies its expected directory identity. Candidates are not checked for exact equality, and the uppercase JSON expectation uses the Program's filesystem case policy; this does not independently certify that policy or the compiler's full resolver semantics. Wildcard type enumeration is not claimed for an omitted types option.
 // @evidence contracts/testing.md#distinguishing-cases resolveJsonModule false/true and conditional uppercase admission contrast; noResolve retains a successful target as a candidate. Project-reference source presence and output absence differ from realized edge membership. Explicit absolute semantic config, an unmarked wrapper despite ambient metadata, and a rejected relative semantic path exercise separate selection branches.
 // @evidence contracts/testing.md#execution-ownership This driver Go unit writes and cleans its own temporary projects, constructs maintained native compiler Programs in-process, and calls the owning graph operation. Each returned Program is closed; a restored empty linked-plugin manifest excludes ambient hooks, and no installed consumer or external compiler command is used. It does not substitute a literal-input-only aggregation test for this native compiler connection.
 func TestTransformGraphReplaysCompilerResolutionSemantics(t *testing.T) {
@@ -163,7 +167,7 @@ export const value = true;
       t.Fatalf("resolveJsonModule=%t JSON candidates = %v", resolveJSON, jsonReferenceGraph.Candidates[jsonReferenceSource])
     }
     containsUppercaseCandidate := slices.Contains(jsonReferenceGraph.Candidates[jsonReferenceSource], uppercaseJSONCandidate)
-    expectsUppercaseCandidate := resolveJSON && !jsonReferenceProgram.FS.UseCaseSensitiveFileNames()
+    expectsUppercaseCandidate := resolveJSON && !(shimvfs.CaseSensitivityOf(jsonReferenceProgram.FS) == shimtspath.CaseSensitive)
     if containsUppercaseCandidate != expectsUppercaseCandidate {
       t.Fatalf("resolveJsonModule=%t uppercase JSON candidates = %v", resolveJSON, jsonReferenceGraph.Candidates[jsonReferenceSource])
     }
@@ -340,9 +344,18 @@ export const parent = true;`,
     t.Fatalf("unexpected generated-wrapper diagnostics: %#v", semanticDiagnostics)
   }
   defer semanticProgram.Close()
-  if got := semanticProgram.TSProgram.Options().ConfigFilePath; got != filepath.ToSlash(semanticConfig) {
+  if got := semanticProgram.TSProgram.Options().ConfigFilePath; string(got) != filepath.ToSlash(semanticConfig) {
     t.Fatalf("generated wrapper semantic config = %q, want %q", got, filepath.ToSlash(semanticConfig))
   }
+  // The compiler anchors type discovery and its current directory at the
+  // parsed config's base directory, not ConfigFilePath. The user config must
+  // be the parsed project while the wrapper's overlay still applies.
+  if got := semanticProgram.TSProgram.GetCurrentDirectory(); string(got) != filepath.ToSlash(semanticRoot) {
+    t.Fatalf("generated wrapper base directory = %q, want %q", got, filepath.ToSlash(semanticRoot))
+  }
+  if got := semanticProgram.TSProgram.Options().Strict; got != core.TSTrue {
+    t.Fatalf("generated wrapper overlay strict = %v, want true", got)
+  }
   semanticGraph := NewTransformGraph(semanticProgram, semanticRoot)
   semanticTypeRoot := filepath.ToSlash(filepath.Join("node_modules", "@types"))
   if !slices.Contains(semanticGraph.ResolutionInputs, semanticTypeRoot) {
@@ -356,7 +369,7 @@ export const parent = true;`,
     t.Fatalf("unexpected unmarked-wrapper diagnostics: %#v", unmarkedDiagnostics)
   }
   defer unmarkedProgram.Close()
-  if got := unmarkedProgram.TSProgram.Options().ConfigFilePath; got != filepath.ToSlash(generatedConfig) {
+  if got := unmarkedProgram.TSProgram.Options().ConfigFilePath; string(got) != filepath.ToSlash(generatedConfig) {
     t.Fatalf("unmarked wrapper inherited ambient semantic config = %q, want %q", got, filepath.ToSlash(generatedConfig))
   }
   invalidProgram, _, err := LoadProgram(semanticRoot, generatedConfig, LoadProgramOptions{SemanticConfigPath: "relative.json"})