ttsc 0.30.3 → 0.31.0

package/lib/launcher/internal/runtime/reclaimDependencyBuildLock.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reclaimDependencyBuildLock = reclaimDependencyBuildLock;
+const DependencyBuildLockProtocol_1 = require("./DependencyBuildLockProtocol");
+/**
+ * Retire exactly the generation carried by an abandoned observation. Returns
+ * false when that generation is no longer the held one.
+ *
+ * @evidence contracts/common.md#principled-implementation Delegating the observation's generation to fenced retirement prevents a stale recovery attempt from moving a successor's current directory.
+ * @evidence contracts/common.md#clear-and-simple-design This recovery adapter accepts a fence rather than acquisition authority and keeps the retirement algorithm in the shared protocol.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No unconditional recursive deletion or timeout-only removal substitutes for generation-fenced retirement.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states exact-generation recovery and the false result when ownership changed.
+ * @evidence contracts/portability.md#os-neutral-implementation Native rename behavior and contention handling remain in the shared retirement owner; the adapter preserves the caller's native lock path.
+ * @evidence contracts/performance.md#efficient-algorithms The field projection adds constant adapter work to actual generation/path text and native retirement/probe/retry/yield cost. It does not scan holder or tombstone history; delegated contention can still grow total call work.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Reclaim is an ownership-changing effect; a prior result cannot authorize another generation's recovery.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Successful retirement transfers current into its tombstone; false or native failure does not certify recovery. Historical tombstones remain until container removal, and native peer-handle waiting/probe cleanup have no independent bounded completion here.
+ */
+function reclaimDependencyBuildLock(lockDir, fence) {
+    return DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.retireDependencyBuildLock(lockDir, fence.generation);
+}
+//# sourceMappingURL=reclaimDependencyBuildLock.js.map

package/lib/launcher/internal/runtime/reclaimDependencyBuildLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reclaimDependencyBuildLock.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/reclaimDependencyBuildLock.ts"],"names":[],"mappings":";;;AACA,+EAA4E;AAE5E;;;;;;;;;;;;;;GAcG;AACH,oCACE,OAAe,EACf,KAA+B;IAE/B,OAAO,yDAA2B,CAAC,yBAAyB,CAC1D,OAAO,EACP,KAAK,CAAC,UAAU,CACjB,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/runtime/releaseDependencyBuildLock.d.ts

@@ -0,0 +1,17 @@
+import type { DependencyBuildLockLease } from "./DependencyBuildLockLease";
+/**
+ * Retire a held generation during the holder's `finally`. Returns false when
+ * the lease was already retired or no longer holds current.
+ *
+ * @evidence contracts/common.md#principled-implementation The acquired lease supplies the exact retirement generation, so a late finalizer cannot release a successor after recovery.
+ * @evidence contracts/common.md#clear-and-simple-design The holder adapter uses the same fenced retirement owner as reclaim while accepting the distinct acquisition token.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Release preserves the generation fence instead of deleting whichever directory occupies the shared current name.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies finally ownership and explains false after retirement or replacement.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lock-path representation and platform rename semantics stay with the shared protocol implementation.
+ * @evidence contracts/performance.md#efficient-algorithms The field projection delegates one retirement without a history scan; actual generation/path text, native mkdir/rename/sibling probes and peer-handle retry/yield work remain part of this call's cost and can grow with contention.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Release is a generation-specific ownership effect rather than a reusable computation.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Successful retirement moves current into its retained tombstone; false and native failures do not certify release. Peer-handle waiting has no separate deadline and probe-cleanup failures can retain artifacts; container cleanup owns historical state.
+ */
+export declare function releaseDependencyBuildLock(lockDir: string, lease: DependencyBuildLockLease): boolean;

package/lib/launcher/internal/runtime/releaseDependencyBuildLock.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseDependencyBuildLock = releaseDependencyBuildLock;
+const DependencyBuildLockProtocol_1 = require("./DependencyBuildLockProtocol");
+/**
+ * Retire a held generation during the holder's `finally`. Returns false when
+ * the lease was already retired or no longer holds current.
+ *
+ * @evidence contracts/common.md#principled-implementation The acquired lease supplies the exact retirement generation, so a late finalizer cannot release a successor after recovery.
+ * @evidence contracts/common.md#clear-and-simple-design The holder adapter uses the same fenced retirement owner as reclaim while accepting the distinct acquisition token.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Release preserves the generation fence instead of deleting whichever directory occupies the shared current name.
+ * @evidence contracts/common.md#meaningful-documentation Native prose identifies finally ownership and explains false after retirement or replacement.
+ * @evidence contracts/portability.md#os-neutral-implementation Native lock-path representation and platform rename semantics stay with the shared protocol implementation.
+ * @evidence contracts/performance.md#efficient-algorithms The field projection delegates one retirement without a history scan; actual generation/path text, native mkdir/rename/sibling probes and peer-handle retry/yield work remain part of this call's cost and can grow with contention.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Release is a generation-specific ownership effect rather than a reusable computation.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Successful retirement moves current into its retained tombstone; false and native failures do not certify release. Peer-handle waiting has no separate deadline and probe-cleanup failures can retain artifacts; container cleanup owns historical state.
+ */
+function releaseDependencyBuildLock(lockDir, lease) {
+    return DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.retireDependencyBuildLock(lockDir, lease.generation);
+}
+//# sourceMappingURL=releaseDependencyBuildLock.js.map

