ttsc 0.30.3 → 0.31.0

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

@@ -0,0 +1,36 @@
+import type { PluginBinaryWaitResult } from "./PluginBinaryWaitResult";
+/**
+ * Poll for binary pathname publication using a monotonic admission budget.
+ * `timeoutMs` is checked between observations, not a hard wall-clock limit: the
+ * synchronous inspector can retry internally and native calls can block.
+ *
+ * Pending native guards suppress binary adoption while the existing bounded
+ * wait continues. Unknown or malformed guards refuse immediately. A timeout
+ * includes retained paths and never converts pending into reclaimable state.
+ *
+ * Normal release requests reacquisition and an abandoned owner carries the
+ * exact observed generation. Expiring the monotonic wait budget throws; it
+ * never retires a live or inconclusive owner while its payload task may still
+ * run. An opted-in synchronous owner can cancel observation or interrupt a
+ * polling sleep; cancellation never retires the holder's generation.
+ *
+ * @evidence contracts/common.md#principled-implementation Polling first refuses unknown/malformed native guards, suppresses publication while pending and rechecks after observed release; actual abandoned-owner observations retain their exact generation, while budget expiry fails without revoking a possibly active payload task.
+ * @evidence contracts/common.md#clear-and-simple-design The loop separates publication, release, retirement and periodic status reporting; generation interpretation belongs to inspectPluginBuildLock.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Budget expiry throws instead of retiring a live-looking generation and compensating for concurrent callbacks; status output never substitutes for ownership evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe monotonic wait units, distinct results and timeout failure without retirement; owner-aware diagnostics identify the actual contended key.
+ * @evidence contracts/portability.md#os-neutral-implementation Node filesystem existence and the shared lock inspector implement native observations; waiting uses platform-neutral shared-memory sleep.
+ * @evidence contracts/performance.md#efficient-algorithms Each outer iteration scans native guard metadata, observes an unprotected binary pathname and delegates lock inspection, including its native path/record bytes, observer registration and possible internal retries. Sleeps separate active polls; diagnostic formatting/output is throttled independently and scales with supplied labels/paths. A clock sample taken before inspection is not a hard bound on its duration.
+ * @evidence contracts/performance.md#reuse-equivalent-work After pending guards retire, the waiter adopts the same already-published binary instead of compiling the key again; only an observed released generation triggers ordinary reacquisition.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Scoped cancellation ends this waiter without retiring the builder. Its inspector may register observer records retained until process absence is proven, with growth by distinct generations. Returned outcomes, cancellation checkpoints or observed budget expiry end the outer wait; internal inspection/native calls can delay that boundary without an overall deadline. No asynchronous timer is installed.
+ */
+export declare function waitForPluginBinary(opts: {
+    binaryPath: string;
+    lockDir: string;
+    lockInfo: {
+        label: string;
+        pluginName: string;
+        quiet: boolean;
+    };
+    timeoutMs: number;
+}): PluginBinaryWaitResult;

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

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForPluginBinary = waitForPluginBinary;
+const node_fs_1 = __importDefault(require("node:fs"));
+const OwnedSynchronousProcess_1 = require("../../../internal/OwnedSynchronousProcess");
+const SourceNativeRetirement_1 = require("../../../internal/SourceNativeRetirement");
+const PluginBuildLockProtocol_1 = require("./PluginBuildLockProtocol");
+const formatDuration_1 = require("./formatDuration");
+const inspectPluginBuildLock_1 = require("./inspectPluginBuildLock");
+/**
+ * Poll for binary pathname publication using a monotonic admission budget.
+ * `timeoutMs` is checked between observations, not a hard wall-clock limit: the
+ * synchronous inspector can retry internally and native calls can block.
+ *
+ * Pending native guards suppress binary adoption while the existing bounded
+ * wait continues. Unknown or malformed guards refuse immediately. A timeout
+ * includes retained paths and never converts pending into reclaimable state.
+ *
+ * Normal release requests reacquisition and an abandoned owner carries the
+ * exact observed generation. Expiring the monotonic wait budget throws; it
+ * never retires a live or inconclusive owner while its payload task may still
+ * run. An opted-in synchronous owner can cancel observation or interrupt a
+ * polling sleep; cancellation never retires the holder's generation.
+ *
+ * @evidence contracts/common.md#principled-implementation Polling first refuses unknown/malformed native guards, suppresses publication while pending and rechecks after observed release; actual abandoned-owner observations retain their exact generation, while budget expiry fails without revoking a possibly active payload task.
+ * @evidence contracts/common.md#clear-and-simple-design The loop separates publication, release, retirement and periodic status reporting; generation interpretation belongs to inspectPluginBuildLock.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Budget expiry throws instead of retiring a live-looking generation and compensating for concurrent callbacks; status output never substitutes for ownership evidence.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe monotonic wait units, distinct results and timeout failure without retirement; owner-aware diagnostics identify the actual contended key.
+ * @evidence contracts/portability.md#os-neutral-implementation Node filesystem existence and the shared lock inspector implement native observations; waiting uses platform-neutral shared-memory sleep.
+ * @evidence contracts/performance.md#efficient-algorithms Each outer iteration scans native guard metadata, observes an unprotected binary pathname and delegates lock inspection, including its native path/record bytes, observer registration and possible internal retries. Sleeps separate active polls; diagnostic formatting/output is throttled independently and scales with supplied labels/paths. A clock sample taken before inspection is not a hard bound on its duration.
+ * @evidence contracts/performance.md#reuse-equivalent-work After pending guards retire, the waiter adopts the same already-published binary instead of compiling the key again; only an observed released generation triggers ordinary reacquisition.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Scoped cancellation ends this waiter without retiring the builder. Its inspector may register observer records retained until process absence is proven, with growth by distinct generations. Returned outcomes, cancellation checkpoints or observed budget expiry end the outer wait; internal inspection/native calls can delay that boundary without an overall deadline. No asynchronous timer is installed.
+ */
+function waitForPluginBinary(opts) {
+    const startedAt = performance.now();
+    let nextStatusAt = startedAt + PLUGIN_BUILD_LOCK_STATUS_MS;
+    const protocolDir = PluginBuildLockProtocol_1.PluginBuildLockProtocol.pluginBuildLockProtocolDir(opts.lockDir);
+    for (;;) {
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+        SourceNativeRetirement_1.SourceNativeRetirement.assertAvailable(protocolDir);
+        const protectedNativeInputs = SourceNativeRetirement_1.SourceNativeRetirement.isProtected(protocolDir);
+        if (!protectedNativeInputs && node_fs_1.default.existsSync(opts.binaryPath)) {
+            OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+            return { outcome: "published" };
+        }
+        const clock = performance.now();
+        const lock = (0, inspectPluginBuildLock_1.inspectPluginBuildLock)(opts.lockDir);
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+        if (lock.state === "released") {
+            // The holder retired its generation between the binary check above and
+            // this observation. That is a normal release, not abandonment: prefer the
+            // binary when it landed inside that window, otherwise hand the free key
+            // back to the caller.
+            return !protectedNativeInputs && node_fs_1.default.existsSync(opts.binaryPath)
+                ? { outcome: "published" }
+                : { outcome: "released" };
+        }
+        if (lock.state === "abandoned") {
+            return {
+                outcome: "abandoned",
+                reason: lock.reason,
+                fence: lock.fence,
+            };
+        }
+        if (clock - startedAt >= opts.timeoutMs) {
+            throw new Error(`ttsc: timed out after ${(0, formatDuration_1.formatDuration)(clock - startedAt)} waiting for ` +
+                `${opts.lockInfo.label} "${opts.lockInfo.pluginName}" at ${opts.lockDir}; ` +
+                `${lock.owner} may still be running; ` +
+                `${SourceNativeRetirement_1.SourceNativeRetirement.describeProtection(protocolDir) ?? "native ownership has no additional guard"}`);
+        }
+        if (!opts.lockInfo.quiet && clock >= nextStatusAt) {
+            reportPluginLockWait({
+                binaryPath: opts.binaryPath,
+                elapsedMs: clock - startedAt,
+                lockDir: opts.lockDir,
+                lockInfo: opts.lockInfo,
+                owner: lock.owner,
+            });
+            nextStatusAt = clock + PLUGIN_BUILD_LOCK_STATUS_MS;
+        }
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.sleep(Math.min(PluginBuildLockProtocol_1.PluginBuildLockProtocol.PLUGIN_BUILD_LOCK_POLL_MS, Math.max(0, opts.timeoutMs - (performance.now() - startedAt))));
+    }
+}
+const PLUGIN_BUILD_LOCK_STATUS_MS = 30_000;
+function reportPluginLockWait(opts) {
+    process.stderr.write(`ttsc: waiting for ${opts.lockInfo.label} "${opts.lockInfo.pluginName}" ` +
+        `cache lock after ${(0, formatDuration_1.formatDuration)(opts.elapsedMs)}; ` +
+        `lock=${opts.lockDir}; binary=${opts.binaryPath}; owner=${opts.owner}\n`);
+}
+//# sourceMappingURL=waitForPluginBinary.js.map

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Build the fixed cmd.exe switch sequence for one already quoted payload.
+ *
+ * `/d` disables AutoRun, `/v:off` prevents delayed expansion and `/s /c` run
+ * the prequoted command payload without another shell layer.
+ *
+ * @evidence contracts/common.md#principled-implementation The fixed cmd switches preserve the caller's one-pass quoted payload while disabling ambient AutoRun and delayed expansion.
+ * @evidence contracts/common.md#clear-and-simple-design One argument builder separates shell switches from the shim's payload construction and actual spawning.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts These constants are cmd's documented invocation switches, not arguments chosen to bypass a consumer-specific failure.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains each switch's reason and the already-quoted payload premise.
+ * @evidence contracts/portability.md#os-neutral-implementation This is the isolated Windows wrapper argv boundary; ordinary native executables and POSIX Go tools use direct argv spawning instead.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A fixed five-element argv has no input-dependent processing strategy beyond carrying the supplied payload.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Argument construction has no completed or in-flight computation to coordinate.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The caller owns spawning; this returns argv without acquiring a process or handle.
+ */
+export declare function windowsGoCommandArgs(payload: string): string[];

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.windowsGoCommandArgs = windowsGoCommandArgs;
+/**
+ * Build the fixed cmd.exe switch sequence for one already quoted payload.
+ *
+ * `/d` disables AutoRun, `/v:off` prevents delayed expansion and `/s /c` run
+ * the prequoted command payload without another shell layer.
+ *
+ * @evidence contracts/common.md#principled-implementation The fixed cmd switches preserve the caller's one-pass quoted payload while disabling ambient AutoRun and delayed expansion.
+ * @evidence contracts/common.md#clear-and-simple-design One argument builder separates shell switches from the shim's payload construction and actual spawning.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts These constants are cmd's documented invocation switches, not arguments chosen to bypass a consumer-specific failure.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains each switch's reason and the already-quoted payload premise.
+ * @evidence contracts/portability.md#os-neutral-implementation This is the isolated Windows wrapper argv boundary; ordinary native executables and POSIX Go tools use direct argv spawning instead.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A fixed five-element argv has no input-dependent processing strategy beyond carrying the supplied payload.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Argument construction has no completed or in-flight computation to coordinate.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The caller owns spawning; this returns argv without acquiring a process or handle.
+ */
+function windowsGoCommandArgs(payload) {
+    return ["/d", "/v:off", "/s", "/c", payload];
+}
+//# sourceMappingURL=windowsGoCommandArgs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowsGoCommandArgs.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/windowsGoCommandArgs.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,8BAAqC,OAAe;IAClD,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/C,CAAC"}

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

