ttsc 0.30.3 → 0.31.0

package/lib/plugin/internal/source/GoSourceInputs.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoSourceInputs = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * What of a Go source plugin, and of its toolchain, the build and the cache key
+ * both see.
+ *
+ * The source walk and the cache key must agree on which files count, or an
+ * irrelevant file would bust the cached binary (or a relevant one would not),
+ * and the build must run with the same toolchain environment the key hashed.
+ *
+ * Membership is ttsc's declared snapshot naming policy, not Go dependency
+ * discovery. Excluded entries are neither copied nor hashed, even when Go could
+ * embed them in the original package. File-backed plugin data must use names
+ * and directories included by this policy. Generated workspace files belong to
+ * the scratch build; the caller's excluded workspace bytes are not preserved.
+ *
+ * @evidence contracts/common.md#principled-implementation One policy defines the selected source snapshot and fixed artifact flags so hashing, copying and observers agree on its population; name exclusions do not establish which files a raw Go package could consume.
+ * @evidence contracts/common.md#clear-and-simple-design Source-name predicates and invocation-environment construction are centralized for consumers instead of copying their policies across loaders and watchers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The declared naming exclusions apply uniformly to source consumers, including deliberately embedded data with matching names; GOWORK and managed GOCACHE express the scratch build protocol rather than fixture-specific exceptions.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish the snapshot naming policy from Go input discovery and describe excluded data and workspace ownership; invocation and artifact-flag prose explains their separate build responsibilities.
+ * @evidence contracts/portability.md#os-neutral-implementation Native roots use Node path APIs; the same configured sidecar-name exclusions apply across platforms without deriving filesystem capabilities from the running OS.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups input policies; each function owns its environment or membership processing.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Fixed policies are not retained computation; this namespace owns no runtime memo.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Policy collections have fixed population and do not own external resources.
+ */
+var GoSourceInputs;
+(function (GoSourceInputs) {
+    /**
+     * Artifact flags shared by native compilation and its environment identity.
+     *
+     * Go's trimpath removes disposable materialization paths from object keys and
+     * debug information. Runtime source locations identify module files; source
+     * diagnostics and embedded file contents still come from the snapshot.
+     */
+    GoSourceInputs.BUILD_FLAGS = Object.freeze(["-trimpath"]);
+    /**
+     * Names of directories excluded below a plugin source root: a nested
+     * `node_modules`, a repository's `.git`, and ttsc's own `.ttsc`. An observer
+     * outside this package, such as `ttscserver`'s native host, is handed this
+     * list rather than a copy of it.
+     */
+    GoSourceInputs.PRUNED_SOURCE_DIRECTORY_NAMES = [
+        "node_modules",
+        ".git",
+        ".ttsc",
+    ];
+    const PRUNE_DIRS = new Set(GoSourceInputs.PRUNED_SOURCE_DIRECTORY_NAMES);
+    const GENERATED_WORKSPACE_FILES = new Set(["go.work", "go.work.sum"]);
+    /**
+     * The environment of a `go` invocation: `GOWORK=auto`, ttsc's own `GOCACHE`
+     * when a cache root is given, and `GOROOT` inferred from the binary's
+     * location when the copied environment's value is absent or empty. Build
+     * callers supply the managed cache; metadata callers retain their ambient
+     * GOCACHE.
+     *
+     * @evidence contracts/common.md#principled-implementation A copied environment receives explicit workspace/cache settings and an inferred SDK root only when its existing GOROOT value is absent or empty; nonempty caller values remain unchanged.
+     * @evidence contracts/common.md#clear-and-simple-design One constructor serves build and metadata invocations; omitting the cache root intentionally keeps read-only probes separate from owned-cache writes.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The caller's environment is preserved rather than mutating process globals, and documented Go variables express supported invocation policy.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states override precedence and why only actual builds receive managed GOCACHE; tags have separate presentation.
+     * @evidence contracts/portability.md#os-neutral-implementation Native SDK inference delegates to path APIs, and Go's environment variables carry process configuration across supported operating systems.
+     * @evidence contracts/performance.md#efficient-algorithms Environment enumeration copies E property references and processes key names; values are not deep-copied. SDK inference also performs native path-text construction and an existence query, whose filesystem/path costs are not bounded by E alone.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each invocation needs its effective environment copy; no retained computation is coordinated here.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only a call-local environment object is created.
+     */
+    function goBuildEnv(goBinary, goBuildCacheRoot, effectiveEnv = process.env) {
+        const env = { ...effectiveEnv };
+        env.GOWORK = "auto";
+        // Only the actual `go build` needs ttsc's GOCACHE; read-only metadata spawns
+        // (`go mod edit`, `go env`, `go version`) call goBuildEnv with no cache root
+        // and inherit ambient GOCACHE rather than receiving the managed build
+        // cache here. This constructor does not certify child-side effects.
+        if (goBuildCacheRoot) {
+            env.GOCACHE = goBuildCacheRoot;
+        }
+        const goRoot = inferGoRoot(goBinary);
+        if (goRoot && !env.GOROOT) {
+            env.GOROOT = goRoot;
+        }
+        return env;
+    }
+    GoSourceInputs.goBuildEnv = goBuildEnv;
+    /**
+     * Infer an SDK root for an absolute binary path inside `<root>/bin` when
+     * `<root>/src/runtime` exists. The binary basename and runtime entry kind are
+     * not validated here; `null` means this layout check did not match.
+     *
+     * @evidence contracts/common.md#principled-implementation An absolute binary path under bin and an existing src/runtime path establish this layout inference; the selected compiler's actual identity belongs to its resolution/probing owner, and other layouts leave the caller's environment unchanged.
+     * @evidence contracts/common.md#clear-and-simple-design Small early returns expose each required layout condition without a speculative toolchain-discovery abstraction.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Layout recognition uses the SDK's real structure, not a particular user's install path or expected test directory.
+     * @evidence contracts/common.md#meaningful-documentation Native prose documents the recognized layout and null meaning rather than merely repeating the return type.
+     * @evidence contracts/portability.md#os-neutral-implementation Node absolute/dirname/join operations use native path syntax; the Go SDK's bin and src/runtime components are distribution-defined names.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms A fixed sequence of native absolute/dirname/basename/join operations and one existence query checks the layout without enumerating a source tree. Path text and native lookup still contribute cost; fixed operation count is not a constant-byte filesystem bound.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Existence is checked for the current invocation rather than memoized independently of SDK changes.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The function retains no state or native handle.
+     */
+    function inferGoRoot(goBinary) {
+        if (!node_path_1.default.isAbsolute(goBinary))
+            return null;
+        const binDir = node_path_1.default.dirname(goBinary);
+        if (node_path_1.default.basename(binDir) !== "bin")
+            return 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;
+    }
+    GoSourceInputs.inferGoRoot = inferGoRoot;
+    /**
+     * Whether a directory is excluded from the source snapshot: `node_modules`,
+     * `.git`, and `.ttsc`. Membership is by name, even for caller-owned data.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact membership in the shared directory-name set makes every source consumer use the same snapshot omission rule.
+     * @evidence contracts/common.md#clear-and-simple-design One predicate exposes policy without requiring walkers to duplicate its set.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts These are declared subtree exclusions, not a test of whether every matching directory is owned by a package manager, repository or cache.
+     * @evidence contracts/common.md#meaningful-documentation Native prose names the omitted directory categories, with a blank line before tags.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation This name-membership predicate performs no native lookup or path interpretation.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms A prebuilt three-name set avoids rebuilding policy per directory; lookup still compares/hashes the supplied name under native JavaScript string/Set behavior and does not inspect directory content.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Static policy lookup does not coordinate a completed or in-flight computation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The fixed module policy has constant population and owns no external resource.
+     */
+    function shouldPruneDirectory(name) {
+        return PRUNE_DIRS.has(name);
+    }
+    GoSourceInputs.shouldPruneDirectory = shouldPruneDirectory;
+    /**
+     * Names of files excluded from the snapshot: workspace files and names
+     * commonly used for operating-system sidecars. Excluding them avoids key
+     * changes on unrelated workspace or file-browser writes, but also excludes
+     * caller-authored data with those names. An observer that runs outside this
+     * package, such as `ttscserver`'s native host, is handed this list rather
+     * than a copy of it.
+     */
+    GoSourceInputs.OMITTED_SOURCE_FILE_NAMES = [
+        ...GENERATED_WORKSPACE_FILES,
+        ".DS_Store",
+        "Thumbs.db",
+    ];
+    /**
+     * File suffixes excluded from the snapshot: archive names commonly produced
+     * by `npm pack`, and backup names ending in `~`. These suffixes remain
+     * excluded when the files hold deliberately authored plugin data.
+     */
+    GoSourceInputs.OMITTED_SOURCE_FILE_SUFFIXES = [
+        ".tgz",
+        ".tar.gz",
+        "~",
+    ];
+    /**
+     * Whether a file name is excluded from the source snapshot
+     * (`OMITTED_SOURCE_FILE_NAMES`, `OMITTED_SOURCE_FILE_SUFFIXES`).
+     *
+     * @evidence contracts/common.md#principled-implementation Exact names and defined suffixes decide snapshot omission consistently for source digests, copies and observers, independently of Go embed directives.
+     * @evidence contracts/common.md#clear-and-simple-design Shared name/suffix lists keep the complete file-exclusion policy visible to external observers and this predicate.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The published name policy applies without inspecting file contents or treating matching embedded data as an exception; it does not claim all excluded files are irrelevant to Go.
+     * @evidence contracts/common.md#meaningful-documentation Native prose points to the documented categories rather than inventing an additional omission policy.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation This string predicate does not interpret native path identity or access the filesystem.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms The policy lists have fixed size; suffix comparison costs at most their total fixed suffix lengths, without traversing file contents.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Static policy lookup does not share runtime computation across requests.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only fixed policy constants are referenced.
+     */
+    function shouldOmitSourceFile(name) {
+        return (GoSourceInputs.OMITTED_SOURCE_FILE_NAMES.includes(name) ||
+            GoSourceInputs.OMITTED_SOURCE_FILE_SUFFIXES.some((suffix) => name.endsWith(suffix)));
+    }
+    GoSourceInputs.shouldOmitSourceFile = shouldOmitSourceFile;
+})(GoSourceInputs || (exports.GoSourceInputs = GoSourceInputs = {}));
+//# sourceMappingURL=GoSourceInputs.js.map