package/lib/launcher/internal/runtime/releaseDependencyBuildLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseDependencyBuildLock.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/releaseDependencyBuildLock.ts"],"names":[],"mappings":";;;AACA,+EAA4E;AAE5E;;;;;;;;;;;;;;GAcG;AACH,oCACE,OAAe,EACf,KAA+B;IAE/B,OAAO,yDAA2B,CAAC,yBAAyB,CAC1D,OAAO,EACP,KAAK,CAAC,UAAU,CACjB,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/runtime/resolveRuntimeCleanTargets.d.ts

@@ -0,0 +1,34 @@
+/**
+ * What `ttsc clean` removes of a cache root's ttsx runtime directory.
+ *
+ * The runtime directory holds one directory per prepared run, owned by the
+ * processes of that run (`ProcessOwnedDirectory`). A run still in progress
+ * keeps its directory, which clean reports instead of removing. Every other
+ * entry whose owners are all provably gone goes. A run without an owner record
+ * may still belong to an older executable that does not use the lock, so it is
+ * kept alongside live and unreadable owners. When nothing is kept, the whole
+ * runtime directory goes.
+ *
+ * Call while holding `withRuntimeDirectoryLock` for this runtime root, so a new
+ * cooperating run cannot appear between inspection and removal. Physical
+ * spelling and the cooperative lock do not pin native objects or authenticate
+ * owner records against independent mutation.
+ *
+ * @param cacheRoot The resolved cache root.
+ * @returns The directories to remove, and the run directories kept.
+ * @evidence contracts/common.md#principled-implementation Under the root lock, only provably abandoned owner sets become removal targets; live, unknown and unowned runs are preserved, and the physical run index pins external targets before unlinking an empty runtime tree.
+ * @evidence contracts/common.md#clear-and-simple-design The function plans targets and kept runs without performing deletion, separating ownership classification from the clean command's removal effects. Optional observations report the same scan/probe and selected branch to the existing private writer; selection is not a removal receipt.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No unreadable-owner or legacy unowned run is treated as abandoned merely to make clean remove more directories; physical target selection corrects alias identity rather than compensating with lexical retries.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain kept ownership, the required lock and whole-tree removal, with parameters and return fields documented following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native realpath pins a linked run index; path joins retain host spelling and ProcessOwnedDirectory uses conservative local process evidence instead of OS-name case or signal assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms One native realpath/listing and one delegated ownership scan per run process E entries plus owner filenames/JSON bytes, host labels and native process observations. Native path text and IO latency are additional costs; returned target/kept strings scale with listed entries and their path bytes, not only entry count.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Ownership can change between clean invocations; the caller's held lock validates only this plan, not a reusable historical plan.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns a removal plan and closes synchronous reads; the clean command owns deletion, and live processes retain their own run resources.
+ */
+export declare function resolveRuntimeCleanTargets(cacheRoot: string): {
+    /** Run directories protected by live, unknown or absent ownership evidence. */
+    kept: string[];
+    /** Pinned abandoned targets, followed by the runtime tree when none is kept. */
+    targets: string[];
+};

