ttsc 0.12.3 → 0.13.0

package/src/launcher/internal/runTtsx.ts

@@ -2,9 +2,24 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 
+import {
+  getBoolean,
+  getNumber,
+  getString,
+  parseFlags,
+} from "../../flags/parser";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
-
+import { resolveCacheDir } from "./resolveCacheDir";
+
+/**
+ * CLI entry point for `ttsx`. Type-checks the owning project via tsgo, emits
+ * JavaScript to a PID-isolated temp directory, rewrites ESM specifiers when
+ * needed, and executes the compiled entry with the current Node.js runtime.
+ *
+ * @param argv - Command-line arguments (defaults to `process.argv.slice(2)`).
+ * @returns The child-process exit code, or `2` on a ttsx-level error.
+ */
 export function runTtsx(
   argv: readonly string[] = process.argv.slice(2),
 ): number {
@@ -39,8 +54,20 @@ function run(argv: readonly string[]): number {
   const prepared = prepareExecution(entry, {
     binary: parsed.binary,
     cacheDir: resolveCacheDir(cwd, parsed.cacheDir),
+    checkers: parsed.checkers,
     cwd,
+    passthrough: parsed.tsgoFlags,
+    // `--no-plugins` builds the entry's owning project with plugin
+    // discovery and loading disabled. ttsc's own config loaders use it
+    // when they evaluate a `*.config.ts` through ttsx: that build only
+    // needs to type-check and run the config file, so loading the host
+    // project's transform/check plugins (`@nestia/core`, `typia`, …)
+    // would be both wasteful and wrong — those plugins impose project
+    // requirements (e.g. `strict` mode) the ephemeral config-loader
+    // tsconfig deliberately does not satisfy.
+    plugins: parsed.noPlugins ? false : undefined,
     project: parsed.project,
+    singleThreaded: parsed.singleThreaded,
   });
   return runPreparedEntry(parsed, prepared, cwd);
 }
@@ -53,82 +80,108 @@ function formatError(error: unknown): string {
 }
 
 function parseCLI(argv: readonly string[]) {
-  const preload: string[] = [];
-  const passthroughIndex = argv.indexOf("--");
-  const head =
-    passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
-  const passthrough =
-    passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
-
-  let binary: string | undefined;
-  let cacheDir: string | undefined;
-  let cwd: string | undefined;
-  let entry: string | undefined;
-  let project: string | undefined;
-
-  while (head.length !== 0) {
-    const current = head.shift()!;
-    if (entry) {
-      passthrough.push(current, ...head);
-      break;
-    }
-    switch (current) {
-      case "-h":
-      case "--help":
-        return "help";
-      case "-v":
-      case "--version":
-        return "version";
-      case "-P":
-      case "--project":
-        project = takeValue(current, head);
-        break;
-      case "--cwd":
-        cwd = takeValue(current, head);
-        break;
-      case "--cache-dir":
-        cacheDir = takeValue(current, head);
-        break;
-      case "-r":
-      case "--require":
-        preload.push(takeValue(current, head));
-        break;
-      case "--binary":
-        binary = takeValue(current, head);
-        break;
-      default:
-        if (current.startsWith("--project=")) {
-          project = current.slice("--project=".length);
-        } else if (current.startsWith("--cwd=")) {
-          cwd = current.slice("--cwd=".length);
-        } else if (current.startsWith("--cache-dir=")) {
-          cacheDir = current.slice("--cache-dir=".length);
-        } else if (current.startsWith("--binary=")) {
-          binary = current.slice("--binary=".length);
-        } else if (current.startsWith("-")) {
-          throw new Error(`ttsx: unknown option ${current}`);
-        } else {
-          entry = current;
-        }
-        break;
-    }
-  }
+  // ttsx accepts ttsc-style flags plus its own `--no-plugins` / `--require`.
+  // The shared schema engine recognises both; the engine returns positional
+  // tokens (entry file + flag values that aren't `.ts`) and a passthrough
+  // list mirroring the pre-schema behaviour.
+  //
+  // Order pin: ttsx accepts `-P` as an alias for `--project`. The schema
+  // declares `-p` for ttsc; ttsx's lowercase shape would collide on `-p`
+  // → `--tsconfig`, so the legacy `-P` (uppercase) is treated as `--project`
+  // via a manual rewrite before the engine sees argv. We preserve the
+  // historical behaviour and emit a structural error otherwise.
+  const rewritten = argv.map((token) =>
+    token === "-P"
+      ? "--project"
+      : token.startsWith("-P=")
+        ? `--project=${token.slice("-P=".length)}`
+        : token,
+  );
+  // Terminal flags (--help / --version) short-circuit before parsing so
+  // ttsx prints help text even when the entry file is missing.
+  for (const token of rewritten) {
+    if (token === "-h" || token === "--help") return "help" as const;
+    if (token === "-v" || token === "--version") return "version" as const;
+  }
+  const result = parseFlags({
+    argv: rewritten,
+    errorPrefix: "ttsx:",
+    forwardAfterFirstPositional: true,
+    honorDoubleDashSeparator: true,
+    subcommand: "ttsx",
+  });
 
-  if (!entry) {
+  const entry = result.positional.find(looksLikeEntryFile);
+  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),
+  );
+  const postEntryArgs: string[] = [...result.tail];
+
+  const preload: string[] = [];
+  // `--require` accepts repeated values; the schema engine writes the
+  // LAST one into `values`, so reconstruct the full list by scanning the
+  // raw argv. Mirrors the legacy parser's `preload.push(takeValue(...))`
+  // behaviour.
+  //
+  // Stop the rescue scan at the first token that begins tail mode —
+  // either the entry file or the `--` separator. Without this guard,
+  // `ttsx entry.ts -r preload.cjs` would BOTH preload `preload.cjs` AND
+  // forward `-r preload.cjs` to the entry's argv, double-effecting the
+  // module load. The schema engine already routes post-entry tokens to
+  // `result.tail`; the rescue scan must respect the same boundary.
+  const scanEnd = rewritten.findIndex(
+    (token) => looksLikeEntryFile(token) || token === "--",
+  );
+  const scanLimit = scanEnd === -1 ? rewritten.length : scanEnd;
+  for (let i = 0; i < scanLimit; i += 1) {
+    const token = rewritten[i]!;
+    if (token === "-r" || token === "--require") {
+      const value = rewritten[i + 1];
+      if (value !== undefined && !value.startsWith("-")) {
+        preload.push(value);
+        i += 1;
+      }
+    } else if (token.startsWith("--require=")) {
+      preload.push(token.slice("--require=".length));
+    }
+  }
 
   return {
-    binary,
-    cacheDir,
-    cwd,
+    binary: getString(result, "--binary"),
+    cacheDir: getString(result, "--cache-dir"),
+    checkers: getNumber(result, "--checkers"),
+    cwd: getString(result, "--cwd"),
     entry,
-    passthrough,
+    noPlugins: getBoolean(result, "--no-plugins") === true,
+    passthrough: postEntryArgs,
     preload,
-    project,
+    project: getString(result, "--tsconfig"),
+    singleThreaded: getBoolean(result, "--singleThreaded") === true,
+    tsgoFlags: [...result.passthrough, ...preEntryValues],
   };
 }
 
