ttsc 0.33.1 → 0.34.0

package/targets/7.1/bridge/compiler/contentmapper_process.go

@@ -0,0 +1,70 @@
+package compiler
+
+import (
+  "errors"
+  "io"
+  "os/exec"
+  "time"
+)
+
+// spawnContentMapper starts one content-mapper process, the way the tsc
+// command does: command runs in dir, the mapper package's directory, with its
+// stderr written to stderr. The returned value reads the process's stdout and
+// writes its stdin; Close kills and reaps it. The compiler keeps process
+// spawning out of its own packages and leaves it to the host, so ttsc supplies
+// the same behavior as tsc's.
+func spawnContentMapper(command []string, dir string, stderr io.Writer) (io.ReadWriteCloser, error) {
+  if len(command) == 0 {
+    return nil, errors.New("content mapper declares no command to run")
+  }
+  cmd := exec.Command(command[0], command[1:]...)
+  cmd.Dir = dir
+  cmd.Stderr = stderr
+  cmd.WaitDelay = time.Second
+  stdin, err := cmd.StdinPipe()
+  if err != nil {
+    return nil, err
+  }
+  stdout, err := cmd.StdoutPipe()
+  if err != nil {
+    return nil, err
+  }
+  if err := cmd.Start(); err != nil {
+    return nil, err
+  }
+  return &contentMapperProcess{cmd: cmd, stdin: stdin, stdout: stdout}, nil
+}
+
+// contentMapperProcess adapts a mapper's stdout (read) and stdin (write) into
+// one io.ReadWriteCloser.
+type contentMapperProcess struct {
+  cmd    *exec.Cmd
+  stdin  io.WriteCloser
+  stdout io.Reader
+}
+
+func (p *contentMapperProcess) Read(b []byte) (int, error)  { return p.stdout.Read(b) }
+func (p *contentMapperProcess) Write(b []byte) (int, error) { return p.stdin.Write(b) }
+
+// ExitCode reports the process's exit code once it has been reaped; the
+// mapper host reads it to describe a mapper that exited early.
+func (p *contentMapperProcess) ExitCode() (int, bool) {
+  if p.cmd.ProcessState == nil {
+    return 0, false
+  }
+  return p.cmd.ProcessState.ExitCode(), true
+}
+
+// Close kills and reaps the process. Its own exit status is not a close error.
+func (p *contentMapperProcess) Close() error {
+  _ = p.stdin.Close()
+  _ = p.cmd.Process.Kill()
+  err := p.cmd.Wait()
+  if _, ok := errors.AsType[*exec.ExitError](err); ok {
+    return nil
+  }
+  if errors.Is(err, exec.ErrWaitDelay) {
+    return nil
+  }
+  return err
+}

package/targets/7.1/bridge/compiler/emit_sourcemap.go