package/lib/launcher/internal/runtime/resolveRuntimeCleanTargets.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeCleanTargets = resolveRuntimeCleanTargets;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const E2ETrace_1 = require("../../../internal/E2ETrace");
+const SourceBuildCacheLayout_1 = require("../../../plugin/internal/source/SourceBuildCacheLayout");
+const ProcessOwnedDirectory_1 = require("./ProcessOwnedDirectory");
+/**
+ * What `ttsc clean` removes of a cache root's ttsx runtime directory.
+ *
+ * The runtime directory holds one directory per prepared run, owned by the
+ * processes of that run (`ProcessOwnedDirectory`). A run still in progress
+ * keeps its directory, which clean reports instead of removing. Every other
+ * entry whose owners are all provably gone goes. A run without an owner record
+ * may still belong to an older executable that does not use the lock, so it is
+ * kept alongside live and unreadable owners. When nothing is kept, the whole
+ * runtime directory goes.
+ *
+ * Call while holding `withRuntimeDirectoryLock` for this runtime root, so a new
+ * cooperating run cannot appear between inspection and removal. Physical
+ * spelling and the cooperative lock do not pin native objects or authenticate
+ * owner records against independent mutation.
+ *
+ * @param cacheRoot The resolved cache root.
+ * @returns The directories to remove, and the run directories kept.
+ * @evidence contracts/common.md#principled-implementation Under the root lock, only provably abandoned owner sets become removal targets; live, unknown and unowned runs are preserved, and the physical run index pins external targets before unlinking an empty runtime tree.
+ * @evidence contracts/common.md#clear-and-simple-design The function plans targets and kept runs without performing deletion, separating ownership classification from the clean command's removal effects. Optional observations report the same scan/probe and selected branch to the existing private writer; selection is not a removal receipt.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No unreadable-owner or legacy unowned run is treated as abandoned merely to make clean remove more directories; physical target selection corrects alias identity rather than compensating with lexical retries.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain kept ownership, the required lock and whole-tree removal, with parameters and return fields documented following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native realpath pins a linked run index; path joins retain host spelling and ProcessOwnedDirectory uses conservative local process evidence instead of OS-name case or signal assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms One native realpath/listing and one delegated ownership scan per run process E entries plus owner filenames/JSON bytes, host labels and native process observations. Native path text and IO latency are additional costs; returned target/kept strings scale with listed entries and their path bytes, not only entry count.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Ownership can change between clean invocations; the caller's held lock validates only this plan, not a reusable historical plan.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The call returns a removal plan and closes synchronous reads; the clean command owns deletion, and live processes retain their own run resources.
+ */
+function resolveRuntimeCleanTargets(cacheRoot) {
+    const runtime = node_path_1.default.join(cacheRoot, SourceBuildCacheLayout_1.SourceBuildCacheLayout.RUNTIME_CACHE_DIRNAME);
+    const runs = node_path_1.default.join(runtime, SourceBuildCacheLayout_1.SourceBuildCacheLayout.RUNTIME_PROJECT_DIRNAME);
+    let entries;
+    let physicalRuns;
+    try {
+        // The run index can be reached through a junction. Record its current
+        // physical spelling so a later index retarget alone does not redirect
+        // planned children; this is not a pinned native object handle.
+        physicalRuns = node_fs_1.default.realpathSync.native(runs);
+        entries = node_fs_1.default.readdirSync(physicalRuns);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            return { kept: [], targets: [runtime] };
+        }
+        throw error;
+    }
+    const kept = [];
+    const removable = [];
+    for (const entry of entries) {
+        const directory = node_path_1.default.join(physicalRuns, entry);
+        const observe = E2ETrace_1.E2ETrace.runtimeCleanup(directory, runtime, "runtime-clean-selection");
+        observe?.("selection-started");
+        let ownership;
+        try {
+            ownership = ProcessOwnedDirectory_1.ProcessOwnedDirectory.ownership(directory, false, observe === undefined ? undefined : (observation) => observe("owner-observation", undefined, undefined, observation));
+        }
+        catch (cause) {
+            observe?.("selection-failed", undefined, cause);
+            throw cause;
+        }
+        observe?.("ownership", ownership);
+        if (ownership !== "abandoned")
+            kept.push(directory);
+        else
+            removable.push(directory);
+        observe?.(ownership === "abandoned" ? "removal-selected" : "retention-selected", ownership);
+    }
+    return {
+        kept,
+        // Remove pinned external run targets before removing a runtime link. A
+        // whole-tree removal alone would only unlink the index and strand those
+        // abandoned generations in its old physical target.
+        targets: kept.length === 0 ? [...removable, runtime] : removable,
+    };
+}
+//# sourceMappingURL=resolveRuntimeCleanTargets.js.map

package/lib/launcher/internal/runtime/resolveRuntimeCleanTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRuntimeCleanTargets.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/resolveRuntimeCleanTargets.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAE7B,yDAAsD;AACtD,mGAAgG;AAChG,mEAAgE;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,oCAA2C,SAAiB;IAO1D,MAAM,OAAO,GAAG,mBAAI,CAAC,IAAI,CACvB,SAAS,EACT,+CAAsB,CAAC,qBAAqB,CAC7C,CAAC;IACF,MAAM,IAAI,GAAG,mBAAI,CAAC,IAAI,CACpB,OAAO,EACP,+CAAsB,CAAC,uBAAuB,CAC/C,CAAC;IACF,IAAI,OAAiB,CAAC;IACtB,IAAI,YAAoB,CAAC;IACzB,IAAI,CAAC;QACH,sEAAsE;QACtE,sEAAsE;QACtE,+DAA+D;QAC/D,YAAY,GAAG,iBAAE,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5C,OAAO,GAAG,iBAAE,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;IACzC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,GAAI,KAA+B,CAAC,IAAI,CAAC;QACnD,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5C,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;QAC1C,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,SAAS,GAAa,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAG,mBAAI,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QACjD,MAAM,OAAO,GAAG,mBAAQ,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE,yBAAyB,CAAC,CAAC;QACvF,OAAO,EAAE,CAAC,mBAAmB,CAAC,CAAC;QAC/B,IAAI,SAA6D,CAAC;QAClE,IAAI,CAAC;YACH,SAAS,GAAG,6CAAqB,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,EAC1D,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAClD,OAAO,CAAC,mBAAmB,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;QACvE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,CAAC,kBAAkB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAChD,MAAM,KAAK,CAAC;QACd,CAAC;QACD,OAAO,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAClC,IAAI,SAAS,KAAK,WAAW;YAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;;YAC/C,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/B,OAAO,EAAE,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO;QACL,IAAI;QACJ,uEAAuE;QACvE,wEAAwE;QACxE,oDAAoD;QACpD,OAAO,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;KACjE,CAAC;AACJ,CAAC"}

package/lib/launcher/internal/runtime/restoreStrippedNodeBuiltinScheme.d.ts

