ttsc 0.26.2 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.26.2",
+  "version": "0.28.0",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -18,6 +18,10 @@
       "types": "./lib/internal/projectInputPathIdentity.d.ts",
       "default": "./lib/internal/projectInputPathIdentity.js"
     },
+    "./register": {
+      "types": "./lib/register.d.ts",
+      "default": "./lib/register.js"
+    },
     "./package.json": "./package.json"
   },
   "repository": {
@@ -39,15 +43,18 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.26.2",
-    "@ttsc/linux-arm64": "0.26.2",
-    "@ttsc/darwin-x64": "0.26.2",
-    "@ttsc/darwin-arm64": "0.26.2",
-    "@ttsc/linux-arm": "0.26.2",
-    "@ttsc/win32-arm64": "0.26.2",
-    "@ttsc/win32-x64": "0.26.2"
+    "@ttsc/linux-arm": "0.28.0",
+    "@ttsc/darwin-x64": "0.28.0",
+    "@ttsc/linux-x64": "0.28.0",
+    "@ttsc/win32-x64": "0.28.0",
+    "@ttsc/win32-arm64": "0.28.0",
+    "@ttsc/darwin-arm64": "0.28.0",
+    "@ttsc/linux-arm64": "0.28.0"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./lib/register.js",
+    "./src/register.ts"
+  ],
   "files": [
     "README.md",
     "cmd",

package/shim/ast/parent.go

@@ -6,9 +6,17 @@ import innerast "github.com/microsoft/typescript-go/internal/ast"
 // its containing node.
 //
 // A transform that splices freshly built (synthetic) nodes onto a SourceFile
-// must call this before emit: passes that walk parents — e.g. the emit
-// resolver's reference marking (MarkLinkedReferencesRecursively) — dereference
-// Parent and would hit nil on a synthetic node otherwise.
+// must call this before emit, because the passes that then walk the spliced tree
+// dereference Parent and would hit nil on a synthetic node. The printer is the
+// example that holds up: getContainingNodeArray reads node.Parent unguarded for
+// a parameter, template span, decorator, and heritage clause.
+//
+// Two earlier examples were dropped rather than the rule. The emit resolver's
+// reference marking no longer walks the spliced tree at all in ttsc's plugin
+// emit lane, which builds the builtin chain from the parse tree (see
+// driver.EmitWithPluginTransformers). The module transform's own Parent reads
+// carry upstream //nolint:customlint notes saying they deliberately inspect
+// parse-tree parents.
 func SetParentInChildren(node *Node) {
   innerast.SetParentInChildren(node)
 }
@@ -20,6 +28,11 @@ func SetParentInChildren(node *Node) {
 // kept verbatim while sibling statements were rewritten) makes tsgo's
 // runtime-syntax/printer mis-resolve the declaration and drop it from emit.
 // Only freshly built (synthetic) nodes need a parent wired, and those start nil.
+//
+// This is the form ttsc's plugin emit lane calls. How much it currently carries
+// is unproven: stubbing the call out leaves the whole driver suite green, which
+// measures the suite's coverage of parent-dependent emit rather than the hazard.
+// Keep it for the reason above, not on the strength of a failing test.
 func SetParentInChildrenUnset(node *Node) {
   node.ForEachChild(func(child *Node) bool {
     if child.Parent == nil {

package/shim/checker/enums_gen.go

@@ -77,6 +77,17 @@ const (
   ObjectFlagsSingleSignatureType                        = innerchecker.ObjectFlagsSingleSignatureType
   ObjectFlagsTuple                                      = innerchecker.ObjectFlagsTuple
   ObjectFlagsUnresolvedMembers                          = innerchecker.ObjectFlagsUnresolvedMembers
+  SignatureFlagsCallChainFlags                          = innerchecker.SignatureFlagsCallChainFlags
+  SignatureFlagsConstruct                               = innerchecker.SignatureFlagsConstruct
+  SignatureFlagsHasLiteralTypes                         = innerchecker.SignatureFlagsHasLiteralTypes
+  SignatureFlagsHasRestParameter                        = innerchecker.SignatureFlagsHasRestParameter
+  SignatureFlagsIsInnerCallChain                        = innerchecker.SignatureFlagsIsInnerCallChain
+  SignatureFlagsIsNonInferrable                         = innerchecker.SignatureFlagsIsNonInferrable
+  SignatureFlagsIsOuterCallChain                        = innerchecker.SignatureFlagsIsOuterCallChain
+  SignatureFlagsIsSignatureCandidateForOverloadFailure  = innerchecker.SignatureFlagsIsSignatureCandidateForOverloadFailure
+  SignatureFlagsIsUntypedSignatureInJSFile              = innerchecker.SignatureFlagsIsUntypedSignatureInJSFile
+  SignatureFlagsNone                                    = innerchecker.SignatureFlagsNone
+  SignatureFlagsPropagatingFlags                        = innerchecker.SignatureFlagsPropagatingFlags
   SignatureKindConstruct                                = innerchecker.SignatureKindConstruct
   TypeFlagsAnyOrUnknown                                 = innerchecker.TypeFlagsAnyOrUnknown
   TypeFlagsBigInt                                       = innerchecker.TypeFlagsBigInt

package/shim/checker/go.mod

@@ -3,3 +3,12 @@ module github.com/microsoft/typescript-go/shim/checker
 go 1.26
 
 require github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+)

package/shim/checker/go.sum

@@ -0,0 +1,22 @@
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+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/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 h1:llOMPhKDiQ+UEJiAaQuuWaJOTg5V7tNNTEf9JPWoYSY=
+github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157/go.mod h1:m8YA0PMC7ti0GW0RI05D6fEcjQeu98XVS+FWF+VDW2k=
+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.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/shim/checker/shim.go

@@ -20,8 +20,11 @@ import (
 type Checker = innerchecker.Checker
 type IndexInfo = innerchecker.IndexInfo
 type Signature = innerchecker.Signature
+type SignatureFlags = innerchecker.SignatureFlags
 type SignatureKind = innerchecker.SignatureKind
 type Type = innerchecker.Type
+type TypeMapper = innerchecker.TypeMapper
+type TypeMapperKind = innerchecker.TypeMapperKind
 type TypeFlags = innerchecker.TypeFlags
 type ObjectFlags = innerchecker.ObjectFlags
 type ElementFlags = innerchecker.ElementFlags
@@ -214,8 +217,15 @@ func Checker_isSymbolAccessibleAsValue(recv *innerchecker.Checker, symbol *inner
 }
 
 const (
+  SignatureFlagsAbstract = innerchecker.SignatureFlagsAbstract
+
   SignatureKindCall = innerchecker.SignatureKindCall
 
+  TypeMapperKindUnknown = innerchecker.TypeMapperKindUnknown
+  TypeMapperKindSimple  = innerchecker.TypeMapperKindSimple
+  TypeMapperKindArray   = innerchecker.TypeMapperKindArray
+  TypeMapperKindMerged  = innerchecker.TypeMapperKindMerged
+
   TypeFlagsAny             = innerchecker.TypeFlagsAny
   TypeFlagsUnknown         = innerchecker.TypeFlagsUnknown
   TypeFlagsUndefined       = innerchecker.TypeFlagsUndefined
@@ -597,3 +607,71 @@ func Checker_getRestTypeOfSignature(recv *innerchecker.Checker, signature *inner
   }
   return recv.GetRestTypeOfSignature(signature)
 }
+
+//go:linkname checkerInstantiateType github.com/microsoft/typescript-go/internal/checker.(*Checker).instantiateType
+func checkerInstantiateType(recv *innerchecker.Checker, t *innerchecker.Type, m *innerchecker.TypeMapper) *innerchecker.Type
+
+//go:linkname checkerNewSimpleTypeMapper github.com/microsoft/typescript-go/internal/checker.newSimpleTypeMapper
+func checkerNewSimpleTypeMapper(source *innerchecker.Type, target *innerchecker.Type) *innerchecker.TypeMapper
+
+//go:linkname checkerNewTypeMapper github.com/microsoft/typescript-go/internal/checker.newTypeMapper
+func checkerNewTypeMapper(sources []*innerchecker.Type, targets []*innerchecker.Type) *innerchecker.TypeMapper
+
+// Checker_instantiateType substitutes the type parameters of `t` with the
+// concrete types in `mapper`, returning the instantiated type. A type-transform
+// plugin uses it to instantiate a generic class's constructor type with the
+// reference's type arguments, so a type parameter nested inside a container
+// (`A[]`, `[A, B]`) is substituted for free. Returns nil if recv or t is nil.
+func Checker_instantiateType(recv *innerchecker.Checker, t *innerchecker.Type, mapper *innerchecker.TypeMapper) *innerchecker.Type {
+  if recv == nil || t == nil {
+    return nil
+  }
+  return checkerInstantiateType(recv, t, mapper)
+}
+
+// Checker_newSimpleTypeMapper builds a single-pair type mapper that substitutes
+// `source` with `target`. It is the building block for instantiating a generic
+// class's constructor type with its reference type arguments. Returns nil if
+// source or target is nil.
+func Checker_newSimpleTypeMapper(source *innerchecker.Type, target *innerchecker.Type) *innerchecker.TypeMapper {
+  if source == nil || target == nil {
+    return nil
+  }
+  return checkerNewSimpleTypeMapper(source, target)
+}
+
+// Checker_newTypeMapper builds a parallel type mapper from corresponding
+// source and target slices. Unlike Checker_combineTypeMappers, it does not feed
+// one substitution's target through later substitutions, so a mapping such as
+// `[A, B] -> [B, A]` preserves both target identities. Returns nil when the
+// slices are empty, differ in length, or contain nil types.
+func Checker_newTypeMapper(sources []*innerchecker.Type, targets []*innerchecker.Type) *innerchecker.TypeMapper {
+  if len(sources) == 0 || len(sources) != len(targets) {
+    return nil
+  }
+  for i := range sources {
+    if sources[i] == nil || targets[i] == nil {
+      return nil
+    }
+  }
+  return checkerNewTypeMapper(sources, targets)
+}
+
+//go:linkname checkerCombineTypeMappers github.com/microsoft/typescript-go/internal/checker.(*Checker).combineTypeMappers
+func checkerCombineTypeMappers(recv *innerchecker.Checker, m1 *innerchecker.TypeMapper, m2 *innerchecker.TypeMapper) *innerchecker.TypeMapper
+
+// Checker_combineTypeMappers composes two mapper stages. The first mapper's
+// substituted target is instantiated through the second mapper, so use
+// Checker_newTypeMapper instead when source and target slices are parallel
+// declaration-parameter mappings. Returns m2 when m1 is nil, including when
+// recv is nil. Returns nil when m1 is non-nil and recv or m2 is nil, because
+// both are required to build a usable composite mapper.
+func Checker_combineTypeMappers(recv *innerchecker.Checker, m1 *innerchecker.TypeMapper, m2 *innerchecker.TypeMapper) *innerchecker.TypeMapper {
+  if m1 == nil {
+    return m2
+  }
+  if recv == nil || m2 == nil {
+    return nil
+  }
+  return checkerCombineTypeMappers(recv, m1, m2)
+}

package/shim/compiler/emithook.go

@@ -18,5 +18,15 @@ import (
 // (type-erase, import-elision, runtime-syntax, module-transform, ...) for one
 // source file, linked from the internal package via go:linkname.
 //
+// `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 then 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.
+//
 //go:linkname GetScriptTransformers github.com/microsoft/typescript-go/internal/compiler.getScriptTransformers
 func GetScriptTransformers(emitContext *innerprinter.EmitContext, host innerprinter.EmitHost, sourceFile *innerast.SourceFile) []*innertransformers.Transformer

package/shim/compiler/incremental.go

@@ -1,13 +1,20 @@
 // gen_shims:hand-maintained
 //
-// Reference-graph parts of tsgo's own incremental engine (`tsc --incremental`
-// semantics), linked from internal/execute/incremental so ttsc's transform
-// envelopes can carry the same language-semantic input bound the compiler
-// itself uses for invalidation: per-file direct resolved references and the
-// files that contribute to the global scope.
+// Parts of tsgo's own incremental engine (`tsc --incremental` semantics),
+// exposed from internal/execute/incremental for the two things a ttsc host
+// needs from it:
+//
+//   - the reference graph, so transform envelopes can carry the same
+//     language-semantic input bound the compiler itself uses for invalidation:
+//     per-file direct resolved references and the files that contribute to the
+//     global scope;
+//   - the build-information emit, so a host that constructs its Program
+//     in-process still writes the `.tsbuildinfo` an `incremental` or
+//     `composite` project asked for.
 package compiler
 
 import (
+  "context"
   _ "unsafe"
 
   innerast "github.com/microsoft/typescript-go/internal/ast"
@@ -15,11 +22,41 @@ import (
   innercompiler "github.com/microsoft/typescript-go/internal/compiler"
   "github.com/microsoft/typescript-go/internal/tspath"
 
-  // The linknamed symbols below live in the incremental package; the blank
-  // import compiles it into every shim consumer so the references resolve.
-  _ "github.com/microsoft/typescript-go/internal/execute/incremental"
+  // Imported for EmitFreshWithBuildInfo below, and for the linknamed symbols
+  // further down: compiling the package into every shim consumer is what makes
+  // those references resolve.
+  "github.com/microsoft/typescript-go/internal/execute/incremental"
 )
 
+// EmitFreshWithBuildInfo runs a full emit through tsgo's own incremental
+// program, so an `incremental` or `composite` project gets the `.tsbuildinfo`
+// tsgo would have written, in the exact format and location
+// `outputpaths.GetBuildInfoFileName` resolves from the compiler options.
+//
+// This is the emit half of `tsc.go::performIncrementalCompilation`, which the
+// tsgo CLI takes whenever `CompilerOptions.IsIncremental()`. A host that builds
+// its Program in-process (ttsc's driver, and therefore every plugin sidecar
+// emitting through it) never reaches that CLI path, so without this the build
+// information is silently dropped even though the options parsed cleanly.
+//
+// "Fresh" is the load-bearing word: no previous snapshot is supplied, so
+// `programToSnapshot` marks every file changed and this emits the whole program
+// exactly as `Program.Emit` does, then writes the build info. A ttsc plugin's
+// output is not a pure function of the source text a build info records — it
+// also depends on the plugin binary, its config file, and its contributors —
+// so reusing a previous snapshot to skip a file would serve stale transformed
+// output. Producing the record is sound; consuming it needs plugin identity in
+// the invalidation key first.
+func EmitFreshWithBuildInfo(ctx context.Context, program *Program, options EmitOptions) *EmitResult {
+  incrementalProgram := incremental.NewProgram(
+    program,
+    nil,
+    incremental.CreateHost(program.Host()),
+    false,
+  )
+  return incrementalProgram.Emit(ctx, options)
+}
+
 //go:linkname incrementalGetReferencedFiles github.com/microsoft/typescript-go/internal/execute/incremental.getReferencedFiles
 func incrementalGetReferencedFiles(program *innercompiler.Program, file *innerast.SourceFile) *collections.Set[tspath.Path]
 

package/src/TtscCompiler.ts

@@ -6,7 +6,10 @@ import { resolveProjectConfig } from "./compiler/internal/project/resolveProject
 import { resolveBinary } from "./compiler/internal/resolveBinary";
 import { createProcessDiagnostic } from "./compiler/internal/runBuild";
 import { transformProjectInMemory } from "./compiler/internal/transformProjectInMemory";
-import { assertSafeExplicitCacheDirectory } from "./internal/assertSafeExplicitCacheDirectory";
+import {
+  type SafeCacheCleanupTarget,
+  resolveSafeCacheCleanupTargets,
+} from "./internal/resolveSafeCacheCleanupTargets";
 import { resolveCleanTargets } from "./plugin/internal/buildSourcePlugin";
 import { loadProjectPlugins } from "./plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
@@ -86,15 +89,16 @@ export class TtscCompiler {
   /**
    * Remove compiled cache artifacts for this compiler instance.
    *
-   * Removes the resolved cache root (which holds both the plugin binaries and,
-   * when ttsc-owned, the Go build cache), a ttsc-owned Go build cache that
-   * lives outside that root (`TTSC_GO_CACHE_DIR`), and the two legacy
-   * project-local caches. A user-provided `GOCACHE` is never removed. The cache
+   * Removes an explicit `cacheDir` wholesale. Otherwise removes the plugin
+   * binary subdirectory, a safely identified ttsc-owned Go build cache
+   * (including an external `TTSC_GO_CACHE_DIR`), and the two legacy
+   * project-local caches. A user-provided `GOCACHE` is never removed. Every
+   * resolved deletion target is validated before the first removal. The cache
    * location comes from this instance's `cacheDir` and environment
    * (`TTSC_CACHE_DIR` / `TTSC_GO_CACHE_DIR`), defaulting to
-   * `<workspaceRoot>/node_modules/.cache/ttsc`. An explicit cache directory
-   * that equals or contains the project, or names a filesystem root, is
-   * rejected before any directory is removed.
+   * `<workspaceRoot>/node_modules/.cache/ttsc`. Any resolved cache target that
+   * equals or contains the project, or names a filesystem root, is rejected
+   * before any directory is removed.
    *
    * @returns Cache directories that were removed.
    */
@@ -105,31 +109,35 @@ export class TtscCompiler {
       path.join(projectRoot, ".ttsc"),
     ];
     const explicitCacheDir = this.resolveCacheDir();
+    let targets: string[];
     if (explicitCacheDir !== undefined) {
-      assertSafeExplicitCacheDirectory(projectRoot, explicitCacheDir);
       // An explicit constructor `cacheDir` names the cache directory for this
       // instance — exactly like `ttsc clean --cache-dir X` on the CLI — so
       // remove it wholesale plus the legacy project-local caches. This keeps
       // the programmatic and CLI clean contracts identical for an explicit
       // cache dir.
-      return removeExistingDirectories([explicitCacheDir, ...legacyTargets]);
-    }
-    // Default / `context.env.TTSC_CACHE_DIR`: resolve the cache root and the Go
-    // build cache (`TTSC_GO_CACHE_DIR`) from this instance's effective
-    // environment — the same `{ ...process.env, ...context.env }` that
-    // prepare()/compile()/transform() build with — then remove only the
-    // ttsc-owned subdirectories, so a possibly-shared root is never deleted and
-    // a user-provided `GOCACHE` is never touched. Using the effective env (not
-    // ambient `process.env`) makes clean() remove exactly the artifacts this
-    // instance owns, including a `TTSC_GO_CACHE_DIR` supplied only in
-    // `context.env`.
-    return removeExistingDirectories(
-      resolveCleanTargets(
+      targets = [explicitCacheDir, ...legacyTargets];
+    } else {
+      // Default / `context.env.TTSC_CACHE_DIR`: resolve the cache root and the Go
+      // build cache (`TTSC_GO_CACHE_DIR`) from this instance's effective
+      // environment — the same `{ ...process.env, ...context.env }` that
+      // prepare()/compile()/transform() build with — then remove only the
+      // ttsc-owned subdirectories, so a possibly-shared root is never deleted and
+      // a user-provided `GOCACHE` is never touched. Using the effective env (not
+      // ambient `process.env`) makes clean() remove exactly the artifacts this
+      // instance owns, including a `TTSC_GO_CACHE_DIR` supplied only in
+      // `context.env`.
+      targets = resolveCleanTargets(
         projectRoot,
         this.resolvePluginCacheDir(),
         this.resolveEffectiveEnv(),
-      ),
-    );
+      );
+    }
+    // Validate the complete deletion set before removing the first directory.
+    // This includes an environment-selected TTSC_GO_CACHE_DIR and project-local
+    // legacy locations, not only an explicit constructor cacheDir.
+    const safeTargets = resolveSafeCacheCleanupTargets(projectRoot, targets);
+    return removeExistingDirectories(safeTargets);
   }
 
   /**
@@ -234,24 +242,29 @@ export class TtscCompiler {
    * The effective environment for this instance's source-plugin builds and
    * clean targets: `context.env` merged over `process.env`, matching the
    * documented {@link ITtscCompilerContext.env} contract that child compiler,
-   * native-plugin, and native-host processes already receive. Returned as a
-   * fresh object so callers never mutate the shared `process.env`; when no
-   * `context.env` was supplied this is a plain copy of `process.env`, so CLI /
-   * default behavior is unchanged.
+   * native-plugin, native-host, and isolated descriptor processes already
+   * receive. Returned as a fresh object so callers never mutate the shared
+   * `process.env`; when no `context.env` was supplied this is a plain copy of
+   * `process.env`, so CLI / default behavior is unchanged.
    */
   private resolveEffectiveEnv(): NodeJS.ProcessEnv {
     return { ...process.env, ...this.context.env };
   }
 }
 
-function removeExistingDirectories(directories: readonly string[]): string[] {
+function removeExistingDirectories(
+  directories: readonly SafeCacheCleanupTarget[],
+): string[] {
   const removed: string[] = [];
-  for (const directory of [...new Set(directories)]) {
-    if (!fs.existsSync(directory)) {
+  const visited = new Set<string>();
+  for (const directory of directories) {
+    if (visited.has(directory.path)) continue;
+    visited.add(directory.path);
+    if (!directory.exists || !fs.existsSync(directory.path)) {
       continue;
     }
-    fs.rmSync(directory, { recursive: true, force: true });
-    removed.push(directory);
+    fs.rmSync(directory.path, { recursive: true, force: true });
+    removed.push(directory.requestedPath);
   }
   return removed;
 }
@@ -265,6 +278,9 @@ interface ProjectTransformation {
   dependencies?: Record<string, string[]>;
   dependenciesComplete?: string[];
   graph?: ITtscCompilerTransformation.IReferenceGraph;
+  hostInputHashes?: Record<string, string | null>;
+  hostInputRealpaths?: Record<string, string | null>;
+  hostInputs?: string[];
   result: TtscBuildResult;
   typescript: Record<string, string>;
   volatile?: string[];
@@ -382,6 +398,9 @@ function toCompilerTransformation(
     dependencies,
     dependenciesComplete,
     graph,
+    hostInputHashes,
+    hostInputRealpaths,
+    hostInputs,
     result,
     typescript,
     volatile,
@@ -390,6 +409,9 @@ function toCompilerTransformation(
     ...(dependencies === undefined ? {} : { dependencies }),
     ...(dependenciesComplete === undefined ? {} : { dependenciesComplete }),
     ...(graph === undefined ? {} : { graph }),
+    ...(hostInputHashes === undefined ? {} : { hostInputHashes }),
+    ...(hostInputRealpaths === undefined ? {} : { hostInputRealpaths }),
+    ...(hostInputs === undefined ? {} : { hostInputs }),
     ...(volatile === undefined ? {} : { volatile }),
   };
   if (result.status === 0 && !hasErrorDiagnostics(result.diagnostics)) {

package/src/compiler/internal/captureProcessOutput.ts

@@ -1,7 +1,8 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
+import { createCanonicalTempDirectory } from "../../internal/createCanonicalTempDirectory";
+
 export interface CapturedProcessOutput {
   /** Close the descriptors and remove the backing files. */
   dispose(): void;
@@ -32,7 +33,7 @@ export interface CapturedProcessOutput {
  * bytes.
  */
 export function captureProcessOutput(): CapturedProcessOutput {
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-spawn-"));
+  const directory = createCanonicalTempDirectory("ttsc-spawn-");
   const stdoutPath = path.join(directory, "stdout");
   const stderrPath = path.join(directory, "stderr");
   const stdoutFd = fs.openSync(stdoutPath, "w+");

package/src/compiler/internal/compileProjectInMemory.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
+import { createCanonicalTempDirectory } from "../../internal/createCanonicalTempDirectory";
 import { hasProjectPluginEntries } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscCompilerDiagnostic } from "../../structures/ITtscCompilerDiagnostic";
@@ -11,6 +11,7 @@ import { buildNativeCompiler } from "./buildNativeCompiler";
 import { isOutsideRelativePath, packageRootDir } from "./paths";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { runBuild } from "./runBuild";
+import { inheritedSidecarEnv } from "./sharedHostHelpers";
 import { outputText, spawnNative } from "./spawnNative";
 
 /**
@@ -50,7 +51,7 @@ export function compileProjectInMemory(options: ITtscCompilerContext): {
     ["api-compile", "--cwd", project.root, "--tsconfig", tsconfig],
     {
       cwd: project.root,
-      env: { ...process.env, ...options.env },
+      env: inheritedSidecarEnv(options.env),
     },
   );
   if (res.error) {
@@ -110,7 +111,7 @@ function compileProjectWithPlugins(
   output: Record<string, string>;
   result: TtscBuildResult;
 } {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-api-output-"));
+  const tempRoot = createCanonicalTempDirectory("ttsc-api-output-");
   const tempOutDir = path.join(tempRoot, "out");
   try {
     const result = runBuild({

package/src/compiler/internal/project/createNativeProjectContextArgs.ts

@@ -7,9 +7,24 @@ export function createNativeProjectContextArgs(
 ): string[] {
   return [
     "--project-context-json=" +
-      JSON.stringify({
-        ...project.identity,
-        ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
-      }),
+      createNativeProjectContextJson(project, pluginConfigOrigin),
   ];
 }
+
+/**
+ * The identity payload itself, for a caller that spawns a sidecar without going
+ * through the compiler's own argument list.
+ *
+ * Split from the flag so there is still exactly one place that decides what a
+ * sidecar is told about the project. A second caller assembling the same JSON,
+ * or slicing it back out of the flag, is how the two drift.
+ */
+export function createNativeProjectContextJson(
+  project: ITtscParsedProjectConfig,
+  pluginConfigOrigin?: string,
+): string {
+  return JSON.stringify({
+    ...project.identity,
+    ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
+  });
+}

package/src/compiler/internal/resolveEmittedJavaScript.ts

@@ -20,6 +20,8 @@ import { isOutsideRelativePath } from "./paths";
  * Returns `null` when no matching output file is found on disk.
  */
 export function resolveEmittedJavaScript(options: {
+  /** Skip trailing-stem recovery when exact source ownership is required. */
+  allowStemFallback?: boolean;
   /** Pre-computed list of emitted paths; when absent `outDir` is scanned. */
   emittedFiles?: readonly string[];
   outDir: string;
@@ -45,6 +47,10 @@ export function resolveEmittedJavaScript(options: {
     }
   }
 
+  if (options.allowStemFallback === false) {
+    return null;
+  }
+
   // Score the pre-computed emit list first (cheap). When it yields nothing —
   // because the list is incomplete (a native transform host such as typia emits
   // without printing the `--listEmittedFiles` lines) or because the emit landed