ttsc 0.33.0 → 0.34.0

package/driver/emit_plugin.go

@@ -7,6 +7,7 @@ import (
   "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -15,31 +16,32 @@ import (
 )
 
 // pluginEmitHost implements printer.EmitHost (and, structurally,
-// SourceFileMayBeEmittedHost + OutputPathsHost — their methods are a subset) by
-// delegating to the driver Program, exactly like tsgo's internal emitHost. It
-// carries the emit resolver from the program's single checker.
+// SourceFileMayBeEmittedHost, OutputPathsHost and, on TypeScript 7.1,
+// SourceMapHost — their methods are a subset) by delegating to the driver
+// Program, exactly like tsgo's internal emitHost. Its emit resolver comes from
+// the program's single checker, guarded to the program's original member
+// accesses. The methods whose names or types differ between compiler targets
+// live in target_ts70.go and target_ts71.go.
 type pluginEmitHost struct {
-  program      *shimcompiler.Program
-  emitResolver shimprinter.EmitResolver
+  program         *shimcompiler.Program
+  checker         *shimchecker.Checker
+  originalMembers map[*shimast.Node]struct{}
 }
 
 func (h *pluginEmitHost) Options() *shimcore.CompilerOptions { return h.program.Options() }
 func (h *pluginEmitHost) SourceFiles() []*shimast.SourceFile { return h.program.SourceFiles() }
-func (h *pluginEmitHost) UseCaseSensitiveFileNames() bool {
-  return h.program.UseCaseSensitiveFileNames()
+func (h *pluginEmitHost) CommonSourceDirectory() shimtspath.RootedDirectoryPath {
+  return h.program.CommonSourceDirectory()
+}
+func (h *pluginEmitHost) IsEmitBlocked(file shimtspath.RootedFilePath) bool {
+  return h.program.IsEmitBlocked(file)
 }
-func (h *pluginEmitHost) GetCurrentDirectory() string    { return h.program.GetCurrentDirectory() }
-func (h *pluginEmitHost) CommonSourceDirectory() string  { return h.program.CommonSourceDirectory() }
-func (h *pluginEmitHost) IsEmitBlocked(file string) bool { return h.program.IsEmitBlocked(file) }
-func (h *pluginEmitHost) WriteFile(fileName string, text string) error {
+func (h *pluginEmitHost) WriteFile(fileName shimtspath.RootedFilePath, text string) error {
   return h.program.Host().FS().WriteFile(fileName, text)
 }
 func (h *pluginEmitHost) GetEmitModuleFormatOfFile(file shimast.HasFileName) shimcore.ModuleKind {
   return h.program.GetEmitModuleFormatOfFile(file)
 }
-func (h *pluginEmitHost) GetEmitResolver() shimprinter.EmitResolver {
-  return h.emitResolver
-}
 
 // guardedEmitResolver only resolves member accesses from the program's input
 // trees. ParseNode follows original links but trusts the synthesized flag:
@@ -67,7 +69,7 @@ func collectOriginalMembers(node *shimast.Node, members map[*shimast.Node]struct
     return false
   })
 }