@@ -0,0 +1,20 @@
+import type { ResolveResult } from "./ResolveResult";
+/**
+ * Restore a `node:` builtin URL when affected Node releases return the exact
+ * prefix-stripped spelling from their synchronous CommonJS resolver.
+ *
+ * Every other result passes through unchanged. In particular, a user hook that
+ * intentionally remaps a `node:` specifier to another URL retains ownership of
+ * that mapping, while ordinary and ESM builtin results already carrying the
+ * scheme avoid an unnecessary copy.
+ *
+ * @evidence contracts/common.md#principled-implementation Restoration requires a real builtin, an explicit node: request and the exact stripped result; any other mapping remains owned by the resolver that produced it.
+ * @evidence contracts/common.md#clear-and-simple-design One result adapter isolates the documented synchronous CommonJS scheme difference without rerunning resolution or duplicating builtin tables.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The compatibility path addresses an actual supported Node result shape through isBuiltin; it neither overrides intentional user remaps nor patches a foreign resolver.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain exact restoration scope, user-hook ownership and unchanged ESM/builtin results.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns the supplied result or one shallow copy and retains nothing.
+ * @evidence contracts/performance.md#efficient-algorithms Builtin lookup and prefix/sliced-text equality observe the supplied specifier and URL text; restoration allocates one shallow result copy, observing its enumerable fields. There is no recursive filesystem scan or retained result memo.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A pure function of its two arguments with nothing to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares specifier and URL strings and checks isBuiltin; it builds no path and touches no filesystem.
+ */
+export declare function restoreStrippedNodeBuiltinScheme(specifier: string, result: ResolveResult): ResolveResult;

package/lib/launcher/internal/runtime/restoreStrippedNodeBuiltinScheme.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreStrippedNodeBuiltinScheme = restoreStrippedNodeBuiltinScheme;
+const node_module_1 = require("node:module");
+/**
+ * Restore a `node:` builtin URL when affected Node releases return the exact
+ * prefix-stripped spelling from their synchronous CommonJS resolver.
+ *
+ * Every other result passes through unchanged. In particular, a user hook that
+ * intentionally remaps a `node:` specifier to another URL retains ownership of
+ * that mapping, while ordinary and ESM builtin results already carrying the
+ * scheme avoid an unnecessary copy.
+ *
+ * @evidence contracts/common.md#principled-implementation Restoration requires a real builtin, an explicit node: request and the exact stripped result; any other mapping remains owned by the resolver that produced it.
+ * @evidence contracts/common.md#clear-and-simple-design One result adapter isolates the documented synchronous CommonJS scheme difference without rerunning resolution or duplicating builtin tables.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The compatibility path addresses an actual supported Node result shape through isBuiltin; it neither overrides intentional user remaps nor patches a foreign resolver.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain exact restoration scope, user-hook ownership and unchanged ESM/builtin results.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Returns the supplied result or one shallow copy and retains nothing.
+ * @evidence contracts/performance.md#efficient-algorithms Builtin lookup and prefix/sliced-text equality observe the supplied specifier and URL text; restoration allocates one shallow result copy, observing its enumerable fields. There is no recursive filesystem scan or retained result memo.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A pure function of its two arguments with nothing to share.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Compares specifier and URL strings and checks isBuiltin; it builds no path and touches no filesystem.
+ */
+function restoreStrippedNodeBuiltinScheme(specifier, result) {
+    return (0, node_module_1.isBuiltin)(specifier) &&
+        specifier.startsWith("node:") &&
+        result.url === specifier.slice("node:".length)
+        ? { ...result, url: specifier }
+        : result;
+}
+//# sourceMappingURL=restoreStrippedNodeBuiltinScheme.js.map

package/lib/launcher/internal/runtime/restoreStrippedNodeBuiltinScheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreStrippedNodeBuiltinScheme.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/restoreStrippedNodeBuiltinScheme.ts"],"names":[],"mappings":";;;AAAA,6CAAwC;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,0CACE,SAAiB,EACjB,MAAqB;IAErB,OAAO,IAAA,uBAAS,EAAC,SAAS,CAAC;QACzB,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC;QAC7B,MAAM,CAAC,GAAG,KAAK,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAC9C,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE;QAC/B,CAAC,CAAC,MAAM,CAAC;AACb,CAAC"}

package/lib/launcher/internal/runtime/runtimeRunKey.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This process's run key, which names the runtime directories it prepares: the
+ * process id, so a person reading the cache can tell which process a directory
+ * belongs to, followed by a nonce.
+ *
+ * A process id alone names a directory another run may hold too. A process of
+ * another host sharing the cache root can have the same id, and a later process
+ * given the id of one that was killed would claim the directory a sweep is
+ * removing as abandoned (`ProcessOwnedDirectory.sweep`). The nonce lowers this
+ * collision risk; a finite random identifier cannot guarantee uniqueness. The
+ * memoized key belongs to this loaded module instance. Another instance or
+ * worker can own another key even when Node reports the same process id.
+ *
+ * @returns The same key for every call to this module instance.
+ * @evidence contracts/common.md#principled-implementation Combining the diagnostic pid with a random 64-bit nonce distinguishes successive and cross-host runs that may share a pid; the identifier is probabilistic rather than a security credential.
+ * @evidence contracts/common.md#clear-and-simple-design One module-local lazy value supplies its callers' run identity without caller-specific naming schemes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cryptographic randomness avoids a pid-only identity policy without certifying collision absence; the pid remains explanatory metadata rather than globally unique authority.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared-host/recycled-pid collision risk and finite randomness, and state module-instance stability without promising process-wide singleton identity.
+ * @evidence contracts/performance.md#efficient-algorithms One eight-byte native random draw, hex encoding and native pid text initialize a fixed-size identifier; entropy acquisition can fail or add native latency. Cached access returns its stored string without another draw.
+ * @evidence contracts/performance.md#reuse-equivalent-work Preparations using this loaded module share its identity; a new module instance obtains its own nonce rather than trusting a recycled pid alone.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One identifier remains per loaded module instance for its lifetime; repeated calls do not grow that slot, while module-instance populations and named-directory reclamation belong to their owners.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The reported pid is explanatory scalar text beside random hex, not a process-liveness or filesystem-identity authority. Native path construction, ownership probes and process lifecycle remain with callers.
+ */
+export declare function runtimeRunKey(): string;