package/lib/plugin/internal/source/GoSourceInputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoSourceInputs.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/GoSourceInputs.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,IAAiB,cAAc,CA0J9B;AA1JD,WAAiB,cAAc;IAC7B;;;;;;OAMG;IACU,0BAAW,GAAsB,MAAM,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;IAE3E;;;;;OAKG;IACU,4CAA6B,GAAsB;QAC9D,cAAc;QACd,MAAM;QACN,OAAO;KACR,CAAC;IAEF,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,4CAA6B,CAAC,CAAC;IAE1D,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACH,SAAgB,UAAU,CACxB,QAAgB,EAChB,gBAAyB,EACzB,YAAY,GAAsB,OAAO,CAAC,GAAG;QAE7C,MAAM,GAAG,GAAG,EAAE,GAAG,YAAY,EAAE,CAAC;QAChC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;QACpB,6EAA6E;QAC7E,6EAA6E;QAC7E,sEAAsE;QACtE,oEAAoE;QACpE,IAAI,gBAAgB,EAAE,CAAC;YACrB,GAAG,CAAC,OAAO,GAAG,gBAAgB,CAAC;QACjC,CAAC;QACD,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,MAAM,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;YAC1B,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;QACtB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAnBe,eAAA,UAAU,aAmBzB,CAAA;IAED;;;;;;;;;;;;;;OAcG;IACH,SAAgB,WAAW,CAAC,QAAgB;QAC1C,IAAI,CAAC,mBAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QAC5C,MAAM,MAAM,GAAG,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,mBAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QACjD,MAAM,MAAM,GAAG,mBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpC,OAAO,iBAAE,CAAC,UAAU,CAAC,mBAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5E,CAAC;IANe,eAAA,WAAW,cAM1B,CAAA;IAED;;;;;;;;;;;;;;;OAeG;IACH,SAAgB,oBAAoB,CAAC,IAAY;QAC/C,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAFe,eAAA,oBAAoB,uBAEnC,CAAA;IAED;;;;;;;OAOG;IACU,wCAAyB,GAAsB;QAC1D,GAAG,yBAAyB;QAC5B,WAAW;QACX,WAAW;KACZ,CAAC;IAEF;;;;OAIG;IACU,2CAA4B,GAAsB;QAC7D,MAAM;QACN,SAAS;QACT,GAAG;KACJ,CAAC;IAEF;;;;;;;;;;;;;;;OAeG;IACH,SAAgB,oBAAoB,CAAC,IAAY;QAC/C,OAAO,CACL,wCAAyB,CAAC,QAAQ,CAAC,IAAI,CAAC;YACxC,2CAA4B,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CACrE,CAAC;IACJ,CAAC;IALe,eAAA,oBAAoB,uBAKnC,CAAA;AACH,CAAC,EA1JgB,cAAc,aAAd,cAAc,GAAd,cAAc,QA0J9B"}