-func (h *pluginEmitHost) GetProjectReferenceFromSource(path shimtspath.Path) *shimtsoptions.SourceOutputAndProjectReference {
+func (h *pluginEmitHost) GetProjectReferenceFromSource(path shimtspath.PathKey) *shimtsoptions.SourceOutputAndProjectReference {
   return h.program.GetProjectReferenceFromSource(path)
 }
 func (h *pluginEmitHost) IsSourceFileFromExternalLibrary(file *shimast.SourceFile) bool {
@@ -79,8 +81,12 @@ func (h *pluginEmitHost) IsSourceFileFromExternalLibrary(file *shimast.SourceFil
 // used by builtin transforms; they do not make every arbitrary constructed tree
 // valid. Injected bindings must use the supported generated-name policy and
 // preserve the original links needed by the particular transformation.
-// Returning nil leaves the file unchanged. This is the AST-integration contract
-// that replaces text-splice: a plugin returns AST, not text. The shape mirrors a
+// Build returned nodes with ec.Factory, or with a factory created inside the
+// call. A package-global or retained factory shares one node arena across files
+// and Programs, so once distinct Programs emit at the same time its nodes race
+// and can print under another file. Returning nil leaves the file unchanged.
+// This is the AST-integration contract that replaces text-splice: a plugin
+// returns AST, not text. The shape mirrors a
 // classic source-file transformer, with EmitContext supplied on each call;
 // adapting an existing transformer still requires the native AST and context
 // APIs rather than only changing its function signature.
@@ -88,7 +94,7 @@ func (h *pluginEmitHost) IsSourceFileFromExternalLibrary(file *shimast.SourceFil
 // @evidence contracts/common.md#principled-implementation Generated AST identity belongs to the shared emit context, allowing builtin import and module transforms to interpret plugin nodes.
 // @evidence contracts/common.md#clear-and-simple-design A per-source callback returns an optional replacement; the host owns ordering and printing.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The supported AST factory and original links replace textual alias guesses or patched compiler methods.
-// @evidence contracts/common.md#meaningful-documentation Native prose specifies context identity, nil behavior, and source transformation following the documentation skill.
+// @evidence contracts/common.md#meaningful-documentation Native prose specifies context identity, the per-file factory requirement and its concurrency consequence, nil behavior, and source transformation following the documentation skill.
 // @evidenceExclude contracts/portability.md#os-neutral-implementation The callback signature defines AST work rather than native path or process operations.
 // @evidenceExclude contracts/performance.md#efficient-algorithms Concrete callbacks select their algorithms; the signature performs no traversal.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work The signature owns no shared-work coordinator.
@@ -239,7 +245,9 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
     }
     return p.pluginEmitDiagnostics("analysis-only emit", result.Diagnostics)
   }
-  if result := shimcompiler.HandleNoEmitOnError(context.Background(), p.TSProgram, nil); result != nil {
+  // noEmit returned above, so this applies exactly noEmitOnError's
+  // whole-program diagnostic gate.
+  if result := handleNoEmit(context.Background(), p.TSProgram); result != nil {
     return p.pluginEmitDiagnostics("pre-emit checking", result.Diagnostics)
   }
   hasTransform := false
@@ -251,15 +259,15 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   }
   if !hasTransform {
     correctSourceMap := p.NewSourceMapCorrector()
-    result, diagnostics, err := p.EmitAllRaw(func(fileName, text string, data *shimcompiler.WriteFileData) error {
-      corrected, err := correctSourceMap(fileName, text)
+    result, diagnostics, err := p.EmitAllRaw(func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
+      corrected, err := correctSourceMap(string(fileName), text)
       if err != nil {
         return err
       }
       if writeFile != nil {
         return writeFile(fileName, corrected, data)
       }
-      return DefaultWriteFile(fileName, corrected)
+      return DefaultWriteFile(string(fileName), corrected)
     })
     if err != nil || result == nil {
       return diagnostics, err
@@ -276,15 +284,15 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   for _, sf := range p.TSProgram.SourceFiles() {
     collectOriginalMembers(sf.AsNode(), members)
   }
-  host := &pluginEmitHost{program: p.TSProgram, emitResolver: guardedEmitResolver{p.Checker.GetEmitResolver(), members}}
+  host := &pluginEmitHost{program: p.TSProgram, checker: p.Checker, originalMembers: members}
 
   // noEmitOnError applies to the whole build. The JS lane runs before the
   // declaration lane, so defer callbacks until both have succeeded. Outside
   // that option keep upstream's emit-despite-errors behavior.
   output := newPluginEmitOutput(writeFile, options.NoEmitOnError.IsTrue())
   correctSourceMap := p.NewSourceMapCorrector()
-  for _, sf := range shimcompiler.GetSourceFilesToEmit(host, nil, false) {
-    paths := shimcompiler.GetOutputPathsFor(sf, options, host, false)
+  for _, sf := range shimcompiler.SourceFilesToEmit(host) {
+    paths := shimcompiler.OutputPathsFor(sf, options, host)
     if paths.JsFilePath() != "" && !p.outputEscapesOutDir(paths.JsFilePath()) {
       ec := shimprinter.NewEmitContext()
       out := sf
@@ -330,9 +338,7 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       // Marks accumulate on the checker and are never cleared, so marking one
       // fixed tree per file also stops a second emit on the same Program from
       // inheriting the first pass's plugin-tree marks.
-      for _, tr := range shimcompiler.GetScriptTransformers(ec, host, sf) {
-        out = tr.TransformSourceFile(out)
-      }
+      out = applyScriptTransformers(ec, host, sf, out)
       // Print through the source-map-aware helper for an external sourceMap or
       // an inlineSourceMap trailer, and an emitBOM leading mark: the hand-assembled
       // emit pipeline does not run tsgo's emitter, so everything printSourceFile
@@ -346,26 +352,24 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       // the external `.js.map` and an inline base64 map embedded in the JS.
       if p.SourcePreamble != "" {
         var err error
-        if printed.JS, err = correctSourceMap(paths.JsFilePath(), printed.JS); err != nil {
+        if printed.JS, err = correctSourceMap(string(paths.JsFilePath()), printed.JS); err != nil {
           return nil, err
         }
         if printed.MapPath != "" {
-          if printed.MapText, err = correctSourceMap(printed.MapPath, printed.MapText); err != nil {
+          if printed.MapText, err = correctSourceMap(string(printed.MapPath), printed.MapText); err != nil {
             return nil, err
           }
         }
       }
       // The emitter hands its writeFile callback a WriteFileData for the
-      // JavaScript and a nil one for the map (printSourceFile:
-      // `writeText(sourceMapFilePath, sourceMap, nil)`), so this lane does the
-      // same. See writePluginEmitOutput for what the struct carries here and
-      // why the remaining fields stay zero.
-      if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, &shimcompiler.WriteFileData{
-        SourceMapUrlPos: printed.SourceMapUrlPos,
-      }, output.write); err != nil {
+      // JavaScript and, for the map, nil on TypeScript 7.0 or one carrying only
+      // the emitted source file on 7.1 (printSourceFile's `writeText` call), so
+      // this lane does the same. See writePluginEmitOutput for what the struct
+      // carries here and why the remaining fields stay zero.
+      if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, scriptWriteFileData(sf, printed.SourceMapUrlPos), output.write); err != nil {
         return nil, fmt.Errorf("driver: native plugin JavaScript emit failed: %w", err)
       }
-      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, nil, output.write); err != nil {
+      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, sourceMapWriteFileData(sf), output.write); err != nil {
         return nil, fmt.Errorf("driver: native plugin source map emit failed: %w", err)
       }
     }
@@ -374,7 +378,7 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   // so it also runs for a JavaScript-only `incremental` / `composite` project
   // that has no declarations to write at all.
   if !options.GetEmitDeclarations() && !p.emitsBuildInfo() {
-    if result := shimcompiler.HandleNoEmitOnError(context.Background(), p.TSProgram, nil); result != nil {
+    if result := handleNoEmit(context.Background(), p.TSProgram); result != nil {
       return p.pluginEmitDiagnostics("JavaScript emit", result.Diagnostics)
     }
     return nil, output.flush()
@@ -398,7 +402,7 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
   var wfMu sync.Mutex
   result := p.emitProgram(shimcompiler.EmitOptions{
     EmitOnly: shimcompiler.EmitOnlyDts,
-    WriteFile: func(fileName string, text string, data *shimcompiler.WriteFileData) error {
+    WriteFile: func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
       wfMu.Lock()
       defer wfMu.Unlock()
       if p.outputEscapesOutDir(fileName) {
@@ -407,7 +411,7 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
         }
         return nil
       }
-      corrected, err := correctSourceMap(fileName, text)
+      corrected, err := correctSourceMap(string(fileName), text)
       if err != nil {
         return err
       }
@@ -435,6 +439,10 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
 //     when none was written. PrintFileWithSourceMap records it exactly where
 //     printSourceFile does, so a consumer that relocates or rewrites the trailer
 //     works the same on both lanes.
+//   - SourceFile, on TypeScript 7.1: the program source file the artifact was
+//     emitted from, the file as parsed rather than the transformed tree,
+//     exactly as the emitter's own field names its input file. The map carries
+//     only this; on 7.0, where the field does not exist, the map gets nil.
 //   - Diagnostics: always empty. The emitter's field carries its accumulated
 //     emitterDiagnostics, which on the JavaScript lane are its own write
 //     failures; here a write failure is returned as an `error` from
@@ -450,12 +458,12 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
 // Nothing on this lane reads the struct back afterwards: unlike tsgo's emitter,
 // EmitWithPluginTransformers builds no EmitResult, so there is no EmittedFiles
 // list for a callee-set SkippedDtsWrite to keep a file out of.
-func (p *Program) writePluginEmitOutput(fileName, text string, data *shimcompiler.WriteFileData, writeFile shimcompiler.WriteFile) error {
+func (p *Program) writePluginEmitOutput(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData, writeFile shimcompiler.WriteFile) error {
   if fileName == "" || p.outputEscapesOutDir(fileName) {
     return nil
   }
   if writeFile != nil {
     return writeFile(fileName, text, data)
   }
-  return DefaultWriteFile(fileName, text)
+  return DefaultWriteFile(string(fileName), text)
 }

package/driver/emit_plugin_output.go

@@ -6,6 +6,7 @@ import (
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // PluginEmitError reports compiler errors from a native plugin emit. The same
@@ -63,7 +64,7 @@ func (p *Program) pluginEmitDiagnostics(phase string, raw []*shimast.Diagnostic)
     Diagnostics:  diagnostics,
     Phase:        phase,
     Declarations: p.TSProgram.Options().GetEmitDeclarations(),
-    cwd:          p.TSProgram.GetCurrentDirectory(),
+    cwd:          string(p.TSProgram.GetCurrentDirectory()),
   }
 }
 
@@ -74,22 +75,22 @@ type pluginEmitOutput struct {
 }
 
 type pluginEmitFile struct {
-  name string
+  name shimtspath.RootedFilePath
   text string
   data *shimcompiler.WriteFileData
 }
 
 func newPluginEmitOutput(writeFile shimcompiler.WriteFile, buffered bool) *pluginEmitOutput {
   if writeFile == nil {
-    writeFile = func(name, text string, _ *shimcompiler.WriteFileData) error {
-      return DefaultWriteFile(name, text)
+    writeFile = func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+      return DefaultWriteFile(string(name), text)
     }
   }
   return &pluginEmitOutput{writeFile: writeFile, buffered: buffered}
 }
 
 // The caller serializes declaration writes; JavaScript and flush are serial.
-func (o *pluginEmitOutput) write(name, text string, data *shimcompiler.WriteFileData) error {
+func (o *pluginEmitOutput) write(name shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
   if !o.buffered {
     return o.writeFile(name, text, data)
   }

package/driver/emit_provenance.go

@@ -52,43 +52,40 @@ func (p *Program) NewEmitProvenanceRecorder(writeFile shimcompiler.WriteFile) (s
   program := p.TSProgram
   observer := p.inputObserver
   cwd := program.GetCurrentDirectory()
-  caseSensitive := program.UseCaseSensitiveFileNames()
+  caseSensitivity := shimcompiler.ProgramCaseSensitivity(program)
   nativePath := func(name string) string {
     return filepath.FromSlash(shimtspath.GetNormalizedAbsolutePath(name, cwd))
   }
   coordinateKey := func(name string) string {
-    return shimtspath.GetCanonicalFileName(
-      shimtspath.NormalizePath(nativePath(name)),
-      caseSensitive,
-    )
+    return shimtspath.Canonicalize(caseSensitivity, shimtspath.NormalizePath(nativePath(name)))
   }
   candidates := map[string][]string{}
   host := &pluginEmitHost{program: program}
-  for _, source := range shimcompiler.GetSourceFilesToEmit(host, nil, false) {
-    output := shimcompiler.GetOutputPathsFor(source, program.Options(), host, false).JsFilePath()
-    switch strings.ToLower(filepath.Ext(output)) {
+  for _, source := range shimcompiler.SourceFilesToEmit(host) {
+    output := shimcompiler.OutputPathsFor(source, program.Options(), host).JsFilePath()
+    switch strings.ToLower(filepath.Ext(string(output))) {
     case ".js", ".jsx", ".mjs", ".cjs":
-      key := coordinateKey(output)
-      candidates[key] = append(candidates[key], nativePath(source.FileName()))
+      key := coordinateKey(string(output))
+      candidates[key] = append(candidates[key], nativePath(string(source.FileName())))
     }
   }
   if writeFile == nil {
-    writeFile = func(name, text string, _ *shimcompiler.WriteFileData) error {
-      return DefaultWriteFile(name, text)
+    writeFile = func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+      return DefaultWriteFile(string(name), text)
     }
   }
   written := map[string]string{}
   var mu sync.Mutex
-  record := func(name, text string, data *shimcompiler.WriteFileData) error {
+  record := func(name shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
     mu.Lock()
     defer mu.Unlock()
     if err := writeFile(name, text, data); err != nil {
       return err
     }
     if data == nil || !data.SkippedDtsWrite {
-      switch strings.ToLower(filepath.Ext(name)) {
+      switch strings.ToLower(filepath.Ext(string(name))) {
       case ".js", ".jsx", ".mjs", ".cjs":
-        written[nativePath(name)] = coordinateKey(name)
+        written[nativePath(string(name))] = coordinateKey(string(name))
       }
     }
     return nil

package/driver/graph.go

@@ -103,10 +103,10 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
   }
   for _, file := range prog.TSProgram.SourceFiles() {
     fileName := file.FileName()
-    if strings.HasPrefix(fileName, bundledScheme) {
+    if strings.HasPrefix(string(fileName), bundledScheme) {
       continue
     }
-    key := TransformOutputKey(cwd, fileName)
+    key := TransformOutputKey(cwd, string(fileName))
     if shimcompiler.FileAffectsGlobalScope(file) {
       graph.Globals = append(graph.Globals, key)
     }
@@ -216,17 +216,17 @@ func referenceTargets(prog *Program, cwd string, file *ast.SourceFile) []string
   paths := shimcompiler.GetReferencedFilePaths(prog.TSProgram, file)
   targets := make([]string, 0, len(paths))
   for _, referencedPath := range paths {
-    // Referenced paths are case-canonicalized tspath.Path values; recover the
+    // Referenced paths are case-canonicalized tspath.PathKey values; recover the
     // resident source and its real spelling from the Program. The incremental
     // helper can retain a raw extensionless project-reference directive even
     // when no corresponding source became resident. That spelling is a
     // resolver candidate, not a realized graph edge, and has no compiler-time
     // content proof.
-    resolved := prog.TSProgram.GetSourceFileByPath(shimtspath.Path(referencedPath))
-    if resolved == nil || resolved == file || strings.HasPrefix(resolved.FileName(), bundledScheme) {
+    resolved := prog.TSProgram.GetSourceFileByPath(shimtspath.PathKey(referencedPath))
+    if resolved == nil || resolved == file || strings.HasPrefix(string(resolved.FileName()), bundledScheme) {
       continue
     }
-    targets = append(targets, TransformOutputKey(cwd, resolved.FileName()))
+    targets = append(targets, TransformOutputKey(cwd, string(resolved.FileName())))
   }
   sort.Strings(targets)
   return targets
@@ -241,10 +241,10 @@ func configChain(prog *Program, cwd string) []string {
     return configs
   }
   if source := parsed.ConfigFile.SourceFile; source != nil {
-    configs = append(configs, TransformOutputKey(cwd, source.FileName()))
+    configs = append(configs, TransformOutputKey(cwd, string(source.FileName())))
   }
   for _, extended := range parsed.ExtendedSourceFiles() {
-    configs = append(configs, TransformOutputKey(cwd, extended))
+    configs = append(configs, TransformOutputKey(cwd, string(extended)))
   }
   return configs
 }

package/driver/host.go

@@ -12,6 +12,7 @@ package driver
 import (
   "github.com/microsoft/typescript-go/shim/bundled"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/microsoft/typescript-go/shim/vfs"
   "github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
   "github.com/microsoft/typescript-go/shim/vfs/osvfs"
@@ -34,21 +35,30 @@ func DefaultFS() vfs.FS {
   return bundled.WrapFS(cachedvfs.From(osvfs.FS()))
 }
 
-// DefaultHost returns a CompilerHost anchored at cwd that can find tsgo's
-// bundled library files via `bundled.LibPath()`.
+// DefaultHost returns a CompilerHost over fs that can find tsgo's bundled
+// library files via `bundled.LibPath()`. On the TypeScript 7.0 target the host
+// carries cwd as the Program's working directory; on 7.1 the parsed command
+// line's base directory anchors a Program, and cwd is unused.
 // The constructor retains the supplied cwd and FS without independently
 // normalizing or probing that anchor. In noembed builds the native library
 // provider initializes a process-wide disk location, which can perform native
 // queries or panic if its required library layout is unavailable.
 //
-// @evidence contracts/common.md#principled-implementation The supplied FS and cwd are passed to the upstream CompilerHost with the matching bundled-library location.
+// @evidence contracts/common.md#principled-implementation The supplied FS and cwd are passed to the target's upstream CompilerHost constructor through shimcompiler.NewHost with the matching bundled-library location.
 // @evidence contracts/common.md#clear-and-simple-design Host construction stays in one adapter used by initial and incremental program creation.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The supported CompilerHost constructor owns behavior without an injected foreign-method replacement.
-// @evidence contracts/common.md#meaningful-documentation Native prose names project anchoring and bundled library lookup under documentation-skill guidance.
+// @evidence contracts/common.md#meaningful-documentation Native prose names each target's use of cwd and bundled library lookup under documentation-skill guidance.
 // @evidence contracts/portability.md#os-neutral-implementation The host uses the supplied filesystem's native capabilities and upstream path handling rather than hardcoded OS path rules.
 // @evidence contracts/performance.md#bound-retention-and-release-resources The new host transfers its cwd/library strings and supplied FS reference to the caller; keeping it reachable also keeps that FS stack and its caches reachable. The factory adds no separate host cache, handle or release operation.
 // @evidence contracts/performance.md#efficient-algorithms Host allocation initializes fixed fields; embedded library location is a constant, while first noembed location initialization can query executable/realpath/library metadata under the native provider's once cache. This constructor does not parse source files, but delegated location work is not universally a fixed field assignment.
 // @evidenceExclude contracts/performance.md#reuse-equivalent-work Each returned host retains its supplied cwd/FS without a driver-owned cache or request coordinator; the native library provider owns any process-wide location sharing.
 func DefaultHost(cwd string, fs vfs.FS) shimcompiler.CompilerHost {
-  return shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
+  return shimcompiler.NewHost(shimtspath.RootedDirectoryPath(cwd), fs, shimtspath.RootedDirectoryPath(bundled.LibPath()))
+}
+
+// projectHost is DefaultHost for a Program built from a parsed project: on the
+// TypeScript 7.1 target, hosts transforms the project's content-mapped files
+// through its content mappers. A nil hosts yields DefaultHost's host.
+func projectHost(hosts *shimcompiler.ProjectHosts, cwd string, fs vfs.FS) shimcompiler.CompilerHost {
+  return hosts.Host(shimtspath.RootedDirectoryPath(cwd), fs, shimtspath.RootedDirectoryPath(bundled.LibPath()))
 }

package/driver/input_observation.go

@@ -142,7 +142,7 @@ type observedInput struct {
 // of attaching post-compile disk hashes to an earlier result.
 type inputObservationFS struct {
   vfs.FS
-  caseSensitive        bool
+  caseSensitivity      shimtspath.CaseSensitivity
   mu                   sync.Mutex
   observations         map[string]observedInput
   observationOrder     []string
@@ -152,14 +152,15 @@ type inputObservationFS struct {
 func newInputObservationFS(inner vfs.FS) *inputObservationFS {
   return &inputObservationFS{
     FS:                   inner,
-    caseSensitive:        inner.UseCaseSensitiveFileNames(),
+    caseSensitivity:      vfs.CaseSensitivityOf(inner),
     observations:         map[string]observedInput{},
     observationSpellings: map[string]string{},
   }
 }
 
-func (fs *inputObservationFS) FileExists(path string) bool {
-  exists := fs.FS.FileExists(path)
+func (fs *inputObservationFS) FileExists(file shimtspath.RootedFilePath) bool {
+  exists := fs.FS.FileExists(file)
+  path := shimtspath.RootedPath(file)
   proof := TransformInputObservation{FileExists: boolPointer(exists)}
   if exists {
     // Existence participates in resolution, but only ReadFile returns bytes
@@ -171,8 +172,9 @@ func (fs *inputObservationFS) FileExists(path string) bool {
   return exists
 }
 
-func (fs *inputObservationFS) ReadFile(path string) (string, bool) {
-  contents, ok := fs.FS.ReadFile(path)
+func (fs *inputObservationFS) ReadFile(file shimtspath.RootedFilePath) (string, bool) {
+  contents, ok := fs.FS.ReadFile(file)
+  path := shimtspath.RootedPath(file)
   if ok {
     digest := sha256.Sum256([]byte(contents))
     hash := hex.EncodeToString(digest[:])
@@ -192,8 +194,9 @@ func (fs *inputObservationFS) ReadFile(path string) (string, bool) {
   return contents, ok
 }
 
-func (fs *inputObservationFS) DirectoryExists(path string) bool {
-  exists := fs.FS.DirectoryExists(path)
+func (fs *inputObservationFS) DirectoryExists(directory shimtspath.RootedDirectoryPath) bool {
+  exists := fs.FS.DirectoryExists(directory)
+  path := shimtspath.RootedPath(directory)
   proof := TransformInputObservation{DirectoryExists: boolPointer(exists)}
   if exists {
     proof.Realpath = fs.currentRealpath(path)
@@ -202,9 +205,9 @@ func (fs *inputObservationFS) DirectoryExists(path string) bool {
   return exists
 }
 
-func (fs *inputObservationFS) GetAccessibleEntries(path string) vfs.Entries {
-  entries := fs.FS.GetAccessibleEntries(path)
-  fs.observe(path, observedInput{
+func (fs *inputObservationFS) GetAccessibleEntries(directory shimtspath.RootedDirectoryPath) vfs.Entries {
+  entries := fs.FS.GetAccessibleEntries(directory)
+  fs.observe(shimtspath.RootedPath(directory), observedInput{
     proof: TransformInputObservation{
       AccessibleEntries: &TransformInputEntriesObservation{
         Directories: append([]string{}, entries.Directories...),
@@ -215,7 +218,7 @@ func (fs *inputObservationFS) GetAccessibleEntries(path string) vfs.Entries {
   return entries
 }
 
-func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
+func (fs *inputObservationFS) Stat(path shimtspath.RootedPath) vfs.FileInfo {
   info := fs.FS.Stat(path)
   kind := "missing"
   if info == nil {
@@ -242,16 +245,16 @@ func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
   return info
 }
 
-func (fs *inputObservationFS) Realpath(path string) string {
+func (fs *inputObservationFS) Realpath(path shimtspath.RootedPath) shimtspath.RootedPath {
   realpath := fs.FS.Realpath(path)
   fs.observe(path, observedInput{
-    proof: TransformInputObservation{Realpath: realpathObservation(realpath)},
+    proof: TransformInputObservation{Realpath: realpathObservation(string(realpath))},
   })
   return realpath
 }
 
-func (fs *inputObservationFS) currentRealpath(path string) *TransformInputRealpathObservation {
-  return realpathObservation(fs.FS.Realpath(path))
+func (fs *inputObservationFS) currentRealpath(path shimtspath.RootedPath) *TransformInputRealpathObservation {
+  return realpathObservation(string(fs.FS.Realpath(path)))
 }
 
 func realpathObservation(realpath string) *TransformInputRealpathObservation {
@@ -272,13 +275,11 @@ func (fs *inputObservationFS) observationKey(path string) string {
   if !filepath.IsAbs(path) {
     return ""
   }
-  return shimtspath.GetCanonicalFileName(
-    shimtspath.NormalizePath(path),
-    fs.caseSensitive,
-  )
+  return shimtspath.Canonicalize(fs.caseSensitivity, shimtspath.NormalizePath(path))
 }
 
-func (fs *inputObservationFS) observe(path string, next observedInput) {
+func (fs *inputObservationFS) observe(rooted shimtspath.RootedPath, next observedInput) {
+  path := string(rooted)
   key := fs.observationKey(path)
   if key == "" {
     return

package/driver/input_observation_test.go

@@ -9,6 +9,7 @@ import (
   "runtime"
   "testing"
 
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/samchon/ttsc/packages/ttsc/driver/windowsjunction"
 )
 
@@ -23,13 +24,13 @@ func TestInputObservationFSRejectsRestoredContent(t *testing.T) {
     t.Fatal(err)
   }
   observed := newInputObservationFS(DefaultFS())
-  if contents, ok := observed.ReadFile(file); !ok || contents != "A" {
+  if contents, ok := observed.ReadFile(shimtspath.RootedFilePathFromAbsolute(file)); !ok || contents != "A" {
     t.Fatalf("first read = %q, %v", contents, ok)
   }
   if err := os.WriteFile(file, []byte("B"), 0o644); err != nil {
     t.Fatal(err)
   }
-  if contents, ok := observed.ReadFile(file); !ok || contents != "B" {
+  if contents, ok := observed.ReadFile(shimtspath.RootedFilePathFromAbsolute(file)); !ok || contents != "B" {
     t.Fatalf("second read = %q, %v", contents, ok)
   }
   if err := os.WriteFile(file, []byte("A"), 0o644); err != nil {
@@ -53,16 +54,16 @@ func TestInputObservationFSProvesReadBytesAndMissingCandidates(t *testing.T) {
     t.Fatal(err)
   }
   observed := newInputObservationFS(DefaultFS())
-  if !observed.FileExists(file) {
+  if !observed.FileExists(shimtspath.RootedFilePathFromAbsolute(file)) {
     t.Fatal("selected file was not found")
   }
   if _, _, failure := observed.proof(file); failure != inputProofContentUnavailable {
     t.Fatalf("existence-only proof failure = %q, want %q", failure, inputProofContentUnavailable)
   }
-  if _, ok := observed.ReadFile(file); !ok {
+  if _, ok := observed.ReadFile(shimtspath.RootedFilePathFromAbsolute(file)); !ok {
     t.Fatal("selected file was not read")
   }
-  if observed.FileExists(missing) {
+  if observed.FileExists(shimtspath.RootedFilePathFromAbsolute(missing)) {
     t.Fatal("missing candidate unexpectedly exists")
   }
 
@@ -109,10 +110,10 @@ func testInputObservationFSKeepsFileAndDirectoryPredicatesIndependent(t *testing
     t.Fatal(err)
   }
   observed := newInputObservationFS(DefaultFS())
-  if observed.FileExists(directory) {
+  if observed.FileExists(shimtspath.RootedFilePathFromAbsolute(directory)) {
     t.Fatal("directory unexpectedly satisfied FileExists")
   }
-  if !observed.DirectoryExists(directory) {
+  if !observed.DirectoryExists(shimtspath.RootedDirectoryPathFromAbsolute(directory)) {
     t.Fatal("directory did not satisfy DirectoryExists")
   }
 
@@ -310,7 +311,7 @@ func TestInputObservationFSHashesCompilerDecodedText(t *testing.T) {
     t.Fatal(err)
   }
   observed := newInputObservationFS(DefaultFS())
-  contents, ok := observed.ReadFile(file)
+  contents, ok := observed.ReadFile(shimtspath.RootedFilePathFromAbsolute(file))
   if !ok || contents != text {
     t.Fatalf("compiler read = %q, %v; want decoded text", contents, ok)
   }
@@ -349,10 +350,10 @@ func TestInputObservationFSJoinsSelectedAliasProbeToPhysicalRead(t *testing.T) {
   }
   lexical := filepath.Join(alias, "value.js")
   observed := newInputObservationFS(DefaultFS())
-  if !observed.FileExists(lexical) {
+  if !observed.FileExists(shimtspath.RootedFilePathFromAbsolute(lexical)) {
     t.Fatal("selected lexical alias was not found")
   }
-  if _, ok := observed.ReadFile(physical); !ok {
+  if _, ok := observed.ReadFile(shimtspath.RootedFilePathFromAbsolute(physical)); !ok {
     t.Fatal("selected physical source was not read")
   }