ttsc 0.8.1 → 0.10.0

package/lib/plugin/internal/buildSourcePlugin.js

@@ -1,101 +1,92 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSourcePlugin = buildSourcePlugin;
+exports.computeCacheKey = computeCacheKey;
 const node_child_process_1 = require("node:child_process");
-const crypto = __importStar(require("node:crypto"));
-const fs = __importStar(require("node:fs"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_module_1 = require("node:module");
-const path = __importStar(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const GO_MOD_SEARCH_MAX_DEPTH = 3;
-const SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "vendor",
-    "lib",
-]);
+const TTSC_GO_MODULE_PATH = "github.com/samchon/ttsc/packages/ttsc";
+const TSGO_GO_MODULE_PATH = "github.com/microsoft/typescript-go";
+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. */
 function buildSourcePlugin(opts) {
     const { dir, entry, source } = resolveSourceBuildTarget(opts);
+    const overlayDirs = opts.overlayDirs ?? findTtscOverlayDirs();
+    const goBinary = resolveGoCompiler();
+    ensureExecutableGoToolchain(goBinary);
     const key = computeCacheKey({
         dir,
         entry,
+        goBinary,
+        overlayDirs,
         ttscVersion: opts.ttscVersion,
         tsgoVersion: opts.tsgoVersion,
     });
     const root = resolvePluginCacheRoot(opts.baseDir, opts.cacheDir);
-    const cacheDir = path.join(root, key);
+    const cacheDir = node_path_1.default.join(root, key);
     const binaryName = process.platform === "win32" ? "plugin.exe" : "plugin";
-    const binaryPath = path.join(cacheDir, binaryName);
-    if (fs.existsSync(binaryPath)) {
+    const binaryPath = node_path_1.default.join(cacheDir, binaryName);
+    if (node_fs_1.default.existsSync(binaryPath)) {
         return binaryPath;
     }
-    fs.mkdirSync(cacheDir, { recursive: true });
+    node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
     const label = opts.label ?? "source plugin";
     if (opts.quiet !== true) {
         process.stderr.write(`ttsc: building ${label} "${opts.pluginName}" from ${source} (this runs once per cache key)\n`);
     }
-    const scratchDir = path.join(root, `scratch-${key}-${process.pid}-${Date.now()}`);
+    const scratchDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), `ttsc-plugin-${key}-`));
     try {
         materializeScratchDir(dir, scratchDir);
-        writeGoWork(scratchDir, opts.overlayDirs ?? findTtscOverlayDirs());
+        writeGoWork(scratchDir, overlayDirs, goBinary, opts.pluginName);
         const scratchBinaryName = process.platform === "win32" ? ".ttsc-plugin.exe" : ".ttsc-plugin";
-        runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName);
-        const builtBinary = path.join(scratchDir, scratchBinaryName);
-        fs.renameSync(builtBinary, binaryPath);
-        if (process.platform !== "win32") {
-            fs.chmodSync(binaryPath, 0o755);
-        }
+        runGoBuild(scratchDir, entry, scratchBinaryName, opts.pluginName, goBinary);
+        const builtBinary = node_path_1.default.join(scratchDir, scratchBinaryName);
+        publishBuiltBinary(builtBinary, binaryPath);
         return binaryPath;
     }
     finally {
-        fs.rmSync(scratchDir, { recursive: true, force: true });
+        node_fs_1.default.rmSync(scratchDir, { recursive: true, force: true });
+    }
+}
+function publishBuiltBinary(builtBinary, binaryPath) {
+    const pending = `${binaryPath}.${process.pid}.${Date.now()}-${Math.random()
+        .toString(16)
+        .slice(2)}.tmp`;
+    node_fs_1.default.copyFileSync(builtBinary, pending);
+    if (process.platform !== "win32") {
+        node_fs_1.default.chmodSync(pending, 0o755);
+    }
+    try {
+        node_fs_1.default.renameSync(pending, binaryPath);
+    }
+    catch (error) {
+        node_fs_1.default.rmSync(pending, { force: true });
+        const code = error.code;
+        if ((code === "EEXIST" || code === "EPERM" || code === "EACCES") &&
+            node_fs_1.default.existsSync(binaryPath)) {
+            return;
+        }
+        throw error;
     }
 }
 function resolveSourceBuildTarget(opts) {
-    const source = path.isAbsolute(opts.source)
+    const source = node_path_1.default.isAbsolute(opts.source)
         ? opts.source
-        : path.resolve(opts.baseDir, opts.source);
-    if (!fs.existsSync(source)) {
+        : node_path_1.default.resolve(opts.baseDir, opts.source);
+    if (!node_fs_1.default.existsSync(source)) {
         throw new Error(`ttsc: plugin "${opts.pluginName}" source does not exist: ${source}`);
     }
-    const stat = fs.statSync(source);
-    const packageDir = stat.isFile() && path.basename(source) === "go.mod"
-        ? path.dirname(source)
+    const stat = node_fs_1.default.statSync(source);
+    const packageDir = stat.isFile() && node_path_1.default.basename(source) === "go.mod"
+        ? node_path_1.default.dirname(source)
         : stat.isDirectory()
             ? source
             : null;
@@ -106,8 +97,8 @@ function resolveSourceBuildTarget(opts) {
     if (goMod === null) {
         throw new Error(`ttsc: plugin "${opts.pluginName}" source must be inside a Go module with go.mod within ${GO_MOD_SEARCH_MAX_DEPTH} parent directories: ${source}`);
     }
-    const dir = path.dirname(goMod);
-    const rel = path.relative(dir, packageDir).replace(/\\/g, "/");
+    const dir = node_path_1.default.dirname(goMod);
+    const rel = node_path_1.default.relative(dir, packageDir).replace(/\\/g, "/");
     return {
         dir,
         entry: rel === "" ? "." : `./${rel}`,
@@ -115,15 +106,15 @@ function resolveSourceBuildTarget(opts) {
     };
 }
 function findNearestGoMod(from, maxDepth) {
-    let current = path.resolve(from);
+    let current = node_path_1.default.resolve(from);
     let depth = 0;
     while (true) {
-        const candidate = path.join(current, "go.mod");
-        if (fs.existsSync(candidate))
+        const candidate = node_path_1.default.join(current, "go.mod");
+        if (node_fs_1.default.existsSync(candidate))
             return candidate;
         if (depth >= maxDepth)
             return null;
-        const parent = path.dirname(current);
+        const parent = node_path_1.default.dirname(current);
         if (parent === current)
             return null;
         current = parent;
@@ -131,52 +122,139 @@ function findNearestGoMod(from, maxDepth) {
     }
 }
 function materializeScratchDir(source, scratch) {
-    fs.mkdirSync(scratch, { recursive: true });
-    fs.cpSync(source, scratch, {
+    node_fs_1.default.mkdirSync(scratch, { recursive: true });
+    node_fs_1.default.cpSync(source, scratch, {
         recursive: true,
         filter: (src) => {
-            const base = path.basename(src);
-            if (SKIP_DIRS.has(base))
+            const base = node_path_1.default.basename(src);
+            if (shouldPruneDirectory(base))
                 return false;
-            if (base === "go.work" || base === "go.work.sum")
+            if (shouldOmitSourceFile(base))
                 return false;
             return true;
         },
     });
 }
-function writeGoWork(scratchDir, useDirs) {
+function writeGoWork(scratchDir, useDirs, goBinary, pluginName) {
+    const goModReader = createGoModReader(goBinary, pluginName);
+    validateSourceReplacements(scratchDir, useDirs, goModReader, pluginName);
     const useLines = ["\t."];
     for (const dir of useDirs) {
         useLines.push(`\t${dir.replace(/\\/g, "/")}`);
     }
-    const replaceLines = sourceBuildWorkspaceReplacements(useDirs);
+    const replaceLines = sourceBuildWorkspaceReplacements(useDirs, goModReader);
     const replaceBlock = replaceLines.length === 0 ? "" : `\n\n${replaceLines.join("\n")}\n`;
     const goWork = `go 1.26\n\nuse (\n${useLines.join("\n")}\n)${replaceBlock}`;
-    fs.writeFileSync(path.join(scratchDir, "go.work"), goWork, "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(scratchDir, "go.work"), goWork, "utf8");
+}
+function validateSourceReplacements(scratchDir, useDirs, goModReader, pluginName) {
+    const sourceInfo = goModReader.read(scratchDir);
+    if (sourceInfo.modulePath === TTSC_GO_MODULE_PATH) {
+        return;
+    }
+    const sourceReplacements = sourceInfo.replacements;
+    if (sourceReplacements.length === 0) {
+        return;
+    }
+    const overlayModules = collectOverlayModulePaths(useDirs, goModReader);
+    for (const replacement of sourceReplacements) {
+        if (isTtscManagedModulePath(replacement.modulePath) ||
+            overlayModules.has(replacement.modulePath)) {
+            throw new Error(`ttsc: plugin "${pluginName}" go.mod replaces ttsc-managed module ` +
+                `${JSON.stringify(replacement.modulePath)}. Remove this replace directive; ` +
+                `ttsc supplies its own compiler and shim modules while building source plugins.`);
+        }
+    }
 }
-function sourceBuildWorkspaceReplacements(useDirs) {
-    const ttscRoot = useDirs.find((dir) => hasModulePath(dir, "github.com/samchon/ttsc/packages/ttsc"));
+function sourceBuildWorkspaceReplacements(useDirs, goModReader) {
+    const ttscRoot = useDirs.find((dir) => goModReader.read(dir).modulePath === TTSC_GO_MODULE_PATH);
     if (!ttscRoot) {
         return [];
     }
     return [
-        `replace github.com/samchon/ttsc/packages/ttsc v0.0.0 => ${ttscRoot.replace(/\\/g, "/")}`,
+        `replace ${TTSC_GO_MODULE_PATH} v0.0.0 => ${ttscRoot.replace(/\\/g, "/")}`,
     ];
 }
-function hasModulePath(dir, modulePath) {
+function createGoModReader(goBinary, pluginName) {
+    const cache = new Map();
+    return {
+        read(dir) {
+            const resolved = node_path_1.default.resolve(dir);
+            const cached = cache.get(resolved);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const info = readGoModInfo(resolved, goBinary, pluginName);
+            cache.set(resolved, info);
+            return info;
+        },
+    };
+}
+function readGoModInfo(dir, goBinary, pluginName) {
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(dir, "go.mod"))) {
+        return emptyGoModInfo();
+    }
+    const result = (0, node_child_process_1.spawnSync)(goBinary, ["mod", "edit", "-json"], {
+        cwd: dir,
+        encoding: "utf8",
+        env: goBuildEnv(goBinary),
+        maxBuffer: 1024 * 1024 * 16,
+        windowsHide: true,
+    });
+    if (result.error) {
+        if (result.error.code === "ENOENT") {
+            throw new Error(goToolchainNotFoundMessage(pluginName));
+        }
+        throw new Error(`ttsc: reading go.mod for plugin "${pluginName}" failed to spawn ${goBinary}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`ttsc: reading go.mod for plugin "${pluginName}" failed:\n${result.stderr || result.stdout}`);
+    }
+    let json;
     try {
-        const goMod = fs.readFileSync(path.join(dir, "go.mod"), "utf8");
-        return new RegExp(`^module\\s+${escapeRegExp(modulePath)}\\s*$`, "m").test(goMod);
+        json = JSON.parse(result.stdout);
     }
-    catch {
-        return false;
+    catch (error) {
+        throw new Error(`ttsc: reading go.mod for plugin "${pluginName}" returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
+    return {
+        modulePath: json.Module?.Path ?? null,
+        replacements: (json.Replace ?? [])
+            .map(jsonReplacementToGoModReplacement)
+            .filter((replacement) => replacement !== null),
+    };
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function emptyGoModInfo() {
+    return {
+        modulePath: null,
+        replacements: [],
+    };
 }
-function runGoBuild(cwd, entry, binaryName, pluginName) {
-    const goBinary = resolveGoCompiler();
+function jsonReplacementToGoModReplacement(replacement) {
+    const modulePath = replacement.Old?.Path;
+    if (modulePath === undefined) {
+        return null;
+    }
+    return {
+        modulePath,
+    };
+}
+function collectOverlayModulePaths(dirs, goModReader) {
+    const out = new Set();
+    for (const dir of dirs) {
+        const modulePath = goModReader.read(dir).modulePath;
+        if (modulePath !== null) {
+            out.add(modulePath);
+        }
+    }
+    return out;
+}
+function isTtscManagedModulePath(modulePath) {
+    return (modulePath === TTSC_GO_MODULE_PATH ||
+        modulePath === TSGO_GO_MODULE_PATH ||
+        modulePath.startsWith("github.com/microsoft/typescript-go/shim/"));
+}
+function runGoBuild(cwd, entry, binaryName, pluginName, goBinary) {
     ensureExecutableGoToolchain(goBinary);
     const result = (0, node_child_process_1.spawnSync)(goBinary, ["build", "-o", binaryName, entry], {
         cwd,
@@ -187,9 +265,7 @@ function runGoBuild(cwd, entry, binaryName, pluginName) {
     });
     if (result.error) {
         if (result.error.code === "ENOENT") {
-            throw new Error(`ttsc: building plugin "${pluginName}" failed because the Go toolchain was not found. ` +
-                `Reinstall ttsc with optional dependencies so the bundled Go compiler is present, ` +
-                `or set TTSC_GO_BINARY to an absolute path.`);
+            throw new Error(goToolchainNotFoundMessage(pluginName));
         }
         throw new Error(`ttsc: building plugin "${pluginName}" failed to spawn ${goBinary}: ${result.error.message}`);
     }
@@ -197,6 +273,11 @@ function runGoBuild(cwd, entry, binaryName, pluginName) {
         throw new Error(`ttsc: building plugin "${pluginName}" via "go build" failed:\n${result.stderr || result.stdout}`);
     }
 }
+function goToolchainNotFoundMessage(pluginName) {
+    return (`ttsc: building plugin "${pluginName}" failed because the Go toolchain was not found. ` +
+        `Reinstall ttsc with optional dependencies so the bundled Go compiler is present, ` +
+        `or set TTSC_GO_BINARY to an absolute path.`);
+}
 function goBuildEnv(goBinary) {
     const env = { ...process.env };
     const goRoot = inferGoRoot(goBinary);
@@ -206,32 +287,32 @@ function goBuildEnv(goBinary) {
     return env;
 }
 function inferGoRoot(goBinary) {
-    if (!path.isAbsolute(goBinary))
+    if (!node_path_1.default.isAbsolute(goBinary))
         return null;
-    const binDir = path.dirname(goBinary);
-    if (path.basename(binDir) !== "bin")
+    const binDir = node_path_1.default.dirname(goBinary);
+    if (node_path_1.default.basename(binDir) !== "bin")
         return null;
-    const goRoot = path.dirname(binDir);
-    return fs.existsSync(path.join(goRoot, "src", "runtime")) ? goRoot : null;
+    const goRoot = node_path_1.default.dirname(binDir);
+    return node_fs_1.default.existsSync(node_path_1.default.join(goRoot, "src", "runtime")) ? goRoot : null;
 }
 function ensureExecutableGoToolchain(goBinary) {
     if (process.platform === "win32")
         return;
-    if (!path.isAbsolute(goBinary) || !fs.existsSync(goBinary))
+    if (!node_path_1.default.isAbsolute(goBinary) || !node_fs_1.default.existsSync(goBinary))
         return;
     try {
-        fs.chmodSync(goBinary, 0o755);
+        node_fs_1.default.chmodSync(goBinary, 0o755);
         const goRoot = inferGoRoot(goBinary);
         if (!goRoot)
             return;
-        const gofmt = path.join(path.dirname(goBinary), "gofmt");
-        if (fs.existsSync(gofmt))
-            fs.chmodSync(gofmt, 0o755);
-        const toolDir = path.join(goRoot, "pkg", "tool");
-        if (!fs.existsSync(toolDir))
+        const gofmt = node_path_1.default.join(node_path_1.default.dirname(goBinary), "gofmt");
+        if (node_fs_1.default.existsSync(gofmt))
+            node_fs_1.default.chmodSync(gofmt, 0o755);
+        const toolDir = node_path_1.default.join(goRoot, "pkg", "tool");
+        if (!node_fs_1.default.existsSync(toolDir))
             return;
         for (const file of walkToolFiles(toolDir)) {
-            fs.chmodSync(file, 0o755);
+            node_fs_1.default.chmodSync(file, 0o755);
         }
     }
     catch {
@@ -242,13 +323,13 @@ function walkToolFiles(dir) {
     const out = [];
     let entries;
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
     }
     catch {
         return out;
     }
     for (const entry of entries) {
-        const file = path.join(dir, entry.name);
+        const file = node_path_1.default.join(dir, entry.name);
         if (entry.isDirectory()) {
             out.push(...walkToolFiles(file));
         }
@@ -259,13 +340,13 @@ function walkToolFiles(dir) {
     return out;
 }
 function findTtscOverlayDirs() {
-    const ttscRoot = path.resolve(__dirname, "..", "..", "..");
+    const ttscRoot = node_path_1.default.resolve(__dirname, "..", "..", "..");
     const dirs = [];
-    if (fs.existsSync(path.join(ttscRoot, "go.mod"))) {
+    if (node_fs_1.default.existsSync(node_path_1.default.join(ttscRoot, "go.mod"))) {
         dirs.push(ttscRoot);
     }
-    const shimRoot = path.join(ttscRoot, "shim");
-    if (fs.existsSync(shimRoot)) {
+    const shimRoot = node_path_1.default.join(ttscRoot, "shim");
+    if (node_fs_1.default.existsSync(shimRoot)) {
         walkForGoMod(shimRoot, dirs);
     }
     dirs.sort();
@@ -274,7 +355,7 @@ function findTtscOverlayDirs() {
 function walkForGoMod(dir, out) {
     let entries;
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
     }
     catch {
         return;
@@ -291,28 +372,28 @@ function walkForGoMod(dir, out) {
     for (const entry of entries) {
         if (!entry.isDirectory())
             continue;
-        if (SKIP_DIRS.has(entry.name))
+        if (shouldPruneDirectory(entry.name))
             continue;
-        walkForGoMod(path.join(dir, entry.name), out);
+        walkForGoMod(node_path_1.default.join(dir, entry.name), out);
     }
 }
 function resolvePluginCacheRoot(projectRoot, cacheDir) {
     if (cacheDir) {
-        return path.resolve(cacheDir, "plugins");
+        return node_path_1.default.resolve(projectRoot, cacheDir, "plugins");
     }
     if (process.env.TTSC_CACHE_DIR) {
-        return path.resolve(process.env.TTSC_CACHE_DIR, "plugins");
+        return node_path_1.default.resolve(process.env.TTSC_CACHE_DIR, "plugins");
     }
-    const root = path.resolve(projectRoot);
-    const nodeModules = path.join(root, "node_modules");
+    const root = node_path_1.default.resolve(projectRoot);
+    const nodeModules = node_path_1.default.join(root, "node_modules");
     if (isDirectory(nodeModules)) {
-        return path.join(nodeModules, ".ttsc", "plugins");
+        return node_path_1.default.join(nodeModules, ".ttsc", "plugins");
     }
-    return path.join(root, ".ttsc", "plugins");
+    return node_path_1.default.join(root, ".ttsc", "plugins");
 }
 function isDirectory(candidate) {
     try {
-        return fs.statSync(candidate).isDirectory();
+        return node_fs_1.default.statSync(candidate).isDirectory();
     }
     catch {
         return false;
@@ -328,30 +409,41 @@ function resolveGoCompiler() {
     catch {
         /* fall through */
     }
-    const platformPackage = path.resolve(__dirname, "..", "..", "..", "..", `ttsc-${process.platform}-${process.arch}`, "bin", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
-    if (fs.existsSync(platformPackage))
+    const platformPackage = node_path_1.default.resolve(__dirname, "..", "..", "..", "..", `ttsc-${process.platform}-${process.arch}`, "bin", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
+    if (node_fs_1.default.existsSync(platformPackage))
         return platformPackage;
-    const local = path.resolve(__dirname, "..", "..", "..", "..", "native", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
-    if (fs.existsSync(local))
+    const local = node_path_1.default.resolve(__dirname, "..", "..", "..", "..", "native", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
+    if (node_fs_1.default.existsSync(local))
         return local;
-    const homeSdk = path.join(process.env.HOME ?? "", "go-sdk", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
-    if (fs.existsSync(homeSdk))
+    const homeSdk = node_path_1.default.join(process.env.HOME ?? "", "go-sdk", "go", "bin", process.platform === "win32" ? "go.exe" : "go");
+    if (node_fs_1.default.existsSync(homeSdk))
         return homeSdk;
     return "go";
 }
 function computeCacheKey(inputs) {
-    const hash = crypto.createHash("sha256");
+    const hash = node_crypto_1.default.createHash("sha256");
     hash.update(`ttsc=${inputs.ttscVersion}\n`);
     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, "/");
-        hash.update(`f=${rel}\n`);
-        hash.update(fs.readFileSync(file));
+    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, label, root) {
+    hash.update(`dir=${label}\n`);
+    for (const file of collectSourceFiles(root)) {
+        const rel = node_path_1.default.relative(root, file).replace(/\\/g, "/");
+        hash.update(`f=${rel}\n`);
+        hash.update(node_fs_1.default.readFileSync(file));
+        hash.update("\n");
+    }
+}
 function collectSourceFiles(root) {
     const out = [];
     walk(root, out);
@@ -361,29 +453,85 @@ function collectSourceFiles(root) {
 function walk(dir, out) {
     let entries;
     try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
     }
     catch {
         return;
     }
     for (const entry of entries) {
-        if (SKIP_DIRS.has(entry.name))
-            continue;
-        const full = path.join(dir, entry.name);
+        const full = node_path_1.default.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) {
+    return PRUNE_DIRS.has(name);
+}
+function shouldOmitSourceFile(name) {
+    return GENERATED_WORKSPACE_FILES.has(name);
+}
 function isHashableFile(name) {
-    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) {
+    const resolved = resolveExecutableIdentityPath(goBinary);
+    const version = (0, node_child_process_1.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 = node_fs_1.default.statSync(resolved);
+        statText = `${stat.size}:${stat.mtimeMs}`;
+    }
+    catch {
+        statText = "missing";
+    }
+    return `${goBinary}:${resolved}:${statText}:${versionText}`;
+}
+function resolveExecutableIdentityPath(binary) {
+    if (node_path_1.default.isAbsolute(binary)) {
+        return resolveRealPath(binary);
+    }
+    if (binary.includes(node_path_1.default.sep)) {
+        return resolveRealPath(node_path_1.default.resolve(binary));
+    }
+    for (const dir of (process.env.PATH ?? "").split(node_path_1.default.delimiter)) {
+        if (dir.length === 0)
+            continue;
+        const candidate = node_path_1.default.join(dir, binary);
+        if (node_fs_1.default.existsSync(candidate)) {
+            return resolveRealPath(candidate);
+        }
+        if (process.platform === "win32") {
+            const executable = `${candidate}.exe`;
+            if (node_fs_1.default.existsSync(executable)) {
+                return resolveRealPath(executable);
+            }
+        }
+    }
+    return binary;
+}
+function resolveRealPath(location) {
+    try {
+        return node_fs_1.default.realpathSync(location);
+    }
+    catch {
+        return location;
+    }
 }
 //# sourceMappingURL=buildSourcePlugin.js.map