ttsc 0.26.0 → 0.26.2

package/README.md

@@ -38,7 +38,7 @@ That covers the CLI. The integrations each have a short guide:
 
 ## Lint
 
-Lint and format inside the type-check you already run. 720+ rules across 21 families, plus a formatter that reproduces Prettier's output.
+Lint and format inside the type-check you already run. 720+ rules across 21 families, plus a formatter whose rules are ported from Prettier 3.8.3 — see the [format guide](https://ttsc.dev/docs/lint/format) for the shapes it covers and the ones it leaves alone.
 
 ```ts
 // src/index.ts

package/driver/diagnostics_preamble.go

@@ -0,0 +1,284 @@
+package driver
+
+import (
+  "strings"
+
+  "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/microsoft/typescript-go/shim/core"
+  shimparser "github.com/microsoft/typescript-go/shim/parser"
+)
+
+// Source-preamble correction for compiler diagnostics.
+//
+// ttsc injects a plugin's source preamble (e.g. @ttsc/banner's copyright block)
+// at the SOURCE level: sourcePreambleFS prepends it before TypeScript-Go parses,
+// so the preamble participates in comment emission, removeComments, JSDoc
+// association, and `.d.ts` emit naturally. The side effect is that every
+// position tsgo records — including every diagnostic's — is shifted down by the
+// preamble's line count, while the file the user reads has no preamble. The
+// emitted source map already undoes that shift (AdjustEmittedSourceMap); this is
+// the same invariant applied to the other coordinate the user is shown.
+//
+// The correction lives here, at the Program boundary where the preamble is
+// known, rather than in each renderer. `WritePrettyDiagnostics`, the structured
+// diagnostic list the JS launcher serializes, the graph snapshot, and any future
+// consumer all read a Diagnostic that is already authored-relative, so none of
+// them has to remember.
+
+// preambleView is the authored (preamble-free) view of one preamble-injected
+// source file, plus the byte region the preamble occupies in the buffer tsgo
+// parsed.
+//
+// file is a re-parse of the authored text. The diagnostic renderer reads a
+// source file's FileName, Text, and ECMA line map to place a location and quote
+// a code frame, and all three have to describe the text the user wrote — moving
+// the position alone would still quote the preamble-bearing buffer. Re-parsing
+// is what produces a line map tsgo itself computed rather than one this package
+// re-derived, and it costs one parse per file that actually carries a
+// diagnostic.
+type preambleView struct {
+  file *ast.SourceFile
+  // start is the byte offset where the preamble was inserted, and length its
+  // byte length. ApplySourcePreamble inserts after a BOM and after a hashbang
+  // line, so start is not always zero.
+  start  int
+  length int
+}
+
+// authoredPos maps a position in the preamble-bearing buffer to the authored
+// file. ok is false for a position inside the injected region, which has no
+// authored counterpart at all.
+func (v *preambleView) authoredPos(pos int) (int, bool) {
+  if pos < v.start {
+    return pos, true
+  }
+  if pos >= v.start+v.length {
+    return pos - v.length, true
+  }
+  return 0, false
+}
+
+// authoredEnd maps an exclusive end offset. An end inside the injected region is
+// truncated to the region's authored boundary, so a range that starts before the
+// preamble never stretches over text the user did not write.
+func (v *preambleView) authoredEnd(end int) int {
+  if end <= v.start {
+    return end
+  }
+  if end >= v.start+v.length {
+    return end - v.length
+  }
+  return v.start
+}
+
+// sourcePreambleBOM is the UTF-8 byte order mark ApplySourcePreamble keeps
+// ahead of an injected preamble.
+const sourcePreambleBOM = "\ufeff"
+
+// sourcePreambleRegion locates the injected preamble inside the text tsgo
+// parsed, mirroring ApplySourcePreamble's insertion point: after a BOM, and
+// after a hashbang line when one is present.
+//
+// The region is read back out of the parsed text rather than recomputed from the
+// on-disk file, so it stays correct whichever of the BOM or hashbang the host
+// stripped before parsing, and the leading-prefix check makes the result
+// self-verifying: a file the preamble was never injected into (a declaration
+// file, a `.json` input, a library file) simply does not match and is reported
+// as having no region.
+//
+// One degenerate shape is nominally off by one, matching the same allowance
+// AdjustSourceMapForPreamble states: a file whose entire content is a hashbang
+// with no trailing newline gets the preamble appended after an inserted newline,
+// which is indistinguishable from an authored trailing newline. Only a position
+// at that file's very end could differ, and such a file has no code to diagnose.
+func sourcePreambleRegion(filePath, text, preamble string) (start int, length int, ok bool) {
+  if preamble == "" || !isSourcePreambleTarget(filePath) {
+    return 0, 0, false
+  }
+  start = 0
+  if strings.HasPrefix(text, sourcePreambleBOM) {
+    start = len(sourcePreambleBOM)
+  }
+  if strings.HasPrefix(text[start:], "#!") {
+    newline := strings.IndexByte(text[start:], '\n')
+    if newline < 0 {
+      return 0, 0, false
+    }
+    start += newline + 1
+  }
+  if !strings.HasPrefix(text[start:], preamble) {
+    return 0, 0, false
+  }
+  return start, len(preamble), true
+}
+
+// preambleMapper rebuilds diagnostics against the authored source files of one
+// preamble-bearing Program. It caches one authored view per source file so every
+// diagnostic in a file shares a single re-parsed file object — the renderer's
+// "Found N errors in M files" summary groups by that object's identity.
+//
+// A mapper is built per diagnostics call and thrown away with it: it holds
+// re-parsed source files, which have no reason to outlive the report they were
+// built for.
+type preambleMapper struct {
+  preamble string
+  views    map[*ast.SourceFile]*preambleView
+}
+
+// newPreambleMapper returns nil when this Program has no source preamble, which
+// is the signal to leave every diagnostic exactly as tsgo produced it.
+func (p *Program) newPreambleMapper() *preambleMapper {
+  if p == nil || p.SourcePreamble == "" {
+    return nil
+  }
+  return &preambleMapper{
+    preamble: p.SourcePreamble,
+    views:    map[*ast.SourceFile]*preambleView{},
+  }
+}
+
+// viewOf returns the authored view of file, or nil when the preamble was never
+// injected into it.
+func (m *preambleMapper) viewOf(file *ast.SourceFile) *preambleView {
+  if m == nil || file == nil {
+    return nil
+  }
+  if view, cached := m.views[file]; cached {
+    return view
+  }
+  view := newPreambleView(file, m.preamble)
+  m.views[file] = view
+  return view
+}
+
+// newPreambleView re-parses file without its injected preamble. It returns nil
+// when the file carries no preamble, or when the re-parse yields nothing to
+// 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)
+  if !ok {
+    return nil
+  }
+  authored := shimparser.ParseSourceFile(file.ParseOptions(), text[:start]+text[start+length:], file.ScriptKind)
+  if authored == nil {
+    return nil
+  }
+  return &preambleView{file: authored, start: start, length: length}
+}
+
+// remapDiagnostic returns d anchored to its authored source file. ok is false
+// when d's own position falls inside the injected preamble, which is the one
+// case with no authored answer; see unanchoredPreambleDiagnostic for what the
+// caller does with it.
+//
+// The original diagnostic is never mutated: it belongs to the Program's own
+// diagnostic collection, which other callers read.
+func (m *preambleMapper) remapDiagnostic(d *ast.Diagnostic) (*ast.Diagnostic, bool) {
+  if m == nil || d == nil {
+    return d, d != nil
+  }
+  related, relatedChanged := m.remapRelated(d.RelatedInformation())
+  view := m.viewOf(d.File())
+  if view == nil {
+    if !relatedChanged {
+      return d, true
+    }
+    clone := d.Clone()
+    clone.SetRelatedInfo(related)
+    return clone, true
+  }
+  pos, ok := view.authoredPos(d.Pos())
+  if !ok {
+    return nil, false
+  }
+  clone := d.Clone()
+  clone.SetFile(view.file)
+  clone.SetLocation(core.NewTextRange(pos, view.authoredEnd(d.End())))
+  if relatedChanged {
+    clone.SetRelatedInfo(related)
+  }
+  return clone, true
+}
+
+// remapRelated remaps a diagnostic's related information, each entry against its
+// own file. An entry with no authored counterpart is dropped rather than
+// reported without a position: related information exists only to point at a
+// second location, and the primary diagnostic still carries the message.
+func (m *preambleMapper) remapRelated(in []*ast.Diagnostic) ([]*ast.Diagnostic, bool) {
+  if len(in) == 0 {
+    return nil, false
+  }
+  out := make([]*ast.Diagnostic, 0, len(in))
+  changed := false
+  for _, related := range in {
+    mapped, ok := m.remapDiagnostic(related)
+    if !ok {
+      changed = true
+      continue
+    }
+    if mapped != related {
+      changed = true
+    }
+    out = append(out, mapped)
+  }
+  return out, changed
+}
+
+// unanchoredPreambleDiagnostic reports a diagnostic whose position lies inside
+// an injected source preamble.
+//
+// The preamble is text the user never wrote, so there is no authored line to
+// name. The source-map lane drops such segments, but a diagnostic is not a
+// mapping: dropping it would leave a failing build with nothing on stderr to
+// explain the failure, and clamping it to the top of the file would print a
+// coordinate that is simply false — the exact defect this correction exists to
+// remove. So the report is kept and only the coordinate is dropped: the message,
+// the code, and the file the preamble was injected into survive, and the
+// diagnostic renders through the anchor-less `path: message` form ttsc already
+// uses for diagnostics that have no source range. It counts as an error exactly
+// as it did before, so the exit code is unchanged.
+//
+// One consequence to know: the JS launcher recovers structured diagnostics by
+// parsing rendered text, and the anchor-less form carries no `line:col` for that
+// parser to match — so a preamble-region diagnostic reaches stderr and the exit
+// code but not `IFailure.diagnostics`. That is the same deal every anchor-less
+// driver diagnostic has always had (`driver: linked plugins failed to apply`),
+// and it is preferable to publishing a structured position that is not real.
+func unanchoredPreambleDiagnostic(d *ast.Diagnostic) Diagnostic {
+  out := Diagnostic{
+    Code:     d.Code(),
+    Message:  d.String(),
+    Severity: SeverityError,
+  }
+  if file := d.File(); file != nil {
+    out.File = file.FileName()
+  }
+  return out
+}
+
+// convertProgramDiagnostics converts tsgo diagnostics produced by this Program,
+// undoing any source-preamble shift first. Every path that turns this Program's
+// raw diagnostics into driver Diagnostics goes through here, so the correction
+// cannot be forgotten by a new caller. Diagnostics that never pass through a
+// Program — a tsconfig parse failure, a bad CLI flag — keep using
+// convertDiagnostics directly, because no preamble is ever injected into them.
+func (p *Program) convertProgramDiagnostics(in []*ast.Diagnostic) []Diagnostic {
+  mapper := p.newPreambleMapper()
+  if mapper == nil {
+    return convertDiagnostics(in)
+  }
+  out := make([]Diagnostic, 0, len(in))
+  for _, d := range in {
+    if d == nil {
+      continue
+    }
+    mapped, ok := mapper.remapDiagnostic(d)
+    if !ok {
+      out = append(out, unanchoredPreambleDiagnostic(d))
+      continue
+    }
+    out = append(out, convertDiagnostic(mapped))
+  }
+  return out
+}

package/driver/emit_plugin.go

@@ -133,13 +133,16 @@ func restoreOriginalDeclarationSymbols(ec *shimprinter.EmitContext, node *shimas
 // EmitTransformPlugins are chained after the caller's transforms in
 // registration order.
 //
-// Because the JavaScript side bypasses tsgo's own emitter, it reproduces the
-// emitter's source-map step via PrintFileWithSourceMap: a `sourceMap` /
-// `inlineSourceMap` build emits a `.js.map` (and `//# sourceMappingURL=`
-// trailer) just like a plain build, even when a transform expanded one source
-// line into many. All non-JavaScript outputs stay delegated to tsgo's normal
-// dts-only emitter so declaration files, declaration maps, and any future
-// declaration-lane outputs are not silently lost by the hand-assembled JS path.
+// Because the JavaScript side bypasses tsgo's own emitter, it reproduces that
+// emitter's whole printSourceFile step via PrintFileWithSourceMap: a
+// `sourceMap` / `inlineSourceMap` build emits a `.js.map` (and
+// `//# sourceMappingURL=` trailer) just like a plain build, even when a
+// transform expanded one source line into many; an `emitBOM` build still starts
+// with the byte order mark; and the caller's WriteFile still receives the
+// WriteFileData the emitter would hand it. All non-JavaScript outputs stay
+// delegated to tsgo's normal dts-only emitter so declaration files, declaration
+// maps, and any future declaration-lane outputs are not silently lost by the
+// hand-assembled JS path.
 func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, writeFile shimcompiler.WriteFile) ([]Diagnostic, error) {
   if p == nil || p.TSProgram == nil {
     return nil, errors.New("driver: nil program")
@@ -183,10 +186,10 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       }
       // Print through the source-map-aware helper so a `sourceMap` /
       // `inlineSourceMap` build still gets its `.js.map` and sourceMappingURL
-      // trailer: the hand-assembled emit pipeline does not run tsgo's emitter,
-      // so the source-map step printSourceFile would otherwise perform has to
-      // happen here. With maps off this is the same bare-printer output as
-      // before.
+      // trailer, and an `emitBOM` build its leading mark: the hand-assembled
+      // emit pipeline does not run tsgo's emitter, so everything printSourceFile
+      // would otherwise do around the printer has to happen here. With maps and
+      // emitBOM off this is the same bare-printer output as before.
       printed := shimcompiler.PrintFileWithSourceMap(ec, out.AsNode(), out, options, host, paths.JsFilePath(), paths.SourceMapFilePath())
       // A source-level preamble (e.g. @ttsc/banner linked into a typia host)
       // shifts the map's source coordinates; correct them here too, so the
@@ -204,10 +207,17 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
           }
         }
       }
