ttsc 0.7.3 → 0.8.0-dev.20260505

package/shim/compiler/emit_hooks.go

@@ -0,0 +1,494 @@
+package compiler
+
+import (
+  "context"
+
+  "github.com/microsoft/typescript-go/internal/ast"
+  "github.com/microsoft/typescript-go/internal/binder"
+  innercompiler "github.com/microsoft/typescript-go/internal/compiler"
+  "github.com/microsoft/typescript-go/internal/core"
+  "github.com/microsoft/typescript-go/internal/diagnostics"
+  "github.com/microsoft/typescript-go/internal/module"
+  "github.com/microsoft/typescript-go/internal/outputpaths"
+  "github.com/microsoft/typescript-go/internal/packagejson"
+  "github.com/microsoft/typescript-go/internal/printer"
+  "github.com/microsoft/typescript-go/internal/sourcemap"
+  "github.com/microsoft/typescript-go/internal/stringutil"
+  "github.com/microsoft/typescript-go/internal/symlinks"
+  "github.com/microsoft/typescript-go/internal/transformers"
+  "github.com/microsoft/typescript-go/internal/transformers/declarations"
+  "github.com/microsoft/typescript-go/internal/transformers/estransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/inliners"
+  "github.com/microsoft/typescript-go/internal/transformers/jsxtransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/moduletransforms"
+  "github.com/microsoft/typescript-go/internal/transformers/tstransforms"
+  "github.com/microsoft/typescript-go/internal/tsoptions"
+  "github.com/microsoft/typescript-go/internal/tspath"
+)
+
+type EmitContext = printer.EmitContext
+
+type EmitSourceFileHook func(context *EmitContext, file *ast.SourceFile) *ast.SourceFile
+
+type EmitHooks struct {
+  BeforePrintDeclaration EmitSourceFileHook
+  BeforePrintJS          EmitSourceFileHook
+}
+
+type hookEmitHost struct {
+  program      *innercompiler.Program
+  emitResolver printer.EmitResolver
+}
+
+type hookEmitter struct {
+  host       *hookEmitHost
+  emitOnly   innercompiler.EmitOnly
+  emitResult innercompiler.EmitResult
+  hooks      EmitHooks
+  paths      *outputpaths.OutputPaths
+  sourceFile *ast.SourceFile
+  writeFile  innercompiler.WriteFile
+  writer     printer.EmitTextWriter
+}
+
+func EmitWithHooks(ctx context.Context, program *innercompiler.Program, options innercompiler.EmitOptions, hooks EmitHooks) *innercompiler.EmitResult {
+  if program == nil {
+    return nil
+  }
+  if options.EmitOnly != innercompiler.EmitOnlyForcedDts {
+    result := HandleNoEmitOnError(ctx, program, options.TargetSourceFile)
+    if result != nil || ctx.Err() != nil {
+      return result
+    }
+  }
+  var results []*innercompiler.EmitResult
+  newLine := program.Options().NewLine.GetNewLineCharacter()
+  for _, sourceFile := range hookSourceFilesToEmit(program, options.TargetSourceFile, options.EmitOnly == innercompiler.EmitOnlyForcedDts) {
+    host, done := newHookEmitHost(ctx, program, sourceFile)
+    emitter := &hookEmitter{
+      host:       host,
+      emitOnly:   options.EmitOnly,
+      hooks:      hooks,
+      paths:      outputpaths.GetOutputPathsFor(sourceFile, host.Options(), host, options.EmitOnly == innercompiler.EmitOnlyForcedDts),
+      sourceFile: sourceFile,
+      writeFile:  options.WriteFile,
+      writer:     printer.NewTextWriter(newLine, 0),
+    }
+    emitter.emit()
+    done()
+    results = append(results, &emitter.emitResult)
+  }
+  return CombineEmitResults(results)
+}
+
+func hookSourceFilesToEmit(program *innercompiler.Program, target *ast.SourceFile, forceDtsEmit bool) []*ast.SourceFile {
+  if target != nil {
+    if program.SourceFileMayBeEmitted(target, forceDtsEmit) {
+      return []*ast.SourceFile{target}
+    }
+    return nil
+  }
+  var out []*ast.SourceFile
+  for _, sourceFile := range program.SourceFiles() {
+    if program.SourceFileMayBeEmitted(sourceFile, forceDtsEmit) {
+      out = append(out, sourceFile)
+    }
+  }
+  return out
+}
+
+func newHookEmitHost(ctx context.Context, program *innercompiler.Program, file *ast.SourceFile) (*hookEmitHost, func()) {
+  checker, done := program.GetTypeCheckerForFile(ctx, file)
+  return &hookEmitHost{
+    program:      program,
+    emitResolver: checker.GetEmitResolver(),
+  }, done
+}
+
+func (e *hookEmitter) emit() {
+  e.emitJSFile(e.sourceFile, e.paths.JsFilePath(), e.paths.SourceMapFilePath())
+  e.emitDeclarationFile(e.sourceFile, e.paths.DeclarationFilePath(), e.paths.DeclarationMapPath())
+  e.emitResult.Diagnostics = e.emitterDiagnostics()
+}
+
+func (e *hookEmitter) emitterDiagnostics() []*ast.Diagnostic {
+  return e.emitResult.Diagnostics
+}
+
+func (e *hookEmitter) addDiagnostic(diag *ast.Diagnostic) {
+  e.emitResult.Diagnostics = append(e.emitResult.Diagnostics, diag)
+}
+
+func (e *hookEmitter) runScriptTransformers(emitContext *printer.EmitContext, sourceFile *ast.SourceFile) *ast.SourceFile {
+  for _, transformer := range hookScriptTransformers(emitContext, e.host, sourceFile) {
+    sourceFile = transformer.TransformSourceFile(sourceFile)
+  }
+  return sourceFile
+}
+
+func (e *hookEmitter) runDeclarationTransformers(emitContext *printer.EmitContext, sourceFile *ast.SourceFile, declarationFilePath, declarationMapPath string) (*ast.SourceFile, []*ast.Diagnostic) {
+  transform := declarations.NewDeclarationTransformer(e.host, emitContext, e.host.Options(), declarationFilePath, declarationMapPath)
+  sourceFile = transform.TransformSourceFile(sourceFile)
+  return sourceFile, transform.GetDiagnostics()
+}
+
+func (e *hookEmitter) emitJSFile(sourceFile *ast.SourceFile, jsFilePath string, sourceMapFilePath string) {
+  options := e.host.Options()
+  if sourceFile == nil || e.emitOnly != innercompiler.EmitAll && e.emitOnly != innercompiler.EmitOnlyJs || len(jsFilePath) == 0 {
+    return
+  }
+  if options.NoEmit == core.TSTrue || e.host.IsEmitBlocked(jsFilePath) {
+    e.emitResult.EmitSkipped = true
+    return
+  }
+  emitContext, putEmitContext := printer.GetEmitContext()
+  defer putEmitContext()
+  sourceFile = e.runScriptTransformers(emitContext, sourceFile)
+  if e.hooks.BeforePrintJS != nil {
+    sourceFile = e.hooks.BeforePrintJS(emitContext, sourceFile)
+  }
+  printerOptions := printer.PrinterOptions{
+    RemoveComments:  options.RemoveComments.IsTrue(),
+    NewLine:         options.NewLine,
+    NoEmitHelpers:   options.NoEmitHelpers.IsTrue(),
+    SourceMap:       options.SourceMap.IsTrue(),
+    InlineSourceMap: options.InlineSourceMap.IsTrue(),
+    InlineSources:   options.InlineSources.IsTrue(),
+    Target:          options.Target,
+  }
+  p := printer.NewPrinter(printerOptions, printer.PrintHandlers{}, emitContext)
+  e.printSourceFile(jsFilePath, sourceMapFilePath, sourceFile, p, hookShouldEmitSourceMaps(options, sourceFile))
+}
+
+func (e *hookEmitter) emitDeclarationFile(sourceFile *ast.SourceFile, declarationFilePath string, declarationMapPath string) {
+  options := e.host.Options()
+  if sourceFile == nil || e.emitOnly == innercompiler.EmitOnlyJs || len(declarationFilePath) == 0 {
+    return
+  }
+  if e.emitOnly != innercompiler.EmitOnlyForcedDts && (options.NoEmit == core.TSTrue || e.host.IsEmitBlocked(declarationFilePath)) {
+    e.emitResult.EmitSkipped = true
+    return
+  }
+  emitContext, putEmitContext := printer.GetEmitContext()
+  defer putEmitContext()
+  sourceFile, diags := e.runDeclarationTransformers(emitContext, sourceFile, declarationFilePath, declarationMapPath)
+  if e.hooks.BeforePrintDeclaration != nil {
+    sourceFile = e.hooks.BeforePrintDeclaration(emitContext, sourceFile)
+  }
+  printerOptions := printer.PrinterOptions{
+    RemoveComments:      options.RemoveComments.IsTrue(),
+    OnlyPrintJSDocStyle: true,
+    NewLine:             options.NewLine,
+    NoEmitHelpers:       options.NoEmitHelpers.IsTrue(),
+    SourceMap:           options.DeclarationMap.IsTrue(),
+    InlineSourceMap:     options.InlineSourceMap.IsTrue(),
+    InlineSources:       options.InlineSources.IsTrue(),
+  }
+  p := printer.NewPrinter(printerOptions, printer.PrintHandlers{}, emitContext)
+  for _, diag := range diags {
+    e.addDiagnostic(diag)
+  }
+  e.printSourceFile(declarationFilePath, declarationMapPath, sourceFile, p, e.emitOnly != innercompiler.EmitOnlyForcedDts && hookShouldEmitDeclarationSourceMaps(options, sourceFile))
+}
+
+func (e *hookEmitter) printSourceFile(filePath string, sourceMapFilePath string, sourceFile *ast.SourceFile, printer_ *printer.Printer, shouldEmitSourceMaps bool) {
+  options := e.host.Options()
+  var sourceMapGenerator *sourcemap.Generator
+  if shouldEmitSourceMaps {
+    sourceMapGenerator = sourcemap.NewGenerator(
+      tspath.GetBaseFileName(tspath.NormalizeSlashes(filePath)),
+      hookSourceRoot(options),
+      e.sourceMapDirectory(options, filePath, sourceFile),
+      tspath.ComparePathsOptions{
+        UseCaseSensitiveFileNames: e.host.UseCaseSensitiveFileNames(),
+        CurrentDirectory:          e.host.GetCurrentDirectory(),
+      },
+    )
+  }
+  printer_.Write(sourceFile.AsNode(), sourceFile, e.writer, sourceMapGenerator)
+  sourceMapURLPos := -1
+  if sourceMapGenerator != nil {
+    if options.SourceMap.IsTrue() || options.InlineSourceMap.IsTrue() || options.GetAreDeclarationMapsEnabled() {
+      e.emitResult.SourceMaps = append(e.emitResult.SourceMaps, &innercompiler.SourceMapEmitResult{
+        InputSourceFileNames: sourceMapGenerator.Sources(),
+        SourceMap:            sourceMapGenerator.RawSourceMap(),
+        GeneratedFile:        filePath,
+      })
+    }
+    sourceMappingURL := e.sourceMappingURL(options, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile)
+    if len(sourceMappingURL) > 0 {
+      if !e.writer.IsAtStartOfLine() {
+        e.writer.RawWrite(core.IfElse(options.NewLine == core.NewLineKindCRLF, "\r\n", "\n"))
+      }
+      sourceMapURLPos = e.writer.GetTextPos()
+      e.writer.WriteComment("//# sourceMappingURL=")
+      e.writer.WriteComment(sourceMappingURL)
+    }
+    if len(sourceMapFilePath) > 0 {
+      sourceMap := sourceMapGenerator.String()
+      if err := e.writeText(sourceMapFilePath, sourceMap, nil); err != nil {
+        e.addDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, filePath, err.Error()))
+      } else {
+        e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, sourceMapFilePath)
+      }
+    }
+  } else {
+    e.writer.WriteLine()
+  }
+  text := e.writer.String()
+  if options.EmitBOM.IsTrue() {
+    text = stringutil.AddUTF8ByteOrderMark(text)
+  }
+  data := &innercompiler.WriteFileData{
+    SourceMapUrlPos: sourceMapURLPos,
+    Diagnostics:     e.emitterDiagnostics(),
+  }
+  err := e.writeText(filePath, text, data)
+  skippedDtsWrite := data.SkippedDtsWrite
+  if err != nil {
+    e.addDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Could_not_write_file_0_Colon_1, filePath, err.Error()))
+  } else if !skippedDtsWrite {
+    e.emitResult.EmittedFiles = append(e.emitResult.EmittedFiles, filePath)
+  }
+  e.writer.Clear()
+}
+
+func (e *hookEmitter) writeText(fileName string, text string, data *innercompiler.WriteFileData) error {
+  if e.writeFile != nil {
+    return e.writeFile(fileName, text, data)
+  }
+  return e.host.WriteFile(fileName, text)
+}
+
+func (e *hookEmitter) sourceMapDirectory(options *core.CompilerOptions, filePath string, sourceFile *ast.SourceFile) string {
+  if len(options.SourceRoot) > 0 {
+    return e.host.CommonSourceDirectory()
+  }
+  if len(options.MapRoot) > 0 {
+    sourceMapDir := tspath.NormalizeSlashes(options.MapRoot)
+    if sourceFile != nil {
+      sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
+        sourceFile.FileName(),
+        sourceMapDir,
+        e.host.GetCurrentDirectory(),
+        e.host.CommonSourceDirectory(),
+        e.host.UseCaseSensitiveFileNames(),
+      ))
+    }
+    if tspath.GetRootLength(sourceMapDir) == 0 {
+      sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
+    }
+    return sourceMapDir
+  }
+  return tspath.GetDirectoryPath(tspath.NormalizePath(filePath))
+}
+
+func (e *hookEmitter) sourceMappingURL(options *core.CompilerOptions, sourceMapGenerator *sourcemap.Generator, filePath string, sourceMapFilePath string, sourceFile *ast.SourceFile) string {
+  if options.InlineSourceMap.IsTrue() {
+    return sourceMapGenerator.Base64DataURL()
+  }
+  sourceMapFile := tspath.GetBaseFileName(tspath.NormalizeSlashes(sourceMapFilePath))
+  if len(options.MapRoot) > 0 {
+    sourceMapDir := tspath.NormalizeSlashes(options.MapRoot)
+    if sourceFile != nil {
+      sourceMapDir = tspath.GetDirectoryPath(outputpaths.GetSourceFilePathInNewDir(
+        sourceFile.FileName(),
+        sourceMapDir,
+        e.host.GetCurrentDirectory(),
+        e.host.CommonSourceDirectory(),
+        e.host.UseCaseSensitiveFileNames(),
+      ))
+    }
+    if tspath.GetRootLength(sourceMapDir) == 0 {
+      sourceMapDir = tspath.CombinePaths(e.host.CommonSourceDirectory(), sourceMapDir)
+      return stringutil.EncodeURI(
+        tspath.GetRelativePathToDirectoryOrUrl(
+          tspath.GetDirectoryPath(tspath.NormalizePath(filePath)),
+          tspath.CombinePaths(sourceMapDir, sourceMapFile),
+          true,
+          tspath.ComparePathsOptions{
+            UseCaseSensitiveFileNames: e.host.UseCaseSensitiveFileNames(),
+            CurrentDirectory:          e.host.GetCurrentDirectory(),
+          },
+        ),
+      )
+    }
+    return stringutil.EncodeURI(tspath.CombinePaths(sourceMapDir, sourceMapFile))
+  }
+  return stringutil.EncodeURI(sourceMapFile)
+}
+
+func hookShouldEmitSourceMaps(options *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
+  return (options.SourceMap.IsTrue() || options.InlineSourceMap.IsTrue()) &&
+    !tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
+}
+
+func hookShouldEmitDeclarationSourceMaps(options *core.CompilerOptions, sourceFile *ast.SourceFile) bool {
+  return options.DeclarationMap.IsTrue() &&
+    !tspath.FileExtensionIs(sourceFile.FileName(), tspath.ExtensionJson)
+}
+
+func hookSourceRoot(options *core.CompilerOptions) string {
+  sourceRoot := tspath.NormalizeSlashes(options.SourceRoot)
+  if len(sourceRoot) > 0 {
+    sourceRoot = tspath.EnsureTrailingDirectorySeparator(sourceRoot)
+  }
+  return sourceRoot
+}
+
+func hookScriptTransformers(emitContext *printer.EmitContext, host printer.EmitHost, sourceFile *ast.SourceFile) []*transformers.Transformer {
+  var tx []*transformers.Transformer
+  options := host.Options()
+  importElisionEnabled := !options.VerbatimModuleSyntax.IsTrue() && !ast.IsInJSFile(sourceFile.AsNode())
+  jsxTransformEnabled := options.GetJSXTransformEnabled() && sourceFile.LanguageVariant == core.LanguageVariantJSX
+  emitResolver := host.GetEmitResolver()
+  var referenceResolver binder.ReferenceResolver
+  if importElisionEnabled || jsxTransformEnabled || !options.GetIsolatedModules() || options.EmitDecoratorMetadata.IsTrue() {
+    emitResolver.MarkLinkedReferencesRecursively(sourceFile)
+    referenceResolver = emitResolver
+  } else {
+    referenceResolver = binder.NewReferenceResolver(options, binder.ReferenceResolverHooks{})
+  }
+  opts := transformers.TransformOptions{
+    Context:                   emitContext,
+    CompilerOptions:           options,
+    Resolver:                  referenceResolver,
+    EmitResolver:              emitResolver,
+    GetEmitModuleFormatOfFile: host.GetEmitModuleFormatOfFile,
+  }
+  if options.EmitDecoratorMetadata.IsTrue() {
+    tx = append(tx, tstransforms.NewMetadataTransformer(&opts))
+  }
+  tx = append(tx, tstransforms.NewTypeEraserTransformer(&opts))
+  if importElisionEnabled {
+    tx = append(tx, tstransforms.NewImportElisionTransformer(&opts))
+  }
+  tx = append(tx, tstransforms.NewRuntimeSyntaxTransformer(&opts))
+  if options.ExperimentalDecorators.IsTrue() {
+    tx = append(tx, tstransforms.NewLegacyDecoratorsTransformer(&opts))
+  }
+  if jsxTransformEnabled {
+    tx = append(tx, jsxtransforms.NewJSXTransformer(&opts))
+  }
+  downleveler := estransforms.GetESTransformer(&opts)
+  if downleveler != nil {
+    tx = append(tx, downleveler)
+  }
+  tx = append(tx, estransforms.NewUseStrictTransformer(&opts))
+  tx = append(tx, hookModuleTransformer(&opts))
+  if !options.GetIsolatedModules() {
+    tx = append(tx, inliners.NewConstEnumInliningTransformer(&opts))
+  }
+  return tx
+}
+
+func hookModuleTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
+  switch opts.CompilerOptions.GetEmitModuleKind() {
+  case core.ModuleKindPreserve:
+    return moduletransforms.NewESModuleTransformer(opts)
+  case core.ModuleKindESNext,
+    core.ModuleKindES2022,
+    core.ModuleKindES2020,
+    core.ModuleKindES2015,
+    core.ModuleKindNode20,
+    core.ModuleKindNode18,
+    core.ModuleKindNode16,
+    core.ModuleKindNodeNext,
+    core.ModuleKindCommonJS:
+    return moduletransforms.NewImpliedModuleTransformer(opts)
+  default:
+    return moduletransforms.NewCommonJSModuleTransformer(opts)
+  }
+}
+
+func (host *hookEmitHost) GetModeForUsageLocation(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) core.ResolutionMode {
+  return host.program.GetModeForUsageLocation(file, moduleSpecifier)
+}
+
+func (host *hookEmitHost) GetResolvedModuleFromModuleSpecifier(file ast.HasFileName, moduleSpecifier *ast.StringLiteralLike) *module.ResolvedModule {
+  return host.program.GetResolvedModuleFromModuleSpecifier(file, moduleSpecifier)
+}
+
+func (host *hookEmitHost) GetDefaultResolutionModeForFile(file ast.HasFileName) core.ResolutionMode {
+  return host.program.GetDefaultResolutionModeForFile(file)
+}
+
+func (host *hookEmitHost) GetEmitModuleFormatOfFile(file ast.HasFileName) core.ModuleKind {
+  return host.program.GetEmitModuleFormatOfFile(file)
+}
+
+func (host *hookEmitHost) FileExists(path string) bool {
+  return host.program.FileExists(path)
+}
+
+func (host *hookEmitHost) GetGlobalTypingsCacheLocation() string {
+  return host.program.GetGlobalTypingsCacheLocation()
+}
+
+func (host *hookEmitHost) GetNearestAncestorDirectoryWithPackageJson(dirname string) string {
+  return host.program.GetNearestAncestorDirectoryWithPackageJson(dirname)
+}
+
+func (host *hookEmitHost) GetPackageJsonInfo(pkgJSONPath string) *packagejson.InfoCacheEntry {
+  return host.program.GetPackageJsonInfo(pkgJSONPath)
+}
+
+func (host *hookEmitHost) GetSourceOfProjectReferenceIfOutputIncluded(file ast.HasFileName) string {
+  return host.program.GetSourceOfProjectReferenceIfOutputIncluded(file)
+}
+
+func (host *hookEmitHost) GetProjectReferenceFromSource(path tspath.Path) *tsoptions.SourceOutputAndProjectReference {
+  return host.program.GetProjectReferenceFromSource(path)
+}
+
+func (host *hookEmitHost) GetRedirectTargets(path tspath.Path) []string {
+  return host.program.GetRedirectTargets(path)
+}
+
+func (host *hookEmitHost) GetEffectiveDeclarationFlags(node *ast.Node, flags ast.ModifierFlags) ast.ModifierFlags {
+  return host.GetEmitResolver().GetEffectiveDeclarationFlags(node, flags)
+}
+
+func (host *hookEmitHost) GetOutputPathsFor(file *ast.SourceFile, forceDtsPaths bool) declarations.OutputPaths {
+  return outputpaths.GetOutputPathsFor(file, host.Options(), host, forceDtsPaths)
+}
+
+func (host *hookEmitHost) GetResolutionModeOverride(node *ast.Node) core.ResolutionMode {
+  return host.GetEmitResolver().GetResolutionModeOverride(node)
+}
+
+func (host *hookEmitHost) GetSourceFileFromReference(origin *ast.SourceFile, ref *ast.FileReference) *ast.SourceFile {
+  return host.program.GetSourceFileFromReference(origin, ref)
+}
+
+func (host *hookEmitHost) Options() *core.CompilerOptions { return host.program.Options() }
+func (host *hookEmitHost) SourceFiles() []*ast.SourceFile { return host.program.SourceFiles() }
+func (host *hookEmitHost) GetCurrentDirectory() string    { return host.program.GetCurrentDirectory() }
+func (host *hookEmitHost) CommonSourceDirectory() string  { return host.program.CommonSourceDirectory() }
+func (host *hookEmitHost) UseCaseSensitiveFileNames() bool {
+  return host.program.UseCaseSensitiveFileNames()
+}
+
+func (host *hookEmitHost) IsEmitBlocked(file string) bool {
+  return host.program.IsEmitBlocked(file)
+}
+
+func (host *hookEmitHost) WriteFile(fileName string, text string) error {
+  return host.program.Host().FS().WriteFile(fileName, text)
+}
+
+func (host *hookEmitHost) GetEmitResolver() printer.EmitResolver {
+  return host.emitResolver
+}
+
+func (host *hookEmitHost) IsSourceFileFromExternalLibrary(file *ast.SourceFile) bool {
+  return host.program.IsSourceFileFromExternalLibrary(file)
+}
+
+func (host *hookEmitHost) GetSymlinkCache() *symlinks.KnownSymlinks {
+  return host.program.GetSymlinkCache()
+}
+
+func (host *hookEmitHost) ResolveModuleName(moduleName string, containingFile string, resolutionMode core.ResolutionMode) *module.ResolvedModule {
+  return host.program.ResolveModuleName(moduleName, containingFile, resolutionMode)
+}