package/lib/launcher/internal/runtime/runtimeRunKey.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeRunKey = runtimeRunKey;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+/**
+ * This process's run key, which names the runtime directories it prepares: the
+ * process id, so a person reading the cache can tell which process a directory
+ * belongs to, followed by a nonce.
+ *
+ * A process id alone names a directory another run may hold too. A process of
+ * another host sharing the cache root can have the same id, and a later process
+ * given the id of one that was killed would claim the directory a sweep is
+ * removing as abandoned (`ProcessOwnedDirectory.sweep`). The nonce lowers this
+ * collision risk; a finite random identifier cannot guarantee uniqueness. The
+ * memoized key belongs to this loaded module instance. Another instance or
+ * worker can own another key even when Node reports the same process id.
+ *
+ * @returns The same key for every call to this module instance.
+ * @evidence contracts/common.md#principled-implementation Combining the diagnostic pid with a random 64-bit nonce distinguishes successive and cross-host runs that may share a pid; the identifier is probabilistic rather than a security credential.
+ * @evidence contracts/common.md#clear-and-simple-design One module-local lazy value supplies its callers' run identity without caller-specific naming schemes.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cryptographic randomness avoids a pid-only identity policy without certifying collision absence; the pid remains explanatory metadata rather than globally unique authority.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain shared-host/recycled-pid collision risk and finite randomness, and state module-instance stability without promising process-wide singleton identity.
+ * @evidence contracts/performance.md#efficient-algorithms One eight-byte native random draw, hex encoding and native pid text initialize a fixed-size identifier; entropy acquisition can fail or add native latency. Cached access returns its stored string without another draw.
+ * @evidence contracts/performance.md#reuse-equivalent-work Preparations using this loaded module share its identity; a new module instance obtains its own nonce rather than trusting a recycled pid alone.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One identifier remains per loaded module instance for its lifetime; repeated calls do not grow that slot, while module-instance populations and named-directory reclamation belong to their owners.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The reported pid is explanatory scalar text beside random hex, not a process-liveness or filesystem-identity authority. Native path construction, ownership probes and process lifecycle remain with callers.
+ */
+function runtimeRunKey() {
+    key ??= `${process.pid}-${node_crypto_1.default.randomBytes(8).toString("hex")}`;
+    return key;
+}
+let key;
+//# sourceMappingURL=runtimeRunKey.js.map

package/lib/launcher/internal/runtime/runtimeRunKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeRunKey.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/runtimeRunKey.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAiC;AAEjC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACE,GAAG,KAAK,GAAG,OAAO,CAAC,GAAG,IAAI,qBAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;IAClE,OAAO,GAAG,CAAC;AACb,CAAC;AAED,IAAI,GAAuB,CAAC"}

package/lib/launcher/internal/runtime/selectRuntimePluginPolicy.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeManifest } from "./RuntimeManifest";
+/**
+ * Select the plugin policy shared by runtime project and isolated-root builds.
+ * Descriptor evaluation disables plugins to prevent recursive self-hosting. A
+ * run that disabled them retains that policy for every subsequently loaded
+ * project, independent of which manifest supplied its runtime cache.
+ *
+ * @evidence contracts/common.md#principled-implementation Descriptor evaluation or any manifest with plugins false selects disabled loading; otherwise the owning project's ordinary discovery remains available.
+ * @evidence contracts/common.md#clear-and-simple-design One pure selection owns the same policy for project builds, isolated roots and their cache identity; runtime observation stays with the hook owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit run and evaluator policy determine selection without recognizing plugin names, replacing module methods or manufacturing successful builds.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluator recursion and the inherited run policy across project boundaries, with inputs documented beside the signature.
+ * @evidence contracts/performance.md#efficient-algorithms Descriptor evaluation exits immediately; ordinary selection scans at most M manifest policy fields and stops on the first disabled one without copying inputs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate selects current supplied policy; the build coordinator includes its result in the generation key before admitting reuse.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supplied manifests remain caller-owned and no history, process or handle is retained.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The body selects only the supplied descriptor boolean and manifest plugins discriminant; native project paths, runtime environment reads and build execution belong to the caller, not this predicate.
+ */
+export declare function selectRuntimePluginPolicy(
+/** Build manifests already admitted to the current runtime. */
+manifests: readonly Pick<RuntimeManifest, "plugins">[], 
+/** Whether this invocation evaluates a plugin descriptor. */
+descriptorLoad: boolean): false | undefined;