@@ -0,0 +1,296 @@
+// gen_shims:hand-maintained
+//
+// Source-map emission for the single-file plugin-transform emit path.
+//
+// tsgo's Program.Emit has no hook to inject a custom transformer, so ttsc's
+// driver assembles the per-file emit pipeline by hand (see GetSourceFilesToEmit
+// / GetScriptTransformers / GetOutputPathsFor). That hand-assembly must also
+// reproduce the selected text/map assembly steps: building the printer's
+// options from the compiler options, the source-map branch a bare printer.Write
+// with a nil generator drops entirely, the `emitBOM` byte-order mark, and the
+// trailer position the emitter places in WriteFileData. This file ports
+// internal/compiler/emitter.go's `emitJSFile` PrinterOptions construction and
+// its printing, source-map and BOM assembly policy. The driver owns writing
+// returned artifacts and its metadata; upstream diagnostic/write-result and
+// SourceMaps receipt machinery is not reproduced by this helper. Byte and map
+// compatibility depends on the actual transformed nodes and retained provenance.
+//
+// Keep it in sync with that emitter source when the pin is bumped. Anything
+// `emitJSFile` sets and this file omits takes the Go zero value, which silently
+// turns the option off for every project that emits through a plugin transform,
+// and anything `printSourceFile` does around the printer that this file omits
+// is missing from the plugin lane's output even when the option set matches.
+// `emit_plugin_transform_matches_plain_emit_for_printer_options_test.go` fails
+// when a forwarded option stops matching the plain emit.
+package compiler
+
+import (
+  innerast "github.com/microsoft/TypeScript/tsc/internal/ast"
+  innercore "github.com/microsoft/TypeScript/tsc/internal/core"
+  inneroutputpaths "github.com/microsoft/TypeScript/tsc/internal/outputpaths"
+  innerprinter "github.com/microsoft/TypeScript/tsc/internal/printer"
+  innersourcemap "github.com/microsoft/TypeScript/tsc/internal/sourcemap"
+  innerstringutil "github.com/microsoft/TypeScript/tsc/internal/stringutil"
+  innertspath "github.com/microsoft/TypeScript/tsc/internal/tspath"
+)
+
+// PrintedFile is the rendered output of one source file in the plugin-transform
+// emit path. JS is the script text, carrying a sourceMappingURL trailer when
+// its selected URL is nonempty and a leading UTF-8 BOM when emitBOM is on.
+// MapText/MapPath contain external map text and its selected destination only
+// when mapping is enabled, maps are not inline and that destination is nonempty.
+// They are otherwise empty. These are returned artifacts, not write receipts.
+//
+// @evidence contracts/common.md#principled-implementation The record separates emitted script, optional external map and map destination, retaining the pinned emitter's pre-BOM trailer coordinate rather than mixing file bytes with writer positions.
+// @evidence contracts/common.md#clear-and-simple-design One per-file result carries related output artifacts; absent external maps use empty values and absent trailers use the documented negative sentinel.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The sentinel and pre-BOM coordinate are compiler protocol values, not patched expected answers; no foreign state or consumer-specific output is introduced.
+// @evidence contracts/common.md#meaningful-documentation Native prose explains map absence, inline output and BOM coordinate effects; every member has native documentation separated by blank source lines.
+// @evidence contracts/portability.md#os-neutral-implementation MapPath preserves the host-resolved native output destination while JS contains URI trailer spelling; the fields keep those distinct rather than equating URL and filesystem identity.
+// @evidenceExclude contracts/performance.md#efficient-algorithms This record represents output and does not choose the printing algorithm.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This output record does not coordinate computation across consumers.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Storage lifetime belongs to the printing operation and its caller, not independently to the result declaration.
+type PrintedFile struct {
+  // JS contains emitted script text, optional map trailer and optional BOM.
+  JS string
+
+  // MapText contains the external map JSON, or empty text for inline or absent maps.
+  MapText string
+
+  // MapPath is the destination for MapText, or empty when no external map is emitted.
+  MapPath innertspath.RootedFilePath
+
+  // SourceMapUrlPos is the offset of the `//# sourceMappingURL=` trailer in JS,
+  // or -1 when no trailer was written, the value tsgo's emitter reports as
+  // WriteFileData.SourceMapUrlPos so a caller can locate and rewrite the
+  // trailer without re-scanning the text. Like the emitter's, it is the printer
+  // writer's text position, taken BEFORE the `emitBOM` mark is prepended, so a
+  // BOM build's offset is three bytes short of the trailer's position in the
+  // written file. That is the pinned emitter's own behavior
+  // (internal/compiler/emitter.go::printSourceFile computes sourceMapUrlPos
+  // from the writer and only then calls AddUTF8ByteOrderMark), and this lane
+  // exists to match it: "correcting" the offset here would make a plugin build
+  // disagree with the plain build of the same project.
+  SourceMapUrlPos int
+}
+
+// SourceMapHost supplies the directory and path-identity context the
+// compiler's source-map placement reads: the common source directory that a
+// relative mapRoot and a sourceRoot resolve against, the base directory an
+// absolute mapRoot resolves against, and the case policy of path comparison.
+// The compiler's emit host satisfies it.
+//
+// @evidence contracts/common.md#principled-implementation The three methods are exactly the emit-host queries the pinned emitter's source-map directory and URL policy read.
+// @evidence contracts/common.md#clear-and-simple-design A narrow interface lets a driver-owned emit host supply map context without implementing the declaration-emit host.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Directory context comes from the host's compiler state, not from a guessed process directory.
+// @evidence contracts/common.md#meaningful-documentation Native prose names each method's role in map placement, with a blank line before tags.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources An interface declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms An interface declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work An interface declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation Implementations own path identity; the declaration names rooted path types and a case policy rather than an OS assumption.
+type SourceMapHost interface {
+  // CommonSourceDirectory is the directory a relative mapRoot and a sourceRoot resolve against.
+  //
+  // @evidence contracts/common.md#principled-implementation The query is the emit-host method the pinned emitter's source-map policy reads for this value.
+  // @evidence contracts/common.md#clear-and-simple-design One method supplies one map-placement input without a wider host contract.
+  // @evidence contracts/common.md#prohibited-implementation-shortcuts The value comes from the host's compiler state rather than a guessed process directory.
+  // @evidence contracts/common.md#meaningful-documentation Native prose names the value and its role in map placement following the documentation skill.
+  // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources CommonSourceDirectory declares a signature only; the implementation owns acquisition and release of resources.
+  // @evidenceExclude contracts/performance.md#efficient-algorithms CommonSourceDirectory declares a signature only; the implementation owns the processing strategy.
+  // @evidenceExclude contracts/performance.md#reuse-equivalent-work CommonSourceDirectory declares a signature only; the implementation owns any shared work.
+  // @evidenceExclude contracts/portability.md#os-neutral-implementation CommonSourceDirectory is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+  CommonSourceDirectory() innertspath.RootedDirectoryPath
+
+  // BaseDirectory is the directory an absolute mapRoot resolves against.
+  //
+  // @evidence contracts/common.md#principled-implementation The query is the emit-host method the pinned emitter's source-map policy reads for this value.
+  // @evidence contracts/common.md#clear-and-simple-design One method supplies one map-placement input without a wider host contract.
+  // @evidence contracts/common.md#prohibited-implementation-shortcuts The value comes from the host's compiler state rather than a guessed process directory.
+  // @evidence contracts/common.md#meaningful-documentation Native prose names the value and its role in map placement following the documentation skill.
+  // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources BaseDirectory declares a signature only; the implementation owns acquisition and release of resources.
+  // @evidenceExclude contracts/performance.md#efficient-algorithms BaseDirectory declares a signature only; the implementation owns the processing strategy.
+  // @evidenceExclude contracts/performance.md#reuse-equivalent-work BaseDirectory declares a signature only; the implementation owns any shared work.
+  // @evidenceExclude contracts/portability.md#os-neutral-implementation BaseDirectory is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+  BaseDirectory() innertspath.RootedDirectoryPath
+
+  // CaseSensitivity is the case policy of map path comparison.
+  //
+  // @evidence contracts/common.md#principled-implementation The query is the emit-host method the pinned emitter's source-map policy reads for this value.
+  // @evidence contracts/common.md#clear-and-simple-design One method supplies one map-placement input without a wider host contract.
+  // @evidence contracts/common.md#prohibited-implementation-shortcuts The value comes from the host's compiler state rather than a guessed process directory.
+  // @evidence contracts/common.md#meaningful-documentation Native prose names the value and its role in map placement following the documentation skill.
+  // @evidenceExclude contracts/performance.md#bound-retention-and-release-resources CaseSensitivity declares a signature only; the implementation owns acquisition and release of resources.
+  // @evidenceExclude contracts/performance.md#efficient-algorithms CaseSensitivity declares a signature only; the implementation owns the processing strategy.
+  // @evidenceExclude contracts/performance.md#reuse-equivalent-work CaseSensitivity declares a signature only; the implementation owns any shared work.
+  // @evidenceExclude contracts/portability.md#os-neutral-implementation CaseSensitivity is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+  CaseSensitivity() innertspath.CaseSensitivity
+}
+
+// PrintFileWithSourceMap renders node from sourceFile through a printer built
+// from options and emitContext, optionally generating a source map, mirroring
+// their text/map assembly for the single-file plugin-transform path. It returns
+// artifacts; it does not reproduce upstream writes, diagnostics, SourceMaps
+// receipts or complete WriteFileData. The PrinterOptions below are emitJSFile's, field for
+// field: `removeComments`, `newLine`, `noEmitHelpers`, `sourceMap`,
+// `inlineSourceMap`, `inlineSources`, and `target`. When
+// `sourceMap`/`inlineSourceMap` is enabled (and the file is not JSON) it builds a
+// sourcemap.Generator, feeds it to the printer so positions are recorded,
+// appends the sourceMappingURL trailer, records its offset, and returns the
+// external map text/path (or encodes the map inline). `emitBOM` prepends the
+// UTF-8 byte order mark to the JavaScript afterwards, exactly where
+// printSourceFile does it, outside PrinterOptions, which is why forwarding the
+// whole options struct never reached it. Returned external map text has no BOM,
+// matching the text supplied to upstream's map write.
+// host supplies the same directory/casing context tsgo's emitter reads.
+//
+// The source file, compiler options and host must be nonnil. Original node
+// positions and emitContext provenance determine source-map accuracy.
+//
+// @evidence contracts/common.md#principled-implementation The maintained port follows the pinned emitter's printer options, map eligibility, URI encoding, newline/trailer handling and post-print BOM ordering; upstream printer traversal derives mappings from retained node provenance.
+// @evidence contracts/common.md#clear-and-simple-design One per-file printer/writer/generator owns output assembly, while focused helpers separate source-root, shared map-directory and trailer-URL policy without duplicating output state.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts JSON map suppression, inline maps and pre-BOM offsets implement actual compiler options and output protocol; they do not select fixtures or patch upstream printer behavior.
+// @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish printer settings from post-print BOM effects, external from inline maps, path context and provenance requirements; the result documents its coordinate convention explicitly.
+// @evidence contracts/portability.md#os-neutral-implementation Compiler path helpers normalize native output paths, host-provided case sensitivity governs relative identity, and trailer paths are separately URI-encoded; URL spelling is not treated as filesystem casing.
+// @evidence contracts/performance.md#efficient-algorithms Text and mapping collection share one printer invocation; upstream printing can also consult node provenance, semantic helpers, source positions and path text, so this is not a strict one-pass bound over input or output bytes. Map-table copies and JSON serialization, optional base64, trailer writes and a BOM text copy add their own work. The writer's recorded position avoids rescanning emitted text just to locate the trailer.
+// @evidence contracts/performance.md#reuse-equivalent-work Text and source mappings share the printer traversal and EmitContext provenance; no cross-file printer source-index state is reused, and compiler options and transformed nodes determine each output.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Per-call printer, writer and generator hold output buffers, source/name indexes, mapping segments and optional borrowed source text. Map serialization/base64 and BOM assembly can temporarily coexist with those buffers; result strings retain their backing bytes after return. EmitContext and source/semantic graphs remain caller-owned, and this function adds no historical result registry or spawned task. No fixed byte cap is imposed here.
+func PrintFileWithSourceMap(
+  emitContext *innerprinter.EmitContext,
+  node *innerast.Node,
+  sourceFile *innerast.SourceFile,
+  options *innercore.CompilerOptions,
+  host SourceMapHost,
+  jsFilePath innertspath.RootedFilePath,
+  sourceMapFilePath innertspath.RootedFilePath,
+) PrintedFile {
+  printer := innerprinter.NewPrinter(innerprinter.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,
+  }, innerprinter.PrintHandlers{}, emitContext)
+  writer := innerprinter.NewTextWriter(options.NewLine.GetNewLineCharacter(), 0)
+
+  shouldEmit := (options.SourceMap.IsTrue() || options.InlineSourceMap.IsTrue()) &&
+    !sourceFile.FileName().ExtensionIs(innertspath.ExtensionJson)
+
+  var generator *innersourcemap.Generator
+  if shouldEmit {
+    generator = innersourcemap.NewGenerator(
+      jsFilePath.BaseName(),
+      sourceMapSourceRoot(options),
+      SourceMapDirectory(options, host, jsFilePath, sourceFile),
+      host.CaseSensitivity(),
+    )
+  }
+
+  printer.Write(node, sourceFile, writer, generator)
+
+  result := PrintedFile{SourceMapUrlPos: -1}
+  if generator != nil {
+    url := sourceMappingURL(options, generator, host, jsFilePath, sourceMapFilePath, sourceFile)
+    if len(url) > 0 {
+      if !writer.IsAtStartOfLine() {
+        if options.NewLine == innercore.NewLineKindCRLF {
+          writer.RawWrite("\r\n")
+        } else {
+          writer.RawWrite("\n")
+        }
+      }
+      result.SourceMapUrlPos = writer.GetTextPos()
+      writer.WriteComment("//# sourceMappingURL=")
+      writer.WriteComment(url)
+    }
+    if !options.InlineSourceMap.IsTrue() && sourceMapFilePath != "" {
+      result.MapText = generator.String()
+      result.MapPath = sourceMapFilePath
+    }
+  } else {
+    writer.WriteLine()
+  }
+  result.JS = writer.String()
+  if options.EmitBOM.IsTrue() {
+    result.JS = innerstringutil.AddUTF8ByteOrderMark(result.JS)
+  }
+  return result
+}
+
+// sourceMapSourceRoot mirrors emitter.getSourceRoot: a normalized sourceRoot
+// with a trailing separator so it composes with the relative source paths.
+func sourceMapSourceRoot(options *innercore.CompilerOptions) string {
+  root := options.SourceRoot.AsString()
+  if len(root) > 0 {
+    root = innertspath.EnsureTrailingDirectorySeparator(root)
+  }
+  return root
+}
+
+// SourceMapDirectory returns the directory the pinned compiler's source-map
+// generator uses to resolve source paths. This is the generator's internal
+// directory context, not the map's published sourceRoot field.
+//
+// A nonempty sourceRoot selects the host's common source directory. Otherwise
+// mapRoot selects the map directory, projecting sourceFile's path into that
+// root when sourceFile is present; a relative mapRoot is based on the common
+// source directory and an absolute one on the host's base directory. Without
+// either option, the output file's directory is used.
+// The options and host must be nonnil; sourceFile may be nil.
+//
+// @evidence contracts/common.md#principled-implementation The maintained helper follows pinned emitter.getSourceMapDirectory's sourceRoot precedence, per-source mapRoot projection and relative-root anchoring, returning the exact generator base instead of assuming maps are based on an emitted file directory.
+// @evidence contracts/common.md#clear-and-simple-design One supported public helper owns generator-directory policy for printing and downstream map consumers, avoiding independently implemented path-base rules.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Directory selection follows real compiler options and host context, including URL and relative roots, without a consumer-specific map repair or filesystem guessing.
+// @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish internal generator context from published sourceRoot, describe option precedence and path projection, and state nonnil versus optional inputs.
+// @evidence contracts/portability.md#os-neutral-implementation Compiler path helpers handle native roots and URL spelling separately, while per-source projection uses the host's actual current/common directories and case policy rather than an OS-name assumption.
+// @evidence contracts/performance.md#efficient-algorithms Branching applies sourceRoot/mapRoot precedence and compiler path normalization/remapping over path text. Host CommonSourceDirectory/current-directory/case queries are delegated work and may compute or reuse source metadata; the absence of a local file loop does not bound those host costs. Centralizing this policy avoids separate consumer implementations, not all repeated path work.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work This pure path-context calculation does not coordinate completed or in-flight work across requests; map consumers own any per-file index of its results.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Intermediate normalized/remapped path strings are invocation-local, and the returned directory string can retain newly allocated or borrowed backing bytes. Host-owned common-directory/source metadata remains with that host. This helper keeps no independent historical result cache, native handle or running task; callers determine the returned string's retention.
+func SourceMapDirectory(options *innercore.CompilerOptions, host SourceMapHost, filePath innertspath.RootedFilePath, sourceFile *innerast.SourceFile) innertspath.RootedDirectoryPath {
+  if len(options.SourceRoot) > 0 {
+    return host.CommonSourceDirectory()
+  }
+  if len(options.MapRoot) > 0 {
+    return mapRootDirectory(options.MapRoot, host, sourceFile)
+  }
+  return filePath.Directory()
+}
+
+// mapRootDirectory mirrors emitter.getMapRootDirectory: mapRoot resolved
+// against the common source directory when relative and the base directory
+// otherwise, then narrowed to sourceFile's projected directory beneath it.
+func mapRootDirectory(mapRoot innertspath.SourceMapLocation, host SourceMapHost, sourceFile *innerast.SourceFile) innertspath.RootedDirectoryPath {
+  directory := mapRoot.ResolveDirectory(host.CommonSourceDirectory(), host.BaseDirectory())
+  if sourceFile != nil {
+    directory = inneroutputpaths.GetSourceFileNameInNewDir(
+      sourceFile.FileName(),
+      directory,
+      host.CommonSourceDirectory(),
+      host.CaseSensitivity(),
+    ).Directory()
+  }
+  return directory
+}
+
+// sourceMappingURL mirrors emitter.getSourceMappingURL: the value written after
+// `//# sourceMappingURL=`, either an inline base64 data URL or the encoded path
+// to the external `.js.map` (honoring mapRoot).
+func sourceMappingURL(options *innercore.CompilerOptions, generator *innersourcemap.Generator, host SourceMapHost, filePath innertspath.RootedFilePath, sourceMapFilePath innertspath.RootedFilePath, sourceFile *innerast.SourceFile) string {
+  if options.InlineSourceMap.IsTrue() {
+    return generator.Base64DataURL()
+  }
+  sourceMapFile := sourceMapFilePath.BaseName()
+  if len(options.MapRoot) > 0 {
+    mapFilePath := mapRootDirectory(options.MapRoot, host, sourceFile).ResolveFile(sourceMapFile)
+    if options.MapRoot.IsRelative() {
+      return innerstringutil.EncodeURI(innertspath.GetRelativePathToDirectoryOrUrl(
+        filePath.Directory().AsString(),
+        mapFilePath.AsString(),
+        true,
+        host.CaseSensitivity(),
+      ))
+    }
+    return innerstringutil.EncodeURI(mapFilePath.AsString())
+  }
+  return innerstringutil.EncodeURI(sourceMapFile)
+}

