ttsc 0.33.1 → 0.34.0

package/cmd/ttscgraph/serve_shards_delete_removed_source_test.go

@@ -40,7 +40,7 @@ func TestServeShardsDeleteRemovedSource(t *testing.T) {
   }
   removedKeyFile := removedSource.FileName()
   keepKeyFile := keepSource.FileName()
-  removedKey := session.graphStore.sourceKeys[removedKeyFile]
+  removedKey := session.graphStore.sourceKeys[string(removedKeyFile)]
   if removedKey == "" {
     t.Fatal("initial generation omitted removable source shard")
   }
@@ -58,10 +58,10 @@ func TestServeShardsDeleteRemovedSource(t *testing.T) {
   if !containsString(replacement.Deletes, removedKey) {
     t.Fatalf("replacement did not delete removed source shard %q: %v", removedKey, replacement.Deletes)
   }
-  if _, exists := session.graphStore.sourceKeys[removedKeyFile]; exists {
+  if _, exists := session.graphStore.sourceKeys[string(removedKeyFile)]; exists {
     t.Fatal("committed store retained removed source identity")
   }
-  if session.graphStore.sourceKeys[keepKeyFile] == "" {
+  if session.graphStore.sourceKeys[string(keepKeyFile)] == "" {
     t.Fatal("replacement generation dropped remaining source")
   }
 }

package/cmd/ttscgraph/serve_shards_prune_unreferenced_external_endpoints_test.go

@@ -39,7 +39,7 @@ func TestServeShardsPruneUnreferencedExternalEndpoints(t *testing.T) {
   if source == nil {
     t.Fatal("fixture source was absent from resident program")
   }
-  sourceKey := session.graphStore.sourceKeys[source.FileName()]
+  sourceKey := session.graphStore.sourceKeys[string(source.FileName())]
   if sourceKey == "" || len(session.graphStore.sourceExternal[sourceKey]) != 1 {
     t.Fatalf("fixture source must own one external endpoint: key=%q targets=%v", sourceKey, session.graphStore.sourceExternal[sourceKey])
   }

package/cmd/ttscgraph/serve_shards_publish_created_source_test.go

@@ -48,7 +48,7 @@ func TestServeShardsPublishCreatedSource(t *testing.T) {
     t.Fatal("fixture source was absent from resident program")
   }
   consumerKeyFile := consumerSource.FileName()
-  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  initialConsumerKey := session.graphStore.sourceKeys[string(consumerKeyFile)]
   if initialConsumerKey == "" {
     t.Fatal("initial generation omitted the dependent source shard")
   }
@@ -67,7 +67,7 @@ func TestServeShardsPublishCreatedSource(t *testing.T) {
   if createdSource == nil {
     t.Fatal("created source did not enter the resident program")
   }
-  createdKey := session.graphStore.sourceKeys[createdSource.FileName()]
+  createdKey := session.graphStore.sourceKeys[string(createdSource.FileName())]
   if createdKey == "" {
     t.Fatal("created source did not acquire a committed shard identity")
   }
@@ -76,7 +76,7 @@ func TestServeShardsPublishCreatedSource(t *testing.T) {
   }
   // The unchanged consumer text must acquire a different published shard key;
   // the call-edge contents are not independently checked here.
-  nextConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  nextConsumerKey := session.graphStore.sourceKeys[string(consumerKeyFile)]
   if nextConsumerKey == "" || nextConsumerKey == initialConsumerKey {
     t.Fatalf("dependent shard identity %q survived a newly resolved import", nextConsumerKey)
   }

package/cmd/ttscgraph/serve_shards_refresh_cross_file_implementation_test.go

@@ -43,7 +43,7 @@ func TestServeShardsRefreshCrossFileImplementation(t *testing.T) {
   if serviceSource == nil {
     t.Fatal("service source was absent from resident program")
   }
-  serviceKey := session.graphStore.sourceKeys[serviceSource.FileName()]
+  serviceKey := session.graphStore.sourceKeys[string(serviceSource.FileName())]
   initialService, exists := session.graphStore.shards[serviceKey]
   if serviceKey == "" || !exists || initialService.digest == "" {
     t.Fatal("initial Service shard has no committed identity or digest")
@@ -73,7 +73,7 @@ func TestServeShardsRefreshCrossFileImplementation(t *testing.T) {
   if session.graphStore.shards[serviceKey].digest == before {
     t.Fatal("declaration shard retained its cross-file implementation evidence")
   }
-  currentServiceKey := session.graphStore.sourceKeys[serviceSource.FileName()]
+  currentServiceKey := session.graphStore.sourceKeys[string(serviceSource.FileName())]
   currentService, exists := session.graphStore.shards[currentServiceKey]
   if currentServiceKey == "" || !exists || currentService.digest == "" || currentService.digest == before {
     t.Fatalf("current Service shard was not replaced with a changed digest: key=%q shard=%#v", currentServiceKey, currentService)

package/cmd/ttscgraph/serve_shards_refresh_dependent_diagnostics_test.go

@@ -42,7 +42,7 @@ func TestServeShardsRefreshDependentDiagnostics(t *testing.T) {
   if consumerSource == nil {
     t.Fatal("consumer source was absent from resident program")
   }
-  consumerKey := session.graphStore.sourceKeys[consumerSource.FileName()]
+  consumerKey := session.graphStore.sourceKeys[string(consumerSource.FileName())]
   initialConsumer, exists := session.graphStore.shards[consumerKey]
   if consumerKey == "" || !exists || initialConsumer.digest == "" {
     t.Fatal("initial consumer shard has no committed identity or digest")
@@ -90,8 +90,8 @@ func TestServeShardsRefreshDependentDiagnostics(t *testing.T) {
   valueKeyFile := session.compiler.Program().SourceFile(value).FileName()
   consumerKeyFile := consumerSource.FileName()
   if len(session.graphStore.extractedFiles) != 2 ||
-    session.graphStore.extractedFiles[0] != consumerKeyFile ||
-    session.graphStore.extractedFiles[1] != valueKeyFile {
+    session.graphStore.extractedFiles[0] != string(consumerKeyFile) ||
+    session.graphStore.extractedFiles[1] != string(valueKeyFile) {
     t.Fatalf(
       "public API edit extracted %v, want reverse closure [%s %s]",
       session.graphStore.extractedFiles,

package/cmd/ttscgraph/serve_shards_rename_moves_source_identity_test.go

@@ -52,8 +52,8 @@ func TestServeShardsRenameMovesSourceIdentity(t *testing.T) {
   }
   originalKeyFile := originalSource.FileName()
   consumerKeyFile := consumerSource.FileName()
-  originalKey := session.graphStore.sourceKeys[originalKeyFile]
-  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  originalKey := session.graphStore.sourceKeys[string(originalKeyFile)]
+  initialConsumerKey := session.graphStore.sourceKeys[string(consumerKeyFile)]
   if originalKey == "" || initialConsumerKey == "" {
     t.Fatal("initial generation omitted a fixture source shard")
   }
@@ -74,14 +74,14 @@ func TestServeShardsRenameMovesSourceIdentity(t *testing.T) {
   if !containsString(next.Deletes, originalKey) {
     t.Fatalf("rename did not delete the superseded shard %q: %v", originalKey, next.Deletes)
   }
-  if _, exists := session.graphStore.sourceKeys[originalKeyFile]; exists {
+  if _, exists := session.graphStore.sourceKeys[string(originalKeyFile)]; exists {
     t.Fatal("committed store retained the pre-rename source identity")
   }
   renamedSource := session.compiler.Program().SourceFile(renamed)
   if renamedSource == nil {
     t.Fatal("renamed source did not enter the resident program")
   }
-  renamedKey := session.graphStore.sourceKeys[renamedSource.FileName()]
+  renamedKey := session.graphStore.sourceKeys[string(renamedSource.FileName())]
   if renamedKey == "" {
     t.Fatal("renamed source did not acquire a committed shard identity")
   }
@@ -91,7 +91,7 @@ func TestServeShardsRenameMovesSourceIdentity(t *testing.T) {
   if !containsUpsertedShardKey(next, renamedKey) {
     t.Fatalf("generation did not publish the renamed source shard %q", renamedKey)
   }
-  nextConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
+  nextConsumerKey := session.graphStore.sourceKeys[string(consumerKeyFile)]
   if nextConsumerKey == "" || nextConsumerKey == initialConsumerKey {
     t.Fatalf("dependent shard identity %q survived a repointed import", nextConsumerKey)
   }

package/cmd/ttscgraph/serve_shards_reuse_unaffected_sources_test.go

@@ -55,16 +55,16 @@ func TestServeShardsReuseUnaffectedSources(t *testing.T) {
   valueKeyFile := valueSource.FileName()
   consumerKeyFile := consumerSource.FileName()
   unrelatedKeyFile := unrelatedSource.FileName()
-  initialValueKey := session.graphStore.sourceKeys[valueKeyFile]
-  initialConsumerKey := session.graphStore.sourceKeys[consumerKeyFile]
-  initialUnrelatedKey := session.graphStore.sourceKeys[unrelatedKeyFile]
+  initialValueKey := session.graphStore.sourceKeys[string(valueKeyFile)]
+  initialConsumerKey := session.graphStore.sourceKeys[string(consumerKeyFile)]
+  initialUnrelatedKey := session.graphStore.sourceKeys[string(unrelatedKeyFile)]
   if initialValueKey == "" || initialConsumerKey == "" || initialUnrelatedKey == "" {
     t.Fatal("initial generation omitted a fixture source key")
   }
-  unrelatedWireFile := session.graphStore.wireSources[unrelatedKeyFile]
+  unrelatedWireFile := session.graphStore.wireSources[string(unrelatedKeyFile)]
   alteredUnrelatedProvenance := false
   for index := range session.graphStore.provenance.Sources {
-    if session.graphStore.provenance.Sources[index].File != unrelatedKeyFile {
+    if session.graphStore.provenance.Sources[index].File != string(unrelatedKeyFile) {
       continue
     }
     if runtime.GOOS == "windows" {
@@ -92,7 +92,7 @@ func TestServeShardsReuseUnaffectedSources(t *testing.T) {
   if delta == nil || mode != serveModeIncremental || !changed || delta.BaseSequence != initial.Sequence || delta.BaseGeneration != initial.Generation {
     t.Fatalf("incremental coordinates: snapshot=%#v mode=%q changed=%v", delta, mode, changed)
   }
-  nextValueKey := session.graphStore.sourceKeys[valueKeyFile]
+  nextValueKey := session.graphStore.sourceKeys[string(valueKeyFile)]
   if nextValueKey == "" || nextValueKey == initialValueKey {
     t.Fatal("changed source retained its content-addressed shard key")
   }
@@ -102,10 +102,10 @@ func TestServeShardsReuseUnaffectedSources(t *testing.T) {
   if !containsString(delta.Deletes, initialValueKey) {
     t.Fatalf("delta did not delete superseded source shard %q: %v", initialValueKey, delta.Deletes)
   }
-  if session.graphStore.sourceKeys[consumerKeyFile] != initialConsumerKey || session.graphStore.sourceKeys[unrelatedKeyFile] != initialUnrelatedKey {
+  if session.graphStore.sourceKeys[string(consumerKeyFile)] != initialConsumerKey || session.graphStore.sourceKeys[string(unrelatedKeyFile)] != initialUnrelatedKey {
     t.Fatal("body edit moved an unchanged source shard identity")
   }
-  if len(session.graphStore.extractedFiles) != 1 || session.graphStore.extractedFiles[0] != valueKeyFile {
+  if len(session.graphStore.extractedFiles) != 1 || session.graphStore.extractedFiles[0] != string(valueKeyFile) {
     t.Fatalf("private body edit extracted %v, want only %s", session.graphStore.extractedFiles, valueKeyFile)
   }
   wireFilePreserved := false

package/cmd/ttscgraph/serve_source_encoding_test.go

@@ -106,10 +106,10 @@ func TestServeSourceEncodingKeepsRawIdentityAndDecodedResidentText(t *testing.T)
         t.Errorf("%s %s decoded text=%q want=%q", stage, name, source.Text(), text(name, suffix))
       }
       rawHash := sha256.Sum256(bytesOf(name, text(name, suffix)))
-      if hashes[source.FileName()] != rawHash {
+      if hashes[string(source.FileName())] != rawHash {
         t.Errorf("%s %s invalidation identity differs from raw bytes", stage, name)
       }
-      if digests[source.FileName()] != graph.Digest(rawHash) {
+      if digests[string(source.FileName())] != graph.Digest(rawHash) {
         t.Errorf("%s %s disk digest differs from raw bytes", stage, name)
       }
     }

package/driver/build_information_uses_selected_output_identity_test.go

@@ -9,6 +9,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // TestBuildInformationUsesSelectedOutputIdentity Verifies incremental metadata
@@ -76,11 +77,11 @@ func TestBuildInformationUsesSelectedOutputIdentity(t *testing.T) {
         state = "tsconfig.tsbuildinfo"
       }
       expected := filepath.ToSlash(filepath.Join(root, state))
-      if escaped := p.outputEscapesOutDir(expected); escaped == c.incremental {
+      if escaped := p.outputEscapesOutDir(shimtspath.RootedFilePathFromAbsolute(expected)); escaped == c.incremental {
         t.Errorf("selected state containment: escaped=%v incremental=%v", escaped, c.incremental)
       }
       for _, decoy := range []string{"cache/unrelated.tsbuildinfo", "cache/unrelated.map"} {
-        if !p.outputEscapesOutDir(filepath.ToSlash(filepath.Join(root, decoy))) {
+        if !p.outputEscapesOutDir(shimtspath.RootedFilePathFromAbsolute(filepath.ToSlash(filepath.Join(root, decoy)))) {
           t.Errorf("unselected output escaped containment: %s", decoy)
         }
       }
@@ -105,8 +106,8 @@ func TestBuildInformationUsesSelectedOutputIdentity(t *testing.T) {
       for _, lane := range []string{"raw", "rewrite", "plugin"} {
         t.Run(lane, func(t *testing.T) {
           writes := map[string]string{}
-          writer := func(file, text string, _ *shimcompiler.WriteFileData) error {
-            writes[filepath.ToSlash(file)] = text
+          writer := func(file shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+            writes[filepath.ToSlash(string(file))] = text
             return nil
           }
           var emitted []Diagnostic

package/driver/check_observations.go

@@ -41,7 +41,7 @@ func WriteCheckObservationsJSON(fileName string, program *Program) error {
   }
   if program != nil {
     if program.TSProgram != nil {
-      graph = NewTransformGraph(program, program.TSProgram.GetCurrentDirectory())
+      graph = NewTransformGraph(program, string(program.TSProgram.GetCurrentDirectory()))
     }
     if recorded := program.PluginHostInputs(); recorded != nil {
       inputs = recorded

package/driver/config_discovery.go

@@ -4,6 +4,7 @@ import (
   "os"
   "path/filepath"
 
+  "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/microsoft/typescript-go/shim/vfs/osvfs"
 )
 
@@ -159,7 +160,10 @@ func ReportRejectedConfigCandidates(candidates []ConfigCandidate, hashReporter,
         // conflict and leave every persistent consumer unable to reuse.
         before, beforeErr := os.Stat(resolved)
         if beforeErr == nil && before.IsDir() {
-          physical := osvfs.FS().Realpath(resolved)
+          physical := resolved
+          if rooted, ok := tspath.TryRootedPathFromAbsolute(resolved); ok {
+            physical = string(osvfs.FS().Realpath(rooted))
+          }
           // Realpath returns its argument if the native resolver fails. An
           // unchanged spelling is proof only when no component is an alias or
           // unknown reparse entry; SameFile alone cannot prove its spelling.

package/driver/declaration_shape.go

@@ -34,23 +34,21 @@ func (p *Program) DeclarationShapeDigest(file *ast.SourceFile) (string, error) {
   }
   var signature strings.Builder
   emitted := false
-  p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
-    TargetSourceFile: file,
-    EmitOnly:         shimcompiler.EmitOnlyForcedDts,
-    WriteFile: func(_ string, text string, data *shimcompiler.WriteFileData) error {
-      emitted = true
-      if data != nil && data.SourceMapUrlPos >= 0 && data.SourceMapUrlPos <= len(text) {
-        text = text[:data.SourceMapUrlPos]
+  // The forced declaration mode is upstream's declaration emit for
+  // incremental signatures; declarationShapeEmitOptions names each target's.
+  p.TSProgram.Emit(context.Background(), declarationShapeEmitOptions(file, func(_ shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
+    emitted = true
+    if data != nil && data.SourceMapUrlPos >= 0 && data.SourceMapUrlPos <= len(text) {
+      text = text[:data.SourceMapUrlPos]
+    }
+    signature.WriteString(text)
+    if data != nil {
+      for _, diagnostic := range data.Diagnostics {
+        appendDeclarationShapeDiagnostic(&signature, file, diagnostic)
       }
-      signature.WriteString(text)
-      if data != nil {
-        for _, diagnostic := range data.Diagnostics {
-          appendDeclarationShapeDiagnostic(&signature, file, diagnostic)
-        }
-      }
-      return nil
-    },
-  })
+    }
+    return nil
+  }))
   if !emitted {
     // Mirrors tsgo's incremental fallback to the file version when forced
     // declaration emit has no output. This is conservative: any body movement
@@ -68,11 +66,7 @@ func appendDeclarationShapeDiagnostic(builder *strings.Builder, source *ast.Sour
   builder.WriteString("\n")
   diagnosticFile := diagnostic.File()
   if diagnosticFile != nil && diagnosticFile != source {
-    builder.WriteString(shimtspath.EnsurePathIsNonModuleName(shimtspath.GetRelativePathFromDirectory(
-      shimtspath.GetDirectoryPath(string(source.Path())),
-      string(diagnosticFile.Path()),
-      shimtspath.ComparePathsOptions{},
-    )))
+    writeDeclarationShapeDiagnosticFile(builder, source, diagnosticFile)
   }
   if diagnosticFile != nil {
     builder.WriteString(fmt.Sprintf("(%d,%d): ", diagnostic.Pos(), diagnostic.Len()))

package/driver/diagnostics_preamble.go

@@ -157,7 +157,7 @@ func (m *preambleMapper) viewOf(file *ast.SourceFile) *preambleView {
 // anchor against — an uncorrected position is still better than a nil file.
 func newPreambleView(file *ast.SourceFile, preamble string) *preambleView {
   text := file.Text()
-  start, length, ok := sourcePreambleRegion(file.FileName(), text, preamble)
+  start, length, ok := sourcePreambleRegion(string(file.FileName()), text, preamble)
   if !ok {
     return nil
   }
@@ -253,7 +253,7 @@ func unanchoredPreambleDiagnostic(d *ast.Diagnostic) Diagnostic {
     Severity: SeverityError,
   }
   if file := d.File(); file != nil {
-    out.File = file.FileName()
+    out.File = string(file.FileName())
   }
   return out
 }

package/driver/emit_containment.go

@@ -15,7 +15,10 @@
 // same way tsc treats node_modules externals (no emit, no error).
 package driver
 
-import "github.com/microsoft/typescript-go/shim/tspath"
+import (
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  "github.com/microsoft/typescript-go/shim/tspath"
+)
 
 // isBuildInfoOutput identifies the metadata artifact selected by this compiler
 // generation. Its configured extension does not determine its kind, and an
@@ -27,19 +30,16 @@ import "github.com/microsoft/typescript-go/shim/tspath"
 // Common: Clear and simple design: One artifact predicate serves containment and source-map correction rather than independent suffix rules.
 // Common: Prohibited implementation shortcuts: The real compiler-selected path replaces the suffix exception; no API-specific filename or consumer exemption compensates for output loss.
 // Common: Meaningful documentation: Native prose distinguishes selected artifact identity from filename extension and explains why unrelated metadata-looking paths remain ordinary outputs.
-// Portability: OS-neutral implementation: Native compiler path comparison uses the loaded Program's current directory and actual case policy, without assuming case behavior from the operating system.
+// Portability: OS-neutral implementation: Native compiler path comparison of rooted paths uses the loaded Program's actual case policy, without assuming case behavior from the operating system.
 // Performance: Efficient algorithms: Upstream destination inference and lexical comparison process a bounded number of path strings with costs proportional to their text; no directory traversal or file read is added.
 // Performance: Reuse equivalent work: The current compiler generation owns destination selection; this predicate introduces no result cache or independent producer.
 // Performance: Bound retention and release resources: The predicate returns a boolean and retains no compiler generation, path history or external resource.
-func (p *Program) isBuildInfoOutput(fileName string) bool {
+func (p *Program) isBuildInfoOutput(fileName tspath.RootedFilePath) bool {
   if p == nil || p.TSProgram == nil {
     return false
   }
   buildInfo := p.TSProgram.CommandLine().GetBuildInfoFileName()
-  return buildInfo != "" && tspath.ComparePaths(buildInfo, fileName, tspath.ComparePathsOptions{
-    UseCaseSensitiveFileNames: p.TSProgram.UseCaseSensitiveFileNames(),
-    CurrentDirectory:          p.TSProgram.GetCurrentDirectory(),
-  }) == 0
+  return buildInfo != "" && tspath.CompareFilePaths(shimcompiler.ProgramCaseSensitivity(p.TSProgram), buildInfo, fileName) == 0
 }
 
 // outputEscapesOutDir reports whether fileName — an emit output path tsgo
@@ -48,7 +48,7 @@ func (p *Program) isBuildInfoOutput(fileName string) bool {
 // next to their sources by design, so the guard only applies when `outDir`
 // gives the project an output boundary. The compiler-selected build-information
 // artifact is exempt because its location can legitimately be outside outDir.
-func (p *Program) outputEscapesOutDir(fileName string) bool {
+func (p *Program) outputEscapesOutDir(fileName tspath.RootedFilePath) bool {
   if p == nil || p.TSProgram == nil {
     return false
   }
@@ -59,14 +59,11 @@ func (p *Program) outputEscapesOutDir(fileName string) bool {
   if p.isBuildInfoOutput(fileName) {
     return false
   }
-  cmp := tspath.ComparePathsOptions{
-    UseCaseSensitiveFileNames: p.TSProgram.UseCaseSensitiveFileNames(),
-    CurrentDirectory:          p.TSProgram.GetCurrentDirectory(),
-  }
-  if tspath.ContainsPath(options.OutDir, fileName, cmp) {
+  caseSensitivity := shimcompiler.ProgramCaseSensitivity(p.TSProgram)
+  if tspath.ContainsPathWith(caseSensitivity, options.OutDir, tspath.RootedPath(fileName)) {
     return false
   }
-  if options.DeclarationDir != "" && tspath.ContainsPath(options.DeclarationDir, fileName, cmp) {
+  if options.DeclarationDir != "" && tspath.ContainsPathWith(caseSensitivity, options.DeclarationDir, tspath.RootedPath(fileName)) {
     return false
   }
   return true

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