@@ -0,0 +1,37 @@
+/**
+ * Run one Go build under a cross-process cache lease when ttsc owns the cache.
+ *
+ * The lease is published before checking maintenance. A maintenance process
+ * that arrived first keeps its intent visible, so this builder withdraws and
+ * retries; one that arrives second sees the lease and yields. That ordering
+ * closes the scan/start race without serializing independent Go builds.
+ *
+ * Owned native tasks also register lifetime guards, including caller-selected
+ * unmanaged Go caches. Such guards protect inputs from clean/GC without
+ * granting eviction ownership or preventing independent shared-cache builds.
+ * Unknown closure defers record cleanup; ordinary synchronous callers acquire
+ * no new native-retirement metadata.
+ *
+ * Protection for unguarded calls assumes the coordination heartbeat stays
+ * within its freshness grace; a later suspension or refresh failure is not
+ * process-absence proof. The lease covers the synchronous callback invocation,
+ * not later asynchronous work it might return. Finish requests refresher
+ * shutdown and record cleanup; this synchronous function does not join
+ * termination or guarantee native removal. An opted-in asynchronous owner joins
+ * tracked heartbeat exit/close and receives termination failures after this
+ * operation unwinds. Scoped cancellation checks admission and callback
+ * completion and interrupts contention sleeps. Every acquired record still
+ * requests finish before cancellation leaves this operation.
+ *
+ * @evidence contracts/common.md#principled-implementation Publishing before scanning maintenance makes either ordering visible to the other participant under the coordination freshness premise; startup acknowledgment does not prove continued heartbeat progress, and lease cleanup covers the scan and callback.
+ * @evidence contracts/common.md#clear-and-simple-design Unmanaged caches bypass heartbeat/eviction coordination but owned native tasks register lifetime guards; one retry loop owns managed lease acquisition, maintenance negotiation and finally release.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Maintenance uses the shared live-record protocol instead of assuming no other process writes the cache; contention retries address the actual arbitration requirement.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the two possible arrival orders and why independent builds remain concurrent, with distinct acknowledgment tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Managed roots are physically canonicalized and Node-backed lease/heartbeat operations isolate native coordination details.
+ * @evidence contracts/performance.md#efficient-algorithms Each attempt publishes a record and scans maintenance entries and their path/JSON/mtime bytes, with native directory validation. Contention sleeps between attempts; heartbeat startup adds a worker or Node-child readiness handshake before the callback. Separate builders are not serialized when maintenance is absent. The callback's own build cost is delegated; native calls and startup observation can exceed a between-attempt admission budget check.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A lease protects an individual effectful build; equivalent binary reuse belongs to the outer plugin-key build owner.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Each attempt owns one published record and, after successful startup, one refresher capability. Finally calls finish after scan/startup failure or synchronous callback completion; unresolved native boundaries defer record completion until qualified recovery; this synchronous operation does not join termination, but an opted-in asynchronous owner joins tracked exit/close and receives termination failures. Record/ready-file cleanup is best-effort. A failed worker startup may overlap its requested termination with child fallback; leftover records follow freshness/uncertainty policy rather than a guaranteed removal bound. A returned asynchronous task is outside this callback-invocation lease.
+ */
+export declare function withGoBuildCacheLease<T>(root: string, managed: boolean, callback: (cacheRoot: string) => T): T;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withGoBuildCacheLease = withGoBuildCacheLease;
+const OwnedSynchronousProcess_1 = require("../../../internal/OwnedSynchronousProcess");
+const SourceNativeRetirement_1 = require("../../../internal/SourceNativeRetirement");
+const GoBuildCacheCoordination_1 = require("./GoBuildCacheCoordination");
+const PluginBuildLockProtocol_1 = require("./PluginBuildLockProtocol");
+/**
+ * Run one Go build under a cross-process cache lease when ttsc owns the cache.
+ *
+ * The lease is published before checking maintenance. A maintenance process
+ * that arrived first keeps its intent visible, so this builder withdraws and
+ * retries; one that arrives second sees the lease and yields. That ordering
+ * closes the scan/start race without serializing independent Go builds.
+ *
+ * Owned native tasks also register lifetime guards, including caller-selected
+ * unmanaged Go caches. Such guards protect inputs from clean/GC without
+ * granting eviction ownership or preventing independent shared-cache builds.
+ * Unknown closure defers record cleanup; ordinary synchronous callers acquire
+ * no new native-retirement metadata.
+ *
+ * Protection for unguarded calls assumes the coordination heartbeat stays
+ * within its freshness grace; a later suspension or refresh failure is not
+ * process-absence proof. The lease covers the synchronous callback invocation,
+ * not later asynchronous work it might return. Finish requests refresher
+ * shutdown and record cleanup; this synchronous function does not join
+ * termination or guarantee native removal. An opted-in asynchronous owner joins
+ * tracked heartbeat exit/close and receives termination failures after this
+ * operation unwinds. Scoped cancellation checks admission and callback
+ * completion and interrupts contention sleeps. Every acquired record still
+ * requests finish before cancellation leaves this operation.
+ *
+ * @evidence contracts/common.md#principled-implementation Publishing before scanning maintenance makes either ordering visible to the other participant under the coordination freshness premise; startup acknowledgment does not prove continued heartbeat progress, and lease cleanup covers the scan and callback.
+ * @evidence contracts/common.md#clear-and-simple-design Unmanaged caches bypass heartbeat/eviction coordination but owned native tasks register lifetime guards; one retry loop owns managed lease acquisition, maintenance negotiation and finally release.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Maintenance uses the shared live-record protocol instead of assuming no other process writes the cache; contention retries address the actual arbitration requirement.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains the two possible arrival orders and why independent builds remain concurrent, with distinct acknowledgment tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Managed roots are physically canonicalized and Node-backed lease/heartbeat operations isolate native coordination details.
+ * @evidence contracts/performance.md#efficient-algorithms Each attempt publishes a record and scans maintenance entries and their path/JSON/mtime bytes, with native directory validation. Contention sleeps between attempts; heartbeat startup adds a worker or Node-child readiness handshake before the callback. Separate builders are not serialized when maintenance is absent. The callback's own build cost is delegated; native calls and startup observation can exceed a between-attempt admission budget check.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A lease protects an individual effectful build; equivalent binary reuse belongs to the outer plugin-key build owner.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Each attempt owns one published record and, after successful startup, one refresher capability. Finally calls finish after scan/startup failure or synchronous callback completion; unresolved native boundaries defer record completion until qualified recovery; this synchronous operation does not join termination, but an opted-in asynchronous owner joins tracked exit/close and receives termination failures. Record/ready-file cleanup is best-effort. A failed worker startup may overlap its requested termination with child fallback; leftover records follow freshness/uncertainty policy rather than a guaranteed removal bound. A returned asynchronous task is outside this callback-invocation lease.
+ */
+function withGoBuildCacheLease(root, managed, callback) {
+    OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+    if (!managed) {
+        SourceNativeRetirement_1.SourceNativeRetirement.registerSharedRoot(root);
+        try {
+            const result = callback(root);
+            OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+            return result;
+        }
+        finally {
+            SourceNativeRetirement_1.SourceNativeRetirement.release(() => SourceNativeRetirement_1.SourceNativeRetirement.forget(root));
+        }
+    }
+    const cacheRoot = GoBuildCacheCoordination_1.GoBuildCacheCoordination.canonicalGoBuildCacheRoot(root);
+    const started = performance.now();
+    for (;;) {
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+        const lease = GoBuildCacheCoordination_1.GoBuildCacheCoordination.createGoBuildCacheCoordinationRecord(cacheRoot, GoBuildCacheCoordination_1.GoBuildCacheCoordination.GO_BUILD_CACHE_LEASE_DIR);
+        try {
+            OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+            const maintenance = GoBuildCacheCoordination_1.GoBuildCacheCoordination.collectLiveGoBuildCacheCoordinationRecords(cacheRoot, GoBuildCacheCoordination_1.GoBuildCacheCoordination.GO_BUILD_CACHE_MAINTENANCE_DIR, Date.now());
+            OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+            if (maintenance.length === 0) {
+                if (!lease.startHeartbeat()) {
+                    throw new Error(`ttsc: unable to start Go build cache lease heartbeat at ${cacheRoot}`);
+                }
+                OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+                const result = callback(cacheRoot);
+                OwnedSynchronousProcess_1.OwnedSynchronousProcess.checkpoint();
+                return result;
+            }
+        }
+        finally {
+            lease.finish();
+        }
+        if (performance.now() - started >
+            PluginBuildLockProtocol_1.PluginBuildLockProtocol.PLUGIN_BUILD_LOCK_WAIT_MS) {
+            throw new Error(`ttsc: timed out waiting for Go build cache maintenance at ${cacheRoot}`);
+        }
+        OwnedSynchronousProcess_1.OwnedSynchronousProcess.sleep(GO_BUILD_CACHE_COORDINATION_POLL_MS);
+    }
+}
+const GO_BUILD_CACHE_COORDINATION_POLL_MS = 25;
+//# sourceMappingURL=withGoBuildCacheLease.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withGoBuildCacheLease.js","sourceRoot":"","sources":["../../../../src/plugin/internal/source/withGoBuildCacheLease.ts"],"names":[],"mappings":";;;AAAA,uFAAoF;AACpF,qFAAkF;AAClF,yEAAsE;AACtE,uEAAoE;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,+BACE,IAAY,EACZ,OAAgB,EAChB,QAAkC;IAElC,iDAAuB,CAAC,UAAU,EAAE,CAAC;IACrC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,+CAAsB,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC9B,iDAAuB,CAAC,UAAU,EAAE,CAAC;YACrC,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YACT,+CAAsB,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,+CAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5E,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,mDAAwB,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;IAC3E,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAClC,SAAS,CAAC;QACR,iDAAuB,CAAC,UAAU,EAAE,CAAC;QACrC,MAAM,KAAK,GAAG,mDAAwB,CAAC,oCAAoC,CACzE,SAAS,EACT,mDAAwB,CAAC,wBAAwB,CAClD,CAAC;QACF,IAAI,CAAC;YACH,iDAAuB,CAAC,UAAU,EAAE,CAAC;YACrC,MAAM,WAAW,GACf,mDAAwB,CAAC,0CAA0C,CACjE,SAAS,EACT,mDAAwB,CAAC,8BAA8B,EACvD,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;YACJ,iDAAuB,CAAC,UAAU,EAAE,CAAC;YACrC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC7B,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,CAAC;oBAC5B,MAAM,IAAI,KAAK,CACb,2DAA2D,SAAS,EAAE,CACvE,CAAC;gBACJ,CAAC;gBACD,iDAAuB,CAAC,UAAU,EAAE,CAAC;gBACrC,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;gBACnC,iDAAuB,CAAC,UAAU,EAAE,CAAC;gBACrC,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,CAAC;QACD,IACE,WAAW,CAAC,GAAG,EAAE,GAAG,OAAO;YAC3B,iDAAuB,CAAC,yBAAyB,EACjD,CAAC;YACD,MAAM,IAAI,KAAK,CACb,6DAA6D,SAAS,EAAE,CACzE,CAAC;QACJ,CAAC;QACD,iDAAuB,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAED,MAAM,mCAAmC,GAAG,EAAE,CAAC"}