package/targets/7.1/bridge/compiler/emitassemble.go

@@ -0,0 +1,81 @@
+// gen_shims:hand-maintained
+//
+// Emit-pipeline assembly parts: pick the files tsgo would emit and resolve
+// their output paths, so ttsc's driver can drive emit per file with a plugin
+// transformer inserted ahead of the builtin chain.
+package compiler
+
+import (
+  _ "unsafe"
+
+  innerast "github.com/microsoft/TypeScript/tsc/internal/ast"
+  innercompiler "github.com/microsoft/TypeScript/tsc/internal/compiler"
+  innercore "github.com/microsoft/TypeScript/tsc/internal/core"
+  inneroutputpaths "github.com/microsoft/TypeScript/tsc/internal/outputpaths"
+)
+
+// GetSourceFilesToEmit returns the source files tsgo would emit for the program
+// (excludes .d.ts and external-library files), linked from the internal package.
+// A nil targetSourceFiles selects every program file; forceDtsEmit and
+// forceJsEmit select files whose declaration or script output would otherwise
+// be suppressed.
+//
+// @evidence contracts/common.md#principled-implementation Linking the pinned compiler's own selection helper preserves its target-file, declaration and compiler-option eligibility decisions rather than recreating emit selection.
+// @evidence contracts/common.md#clear-and-simple-design The direct declaration exposes selection independently of output writing, allowing the driver to insert transformers while retaining compiler ownership of eligible files.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The symbol bridge exposes upstream behavior without replacing it; forceDtsEmit and forceJsEmit are actual compiler controls, not fixture exceptions.
+// @evidence contracts/common.md#meaningful-documentation Native prose describes emitted-file selection and internal linkage, with the acknowledgment separated from the Go linkage directive.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This exposes upstream emit eligibility and does not choose native path identity or perform filesystem access.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources GetSourceFilesToEmit declares a signature only; the implementation owns acquisition and release of resources.
+// @evidenceExclude contracts/performance.md#efficient-algorithms GetSourceFilesToEmit declares a signature only; the implementation owns the processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work GetSourceFilesToEmit declares a signature only; the implementation owns any shared work.
+//
+//go:linkname GetSourceFilesToEmit github.com/microsoft/TypeScript/tsc/internal/compiler.getSourceFilesToEmit
+func GetSourceFilesToEmit(host innercompiler.SourceFileMayBeEmittedHost, targetSourceFiles []*innerast.SourceFile, forceDtsEmit bool, forceJsEmit bool) []*innerast.SourceFile
+
+// OutputPaths holds the resolved output file paths for one source file.
+// Empty fields represent outputs disabled or suppressed by upstream policy,
+// such as a JSON script destination identical to its source location. Resolved
+// destinations do not certify that later emit or writing succeeds.
+//
+// @evidence contracts/common.md#principled-implementation The exact upstream output-path alias preserves separate script, declaration and map destinations, including absent outputs, without losing compiler-resolved path distinctions.
+// @evidence contracts/common.md#clear-and-simple-design One compiler-owned result groups related outputs for a source file, avoiding independently recomputed paths at each sink.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The alias does not insert consumer-specific filenames or alter output policy.
+// @evidence contracts/common.md#meaningful-documentation Native prose states per-file output ownership and the meaning of empty destinations.
+// @evidence contracts/portability.md#os-neutral-implementation Output fields preserve the compiler's host-resolved native destinations, including absent outputs, rather than imposing URL spelling or an OS-derived case policy.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+type OutputPaths = inneroutputpaths.OutputPaths
+
+// ForceEmitPaths selects outputs GetOutputPathsFor resolves even when the
+// compiler options would suppress them: declarations, scripts and declaration
+// maps.
+//
+// @evidence contracts/common.md#principled-implementation The alias preserves upstream's force-selection record, so callers state each forced output class exactly as the emitter does.
+// @evidence contracts/common.md#clear-and-simple-design One upstream record replaces a positional flag per output class.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The fields are actual compiler emit controls rather than shim-specific overrides.
+// @evidence contracts/common.md#meaningful-documentation Native prose names each selected output class, with a blank line before tags.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+// @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation This type declaration describes a data shape only; it opens no file, builds no path and branches on no platform.
+type ForceEmitPaths = inneroutputpaths.ForceEmitPaths
+
+// GetOutputPathsFor resolves script, declaration and map destinations using
+// upstream extension and output-directory policy. The script extension can
+// also be .jsx, .mjs, .cjs or .json; disabled or suppressed outputs are empty.
+// The host supplies the common source directory, current directory and case
+// policy. This is path selection, not proof that emit writes every destination.
+// sourceFile, options and host must satisfy the upstream resolver's premises.
+//
+// @evidence contracts/common.md#principled-implementation The wrapper delegates the same source file, options, host and forced-output selection to the compiler's output-path algorithm, preserving root and output directory semantics.
+// @evidence contracts/common.md#clear-and-simple-design Output placement remains in upstream's owning helper; this adapter only exposes that boundary to the driver.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts No path is fabricated from a consumer or fixture name, and the upstream output resolver is neither copied nor patched.
+// @evidence contracts/common.md#meaningful-documentation Native prose names the output classes, relevant directory options and host context, with a separate acknowledgment section.
+// @evidence contracts/portability.md#os-neutral-implementation Upstream's output resolver receives the actual host directory and path-identity policy; the shim does not guess separators, drive roots or case sensitivity from an OS name.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Upstream allocates a returned OutputPaths object and constructs or borrows destination strings; their backing storage survives with the caller's result. Host-owned directory and case-policy state remains with the host. This bridge acquires no independent file handle or persistent result registry.
+// @evidenceExclude contracts/performance.md#efficient-algorithms Upstream owns extension selection, path normalization, comparison and directory remapping, including work proportional to path text and any host directory lookup. This direct adapter chooses no separate output-path algorithm.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work Output-path computation and any reusable common-directory or host metadata belong to the upstream resolver and host. This bridge coordinates no independent cache or cross-call producer.
+func GetOutputPathsFor(sourceFile *innerast.SourceFile, options *innercore.CompilerOptions, host inneroutputpaths.OutputPathsHost, force ForceEmitPaths) *inneroutputpaths.OutputPaths {
+  return inneroutputpaths.GetOutputPathsFor(sourceFile, options, host, force)
+}