-      if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, writeFile); err != nil {
+      // 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,
+      }, writeFile); err != nil {
         return nil, err
       }
-      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, writeFile); err != nil {
+      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, nil, writeFile); err != nil {
         return nil, err
       }
     }
@@ -235,17 +245,42 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
     },
   })
   if result != nil && len(result.Diagnostics) != 0 {
-    return convertDiagnostics(result.Diagnostics), nil
+    return p.convertProgramDiagnostics(result.Diagnostics), nil
   }
   return nil, nil
 }
 
-func (p *Program) writePluginEmitOutput(fileName, text string, writeFile shimcompiler.WriteFile) error {
+// writePluginEmitOutput writes one artifact of the hand-assembled emit, passing
+// the caller's WriteFile the same WriteFileData tsgo's emitter would.
+//
+// What this lane can populate, and what it deliberately cannot:
+//
+//   - SourceMapUrlPos: the offset of the `//# sourceMappingURL=` trailer, or -1
+//     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. This is why a nil data was a real loss and
+//     not merely a cosmetic one.
+//   - 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
+//     EmitWithPluginTransformers instead, and the declaration lane's diagnostics
+//     reach the caller through tsgo's own EmitOnlyDts pass and its own
+//     WriteFileData. Empty therefore means "nothing to report", not "never
+//     populated".
+//   - BuildInfo: always nil. It is the `.tsbuildinfo` payload, and this lane
+//     emits only JavaScript and its map.
+//   - SkippedDtsWrite: an out-parameter for the callee, left zero. Each write
+//     gets its own struct so one file's callback cannot observe another's.
+//
+// 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 {
   if fileName == "" || p.outputEscapesOutDir(fileName) {
     return nil
   }
   if writeFile != nil {
-    return writeFile(fileName, text, nil)
+    return writeFile(fileName, text, data)
   }
   return DefaultWriteFile(fileName, text)
 }