package/lib/plugin/internal/writeCapabilityResolution.d.ts

@@ -0,0 +1,80 @@
+import type { ITtscCapabilityResolutionEntry } from "./ITtscCapabilityResolutionEntry";
+import type { ITtscCapabilityResolutionPlugin } from "./ITtscCapabilityResolutionPlugin";
+/**
+ * Record the answer and the state it was true for.
+ *
+ * The state is the one the plugin load read, not the one found now: each input
+ * is recorded with the evaluation-time hash and physical path the load proved
+ * (`hostInputHashes`, `hostInputRealpaths`). A later read proves the entry by
+ * comparing those with the filesystem, so hashing the inputs again here would
+ * pair an answer computed from one state with another state, and an input that
+ * moved while the descriptors evaluated would bless the stale answer for as
+ * long as it held still afterwards. An answer with an input the load could not
+ * prove is not recorded at all: nothing could prove it later either, and the
+ * next resolution walks again.
+ *
+ * A write failure is not reported. The cache is an optimization over a walk
+ * that still works, and a read-only or full disk is a reason to be slower, not
+ * a reason to replace a successfully discovered answer. The owning resolver
+ * catches failures in its load/publication block; this does not establish a
+ * never-throws contract for its earlier authority/tool lookup stages.
+ *
+ * Returns the published entry, or null when no complete entry was written.
+ * Publication is not a freshness assertion: the reader must still prove its
+ * recorded observations before dependent results can reuse it. Private opt-in
+ * tracing records the reached refusal branch or successful rename. It neither
+ * retries persistence nor observes an unexecuted proof comparison; failures
+ * inside the trace writer cannot replace this result.
+ *
+ * Default workspace storage is marked before even the clock probe is written,
+ * so a first answer cannot make a later root search choose a different
+ * installation under the root ownership policy. The probe and answer use the
+ * marker's returned physical spelling, not a retained directory handle;
+ * publication assumes that path remains stable. An explicit `TTSC_CACHE_DIR`
+ * remains caller-owned.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained inputs carry load-time hash/realpath and expected authority; default root provenance is marked before clock-probe or answer publication, while source digest acceleration must reconstruct the recorded build state.
+ * @evidence contracts/common.md#clear-and-simple-design The writer persists a narrow copied answer and proof entry; descriptor discovery and binary building remain outside persistence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host proofs are not rehashed now to bless an answer computed earlier; unavailable proof prevents a write, and write failure does not invent a capability answer.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluation-time proof, best-effort persistence and first-write default-root selection, with member/tag separation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve/join, the shared physical-root marker and same-directory rename preserve OS-neutral identities; source witnesses use actual device metadata.
+ * @evidence contracts/performance.md#efficient-algorithms Normalized path Set deduplication and text-sensitive sorting precede own-key proof copies. Source digest acceleration can enumerate/query signatures twice, read full source bytes and observe build environment; authority/root/probe/publication operations also cost native work. Plugin capability maps, full manifest/context/proof/source text and complete JSON serialization contribute storage and processing beyond plugin count.
+ * @evidence contracts/performance.md#reuse-equivalent-work Persistence stores one complete project answer under the shared format key; later reuse must reprove these exact evaluation/build states rather than treating writing as validation.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Same-directory staging cleanup is attempted in finally and can fail; serialized/copied entry data scales with the full answer and transfers to the caller/storage owner. Default entry pruning has interval/protection/failure limits and caller-selected roots remain caller-owned; transient probe removal is likewise an owning helper's attempt, with no guaranteed deletion or independent byte ceiling here.
+ */
+export declare function writeCapabilityResolution(options: {
+    /** Invocation directory included in the shared cache-entry identity. */
+    cwd: string;
+    /** Selected project config identity used by the matching reader. */
+    tsconfig: string;
+    /** Ttsc product version paired with the cache format revision. */
+    version: string;
+    /** Environment selecting storage, or ambient process env when omitted. */
+    env?: NodeJS.ProcessEnv;
+    /** Pre-load authority key; a moved evaluation authority refuses the write. */
+    expectedAuthority?: string;
+}, answer: {
+    /**
+     * The evaluation-time content hash or unavailable null state reported by
+     * the load. A missing own key is not a recorded observation.
+     */
+    hostInputHashes: Readonly<Record<string, string | null>>;
+    /**
+     * The evaluation-time physical path or unavailable null state reported by
+     * the load. A missing own key is not a recorded observation.
+     */
+    hostInputRealpaths: Readonly<Record<string, string | null>>;
+    /** The files the answer was computed from, as absolute paths. */
+    hostInputs: readonly string[];
+    /** The native plugin-manifest payload preserved verbatim. */
+    manifest: string;
+    /**
+     * Keyed states of the directories included in the load's pluginSources
+     * report; the load owns installed-package exclusions.
+     */
+    pluginSources: Readonly<Record<string, string>>;
+    /** Native project identity payload, or null when no consumer requested it. */
+    projectContext: string | null;
+    /** Ordered sidecar paths and their declared capability maps. */
+    plugins: readonly ITtscCapabilityResolutionPlugin[];
+}): ITtscCapabilityResolutionEntry | null;

