ttsc 0.4.4 → 0.5.0-dev.20260429

package/src/cli.ts

@@ -12,6 +12,7 @@ import {
 } from "./api";
 import { installHint, resolveBinary } from "./platform";
 import { resolveProjectConfig, resolveProjectRoot } from "./project";
+import { pluginCacheCleanupTargets } from "./source-build";
 
 export function main(argv: readonly string[] = process.argv.slice(2)): number {
   try {
@@ -35,6 +36,8 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         return runCompatibleBuild(rest, false);
       case "check":
         return runCompatibleBuild(rest, true);
+      case "clean":
+        return runClean(rest);
       case "transform":
         return runTransform(rest);
       case "demo":
@@ -99,6 +102,49 @@ function runTransform(argv: readonly string[]): number {
   return 0;
 }
 
+interface CleanInvocation {
+  cwd?: string;
+  tsconfig?: string;
+}
+
+function runClean(argv: readonly string[]): number {
+  const options = parseCleanArgs(argv);
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const projectRoot = resolveCleanProjectRoot(cwd, options.tsconfig);
+  const targets = pluginCacheCleanupTargets(projectRoot);
+  const removed: string[] = [];
+  for (const target of targets) {
+    if (!fs.existsSync(target)) continue;
+    fs.rmSync(target, { recursive: true, force: true });
+    removed.push(target);
+  }
+  if (removed.length === 0) {
+    process.stdout.write(`ttsc: no cache directories found under ${projectRoot}\n`);
+    return 0;
+  }
+  for (const target of removed) {
+    process.stdout.write(`ttsc: removed ${formatCleanPath(cwd, target)}\n`);
+  }
+  return 0;
+}
+
+function resolveCleanProjectRoot(cwd: string, tsconfig?: string): string {
+  try {
+    return path.dirname(resolveProjectConfig({ cwd, tsconfig }));
+  } catch (error) {
+    if (tsconfig) throw error;
+    return cwd;
+  }
+}
+
+function formatCleanPath(cwd: string, target: string): string {
+  const relative = path.relative(cwd, target);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return target;
+  }
+  return relative;
+}
+
 function delegateToNative(argv: readonly string[]): number {
   const bin = resolveBinary();
   if (!bin) {
@@ -122,6 +168,38 @@ function delegateToNative(argv: readonly string[]): number {
   return result.status ?? 1;
 }
 
+function parseCleanArgs(argv: readonly string[]): CleanInvocation {
+  let cwd: string | undefined;
+  let tsconfig: string | undefined;
+
+  const rest = [...argv];
+  while (rest.length !== 0) {
+    const current = rest.shift()!;
+    switch (current) {
+      case "--cwd":
+        cwd = takeValue(current, rest);
+        break;
+      case "-p":
+      case "--tsconfig":
+      case "--project":
+        tsconfig = takeValue(current, rest);
+        break;
+      default:
+        if (current.startsWith("--cwd=")) {
+          cwd = current.slice("--cwd=".length);
+        } else if (current.startsWith("--tsconfig=")) {
+          tsconfig = current.slice("--tsconfig=".length);
+        } else if (current.startsWith("--project=")) {
+          tsconfig = current.slice("--project=".length);
+        } else {
+          throw new Error(`ttsc: unknown option ${current}`);
+        }
+        break;
+    }
+  }
+  return { cwd, tsconfig };
+}
+
 function parseBuildArgs(
   argv: readonly string[],
   checkOnly: boolean,
@@ -298,6 +376,7 @@ function printHelp(): void {
       "  ttsc -p tsconfig.json",
       "  ttsc --watch",
       "  ttsc --noEmit",
+      "  ttsc clean [options]",
       "  ttsc transform --file <path> [options]",
       "  ttsc version",
       "  ttsc --help",
@@ -319,12 +398,13 @@ function printHelp(): void {
       "",
       "Plugin contract:",
       "  ttsc reads compilerOptions.plugins from tsconfig.json.",
-      "  TS plugins may export `definePlugin(...)` from ttsc.",
-      "  Native consumer plugins may also provide their own binary path.",
+      "  Plugin modules are descriptors for ordered native transformer backends.",
+      "  JS transformOutput/transformSource hooks are not part of the public contract.",
       "",
       "Compatibility aliases:",
       "  ttsc build [options]       Same project build lane as `ttsc [options]`.",
       "  ttsc check [options]       Same as `ttsc --noEmit [options]`.",
+      "  ttsc clean [options]       Delete local source-plugin cache directories.",
     ].join("\n"),
   );
   process.stdout.write("\n");

package/src/index.ts

@@ -7,9 +7,9 @@
  *   - platform helpers (`resolveBinary`, `installHint`, …) — compatibility
  *     helper resolution for commands such as `ttsc demo`.
  *   - programmatic API (`transform`, `build`, `check`, `version`) — a thin
- *     TS wrapper around the consumer `tsgo` binary plus JS output-plugin
- *     hooks. Adapters never have to shell out themselves; they call these
- *     helpers and get back a string or a result record.
+ *     TS wrapper around the consumer `tsgo` binary and native plugin
+ *     descriptors. Adapters never have to shell out themselves; they call
+ *     these helpers and get back a string or a result record.
  */
 
 export * from "./platform";

package/src/native.ts

@@ -1,9 +1,15 @@
 export type NativeRewriteMode = string;
 export type NativePluginContractVersion = 1;
 
+export interface TtscNativeSource {
+  dir: string;
+  entry?: string;
+}
+
 export interface TtscNativeBackend {
   mode: NativeRewriteMode;
   binary?: string;
+  source?: TtscNativeSource;
   contractVersion?: NativePluginContractVersion;
   capabilities?: readonly string[];
 }
@@ -53,6 +59,18 @@ export function resolveNativeBackend(
       `ttsc: plugin "${plugin.name}" requested unsupported native contract version ${backend.contractVersion}`,
     );
   }
+  if (backend.source) {
+    if (backend.binary) {
+      throw new Error(
+        `ttsc: plugin "${plugin.name}" must use either native.binary or native.source, not both`,
+      );
+    }
+    if (typeof backend.source.dir !== "string" || backend.source.dir.length === 0) {
+      throw new Error(
+        `ttsc: plugin "${plugin.name}" native.source.dir must be a non-empty string`,
+      );
+    }
+  }
   return {
     ...backend,
     contractVersion: backend.contractVersion ?? 1,

package/src/plugin.ts

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -11,11 +12,13 @@ import {
   type ProjectPluginConfig,
   readProjectConfig,
 } from "./project";
+import { buildSourcePlugin } from "./source-build";
 
 export type {
   NativePluginContractVersion,
   NativeRewriteMode,
   TtscNativeBackend,
+  TtscNativeSource,
 } from "./native";
 
 export interface TtscPluginFactoryContext {
@@ -25,53 +28,6 @@ export interface TtscPluginFactoryContext {
   tsconfig: string;
 }
 
-export interface TtscTransformContext {
-  code: string;
-  command: "build" | "transform";
-  cwd: string;
-  compilerOptions: Record<string, unknown>;
-  outputFile?: string;
-  projectRoot: string;
-  sourceFile?: string;
-  tsconfig: string;
-}
-
-export interface TtscSourceTransformContext {
-  code: string;
-  command: "build" | "transform";
-  compilerOptions: Record<string, unknown>;
-  cwd: string;
-  projectRoot: string;
-  sourceFile: string;
-  tsconfig: string;
-}
-
-export interface TtscSourceEdit {
-  code: string;
-  end: number;
-  start: number;
-}
-
-export interface TtscSourceTransformResult {
-  code?: string;
-  edits?: readonly TtscSourceEdit[];
-}
-
-export interface AppliedTtscSourceEdit extends TtscSourceEdit {
-  newEnd: number;
-  newStart: number;
-}
-
-export interface TtscSourceTransformStage {
-  before: string;
-  edits: readonly AppliedTtscSourceEdit[];
-}
-
-export interface TtscSourceTransformOutput {
-  code: string;
-  stages: readonly TtscSourceTransformStage[];
-}
-
 export interface TtscPlugin {
   name: string;
   native?: TtscNativeBackend;
@@ -79,10 +35,6 @@ export interface TtscPlugin {
   nativeMode?: NativeRewriteMode;
   /** @deprecated Use `native.binary` instead. */
   nativeBinary?: string;
-  transformSource?(
-    context: TtscSourceTransformContext,
-  ): string | TtscSourceTransformResult | readonly TtscSourceEdit[] | undefined;
-  transformOutput?(context: TtscTransformContext): string;
 }
 
 export type TtscPluginFactory = (
@@ -92,11 +44,17 @@ export type TtscPluginFactory = (
 
 export type TtscPluginModule = TtscPlugin | TtscPluginFactory;
 
+export interface LoadedNativePlugin {
+  backend: TtscNativeBackend;
+  config: ProjectPluginConfig;
+  name: string;
+}
+
 export interface LoadedPlugins {
   compatibilityFallback: boolean;
-  nativeBackend: TtscNativeBackend | null;
   nativeBinary: string | null;
-  nativeMode: NativeRewriteMode;
+  nativeBinaries: string[];
+  nativePlugins: LoadedNativePlugin[];
   plugins: TtscPlugin[];
   project: ParsedProjectConfig;
 }
@@ -128,9 +86,9 @@ export function loadProjectPlugins(options: LoadPluginsOptions): LoadedPlugins {
   if (entries.length === 0) {
     return {
       compatibilityFallback: false,
-      nativeBackend: null,
       nativeBinary: null,
-      nativeMode: "none",
+      nativeBinaries: [],
+      nativePlugins: [],
       plugins: [],
       project,
     };
@@ -144,169 +102,51 @@ export function loadProjectPlugins(options: LoadPluginsOptions): LoadedPlugins {
   };
   const plugins = entries.map((entry) => loadPluginEntry(entry, context));
 
-  let nativeBinary: string | null = null;
-  let nativeBackend: TtscNativeBackend | null = null;
-  let nativeMode: NativeRewriteMode = "none";
-  for (const plugin of plugins) {
-    const backend = resolveNativeBackend(plugin);
+  const nativePlugins: LoadedNativePlugin[] = [];
+  const ttscVersion = readTtscVersion();
+  const tsgoVersion = readTsgoVersion(context.projectRoot);
+  plugins.forEach((plugin, index) => {
+    let backend = resolveNativeBackend(plugin);
     if (!backend) {
-      continue;
-    }
-    if (nativeMode !== "none" && nativeMode !== backend.mode) {
-      throw new Error(
-        `ttsc: multiple native plugin modes requested (${nativeMode}, ${backend.mode})`,
-      );
+      return;
     }
-    nativeMode = backend.mode;
-    nativeBackend = backend;
-    if (backend.binary) {
-      if (nativeBinary !== null && nativeBinary !== backend.binary) {
-        throw new Error(
-          `ttsc: multiple native plugin binaries requested (${nativeBinary}, ${backend.binary})`,
-        );
-      }
-      nativeBinary = backend.binary;
+    if (backend.source && !backend.binary) {
+      const built = buildSourcePlugin({
+        baseDir: context.projectRoot,
+        pluginName: plugin.name,
+        source: backend.source,
+        ttscVersion,
+        tsgoVersion,
+      });
+      backend = { ...backend, binary: built };
     }
+    nativePlugins.push({ backend, config: entries[index]!, name: plugin.name });
+  });
+  if (nativePlugins.length !== plugins.length) {
+    const missing = plugins
+      .filter((plugin) => !resolveNativeBackend(plugin))
+      .map((plugin) => plugin.name)
+      .join(", ");
+    throw new Error(
+      `ttsc: every plugin must declare a native backend; missing native for ${missing}`,
+    );
   }
   return {
     compatibilityFallback: false,
-    nativeBackend,
-    nativeBinary,
-    nativeMode,
+    nativeBinary: nativePlugins[0]?.backend.binary ?? null,
+    nativeBinaries: [
+      ...new Set(
+        nativePlugins
+          .map((plugin) => plugin.backend.binary)
+          .filter((binary): binary is string => typeof binary === "string"),
+      ),
+    ],
+    nativePlugins,
     plugins,
     project,
   };
 }
 
-export function applyPluginTransforms(
-  plugins: readonly TtscPlugin[],
-  context: TtscTransformContext,
-): string {
-  let code = context.code;
-  for (const plugin of plugins) {
-    if (!plugin.transformOutput) {
-      continue;
-    }
-    code = plugin.transformOutput({ ...context, code });
-  }
-  return code;
-}
-
-export function applyPluginSourceTransforms(
-  plugins: readonly TtscPlugin[],
-  context: TtscSourceTransformContext,
-): string {
-  return applyPluginSourceTransformsWithMap(plugins, context).code;
-}
-
-export function applyPluginSourceTransformsWithMap(
-  plugins: readonly TtscPlugin[],
-  context: TtscSourceTransformContext,
-): TtscSourceTransformOutput {
-  let code = context.code;
-  const stages: TtscSourceTransformStage[] = [];
-  for (const plugin of plugins) {
-    if (!plugin.transformSource) {
-      continue;
-    }
-    const before = code;
-    const result = plugin.transformSource({ ...context, code });
-    if (typeof result === "string") {
-      code = result;
-      if (code !== before) {
-        stages.push({
-          before,
-          edits: createAppliedSourceEdits(before, [
-            { code, end: before.length, start: 0 },
-          ]),
-        });
-      }
-      continue;
-    }
-    if (isSourceEditArray(result)) {
-      const edits = createAppliedSourceEdits(before, result);
-      code = applySourceEdits(before, edits);
-      if (edits.length > 0) {
-        stages.push({ before, edits });
-      }
-      continue;
-    }
-    if (result?.code !== undefined) {
-      code = result.code;
-      if (code !== before) {
-        stages.push({
-          before,
-          edits: createAppliedSourceEdits(before, [
-            { code, end: before.length, start: 0 },
-          ]),
-        });
-      }
-      continue;
-    }
-    if (result?.edits) {
-      const edits = createAppliedSourceEdits(before, result.edits);
-      code = applySourceEdits(before, edits);
-      if (edits.length > 0) {
-        stages.push({ before, edits });
-      }
-    }
-  }
-  return { code, stages };
-}
-
-function isSourceEditArray(value: unknown): value is readonly TtscSourceEdit[] {
-  return Array.isArray(value);
-}
-
-function applySourceEdits(
-  source: string,
-  edits: readonly TtscSourceEdit[],
-): string {
-  if (edits.length === 0) {
-    return source;
-  }
-  const ordered = [...edits].sort((a, b) => b.start - a.start);
-  let output = source;
-  for (const edit of ordered) {
-    output = output.slice(0, edit.start) + edit.code + output.slice(edit.end);
-  }
-  return output;
-}
-
-function createAppliedSourceEdits(
-  source: string,
-  edits: readonly TtscSourceEdit[],
-): AppliedTtscSourceEdit[] {
-  if (edits.length === 0) {
-    return [];
-  }
-  const ordered = [...edits].sort((a, b) => a.start - b.start);
-  let previousEnd = 0;
-  let delta = 0;
-  const applied: AppliedTtscSourceEdit[] = [];
-  for (const edit of ordered) {
-    if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end)) {
-      throw new Error("ttsc: transformSource edit offsets must be integers");
-    }
-    if (
-      edit.start < 0 ||
-      edit.end < edit.start ||
-      edit.end > source.length ||
-      edit.start < previousEnd
-    ) {
-      throw new Error(
-        `ttsc: invalid or overlapping transformSource edit ${edit.start}:${edit.end}`,
-      );
-    }
-    const newStart = edit.start + delta;
-    const newEnd = newStart + edit.code.length;
-    applied.push({ ...edit, newEnd, newStart });
-    delta += edit.code.length - (edit.end - edit.start);
-    previousEnd = edit.end;
-  }
-  return applied;
-}
-
 function loadPluginEntry(
   entry: ProjectPluginConfig,
   context: TtscPluginFactoryContext,
@@ -327,13 +167,17 @@ function loadPluginEntry(
     mod.plugin ??
     (mod as unknown as TtscPluginModule);
   if (typeof candidate === "function") {
-    return candidate(entry, context);
+    const plugin = candidate(entry, context);
+    if (!isTtscPlugin(plugin)) {
+      throw new Error(
+        `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+      );
+    }
+    rejectJsTransformHooks(specifier, plugin);
+    return plugin;
   }
-  if (
-    candidate &&
-    typeof candidate === "object" &&
-    typeof candidate.name === "string"
-  ) {
+  if (isTtscPlugin(candidate)) {
+    rejectJsTransformHooks(specifier, candidate);
     return candidate;
   }
   throw new Error(
@@ -341,6 +185,23 @@ function loadPluginEntry(
   );
 }
 
+function isTtscPlugin(value: unknown): value is TtscPlugin {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { name?: unknown }).name === "string"
+  );
+}
+
+function rejectJsTransformHooks(specifier: string, candidate: object): void {
+  if ("transformSource" in candidate || "transformOutput" in candidate) {
+    throw new Error(
+      `ttsc: plugin "${specifier}" declares unsupported JS transform hooks; ` +
+        "declare a native backend instead",
+    );
+  }
+}
+
 function resolvePluginRequest(specifier: string, projectRoot: string): string {
   if (path.isAbsolute(specifier)) {
     return specifier;
@@ -394,3 +255,36 @@ function resolveSourceCheckoutPlugin(
     return null;
   }
 }
+
+let cachedTtscVersion: string | null = null;
+
+function readTtscVersion(): string {
+  if (cachedTtscVersion !== null) {
+    return cachedTtscVersion;
+  }
+  try {
+    const file = path.resolve(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(file, "utf8")) as {
+      version?: string;
+    };
+    cachedTtscVersion = pkg.version ?? "0.0.0";
+  } catch {
+    cachedTtscVersion = "0.0.0";
+  }
+  return cachedTtscVersion;
+}
+
+function readTsgoVersion(projectRoot: string): string {
+  try {
+    const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+    const pkgPath = projectRequire.resolve(
+      "@typescript/native-preview/package.json",
+    );
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8")) as {
+      version?: string;
+    };
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}

package/src/runner/cli.ts

@@ -244,6 +244,11 @@ function rewriteEsmSpecifiers(root: string): void {
           (_, quote: string, specifier: string) =>
             `from ${quote}${withResolvableExtension(next, specifier)}${quote}`,
         )
+        .replace(
+          /\bimport\s+(['"])(\.[^'"]+)\1/g,
+          (_, quote: string, specifier: string) =>
+            `import ${quote}${withResolvableExtension(next, specifier)}${quote}`,
+        )
         .replace(
           /\bimport\(\s*(['"])(\.[^'"]+)\1\s*\)/g,
           (_, quote: string, specifier: string) =>