package/driver/program.go

@@ -638,7 +638,11 @@ func (p *Program) diagnostics(files []*ast.SourceFile) []Diagnostic {
     }
   }
   raw = filterDiagnostics(raw)
-  return append(out, convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))...)
+  // filterDiagnostics runs first because it resolves a node from the position
+  // tsgo recorded, which only makes sense against the tree tsgo parsed. The
+  // preamble correction happens inside convertProgramDiagnostics, once the
+  // positions are no longer used to look anything up.
+  return append(out, p.convertProgramDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))...)
 }
 
 // filterDiagnostics removes diagnostics that are false positives in ttsc's
@@ -684,25 +688,34 @@ func isUnusedOverloadSignatureTypeParameterDiagnostic(d *ast.Diagnostic) bool {
 // convertDiagnostics translates shim-specific diagnostics into the plain
 // Diagnostic struct with line/column populated via tsgo's ECMALineMap (the
 // same helper tsc uses for its "file:line:col: message" banner).
+//
+// Diagnostics produced by a Program go through convertProgramDiagnostics
+// instead, which undoes a source preamble's position shift first.
 func convertDiagnostics(in []*ast.Diagnostic) []Diagnostic {
   out := make([]Diagnostic, 0, len(in))
   for _, d := range in {
     if d == nil {
       continue
     }
-    diag := Diagnostic{Code: d.Code(), Message: d.String(), raw: d}
-    if file := d.File(); file != nil {
-      diag.File = file.FileName()
-      if pos := d.Pos(); pos >= 0 {
-        length := d.Len()
-        diag.Start = &pos
-        diag.Length = &length
-        line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
-        diag.Line = line + 1
-        diag.Column = col + 1
-      }
-    }
-    out = append(out, diag)
+    out = append(out, convertDiagnostic(d))
   }
   return out
 }
+
+// convertDiagnostic translates one shim diagnostic, taking its file, line, and
+// column from whatever source file the diagnostic is anchored to.
+func convertDiagnostic(d *ast.Diagnostic) Diagnostic {
+  diag := Diagnostic{Code: d.Code(), Message: d.String(), raw: d}
+  if file := d.File(); file != nil {
+    diag.File = file.FileName()
+    if pos := d.Pos(); pos >= 0 {
+      length := d.Len()
+      diag.Start = &pos
+      diag.Length = &length
+      line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+      diag.Line = line + 1
+      diag.Column = col + 1
+    }
+  }
+  return diag
+}

package/driver/rewrite.go

@@ -132,7 +132,7 @@ func (p *Program) EmitAllRaw(writeFile shimcompiler.WriteFile) (*shimcompiler.Em
   result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
     WriteFile: wf,
   })
