ttsc 0.30.3 → 0.31.0

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

@@ -0,0 +1,475 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoBuildCacheCoordination = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_worker_threads_1 = require("node:worker_threads");
+const E2ETrace_1 = require("../../../internal/E2ETrace");
+const OwnedSynchronousProcess_1 = require("../../../internal/OwnedSynchronousProcess");
+const SourceNativeRetirement_1 = require("../../../internal/SourceNativeRetirement");
+const SourceBuildCacheLayout_1 = require("./SourceBuildCacheLayout");
+/**
+ * Coordination between Go builds that use ttsc's own Go object cache and the
+ * opportunistic pruning of that cache.
+ *
+ * Coordinated build and admitted maintenance attempts publish records in
+ * private cache directories and attempt heartbeat startup. Pruning skips the
+ * cohort a live build may still read, and an abandoned record expires after a
+ * grace period (one hour for builds, one minute for maintenance). Byte-read
+ * failure still permits age-based expiry when metadata is readable; unknown age
+ * or failed clock-skew repair defers pruning conservatively. This is
+ * opportunistic coordination rather than an absolute proof that every abandoned
+ * record can be reclaimed.
+ *
+ * Scoped native boundaries add independent guards: their exact build leases
+ * survive age/PID-based collection until qualified closure. Shared cache guards
+ * prevent eviction and clean without serializing independent builders.
+ * Maintenance freshness remains separate so an old maintenance record cannot
+ * block concurrent builds indefinitely under an unrelated native guard.
+ *
+ * Age-based expiry for unguarded records assumes a running task can keep its
+ * heartbeat fresh. A prolonged suspension or failed heartbeat after startup can
+ * outlast the grace; elapsed time alone does not prove that its Go process has
+ * ended.
+ *
+ * @evidence contracts/common.md#principled-implementation Exact scoped native guards supersede build-lease expiry until certified closure while shared Go admission remains concurrent. Published completion and refreshed mtimes implement task policy: build grace is one hour and maintenance grace one minute. Unknown metadata age defers pruning, while unreadable bytes can still expire by observed age; grace expiry is not process-absence proof after heartbeat failure.
+ * @evidence contracts/common.md#clear-and-simple-design Root validation, task publication and collection form one coordination boundary used by builders and maintenance.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Time windows are documented coordination policy; worker/process alternatives address actual synchronous-build and native spawn constraints rather than known fixtures.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains lease purpose and conservative unreadable/clock-skew limits; function and member comments describe release and startup outcomes.
+ * @evidence contracts/portability.md#os-neutral-implementation Native filesystem metadata and Node worker/process APIs provide the boundary without assuming an OS's case policy.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms The namespace groups member-owned processing strategies and performs no scan itself.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Namespace membership establishes no computed-result identity.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Actual records and workers are owned by create/finish operations rather than the namespace declaration.
+ */
+var GoBuildCacheCoordination;
+(function (GoBuildCacheCoordination) {
+    /** Directory of the cache holding one record per running Go build. */
+    GoBuildCacheCoordination.GO_BUILD_CACHE_LEASE_DIR = ".ttsc-build-leases";
+    /** Directory of the cache holding one record per running maintenance pass. */
+    GoBuildCacheCoordination.GO_BUILD_CACHE_MAINTENANCE_DIR = ".ttsc-maintenance";
+    const GO_BUILD_CACHE_COORDINATION_STALE_MS = 60 * 60 * 1000;
+    const GO_BUILD_CACHE_MAINTENANCE_STALE_MS = 60 * 1000;
+    const GO_BUILD_CACHE_COORDINATION_CLOCK_SKEW_MS = 5 * 60 * 1000;
+    const GO_BUILD_CACHE_COORDINATION_HEARTBEAT_MS = 5_000;
+    /**
+     * Create the owned Go cache and return its observed physical directory
+     * spelling.
+     *
+     * The leaf may be user-controlled inside `node_modules/.cache`; accepting a
+     * symlink or junction there would let LRU deletion escape into an arbitrary
+     * two-hex directory. Returning the canonical spelling also keeps the build,
+     * leases, and maintenance address that spelling if an ancestor alias moves.
+     * These sequential observations do not retain a directory handle or prevent
+     * later physical-path replacement.
+     *
+     * @evidence contracts/common.md#principled-implementation lstat rejects aliased leaves and physical parent validation confines the returned Go root to its resolved parent before deletion or builds use it.
+     * @evidence contracts/common.md#clear-and-simple-design Validation returns one physical spelling or throws, so consumers do not carry partially safe paths.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Native filesystem facts establish ownership boundaries, not guessed cache names or foreign API mutation.
+     * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain project-controlled leaf risk, ancestor-alias spelling resolution and the absence of a retained directory handle.
+     * @evidence contracts/portability.md#os-neutral-implementation Native realpath/lstat preserve actual identity; no Windows-name check supplies volume case semantics.
+     * @evidence contracts/performance.md#efficient-algorithms Fixed metadata calls validate the leaf; path resolution and recursive creation scale with ancestor depth.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Mutable aliases are checked per operation rather than cached without an invalidation witness.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Validation opens no persistent handle and owns no cache entries.
+     */
+    function canonicalGoBuildCacheRoot(root) {
+        node_fs_1.default.mkdirSync(root, { recursive: true });
+        const physicalParent = node_fs_1.default.realpathSync.native(node_path_1.default.dirname(root));
+        const stats = node_fs_1.default.lstatSync(root);
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+            throw new Error(`ttsc: unsafe Go build cache root: ${root}`);
+        }
+        const physicalRoot = node_fs_1.default.realpathSync.native(root);
+        if (node_path_1.default.dirname(physicalRoot) !== physicalParent) {
+            throw new Error(`ttsc: Go build cache root escaped its parent: ${root}`);
+        }
+        return physicalRoot;
+    }
+    GoBuildCacheCoordination.canonicalGoBuildCacheRoot = canonicalGoBuildCacheRoot;
+    /**
+     * Publish an `active` record for this process in the coordination directory
+     * `directoryName` of the cache at `root`.
+     *
+     * @evidence contracts/common.md#principled-implementation A random process-qualified record distinguishes concurrent tasks, atomic metadata publishes active/complete states and terminal finish prevents restart.
+     * @evidence contracts/common.md#clear-and-simple-design Returned callbacks close over exactly one record, heartbeat and terminal flag rather than a global task registry.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Random uniqueness and completion-before-unlink address real concurrent publication and cleanup failures; no consumer identity is privileged.
+     * @evidence contracts/common.md#meaningful-documentation Native type/member comments describe ownership and release semantics while the factory identifies the publication location.
+     * @evidence contracts/portability.md#os-neutral-implementation Native path, hostname and atomic entry publication identify the local task without assuming PID meaning on another host.
+     * @evidence contracts/performance.md#efficient-algorithms Publication validates native coordination paths and atomically writes one host/PID/status record, with path/JSON-byte costs. Startup is lazy and shares the stored capability; it includes worker construction or child launch/readiness observations rather than just record writes.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A task lease is not a cached build answer; producer identity and lock sharing belong to the build owner.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources The caller receives one record and lazy refresher capability and must call finish after its synchronous task. Termination and actual exit/close are tracked for opted-in owners to join after synchronous work; ordinary callers request termination without joining. Failed startup can overlap fallback; scoped unknown native closure retains the exact lease without age expiry, while unguarded failed completion/removal follows age/uncertainty policy. This factory imposes no cross-task population bound.
+     */
+    function createGoBuildCacheCoordinationRecord(root, directoryName) {
+        const directory = goBuildCacheCoordinationDirectory(root, directoryName, true);
+        const record = node_path_1.default.join(directory, `${process.pid}-${node_crypto_1.default.randomBytes(16).toString("hex")}.json`);
+        const metadata = {
+            directoryName,
+            hostname: node_os_1.default.hostname(),
+            pid: process.pid,
+            startedAt: Date.now(),
+        };
+        writeGoBuildCacheCoordinationRecord(record, metadata, "active");
+        if (directoryName === GoBuildCacheCoordination.GO_BUILD_CACHE_LEASE_DIR)
+            SourceNativeRetirement_1.SourceNativeRetirement.register({
+                fenceRoot: root,
+                retainedPaths: [root, record],
+                generation: node_path_1.default.basename(record),
+            });
+        let heartbeat;
+        let finished = false;
+        return {
+            file: record,
+            finish: () => {
+                if (finished)
+                    return;
+                finished = true;
+                try {
+                    heartbeat?.stop();
+                }
+                catch (error) {
+                    trackGoBuildCacheRetirement(Promise.reject(error));
+                    // Native termination failure must not skip completion publication.
+                }
+                heartbeat = undefined;
+                SourceNativeRetirement_1.SourceNativeRetirement.release(() => {
+                    SourceNativeRetirement_1.SourceNativeRetirement.assertReleasable(root, node_path_1.default.basename(record));
+                    // A failed unlink must not leave a completed task looking active until
+                    // its stale timeout. Persist completion first; collectors discard it.
+                    try {
+                        writeGoBuildCacheCoordinationRecord(record, metadata, "complete");
+                    }
+                    catch { }
+                    try {
+                        node_fs_1.default.rmSync(record, { force: true });
+                    }
+                    catch { }
+                    SourceNativeRetirement_1.SourceNativeRetirement.forget(root, node_path_1.default.basename(record));
+                });
+            },
+            startHeartbeat: () => {
+                if (finished)
+                    return false;
+                heartbeat ??= startGoBuildCacheHeartbeat(record);
+                return heartbeat !== undefined;
+            },
+        };
+    }
+    GoBuildCacheCoordination.createGoBuildCacheCoordinationRecord = createGoBuildCacheCoordinationRecord;
+    /** Publish a complete coordination state through the shared atomic writer. */
+    function writeGoBuildCacheCoordinationRecord(file, metadata, status) {
+        SourceBuildCacheLayout_1.SourceBuildCacheLayout.replaceCacheMetadataFile(file, `${JSON.stringify({ ...metadata, status, version: 1 })}\n`);
+    }
+    /**
+     * Refresh one synchronous task independently of the blocked parent thread.
+     *
+     * Initialization is acknowledged before success. Later inaccessible record
+     * writes can still stop freshness, so collection retains its conservative
+     * grace and uncertainty policy rather than claiming perfect liveness.
+     */
+    function startGoBuildCacheHeartbeat(file) {
+        const control = new SharedArrayBuffer(4);
+        const state = new Int32Array(control);
+        try {
+            const worker = new node_worker_threads_1.Worker([
+                'const fs = process.getBuiltinModule("node:fs");',
+                'const { workerData } = process.getBuiltinModule("node:worker_threads");',
+                "const state = new Int32Array(workerData.control);",
+                "Atomics.store(state, 0, 1);",
+                "Atomics.notify(state, 0);",
+                "for (;;) {",
+                "  const result = Atomics.wait(state, 0, 1, workerData.interval);",
+                '  if (result !== "timed-out" || Atomics.load(state, 0) !== 1) break;',
+                "  try {",
+                "    const now = new Date();",
+                "    fs.utimesSync(workerData.file, now, now);",
+                "  } catch {}",
+                "}",
+            ].join("\n"), {
+                eval: true,
+                workerData: {
+                    control,
+                    file,
+                    interval: GO_BUILD_CACHE_COORDINATION_HEARTBEAT_MS,
+                },
+            });
+            const owned = OwnedSynchronousProcess_1.OwnedSynchronousProcess.track(new Promise((resolve) => worker.once("exit", () => resolve())));
+            worker.on("error", () => {
+                Atomics.store(state, 0, 2);
+                Atomics.notify(state, 0);
+            });
+            if (!owned)
+                worker.unref();
+            Atomics.wait(state, 0, 0, GO_BUILD_CACHE_COORDINATION_HEARTBEAT_MS);
+            if (Atomics.load(state, 0) === 1) {
+                return {
+                    stop: () => {
+                        Atomics.store(state, 0, 2);
+                        Atomics.notify(state, 0);
+                        retireGoBuildCacheWorker(worker);
+                    },
+                };
+            }
+            Atomics.store(state, 0, 2);
+            Atomics.notify(state, 0);
+            retireGoBuildCacheWorker(worker);
+        }
+        catch { }
+        // Node's permission model can deny Worker construction while still allowing
+        // the child process required for `go build`. The fallback inherits only the
+        // low standard descriptors and checks its parent PID. An IPC channel would
+        // allocate another high descriptor and recreate Darwin's spawn EBADF limit.
+        const ready = `${file}.heartbeat-${node_crypto_1.default.randomBytes(16).toString("hex")}`;
+        let heartbeatChild;
+        try {
+            const heartbeatArgs = [
+                "-e",
+                [
+                    'const fs = require("node:fs");',
+                    "const file = process.argv[1];",
+                    "const interval = Number(process.argv[2]);",
+                    "const parent = Number(process.argv[3]);",
+                    "const ready = process.argv[4];",
+                    "const timer = setInterval(() => {",
+                    "  try { process.kill(parent, 0); } catch { clearInterval(timer); process.exit(0); }",
+                    "  try {",
+                    '    if (JSON.parse(fs.readFileSync(file, "utf8")).status === "complete") {',
+                    "      clearInterval(timer); process.exit(0);",
+                    "    }",
+                    "    const now = new Date();",
+                    "    fs.utimesSync(file, now, now);",
+                    '  } catch (error) { if (error.code === "ENOENT") { clearInterval(timer); process.exit(0); } }',
+                    "}, interval);",
+                    'try { fs.writeFileSync(ready, "ready", { flag: "wx" }); }',
+                    "catch { clearInterval(timer); process.exit(1); }",
+                ].join("\n"),
+                file,
+                String(GO_BUILD_CACHE_COORDINATION_HEARTBEAT_MS),
+                String(process.pid),
+                ready,
+            ];
+            const trace = E2ETrace_1.E2ETrace.begin(process.execPath, heartbeatArgs, {}, "go-cache-heartbeat");
+            const child = (0, node_child_process_1.spawn)(process.execPath, heartbeatArgs, {
+                stdio: [0, 1, 2],
+                windowsHide: true,
+            });
+            const owned = OwnedSynchronousProcess_1.OwnedSynchronousProcess.track(new Promise((resolve) => child.once("close", () => resolve())));
+            heartbeatChild = child;
+            E2ETrace_1.E2ETrace.asynchronous(trace, child);
+            trackGoBuildCacheRetirement(new Promise((resolve, reject) => {
+                // Capture this promise while the lexical scope is installed: these
+                // events run after the synchronous callback restores its scope.
+                child.on("error", (error) => {
+                    // A failed spawn can fall back to unavailable. A launched child's
+                    // control failure must reach its owner even if it later closes.
+                    if (child.pid !== undefined)
+                        reject(error);
+                });
+                child.once("close", () => resolve());
+            }));
+            if (!owned)
+                child.unref();
+            if (child.pid === undefined)
+                return undefined;
+            const deadline = performance.now() + GO_BUILD_CACHE_COORDINATION_HEARTBEAT_MS;
+            while (!node_fs_1.default.existsSync(ready)) {
+                if (performance.now() >= deadline) {
+                    retireGoBuildCacheChild(child);
+                    return undefined;
+                }
+                Atomics.wait(state, 0, Atomics.load(state, 0), 10);
+            }
+            return {
+                stop: () => {
+                    retireGoBuildCacheChild(child);
+                },
+            };
+        }
+        catch {
+            try {
+                if (heartbeatChild !== undefined)
+                    retireGoBuildCacheChild(heartbeatChild);
+            }
+            catch (error) {
+                trackGoBuildCacheRetirement(Promise.reject(error));
+            }
+            return undefined;
+        }
+        finally {
+            try {
+                node_fs_1.default.rmSync(ready, { force: true });
+            }
+            catch { }
+        }
+    }
+    /** Preserve scoped retirement failures without unhandled ordinary rejections. */
+    function trackGoBuildCacheRetirement(retirement) {
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.track(retirement);
+        void retirement.catch(() => undefined);
+    }
+    /** Track a real worker termination request, including synchronous refusal. */
+    function retireGoBuildCacheWorker(worker) {
+        try {
+            trackGoBuildCacheRetirement(worker.terminate());
+        }
+        catch (error) {
+            trackGoBuildCacheRetirement(Promise.reject(error));
+        }
+    }
+    /** A kill request never replaces the independently tracked child close. */
+    function retireGoBuildCacheChild(child) {
+        try {
+            child.kill();
+        }
+        catch (error) {
+            trackGoBuildCacheRetirement(Promise.reject(error));
+            throw error;
+        }
+    }
+    /**
+     * The live records of one coordination directory at `now`. Completed and
+     * age-policy-stale records have deletion attempted; inaccessible metadata is
+     * retained when its age cannot be established safely. Exact native-guarded
+     * build generations are retained independently of status and age. Maintenance
+     * records retain their ordinary freshness policy so unrelated guards cannot
+     * block independent shared-cache builds indefinitely.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact native-guarded build generations override status and age; for unguarded records complete status overrides age, and stale ordinary records have removal attempted. Unknown metadata age or far-future clock observations preserve possible work, while unreadable content alone does not prevent age-based expiry.
+     * @evidence contracts/common.md#clear-and-simple-design One snapshot feeds a liveness helper and best-effort removal, returning only the protected paths.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts PID lifetime is not substituted for task lifetime; actual task status and heartbeat age drive selection.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes completed/stale reclamation from inaccessible metadata retention.
+     * @evidence contracts/portability.md#os-neutral-implementation Native Dirents select ordinary files and sequential lstat/realpath checks validate the coordination directory's observed spelling; no directory handle prevents later replacement.
+     * @evidence contracts/performance.md#efficient-algorithms One native-guard snapshot and generation Set membership avoid repeating a guard scan for each lease; one coordination listing and per-selected-record JSON/mtime reads scale with guard and record counts, path strings and metadata bytes, with arrays retaining entry/path text. Future-clock rebasing can add atomic metadata writes, and stale/complete cleanup adds native removals; directory validation adds native resolution without scanning unrelated cache payloads.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Liveness is time-sensitive and filesystem-mutating collection is not memoized.
+     *
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Unguarded completed and stale records are reclaimed; exact native guards retain build records until qualified closure without age expiry. Unknown metadata or failed deletion can also retain records beyond ordinary grace.
+     */
+    function collectLiveGoBuildCacheCoordinationRecords(root, directoryName, now) {
+        const directory = goBuildCacheCoordinationDirectory(root, directoryName, false);
+        if (directory === undefined)
+            return [];
+        let records;
+        try {
+            records = node_fs_1.default.readdirSync(directory, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const live = [];
+        const protectedGenerations = directoryName === GoBuildCacheCoordination.GO_BUILD_CACHE_LEASE_DIR
+            ? SourceNativeRetirement_1.SourceNativeRetirement.protectedGenerations(root)
+            : new Set();
+        for (const record of records) {
+            if (!record.isFile()) {
+                continue;
+            }
+            const file = node_path_1.default.join(directory, record.name);
+            const protectedNativeInputs = protectedGenerations === undefined ||
+                protectedGenerations.has(record.name);
+            if (protectedNativeInputs ||
+                goBuildCacheCoordinationRecordIsLive(file, directoryName, now)) {
+                live.push(file);
+                continue;
+            }
+            try {
+                node_fs_1.default.rmSync(file, { force: true });
+            }
+            catch { }
+        }
+        return live;
+    }
+    GoBuildCacheCoordination.collectLiveGoBuildCacheCoordinationRecords = collectLiveGoBuildCacheCoordinationRecords;
+    /**
+     * Resolve one private coordination directory without following a project-
+     * supplied symlink or junction outside the owned Go cache.
+     */
+    function goBuildCacheCoordinationDirectory(root, directoryName, create) {
+        if (create)
+            node_fs_1.default.mkdirSync(root, { recursive: true });
+        const directory = node_path_1.default.join(root, directoryName);
+        if (create) {
+            try {
+                node_fs_1.default.mkdirSync(directory);
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+            }
+        }
+        let stats;
+        try {
+            stats = node_fs_1.default.lstatSync(directory);
+        }
+        catch (error) {
+            if (!create && error.code === "ENOENT") {
+                return undefined;
+            }
+            throw error;
+        }
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+            throw new Error(`ttsc: unsafe Go build cache coordination directory: ${directory}`);
+        }
+        const physicalRoot = node_fs_1.default.realpathSync.native(root);
+        const physicalDirectory = node_fs_1.default.realpathSync.native(directory);
+        if (node_path_1.default.dirname(physicalDirectory) !== physicalRoot) {
+            throw new Error(`ttsc: Go build cache coordination directory escaped its root: ${directory}`);
+        }
+        return physicalDirectory;
+    }
+    /** Classify task freshness without deleting under uncertain native state. */
+    function goBuildCacheCoordinationRecordIsLive(file, directoryName, now) {
+        let contents;
+        try {
+            contents = node_fs_1.default.readFileSync(file, "utf8");
+            const parsed = JSON.parse(contents);
+            if (parsed.status === "complete")
+                return false;
+            // Parse valid records for forward compatibility, but do not equate a PID's
+            // lifetime with one task. A failed unlink can leave a record owned by a
+            // still-running Vite process, while a dead Node parent can leave its
+            // spawnSync Go child alive. The heartbeat/grace below models the task.
+            void parsed;
+        }
+        catch { }
+        try {
+            const age = now - node_fs_1.default.statSync(file).mtimeMs;
+            if (age < -GO_BUILD_CACHE_COORDINATION_CLOCK_SKEW_MS) {
+                // A restored cache can carry a far-future timestamp, but the same state
+                // also occurs when the system clock moves backward during a real build.
+                // Rebase the record and grant one ordinary grace period; an active
+                // heartbeat keeps refreshing it, while an orphan then expires normally.
+                // Treat a failed rebase as live too: the safe failure mode is to defer
+                // opportunistic maintenance, never to delete under a possibly live Go.
+                // Replace the directory entry rather than changing its inode in place.
+                // A restored or user-modified cache can contain a hard-linked record;
+                // utimesSync(file) would then mutate metadata outside the owned cache.
+                if (contents !== undefined) {
+                    try {
+                        SourceBuildCacheLayout_1.SourceBuildCacheLayout.replaceCacheMetadataFile(file, contents);
+                    }
+                    catch { }
+                }
+                return true;
+            }
+            const staleMs = directoryName === GoBuildCacheCoordination.GO_BUILD_CACHE_MAINTENANCE_DIR
+                ? GO_BUILD_CACHE_MAINTENANCE_STALE_MS
+                : GO_BUILD_CACHE_COORDINATION_STALE_MS;
+            return age <= staleMs;
+        }
+        catch (error) {
+            return error.code !== "ENOENT";
+        }
+    }
+})(GoBuildCacheCoordination || (exports.GoBuildCacheCoordination = GoBuildCacheCoordination = {}));
+//# sourceMappingURL=GoBuildCacheCoordination.js.map

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

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

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

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+export declare namespace 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.
+     */
+    const BUILD_FLAGS: readonly string[];
+    /**
+     * 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.
+     */
+    const PRUNED_SOURCE_DIRECTORY_NAMES: readonly string[];
+    /**
+     * 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: string, goBuildCacheRoot?: string, effectiveEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+    /**
+     * 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: string): string | null;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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.
+     */
+    const OMITTED_SOURCE_FILE_NAMES: readonly string[];
+    /**
+     * 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.
+     */
+    const OMITTED_SOURCE_FILE_SUFFIXES: readonly string[];
+    /**
+     * 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: string): boolean;
+}