package/targets/7.1/bridge/compiler/emithook.go

@@ -0,0 +1,44 @@
+// gen_shims:hand-maintained
+//
+// Exposes tsgo's emit-stage internals so ttsc can assemble the emit pipeline
+// from real tsgo parts (no tsgo source copy/edit): obtain the builtin
+// transformer chain for a file and prepend a plugin transformer that shares the
+// same EmitContext, so module-transform aliases plugin-generated imports.
+package compiler
+
+import (
+  _ "unsafe"
+
+  innerast "github.com/microsoft/TypeScript/tsc/internal/ast"
+  innerprinter "github.com/microsoft/TypeScript/tsc/internal/printer"
+  innertransformers "github.com/microsoft/TypeScript/tsc/internal/transformers"
+)
+
+// GetScriptTransformers returns tsgo's builtin emit transformer chain
+// (type-erase, import-elision, runtime-syntax, module-transform, ...) for one
+// source file, linked from the internal package via go:linkname.
+// emitResolver must carry the EmitContext the chain transforms in; obtain it
+// from the emit host's NewEmitResolver for that context.
+//
+// `sourceFile` is the marking target, not the file that gets transformed.
+// Upstream reads it for two per-file constants (in-JS-file, JSX language
+// variant) and, unless isolated modules without import elision, JSX transform
+// or decorator metadata makes marking unnecessary, hands it to
+// emitResolver.MarkLinkedReferencesRecursively, whose marks the import-elision
+// transformer later reads back through EmitContext.ParseNode. A caller that runs a plugin pass first must therefore
+// pass the PARSE tree here and the transformed tree to TransformSourceFile;
+// upstream's own emitter passes one file to both only because it has nothing in
+// between. Re-check this when the pin moves: a new use of the parameter inside
+// getScriptTransformers could make the two roles diverge further.
+//
+// @evidence contracts/common.md#principled-implementation Linking the pinned builtin chain preserves compiler transform ordering; the parse-tree argument supplies stable linked-reference marks that transformed nodes retrieve through EmitContext provenance.
+// @evidence contracts/common.md#clear-and-simple-design The helper exposes chain assembly without running transforms, keeping plugin insertion in the driver and builtin ordering in the compiler.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts The source-file distinction follows the pinned helper's marking semantics rather than masking an arbitrary transform failure; linkage exposes the function without replacing its implementation.
+// @evidence contracts/common.md#meaningful-documentation Native paragraphs explain chain contents, marking versus transformation roles and the version-pin premise, with Go linkage retained outside the prose section.
+// @evidenceExclude contracts/performance.md#bound-retention-and-release-resources GetScriptTransformers declares a signature only; the implementation owns acquisition and release of resources.
+// @evidenceExclude contracts/performance.md#efficient-algorithms GetScriptTransformers declares a signature only; the implementation owns the processing strategy.
+// @evidenceExclude contracts/performance.md#reuse-equivalent-work GetScriptTransformers declares a signature only; the implementation owns any shared work.
+// @evidenceExclude contracts/portability.md#os-neutral-implementation GetScriptTransformers is a signature without a body here; path and platform behavior belongs to the implementation that supplies it.
+//
+//go:linkname GetScriptTransformers github.com/microsoft/TypeScript/tsc/internal/compiler.getScriptTransformers
+func GetScriptTransformers(emitResolver innerprinter.EmitResolver, host innerprinter.EmitHost, sourceFile *innerast.SourceFile) []*innertransformers.Transformer

package/targets/7.1/bridge/compiler/extra-shim.json

@@ -0,0 +1,4 @@
+{
+  "ExtraMethods": {},
+  "ExtraFields": {}
+}

package/targets/7.1/bridge/compiler/go.mod

@@ -0,0 +1,15 @@
+module github.com/microsoft/TypeScript/tsc/shim/compiler
+
+go 1.27
+
+require github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906
+
+require (
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/klauspost/compress v1.20.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.23.0 // indirect
+	golang.org/x/sys v0.48.0 // indirect
+	golang.org/x/text v0.42.0 // indirect
+)

package/targets/7.1/bridge/compiler/go.sum

@@ -0,0 +1,24 @@
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/compress v1.20.0 h1:a3C1ke2ohxFymNlb2HWAHjDeKCI90scRskErZkR0ezA=
+github.com/klauspost/compress v1.20.0/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906 h1:Wn+Kp4ORyay6jJwvOng7G8pTD6HOP+Fwx8si66Wq7Bk=
+github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906/go.mod h1:28hWKaTYwRARPm0T9Y0XvdvYpU2HtjONzsMqAdYLucY=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
+golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
+golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
+golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
+golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=