-  return result, convertDiagnostics(result.Diagnostics), nil
+  return result, p.convertProgramDiagnostics(result.Diagnostics), nil
 }
 
 // EmitFile runs tsgo's emitter for one source file, applying the same rewrite
@@ -201,7 +201,7 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
     TargetSourceFile: target,
     WriteFile:        wf,
   })
-  return result, convertDiagnostics(result.Diagnostics), nil
+  return result, p.convertProgramDiagnostics(result.Diagnostics), nil
 }
 
 // DefaultWriteFile is the default disk writer used when EmitAll's caller does not

package/internal/graph/diagnostics.go

@@ -3,9 +3,10 @@ package graph
 import "github.com/samchon/ttsc/packages/ttsc/driver"
 
 // FileDiagnostics returns the resident program's compiler diagnostics for the
-// source file at path, in the same code and location tsgo reports. Because the
-// graph rides the already-open Program, this is one Program.Diagnostics() call
-// over the warm checker, not a second compile.
+// source file at path, with the code tsgo reports and the location the driver
+// resolves (see Diagnostic: authored-relative under a source preamble). Because
+// the graph rides the already-open Program, this is one Program.Diagnostics()
+// call over the warm checker, not a second compile.
 //
 // This is the compiler-only slice: it carries the TypeScript semantic
 // diagnostics, not @ttsc/lint or transform-plugin findings.

