ttsc 0.11.0 → 0.12.0

package/shim/lsp/shim.go

@@ -1,34 +1,28 @@
 // gen_shims:hand-maintained
 //
 // Minimal shim of tsgo's internal/lsp package. Hand-written instead of
-// generated so the surface stays narrow: ttscserver embeds the tsgo LSP
-// server unmodified and intercepts traffic at the byte level, so the only
-// types it touches are the opaque Server, its options struct, and the
-// Reader/Writer interfaces that ToReader/ToWriter return. The marker on
-// the first line tells gen_shims to skip this file.
+// generated so the surface stays narrow for custom in-process host
+// experiments. The shipped ttscserver wraps `tsgo --lsp --stdio` as an
+// external process and does not import this package. The marker on the
+// first line tells gen_shims to skip this file.
 package lsp
 
 import (
-  "io"
-  _ "unsafe"
+	"io"
+	_ "unsafe"
 
-  innerlsp "github.com/microsoft/typescript-go/internal/lsp"
+	innerlsp "github.com/microsoft/typescript-go/internal/lsp"
 )
 
-// Server is the opaque LSP server type from tsgo. ttscserver does not poke
-// its internals; it only calls Run and (via wrapped Writer) observes the
-// traffic the server emits.
+// Server is the opaque LSP server type from tsgo.
 type Server = innerlsp.Server
 
 // ServerOptions mirrors the upstream construction parameters. Fields with
-// internal-package types (e.g. ParseCache *project.ParseCache) are left
-// unset by ttscserver, which is safe because every such field is an
-// optional pointer the upstream constructor accepts as nil.
+// internal-package types (e.g. ParseCache *project.ParseCache) can be left
+// unset by callers when upstream accepts nil.
 type ServerOptions = innerlsp.ServerOptions
 
-// Reader / Writer carry framed lsproto.Message values. ttscserver feeds
-// the server through io.Pipe shims of these so it can splice its own
-// JSON-RPC traffic into the same stream the editor speaks.
+// Reader / Writer carry framed lsproto.Message values.
 type Reader = innerlsp.Reader
 type Writer = innerlsp.Writer
 

package/src/TtscCompiler.ts

@@ -5,6 +5,7 @@ import { compileProjectInMemory } from "./compiler/internal/compileProjectInMemo
 import { resolveProjectConfig } from "./compiler/internal/project/resolveProjectConfig";
 import { resolveBinary } from "./compiler/internal/resolveBinary";
 import { transformProjectInMemory } from "./compiler/internal/transformProjectInMemory";
+import { defaultPluginCacheCleanTargets } from "./plugin/internal/buildSourcePlugin";
 import { loadProjectPlugins } from "./plugin/internal/loadProjectPlugins";
 import type { ITtscCompilerContext } from "./structures/ITtscCompilerContext";
 import type { ITtscCompilerDiagnostic } from "./structures/ITtscCompilerDiagnostic";