+/**
+ * Report whether a bare CLI token is the TypeScript entry file rather than a
+ * forwarded flag's value. ttsx runs a TypeScript entrypoint, so only a token
+ * with a TypeScript source extension is treated as the entry.
+ */
+function looksLikeEntryFile(token: string): boolean {
+  return [".ts", ".tsx", ".mts", ".cts"].some((ext) => token.endsWith(ext));
+}
+
 function printHelp(): void {
   process.stdout.write(
     [
@@ -142,10 +195,16 @@ function printHelp(): void {
       "  --cwd <dir>            Resolve entry/project relative to this directory",
       "  --cache-dir <dir>      Override the runner and source-plugin cache root",
       "  --binary <path>        Use an explicit tsgo binary",
+      "  --no-plugins           Build the project without ttsc plugins",
       "  -r, --require <module> Preload a module before the entrypoint",
+      "  --singleThreaded       Run TypeScript-Go single-threaded (one checker)",
+      "  --checkers <n>         Type-checker pool size (default: TypeScript-Go's)",
       "  -h, --help             Show this help",
       "  -v, --version          Print the runner version",
       "",
+      "  Any other flag before the entry is forwarded to tsgo, so options like",
+      "  --strict apply to the type-check (e.g. ttsx --strict src/index.ts).",
+      "",
       "Examples:",
       "  ttsx src/index.ts",
       "  ttsx --project tsconfig.json src/index.ts -- --port 3000",
@@ -172,21 +231,6 @@ function isRelativeSpecifier(specifier: string): boolean {
   );
 }
 
-function resolveCacheDir(cwd: string, cacheDir?: string): string | undefined {
-  if (!cacheDir) {
-    return undefined;
-  }
-  return path.isAbsolute(cacheDir) ? cacheDir : path.resolve(cwd, cacheDir);
-}
-
-function takeValue(flag: string, rest: string[]): string {
-  const value = rest.shift();
-  if (!value) {
-    throw new Error(`ttsx: ${flag} requires a value`);
-  }
-  return value;
-}
-
 function runPreparedEntry(
   parsed: Exclude<ReturnType<typeof parseCLI>, "help" | "version">,
   execution: ReturnType<typeof prepareExecution>,
@@ -222,6 +266,12 @@ function runPreparedEntry(
   return result.status ?? 1;
 }
 
+/**
+ * Walk every `.js`/`.mjs`/`.cjs` file in `root` and rewrite bare relative
+ * specifiers (e.g. `"./foo"`) to include the resolved file extension so Node
+ * can load them with `--input-type=module`. Files that did not change are not
+ * written back.
+ */
 function rewriteEsmSpecifiers(root: string): void {
   const stack = [root];
   while (stack.length !== 0) {
@@ -431,26 +481,37 @@ function findTemplateExpressionEnd(
   return null;
 }
 
+/**
+ * Append or fix a file extension on a relative specifier so that Node's ESM
+ * loader can resolve it. The resolution order mirrors Node's own algorithm:
+ * exact file match → directory index → `.js` fallback. Non-relative specifiers
+ * and already-extensioned paths are returned unchanged.
+ */
 function withResolvableExtension(fromFile: string, specifier: string): string {
   if (!specifier.startsWith(".")) {
+    // Bare specifiers (packages, builtins) need no rewriting.
     return specifier;
   }
   if (/\.(?:[cm]?js|json|node)$/i.test(specifier)) {
+    // Already has a concrete extension the loader understands.
     return specifier;
   }
   const [pathname, suffix = ""] = splitSpecifierSuffix(specifier);
   const fromDir = path.dirname(fromFile);
+  // 1. Try the specifier as a file path with each JS extension.
   for (const extension of [".js", ".mjs", ".cjs"]) {
     if (fs.existsSync(path.resolve(fromDir, pathname + extension))) {
       return pathname + extension + suffix;
     }
   }
+  // 2. Try interpreting it as a directory with an index file.
   const directory = pathname.replace(/\/+$/, "");
   for (const extension of [".js", ".mjs", ".cjs"]) {
     if (fs.existsSync(path.resolve(fromDir, directory, "index" + extension))) {
       return `${directory}/index${extension}${suffix}`;
     }
   }
+  // 3. Last resort: append `.js` and let Node surface the error if it's wrong.
   return `${specifier}.js`;
 }
 
@@ -553,6 +614,12 @@ function skipRegex(input: string, start: number): number {
   return input.length;
 }
 
+/**
+ * Determine whether the `/` at `start` opens a regex literal rather than a
+ * division operator. This is a conservative approximation: check the preceding
+ * non-whitespace token — if it is an operator character or a keyword that must
+ * be followed by an expression, we assume regex.
+ */
 function looksLikeRegexStart(input: string, start: number): boolean {
   let i = start - 1;
   while (i >= 0 && /\s/.test(input[i]!)) {

package/src/plugin/internal/buildSourcePlugin.ts

@@ -5,6 +5,8 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 
+import { findNearestGoMod } from "../../compiler/internal/paths";
+
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
 const TTSC_GO_MODULE_PATH = "github.com/samchon/ttsc/packages/ttsc";
 const TSGO_GO_MODULE_PATH = "github.com/microsoft/typescript-go";
@@ -397,20 +399,6 @@ function resolveSourceBuildTarget(opts: {
   };
 }
 
-function findNearestGoMod(from: string, maxDepth: number): string | null {
-  let current = path.resolve(from);
-  let depth = 0;
-  while (true) {
-    const candidate = path.join(current, "go.mod");
-    if (fs.existsSync(candidate)) return candidate;
-    if (depth >= maxDepth) return null;
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-    depth += 1;
-  }
-}
-
 function materializeScratchDir(source: string, scratch: string): void {
   fs.mkdirSync(scratch, { recursive: true });
   fs.cpSync(source, scratch, {
@@ -768,6 +756,19 @@ function walkForGoMod(dir: string, out: string[]): void {
   }
 }
 
+/**
+ * Resolve the directory where compiled plugin binaries are cached.
+ *
+ * Priority order:
+ *
+ * 1. `cacheDir` option (resolved relative to `projectRoot`).
+ * 2. `TTSC_CACHE_DIR` environment variable.
+ * 3. Platform-specific global user cache (XDG / AppData / Library/Caches).
+ *
+ * When falling back to the global cache, a GC pass is triggered
+ * opportunistically to evict old or oversized entries before the cache is
+ * used.
+ */
 export function resolvePluginCacheRoot(
   projectRoot: string,
   cacheDir?: string,
@@ -783,6 +784,13 @@ export function resolvePluginCacheRoot(
   return root;
 }
 
+/**
+ * Return the absolute path to the global plugin binary cache root.
+ *
+ * The path follows platform conventions (XDG on Linux, AppData on Windows,
+ * Library/Caches on macOS) and does not depend on project-local config. Used by
+ * `ttsc cache clean` to enumerate cache locations.
+ */
 export function resolveGlobalPluginCacheRoot(): string {
   return path.join(
     resolveUserCacheRoot(),
@@ -791,6 +799,13 @@ export function resolveGlobalPluginCacheRoot(): string {
   );
 }
 
+/**
+ * Return all directories that `ttsc cache clean` should wipe for a project.
+ *
+ * Covers three locations where plugin binaries may accumulate: the global user
+ * cache, the project-local `node_modules/.ttsc` cache (legacy), and the
+ * project-local `.ttsc` cache.
+ */
 export function defaultPluginCacheCleanTargets(projectRoot: string): string[] {
   return [
     resolveGlobalPluginCacheRoot(),
@@ -878,6 +893,17 @@ function resolveGoCompiler(): string {
   return "go";
 }
 
+/**
+ * Compute a deterministic SHA-256 cache key for a plugin build.
+ *
+ * The key covers every input that can produce a different binary: ttsc/tsgo
+ * versions, platform, entry package, Go compiler identity, Go build environment
+ * variables, overlay module sources, plugin source files, and contributor
+ * source files. Contributors are sorted by name so declaration order does not
+ * affect the key.
+ *
+ * Exposed for testing and for the `ttsc cache` CLI command.
+ */
 export function computeCacheKey(inputs: {
   contributors?: readonly ITtscBuildContributor[];
   dir: string;

package/src/plugin/internal/loadProjectPlugins.ts

@@ -2,9 +2,10 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 
+import { findNearestGoMod } from "../../compiler/internal/paths";
 import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
-import type { ITtscPluginContributor } from "../../structures/ITtscPluginContributor";
 import type { ITtscPlugin } from "../../structures/ITtscPlugin";
+import type { ITtscPluginContributor } from "../../structures/ITtscPluginContributor";
 import type { ITtscPluginFactoryContext } from "../../structures/ITtscPluginFactoryContext";
 import type { ITtscProjectPluginConfig } from "../../structures/ITtscProjectPluginConfig";
 import type { TtscPluginStage } from "../../structures/TtscPluginStage";
@@ -30,6 +31,24 @@ type PackageManifest = {
   ttsc?: unknown;
 };
 
+/**
+ * Resolve, load, and build all native plugin sidecars for a TypeScript project.
+ *
+ * Reads the project config, discovers plugin entries (from tsconfig and package
+ * auto-discovery), validates and composes their descriptors, then invokes
+ * `buildSourcePlugin` to compile each Go source package into a cached binary.
+ * Returns the ordered set of loaded native plugins alongside the parsed project
+ * config.
+ *
+ * @param options.binary - Absolute path to the ttsc native helper binary.
+ * @param options.cacheDir - Override the plugin binary cache directory.
+ * @param options.cwd - Working directory for resolving relative paths.
+ * @param options.entries - Explicit plugin entries; `false` disables all
+ *   plugins (skips both tsconfig entries and package auto-discovery).
+ * @param options.file - Path to the tsconfig/jsconfig file.
+ * @param options.projectRoot - Override the project root directory.
+ * @param options.tsconfig - Alias for `file`.
+ */
 export function loadProjectPlugins(options: {
   binary: string;
   cacheDir?: string;
@@ -85,21 +104,31 @@ export function loadProjectPlugins(options: {
     validatePluginSource(plugin);
     const contributors = validatePluginContributors(plugin);
     const source = resolvePluginSource(plugin.source, context.projectRoot);
-    const kind = resolveNativeSourceKind(source, plugin, entries[index]!.config, index);
+    const kind = resolveNativeSourceKind(
+      source,
+      plugin,
+      entries[index]!.config,
+      index,
+    );
     if (kind === "linked" && stage !== "transform") {
       throw new Error(
         `ttsc: plugin "${pluginLabel(plugin, entries[index]!.config, index)}" source is a linked Go package, but only transform-stage plugins can be linked into a compiler host`,
       );
     }
     const linkedContributorName =
-      kind === "linked" ? `linked_${String(index).padStart(6, "0")}` : undefined;
+      kind === "linked"
+        ? `linked_${String(index).padStart(6, "0")}`
+        : undefined;
     return {
+      capabilities: plugin.capabilities,
       contributors,
       config: entries[index]!.config,
       kind,
       label: pluginLabel(plugin, entries[index]!.config, index),
       linkedContributorName,
       name: plugin.name,
+      reportsTypeScriptDiagnostics:
+        plugin.reportsTypeScriptDiagnostics === true,
       source,
       stage,
     };
@@ -170,10 +199,12 @@ export function loadProjectPlugins(options: {
     }
     return {
       binary,
+      capabilities: record.capabilities,
       config: record.config,
       contributors: record.contributors,
       kind: record.kind,
       name: record.name,
+      reportsTypeScriptDiagnostics: record.reportsTypeScriptDiagnostics,
       source: record.source,
       stage: record.stage,
     };
@@ -261,6 +292,15 @@ function composePluginSources(
     return {
       ...plugin,
       source: aggregate.plugin.source,
+      contributors: aggregate.plugin.contributors,
+      // The composed plugin's runtime BINARY is the aggregate's binary,
+      // so the CLI surface (which flags the sidecar parses) is the
+      // aggregate's. Inherit `capabilities` from the aggregate so a
+      // capability the aggregate declares — e.g. threadingArgs — does
+      // not get silently dropped just because the composed entry's own
+      // descriptor omitted it. If the aggregate did not set capabilities
+      // we keep the composed plugin's own as a fallback.
+      capabilities: aggregate.plugin.capabilities ?? plugin.capabilities,
     };
   });
 }
@@ -276,6 +316,14 @@ function matchesPluginAlias(
   );
 }
 
+/**
+ * Return `true` when the project has at least one enabled plugin entry.
+ *
+ * Used by callers that need to skip plugin-specific work when no plugins are
+ * configured, without paying the full cost of `loadProjectPlugins`.
+ *
+ * @param entries - Explicit entries; `false` always returns `false`.
+ */
 export function hasProjectPluginEntries(
   project: ITtscParsedProjectConfig,
   entries?: readonly ITtscProjectPluginConfig[] | false,
@@ -510,38 +558,72 @@ function loadPluginEntry(
   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, baseDir);
-  const mod = require(request) as {
-    createTtscPlugin?: TtscPluginFactory;
-    default?: ITtscPlugin | TtscPluginFactory;
-  } & Partial<Record<"plugin", ITtscPlugin | TtscPluginFactory>>;
-  const candidate =
-    mod.createTtscPlugin ??
-    mod.default ??
-    mod.plugin ??
-    (mod as unknown as ITtscPlugin | TtscPluginFactory);
-  if (typeof candidate === "function") {
-    const plugin = candidate(context);
-    if (!isTtscPlugin(plugin)) {
+  return withPluginLoaderEnv(() => {
+    const specifier = entry.transform;
+    if (typeof specifier !== "string" || specifier.length === 0) {
       throw new Error(
-        `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+        `ttsc: plugin entry is missing a string "transform" field`,
       );
     }
-    rejectJsTransformFunctions(specifier, plugin);
-    return plugin;
+
+    const request = resolvePluginRequest(specifier, baseDir);
+    const mod = require(request) as {
+      createTtscPlugin?: TtscPluginFactory;
+      default?: ITtscPlugin | TtscPluginFactory;
+    } & Partial<Record<"plugin", ITtscPlugin | TtscPluginFactory>>;
+    const candidate =
+      mod.createTtscPlugin ??
+      mod.default ??
+      mod.plugin ??
+      (mod as unknown as ITtscPlugin | TtscPluginFactory);
+    if (typeof candidate === "function") {
+      const plugin = candidate(context);
+      if (!isTtscPlugin(plugin)) {
+        throw new Error(
+          `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+        );
+      }
+      rejectJsTransformFunctions(specifier, plugin);
+      return plugin;
+    }
+    if (isTtscPlugin(candidate)) {
+      rejectJsTransformFunctions(specifier, candidate);
+      return candidate;
+    }
+    throw new Error(
+      `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
+    );
+  });
+}
+
+function withPluginLoaderEnv<T>(run: () => T): T {
+  const previousNode = process.env.TTSC_NODE_BINARY;
+  const previousTtsx = process.env.TTSC_TTSX_BINARY;
+  process.env.TTSC_NODE_BINARY ??= process.execPath;
+  process.env.TTSC_TTSX_BINARY ??= path.join(
+    __dirname,
+    "..",
+    "..",
+    "launcher",
+    "ttsx.js",
+  );
+  try {
+    return run();
+  } finally {
+    restoreEnv("TTSC_NODE_BINARY", previousNode);
+    restoreEnv("TTSC_TTSX_BINARY", previousTtsx);
   }
-  if (isTtscPlugin(candidate)) {
-    rejectJsTransformFunctions(specifier, candidate);
-    return candidate;
+}
+
+function restoreEnv(
+  key: "TTSC_NODE_BINARY" | "TTSC_TTSX_BINARY",
+  value: string | undefined,
+): void {
+  if (value === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = value;
   }
-  throw new Error(
-    `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
-  );
 }
 
 function isTtscPlugin(value: unknown): value is ITtscPlugin {
@@ -610,7 +692,10 @@ function resolveNativeSourceKind(
   config: ITtscProjectPluginConfig,
   index: number,
 ): "executable" | "linked" {
-  const packageDir = resolveGoPackageDir(source, pluginLabel(plugin, config, index));
+  const packageDir = resolveGoPackageDir(
+    source,
+    pluginLabel(plugin, config, index),
+  );
   if (findNearestGoMod(packageDir, GO_MOD_SEARCH_MAX_DEPTH) === null) {
     throw new Error(
       `ttsc: plugin "${pluginLabel(plugin, config, index)}" source must be inside a Go module with go.mod within ${GO_MOD_SEARCH_MAX_DEPTH} parent directories: ${source}`,
@@ -625,20 +710,6 @@ function resolveNativeSourceKind(
   return packageName === "main" ? "executable" : "linked";
 }
 
-function findNearestGoMod(from: string, maxDepth: number): string | null {
-  let current = path.resolve(from);
-  let depth = 0;
-  while (true) {
-    const candidate = path.join(current, "go.mod");
-    if (fs.existsSync(candidate)) return candidate;
-    if (depth >= maxDepth) return null;
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-    depth += 1;
-  }
-}
-
 function resolveGoPackageDir(source: string, label: string): string {
   if (!fs.existsSync(source)) {
     throw new Error(`ttsc: plugin "${label}" source does not exist: ${source}`);