ttsc 0.18.3 → 0.19.0

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) {
@@ -160,17 +190,31 @@ function runBuildTimed(
 ): TtscBuildResult {
   const setupStartedAt = process.hrtime.bigint();
   const execution = resolveExecutionContext(options);
-  if (execution.nativePlugins.length > 0) {
+  if (
+    execution.nativePlugins.length > 0 ||
+    execution.pluginSetupFailure !== undefined
+  ) {
     recordTiming(timing, "ttsc plugin setup time", setupStartedAt);
   }
   const buildOptions = applyProjectNoEmit(options, execution);
+  if (execution.pluginSetupFailure !== undefined) {
+    return appendTypeScriptDiagnosticsAfterPluginFailure(
+      execution.pluginSetupFailure,
+      buildOptions,
+      execution,
+    );
+  }
   if (execution.nativePlugins.length > 0) {
     const compilers = execution.nativePlugins.filter(
       (plugin) => plugin.stage === "transform",
     );
     const checked = runNativeCheckPlugins(buildOptions, execution, timing);
     if (checked.status !== 0) {
-      return checked;
+      return appendTypeScriptDiagnosticsAfterPluginFailure(
+        checked,
+        buildOptions,
+        execution,
+      );
     }
 
     if (buildOptions.emit === false) {
@@ -191,15 +235,20 @@ function runBuildTimed(
       }
       if (compilers.length !== 0) {
         assertSharedHostCompatibility(compilers, "emit");
-        return appendBuildOutput(
-          checked,
-          buildWithNativeCompilerPlugins(
-            buildOptions,
-            execution,
-            compilers,
-            timing,
-          ),
+        const compiled = buildWithNativeCompilerPlugins(
+          buildOptions,
+          execution,
+          compilers,
+          timing,
         );
+        const result = appendBuildOutput(checked, compiled);
+        return compiled.status === 0
+          ? result
+          : appendTypeScriptDiagnosticsAfterPluginFailure(
+              result,
+              buildOptions,
+              execution,
+            );
       }
       if (checkPluginsReportTypeScriptDiagnostics(execution.nativePlugins)) {
         return checked;
@@ -213,15 +262,20 @@ function runBuildTimed(
     let result: TtscBuildResult;
     if (compilers.length !== 0) {
       assertSharedHostCompatibility(compilers, "emit");
-      result = appendBuildOutput(
-        checked,
-        buildWithNativeCompilerPlugins(
+      const compiled = buildWithNativeCompilerPlugins(
+        buildOptions,
+        execution,
+        compilers,
+        timing,
+      );
+      result = appendBuildOutput(checked, compiled);
+      if (compiled.status !== 0) {
+        result = appendTypeScriptDiagnosticsAfterPluginFailure(
+          result,
           buildOptions,
           execution,
-          compilers,
-          timing,
-        ),
-      );
+        );
+      }
     } else {
       if (
         buildOptions.skipDiagnosticsCheck !== true &&
@@ -295,6 +349,165 @@ function checkPluginsReportTypeScriptDiagnostics(
   );
 }
 
+/**
+ * Preserve a failed plugin's output and status while collecting TypeScript
+ * diagnostics through an independent no-emit pass.
+ *
+ * A sidecar can fail before it loads the project Program, including when a Go
+ * panic or another runtime error terminates the process. The plugin failure
+ * must still block emit, but it must not hide unrelated errors in the user's
+ * TypeScript source. The fallback runs only after a plugin failure, skips modes
+ * whose contract intentionally omits diagnostics, and avoids appending a batch
+ * the plugin already reported itself.
+ */
+function appendTypeScriptDiagnosticsAfterPluginFailure(
+  failure: TtscBuildResult,
+  options: RunBuildOptions,
+  execution: ReturnType<typeof resolveExecutionContext>,
+): TtscBuildResult {
+  if (
+    options.format === true ||
+    options.skipDiagnosticsCheck === true ||
+    forwardsTerminalTsgoFlag(options)
+  ) {
+    return failure;
+  }
+  const typechecked = runTsgo(
+    execution,
+    ["--noEmit"],
+    createPluginFailureTypecheckOptions(options),
+  );
+  const fallback = filterReportedTypeScriptDiagnostics(
+    failure,
+    typechecked,
+    execution.projectRoot,
+  );
+  if (fallback === null) {
+    return failure;
+  }
+  // Structured consumers (the public API's `IFailure.diagnostics`) never see
+  // stdout/stderr, so a plugin failure that reported no parsable diagnostics
+  // must be seeded as one before recovered TypeScript diagnostics are appended
+  // — otherwise the recovery would replace the plugin error with unrelated
+  // type errors instead of surfacing both.
+  const seeded =
+    failure.diagnostics.length === 0
+      ? { ...failure, diagnostics: [createProcessDiagnostic(failure)] }
+      : failure;
+  const status = failure.status;
+  return {
+    ...appendBuildOutput(seeded, fallback),
+    status,
+  };
+}
+
+/**
+ * Make the recovery pass parseable regardless of the user's display flags. This
+ * is an internal second pass, so plain output is required to remove only
+ * diagnostics that the failed plugin already printed.
+ */
+function createPluginFailureTypecheckOptions(
+  options: RunBuildOptions,
+): RunBuildOptions {
+  const passthrough: string[] = [];
+  for (let i = 0; i < (options.passthrough?.length ?? 0); i++) {
+    const token = options.passthrough![i]!;
+    if (token === "--pretty") {
+      if (isBooleanLiteral(options.passthrough![i + 1] ?? "")) i++;
+      continue;
+    }
+    if (token.startsWith("--pretty=")) continue;
+    passthrough.push(token);
+  }
+  return {
+    ...options,
+    passthrough,
+    structuredDiagnostics: true,
+  };
+}
+
+/** Return only fallback diagnostics the failed plugin did not already report. */
+function filterReportedTypeScriptDiagnostics(
+  failure: TtscBuildResult,
+  typechecked: TtscBuildResult,
+  cwd: string,
+): TtscBuildResult | null {
+  if (typechecked.diagnostics.length === 0) {
+    return typechecked.status === 0 ? null : typechecked;
+  }
+  const diagnostics = typechecked.diagnostics.filter(
+    (diagnostic) =>
+      !failure.diagnostics.some((existing) =>
+        compilerDiagnosticsEqual(existing, diagnostic),
+      ),
+  );
+  if (diagnostics.length === 0) return null;
+  if (diagnostics.length === typechecked.diagnostics.length) return typechecked;
+  return {
+    ...typechecked,
+    diagnostics,
+    stderr: filterCompilerDiagnosticText(typechecked.stderr, diagnostics, cwd),
+    stdout: filterCompilerDiagnosticText(typechecked.stdout, diagnostics, cwd),
+  };
+}
+
+/** Remove diagnostic lines absent from the selected structured result. */
+function filterCompilerDiagnosticText(
+  text: string,
+  diagnostics: readonly ITtscCompilerDiagnostic[],
+  cwd: string,
+): string {
+  const out: string[] = [];
+  let keepContinuation = true;
+  for (const line of text.split(/\r?\n/)) {
+    const plain = stripAnsi(line);
+    const diagnostic = parseDiagnosticLine(plain, cwd);
+    if (diagnostic !== null) {
+      keepContinuation = diagnostics.some((selected) =>
+        compilerDiagnosticsEqual(selected, diagnostic),
+      );
+      if (keepContinuation) out.push(line);
+      continue;
+    }
+    if (/^Found\s+\d+\s+errors?/i.test(plain)) continue;
+    if (!keepContinuation && /^\s+/.test(line)) continue;
+    keepContinuation = true;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+/** Compare normalized compiler diagnostics before appending fallback output. */
+function compilerDiagnosticsEqual(
+  left: ITtscCompilerDiagnostic,
+  right: ITtscCompilerDiagnostic,
+): boolean {
+  return (
+    left.category === right.category &&
+    left.code === right.code &&
+    left.file === right.file &&
+    diagnosticPositionsEqual(left, right) &&
+    diagnosticHeadline(left.messageText) ===
+      diagnosticHeadline(right.messageText)
+  );
+}
+
+/** Compare offsets when available, otherwise compare rendered line/column. */
+function diagnosticPositionsEqual(
+  left: ITtscCompilerDiagnostic,
+  right: ITtscCompilerDiagnostic,
+): boolean {
+  if (left.start !== undefined && right.start !== undefined) {
+    return left.start === right.start;
+  }
+  return left.line === right.line && left.character === right.character;
+}
+
+/** Remove pretty-rendered source context from a diagnostic message. */
+function diagnosticHeadline(message: string): string {
+  return message.split(/\r?\n/, 1)[0]!.trim();
+}
+
 /**
  * Tsgo CLI flags that make `tsgo` print something and exit instead of building
  * (`--showConfig`, `--listFilesOnly`, `--help`, …). ttsc must not add
@@ -481,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");
   }
@@ -548,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");
   }
@@ -580,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));
   }
@@ -850,37 +1087,81 @@ export function appendBuildOutput(
   });
 }
 
+/**
+ * Synthesize one structured diagnostic from a non-zero process result that
+ * produced no parsable diagnostics, carrying the captured stderr/stdout as the
+ * message. Shared by the public API result mapping and the plugin-failure
+ * recovery pass so the failure text is never dropped from structured output.
+ */
+export 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,
+  };
+}
+
 /**
  * Resolve all runtime context needed for a build: cwd, tsconfig path, project
  * root, tsgo binary location, and the loaded native plugin list. Centralised
  * 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 });
-  const hasPlugins = hasProjectPluginEntries(project, options.plugins);
-  const loaded = hasPlugins
-    ? loadProjectPlugins({
+  let pluginSetupFailure: TtscBuildResult | undefined;
+  let nativePlugins: ITtscLoadedNativePlugin[] = [];
+  try {
+    if (hasProjectPluginEntries(project, options.plugins)) {
+      nativePlugins = loadProjectPlugins({
         binary: resolveBinary(options) ?? "",
         cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
         cwd,
         entries: options.plugins,
+        env: { ...process.env, ...options.env },
+        pluginConfigDir: options.pluginConfigDir,
         projectRoot,
         tsconfig,
-      })
-    : { nativePlugins: [] };
+      }).nativePlugins;
+    }
+  } catch (error) {
+    pluginSetupFailure = {
+      diagnostics: [],
+      status: 2,
+      stdout: "",
+      stderr: `${error instanceof Error ? error.message : String(error)}\n`,
+    };
+  }
   return {
     cwd,
-    nativePlugins: loaded.nativePlugins,
+    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);