ttsc 0.18.4 → 0.19.0

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

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { ITtscProjectPluginConfig } from "../../../structures/ITtscProjectPluginConfig";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
-import { resolveProjectConfig } from "./resolveProjectConfig";
+import { resolveProjectIdentity } from "./resolveProjectConfig";
 
 /**
  * Compiler option keys whose values are file-system paths that must be resolved
@@ -40,10 +40,9 @@ type ResolvedCompilerOptions = {
 export function readProjectConfig(
   opts: ITtscProjectLocatorOptions = {},
 ): ITtscParsedProjectConfig {
-  const tsconfig = resolveProjectConfig(opts);
-  const root = opts.projectRoot
-    ? path.resolve(opts.cwd ?? process.cwd(), opts.projectRoot)
-    : path.dirname(tsconfig);
+  const identity = resolveProjectIdentity(opts);
+  const tsconfig = identity.physicalConfigPath;
+  const root = identity.physicalProjectRoot;
   const compilerOptions = readResolvedCompilerOptions(tsconfig);
   return {
     compilerOptions: {
@@ -51,6 +50,7 @@ export function readProjectConfig(
       outDir: compilerOptions.outDir,
       plugins: compilerOptions.plugins,
     },
+    identity,
     path: tsconfig,
     pluginBaseDirs: compilerOptions.pluginBaseDirs,
     root,
@@ -254,6 +254,14 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
     return resolveExistingExtendsPath(path.resolve(baseDir, specifier));
   }
   const resolver = createRequire(tsconfig);
+  // A bare package root selects its preset through `package.json#tsconfig`,
+  // matching TypeScript's config resolution. Presets shipped this way often
+  // have no JavaScript/JSON entrypoint at all, so Node's entrypoint resolver
+  // and the `<specifier>.json` fallback below both miss them.
+  const viaManifest = resolvePackageManifestTsconfig(resolver, specifier);
+  if (viaManifest !== undefined) {
+    return resolveExistingExtendsPath(viaManifest);
+  }
   try {
     return resolveRealPath(resolver.resolve(specifier));
   } catch {
@@ -261,6 +269,54 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
   }
 }
 
+/**
+ * When `specifier` names a bare package root, resolve the config file its
+ * `package.json#tsconfig` field selects (anchored at the package directory).
+ * Returns `undefined` when the specifier is a subpath, the manifest is
+ * unresolvable/unparsable, or it declares no `tsconfig` field, so the caller
+ * falls back to Node entrypoint resolution.
+ */
+function resolvePackageManifestTsconfig(
+  resolver: NodeRequire,
+  specifier: string,
+): string | undefined {
+  if (!isBarePackageRoot(specifier)) {
+    return undefined;
+  }
+  let manifestPath: string;
+  try {
+    manifestPath = resolver.resolve(`${specifier}/package.json`);
+  } catch {
+    return undefined;
+  }
+  let field: unknown;
+  try {
+    field = (
+      JSON.parse(stripLeadingBom(fs.readFileSync(manifestPath, "utf8"))) as {
+        tsconfig?: unknown;
+      }
+    ).tsconfig;
+  } catch {
+    return undefined;
+  }
+  if (typeof field !== "string" || field.length === 0) {
+    return undefined;
+  }
+  return path.resolve(path.dirname(manifestPath), field);
+}
+
+/**
+ * Return true when `specifier` is a bare package root (no subpath): a plain
+ * package name (`preset`) or a scoped name (`@scope/preset`). Subpaths such as
+ * `@scope/preset/base.json` resolve directly and keep their current meaning.
+ */
+function isBarePackageRoot(specifier: string): boolean {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").length === 2;
+  }
+  return !specifier.includes("/");
+}
+
 /**
  * Given an on-disk location, try the path as-is, with `.json` appended, and as
  * a directory containing `tsconfig.json`. Returns the first match or throws.

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

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 
+import type { ITtscProjectIdentity } from "../../../structures/internal/ITtscProjectIdentity";
 import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
 
 /**
@@ -13,13 +14,29 @@ import type { ITtscProjectLocatorOptions } from "../../../structures/internal/IT
  *    walking up from the file's directory.
  * 3. `opts.cwd` — the nearest ancestor config walking up from cwd.
  *
- * Always returns a real (symlink-resolved) absolute path. Throws when no config
- * is found or the explicitly supplied path does not exist.
+ * Returns the real (symlink-resolved) absolute config path. Use
+ * {@link resolveProjectIdentity} when both the caller-selected spelling and the
+ * Program identity are required.
  */
 export function resolveProjectConfig(
   opts: ITtscProjectLocatorOptions = {},
 ): string {
+  return resolveProjectIdentity(opts).physicalConfigPath;
+}
+
+/**
+ * Resolve the selected config while retaining its lexical spelling separately
+ * from the physical paths used by the TypeScript Program.
+ */
+export function resolveProjectIdentity(
+  opts: ITtscProjectLocatorOptions = {},
+): Omit<ITtscProjectIdentity, "pluginConfigOrigin"> {
   const cwd = path.resolve(opts.cwd ?? process.cwd());
+  const explicitProjectRoot =
+    opts.projectRoot === undefined || opts.projectRoot === ""
+      ? undefined
+      : resolveAbsolutePath(cwd, opts.projectRoot);
+  let logicalConfigPath: string;
   if (opts.tsconfig) {
     const resolved = resolveAbsolutePath(cwd, opts.tsconfig);
     if (!fs.existsSync(resolved)) {
@@ -35,30 +52,43 @@ export function resolveProjectConfig(
     if (isDirectory(resolved)) {
       const tsconfigInDir = path.join(resolved, "tsconfig.json");
       if (fs.existsSync(tsconfigInDir)) {
-        return resolveRealPath(tsconfigInDir);
-      }
-      const jsconfigInDir = path.join(resolved, "jsconfig.json");
-      if (fs.existsSync(jsconfigInDir)) {
-        return resolveRealPath(jsconfigInDir);
+        logicalConfigPath = tsconfigInDir;
+      } else {
+        const jsconfigInDir = path.join(resolved, "jsconfig.json");
+        if (fs.existsSync(jsconfigInDir)) {
+          logicalConfigPath = jsconfigInDir;
+        } else {
+          throw new Error(
+            `ttsc: directory has no tsconfig.json / jsconfig.json: ${resolved}`,
+          );
+        }
       }
+    } else {
+      logicalConfigPath = resolved;
+    }
+  } else {
+    const start = opts.file ? resolveAbsolutePath(cwd, opts.file) : cwd;
+    const from = isDirectory(start) ? start : path.dirname(start);
+    const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
+    if (!found) {
       throw new Error(
-        `ttsc: directory has no tsconfig.json / jsconfig.json: ${resolved}`,
+        `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
       );
     }
-    return resolveRealPath(resolved);
-  }
-
-  const start = opts.file
-    ? resolveRealPath(resolveAbsolutePath(cwd, opts.file))
-    : cwd;
-  const from = isDirectory(start) ? start : path.dirname(start);
-  const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
-  if (!found) {
-    throw new Error(
-      `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
-    );
+    logicalConfigPath = found;
   }
-  return resolveRealPath(found);
+  const physicalConfigPath = resolveRealPath(logicalConfigPath);
+  const physicalProjectRoot = resolveRealPath(
+    explicitProjectRoot ?? path.dirname(physicalConfigPath),
+  );
+  return {
+    ...(explicitProjectRoot === undefined ? {} : { explicitProjectRoot }),
+    invocationCwd: cwd,
+    logicalConfigPath,
+    logicalProjectRoot: path.dirname(logicalConfigPath),
+    physicalConfigPath,
+    physicalProjectRoot,
+  };
 }
 
 /** Resolve `target` against `cwd` when it is not already absolute. */

package/src/compiler/internal/residentTransformProcess.ts

@@ -4,6 +4,19 @@ import { type Interface, createInterface } from "node:readline";
 /** Cap on retained stderr so a long-lived host cannot grow it without bound. */
 const STDERR_TAIL_LIMIT = 64 * 1024;
 
+/** Cap on how much of an offending line an error message echoes back. */
+const REPLY_ECHO_LIMIT = 200;
+
+/**
+ * The operation a request expects a reply for. The host answers a transform
+ * request (`{"file":...}`) with `{"typescript":...,"found":...}` and an update
+ * request (`{"update":...,"content":...}`) with `{"updated":...}`. The client
+ * knows which it sent, so it validates the reply's shape against the operation
+ * before handing it back — a well-formed JSON object of the wrong operation
+ * shape is a protocol error, not a valid negative result.
+ */
+export type ResidentReplyKind = "transform" | "update";
+
 /** Options for spawning the resident transform host. */
 export interface ResidentTransformProcessOptions {
   args: readonly string[];
@@ -13,6 +26,7 @@ export interface ResidentTransformProcessOptions {
 }
 
 interface PendingRequest {
+  kind: ResidentReplyKind;
   reject: (reason: Error) => void;
   resolve: (reply: Record<string, unknown>) => void;
 }
@@ -78,13 +92,16 @@ export class ResidentTransformProcess {
   }
 
   /**
-   * Send one request to the host and resolve with its parsed JSON reply. The
-   * host answers in FIFO order, so the caller interprets the reply shape by the
-   * payload it sent (a transform reply vs an update reply). Rejects when the
-   * host has already failed or exited, or if writing the request fails.
+   * Send one request to the host and resolve with its validated JSON reply. The
+   * host answers in FIFO order; `kind` tells the client which reply shape the
+   * payload asks for, so the reply is validated as a well-formed `kind` reply
+   * before it resolves. Rejects when the reply is not a valid `kind` reply,
+   * when the host has already failed or exited, or if writing the request
+   * fails.
    */
   public request(
     payload: Record<string, unknown>,
+    kind: ResidentReplyKind,
   ): Promise<Record<string, unknown>> {
     if (this.failure !== undefined) {
       return Promise.reject(this.failure);
@@ -96,7 +113,7 @@ export class ResidentTransformProcess {
       );
     }
     return new Promise<Record<string, unknown>>((resolve, reject) => {
-      const pending: PendingRequest = { reject, resolve };
+      const pending: PendingRequest = { kind, reject, resolve };
       this.pending.push(pending);
       stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
         if (error) {
@@ -149,7 +166,39 @@ export class ResidentTransformProcess {
       }
       return;
     }
-    request.resolve(parseReply(trimmed));
+    const reply = parseReplyObject(trimmed);
+    if (reply === undefined) {
+      // Framing violation: the line is not a JSON object, so it cannot
+      // represent any reply. This request already left the FIFO, so reject it,
+      // then fail the whole process: a bad line may be corruption that shifted
+      // the stream, and the host's real reply that follows must not be paired
+      // with a later request. `fail` marks the failure so that trailing line is
+      // treated as benign instead of unsolicited.
+      const error = new Error(
+        `ttsc: resident transform host sent a malformed reply: ${echoLine(
+          trimmed,
+        )}`,
+      );
+      request.reject(error);
+      this.fail(error);
+      return;
+    }
+    if (!isValidReply(reply, request.kind)) {
+      // Operation-shape violation: a well-formed JSON object that is not a valid
+      // reply for the operation this request sent. FIFO framing is intact — one
+      // line consumed exactly one slot — so only this request is corrupt; later
+      // replies still pair correctly. Reject just this request instead of
+      // failing the whole process.
+      request.reject(
+        new Error(
+          `ttsc: resident transform host sent an invalid ${request.kind} reply: ${echoLine(
+            trimmed,
+          )}`,
+        ),
+      );
+      return;
+    }
+    request.resolve(reply);
   }
 
   private onReaderClose(): void {
@@ -194,23 +243,48 @@ export class ResidentTransformProcess {
 }
 
 /**
- * Parse one reply line into a plain object. A malformed line degrades to an
- * empty object rather than throwing, so one bad line never rejects a request
- * the FIFO has already advanced past; the caller reads missing fields as
- * absent.
+ * Parse one reply line into a plain object, or `undefined` when the line is not
+ * a JSON object. Invalid JSON, arrays, primitives, and `null` all yield
+ * `undefined`: none of them can carry a reply's fields, so the caller treats
+ * them as a framing failure rather than an empty reply. Returning `{}` here
+ * would let a corrupt line masquerade as a valid negative result.
  */
-function parseReply(line: string): Record<string, unknown> {
+function parseReplyObject(line: string): Record<string, unknown> | undefined {
+  let parsed: unknown;
   try {
-    const parsed = JSON.parse(line) as unknown;
-    if (
-      typeof parsed === "object" &&
-      parsed !== null &&
-      !Array.isArray(parsed)
-    ) {
-      return parsed as Record<string, unknown>;
-    }
+    parsed = JSON.parse(line);
   } catch {
-    // A non-object or unparseable line is treated as an empty reply.
+    return undefined;
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
+  }
+  return undefined;
+}
+
+/**
+ * Whether a parsed reply object is a well-formed reply for the given operation.
+ * A transform reply must carry a boolean `found`, and when `found` is `true` a
+ * string `typescript` (a found file always carries its transformed text); when
+ * `found` is `false` the text is irrelevant. An update reply must carry a
+ * boolean `updated`. Every other object shape is a protocol error.
+ */
+function isValidReply(
+  reply: Record<string, unknown>,
+  kind: ResidentReplyKind,
+): boolean {
+  if (kind === "transform") {
+    if (typeof reply.found !== "boolean") {
+      return false;
+    }
+    return reply.found ? typeof reply.typescript === "string" : true;
   }
-  return {};
+  return typeof reply.updated === "boolean";
+}
+
+/** Truncate an offending reply line so error messages stay bounded. */
+function echoLine(line: string): string {
+  return line.length > REPLY_ECHO_LIMIT
+    ? `${line.slice(0, REPLY_ECHO_LIMIT)}…`
+    : line;
 }

package/src/compiler/internal/runBuild.ts

@@ -7,15 +7,18 @@ import {
 } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerDiagnostic } from "../../structures/ITtscCompilerDiagnostic";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
+import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
 import type { TtscCommonOptions } from "../../structures/internal/TtscCommonOptions";
+import { createNativeProjectContextArgs } from "./project/createNativeProjectContextArgs";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
 import {
   assertSharedHostCompatibility,
   linkedTransformPlugins,
+  resolvePluginConfigDir,
   selectSharedHostPlugin,
 } from "./sharedHostHelpers";
 import { outputText, spawnNative } from "./spawnNative";
@@ -23,6 +26,16 @@ import { outputText, spawnNative } from "./spawnNative";
 type RunBuildOptions = TtscBuildOptions & {
   skipDiagnosticsCheck?: boolean;
   forceListEmittedFiles?: boolean;
+  /**
+   * Emit an external source map from the direct tsgo build lane even when the
+   * project configures none. Set by the ttsx runtime builds so a served emit
+   * carries a map to inline under the source URL (issue #353). Applied only to
+   * the plain tsgo emit — never forwarded to a native plugin host, whose own
+   * emit honours the project's `sourceMap` setting.
+   */
+  forceRuntimeSourceMap?: boolean;
+  /** Retain an already selected project's lexical identity across API lanes. */
+  resolvedProject?: ITtscParsedProjectConfig;
 };
 
 type BuildTiming = {
@@ -119,9 +132,13 @@ function formatTimingSeconds(ms: number): string {
 
 /**
  * Build the environment for a native plugin spawn. Injects `TTSC_TSGO_BINARY`
- * and `TTSC_TTSX_BINARY` alongside the base env from `mergeEnv`. For
- * transform-stage plugins, also passes `TTSC_LINKED_PLUGINS_JSON` containing
- * any linked sources so they run inside the same process as the host plugin.
+ * and `TTSC_TTSX_BINARY` alongside the base env from `mergeEnv`, plus
+ * `TTSC_PLUGIN_CONFIG_DIR` when the caller declared a plugin config anchor (an
+ * embedder compiling through a generated wrapper tsconfig) so config-file
+ * discovery walks the real project instead of the wrapper's temp-dir ancestry.
+ * For transform-stage plugins, also passes `TTSC_LINKED_PLUGINS_JSON`
+ * containing any linked sources so they run inside the same process as the host
+ * plugin.
  */
 function nativePluginEnv(
   extra: NodeJS.ProcessEnv | undefined,
@@ -129,12 +146,25 @@ function nativePluginEnv(
   plugin?: ITtscLoadedNativePlugin,
 ): NodeJS.ProcessEnv {
   const env = mergeEnv({
+    ...(execution.pluginConfigDir === undefined
+      ? {}
+      : { TTSC_PLUGIN_CONFIG_DIR: execution.pluginConfigDir }),
     TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? execution.tsgo.binary,
     TTSC_TTSX_BINARY:
       process.env.TTSC_TTSX_BINARY ??
       path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
     ...extra,
   });
+  // The anchor is per-invocation state owned by this host: when this run
+  // declared none (and the caller's env does not name one), drop any value
+  // inherited from an ancestor ttsc process so a nested build never
+  // mis-anchors its plugins at the outer project.
+  if (
+    execution.pluginConfigDir === undefined &&
+    extra?.TTSC_PLUGIN_CONFIG_DIR === undefined
+  ) {
+    delete env.TTSC_PLUGIN_CONFIG_DIR;
+  }
   if (plugin?.stage === "transform") {
     const linked = linkedTransformPlugins(execution.nativePlugins);
     if (linked.length !== 0) {
@@ -664,6 +694,12 @@ function createTsgoBuildArgs(
     if (execution.rewriteRelativeImportExtensionsForEmit) {
       args.push("--rewriteRelativeImportExtensions");
     }
+    // The ttsx runtime build asks for an external map when the project emits
+    // none, so its served emit carries a map to inline under the source URL.
+    // Pushed before passthrough so an explicit user `--sourceMap` still wins.
+    if (options.forceRuntimeSourceMap === true) {
+      args.push("--sourceMap", "true");
+    }
   } else if (options.emit === false) {
     args.push("--noEmit");
   }
@@ -731,6 +767,16 @@ function createNativeBuildArgs(
     "--plugins-json=" + serializeNativePlugins(plugins),
     "--cwd=" + execution.projectRoot,
   ];
+  if (
+    selectSharedHostPlugin(plugins).capabilities?.projectContextArgs === true
+  ) {
+    args.push(
+      ...createNativeProjectContextArgs(
+        execution.project,
+        execution.pluginConfigDir,
+      ),
+    );
+  }
   if (options.emit === true) {
     args.push("--emit");
   }
@@ -763,6 +809,14 @@ function createNativeCheckArgs(
     "--plugins-json=" + serializeNativePlugins(execution.nativePlugins),
     "--cwd=" + execution.projectRoot,
   ];
+  if (plugin.capabilities?.projectContextArgs === true) {
+    args.push(
+      ...createNativeProjectContextArgs(
+        execution.project,
+        execution.pluginConfigDir,
+      ),
+    );
+  }
   if (options.outDir) {
     args.push("--outDir=" + path.resolve(execution.cwd, options.outDir));
   }
@@ -1059,14 +1113,20 @@ export function createProcessDiagnostic(
  * here so every code path in `runBuild` shares the same resolution logic.
  */
 function resolveExecutionContext(
-  options: TtscCommonOptions & { emit?: boolean; tsconfig?: string },
+  options: TtscCommonOptions & {
+    emit?: boolean;
+    resolvedProject?: ITtscParsedProjectConfig;
+    tsconfig?: string;
+  },
 ) {
   const cwd = path.resolve(options.cwd ?? process.cwd());
-  const project = readProjectConfig({
-    cwd,
-    projectRoot: options.projectRoot,
-    tsconfig: options.tsconfig,
-  });
+  const project =
+    options.resolvedProject ??
+    readProjectConfig({
+      cwd,
+      projectRoot: options.projectRoot,
+      tsconfig: options.tsconfig,
+    });
   const tsconfig = project.path;
   const projectRoot = project.root;
   const tsgo = resolveTsgo({ ...options, cwd: projectRoot });
@@ -1079,6 +1139,8 @@ function resolveExecutionContext(
         cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
         cwd,
         entries: options.plugins,
+        env: { ...process.env, ...options.env },
+        pluginConfigDir: options.pluginConfigDir,
         projectRoot,
         tsconfig,
       }).nativePlugins;
@@ -1094,7 +1156,12 @@ function resolveExecutionContext(
   return {
     cwd,
     nativePlugins,
+    pluginConfigDir: resolvePluginConfigDir({
+      cwd,
+      pluginConfigDir: options.pluginConfigDir,
+    }),
     pluginSetupFailure,
+    project,
     projectNoEmit: project.compilerOptions.noEmit === true,
     projectRoot,
     rewriteRelativeImportExtensionsForEmit:

package/src/compiler/internal/runSingleFileEmit.ts

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 
 import type { TtscSingleFileEmitOptions } from "../../structures/internal/TtscSingleFileEmitOptions";
-import { resolveProjectConfig } from "./project/resolveProjectConfig";
+import { readProjectConfig } from "./project/readProjectConfig";
 import { resolveEmittedJavaScript } from "./resolveEmittedJavaScript";
 import { runBuild } from "./runBuild";
 
@@ -24,12 +24,14 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
       ? options.file
       : path.resolve(cwd, options.file),
   );
-  const tsconfig = resolveProjectConfig({
+  const project = readProjectConfig({
     cwd,
-    file: sourceFile,
+    file: options.file,
+    projectRoot: options.projectRoot,
     tsconfig: options.tsconfig,
   });
-  const projectRoot = path.dirname(tsconfig);
+  const tsconfig = project.path;
+  const projectRoot = project.root;
   const outDir = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-single-file-"));
   try {
     const result = runBuild({
@@ -38,6 +40,7 @@ export function runSingleFileEmit(options: TtscSingleFileEmitOptions): string {
       emit: true,
       forceListEmittedFiles: true,
       outDir,
+      resolvedProject: project,
       tsconfig,
     });
     if (result.status !== 0) {

package/src/compiler/internal/sharedHostHelpers.ts

@@ -1,5 +1,29 @@
+import path from "node:path";
+
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 
+/**
+ * Resolve the caller-declared plugin config anchor to an absolute path, or
+ * `undefined` when the caller did not declare one.
+ *
+ * The anchor exists for embedders that compile through a generated tsconfig
+ * outside the project (the bundler adapters' alias overlay): they set
+ * `pluginConfigDir` to the real project directory and every native plugin spawn
+ * forwards it as `TTSC_PLUGIN_CONFIG_DIR`, so config-file discovery walks the
+ * project instead of the wrapper's temp-dir ancestry. Callers that point at a
+ * user-authored tsconfig (even a wrapper outside the project) leave it unset,
+ * keeping discovery anchored at the tsconfig's own directory.
+ */
+export function resolvePluginConfigDir(options: {
+  cwd?: string;
+  pluginConfigDir?: string;
+}): string | undefined {
+  if (options.pluginConfigDir === undefined || options.pluginConfigDir === "") {
+    return undefined;
+  }
+  return path.resolve(options.cwd ?? process.cwd(), options.pluginConfigDir);
+}
+
 /**
  * Reports whether the given transform source is linked into another compiler
  * host instead of owning the process itself.

package/src/compiler/internal/startResidentTransform.ts

@@ -10,6 +10,7 @@ import { resolveTsgo } from "./resolveTsgo";
 import {
   assertSharedHostCompatibility,
   linkedTransformPlugins,
+  resolvePluginConfigDir,
   selectSharedHostPlugin,
 } from "./sharedHostHelpers";
 
@@ -51,6 +52,8 @@ export function startResidentTransform(
     cacheDir: context.cacheDir ?? context.env?.TTSC_CACHE_DIR,
     cwd,
     entries: context.plugins,
+    env: { ...process.env, ...context.env },
+    pluginConfigDir: context.pluginConfigDir,
     projectRoot: context.projectRoot,
     tsconfig: project.path,
   });
@@ -84,7 +87,10 @@ export function startResidentTransform(
 /**
  * Build the environment for the resident host spawn. Matches the per-call
  * transform spawn: injects the Node, tsgo, and ttsx binaries so the host never
- * searches PATH, and forwards linked transform plugins via
+ * searches PATH, sets `TTSC_PLUGIN_CONFIG_DIR` when the caller declared a
+ * plugin config anchor (an embedder compiling through a generated wrapper
+ * tsconfig) so config-file discovery walks the real project instead of the
+ * wrapper's temp-dir ancestry, and forwards linked transform plugins via
  * `TTSC_LINKED_PLUGINS_JSON`.
  */
 function residentEnv(
@@ -92,15 +98,29 @@ function residentEnv(
   tsgoBinary: string,
   nativePlugins: readonly ITtscLoadedNativePlugin[],
 ): NodeJS.ProcessEnv {
+  const pluginConfigDir = resolvePluginConfigDir(context);
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
+    ...(pluginConfigDir === undefined
+      ? {}
+      : { TTSC_PLUGIN_CONFIG_DIR: pluginConfigDir }),
     TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? tsgoBinary,
     TTSC_TTSX_BINARY:
       process.env.TTSC_TTSX_BINARY ??
       path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
     ...context.env,
   };
+  // The anchor is per-invocation state owned by this host: when this run
+  // declared none (and the caller's env does not name one), drop any value
+  // inherited from an ancestor ttsc process so a nested build never
+  // mis-anchors its plugins at the outer project.
+  if (
+    pluginConfigDir === undefined &&
+    context.env?.TTSC_PLUGIN_CONFIG_DIR === undefined
+  ) {
+    delete env.TTSC_PLUGIN_CONFIG_DIR;
+  }
   const linked = linkedTransformPlugins(nativePlugins);
   if (linked.length !== 0) {
     env.TTSC_LINKED_PLUGINS_JSON = serializeNativePlugins(linked);