ttsc 0.8.1 → 0.9.0

package/src/plugin/internal/buildSourcePlugin.ts

@@ -1,19 +1,14 @@
 import { spawnSync } from "node:child_process";
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
+import crypto from "node:crypto";
+import fs from "node:fs";
 import { createRequire } from "node:module";
-import * as path from "node:path";
+import os from "node:os";
+import path from "node:path";
 
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
 
-const SKIP_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "vendor",
-  "lib",
-]);
+const PRUNE_DIRS = new Set(["node_modules", ".git", ".ttsc"]);
+const GENERATED_WORKSPACE_FILES = new Set(["go.work", "go.work.sum"]);
 
 /** Build one Go source plugin into a cached executable. */
 export function buildSourcePlugin(opts: {
@@ -28,9 +23,13 @@ export function buildSourcePlugin(opts: {
   tsgoVersion: string;
 }): string {
   const { dir, entry, source } = resolveSourceBuildTarget(opts);
+  const overlayDirs = opts.overlayDirs ?? findTtscOverlayDirs();
+  const goBinary = resolveGoCompiler();
   const key = computeCacheKey({
     dir,
     entry,
+    goBinary,
+    overlayDirs,
     ttscVersion: opts.ttscVersion,
     tsgoVersion: opts.tsgoVersion,
   });
@@ -49,27 +48,46 @@ export function buildSourcePlugin(opts: {
     );
   }
 
-  const scratchDir = path.join(
-    root,
-    `scratch-${key}-${process.pid}-${Date.now()}`,
+  const scratchDir = fs.mkdtempSync(
+    path.join(os.tmpdir(), `ttsc-plugin-${key}-`),
   );
   try {
     materializeScratchDir(dir, scratchDir);
-    writeGoWork(scratchDir, opts.overlayDirs ?? findTtscOverlayDirs());
+    writeGoWork(scratchDir, overlayDirs);
     const scratchBinaryName =
       process.platform === "win32" ? ".ttsc-plugin.exe" : ".ttsc-plugin";
-    runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName);
+    runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName, goBinary);
     const builtBinary = path.join(scratchDir, scratchBinaryName);
-    fs.renameSync(builtBinary, binaryPath);
-    if (process.platform !== "win32") {
-      fs.chmodSync(binaryPath, 0o755);
-    }
+    publishBuiltBinary(builtBinary, binaryPath);
     return binaryPath;
   } finally {
     fs.rmSync(scratchDir, { recursive: true, force: true });
   }
 }
 
+function publishBuiltBinary(builtBinary: string, binaryPath: string): void {
+  const pending = `${binaryPath}.${process.pid}.${Date.now()}-${Math.random()
+    .toString(16)
+    .slice(2)}.tmp`;
+  fs.copyFileSync(builtBinary, pending);
+  if (process.platform !== "win32") {
+    fs.chmodSync(pending, 0o755);
+  }
+  try {
+    fs.renameSync(pending, binaryPath);
+  } catch (error) {
+    fs.rmSync(pending, { force: true });
+    const code = (error as NodeJS.ErrnoException).code;
+    if (
+      (code === "EEXIST" || code === "EPERM" || code === "EACCES") &&
+      fs.existsSync(binaryPath)
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
 function resolveSourceBuildTarget(opts: {
   source: string;
   pluginName: string;
@@ -136,8 +154,8 @@ function materializeScratchDir(source: string, scratch: string): void {
     recursive: true,
     filter: (src) => {
       const base = path.basename(src);
-      if (SKIP_DIRS.has(base)) return false;
-      if (base === "go.work" || base === "go.work.sum") return false;
+      if (shouldPruneDirectory(base)) return false;
+      if (shouldOmitSourceFile(base)) return false;
       return true;
     },
   });
@@ -189,8 +207,8 @@ function runGoBuild(
   entry: string,
   binaryName: string,
   pluginName: string,
+  goBinary: string,
 ): void {
-  const goBinary = resolveGoCompiler();
   ensureExecutableGoToolchain(goBinary);
   const result = spawnSync(goBinary, ["build", "-o", binaryName, entry], {
     cwd,
@@ -305,7 +323,7 @@ function walkForGoMod(dir: string, out: string[]): void {
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (SKIP_DIRS.has(entry.name)) continue;
+    if (shouldPruneDirectory(entry.name)) continue;
     walkForGoMod(path.join(dir, entry.name), out);
   }
 }
@@ -315,7 +333,7 @@ function resolvePluginCacheRoot(
   cacheDir?: string,
 ): string {
   if (cacheDir) {
-    return path.resolve(cacheDir, "plugins");
+    return path.resolve(projectRoot, cacheDir, "plugins");
   }
   if (process.env.TTSC_CACHE_DIR) {
     return path.resolve(process.env.TTSC_CACHE_DIR, "plugins");
@@ -387,9 +405,11 @@ function resolveGoCompiler(): string {
   return "go";
 }
 
-function computeCacheKey(inputs: {
+export function computeCacheKey(inputs: {
   dir: string;
   entry: string;
+  goBinary?: string;
+  overlayDirs?: readonly string[];
   ttscVersion: string;
   tsgoVersion: string;
 }): string {
@@ -398,12 +418,28 @@ function computeCacheKey(inputs: {
   hash.update(`tsgo=${inputs.tsgoVersion}\n`);
   hash.update(`platform=${process.platform}/${process.arch}\n`);
   hash.update(`entry=${inputs.entry}\n`);
-  for (const file of collectSourceFiles(inputs.dir)) {
-    const rel = path.relative(inputs.dir, file).replace(/\\/g, "/");
+  if (inputs.goBinary !== undefined) {
+    hash.update(`go=${resolveGoCompilerIdentity(inputs.goBinary)}\n`);
+  }
+  hashSourceDirectory(hash, "plugin", inputs.dir);
+  for (const [index, dir] of [...(inputs.overlayDirs ?? [])].sort().entries()) {
+    hashSourceDirectory(hash, `overlay:${index}`, dir);
+  }
+  return hash.digest("hex").slice(0, 32);
+}
+
+function hashSourceDirectory(
+  hash: crypto.Hash,
+  label: string,
+  root: string,
+): void {
+  hash.update(`dir=${label}\n`);
+  for (const file of collectSourceFiles(root)) {
+    const rel = path.relative(root, file).replace(/\\/g, "/");
     hash.update(`f=${rel}\n`);
     hash.update(fs.readFileSync(file));
+    hash.update("\n");
   }
-  return hash.digest("hex").slice(0, 32);
 }
 
 function collectSourceFiles(root: string): string[] {
@@ -421,19 +457,78 @@ function walk(dir: string, out: string[]): void {
     return;
   }
   for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue;
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
+      if (shouldPruneDirectory(entry.name)) continue;
       walk(full, out);
       continue;
     }
     if (!entry.isFile()) continue;
+    if (shouldOmitSourceFile(entry.name)) continue;
     if (!isHashableFile(entry.name)) continue;
     out.push(full);
   }
 }
 
+function shouldPruneDirectory(name: string): boolean {
+  return PRUNE_DIRS.has(name);
+}
+
+function shouldOmitSourceFile(name: string): boolean {
+  return GENERATED_WORKSPACE_FILES.has(name);
+}
+
 function isHashableFile(name: string): boolean {
-  if (name === "go.mod" || name === "go.sum" || name === "go.work") return true;
-  return /\.(?:go|s|c|h|cpp|hpp)$/i.test(name);
+  return !name.endsWith("~");
+}
+
+function resolveGoCompilerIdentity(goBinary: string): string {
+  const resolved = resolveExecutableIdentityPath(goBinary);
+  const version = spawnSync(goBinary, ["version"], {
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const versionText =
+    version.error !== undefined
+      ? version.error.message
+      : `${version.status ?? 0}:${version.stdout}${version.stderr}`;
+  let statText = "";
+  try {
+    const stat = fs.statSync(resolved);
+    statText = `${stat.size}:${stat.mtimeMs}`;
+  } catch {
+    statText = "missing";
+  }
+  return `${goBinary}:${resolved}:${statText}:${versionText}`;
+}
+
+function resolveExecutableIdentityPath(binary: string): string {
+  if (path.isAbsolute(binary)) {
+    return resolveRealPath(binary);
+  }
+  if (binary.includes(path.sep)) {
+    return resolveRealPath(path.resolve(binary));
+  }
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (dir.length === 0) continue;
+    const candidate = path.join(dir, binary);
+    if (fs.existsSync(candidate)) {
+      return resolveRealPath(candidate);
+    }
+    if (process.platform === "win32") {
+      const executable = `${candidate}.exe`;
+      if (fs.existsSync(executable)) {
+        return resolveRealPath(executable);
+      }
+    }
+  }
+  return binary;
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
 }

package/src/plugin/internal/loadProjectPlugins.ts

@@ -15,12 +15,25 @@ type TtscPluginFactory<T = ITtscProjectPluginConfig> = (
   context: ITtscPluginFactoryContext<T>,
 ) => ITtscPlugin;
 
+type ProjectPluginEntry = {
+  baseDir: string;
+  config: ITtscProjectPluginConfig;
+};
+
+type PackageManifest = {
+  dependencies?: Record<string, unknown>;
+  devDependencies?: Record<string, unknown>;
+  name?: unknown;
+  ttsc?: unknown;
+};
+
 export function loadProjectPlugins(options: {
   binary: string;
   cacheDir?: string;
   cwd?: string;
   entries?: readonly ITtscProjectPluginConfig[] | false;
   file?: string;
+  projectRoot?: string;
   tsconfig?: string;
 }): {
   nativePlugins: ITtscLoadedNativePlugin[];
@@ -29,13 +42,14 @@ export function loadProjectPlugins(options: {
   const project = readProjectConfig({
     cwd: options.cwd,
     file: options.file,
+    projectRoot: options.projectRoot,
     tsconfig: options.tsconfig,
   });
-  const entries =
+  const entries: ProjectPluginEntry[] =
     options.entries === false
       ? []
-      : [...(options.entries ?? project.compilerOptions.plugins)].filter(
-          (entry) => entry.enabled !== false,
+      : resolvePluginEntries(project, options.entries).filter(
+          (entry) => entry.config.enabled !== false,
         );
   if (entries.length === 0) {
     return {
@@ -51,7 +65,11 @@ export function loadProjectPlugins(options: {
     tsconfig: project.path,
   };
   const plugins = entries.map((entry) =>
-    loadPluginEntry(entry, { ...context, plugin: entry }),
+    loadPluginEntry(
+      entry.config,
+      { ...context, plugin: entry.config },
+      entry.baseDir,
+    ),
   );
 
   const nativePlugins: ITtscLoadedNativePlugin[] = [];
@@ -70,28 +88,258 @@ export function loadProjectPlugins(options: {
     });
     nativePlugins.push({
       binary,
-      config: entries[index]!,
+      config: entries[index]!.config,
       name: plugin.name,
       source: plugin.source,
       stage,
     });
   });
   return {
-    nativePlugins,
+    nativePlugins: orderNativePlugins(nativePlugins),
     project,
   };
 }
 
+export function hasProjectPluginEntries(
+  project: ITtscParsedProjectConfig,
+  entries?: readonly ITtscProjectPluginConfig[] | false,
+): boolean {
+  if (entries === false) {
+    return false;
+  }
+  return resolvePluginEntries(project, entries).some(
+    (entry) => entry.config.enabled !== false,
+  );
+}
+
+function resolvePluginEntries(
+  project: ITtscParsedProjectConfig,
+  entries?: readonly ITtscProjectPluginConfig[],
+): ProjectPluginEntry[] {
+  if (entries !== undefined) {
+    return entries.map((config) => ({
+      baseDir: project.root,
+      config,
+    }));
+  }
+  const configured = project.compilerOptions.plugins.map((config, index) => ({
+    baseDir: project.pluginBaseDirs[index] ?? project.root,
+    config,
+  }));
+  return [...configured, ...discoverPackagePluginEntries(project, configured)];
+}
+
+function discoverPackagePluginEntries(
+  project: ITtscParsedProjectConfig,
+  configured: readonly ProjectPluginEntry[],
+): ProjectPluginEntry[] {
+  const projectPackageJson = findNearestPackageJson(project.root);
+  if (projectPackageJson === undefined) {
+    return [];
+  }
+  const projectPackageRoot = path.dirname(projectPackageJson);
+  const projectManifest = readPackageManifest(projectPackageJson);
+  if (projectManifest === undefined) {
+    return [];
+  }
+
+  const configuredTransforms = createConfiguredTransformSet(configured);
+  const out: ProjectPluginEntry[] = [];
+  for (const name of directDependencyNames(projectManifest)) {
+    const packageJson = resolveDependencyPackageJson(name, projectPackageRoot);
+    if (packageJson === undefined) {
+      continue;
+    }
+    const manifest = readPackageManifest(packageJson);
+    const config = readPackagePluginConfig(name, manifest);
+    if (config === undefined || config.enabled === false) {
+      continue;
+    }
+    const packageRoot = path.dirname(packageJson);
+    const transform = config.transform;
+    if (typeof transform !== "string") {
+      continue;
+    }
+    const baseDir = isRelativePluginSpecifier(transform)
+      ? packageRoot
+      : projectPackageRoot;
+    const resolved = resolvePluginRequest(transform, baseDir);
+    if (hasConfiguredTransform(configuredTransforms, transform, resolved)) {
+      continue;
+    }
+    out.push({
+      baseDir,
+      config,
+    });
+    addConfiguredTransform(configuredTransforms, transform, resolved);
+  }
+  return out;
+}
+
+type ConfiguredTransformSet = {
+  raw: Set<string>;
+  resolved: Set<string>;
+};
+
+function createConfiguredTransformSet(
+  entries: readonly ProjectPluginEntry[],
+): ConfiguredTransformSet {
+  const raw = new Set<string>();
+  const resolved = new Set<string>();
+  for (const entry of entries) {
+    const transform = entry.config.transform;
+    if (typeof transform !== "string" || transform.length === 0) {
+      continue;
+    }
+    if (!isRelativePluginSpecifier(transform)) {
+      raw.add(transform);
+    }
+    try {
+      resolved.add(resolvePluginRequest(transform, entry.baseDir));
+    } catch {
+      // Keep the normal plugin loading error path for invalid explicit entries.
+    }
+  }
+  return { raw, resolved };
+}
+
+function hasConfiguredTransform(
+  configuredTransforms: ConfiguredTransformSet,
+  transform: string,
+  resolved: string,
+): boolean {
+  return (
+    configuredTransforms.resolved.has(resolved) ||
+    (!isRelativePluginSpecifier(transform) &&
+      configuredTransforms.raw.has(transform))
+  );
+}
+
+function addConfiguredTransform(
+  configuredTransforms: ConfiguredTransformSet,
+  transform: string,
+  resolved: string,
+): void {
+  if (!isRelativePluginSpecifier(transform)) {
+    configuredTransforms.raw.add(transform);
+  }
+  configuredTransforms.resolved.add(resolved);
+}
+
+function directDependencyNames(manifest: PackageManifest): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const dependencies of [
+    manifest.dependencies,
+    manifest.devDependencies,
+  ]) {
+    if (!isRecord(dependencies)) {
+      continue;
+    }
+    for (const name of Object.keys(dependencies)) {
+      if (seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      out.push(name);
+    }
+  }
+  return out;
+}
+
+function resolveDependencyPackageJson(
+  name: string,
+  projectRoot: string,
+): string | undefined {
+  const direct = path.join(projectRoot, "node_modules", ...name.split("/"));
+  const directManifest = path.join(direct, "package.json");
+  if (fs.existsSync(directManifest)) {
+    return resolveRealPath(directManifest);
+  }
+  const projectPackage = path.join(projectRoot, "package.json");
+  const projectRequire = createRequire(projectPackage);
+  try {
+    return resolveRealPath(projectRequire.resolve(`${name}/package.json`));
+  } catch {
+    try {
+      return findNearestPackageJson(projectRequire.resolve(name));
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+function findNearestPackageJson(location: string): string | undefined {
+  let current = fs.statSync(location).isDirectory()
+    ? location
+    : path.dirname(location);
+  while (true) {
+    const manifest = path.join(current, "package.json");
+    if (fs.existsSync(manifest)) {
+      return resolveRealPath(manifest);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+function readPackageManifest(file: string): PackageManifest | undefined {
+  if (!fs.existsSync(file)) {
+    return undefined;
+  }
+  const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
+  return isRecord(parsed) ? (parsed as PackageManifest) : undefined;
+}
+
+function readPackagePluginConfig(
+  packageName: string,
+  manifest: PackageManifest | undefined,
+): ITtscProjectPluginConfig | undefined {
+  const ttsc = manifest?.ttsc;
+  if (!isRecord(ttsc) || !("plugin" in ttsc)) {
+    return undefined;
+  }
+  const plugin = ttsc.plugin;
+  if (!isRecord(plugin) || Array.isArray(plugin)) {
+    throw new Error(
+      `ttsc: package ${JSON.stringify(packageName)} declares invalid "ttsc.plugin"; expected an object`,
+    );
+  }
+  if (typeof plugin.transform !== "string" || plugin.transform.length === 0) {
+    throw new Error(
+      `ttsc: package ${JSON.stringify(packageName)} declares invalid "ttsc.plugin.transform"; expected a non-empty string`,
+    );
+  }
+  return { ...plugin } as ITtscProjectPluginConfig;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function orderNativePlugins(
+  plugins: readonly ITtscLoadedNativePlugin[],
+): ITtscLoadedNativePlugin[] {
+  return [
+    ...plugins.filter((plugin) => plugin.stage === "check"),
+    ...plugins.filter((plugin) => plugin.stage === "transform"),
+  ];
+}
+
 function loadPluginEntry(
   entry: ITtscProjectPluginConfig,
   context: ITtscPluginFactoryContext,
+  baseDir: string,
 ): ITtscPlugin {
   const specifier = entry.transform;
   if (typeof specifier !== "string" || specifier.length === 0) {
     throw new Error(`ttsc: plugin entry is missing a string "transform" field`);
   }
 
-  const request = resolvePluginRequest(specifier, context.projectRoot);
+  const request = resolvePluginRequest(specifier, baseDir);
   const mod = require(request) as {
     createTtscPlugin?: TtscPluginFactory;
     default?: ITtscPlugin | TtscPluginFactory;
@@ -170,12 +418,20 @@ function isPluginStage(value: string): value is TtscPluginStage {
 
 function resolvePluginRequest(specifier: string, projectRoot: string): string {
   if (path.isAbsolute(specifier)) {
-    return specifier;
+    return resolveRealPath(specifier);
   }
   if (isRelativePluginSpecifier(specifier)) {
-    return path.resolve(projectRoot, specifier);
+    return resolveRealPath(path.resolve(projectRoot, specifier));
+  }
+  return resolveRealPath(require.resolve(specifier, { paths: [projectRoot] }));
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
   }
-  return require.resolve(specifier, { paths: [projectRoot] });
 }
 
 function isRelativePluginSpecifier(specifier: string): boolean {

package/src/structures/ITtscCompilerContext.ts

@@ -35,6 +35,17 @@ export interface ITtscCompilerContext {
    */
   tsconfig?: string;
 
+  /**
+   * Project root override for generated config wrappers.
+   *
+   * Most callers should leave this unset so the project root is the directory
+   * containing {@link ITtscCompilerContext.tsconfig}. Embedders that synthesize
+   * a temporary config extending a real project config can set this to keep
+   * plugin resolution, cache paths, and native sidecar `--cwd` anchored to the
+   * real project.
+   */
+  projectRoot?: string;
+
   /**
    * Explicit TypeScript-Go executable for controlled embedding.
    *
@@ -73,9 +84,12 @@ export interface ITtscCompilerContext {
   /**
    * Plugin entries for this compiler instance.
    *
-   * - `undefined`: read `compilerOptions.plugins` from the project config.
-   * - `false`: ignore project plugins for this compiler instance.
-   * - array: use these plugin entries instead of the project config entries.
+   * - `undefined`: read project plugins from `compilerOptions.plugins` and
+   *   directly installed package markers.
+   * - `false`: ignore project config plugins and package markers for this
+   *   compiler instance.
+   * - array: use these plugin entries instead of project config entries and
+   *   package markers.
    *
    * Plugin entries are resolved once per operation from this instance context.
    * Per-call plugin overrides are intentionally not part of the public API.

package/src/structures/ITtscCompilerResult.ts

@@ -34,6 +34,11 @@ export namespace ITtscCompilerResult {
      */
     type: "success";
 
+    /**
+     * Non-fatal diagnostics reported during compilation.
+     */
+    diagnostics?: ITtscCompilerDiagnostic[];
+
     /**
      * The generated compiler output.
      *

package/src/structures/ITtscCompilerTransformation.ts

@@ -19,6 +19,9 @@ export namespace ITtscCompilerTransformation {
     /** Indicates that transformation completed without diagnostics. */
     type: "success";
 
+    /** Non-fatal diagnostics reported during transformation. */
+    diagnostics?: ITtscCompilerDiagnostic[];
+
     /** Transformed TypeScript source text keyed by project file path. */
     typescript: Record<string, string>;
   }

package/src/structures/ITtscPluginFactoryContext.ts

@@ -43,10 +43,13 @@ export interface ITtscPluginFactoryContext<T = ITtscProjectPluginConfig> {
   plugin: T;
 
   /**
-   * Directory containing the resolved tsconfig/jsconfig.
+   * Project root used as the native plugin working directory and package
+   * discovery base.
    *
-   * Relative plugin module specifiers and plugin source paths are resolved from
-   * this directory, matching TypeScript plugin config behavior.
+   * By default this is the directory containing the resolved tsconfig/jsconfig.
+   * Callers may override it when a wrapper config lives outside the project.
+   * Relative `source` paths returned by a plugin descriptor resolve from this
+   * directory.
    */
   projectRoot: string;