ttsc 0.18.3 → 0.19.0

package/lib/structures/ITtscCompilerResult.d.ts

@@ -39,12 +39,14 @@ export declare namespace ITtscCompilerResult {
         output: Record<string, string>;
     }
     /**
-     * Represents a ttsc compilation that completed but had diagnostics.
+     * Represents a ttsc compilation that completed with diagnostics or a
+     * recoverable plugin failure.
      *
      * This interface is returned when the compiler reports errors, warnings, or
-     * other diagnostics during normal compilation. It contains both structured
-     * diagnostic information and any output that was still generated despite the
-     * diagnostics.
+     * other diagnostics during normal compilation, or when a plugin failure can
+     * be retained as a build result while an independent TypeScript check runs.
+     * It contains both structured diagnostic information and any output that was
+     * still generated despite the failure.
      */
     interface IFailure {
         /** Indicates that compilation completed with diagnostics. */
@@ -74,7 +76,8 @@ export declare namespace ITtscCompilerResult {
          * pattern-matching error messages. Omitted when ttsc cannot determine the
          * origin. Treat as `"unknown"` when missing.
          *
-         * - `"plugin"`: a native plugin sidecar crashed or exited non-zero.
+         * - `"plugin"`: plugin preparation failed before a build result could be
+         *   recovered.
          * - `"host"`: the TypeScript-Go host could not start (missing binary, cache
          *   lock, invalid config).
          * - `"unknown"`: any other host-level failure.

package/lib/structures/ITtscPluginCapabilities.d.ts

@@ -35,6 +35,14 @@ export interface ITtscPluginCapabilities {
      * @default false
      */
     lsp?: boolean;
+    /**
+     * Whether the sidecar accepts ttsc's `--project-context-json` identity
+     * protocol. The payload keeps lexical selection paths, physical Program
+     * paths, and explicit overrides as separate fields.
+     *
+     * @default false
+     */
+    projectContextArgs?: boolean;
     /**
      * Whether the sidecar accepts `--singleThreaded` and `--checkers` on its
      * command line. The lint sidecar parses both flags via `parseSubcommandFlags`

package/lib/structures/ITtscPluginFactoryContext.d.ts

@@ -60,6 +60,20 @@ export interface ITtscPluginFactoryContext<T = ITtscProjectPluginConfig> {
      * plugin manifest.
      */
     plugin: T;
+    /**
+     * Caller-declared anchor for plugin config-file discovery and relative
+     * `configFile` resolution.
+     *
+     * Absent for ordinary invocations, where a factory anchors config discovery
+     * at the {@link ITtscPluginFactoryContext.tsconfig} directory. Present when
+     * the embedder compiles through a generated tsconfig outside the project (the
+     * bundler adapters' alias overlay): it names the real project directory, and
+     * a factory that discovers its own config file should anchor there instead of
+     * the generated tsconfig's temp-dir ancestry. Mirrors the
+     * `TTSC_PLUGIN_CONFIG_DIR` environment variable ttsc sets for native plugin
+     * processes.
+     */
+    pluginConfigDir?: string;
     /**
      * Project root used as the native plugin working directory and package
      * discovery base.

package/lib/structures/internal/ITtscParsedProjectConfig.d.ts

@@ -1,4 +1,5 @@
 import type { ITtscProjectPluginConfig } from "../ITtscProjectPluginConfig";
+import type { ITtscProjectIdentity } from "./ITtscProjectIdentity";
 /** Resolved project config subset used inside the ttsc host. */
 export interface ITtscParsedProjectConfig {
     /** Compiler options after extends inheritance has been applied. */
@@ -8,6 +9,8 @@ export interface ITtscParsedProjectConfig {
         /** Project plugin entries after inheritance resolution. */
         plugins: ITtscProjectPluginConfig[];
     } & Record<string, unknown>;
+    /** Lexical and physical identities retained for native plugin contexts. */
+    identity: Omit<ITtscProjectIdentity, "pluginConfigOrigin">;
     /** Absolute path to the resolved tsconfig/jsconfig. */
     path: string;
     /** Directory that declared each inherited plugin entry. */

package/lib/structures/internal/ITtscProjectIdentity.d.ts

@@ -0,0 +1,17 @@
+/** Separate lexical and physical identities for one selected project. */
+export interface ITtscProjectIdentity {
+    /** Caller working directory before filesystem canonicalization. */
+    invocationCwd: string;
+    /** Caller-selected config spelling before filesystem canonicalization. */
+    logicalConfigPath: string;
+    /** Directory containing the caller-selected config spelling. */
+    logicalProjectRoot: string;
+    /** Realpath-resolved config used to load the TypeScript Program. */
+    physicalConfigPath: string;
+    /** Realpath-resolved root supplied to the TypeScript Program host. */
+    physicalProjectRoot: string;
+    /** Caller-declared project-root override, when present. */
+    explicitProjectRoot?: string;
+    /** Caller-declared plugin-config discovery origin, when present. */
+    pluginConfigOrigin?: string;
+}

package/lib/structures/internal/ITtscProjectIdentity.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscProjectIdentity.js.map

package/lib/structures/internal/ITtscProjectIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscProjectIdentity.js","sourceRoot":"","sources":["../../../src/structures/internal/ITtscProjectIdentity.ts"],"names":[],"mappings":""}

package/lib/structures/internal/TtscCommonOptions.d.ts

@@ -15,6 +15,14 @@ export interface TtscCommonOptions {
     cwd?: string;
     /** Project root override for generated tsconfig wrappers. */
     projectRoot?: string;
+    /**
+     * Directory that anchors plugin config-file discovery and relative
+     * `configFile` resolution (forwarded to plugin processes as
+     * `TTSC_PLUGIN_CONFIG_DIR`). Set by build integrations that compile through a
+     * generated tsconfig outside the project; when omitted, plugins anchor at the
+     * tsconfig's own directory.
+     */
+    pluginConfigDir?: string;
     /** Environment variables merged over `process.env` for child processes. */
     env?: NodeJS.ProcessEnv;
     /** Explicit root directory for compiled source-plugin cache artifacts. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.18.3",
+  "version": "0.19.0",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -22,6 +22,9 @@
   },
   "author": "Jeongho Nam",
   "license": "MIT",
+  "engines": {
+    "node": ">=22.15.0"
+  },
   "bugs": {
     "url": "https://github.com/samchon/ttsc/issues"
   },
@@ -32,13 +35,13 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.18.3",
-    "@ttsc/linux-arm": "0.18.3",
-    "@ttsc/linux-arm64": "0.18.3",
-    "@ttsc/darwin-arm64": "0.18.3",
-    "@ttsc/win32-x64": "0.18.3",
-    "@ttsc/win32-arm64": "0.18.3",
-    "@ttsc/darwin-x64": "0.18.3"
+    "@ttsc/linux-x64": "0.19.0",
+    "@ttsc/darwin-x64": "0.19.0",
+    "@ttsc/linux-arm64": "0.19.0",
+    "@ttsc/darwin-arm64": "0.19.0",
+    "@ttsc/linux-arm": "0.19.0",
+    "@ttsc/win32-x64": "0.19.0",
+    "@ttsc/win32-arm64": "0.19.0"
   },
   "sideEffects": false,
   "files": [

package/shim/ast/lint.go

@@ -322,6 +322,16 @@ func GetCombinedNodeFlags(node *Node) NodeFlags {
   return innerast.GetCombinedNodeFlags(node)
 }
 
+// IsConstAssertion reports whether node is an `as const` or `<const>`
+// assertion. Unlike ordinary type assertions, a const assertion propagates
+// its own contextual type to the asserted expression.
+func IsConstAssertion(node *Node) bool { return innerast.IsConstAssertion(node) }
+
+// IsPartOfTypeNode reports whether node belongs to syntax that is evaluated
+// only by the type system. Lint rules use the upstream classifier so runtime
+// reference analysis stays aligned with TypeScript's AST semantics.
+func IsPartOfTypeNode(node *Node) bool { return innerast.IsPartOfTypeNode(node) }
+
 // IsLet reports whether the declaration was introduced by `let` / `using`.
 func IsLet(node *Node) bool { return GetCombinedNodeFlags(node)&NodeFlagsLet != 0 }
 

package/shim/ast/shim.go

@@ -177,6 +177,42 @@ const (
   ModifierFlagsReadonly  = innerast.ModifierFlagsReadonly
 )
 
+// OperatorPrecedence members. The complete family is re-exported by hand so
+// precedence comparisons (e.g. a lint fixer deciding whether a spliced
+// replacement must be parenthesized) can name every level of the
+// OperatorPrecedence type aliased in surface.go; a partial re-export would
+// trip the shim_audit zero-tolerance enum gate.
+const (
+  OperatorPrecedenceComma          = innerast.OperatorPrecedenceComma
+  OperatorPrecedenceSpread         = innerast.OperatorPrecedenceSpread
+  OperatorPrecedenceYield          = innerast.OperatorPrecedenceYield
+  OperatorPrecedenceAssignment     = innerast.OperatorPrecedenceAssignment
+  OperatorPrecedenceConditional    = innerast.OperatorPrecedenceConditional
+  OperatorPrecedenceLogicalOR      = innerast.OperatorPrecedenceLogicalOR
+  OperatorPrecedenceLogicalAND     = innerast.OperatorPrecedenceLogicalAND
+  OperatorPrecedenceBitwiseOR      = innerast.OperatorPrecedenceBitwiseOR
+  OperatorPrecedenceBitwiseXOR     = innerast.OperatorPrecedenceBitwiseXOR
+  OperatorPrecedenceBitwiseAND     = innerast.OperatorPrecedenceBitwiseAND
+  OperatorPrecedenceEquality       = innerast.OperatorPrecedenceEquality
+  OperatorPrecedenceRelational     = innerast.OperatorPrecedenceRelational
+  OperatorPrecedenceShift          = innerast.OperatorPrecedenceShift
+  OperatorPrecedenceAdditive       = innerast.OperatorPrecedenceAdditive
+  OperatorPrecedenceMultiplicative = innerast.OperatorPrecedenceMultiplicative
+  OperatorPrecedenceExponentiation = innerast.OperatorPrecedenceExponentiation
+  OperatorPrecedenceUnary          = innerast.OperatorPrecedenceUnary
+  OperatorPrecedenceUpdate         = innerast.OperatorPrecedenceUpdate
+  OperatorPrecedenceLeftHandSide   = innerast.OperatorPrecedenceLeftHandSide
+  OperatorPrecedenceOptionalChain  = innerast.OperatorPrecedenceOptionalChain
+  OperatorPrecedenceMember         = innerast.OperatorPrecedenceMember
+  OperatorPrecedencePrimary        = innerast.OperatorPrecedencePrimary
+  OperatorPrecedenceParentheses    = innerast.OperatorPrecedenceParentheses
+  OperatorPrecedenceLowest         = innerast.OperatorPrecedenceLowest
+  OperatorPrecedenceHighest        = innerast.OperatorPrecedenceHighest
+  OperatorPrecedenceDisallowComma  = innerast.OperatorPrecedenceDisallowComma
+  OperatorPrecedenceCoalesce       = innerast.OperatorPrecedenceCoalesce
+  OperatorPrecedenceInvalid        = innerast.OperatorPrecedenceInvalid
+)
+
 // NewNodeFactory creates an AST node factory with the supplied creation hooks.
 // Pass a zero-value NodeFactoryHooks to get the default factory behaviour.
 func NewNodeFactory(options NodeFactoryHooks) *NodeFactory {
@@ -195,6 +231,14 @@ func GetCombinedModifierFlags(node *Node) ModifierFlags {
   return innerast.GetCombinedModifierFlags(node)
 }
 
+// GetExpressionPrecedence returns the operator precedence of an expression
+// node — the level at which it binds relative to a surrounding expression.
+// Callers compare it against an OperatorPrecedence floor to decide whether a
+// textual splice of the expression into a new position needs parentheses.
+func GetExpressionPrecedence(expression *Expression) OperatorPrecedence {
+  return innerast.GetExpressionPrecedence(expression)
+}
+
 // IsFunctionLike reports whether node is any function-like construct
 // (function declaration, arrow function, method, constructor, accessor, etc.).
 func IsFunctionLike(node *Node) bool {

package/shim/checker/enums_gen.go

@@ -15,6 +15,25 @@ const (
   ElementFlagsNonRequired                               = innerchecker.ElementFlagsNonRequired
   ElementFlagsNonRest                                   = innerchecker.ElementFlagsNonRest
   ElementFlagsVariable                                  = innerchecker.ElementFlagsVariable
+  IterationTypeKindNext                                 = innerchecker.IterationTypeKindNext
+  IterationTypeKindReturn                               = innerchecker.IterationTypeKindReturn
+  IterationUseAllowsAsyncIterablesFlag                  = innerchecker.IterationUseAllowsAsyncIterablesFlag
+  IterationUseAllowsStringInputFlag                     = innerchecker.IterationUseAllowsStringInputFlag
+  IterationUseAllowsSyncIterablesFlag                   = innerchecker.IterationUseAllowsSyncIterablesFlag
+  IterationUseAsyncGeneratorReturnType                  = innerchecker.IterationUseAsyncGeneratorReturnType
+  IterationUseAsyncYieldStar                            = innerchecker.IterationUseAsyncYieldStar
+  IterationUseCacheFlags                                = innerchecker.IterationUseCacheFlags
+  IterationUseDestructuring                             = innerchecker.IterationUseDestructuring
+  IterationUseDestructuringFlag                         = innerchecker.IterationUseDestructuringFlag
+  IterationUseForAwaitOf                                = innerchecker.IterationUseForAwaitOf
+  IterationUseForOf                                     = innerchecker.IterationUseForOf
+  IterationUseForOfFlag                                 = innerchecker.IterationUseForOfFlag
+  IterationUseGeneratorReturnType                       = innerchecker.IterationUseGeneratorReturnType
+  IterationUsePossiblyOutOfBounds                       = innerchecker.IterationUsePossiblyOutOfBounds
+  IterationUseSpread                                    = innerchecker.IterationUseSpread
+  IterationUseSpreadFlag                                = innerchecker.IterationUseSpreadFlag
+  IterationUseYieldStar                                 = innerchecker.IterationUseYieldStar
+  IterationUseYieldStarFlag                             = innerchecker.IterationUseYieldStarFlag
   ObjectFlagsAnonymous                                  = innerchecker.ObjectFlagsAnonymous
   ObjectFlagsArrayLiteral                               = innerchecker.ObjectFlagsArrayLiteral
   ObjectFlagsContainsIntersections                      = innerchecker.ObjectFlagsContainsIntersections

package/shim/checker/shim.go

@@ -9,8 +9,11 @@
 package checker
 
 import (
+  "sync"
+
   innerast "github.com/microsoft/typescript-go/internal/ast"
   innerchecker "github.com/microsoft/typescript-go/internal/checker"
+  innerprinter "github.com/microsoft/typescript-go/internal/printer"
   _ "unsafe"
 )
 
@@ -22,6 +25,80 @@ type Type = innerchecker.Type
 type TypeFlags = innerchecker.TypeFlags
 type ObjectFlags = innerchecker.ObjectFlags
 type ElementFlags = innerchecker.ElementFlags
+type Program = innerchecker.Program
+type Tracer = innerchecker.Tracer
+
+// NewChecker creates a checker that owns its complete type graph for program.
+// The returned mutex is the upstream checker-pool synchronization primitive;
+// callers that share the checker must serialize access through it.
+func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) {
+  return innerchecker.NewChecker(program, tracer)
+}
+
+//go:linkname checkerGetRegularTypeOfLiteralType github.com/microsoft/typescript-go/internal/checker.(*Checker).getRegularTypeOfLiteralType
+func checkerGetRegularTypeOfLiteralType(recv *innerchecker.Checker, t *innerchecker.Type) *innerchecker.Type
+
+// Checker_getRegularTypeOfLiteralType returns the canonical regular form of a
+// literal type. TypeScript's checker uses this before comparing switch case
+// types because a source literal's fresh type and a union member's regular type
+// denote the same runtime value but have different pointers.
+func Checker_getRegularTypeOfLiteralType(recv *innerchecker.Checker, t *innerchecker.Type) *innerchecker.Type {
+  if recv == nil || t == nil {
+    return t
+  }
+  return checkerGetRegularTypeOfLiteralType(recv, t)
+}
+
+// Checker_typeToStringFullyQualified formats a type with the same stable,
+// alias-aware flags TypeScript uses in diagnostics that name union members.
+// Keeping the flag bundle inside the shim avoids leaking checker-internal enum
+// types through consumer code.
+func Checker_typeToStringFullyQualified(recv *innerchecker.Checker, t *innerchecker.Type, enclosingDeclaration *innerast.Node) string {
+  if recv == nil || t == nil {
+    return ""
+  }
+  return recv.TypeToStringEx(
+    t,
+    enclosingDeclaration,
+    innerchecker.TypeFormatFlagsAllowUniqueESSymbolType|
+      innerchecker.TypeFormatFlagsUseAliasDefinedOutsideCurrentScope|
+      innerchecker.TypeFormatFlagsUseFullyQualifiedType,
+    nil,
+  )
+}
+
+// Checker_symbolToValueString formats a symbol as a value-position expression
+// at enclosingDeclaration. AllowAnyNodeKind lets the checker emit indexed
+// access for enum members whose names cannot use dot notation.
+func Checker_symbolToValueString(recv *innerchecker.Checker, symbol *innerast.Symbol, enclosingDeclaration *innerast.Node) string {
+  if recv == nil || symbol == nil {
+    return ""
+  }
+  return recv.SymbolToStringEx(
+    symbol,
+    enclosingDeclaration,
+    innerast.SymbolFlagsValue,
+    innerchecker.SymbolFormatFlagsAllowAnyNodeKind,
+  )
+}
+
+// Checker_isSymbolAccessibleAsValue verifies that SymbolToStringEx can name a
+// symbol from enclosingDeclaration. Unlike GetAccessibleSymbolChain, the
+// checker also follows containing enum, class, and namespace symbols, so a
+// qualified member such as Domain.Mode.Done is accepted when its container is
+// visible.
+func Checker_isSymbolAccessibleAsValue(recv *innerchecker.Checker, symbol *innerast.Symbol, enclosingDeclaration *innerast.Node) bool {
+  if recv == nil || symbol == nil || enclosingDeclaration == nil {
+    return false
+  }
+  result := recv.IsSymbolAccessible(
+    symbol,
+    enclosingDeclaration,
+    innerast.SymbolFlagsValue,
+    false,
+  )
+  return result.Accessibility == innerprinter.SymbolAccessibilityAccessible
+}
 
 const (
   SignatureKindCall = innerchecker.SignatureKindCall
@@ -110,6 +187,59 @@ func Checker_getTypeOfPropertyOfType(recv *innerchecker.Checker, t *innerchecker
   return recv.GetTypeOfPropertyOfType(t, name)
 }
 
+//go:linkname checkerGetPropertyNameForKnownSymbolName github.com/microsoft/typescript-go/internal/checker.(*Checker).getPropertyNameForKnownSymbolName
+func checkerGetPropertyNameForKnownSymbolName(recv *innerchecker.Checker, symbolName string) string
+
+// Checker_getPropertyNameForKnownSymbolName returns the late-bound property
+// name the checker uses for a member keyed by the global well-known symbol
+// `Symbol.<symbolName>` (e.g. "asyncIterator", "asyncDispose", "iterator").
+// It resolves the unique-symbol type of that property on the global
+// `SymbolConstructor` — including lib-provided and `declare global` augmented
+// members — so `(*Checker).GetPropertyOfType(t, name)` with the returned name
+// finds exactly the members declared as `[Symbol.<symbolName>]`. This is the
+// same resolution the checker itself performs when it validates `for await`
+// iterability, which is why a lint rule that mirrors typescript-eslint's
+// well-known-symbol protocol checks must go through it instead of matching
+// property-name text. When the global `Symbol` constructor lacks the member,
+// the checker's internal fallback name (a `\xFE@`-prefixed string no
+// source-declared property can late-bind to) is returned, so lookups simply
+// find nothing. Returns "" if recv is nil.
+func Checker_getPropertyNameForKnownSymbolName(recv *innerchecker.Checker, symbolName string) string {
+  if recv == nil {
+    return ""
+  }
+  return checkerGetPropertyNameForKnownSymbolName(recv, symbolName)
+}
+
+//go:linkname checkerGetIterationTypeOfIterable github.com/microsoft/typescript-go/internal/checker.(*Checker).getIterationTypeOfIterable
+func checkerGetIterationTypeOfIterable(
+  recv *innerchecker.Checker,
+  use innerchecker.IterationUse,
+  typeKind innerchecker.IterationTypeKind,
+  inputType *innerchecker.Type,
+  errorNode *innerast.Node,
+) *innerchecker.Type
+
+// Checker_getSynchronousIterationYieldType returns the value type produced by
+// inputType's checked `[Symbol.iterator]` protocol. It delegates to the same
+// TypeScript-Go traversal used for synchronous iteration, including inherited
+// and structural iterables, instantiated iterator returns, intersections, and
+// primitive strings. A nil result means the checker could not derive a valid
+// synchronous iteration type. Diagnostics are intentionally disabled because
+// callers use this as a type query after normal TypeScript checking.
+func Checker_getSynchronousIterationYieldType(recv *innerchecker.Checker, inputType *innerchecker.Type) *innerchecker.Type {
+  if recv == nil || inputType == nil {
+    return nil
+  }
+  return checkerGetIterationTypeOfIterable(
+    recv,
+    innerchecker.IterationUseElement,
+    innerchecker.IterationTypeKindYield,
+    inputType,
+    nil,
+  )
+}
+
 //go:linkname checkerGetAliasSymbolForTypeNode github.com/microsoft/typescript-go/internal/checker.(*Checker).getAliasSymbolForTypeNode
 func checkerGetAliasSymbolForTypeNode(recv *innerchecker.Checker, node *innerast.Node) *innerast.Symbol
 

package/shim/diagnosticwriter/lint.go

@@ -30,6 +30,35 @@ const (
   LintCategoryError
 )
 
+// NormalizeLintRange returns a renderer-safe half-open source span. Diagnostic
+// producers are a plugin trust boundary, so offsets are clamped even when the
+// caller's contract says they point inside the current file. Reversed and
+// zero-width ranges select one byte when one exists at pos; EOF and empty-file
+// ranges remain zero-width instead of manufacturing a byte past the source.
+func NormalizeLintRange(file *ast.SourceFile, pos, end int) (int, int) {
+  if file == nil {
+    return 0, 0
+  }
+  sourceLen := len(file.Text())
+  if pos < 0 {
+    pos = 0
+  } else if pos > sourceLen {
+    pos = sourceLen
+  }
+  if end < 0 {
+    end = 0
+  } else if end > sourceLen {
+    end = sourceLen
+  }
+  if end <= pos {
+    end = pos
+    if pos < sourceLen {
+      end++
+    }
+  }
+  return pos, end
+}
+
 // LintDiagnostic is a public, plugin-emittable diagnostic shaped like the
 // `internal/diagnosticwriter.Diagnostic` interface. The internal type is
 // unexported, so this is the only way to mix lint output with tsgo's own
@@ -47,9 +76,7 @@ type LintDiagnostic struct {
 // supplied source file. `code` shows up in the rendered banner — the
 // convention is to give each rule its own stable integer.
 func NewLintDiagnostic(file *ast.SourceFile, pos, end int, code int32, category LintCategory, message string) *LintDiagnostic {
-  if end <= pos {
-    end = pos + 1
-  }
+  pos, end = NormalizeLintRange(file, pos, end)
   return &LintDiagnostic{
     file:     file,
     pos:      pos,

package/shim/printer/shim.go

@@ -1,7 +1,6 @@
-// Package printer re-exports the typescript-go internal/printer types and
-// wraps the three functions that the ttsc driver and transform plugins need
-// to emit source text from an AST. The surface is intentionally narrow: only
-// the construction and single-file emit path are exposed.
+// Package printer re-exports the typescript-go internal/printer types that the
+// ttsc driver and transform plugins need to emit source text and allocate
+// collision-safe generated identifiers. The surface is intentionally narrow.
 package printer
 
 import (
@@ -24,6 +23,25 @@ type PrinterOptions = innerprinter.PrinterOptions
 // and must be created fresh for each emit round via NewEmitContext.
 type EmitContext = innerprinter.EmitContext
 
+// AutoGenerateOptions configures how NodeFactory allocates generated names.
+type AutoGenerateOptions = innerprinter.AutoGenerateOptions
+
+// GeneratedIdentifierFlags controls generated-name scope and collision checks.
+type GeneratedIdentifierFlags = innerprinter.GeneratedIdentifierFlags
+
+const (
+  GeneratedIdentifierFlagsNone                   = innerprinter.GeneratedIdentifierFlagsNone
+  GeneratedIdentifierFlagsAuto                   = innerprinter.GeneratedIdentifierFlagsAuto
+  GeneratedIdentifierFlagsLoop                   = innerprinter.GeneratedIdentifierFlagsLoop
+  GeneratedIdentifierFlagsUnique                 = innerprinter.GeneratedIdentifierFlagsUnique
+  GeneratedIdentifierFlagsNode                   = innerprinter.GeneratedIdentifierFlagsNode
+  GeneratedIdentifierFlagsKindMask               = innerprinter.GeneratedIdentifierFlagsKindMask
+  GeneratedIdentifierFlagsReservedInNestedScopes = innerprinter.GeneratedIdentifierFlagsReservedInNestedScopes
+  GeneratedIdentifierFlagsOptimistic             = innerprinter.GeneratedIdentifierFlagsOptimistic
+  GeneratedIdentifierFlagsFileLevel              = innerprinter.GeneratedIdentifierFlagsFileLevel
+  GeneratedIdentifierFlagsAllowNameSubstitution  = innerprinter.GeneratedIdentifierFlagsAllowNameSubstitution
+)
+
 // NewPrinter creates an emitter with the supplied options, substitution hooks,
 // and emit context. Callers must pass the same EmitContext to all operations
 // in a single emit round.

package/shim/scanner/regexp.go

@@ -0,0 +1,27 @@
+package scanner
+
+import (
+  "github.com/microsoft/typescript-go/internal/ast"
+  "github.com/microsoft/typescript-go/internal/diagnostics"
+)
+
+// IsValidRegularExpressionLiteral reports whether text is one complete,
+// grammar-valid ECMAScript regular-expression literal. It deliberately uses
+// typescript-go's own scanner and regexp parser so callers share the compiler's
+// handling of escapes, flags, Unicode mode, and Unicode Sets syntax.
+func IsValidRegularExpressionLiteral(text string) bool {
+  scanner := NewScanner()
+  valid := true
+  scanner.SetOnError(func(_ *diagnostics.Message, _, _ int, _ ...any) {
+    valid = false
+  })
+  scanner.SetText(text)
+  token := scanner.Scan()
+  if token != ast.KindSlashToken && token != ast.KindSlashEqualsToken {
+    return false
+  }
+  if scanner.ReScanSlashToken(true) != ast.KindRegularExpressionLiteral {
+    return false
+  }
+  return valid && scanner.TokenEnd() == len(text)
+}

package/src/TtscCompiler.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { compileProjectInMemory } from "./compiler/internal/compileProjectInMemory";
 import { resolveProjectConfig } from "./compiler/internal/project/resolveProjectConfig";
 import { resolveBinary } from "./compiler/internal/resolveBinary";
+import { createProcessDiagnostic } from "./compiler/internal/runBuild";
 import { transformProjectInMemory } from "./compiler/internal/transformProjectInMemory";
 import { resolveCleanTargets } from "./plugin/internal/buildSourcePlugin";
 import { loadProjectPlugins } from "./plugin/internal/loadProjectPlugins";
@@ -73,6 +74,8 @@ export class TtscCompiler {
       cacheDir: this.resolvePluginCacheDir(),
       cwd: execution.cwd,
       entries: this.context.plugins,
+      env: this.resolveEffectiveEnv(),
+      pluginConfigDir: this.context.pluginConfigDir,
       projectRoot: execution.projectRoot,
       tsconfig: execution.tsconfig,
     });
@@ -107,16 +110,20 @@ export class TtscCompiler {
       // cache dir.
       return removeExistingDirectories([explicitCacheDir, ...legacyTargets]);
     }
-    // Default / `context.env.TTSC_CACHE_DIR`: resolve the cache root exactly as
-    // prepare() does (`context.env.TTSC_CACHE_DIR`) and the Go build cache from
-    // the ambient process env — the same source `go build` reads via
-    // goBuildEnv — then remove only the ttsc-owned subdirectories, so a
-    // possibly-shared root is never deleted.
+    // 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(
         projectRoot,
         this.resolvePluginCacheDir(),
-        process.env,
+        this.resolveEffectiveEnv(),
       ),
     );
   }
@@ -132,8 +139,9 @@ export class TtscCompiler {
    * directory before returning.
    *
    * The result uses an `embed-typescript`-style discriminated union: `success`
-   * for clean compiles, `failure` for normal compiler diagnostics, and
-   * `exception` for host setup or process failures.
+   * for clean compiles, `failure` for compiler diagnostics or plugin failures
+   * that reached the build pipeline, and `exception` for host failures that
+   * prevent any project check from running.
    *
    * @returns Structured compilation result containing diagnostics or output.
    */
@@ -217,6 +225,19 @@ export class TtscCompiler {
   private resolvePluginCacheDir(): string | undefined {
     return this.resolveCacheDir() ?? this.context.env?.TTSC_CACHE_DIR;
   }
+
+  /**
+   * 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.
+   */
+  private resolveEffectiveEnv(): NodeJS.ProcessEnv {
+    return { ...process.env, ...this.context.env };
+  }
 }
 
 function removeExistingDirectories(directories: readonly string[]): string[] {
@@ -347,20 +368,6 @@ function toCompilerResult(project: ProjectResult): ITtscCompilerResult {
   };
 }
 
-function createProcessDiagnostic(
-  result: TtscBuildResult,
-): ITtscCompilerDiagnostic {
-  const messageText =
-    (result.stderr || result.stdout).trim() ||
-    `ttsc exited with status ${result.status}`;
-  return {
-    category: "error",
-    code: "TTSC_PROCESS",
-    file: null,
-    messageText,
-  };
-}
-
 function toCompilerTransformation(
   project: ProjectTransformation,
 ): ITtscCompilerTransformation {