ttsc 0.18.4 → 0.19.0

package/src/compiler/internal/transformProjectInMemory.ts

@@ -11,6 +11,7 @@ import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscPa
 import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
 import { buildNativeCompiler } from "./buildNativeCompiler";
 import { packageRootDir } from "./paths";
+import { createNativeProjectContextArgs } from "./project/createNativeProjectContextArgs";
 import { readProjectConfig } from "./project/readProjectConfig";
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
@@ -18,6 +19,7 @@ import { appendBuildOutput, normalizeBuildOutput } from "./runBuild";
 import {
   assertSharedHostCompatibility,
   linkedTransformPlugins,
+  resolvePluginConfigDir,
   selectSharedHostPlugin,
 } from "./sharedHostHelpers";
 import { outputText, spawnNative } from "./spawnNative";
@@ -126,6 +128,8 @@ function transformProjectWithPlugins(
     cacheDir: options.cacheDir ?? options.env?.TTSC_CACHE_DIR,
     cwd,
     entries: options.plugins,
+    env: { ...process.env, ...options.env },
+    pluginConfigDir: options.pluginConfigDir,
     projectRoot: options.projectRoot,
     tsconfig: project.path,
   });
@@ -167,7 +171,11 @@ function transformProjectWithPlugins(
   const plugin = selectSharedHostPlugin(transformers);
   const res = spawnNative(
     plugin.binary,
-    createNativeTransformArgs(project, transformers),
+    createNativeTransformArgs(
+      project,
+      transformers,
+      resolvePluginConfigDir(options),
+    ),
     {
       cwd: project.root,
       env: nativePluginEnv(options, tsgoBinary, loaded.nativePlugins, plugin),
@@ -217,7 +225,12 @@ function runNativeChecks(
   for (const plugin of checks) {
     const res = spawnNative(
       plugin.binary,
-      createNativeCheckArgs(project, nativePlugins),
+      createNativeCheckArgs(
+        project,
+        nativePlugins,
+        plugin,
+        resolvePluginConfigDir(options),
+      ),
       {
         cwd: project.root,
         env: nativePluginEnv(options, tsgoBinary, nativePlugins, plugin),
@@ -250,26 +263,39 @@ function runNativeChecks(
 function createNativeTransformArgs(
   project: ITtscParsedProjectConfig,
   plugins: readonly ITtscLoadedNativePlugin[],
+  pluginConfigOrigin?: string,
 ): string[] {
-  return [
+  const args = [
     "transform",
     "--tsconfig=" + project.path,
     "--plugins-json=" + serializeNativePlugins(plugins),
     "--cwd=" + project.root,
   ];
+  if (
+    selectSharedHostPlugin(plugins).capabilities?.projectContextArgs === true
+  ) {
+    args.push(...createNativeProjectContextArgs(project, pluginConfigOrigin));
+  }
+  return args;
 }
 
 /** Build the CLI argument list for the `check` subcommand. */
 function createNativeCheckArgs(
   project: ITtscParsedProjectConfig,
   plugins: readonly ITtscLoadedNativePlugin[],
+  plugin: ITtscLoadedNativePlugin,
+  pluginConfigOrigin?: string,
 ): string[] {
-  return [
+  const args = [
     "check",
     "--tsconfig=" + project.path,
     "--plugins-json=" + serializeNativePlugins(plugins),
     "--cwd=" + project.root,
   ];
+  if (plugin.capabilities?.projectContextArgs === true) {
+    args.push(...createNativeProjectContextArgs(project, pluginConfigOrigin));
+  }
+  return args;
 }
 
 /**
@@ -291,8 +317,11 @@ function serializeNativePlugins(
 /**
  * Build the environment for a native plugin spawn. Injects `TTSC_NODE_BINARY`,
  * `TTSC_TSGO_BINARY`, and `TTSC_TTSX_BINARY` so the sidecar can re-invoke
- * Node.js or tsgo without searching PATH. For transform plugins, also passes
- * `TTSC_LINKED_PLUGINS_JSON` when linked sources are present.
+ * Node.js or tsgo without searching PATH, 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 plugins, also
+ * passes `TTSC_LINKED_PLUGINS_JSON` when linked sources are present.
  */
 function nativePluginEnv(
   options: ITtscCompilerContext,
@@ -300,15 +329,29 @@ function nativePluginEnv(
   nativePlugins?: readonly ITtscLoadedNativePlugin[],
   plugin?: ITtscLoadedNativePlugin,
 ): NodeJS.ProcessEnv {
+  const pluginConfigDir = resolvePluginConfigDir(options);
   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"),
     ...options.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 &&
+    options.env?.TTSC_PLUGIN_CONFIG_DIR === undefined
+  ) {
+    delete env.TTSC_PLUGIN_CONFIG_DIR;
+  }
   if (plugin?.stage === "transform") {
     const linked = linkedTransformPlugins(nativePlugins ?? []);
     if (linked.length !== 0) {

package/src/flags/parser.ts

@@ -58,6 +58,23 @@ export interface ParseOptions {
    * `--` is appended to `passthrough` as-is (ttsx already does this).
    */
   readonly honorDoubleDashSeparator?: boolean;
+  /**
+   * Classifies a bare (non-dash) token as a genuine positional argument (a
+   * source file, the ttsx entry, a project path) rather than the
+   * space-separated value of a preceding forwarded flag.
+   *
+   * When omitted, every bare token is a positional — the historical behaviour
+   * for project-shaped subcommands that never forward `--flag value` pairs.
+   *
+   * When provided, a bare token that fails the predicate is appended to
+   * `passthrough` in its original position instead of `positional`, so an
+   * unknown `--flag value` pair reaches tsgo with its adjacency and relative
+   * order intact. The parser deliberately does not guess a forwarded flag's
+   * arity from the flag itself (it has no schema for a truly unknown flag); the
+   * predicate is the only signal that separates a forwarded value from a real
+   * input file, and both callers key it on the TypeScript source extension.
+   */
+  readonly isPositional?: (token: string) => boolean;
 }
 
 /**
@@ -153,7 +170,17 @@ export function parseFlags(opts: ParseOptions): ParseResult {
       continue;
     }
 
-    // Bare token: positional argument (file / entry / project path).
+    // Bare token: either a genuine positional argument (file / entry / project
+    // path) or the space-separated value of a preceding forwarded flag. When a
+    // caller forwards unknown flags it supplies `isPositional` to tell the two
+    // apart; a forwarded value is appended to `passthrough` in place so the
+    // `--flag value` pair reaches tsgo in its original order and adjacency,
+    // instead of being split into a separate bucket the caller later
+    // concatenates out of order.
+    if (opts.isPositional !== undefined && !opts.isPositional(current)) {
+      passthrough.push(current);
+      continue;
+    }
     positional.push(current);
     if (opts.forwardAfterFirstPositional === true && positional.length === 1) {
       forwardingTail = true;

package/src/flags/schema.ts

@@ -477,6 +477,14 @@ export const FLAG_SCHEMA: readonly FlagSpec[] = [
     description:
       "JSON-encoded ttsc plugin manifest (internal: emitted by runBuild).",
   },
+  {
+    name: "--project-context-json",
+    kind: "value",
+    subcommands: ["build", "check", "fix", "format"],
+    consumedBy: ["lint"],
+    description:
+      "JSON-encoded lexical and physical project identity (internal: emitted by runBuild).",
+  },
   {
     name: "--manifest",
     kind: "value",

package/src/launcher/internal/prepareExecution.ts

@@ -71,8 +71,12 @@ function createProjectContext(
 ) {
   const project = readProjectConfig(
     options.project
-      ? { cwd, tsconfig: path.resolve(cwd, options.project) }
-      : { cwd, file: filename },
+      ? {
+          cwd,
+          projectRoot: options.projectRoot,
+          tsconfig: path.resolve(cwd, options.project),
+        }
+      : { cwd, file: filename, projectRoot: options.projectRoot },
   );
   const tsconfig = project.path;
   const root = project.root;
@@ -83,6 +87,7 @@ function createProjectContext(
   const processDir = path.join(cacheDir, "project", PROCESS_CACHE_KEY);
   const virtualRoot = path.join(processDir, "fs");
   return {
+    project,
     tsconfig,
     root,
     cacheDir,
@@ -102,6 +107,13 @@ function createProjectContext(
       typeof project.compilerOptions.module === "string"
         ? project.compilerOptions.module
         : undefined,
+    // Force a source map on the transient runtime emit only when the project
+    // configures none — when it already emits `sourceMap` or `inlineSourceMap`,
+    // the serve path inlines/absolutizes that map, so no override is needed
+    // (issue #353).
+    forceRuntimeSourceMap:
+      project.compilerOptions.sourceMap !== true &&
+      project.compilerOptions.inlineSourceMap !== true,
     built: false,
     emittedFiles: undefined as string[] | undefined,
   };
@@ -139,8 +151,16 @@ function buildProject(
     cacheDir: context.pluginCacheDir,
     outDir: context.emitDir,
     passthrough: options.passthrough,
+    // Emit a source map on the transient entry emit (a PID-isolated temp dir,
+    // never the consumer's `outDir`) so the serve path can inline it under the
+    // source URL. Routed as a dedicated build option, not a forwarded tsgo
+    // flag, so it never reaches a native plugin host's argument parser (issue
+    // #353).
+    forceRuntimeSourceMap: context.forceRuntimeSourceMap,
+    pluginConfigDir: options.pluginConfigDir,
     plugins: options.plugins,
     quiet: true,
+    resolvedProject: context.project,
     singleThreaded: options.singleThreaded,
     tsconfig: context.tsconfig,
   });

package/src/launcher/internal/runTtsc.ts

@@ -1,11 +1,9 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
 import { TtscCompiler } from "../../TtscCompiler";
 import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
 import { resolveProjectConfig } from "../../compiler/internal/project/resolveProjectConfig";
-import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { runBuild } from "../../compiler/internal/runBuild";
 import { runSingleFileEmit } from "../../compiler/internal/runSingleFileEmit";
 import {
@@ -68,8 +66,6 @@ export function runTtsc(
         return runClean(rest);
       case "prepare":
         return runPrepare(rest);
-      case "demo":
-        return delegateToNative(argv);
       case "-p":
       case "--project":
         return runCompatibleBuild(argv, "build");
@@ -391,54 +387,6 @@ function isOutsideRelativePath(relative: string): boolean {
   );
 }
 
-function delegateToNative(argv: readonly string[]): number {
-  const bin = resolveBinary();
-  if (!bin) {
-    process.stderr.write(
-      [
-        `ttsc: platform-specific helper binary not found (@ttsc/${process.platform}-${process.arch}).`,
-        `Set TTSC_BINARY to an absolute helper path or reinstall with optional dependencies enabled.`,
-      ].join("\n") + "\n",
-    );
-    return 1;
-  }
-  const viaNode = /\.(?:[cm]?js|ts)$/i.test(bin);
-  if (!viaNode) {
-    ensureExecutable(bin);
-  }
-  const result = spawnSync(
-    viaNode ? process.execPath : bin,
-    viaNode ? [bin, ...argv] : [...argv],
-    {
-      stdio: "inherit",
-      env: process.env,
-      windowsHide: true,
-    },
-  );
-  if (result.error) {
-    process.stderr.write(`${result.error.message}\n`);
-    return 1;
-  }
-  return result.status ?? 1;
-}
-
-function ensureExecutable(binary: string): void {
-  if (process.platform === "win32") {
-    return;
-  }
-  try {
-    fs.accessSync(binary, fs.constants.X_OK);
-    return;
-  } catch {
-    try {
-      const mode = fs.statSync(binary).mode & 0o777;
-      fs.chmodSync(binary, mode | 0o755);
-    } catch {
-      /* keep the original spawn error path */
-    }
-  }
-}
-
 function parseProjectArgs(argv: readonly string[]) {
   // `prepare` and `clean` are project-shaped commands. They share the same
   // schema as the build lane; the engine forwards unknown flags as well as
@@ -461,6 +409,12 @@ function parseBuildArgs(argv: readonly string[], checkOnly: boolean) {
   const result = parseFlags({
     argv,
     errorPrefix: "ttsc:",
+    // A bare token is a single-file input only when it carries a TypeScript
+    // source extension; any other bare token is the space-separated value of a
+    // preceding forwarded flag (e.g. the `es2020` in `--target es2020`). The
+    // parser routes those values into `passthrough` in place, so the forwarded
+    // flag/value pairs reach tsgo in their original order.
+    isPositional: looksLikeInputFile,
     subcommand: "build",
   });
   // Defaults: pinned by the previous hand-parser. `quiet` defaults true,
@@ -476,15 +430,13 @@ function parseBuildArgs(argv: readonly string[], checkOnly: boolean) {
   else if (explicitNoEmit === true) emit = false;
   if (emit === undefined && checkOnly) emit = false;
 
-  const files = result.positional.filter(looksLikeInputFile);
-  // Bare non-file positionals are flag values (e.g. the `es2020` in
-  // `--target es2020`). The engine left them in `positional` because the
-  // forwarded flag is unknown to the schema; route them back into
-  // passthrough so the user's pair reaches tsgo intact.
-  const trailingValues = result.positional.filter(
-    (token) => !looksLikeInputFile(token),
-  );
-  const passthrough = [...result.passthrough, ...trailingValues];
+  // `isPositional: looksLikeInputFile` guarantees every `result.positional`
+  // token is a TypeScript input file; forwarded flag values already live in
+  // `result.passthrough` in their original order, so no reconstruction is
+  // needed here (the previous `[...passthrough, ...trailingValues]` concat
+  // reordered every flag ahead of every value).
+  const files = [...result.positional];
+  const passthrough = [...result.passthrough];
 
   return {
     binary: getString(result, "--binary"),

package/src/launcher/internal/runTtscserver.ts

@@ -11,6 +11,7 @@ import {
   loadProjectPlugins,
 } from "../../plugin/internal/loadProjectPlugins";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
+import type { ITtscProjectIdentity } from "../../structures/internal/ITtscProjectIdentity";
 import { resolveTtscserverBinary } from "./resolveTtscserverBinary";
 
 /**
@@ -107,9 +108,11 @@ function resolveTtscserverEnv(argv: readonly string[]): NodeJS.ProcessEnv {
   if (lspPlugins.length > 0) {
     env.TTSC_LSP_PLUGINS_JSON = JSON.stringify({
       plugins: serializeNativePlugins(context.nativePlugins),
+      projectContext: context.projectContext,
       lspPlugins: lspPlugins.map((plugin) => ({
         binary: plugin.binary,
         name: plugin.name,
+        projectContextArgs: plugin.capabilities?.projectContextArgs === true,
         stage: plugin.stage,
       })),
     });
@@ -119,10 +122,16 @@ function resolveTtscserverEnv(argv: readonly string[]): NodeJS.ProcessEnv {
 
 function resolveLspExecutionContext(argv: readonly string[]): {
   nativePlugins: readonly ITtscLoadedNativePlugin[];
+  projectContext?: ITtscProjectIdentity;
   tsgoBinary: string;
 } {
   const cwd = path.resolve(optionValue(argv, "--cwd") ?? process.cwd());
   const tsconfig = optionValue(argv, "--tsconfig");
+  const pluginConfigOrigin =
+    process.env.TTSC_PLUGIN_CONFIG_DIR === undefined ||
+    process.env.TTSC_PLUGIN_CONFIG_DIR === ""
+      ? undefined
+      : path.resolve(cwd, process.env.TTSC_PLUGIN_CONFIG_DIR);
   let project: ReturnType<typeof readProjectConfig>;
   try {
     project = readProjectConfig({ cwd, tsconfig });
@@ -149,12 +158,17 @@ function resolveLspExecutionContext(argv: readonly string[]): {
     ? loadProjectPlugins({
         binary: resolveBinary() ?? "",
         cwd,
+        pluginConfigDir: pluginConfigOrigin,
         projectRoot: project.root,
         tsconfig: project.path,
       })
     : { nativePlugins: [] };
   return {
     nativePlugins: loaded.nativePlugins,
+    projectContext: {
+      ...project.identity,
+      ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
+    },
     tsgoBinary: tsgo.binary,
   };
 }

package/src/launcher/internal/runTtsx.ts

@@ -12,6 +12,7 @@ import {
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
 import { resolveCacheDir } from "./resolveCacheDir";
+import { checkNodeRuntimeSupport } from "./runtimeHooks";
 
 /**
  * CLI entry point for `ttsx`. Type-checks the owning project via tsgo, emits
@@ -45,6 +46,17 @@ function run(argv: readonly string[]): number {
     return 0;
   }
 
+  // Refuse an unsupported Node.js before type-checking and spawning the child:
+  // the child inherits this process's Node version, so an early diagnostic here
+  // pre-empts both the Node 18 `--disable-warning` rejection and the Node 20
+  // missing-`registerHooks` TypeError with one actionable message. `--help` and
+  // `--version` are handled above so they still print on any Node.
+  const nodeSupport = checkNodeRuntimeSupport(process.versions.node);
+  if (nodeSupport !== null) {
+    process.stderr.write(`ttsx: ${nodeSupport}\n`);
+    return 2;
+  }
+
   const cwd = path.resolve(parsed.cwd ?? process.cwd());
   const entry = path.resolve(cwd, parsed.entry);
   if (!fs.existsSync(entry)) {
@@ -109,6 +121,14 @@ function parseCLI(argv: readonly string[]) {
     errorPrefix: "ttsx:",
     forwardAfterFirstPositional: true,
     honorDoubleDashSeparator: true,
+    // Only a TypeScript-extensioned bare token is the entry; every other bare
+    // token before it (e.g. the `es2020` in `--target es2020 entry.ts`) is a
+    // forwarded flag value. Classifying values via the predicate keeps them in
+    // `passthrough` in order AND stops a pre-entry value from being mistaken for
+    // the first positional sentinel — which previously flipped the parser into
+    // tail mode and pushed the real entry into `tail`, failing with
+    // "entry file is required".
+    isPositional: looksLikeEntryFile,
     subcommand: "ttsx",
   });
 
@@ -116,18 +136,13 @@ function parseCLI(argv: readonly string[]) {
   if (entry === undefined) {
     throw new Error("ttsx: entry file is required");
   }
-  // With `forwardAfterFirstPositional: true` the parser reports
-  // `result.positional` as just the entry, `result.passthrough` as flags
-  // arriving BEFORE the entry (tsgo-forwarded), and `result.tail` as every
-  // token AFTER the entry — those are the user program's argv (e.g. the
-  // `generate --input src/input` tail of `ttsx typia.ts generate
-  // --input src/input`) and MUST NOT reach tsgo. Anything in positional
-  // that is not the entry is a pre-entry flag value (e.g. `--target es2020`)
-  // that the parser stored positionally; forward those to tsgo with the
-  // rest of `passthrough`.
-  const preEntryValues: string[] = result.positional.filter(
-    (token) => token !== entry && !looksLikeEntryFile(token),
-  );
+  // With `forwardAfterFirstPositional: true` and `isPositional:
+  // looksLikeEntryFile`, the parser reports `result.positional` as just the
+  // entry, `result.passthrough` as the tsgo-forwarded flags (and their
+  // in-order space values) arriving BEFORE the entry, and `result.tail` as
+  // every token AFTER the entry — the user program's argv (e.g. the `generate
+  // --input src/input` tail of `ttsx typia.ts generate --input src/input`),
+  // which MUST NOT reach tsgo.
   const postEntryArgs: string[] = [...result.tail];
 
   const preload: string[] = [];
@@ -170,7 +185,7 @@ function parseCLI(argv: readonly string[]) {
     preload,
     project: getString(result, "--tsconfig"),
     singleThreaded: getBoolean(result, "--singleThreaded") === true,
-    tsgoFlags: [...result.passthrough, ...preEntryValues],
+    tsgoFlags: [...result.passthrough],
   };
 }