@@ -75,9 +76,9 @@ export class TtscCompiler {
    * Remove compiled cache artifacts for this compiler instance.
    *
    * When the constructor received `cacheDir`, this method removes exactly that
-   * directory. Otherwise it removes the default ttsc cache locations for the
-   * resolved project root, plus the `TTSC_CACHE_DIR/plugins` cache when that
-   * environment variable is active.
+   * directory. When `TTSC_CACHE_DIR` is active, it removes that override's
+   * plugin cache plus legacy project-local caches. Otherwise it removes the
+   * default global plugin cache plus legacy project-local caches.
    *
    * The cache target comes from the constructor context. Create another
    * `TtscCompiler` instance to clean another project or another cache root.
@@ -90,13 +91,25 @@ export class TtscCompiler {
       return removeExistingDirectories([cacheDir]);
     }
 
-    const envCacheDir =
-      this.context.env?.TTSC_CACHE_DIR ?? process.env.TTSC_CACHE_DIR;
     const projectRoot = this.resolveCleanProjectRoot();
-    return removeExistingDirectories([
-      ...(envCacheDir ? [path.resolve(envCacheDir, "plugins")] : []),
+    const legacyTargets = [
       path.join(projectRoot, "node_modules", ".ttsc"),
       path.join(projectRoot, ".ttsc"),
+    ];
+    if (this.context.env?.TTSC_CACHE_DIR) {
+      return removeExistingDirectories([
+        path.resolve(projectRoot, this.context.env.TTSC_CACHE_DIR, "plugins"),
+        ...legacyTargets,
+      ]);
+    }
+    if (process.env.TTSC_CACHE_DIR) {
+      return removeExistingDirectories([
+        path.resolve(process.env.TTSC_CACHE_DIR, "plugins"),
+        ...legacyTargets,
+      ]);
+    }
+    return removeExistingDirectories([
+      ...defaultPluginCacheCleanTargets(projectRoot),
     ]);
   }
 

package/src/compiler/internal/resolveTsgo.ts

@@ -8,6 +8,7 @@ export function resolveTsgo(
     binary?: string;
     cwd?: string;
     env?: NodeJS.ProcessEnv;
+    resolveFrom?: string;
   } = {},
 ) {
   const env = opts.env ?? process.env;
@@ -28,11 +29,13 @@ export function resolveTsgo(
 
   const cwd = path.resolve(opts.cwd ?? process.cwd());
   let packageJson: string;
-  try {
-    packageJson = createRequire(path.join(cwd, "package.json")).resolve(
-      "@typescript/native-preview/package.json",
-    );
-  } catch {
+  packageJson =
+    resolveNativePreviewPackageJson(path.join(cwd, "package.json")) ??
+    (opts.resolveFrom
+      ? resolveNativePreviewPackageJson(opts.resolveFrom)
+      : undefined) ??
+    "";
+  if (!packageJson) {
     throw new Error(
       [
         "ttsc: @typescript/native-preview is required.",
@@ -81,6 +84,16 @@ export function resolveTsgo(
   };
 }
 
+function resolveNativePreviewPackageJson(from: string): string | undefined {
+  try {
+    return createRequire(from).resolve(
+      "@typescript/native-preview/package.json",
+    );
+  } catch {
+    return undefined;
+  }
+}
+
 function readPackageJson(file: string): Record<string, unknown> {
   return JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
 }

package/src/compiler/internal/runBuild.ts

@@ -12,7 +12,11 @@ import type { TtscCommonOptions } from "../../structures/internal/TtscCommonOpti
 import { resolveProjectConfig } from "./project/resolveProjectConfig";
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
-import { assertSharedHostCompatibility } from "./sharedHostHelpers";
+import {
+  assertSharedHostCompatibility,
+  linkedTransformPlugins,
+  selectSharedHostPlugin,
+} from "./sharedHostHelpers";
 
 /** Merge spawn env without clobbering unrelated vars. */
 function mergeEnv(extra?: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
@@ -27,14 +31,22 @@ function mergeEnv(extra?: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
 function nativePluginEnv(
   extra: NodeJS.ProcessEnv | undefined,
   execution: ReturnType<typeof resolveExecutionContext>,
+  plugin?: ITtscLoadedNativePlugin,
 ): NodeJS.ProcessEnv {
-  return mergeEnv({
+  const env = mergeEnv({
     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,
   });
+  if (plugin?.stage === "transform") {
+    const linked = linkedTransformPlugins(execution.nativePlugins);
+    if (linked.length !== 0) {
+      env.TTSC_LINKED_PLUGINS_JSON = serializeNativePlugins(linked);
+    }
+  }
+  return env;
 }
 
 function spawnBinary(
@@ -192,8 +204,9 @@ function buildWithNativeCompilerPlugins(
   execution: ReturnType<typeof resolveExecutionContext>,
   plugins: readonly ITtscLoadedNativePlugin[],
 ): TtscBuildResult {
+  const host = selectSharedHostPlugin(plugins);
   return runNativePluginCommand(
-    plugins[0]!,
+    host,
     createNativeBuildArgs(execution, options, plugins),
     options,
     execution,
@@ -405,7 +418,7 @@ function runNativePluginCommand(
 ): TtscBuildResult {
   const res = spawnBinary(plugin.binary, args, {
     cwd: execution.projectRoot,
-    env: nativePluginEnv(options.env, execution),
+    env: nativePluginEnv(options.env, execution, plugin),
     encoding: "utf8",
   });
   if (res.error) {

package/src/compiler/internal/sharedHostHelpers.ts

@@ -1,79 +1,19 @@
-import fs from "node:fs";
-import path from "node:path";
-
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 
 /**
- * Names of the first-party utility transform plugins that are allowed to share
- * one compiler emit / one source-to-source pass even when their resolved
- * binaries differ. Each entry must be both name-pinned and manifest-pinned: the
- * plugin must declare itself with one of these names AND its source path must
- * resolve to a `package.json` whose `name` field matches.
- *
- * This whitelist exists because `@ttsc/banner`, `@ttsc/paths`, and
- * `@ttsc/strip` are AST-only mutators that operate on the same
- * `*shimast.SourceFile` graph and do not own emit. They are composed through
- * `packages/ttsc/utility/host.go`, so any one of their binaries can host the
- * shared run. Third-party plugins cannot participate in this fast path; they
- * must opt into composition through the explicit `ITtscPlugin.composes` field.
- */
-export const FIRST_PARTY_UTILITY_PLUGIN_NAMES: ReadonlySet<string> = new Set([
-  "@ttsc/banner",
-  "@ttsc/paths",
-  "@ttsc/strip",
-]);
-
-/**
- * Reports whether the given plugin is a first-party utility transform plugin
- * that may participate in the shared compiler host alongside other first-party
- * utility transforms. Returns `false` for `check`-stage plugins, for unknown
- * names, and for plugins whose `source` does not resolve to a matching
- * `package.json`.
+ * Reports whether the given transform source is linked into another compiler
+ * host instead of owning the process itself.
  */
-export function isFirstPartyUtilityTransformPlugin(
+export function isLinkedTransform(
   plugin: ITtscLoadedNativePlugin,
 ): boolean {
-  if (plugin.stage !== "transform") return false;
-  if (!FIRST_PARTY_UTILITY_PLUGIN_NAMES.has(plugin.name)) return false;
-  const manifest = readNearestPackageManifest(plugin.source);
-  return manifest?.name === plugin.name;
-}
-
-/**
- * Walks upward from `source` (a directory or file path) up to four parent
- * levels searching for the nearest `package.json`. Returns the parsed manifest
- * object on success, or `undefined` when no manifest is found or parsing fails.
- * The depth bound mirrors the pre-existing inline implementations in
- * `runBuild.ts` and `transformProjectInMemory.ts`.
- */
-export function readNearestPackageManifest(
-  source: string,
-): { name?: unknown } | undefined {
-  try {
-    let current = fs.statSync(source).isDirectory()
-      ? source
-      : path.dirname(source);
-    for (let i = 0; i < 4; i += 1) {
-      const manifest = path.join(current, "package.json");
-      if (fs.existsSync(manifest)) {
-        return JSON.parse(fs.readFileSync(manifest, "utf8")) as {
-          name?: unknown;
-        };
-      }
-      const parent = path.dirname(current);
-      if (parent === current) break;
-      current = parent;
-    }
-  } catch {
-    return undefined;
-  }
-  return undefined;
+  return plugin.stage === "transform" && plugin.kind === "linked";
 }
 
 /**
  * Verifies that all transform plugins in `plugins` either resolve to the same
- * native binary (the common case) or are all first-party utility plugins (the
- * shared compiler-host fast path).
+ * native binary (the common case) after linked sources are removed from the
+ * compiler-owner set.
  *
  * Two callers exist with subtly different error wording: the build path
  * (`runBuild.ts`) reports "multiple compiler native backends cannot share one
@@ -90,7 +30,14 @@ export function assertSharedHostCompatibility(
   if (binaries.length <= 1) {
     return;
   }
-  if (plugins.every(isFirstPartyUtilityTransformPlugin)) {
+  const ownerBinaries = [
+    ...new Set(
+      plugins
+        .filter((plugin) => !isLinkedTransform(plugin))
+        .map((plugin) => plugin.binary),
+    ),
+  ];
+  if (ownerBinaries.length <= 1) {
     return;
   }
   const phrase =
@@ -103,3 +50,23 @@ export function assertSharedHostCompatibility(
       "; compose transform libraries through one aggregate native host",
   );
 }
+
+/**
+ * Picks the native binary that must own the compiler pass. Linked transform
+ * sources ride inside a host that uses driver.LoadProgram, so an executable
+ * transform wins when one is present.
+ */
+export function selectSharedHostPlugin(
+  plugins: readonly ITtscLoadedNativePlugin[],
+): ITtscLoadedNativePlugin {
+  return (
+    plugins.find((plugin) => !isLinkedTransform(plugin)) ??
+    plugins[0]!
+  );
+}
+
+export function linkedTransformPlugins(
+  plugins: readonly ITtscLoadedNativePlugin[],
+): ITtscLoadedNativePlugin[] {
+  return plugins.filter(isLinkedTransform);
+}

package/src/compiler/internal/transformProjectInMemory.ts

@@ -16,7 +16,11 @@ import { readProjectConfig } from "./project/readProjectConfig";
 import { resolveBinary } from "./resolveBinary";
 import { resolveTsgo } from "./resolveTsgo";
 import { appendBuildOutput, normalizeBuildOutput } from "./runBuild";
-import { assertSharedHostCompatibility } from "./sharedHostHelpers";
+import {
+  assertSharedHostCompatibility,
+  linkedTransformPlugins,
+  selectSharedHostPlugin,
+} from "./sharedHostHelpers";
 
 /** Transform a project and capture TypeScript source output in memory. */
 export function transformProjectInMemory(options: ITtscCompilerContext): {
@@ -126,13 +130,13 @@ function transformProjectWithPlugins(
   }
   assertSharedHostCompatibility(transformers, "source-to-source");
 
-  const plugin = transformers[0]!;
+  const plugin = selectSharedHostPlugin(transformers);
   const res = spawnNative(
     plugin.binary,
     createNativeTransformArgs(project, transformers),
     {
       cwd: project.root,
-      env: nativePluginEnv(options, project.root),
+      env: nativePluginEnv(options, project.root, loaded.nativePlugins, plugin),
     },
   );
   if (res.error) {
@@ -174,7 +178,7 @@ function runNativeChecks(
       createNativeCheckArgs(project, nativePlugins),
       {
         cwd: project.root,
-        env: nativePluginEnv(options, project.root),
+        env: nativePluginEnv(options, project.root, nativePlugins, plugin),
       },
     );
     if (res.error) {
@@ -239,9 +243,11 @@ function serializeNativePlugins(
 function nativePluginEnv(
   options: ITtscCompilerContext,
   projectRoot: string,
+  nativePlugins?: readonly ITtscLoadedNativePlugin[],
+  plugin?: ITtscLoadedNativePlugin,
 ): NodeJS.ProcessEnv {
   const tsgo = resolveTsgo({ ...options, cwd: projectRoot });
-  return {
+  const env: NodeJS.ProcessEnv = {
     ...process.env,
     TTSC_NODE_BINARY: process.env.TTSC_NODE_BINARY ?? process.execPath,
     TTSC_TSGO_BINARY: process.env.TTSC_TSGO_BINARY ?? tsgo.binary,
@@ -250,6 +256,13 @@ function nativePluginEnv(
       path.join(__dirname, "..", "..", "launcher", "ttsx.js"),
     ...options.env,
   };
+  if (plugin?.stage === "transform") {
+    const linked = linkedTransformPlugins(nativePlugins ?? []);
+    if (linked.length !== 0) {
+      env.TTSC_LINKED_PLUGINS_JSON = serializeNativePlugins(linked);
+    }
+  }
+  return env;
 }
 
 function spawnNative(

package/src/index.ts

@@ -8,5 +8,4 @@
  */
 
 export * from "./TtscCompiler";
-export * from "./defineTtscPlugin";
 export * from "./structures/index";

package/src/launcher/internal/runTtsc.ts

@@ -7,6 +7,7 @@ import { resolveProjectConfig } from "../../compiler/internal/project/resolvePro
 import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { runBuild } from "../../compiler/internal/runBuild";
 import { runSingleFileEmit } from "../../compiler/internal/runSingleFileEmit";
+import { defaultPluginCacheCleanTargets } from "../../plugin/internal/buildSourcePlugin";
 import type { TtscBuildOptions } from "../../structures/internal/TtscBuildOptions";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 
@@ -161,13 +162,17 @@ function runClean(argv: readonly string[]): number {
   const options = parseProjectArgs(argv);
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const projectRoot = resolveCleanProjectRoot(cwd, options.tsconfig);
-  const targets = [
+  const legacyTargets = [
     path.join(projectRoot, "node_modules", ".ttsc"),
     path.join(projectRoot, ".ttsc"),
+  ];
+  const targets = [
     ...(options.cacheDir ? [path.resolve(cwd, options.cacheDir)] : []),
     ...(process.env.TTSC_CACHE_DIR
-      ? [path.resolve(process.env.TTSC_CACHE_DIR, "plugins")]
-      : []),
+      ? [path.resolve(process.env.TTSC_CACHE_DIR, "plugins"), ...legacyTargets]
+      : options.cacheDir
+        ? legacyTargets
+        : defaultPluginCacheCleanTargets(projectRoot)),
   ];
   const removed: string[] = [];
   for (const target of targets) {
@@ -436,7 +441,7 @@ function printHelp(): void {
       "  ttsc fix [options]         Apply check-plugin lint + format edits, then run `ttsc check`.",
       "  ttsc format [options]      Apply check-plugin format-class edits only (write-only, no type check).",
       "  ttsc prepare [options]     Build configured source-plugin binaries into cache.",
-      "  ttsc clean [options]       Delete local source-plugin cache directories.",
+      "  ttsc clean [options]       Delete source-plugin cache directories.",
     ].join("\n"),
   );
   process.stdout.write("\n");

package/src/launcher/internal/runTtscserver.ts

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import * as os from "node:os";
 
+import { resolveTsgo } from "../../compiler/internal/resolveTsgo";
 import { resolveTtscserverBinary } from "./resolveTtscserverBinary";
 
 /**
@@ -11,6 +12,7 @@ import { resolveTtscserverBinary } from "./resolveTtscserverBinary";
  * performs only:
  *
  * - Resolve the platform binary,
+ * - Resolve the project TypeScript-Go binary for the native wrapper,
  * - Inject `--stdio` when the first arg is not a meta-command,
  * - Delegate to the binary with inherited stdio so OS-level signals reach the
  *   child via the parent's process group.
@@ -31,9 +33,18 @@ export function runTtscserver(
   ensureExecutable(binary);
 
   const args = needsStdio(argv) ? ["--stdio", ...argv] : [...argv];
+  let env: NodeJS.ProcessEnv;
+  try {
+    env = resolveTtscserverEnv(args);
+  } catch (error) {
+    process.stderr.write(
+      `ttscserver: ${stripTtscPrefix(formatError(error))}\n`,
+    );
+    return 1;
+  }
   const result = spawnSync(binary, args, {
     stdio: "inherit",
-    env: process.env,
+    env,
     windowsHide: true,
   });
   if (result.error) {
@@ -55,6 +66,37 @@ export function runTtscserver(
   return result.status ?? 1;
 }
 
+function resolveTtscserverEnv(argv: readonly string[]): NodeJS.ProcessEnv {
+  if (!argv.includes("--stdio")) {
+    return process.env;
+  }
+  if (process.env.TTSC_TSGO_BINARY || hasTsgoOption(argv)) {
+    return process.env;
+  }
+  const tsgo = resolveTsgo({
+    cwd: process.cwd(),
+    resolveFrom: __filename,
+  });
+  return {
+    ...process.env,
+    TTSC_TSGO_BINARY: tsgo.binary,
+  };
+}
+
+function hasTsgoOption(argv: readonly string[]): boolean {
+  return argv.some((arg) => arg === "--tsgo" || arg.startsWith("--tsgo="));
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function stripTtscPrefix(message: string): string {
+  return message.startsWith("ttsc: ")
+    ? message.slice("ttsc: ".length)
+    : message;
+}
+
 /**
  * `--stdio` is the only transport the native host accepts today. The launcher
  * injects it only when the first argv token looks like a forwarded option;