package/lib/plugin/internal/writeCapabilityResolution.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCapabilityResolution = writeCapabilityResolution;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const SidecarEnvironment_1 = require("../../compiler/internal/sharedHost/SidecarEnvironment");
+const E2ETrace_1 = require("../../internal/E2ETrace");
+const CapabilityResolutionFormat_1 = require("./CapabilityResolutionFormat");
+const SourceBuildCacheLayout_1 = require("./source/SourceBuildCacheLayout");
+const pluginSourceDigest_1 = require("./source/pluginSourceDigest");
+const pluginSourceFilesSignature_1 = require("./source/pluginSourceFilesSignature");
+const pluginSourceState_1 = require("./source/pluginSourceState");
+/**
+ * Record the answer and the state it was true for.
+ *
+ * The state is the one the plugin load read, not the one found now: each input
+ * is recorded with the evaluation-time hash and physical path the load proved
+ * (`hostInputHashes`, `hostInputRealpaths`). A later read proves the entry by
+ * comparing those with the filesystem, so hashing the inputs again here would
+ * pair an answer computed from one state with another state, and an input that
+ * moved while the descriptors evaluated would bless the stale answer for as
+ * long as it held still afterwards. An answer with an input the load could not
+ * prove is not recorded at all: nothing could prove it later either, and the
+ * next resolution walks again.
+ *
+ * A write failure is not reported. The cache is an optimization over a walk
+ * that still works, and a read-only or full disk is a reason to be slower, not
+ * a reason to replace a successfully discovered answer. The owning resolver
+ * catches failures in its load/publication block; this does not establish a
+ * never-throws contract for its earlier authority/tool lookup stages.
+ *
+ * Returns the published entry, or null when no complete entry was written.
+ * Publication is not a freshness assertion: the reader must still prove its
+ * recorded observations before dependent results can reuse it. Private opt-in
+ * tracing records the reached refusal branch or successful rename. It neither
+ * retries persistence nor observes an unexecuted proof comparison; failures
+ * inside the trace writer cannot replace this result.
+ *
+ * Default workspace storage is marked before even the clock probe is written,
+ * so a first answer cannot make a later root search choose a different
+ * installation under the root ownership policy. The probe and answer use the
+ * marker's returned physical spelling, not a retained directory handle;
+ * publication assumes that path remains stable. An explicit `TTSC_CACHE_DIR`
+ * remains caller-owned.
+ *
+ * @evidence contracts/common.md#principled-implementation Retained inputs carry load-time hash/realpath and expected authority; default root provenance is marked before clock-probe or answer publication, while source digest acceleration must reconstruct the recorded build state.
+ * @evidence contracts/common.md#clear-and-simple-design The writer persists a narrow copied answer and proof entry; descriptor discovery and binary building remain outside persistence.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Host proofs are not rehashed now to bless an answer computed earlier; unavailable proof prevents a write, and write failure does not invent a capability answer.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluation-time proof, best-effort persistence and first-write default-root selection, with member/tag separation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path.resolve/join, the shared physical-root marker and same-directory rename preserve OS-neutral identities; source witnesses use actual device metadata.
+ * @evidence contracts/performance.md#efficient-algorithms Normalized path Set deduplication and text-sensitive sorting precede own-key proof copies. Source digest acceleration can enumerate/query signatures twice, read full source bytes and observe build environment; authority/root/probe/publication operations also cost native work. Plugin capability maps, full manifest/context/proof/source text and complete JSON serialization contribute storage and processing beyond plugin count.
+ * @evidence contracts/performance.md#reuse-equivalent-work Persistence stores one complete project answer under the shared format key; later reuse must reprove these exact evaluation/build states rather than treating writing as validation.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Same-directory staging cleanup is attempted in finally and can fail; serialized/copied entry data scales with the full answer and transfers to the caller/storage owner. Default entry pruning has interval/protection/failure limits and caller-selected roots remain caller-owned; transient probe removal is likewise an owning helper's attempt, with no guaranteed deletion or independent byte ceiling here.
+ */
+function writeCapabilityResolution(options, answer) {
+    let file = CapabilityResolutionFormat_1.CapabilityResolutionFormat.resolutionFile(options);
+    if (file === null) {
+        E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+            reason: "storage-authority-unavailable",
+        });
+        return null;
+    }
+    if (options.expectedAuthority !== undefined &&
+        options.expectedAuthority !== file) {
+        E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+            file,
+            reason: "authority-changed",
+        });
+        return null;
+    }
+    const hostInputs = [
+        ...new Set(answer.hostInputs
+            .filter((input) => input !== "")
+            .map((input) => node_path_1.default.resolve(input))),
+    ].sort();
+    if (hostInputs.length === 0) {
+        E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+            file,
+            reason: "empty-host-inputs",
+        });
+        return null;
+    }
+    const hostInputHashes = {};
+    const hostInputRealpaths = {};
+    for (const input of hostInputs) {
+        const hashPresent = Object.prototype.hasOwnProperty.call(answer.hostInputHashes, input);
+        let realpathPresent;
+        if (!hashPresent ||
+            !(realpathPresent = Object.prototype.hasOwnProperty.call(answer.hostInputRealpaths, input))) {
+            E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+                file,
+                input,
+                reason: "host-proof-missing",
+                hashPresent,
+                realpathPresent,
+            });
+            return null;
+        }
+        hostInputHashes[input] = answer.hostInputHashes[input];
+        hostInputRealpaths[input] = answer.hostInputRealpaths[input];
+    }
+    if (!SidecarEnvironment_1.SidecarEnvironment.read(options.env ?? process.env, "TTSC_CACHE_DIR")) {
+        try {
+            const physicalRoot = SourceBuildCacheLayout_1.SourceBuildCacheLayout.markDefaultWorkspaceCacheRoot(node_path_1.default.dirname(node_path_1.default.dirname(file)));
+            file = node_path_1.default.join(physicalRoot, SourceBuildCacheLayout_1.SourceBuildCacheLayout.CAPABILITY_CACHE_DIRNAME, node_path_1.default.basename(file));
+        }
+        catch {
+            E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+                file,
+                reason: "default-root-unavailable",
+            });
+            return null;
+        }
+    }
+    const evidence = CapabilityResolutionFormat_1.CapabilityResolutionFormat.sourceEvidence(CapabilityResolutionFormat_1.CapabilityResolutionFormat.clockReference(file));
+    const entry = {
+        hostInputHashes,
+        hostInputRealpaths,
+        hostInputs,
+        manifest: answer.manifest,
+        pluginSources: Object.fromEntries(Object.entries(answer.pluginSources).map(([directory, state]) => [
+            directory,
+            recordPluginSource(directory, state, evidence),
+        ])),
+        plugins: answer.plugins.map((plugin) => ({
+            binary: plugin.binary,
+            capabilities: { ...plugin.capabilities },
+        })),
+        projectContext: answer.projectContext,
+        version: CapabilityResolutionFormat_1.CapabilityResolutionFormat.formatVersion(options.version),
+    };
+    const staging = `${file}.${String(process.pid)}.${node_crypto_1.default.randomUUID()}.tmp`;
+    try {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+        // Written beside the target and renamed, so a reader never sees half an
+        // entry: a truncated JSON parses as a failure and falls back, but a
+        // partially written one could parse and be believed.
+        node_fs_1.default.writeFileSync(staging, JSON.stringify(entry), "utf8");
+        node_fs_1.default.renameSync(staging, file);
+        E2ETrace_1.E2ETrace.capabilityResolution("write-published", {
+            file,
+            hostInputs: hostInputs.length,
+        });
+        return entry;
+    }
+    catch {
+        E2ETrace_1.E2ETrace.capabilityResolution("write-refused", {
+            file,
+            reason: "publication-exception",
+        });
+        return null;
+    }
+    finally {
+        try {
+            node_fs_1.default.rmSync(staging, { force: true });
+        }
+        catch {
+            // Cache cleanup must not replace the uncached discovery result.
+        }
+    }
+}
+/**
+ * A plugin source as the entry records it: its state, with the digest of its
+ * files and the metadata signature they were read under when a read can vouch
+ * for both (`ITtscCapabilityPluginSource`).
+ *
+ * The digest is read here, between two signatures, because the load's own
+ * reading is not one this writer can place in time: the digest is kept only
+ * when both signatures agree, every stamp was separable from a reference minted
+ * before the read, and the digest gives the very state the load reported, so
+ * the entry never vouches for sources the binary was not built from. Anything
+ * else records the state alone, which a read proves in full.
+ */
+function recordPluginSource(directory, state, evidence) {
+    try {
+        const before = (0, pluginSourceFilesSignature_1.pluginSourceFilesSignature)(directory, evidence);
+        const digest = (0, pluginSourceDigest_1.pluginSourceDigest)(directory);
+        const after = (0, pluginSourceFilesSignature_1.pluginSourceFilesSignature)(directory, evidence);
+        if (before !== undefined &&
+            after !== undefined &&
+            before.signature === after.signature &&
+            after.separable &&
+            (0, pluginSourceState_1.pluginSourceState)(directory, { sourceDigest: digest }) === state) {
+            return { digest, signature: after.signature, state };
+        }
+    }
+    catch {
+        // A source that cannot be read now is proven in full when the entry is.
+    }
+    return { state };
+}
+//# sourceMappingURL=writeCapabilityResolution.js.map

package/lib/plugin/internal/writeCapabilityResolution.js.map

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