package/shim/core/shim.go

@@ -24,3 +24,6 @@ const (
 
 // NewTextRange constructs a closed/open [pos, end) text range.
 func NewTextRange(pos, end int) TextRange { return innercore.NewTextRange(pos, end) }
+
+// UndefinedTextRange marks synthesized AST nodes that do not map to source.
+func UndefinedTextRange() TextRange { return innercore.UndefinedTextRange() }

package/src/compiler/internal/runBuild.ts

@@ -99,9 +99,6 @@ export function runBuild(
     const compilers = execution.nativePlugins.filter(
       (plugin) => plugin.stage === "transform",
     );
-    const outputs = execution.nativePlugins.filter(
-      (plugin) => plugin.stage === "output",
-    );
     const checked = runNativeCheckPlugins(options, execution);
     if (checked.status !== 0) {
       return checked;
@@ -109,7 +106,7 @@ export function runBuild(
 
     if (options.emit === false) {
       if (compilers.length !== 0) {
-        assertSingleCompilerHost(compilers);
+        assertCompilerHostCompatibility(compilers);
         return appendBuildOutput(
           checked,
           buildWithNativeCompilerPlugins(options, execution, compilers),
@@ -123,7 +120,7 @@ export function runBuild(
 
     let result: TtscBuildResult;
     if (compilers.length !== 0) {
-      assertSingleCompilerHost(compilers);
+      assertCompilerHostCompatibility(compilers);
       result = appendBuildOutput(
         checked,
         buildWithNativeCompilerPlugins(options, execution, compilers),
@@ -140,25 +137,13 @@ export function runBuild(
         }
       }
       const args = createTsgoBuildArgs(execution, options, {
-        listEmittedFiles:
-          outputs.length !== 0 || options.forceListEmittedFiles === true,
+        listEmittedFiles: options.forceListEmittedFiles === true,
       });
       const emitted = runTsgoBuild(execution, options, args);
       result = appendBuildOutput(checked, emitted);
     }
 
-    if (result.status !== 0 || outputs.length === 0) {
-      return result;
-    }
-    return appendBuildOutput(
-      result,
-      applyOutputPlugins(
-        options,
-        execution,
-        result.emittedFiles ?? [],
-        outputs,
-      ),
-    );
+    return result;
   }
 
   if (options.emit !== false && options.skipDiagnosticsCheck !== true) {
@@ -332,30 +317,13 @@ function createNativeCheckArgs(
   return args;
 }
 
-function createNativeOutputArgs(
-  execution: ReturnType<typeof resolveExecutionContext>,
-  options: TtscBuildOptions,
-  file: string,
-): string[] {
-  const args = [
-    "output",
-    "--file=" + file,
-    "--tsconfig=" + execution.tsconfig,
-    "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
-    "--cwd=" + execution.projectRoot,
-  ];
-  if (options.outDir) {
-    args.push("--outDir=" + path.resolve(execution.cwd, options.outDir));
-  }
-  return args;
-}
-
 function serializeNativePlugins(
   plugins: readonly ITtscLoadedNativePlugin[],
 ): string {
   return JSON.stringify(
     plugins.map((plugin) => ({
       config: plugin.config,
+      hooks: plugin.hooks,
       name: plugin.name,
       stage: plugin.stage,
     })),
@@ -390,48 +358,6 @@ function runNativeCheckPlugins(
   return out;
 }
 
-function applyOutputPlugins(
-  options: TtscBuildOptions,
-  execution: ReturnType<typeof resolveExecutionContext>,
-  emittedFiles: readonly string[],
-  plugins: readonly ITtscLoadedNativePlugin[],
-): TtscBuildResult {
-  let out: TtscBuildResult = {
-    diagnostics: [],
-    status: 0,
-    stdout: "",
-    stderr: "",
-  };
-  for (const plugin of plugins) {
-    for (const file of emittedFiles) {
-      if (!fs.existsSync(file)) {
-        continue;
-      }
-      const result = runNativeOutputPlugin(options, execution, plugin, file);
-      out = appendBuildOutput(out, result);
-      if (result.status !== 0) {
-        return out;
-      }
-    }
-  }
-  return out;
-}
-
-function runNativeOutputPlugin(
-  options: TtscBuildOptions,
-  execution: ReturnType<typeof resolveExecutionContext>,
-  plugin: ITtscLoadedNativePlugin,
-  file: string,
-): TtscBuildResult {
-  return runNativePluginCommand(
-    plugin,
-    createNativeOutputArgs(execution, options, file),
-    options,
-    execution,
-    "ttsc.output",
-  );
-}
-
 function runNativePluginCommand(
   plugin: ITtscLoadedNativePlugin,
   args: readonly string[],
@@ -473,16 +399,59 @@ function appendBuildOutput(
   });
 }
 
-function assertSingleCompilerHost(
+function assertCompilerHostCompatibility(
   plugins: readonly ITtscLoadedNativePlugin[],
 ): void {
   const binaries = [...new Set(plugins.map((plugin) => plugin.binary))];
-  if (binaries.length > 1) {
-    throw new Error(
-      "ttsc: multiple compiler native backends cannot share one emit pass; " +
-        "use output-capability plugins for post-emit transforms",
-    );
+  if (binaries.length <= 1) {
+    return;
+  }
+  if (plugins.every(isFirstPartyUtilityTransformPlugin)) {
+    return;
+  }
+  throw new Error(
+    "ttsc: multiple compiler native backends cannot share one emit pass; " +
+      "compose transform hook libraries through one aggregate host",
+  );
+}
+
+function isFirstPartyUtilityTransformPlugin(
+  plugin: ITtscLoadedNativePlugin,
+): boolean {
+  if (plugin.stage !== "transform") return false;
+  if (!firstPartyUtilityPluginNames.has(plugin.name)) return false;
+  const manifest = readNearestPackageManifest(plugin.source);
+  return manifest?.name === plugin.name;
+}
+
+const firstPartyUtilityPluginNames = new Set([
+  "@ttsc/banner",
+  "@ttsc/paths",
+  "@ttsc/strip",
+]);
+
+function readNearestPackageManifest(
+  source: string,
+): { name?: unknown } | undefined {
+  try {
+    let current = fs.statSync(source).isDirectory()
+      ? source
+      : path.dirname(source);
+    for (let i = 0; i < 4; i += 1) {
+      const manifest = path.join(current, "package.json");
+      if (fs.existsSync(manifest)) {
+        return JSON.parse(fs.readFileSync(manifest, "utf8")) as {
+          name?: unknown;
+        };
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  } catch {
+    return undefined;
   }
+  return undefined;
 }
 
 function resolveExecutionContext(