package/lib/launcher/internal/runtime/selectRuntimePluginPolicy.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectRuntimePluginPolicy = selectRuntimePluginPolicy;
+/**
+ * Select the plugin policy shared by runtime project and isolated-root builds.
+ * Descriptor evaluation disables plugins to prevent recursive self-hosting. A
+ * run that disabled them retains that policy for every subsequently loaded
+ * project, independent of which manifest supplied its runtime cache.
+ *
+ * @evidence contracts/common.md#principled-implementation Descriptor evaluation or any manifest with plugins false selects disabled loading; otherwise the owning project's ordinary discovery remains available.
+ * @evidence contracts/common.md#clear-and-simple-design One pure selection owns the same policy for project builds, isolated roots and their cache identity; runtime observation stays with the hook owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Explicit run and evaluator policy determine selection without recognizing plugin names, replacing module methods or manufacturing successful builds.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain evaluator recursion and the inherited run policy across project boundaries, with inputs documented beside the signature.
+ * @evidence contracts/performance.md#efficient-algorithms Descriptor evaluation exits immediately; ordinary selection scans at most M manifest policy fields and stops on the first disabled one without copying inputs.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This predicate selects current supplied policy; the build coordinator includes its result in the generation key before admitting reuse.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Supplied manifests remain caller-owned and no history, process or handle is retained.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The body selects only the supplied descriptor boolean and manifest plugins discriminant; native project paths, runtime environment reads and build execution belong to the caller, not this predicate.
+ */
+function selectRuntimePluginPolicy(
+/** Build manifests already admitted to the current runtime. */
+manifests, 
+/** Whether this invocation evaluates a plugin descriptor. */
+descriptorLoad) {
+    return descriptorLoad ||
+        manifests.some((manifest) => manifest.plugins === false)
+        ? false
+        : undefined;
+}
+//# sourceMappingURL=selectRuntimePluginPolicy.js.map

package/lib/launcher/internal/runtime/selectRuntimePluginPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectRuntimePluginPolicy.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/selectRuntimePluginPolicy.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;GAcG;AACH;AACE,+DAA+D;AAC/D,SAAsD;AACtD,6DAA6D;AAC7D,cAAuB;IAEvB,OAAO,cAAc;QACnB,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,KAAK,KAAK,CAAC;QACxD,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC"}

package/lib/launcher/internal/runtime/withRuntimeDirectoryLock.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Serialize a runtime-directory claim with `ttsc clean` over the same root.
+ *
+ * The existing fenced directory-lock protocol publishes a complete owner record
+ * before acquisition and retires exactly the generation it held. Its lock lives
+ * beside the runtime root, so clean can remove the root without removing the
+ * coordination point. The shared inspector selects active/abandoned states:
+ * valid owner records use conservative host/pid probes; a readable generation
+ * lacking a valid owner can also become abandoned under its stale-age policy.
+ * That latter policy is not a native certificate that a process died.
+ * Acquisition waits use the dependency-build elapsed-time policy rather than a
+ * hard completion bound on native IO, work or retirement.
+ *
+ * Retirement may separately wait for peer filesystem handles; that release path
+ * has no independent deadline. Participants must use the same stable physical
+ * namespace and valid records. A physical spelling is not a held directory
+ * handle. Native acquisition or cleanup failure can leave persisted
+ * candidate/current state; this wrapper does not roll back a failed acquisition
+ * before it returns a lease.
+ *
+ * @param runtimeRoot The runtime directory, in any filesystem spelling.
+ * @param work A synchronous claim or clean operation under the lock.
+ * @returns What `work` returned.
+ * @evidence contracts/common.md#principled-implementation Resolving the observed physical root selects the cooperative sibling lock; work executes only after a returned lease. Inspector-authorized recovery retires its observed generation, including its owner-missing stale-age policy, without claiming every abandonment decision proves native process death.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous wrapper coordinates root identity, bounded acquisition polling and finally release while delegating the fenced protocol and work/error precedence to shared owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The wrapper follows the actual inspector state and generation fence rather than bypassing a recognized active owner. Missing valid ownership follows the shared stale-age policy; work errors retain precedence through runHoldingLock.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the sibling coordination point, acquisition timeout and unbounded peer-handle retirement; parameters identify native root spelling and synchronous work ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared filesystem identity resolver selects the native physical root and path constructs its sibling lock; retirement isolates platform rename/handle behavior without assuming case policy from an OS name.
+ * @evidence contracts/performance.md#efficient-algorithms Identity/path text and native observations precede polling. Attempts add candidate/generation/hostname record bytes, filesystem IO and inspector probes; contention waits use Atomics.wait and each attempt avoids retired-history scans. Work is caller-defined and retirement can wait independently; the wall-clock acquisition check does not bound blocking native calls or work.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Distinct claim and clean effects must serialize but cannot share a completed work result; each caller supplies its own synchronous effect.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One sleeper and a returned lease belong to the invocation; finally attempts retirement, with no independent peer-handle release deadline. Acquisition failures can leave persisted state before lease transfer. The sibling lock retains candidates/tombstones until appropriate recovery or container removal, with no historical quota here.
+ */
+export declare function withRuntimeDirectoryLock<T>(runtimeRoot: string, work: () => T): T;