package/lib/plugin/internal/source/GoToolResolution.d.ts

@@ -0,0 +1,125 @@
+import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+/**
+ * Select the `go` executable spelling a source-plugin build shares across its
+ * phases.
+ *
+ * On Windows, `PATH` and `PATHEXT` lookup and `.cmd`/`.bat` wrappers make a
+ * bare `go` ambiguous: the answer can change between the cache-key probe and
+ * the build if relative lookup is repeated. A successfully selected native path
+ * avoids reinterpreting that name against a later scratch cwd. The path is not
+ * a retained executable handle and cannot prevent replacement; an unresolved
+ * bare name can still be returned for normal spawn failure/search.
+ *
+ * POSIX PATH entries and qualified relative executables are also pinned before
+ * the build moves into its scratch directory.
+ *
+ * @evidence contracts/common.md#principled-implementation Platform-specific candidate lookup supplies a selected spelling when found; POSIX execute access and Windows native-before-wrapper policy determine selection. Unresolved fallback is not a proved target, and returned paths do not pin executable content over time.
+ * @evidence contracts/common.md#clear-and-simple-design One namespace owns search bases, executable probing and Windows environment spelling so key probes and actual spawns use one policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Candidate selection follows native process rules rather than hardcoding a particular user's Go installation or mutating process.env.
+ * @evidence contracts/common.md#meaningful-documentation Native comments explain pinned tool identity, Windows wrapper precedence, search order and environment-case handling.
+ * @evidence contracts/portability.md#os-neutral-implementation Native Node paths separate POSIX permission checks from Windows PATHEXT/cmd wrapper handling; path identity is not inferred from filesystem case assumptions.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups operations; its callable members own search algorithms.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This namespace retains no computed resolution; resolveGoToolForBuild defines the build-wide sharing boundary.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no mutable cache or native resource.
+ */
+export declare namespace GoToolResolution {
+    /**
+     * Pin native PATH and command-wrapper lookup to one build-wide target.
+     *
+     * @evidence contracts/common.md#principled-implementation Native bases resolve against the module directory and POSIX X_OK rejects unusable candidates. A selected spelling avoids later relative cwd reinterpretation; unresolved bare fallback and subsequent replacement remain outside that selection guarantee.
+     * @evidence contracts/common.md#clear-and-simple-design The build-facing resolver delegates Windows wrapper policy and otherwise performs one direct native candidate search.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Pinning corrects repeated relative lookup rather than compensating for a mismatched key after the build.
+     * @evidence contracts/common.md#meaningful-documentation The comment identifies the build-wide pin and the owning namespace explains why cwd changes matter.
+     * @evidence contracts/portability.md#os-neutral-implementation POSIX checks actual execute access while Windows uses its executable/wrapper rules; the returned native path is reused unchanged by build subprocesses.
+     * @evidence contracts/performance.md#efficient-algorithms Base construction processes complete PATH/binary/cwd text; POSIX selection performs native stat/access until a usable candidate. Windows adds fixed native suffixes followed by caller-sized PATHEXT wrapper candidates; extension/name/path bytes, environment lookup and native filesystem work are not bounded by P alone.
+     * @evidence contracts/performance.md#reuse-equivalent-work The resolved target is shared by environment queries and the actual Go build so equivalent phases do not reinterpret relative lookup.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The resolver owns no retained memo or process; the caller keeps the resolved path for its build.
+     */
+    export function resolveGoToolForBuild(binary: string, env: NodeJS.ProcessEnv, cwd: string, witness?: PluginBuildEnvironmentWitness.Record): string;
+    interface IWindowsGoToolResolution {
+        location: string | null;
+        wrapper: boolean;
+    }
+    /**
+     * Preserve libuv's native target before falling back to cmd/bat wrappers.
+     *
+     * @evidence contracts/common.md#principled-implementation Direct native executable candidates take precedence and cmd/bat fallback uses PATHEXT only after that search; explicit wrapper names retain wrapper identity even when missing.
+     * @evidence contracts/common.md#clear-and-simple-design One result pairs location with wrapper routing so spawn code does not repeat extension policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing wrappers are represented honestly instead of silently selecting another tool to evade spawn failure.
+     * @evidence contracts/common.md#meaningful-documentation The native comment states native-before-wrapper precedence and the result fields name routing facts.
+     * @evidence contracts/portability.md#os-neutral-implementation This isolates Windows native .com/.exe probing from shell-based .cmd/.bat execution and honors configured wrapper extensions.
+     * @evidence contracts/performance.md#efficient-algorithms Candidate construction retains full path strings. Explicit wrappers use one first-match scan; other names scan direct/fixed .com/.exe choices before a caller-sized wrapper-extension pass. Environment/PATHEXT parsing, text comparisons/path construction and native probes contribute costs beyond P times E query count.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning build resolver pins this result; this Windows search does not retain completed results itself.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No process or persistent handle is acquired during candidate probing.
+     */
+    export function resolveWindowsGoTool(binary: string, env: NodeJS.ProcessEnv, cwd: string, witness?: PluginBuildEnvironmentWitness.Record): IWindowsGoToolResolution;
+    /**
+     * The candidate paths a binary name resolves against, in search order: the
+     * path itself when absolute or qualified, otherwise each `PATH` directory. On
+     * Windows the current directory is searched first, as process creation does,
+     * unless `NoDefaultCurrentDirectoryInExePath` is set.
+     *
+     * @evidence contracts/common.md#principled-implementation Absolute and qualified paths bypass PATH search, while bare names use native ordered bases; Windows quoted entries and the parent-process cwd-search switch preserve libuv lookup distinctions.
+     * @evidence contracts/common.md#clear-and-simple-design Base construction is independent of executable-extension probing, allowing Go and external-command identity readers to share it.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Search fallback uses the native POSIX default or Windows inherited PATH semantics, not a privileged compiler directory.
+     * @evidence contracts/common.md#meaningful-documentation The prose states absolute/qualified handling, current-directory precedence and the disabling switch.
+     * @evidence contracts/portability.md#os-neutral-implementation Node's delimiter and native paths govern POSIX search; Windows semicolon quoting and case-insensitive PATH retrieval are explicit boundaries.
+     * @evidence contracts/performance.md#efficient-algorithms Absolute/qualified inputs take native path checks; bare names split complete PATH text and map directories to full resolved strings. Windows also filters/unquotes entries, can enumerate/casefold environment names and witnesses the ambient cwd-search switch. Path/name/environment bytes and intermediate arrays contribute processing/storage beyond candidate count.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This constructs bases from current arguments and owns no cross-request search cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the returned candidate array survives; no native resource is retained.
+     */
+    export function executableSearchBases(binary: string, env: NodeJS.ProcessEnv, cwd: string, witness?: PluginBuildEnvironmentWitness.Record): string[];
+    /**
+     * Whether `location` exists and is a regular file, following links.
+     *
+     * This is a file-kind probe; POSIX executable permission is checked by the
+     * build-facing resolver separately.
+     *
+     * @evidence contracts/common.md#principled-implementation stat's regular-file classification rejects directories and missing candidates without claiming execute access from file existence alone.
+     * @evidence contracts/common.md#clear-and-simple-design One kind probe is shared by native and wrapper candidate searches; permission policy stays with the resolver that needs it.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Candidate failures return false rather than introducing a known-tool exception that bypasses the filesystem.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraphs explicitly distinguish file kind from POSIX execute permission.
+     * @evidence contracts/portability.md#os-neutral-implementation Node's native stat follows filesystem aliases; callers separately select OS-specific execution rules rather than guessing them from a filename.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One native stat query and regular-file predicate avoid directory enumeration/content reads, but path-component/link lookup and native errors still cost work; fixed query count is not a constant-byte filesystem bound.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Fresh file state is probed rather than cached beyond its observation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous stat creates no lasting handle or retained state.
+     */
+    export function isExecutableFile(location: string): boolean;
+    /**
+     * The executable extensions Windows tries, lower-cased and unquoted, from
+     * `PATHEXT` or its documented default.
+     *
+     * @evidence contracts/common.md#principled-implementation Configured or default PATHEXT values are split with Windows quoting rules, normalized and stripped of empty entries before wrapper lookup.
+     * @evidence contracts/common.md#clear-and-simple-design One extension reader shares the same Windows environment and search-entry helpers as PATH lookup.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The default extension list is Windows invocation vocabulary, not a test-specific compiler suffix list.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states lowercase/unquoted output and configured-versus-default precedence.
+     * @evidence contracts/portability.md#os-neutral-implementation PATHEXT handling is isolated to the Windows lookup boundary rather than applied to POSIX filenames.
+     * @evidence contracts/performance.md#efficient-algorithms Configured extension text is split/unquoted/lowercased/filtered in linear text passes after environment lookup, which can enumerate/casefold/sort name matches. Intermediate and returned extension arrays scale with full text and caller-supplied population; no independent extension-count bound is enforced.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This reads current environment arguments; the owning resolver keeps any chosen executable.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned extension list has no external lifetime or handle ownership.
+     */
+    export function windowsExecutableExtensions(env?: NodeJS.ProcessEnv): readonly string[];
+    /**
+     * Read an environment variable with lowercase-name matching. An exact-case
+     * key wins; otherwise the first matching key in sorted order, so the answer
+     * is deterministic when a caller supplied several spellings.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact spelling is preferred; otherwise matching keys are sorted before selecting one, making case-insensitive aliases deterministic for injected environments.
+     * @evidence contracts/common.md#clear-and-simple-design One helper centralizes the Windows variable-spelling policy used by PATH, PATHEXT and shell selection.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The helper reads the supplied environment and does not patch process.env or rename keys to accommodate a consumer.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph records exact-key precedence and sorted fallback when several aliases exist.
+     * @evidence contracts/portability.md#os-neutral-implementation Case-insensitive environment names are a Windows process convention, distinct from filesystem path case policy.
+     * @evidence contracts/performance.md#efficient-algorithms Exact property lookup processes the supplied key without enumeration. Fallback allocates all N key names, lowercases/compares their bytes and sorts K matching strings with text-sensitive comparisons; it avoids sorting unrelated keys but counts alone do not capture name bytes or array storage.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup uses the supplied current environment and retains no normalized map across calls.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No retained state or native handle is owned.
+     */
+    export function readWindowsEnvironmentValue(env: NodeJS.ProcessEnv, name: string): string | undefined;
+    export {};
+}