package/internal/graph/provenance.go

@@ -179,7 +179,16 @@ type SourceDigest struct {
 }
 
 // Diagnostic is one compiler diagnostic riding the snapshot that produced the
-// facts. Positions are 1-based, matching what tsgo reports.
+// facts. Positions are 1-based and authored-relative: where a SourcePreamble
+// plugin injected text ahead of a file, the driver maps the position back onto
+// the bytes a consumer can read for itself (the file this dump publishes a Disk
+// digest of), rather than onto the augmented text the checker saw. Node spans in
+// this dump stay checker-relative by declaration — see SourceDigest — because
+// they describe the facts, while a diagnostic is an instruction to go look at a
+// line.
+//
+// A diagnostic that points inside the injected preamble itself has no authored
+// counterpart, so it arrives with Line and Column zero and its message intact.
 type Diagnostic struct {
   // File uses the dump's path vocabulary.
   File string `json:"file"`

package/lib/compiler/internal/compileProjectInMemory.js

@@ -91,6 +91,13 @@ function compileProjectWithPlugins(options, cwd, project) {
             emit: true,
             forceListEmittedFiles: true,
             outDir: tempOutDir,
+            // The temp directory is an `outDir` this lane injected so the emit can be
+            // read back as strings; the project need not declare one at all. tsgo
+            // answers an inferred common source directory with TS5011 as soon as any
+            // `outDir` is in play, so pin the root it would infer. The keys
+            // `outputKeyMapper` builds are unchanged by it — that root is exactly the
+            // layout tsgo already lays the emit out against (issue #1172).
+            pinInferredRootDir: true,
             quiet: true,
             resolvedProject: project,
             structuredDiagnostics: true,

package/lib/compiler/internal/compileProjectInMemory.js.map

@@ -1 +1 @@
-{"version":3,"file":"compileProjectInMemory.js","sourceRoot":"","sources":["../../../src/compiler/internal/compileProjectInMemory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"compileProjectInMemory.js","sourceRoot":"","sources":["../../../src/compiler/internal/compileProjectInMemory.ts"],"names":[],"mappings":"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"}

package/lib/compiler/internal/runBuild.d.ts

@@ -11,6 +11,34 @@ export type RunBuildOptions = TtscBuildOptions & {
     forceListEmittedFiles?: boolean;
     /** Keep every compiler-owned side product inside this private directory. */
     isolateOutputsTo?: string;
+    /**
+     * Hand tsgo the `rootDir` it would otherwise infer, for a build whose
+     * `outDir` this process injected rather than the project declaring it.
+     *
+     * Tsgo answers an inferred common source directory with TS5011 the moment an
+     * `outDir` is in play, so injecting one turns a project that declares no
+     * output at all — the `noEmit` check-only shape `tsgo`, `ttsc`, and `ttsc
+     * --emit` all accept — into one that must configure the layout of output the
+     * user never asked for and never sees (issue #1172).
+     *
+     * The pinned value is the one tsgo itself infers: with a config file in play
+     * its common source directory is that file's directory, never the computed
+     * common directory of the input files (`outputpaths.GetCommonSourceDirectory`
+     * consults the file list only for a config-less program). Pinning it
+     * therefore silences the demand without moving a single output, and it is the
+     * same source root `prepareExecution.ts::resolveRuntimeSourceRoot`,
+     * `runtimeHooks.ts::resolveDependencySourceRoot`, and
+     * `watchTopology.ts::inferPerSourceCompilerOutputs` already model on the
+     * JavaScript side.
+     *
+     * Ignored when the project declares its own `rootDir`: that project already
+     * satisfies tsgo, and overriding it would relocate the emit out from under
+     * every consumer that mirrors the declared root.
+     *
+     * Never set for a user-supplied `--outDir`. That outDir is the user's own
+     * request, and TS5011 is then tsgo's genuine answer to it.
+     */
+    pinInferredRootDir?: boolean;
     /**
      * Receives selected native-plugin source roots after the project resolves.
      * The watch launcher uses these roots to invalidate a sidecar when its Go

package/lib/compiler/internal/runBuild.js

@@ -861,6 +861,9 @@ function createTsgoBuildArgs(execution, options, flags) {
         if (options.forceRuntimeSourceMap === true) {
             args.push("--sourceMap", "true");
         }
+        // Pushed before passthrough for the same reason: a user `--rootDir` still
+        // wins over the value ttsc pins for its own injected `outDir`.
+        args.push(...pinnedRootDirArgs(execution, options));
     }
     else if (options.emit === false) {
         args.push("--noEmit");
@@ -880,6 +883,36 @@ function createTsgoBuildArgs(execution, options, flags) {
     }
     return args;
 }
+/**
+ * The explicit `--rootDir` a caller-injected `outDir` needs, or nothing.
+ *
+ * See {@link RunBuildOptions.pinInferredRootDir} for why an injected `outDir`
+ * needs one at all. Three conditions gate it, and each one is load-bearing:
+ *
+ * - The caller injected the `outDir` itself, so a user `--outDir` keeps tsgo's
+ *   own TS5011 answer;
+ * - This pass emits, because a no-emit pass has no layout to pin (tsgo skips the
+ *   check for `noEmit` too);
+ * - The project declares no `rootDir` of its own, so a declared layout is never
+ *   overridden.
+ *
+ * `execution.projectRoot` is the directory of the tsconfig ttsc resolved and
+ * hands tsgo as `-p`, which is exactly the directory tsgo infers, and it is
+ * spelled the way tsgo will spell the input file names it compares against it —
+ * both come from the same `fs.realpathSync` pass. Resolving it any further (a
+ * Windows 8.3 expansion, say) would leave the comparison lexically mixed, and
+ * `ContainsPath` is lexical: every input would count as outside `rootDir` and
+ * tsgo would emit it beside the user's source instead of under `outDir`.
+ */
+function pinnedRootDirArgs(execution, options) {
+    if (options.pinInferredRootDir !== true)
+        return [];
+    if (options.emit !== true)
+        return [];
+    if (typeof execution.project.compilerOptions.rootDir === "string")
+        return [];
+    return ["--rootDir", execution.projectRoot];
+}
 /**
  * Return `["--pretty", "false"]` when structured diagnostics are requested so
  * that the output can be parsed line-by-line, or an empty array otherwise.
@@ -945,7 +978,10 @@ function createNativeBuildArgs(execution, options, plugins) {
             args.push("--quiet");
         }
     }
-    args.push(...createNativeTsgoArgs(options));
+    // The sidecar builds its Program in-process, so the pinned `rootDir` has to
+    // travel the same channel every other tsgo option takes to it — the host flag
+    // set does not declare `--rootDir`, and `filterHostArgs` would strip it.
+    args.push(...createNativeTsgoArgs(options, pinnedRootDirArgs(execution, options)));
     return args;
 }
 /** Build the argument list for a native plugin check/fix/format invocation. */
@@ -1059,8 +1095,11 @@ function transformHostTimingLabel(plugins) {
  * a plugin build the same way it reaches the plain tsgo lane. Encoded as a
  * single token so the sidecars' unknown-flag filters keep it intact.
  */
-function createNativeTsgoArgs(options) {
+function createNativeTsgoArgs(options, leading = []) {
     const passthrough = [
+        // Ahead of the user's own flags, so the same precedence holds here as on
+        // the direct tsgo lane: whatever the user forwarded wins.
+        ...leading,
         ...(nativeTsgoPassthroughArgs(options) ?? []),
         ...isolatedTsgoOutputArgs(options),
     ];