package/lib/launcher/internal/runtime/withRuntimeDirectoryLock.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRuntimeDirectoryLock = withRuntimeDirectoryLock;
+const node_path_1 = __importDefault(require("node:path"));
+const resolvePhysicalPath_1 = require("../../../internal/pathIdentity/resolvePhysicalPath");
+const runHoldingLock_1 = require("../../../internal/runHoldingLock");
+const DependencyBuildLockProtocol_1 = require("./DependencyBuildLockProtocol");
+const acquireDependencyBuildLock_1 = require("./acquireDependencyBuildLock");
+const inspectDependencyBuildLock_1 = require("./inspectDependencyBuildLock");
+const reclaimDependencyBuildLock_1 = require("./reclaimDependencyBuildLock");
+const releaseDependencyBuildLock_1 = require("./releaseDependencyBuildLock");
+/**
+ * Serialize a runtime-directory claim with `ttsc clean` over the same root.
+ *
+ * The existing fenced directory-lock protocol publishes a complete owner record
+ * before acquisition and retires exactly the generation it held. Its lock lives
+ * beside the runtime root, so clean can remove the root without removing the
+ * coordination point. The shared inspector selects active/abandoned states:
+ * valid owner records use conservative host/pid probes; a readable generation
+ * lacking a valid owner can also become abandoned under its stale-age policy.
+ * That latter policy is not a native certificate that a process died.
+ * Acquisition waits use the dependency-build elapsed-time policy rather than a
+ * hard completion bound on native IO, work or retirement.
+ *
+ * Retirement may separately wait for peer filesystem handles; that release path
+ * has no independent deadline. Participants must use the same stable physical
+ * namespace and valid records. A physical spelling is not a held directory
+ * handle. Native acquisition or cleanup failure can leave persisted
+ * candidate/current state; this wrapper does not roll back a failed acquisition
+ * before it returns a lease.
+ *
+ * @param runtimeRoot The runtime directory, in any filesystem spelling.
+ * @param work A synchronous claim or clean operation under the lock.
+ * @returns What `work` returned.
+ * @evidence contracts/common.md#principled-implementation Resolving the observed physical root selects the cooperative sibling lock; work executes only after a returned lease. Inspector-authorized recovery retires its observed generation, including its owner-missing stale-age policy, without claiming every abandonment decision proves native process death.
+ * @evidence contracts/common.md#clear-and-simple-design One synchronous wrapper coordinates root identity, bounded acquisition polling and finally release while delegating the fenced protocol and work/error precedence to shared owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The wrapper follows the actual inspector state and generation fence rather than bypassing a recognized active owner. Missing valid ownership follows the shared stale-age policy; work errors retain precedence through runHoldingLock.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the sibling coordination point, acquisition timeout and unbounded peer-handle retirement; parameters identify native root spelling and synchronous work ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared filesystem identity resolver selects the native physical root and path constructs its sibling lock; retirement isolates platform rename/handle behavior without assuming case policy from an OS name.
+ * @evidence contracts/performance.md#efficient-algorithms Identity/path text and native observations precede polling. Attempts add candidate/generation/hostname record bytes, filesystem IO and inspector probes; contention waits use Atomics.wait and each attempt avoids retired-history scans. Work is caller-defined and retirement can wait independently; the wall-clock acquisition check does not bound blocking native calls or work.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Distinct claim and clean effects must serialize but cannot share a completed work result; each caller supplies its own synchronous effect.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One sleeper and a returned lease belong to the invocation; finally attempts retirement, with no independent peer-handle release deadline. Acquisition failures can leave persisted state before lease transfer. The sibling lock retains candidates/tombstones until appropriate recovery or container removal, with no historical quota here.
+ */
+function withRuntimeDirectoryLock(runtimeRoot, work) {
+    const lockDir = `${(0, resolvePhysicalPath_1.resolvePhysicalPath)(node_path_1.default.resolve(runtimeRoot))}.lock`;
+    const startedAt = Date.now();
+    const sleeper = new Int32Array(new SharedArrayBuffer(4));
+    for (;;) {
+        const lease = (0, acquireDependencyBuildLock_1.acquireDependencyBuildLock)(lockDir);
+        if (lease !== null) {
+            return (0, runHoldingLock_1.runHoldingLock)(work, () => {
+                if (!(0, releaseDependencyBuildLock_1.releaseDependencyBuildLock)(lockDir, lease)) {
+                    throw new Error(`runtime directory lock was not released: ${lockDir}`);
+                }
+            }, (error) => {
+                process.emitWarning(`runtime directory lock release failed at ${lockDir}: ${error instanceof Error ? error.message : String(error)}`, { code: "TTSC_RUNTIME_DIRECTORY_LOCK_RELEASE" });
+            });
+        }
+        const now = Date.now();
+        const observed = (0, inspectDependencyBuildLock_1.inspectDependencyBuildLock)(lockDir, now);
+        if (observed.state === "abandoned") {
+            (0, reclaimDependencyBuildLock_1.reclaimDependencyBuildLock)(lockDir, observed.fence);
+        }
+        if (Date.now() - startedAt >=
+            DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_WAIT_MS) {
+            throw new Error(`runtime directory lock did not become available at ${lockDir}: ${observed.state === "active" ? observed.owner : "no holder could be observed"}`);
+        }
+        Atomics.wait(sleeper, 0, 0, DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_POLL_MS);
+    }
+}
+//# sourceMappingURL=withRuntimeDirectoryLock.js.map