package/lib/plugin/internal/source/GoToolResolution.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoToolResolution = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const PluginBuildEnvironmentWitness_1 = require("./PluginBuildEnvironmentWitness");
+/**
+ * Select the `go` executable spelling a source-plugin build shares across its
+ * phases.
+ *
+ * On Windows, `PATH` and `PATHEXT` lookup and `.cmd`/`.bat` wrappers make a
+ * bare `go` ambiguous: the answer can change between the cache-key probe and
+ * the build if relative lookup is repeated. A successfully selected native path
+ * avoids reinterpreting that name against a later scratch cwd. The path is not
+ * a retained executable handle and cannot prevent replacement; an unresolved
+ * bare name can still be returned for normal spawn failure/search.
+ *
+ * POSIX PATH entries and qualified relative executables are also pinned before
+ * the build moves into its scratch directory.
+ *
+ * @evidence contracts/common.md#principled-implementation Platform-specific candidate lookup supplies a selected spelling when found; POSIX execute access and Windows native-before-wrapper policy determine selection. Unresolved fallback is not a proved target, and returned paths do not pin executable content over time.
+ * @evidence contracts/common.md#clear-and-simple-design One namespace owns search bases, executable probing and Windows environment spelling so key probes and actual spawns use one policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Candidate selection follows native process rules rather than hardcoding a particular user's Go installation or mutating process.env.
+ * @evidence contracts/common.md#meaningful-documentation Native comments explain pinned tool identity, Windows wrapper precedence, search order and environment-case handling.
+ * @evidence contracts/portability.md#os-neutral-implementation Native Node paths separate POSIX permission checks from Windows PATHEXT/cmd wrapper handling; path identity is not inferred from filesystem case assumptions.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups operations; its callable members own search algorithms.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This namespace retains no computed resolution; resolveGoToolForBuild defines the build-wide sharing boundary.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace owns no mutable cache or native resource.
+ */
+var GoToolResolution;
+(function (GoToolResolution) {
+    function isWindowsCommandWrapper(location) {
+        return process.platform === "win32" && /\.(?:bat|cmd)$/i.test(location);
+    }
+    /**
+     * Pin native PATH and command-wrapper lookup to one build-wide target.
+     *
+     * @evidence contracts/common.md#principled-implementation Native bases resolve against the module directory and POSIX X_OK rejects unusable candidates. A selected spelling avoids later relative cwd reinterpretation; unresolved bare fallback and subsequent replacement remain outside that selection guarantee.
+     * @evidence contracts/common.md#clear-and-simple-design The build-facing resolver delegates Windows wrapper policy and otherwise performs one direct native candidate search.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Pinning corrects repeated relative lookup rather than compensating for a mismatched key after the build.
+     * @evidence contracts/common.md#meaningful-documentation The comment identifies the build-wide pin and the owning namespace explains why cwd changes matter.
+     * @evidence contracts/portability.md#os-neutral-implementation POSIX checks actual execute access while Windows uses its executable/wrapper rules; the returned native path is reused unchanged by build subprocesses.
+     * @evidence contracts/performance.md#efficient-algorithms Base construction processes complete PATH/binary/cwd text; POSIX selection performs native stat/access until a usable candidate. Windows adds fixed native suffixes followed by caller-sized PATHEXT wrapper candidates; extension/name/path bytes, environment lookup and native filesystem work are not bounded by P alone.
+     * @evidence contracts/performance.md#reuse-equivalent-work The resolved target is shared by environment queries and the actual Go build so equivalent phases do not reinterpret relative lookup.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The resolver owns no retained memo or process; the caller keeps the resolved path for its build.
+     */
+    function resolveGoToolForBuild(binary, env, cwd, witness) {
+        if (process.platform !== "win32") {
+            for (const candidate of executableSearchBases(binary, env, cwd)) {
+                if (!isExecutableFile(candidate))
+                    continue;
+                try {
+                    node_fs_1.default.accessSync(candidate, node_fs_1.default.constants.X_OK);
+                    return candidate;
+                }
+                catch {
+                    // A non-executable PATH entry must not shadow a later usable tool.
+                }
+            }
+            return node_path_1.default.isAbsolute(binary) || !hasPathQualifier(binary)
+                ? binary
+                : node_path_1.default.resolve(cwd, binary);
+        }
+        return resolveWindowsGoTool(binary, env, cwd, witness).location ?? binary;
+    }
+    GoToolResolution.resolveGoToolForBuild = resolveGoToolForBuild;
+    /**
+     * Preserve libuv's native target before falling back to cmd/bat wrappers.
+     *
+     * @evidence contracts/common.md#principled-implementation Direct native executable candidates take precedence and cmd/bat fallback uses PATHEXT only after that search; explicit wrapper names retain wrapper identity even when missing.
+     * @evidence contracts/common.md#clear-and-simple-design One result pairs location with wrapper routing so spawn code does not repeat extension policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing wrappers are represented honestly instead of silently selecting another tool to evade spawn failure.
+     * @evidence contracts/common.md#meaningful-documentation The native comment states native-before-wrapper precedence and the result fields name routing facts.
+     * @evidence contracts/portability.md#os-neutral-implementation This isolates Windows native .com/.exe probing from shell-based .cmd/.bat execution and honors configured wrapper extensions.
+     * @evidence contracts/performance.md#efficient-algorithms Candidate construction retains full path strings. Explicit wrappers use one first-match scan; other names scan direct/fixed .com/.exe choices before a caller-sized wrapper-extension pass. Environment/PATHEXT parsing, text comparisons/path construction and native probes contribute costs beyond P times E query count.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The owning build resolver pins this result; this Windows search does not retain completed results itself.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No process or persistent handle is acquired during candidate probing.
+     */
+    function resolveWindowsGoTool(binary, env, cwd, witness) {
+        const candidates = executableSearchBases(binary, env, cwd, witness);
+        if (isWindowsCommandWrapper(binary)) {
+            return {
+                location: candidates.find(isExecutableFile) ?? null,
+                wrapper: true,
+            };
+        }
+        const hasExtension = windowsFileNameHasExtension(binary);
+        for (const candidate of candidates) {
+            if (hasExtension && isExecutableFile(candidate)) {
+                return { location: candidate, wrapper: false };
+            }
+            for (const extension of [".com", ".exe"]) {
+                const executable = candidate + extension;
+                if (isExecutableFile(executable)) {
+                    return { location: executable, wrapper: false };
+                }
+            }
+        }
+        const wrapperExtensions = windowsExecutableExtensions(env).filter((ext) => /\.(?:bat|cmd)$/i.test(ext));
+        for (const candidate of candidates) {
+            for (const extension of wrapperExtensions) {
+                const executable = candidate + extension;
+                if (isExecutableFile(executable)) {
+                    return { location: executable, wrapper: true };
+                }
+            }
+        }
+        return { location: null, wrapper: false };
+    }
+    GoToolResolution.resolveWindowsGoTool = resolveWindowsGoTool;
+    /**
+     * The candidate paths a binary name resolves against, in search order: the
+     * path itself when absolute or qualified, otherwise each `PATH` directory. On
+     * Windows the current directory is searched first, as process creation does,
+     * unless `NoDefaultCurrentDirectoryInExePath` is set.
+     *
+     * @evidence contracts/common.md#principled-implementation Absolute and qualified paths bypass PATH search, while bare names use native ordered bases; Windows quoted entries and the parent-process cwd-search switch preserve libuv lookup distinctions.
+     * @evidence contracts/common.md#clear-and-simple-design Base construction is independent of executable-extension probing, allowing Go and external-command identity readers to share it.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Search fallback uses the native POSIX default or Windows inherited PATH semantics, not a privileged compiler directory.
+     * @evidence contracts/common.md#meaningful-documentation The prose states absolute/qualified handling, current-directory precedence and the disabling switch.
+     * @evidence contracts/portability.md#os-neutral-implementation Node's delimiter and native paths govern POSIX search; Windows semicolon quoting and case-insensitive PATH retrieval are explicit boundaries.
+     * @evidence contracts/performance.md#efficient-algorithms Absolute/qualified inputs take native path checks; bare names split complete PATH text and map directories to full resolved strings. Windows also filters/unquotes entries, can enumerate/casefold environment names and witnesses the ambient cwd-search switch. Path/name/environment bytes and intermediate arrays contribute processing/storage beyond candidate count.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This constructs bases from current arguments and owns no cross-request search cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only the returned candidate array survives; no native resource is retained.
+     */
+    function executableSearchBases(binary, env, cwd, witness) {
+        if (node_path_1.default.isAbsolute(binary))
+            return [binary];
+        if (hasPathQualifier(binary))
+            return [node_path_1.default.resolve(cwd, binary)];
+        const directories = process.platform === "win32"
+            ? splitWindowsSearchPath(readPathEnvironment(env))
+                // libuv skips only genuinely empty slices. A quoted-empty slice
+                // survives that check, unquotes to "", and therefore names cwd.
+                .filter((entry) => entry.length > 0)
+                .map(unquoteWindowsSearchEntry)
+            : readPathEnvironment(env).split(node_path_1.default.delimiter);
+        const noDefaultCurrentDirectory = process.platform === "win32"
+            ? readWindowsEnvironmentValue(process.env, "NoDefaultCurrentDirectoryInExePath")
+            : undefined;
+        if (process.platform === "win32")
+            PluginBuildEnvironmentWitness_1.PluginBuildEnvironmentWitness.addEnvironment(witness, "NoDefaultCurrentDirectoryInExePath", noDefaultCurrentDirectory);
+        if (process.platform === "win32" &&
+            noDefaultCurrentDirectory === undefined) {
+            directories.unshift(cwd);
+        }
+        return directories.map((dir) => node_path_1.default.resolve(cwd, dir, binary));
+    }
+    GoToolResolution.executableSearchBases = executableSearchBases;
+    /**
+     * Whether `location` exists and is a regular file, following links.
+     *
+     * This is a file-kind probe; POSIX executable permission is checked by the
+     * build-facing resolver separately.
+     *
+     * @evidence contracts/common.md#principled-implementation stat's regular-file classification rejects directories and missing candidates without claiming execute access from file existence alone.
+     * @evidence contracts/common.md#clear-and-simple-design One kind probe is shared by native and wrapper candidate searches; permission policy stays with the resolver that needs it.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Candidate failures return false rather than introducing a known-tool exception that bypasses the filesystem.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraphs explicitly distinguish file kind from POSIX execute permission.
+     * @evidence contracts/portability.md#os-neutral-implementation Node's native stat follows filesystem aliases; callers separately select OS-specific execution rules rather than guessing them from a filename.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One native stat query and regular-file predicate avoid directory enumeration/content reads, but path-component/link lookup and native errors still cost work; fixed query count is not a constant-byte filesystem bound.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Fresh file state is probed rather than cached beyond its observation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous stat creates no lasting handle or retained state.
+     */
+    function isExecutableFile(location) {
+        try {
+            return node_fs_1.default.statSync(location).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    GoToolResolution.isExecutableFile = isExecutableFile;
+    function hasPathQualifier(location) {
+        return (location.includes(node_path_1.default.sep) ||
+            (process.platform === "win32" &&
+                (location.includes("/") || /^[a-zA-Z]:/.test(location))));
+    }
+    function windowsFileNameHasExtension(location) {
+        const name = node_path_1.default.basename(location);
+        const dot = name.indexOf(".");
+        return dot >= 0 && dot < name.length - 1;
+    }
+    function splitWindowsSearchPath(value) {
+        const entries = [];
+        let start = 0;
+        let quote = "";
+        for (let index = 0; index < value.length; index++) {
+            const character = value[index];
+            if (quote !== "") {
+                if (character === quote)
+                    quote = "";
+            }
+            else if ((character === '"' || character === "'") && index === start) {
+                quote = character;
+            }
+            else if (character === ";") {
+                entries.push(value.slice(start, index));
+                start = index + 1;
+            }
+        }
+        entries.push(value.slice(start));
+        return entries;
+    }
+    function unquoteWindowsSearchEntry(location) {
+        const first = location[0];
+        const withoutFirst = first === '"' || first === "'" ? location.slice(1) : location;
+        const last = withoutFirst[withoutFirst.length - 1];
+        return last === '"' || last === "'"
+            ? withoutFirst.slice(0, -1)
+            : withoutFirst;
+    }
+    /**
+     * The executable extensions Windows tries, lower-cased and unquoted, from
+     * `PATHEXT` or its documented default.
+     *
+     * @evidence contracts/common.md#principled-implementation Configured or default PATHEXT values are split with Windows quoting rules, normalized and stripped of empty entries before wrapper lookup.
+     * @evidence contracts/common.md#clear-and-simple-design One extension reader shares the same Windows environment and search-entry helpers as PATH lookup.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The default extension list is Windows invocation vocabulary, not a test-specific compiler suffix list.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states lowercase/unquoted output and configured-versus-default precedence.
+     * @evidence contracts/portability.md#os-neutral-implementation PATHEXT handling is isolated to the Windows lookup boundary rather than applied to POSIX filenames.
+     * @evidence contracts/performance.md#efficient-algorithms Configured extension text is split/unquoted/lowercased/filtered in linear text passes after environment lookup, which can enumerate/casefold/sort name matches. Intermediate and returned extension arrays scale with full text and caller-supplied population; no independent extension-count bound is enforced.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This reads current environment arguments; the owning resolver keeps any chosen executable.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned extension list has no external lifetime or handle ownership.
+     */
+    function windowsExecutableExtensions(env = process.env) {
+        const pathext = readWindowsEnvironmentValue(env, "PATHEXT");
+        const raw = pathext && pathext.length > 0 ? pathext : ".COM;.EXE;.BAT;.CMD";
+        return splitWindowsSearchPath(raw)
+            .map(unquoteWindowsSearchEntry)
+            .map((ext) => ext.toLowerCase())
+            .filter((ext) => ext.length > 0);
+    }
+    GoToolResolution.windowsExecutableExtensions = windowsExecutableExtensions;
+    function readPathEnvironment(env = process.env) {
+        return process.platform === "win32"
+            ? (readWindowsEnvironmentValue(env, "PATH") ??
+                readWindowsEnvironmentValue(process.env, "PATH") ??
+                "")
+            : (env.PATH ?? "/usr/bin:/bin");
+    }
+    /**
+     * Read an environment variable with lowercase-name matching. An exact-case
+     * key wins; otherwise the first matching key in sorted order, so the answer
+     * is deterministic when a caller supplied several spellings.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact spelling is preferred; otherwise matching keys are sorted before selecting one, making case-insensitive aliases deterministic for injected environments.
+     * @evidence contracts/common.md#clear-and-simple-design One helper centralizes the Windows variable-spelling policy used by PATH, PATHEXT and shell selection.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The helper reads the supplied environment and does not patch process.env or rename keys to accommodate a consumer.
+     * @evidence contracts/common.md#meaningful-documentation The native paragraph records exact-key precedence and sorted fallback when several aliases exist.
+     * @evidence contracts/portability.md#os-neutral-implementation Case-insensitive environment names are a Windows process convention, distinct from filesystem path case policy.
+     * @evidence contracts/performance.md#efficient-algorithms Exact property lookup processes the supplied key without enumeration. Fallback allocates all N key names, lowercases/compares their bytes and sorts K matching strings with text-sensitive comparisons; it avoids sorting unrelated keys but counts alone do not capture name bytes or array storage.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The lookup uses the supplied current environment and retains no normalized map across calls.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No retained state or native handle is owned.
+     */
+    function readWindowsEnvironmentValue(env, name) {
+        const exact = env[name];
+        if (exact !== undefined)
+            return exact;
+        const normalized = name.toLowerCase();
+        const key = Object.keys(env)
+            .filter((candidate) => candidate.toLowerCase() === normalized)
+            .sort()[0];
+        return key === undefined ? undefined : env[key];
+    }
+    GoToolResolution.readWindowsEnvironmentValue = readWindowsEnvironmentValue;
+})(GoToolResolution || (exports.GoToolResolution = GoToolResolution = {}));
+//# sourceMappingURL=GoToolResolution.js.map

package/lib/plugin/internal/source/GoToolResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoToolResolution.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/GoToolResolution.ts"],"names":[],"mappings":"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"}