ttsc 0.33.0 → 0.34.0

package/driver/overlay.go

@@ -22,8 +22,8 @@ import (
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
 type OverlayFS struct {
   vfs.FS
-  caseSensitive bool
-  overrides     map[string]string
+  caseSensitivity shimtspath.CaseSensitivity
+  overrides       map[string]string
 }
 
 // NewOverlayFS returns an overlay over inner with no overrides set.
@@ -32,15 +32,15 @@ type OverlayFS struct {
 // @evidence contracts/common.md#clear-and-simple-design Construction initializes one map and captures the inner VFS in one owner.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Construction does not alter the inner object or inject sample file contents.
 // @evidence contracts/common.md#meaningful-documentation Native prose states the initially empty overlay following the documentation skill.
-// @evidence contracts/portability.md#os-neutral-implementation Construction captures inner.UseCaseSensitiveFileNames as its canonicalization policy; it performs no independent per-directory capability or physical-alias probe.
+// @evidence contracts/portability.md#os-neutral-implementation Construction captures inner.CaseSensitivity as its canonicalization policy; it performs no independent per-directory capability or physical-alias probe.
 // @evidence contracts/performance.md#bound-retention-and-release-resources The returned overlay keeps inner reachable and owns a fresh override map. Later distinct keys and content bytes have no configured cap or eviction; callers remove entries with Unset or release the overlay. Inner handles and caches remain owned by the supplied filesystem.
 // @evidence contracts/performance.md#efficient-algorithms Construction allocates one empty map and wrapper and queries the inner case policy once, without scanning source files or override populations. Any work performed by that supplied policy query belongs to this delegated call, not a universal constant-time guarantee.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work Each construction intentionally creates independent mutable override state; the function owns no cross-overlay sharing coordinator or cached constructor result.
 func NewOverlayFS(inner vfs.FS) *OverlayFS {
   return &OverlayFS{
-    FS:            inner,
-    caseSensitive: inner.UseCaseSensitiveFileNames(),
-    overrides:     map[string]string{},
+    FS:              inner,
+    caseSensitivity: vfs.CaseSensitivityOf(inner),
+    overrides:       map[string]string{},
   }
 }
 
@@ -48,7 +48,7 @@ func NewOverlayFS(inner vfs.FS) *OverlayFS {
 // It does not anchor relative paths to the compiler cwd or resolve physical
 // aliases; callers must use compatible spellings when registering and reading.
 func (o *OverlayFS) key(path string) string {
-  return shimtspath.GetCanonicalFileName(shimtspath.NormalizePath(path), o.caseSensitive)
+  return shimtspath.Canonicalize(o.caseSensitivity, shimtspath.NormalizePath(path))
 }
 
 // Set records an in-memory override for path.
@@ -106,8 +106,8 @@ func (o *OverlayFS) Unset(path string) {
 // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The wrapper adds no read cache or native handle ownership. Override strings remain owned by the overlay and caller; fallback temporary resources and retained read state belong to the supplied inner filesystem, not this adapter's release policy.
 // @evidence contracts/performance.md#efficient-algorithms Lookup processes path normalization/case/hash bytes before testing the override map. A hit returns stored text without scanning it; a miss adds the inner read's actual path, input-byte and decoding/cache costs, which are not universally fixed steps.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work The wrapper adds no completed/in-flight read coordinator or independent disk-content cache; inner reuse remains the supplied filesystem's policy.
-func (o *OverlayFS) ReadFile(path string) (string, bool) {
-  if content, ok := o.overrides[o.key(path)]; ok {
+func (o *OverlayFS) ReadFile(path shimtspath.RootedFilePath) (string, bool) {
+  if content, ok := o.overrides[o.key(string(path))]; ok {
     return content, true
   }
   return o.FS.ReadFile(path)
@@ -123,8 +123,8 @@ func (o *OverlayFS) ReadFile(path string) (string, bool) {
 // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The wrapper retains no new entries or native handles during the query. Existing overrides remain overlay-owned; any temporary handles or metadata caches populated by fallback belong to the supplied inner filesystem.
 // @evidence contracts/performance.md#efficient-algorithms Key normalization/case conversion and hashing process path bytes before one override lookup. Hits require no native query; misses add the supplied filesystem's existence-probe or metadata-cache work rather than a universal fixed cost.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work This wrapper owns no existence-query sharing coordinator or separate metadata cache; it reads current overrides and delegates inner reuse policy.
-func (o *OverlayFS) FileExists(path string) bool {
-  if _, ok := o.overrides[o.key(path)]; ok {
+func (o *OverlayFS) FileExists(path shimtspath.RootedFilePath) bool {
+  if _, ok := o.overrides[o.key(string(path))]; ok {
     return true
   }
   return o.FS.FileExists(path)

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