package/lib/launcher/internal/runtime/withRuntimeDirectoryLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRuntimeDirectoryLock.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/withRuntimeDirectoryLock.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B,4FAAyF;AACzF,qEAAkE;AAClE,+EAA4E;AAC5E,6EAA0E;AAC1E,6EAA0E;AAC1E,6EAA0E;AAC1E,6EAA0E;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,kCACE,WAAmB,EACnB,IAAa;IAEb,MAAM,OAAO,GAAG,GAAG,IAAA,yCAAmB,EAAC,mBAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC;IACzE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,SAAS,CAAC;QACR,MAAM,KAAK,GAAG,IAAA,uDAA0B,EAAC,OAAO,CAAC,CAAC;QAClD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,IAAA,+BAAc,EACnB,IAAI,EACJ,GAAG,EAAE;gBACH,IAAI,CAAC,IAAA,uDAA0B,EAAC,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC;oBAChD,MAAM,IAAI,KAAK,CACb,4CAA4C,OAAO,EAAE,CACtD,CAAC;gBACJ,CAAC;YACH,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;gBACR,OAAO,CAAC,WAAW,CACjB,4CAA4C,OAAO,KAAK,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAChH,EAAE,IAAI,EAAE,qCAAqC,EAAE,CAChD,CAAC;YACJ,CAAC,CACF,CAAC;QACJ,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,QAAQ,GAAG,IAAA,uDAA0B,EAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAC1D,IAAI,QAAQ,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;YACnC,IAAA,uDAA0B,EAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QACtD,CAAC;QACD,IACE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YACtB,yDAA2B,CAAC,sBAAsB,EAClD,CAAC;YACD,MAAM,IAAI,KAAK,CACb,sDAAsD,OAAO,KAAK,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,6BAA6B,EAAE,CACjJ,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,IAAI,CACV,OAAO,EACP,CAAC,EACD,CAAC,EACD,yDAA2B,CAAC,sBAAsB,CACnD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/lib/launcher/internal/runtimeCompilerArgs.d.ts

@@ -1,9 +1,38 @@
+import { readEffectiveCompilerOptions } from "../../compiler/internal/readEffectiveCompilerOptions";
 import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
 /**
- * Lower proposal syntax in ESNext runtime builds without changing the implied
- * library or module kind. TypeScript-Go preserves standard decorators at
- * ESNext, while Node cannot parse them. Its latest standard target, ES2025,
- * runs the upstream decorator transform and keeps native class-field
- * semantics.
+ * The compiler arguments of a runtime build: the caller's own, plus whatever
+ * requests decorator/JSX lowering and JavaScript emission for Node. This is not
+ * certification of every runtime API or syntax feature. The config, source, and
+ * ordinary `ttsc` output never change.
+ *
+ * Two settings hand syntax Node cannot parse to a later tool, and each is
+ * replaced only in the runtime build, after the forwarded flags so it wins over
+ * them as well as over the config:
+ *
+ * - `target: ESNext` preserves proposal decorators. The build lowers to ES2025,
+ *   TypeScript-Go's latest standard target, which runs the upstream decorator
+ *   lowering policy while retaining the standard class-field target, without
+ *   changing the implied library or module kind.
+ * - `jsx: preserve` and `jsx: react-native` keep JSX. The build compiles it with
+ *   the JSX runtime the type-check already reads.
+ *
+ * A forwarded `--noEmit` or `--emitDeclarationOnly` is switched back off as
+ * well. ttsx forwards the flags before the entry to its type-check, and the
+ * check is unchanged by them, but the runtime build is that check's emit, and
+ * without JavaScript there is nothing to run.
+ *
+ * A caller coordinating one build may supply its effective-options reader for
+ * this exact project and forwarded arguments. Null preserves the compiler's
+ * argument-rejection path; omission creates the reader here.
+ *
+ * @evidence contracts/common.md#principled-implementation Effective compiler options determine runtime-only target/JSX overrides; preserving implied module and library choices keeps the original check's meaning while producing executable syntax.
+ * @evidence contracts/common.md#clear-and-simple-design One ordered argument adapter separates runtime emit policy from project configuration and leaves invalid-argument diagnostics to the compiler.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts ES2025 and JSX discriminants reflect supported compiler transforms; no source-text patch or consumer-specific override substitutes for emission.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain decorator, JSX, library and no-emit decisions and their runtime-only scope without changing the user's project.
+ * @evidence contracts/portability.md#os-neutral-implementation Effective-option resolution delegates response-file parsing to the compiler owner and returns argument tokens rather than shell text or platform-specific paths.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The returned copied argv array belongs to the caller. An internally prepared effective reader is call-local; a supplied reader and its captured config/assignment records remain caller-owned. Delegated response inspection and native showConfig/capture own cleanup attempts; this adapter retains no history or process handle.
+ * @evidence contracts/performance.md#efficient-algorithms Copying A forwarded argument references and text/value queries precedes fixed policy additions. Without a supplied reader, delegated argv/response inspection, native showConfig, full output decoding and JSON parsing are additional input/native costs; the returned argv need not be short.
+ * @evidence contracts/performance.md#reuse-equivalent-work One effective reader serves this call's policy queries, and an actual reader supplied for the same project/arguments avoids preparation repeated across coordinated build adapters. The caller owns that equivalence premise; this adapter caches no historical argv result.
  */
-export declare function runtimeCompilerArgs(project: ITtscParsedProjectConfig, passthrough?: readonly string[], binary?: string): string[];
+export declare function runtimeCompilerArgs(project: ITtscParsedProjectConfig, passthrough?: readonly string[], binary?: string, effectiveOptions?: ReturnType<typeof readEffectiveCompilerOptions>): string[];