ttsc 0.30.4 → 0.31.1

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonJsExportNames = commonJsExportNames;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const parseCommonJsExports_1 = require("../parseCommonJsExports");
+const realPath_1 = require("./realPath");
+/**
+ * Static CommonJS names under the served module's source identity.
+ *
+ * Every re-export resolves through that source's CommonJS require authority,
+ * including package conditions. The reader supplies JavaScript bytes or the
+ * target TypeScript source's own compiler emit; private output paths never
+ * become resolution origins. Targets are not evaluated. Failed resolution adds
+ * no names and leaves the eventual native load to report its error, whereas a
+ * reader's ownership error propagates. Root default metadata is retained for
+ * the facade's native own-property ordering; nested default is not re-exported.
+ *
+ * @evidence contracts/common.md#principled-implementation Node createRequire resolves each edge from the physical source module using require conditions; the runtime supplies its existing source-rescue resolver on supported hook variants. Owned compiler bytes retain TypeScript elision and lowering. Static parsing discovers possible names, while the original loaded helper and facade own values and property semantics.
+ * @evidence contracts/common.md#clear-and-simple-design One traversal serves both JavaScript and TypeScript facades. A call-scoped physical seen set prevents mixed-source cycles and duplicate reads without separate emitted/source resolution policies.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Native package resolution and the runtime's existing relative-source policy decide targets. No package-specific exception, foreign loader replacement or target evaluation supplies names.
+ * @evidence contracts/common.md#meaningful-documentation Native prose states source-origin and owned-reader authority, unresolved versus reader failure, static-only discovery and direct versus nested default semantics.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native require/path resolution and realPath preserve actual filesystem identity, package maps and platform paths without separator rewriting or OS-based casing assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms Each reachable physical target is read and parsed at most once per scan; edges incur native resolution and set insertion. Source bytes, metadata, names and a DFS stack scale with the reachable graph; no configured graph/depth cap bounds parser or reader work.
+ * @evidence contracts/performance.md#reuse-equivalent-work The traversal shares equivalent physical targets within one scan. Compiler-owned emission reuse belongs to the supplied reader; mutable package resolution and source results are not cached across scans here.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Names and visited identities are call-local; only the returned array escapes. The reader and native resolver own their synchronous resources and compiler lifetimes; this scanner retains no historical graph or native handle.
+ */
+function commonJsExportNames(source, filename, readSource, resolve = (parent, specifier) => (0, node_module_1.createRequire)(parent).resolve(specifier)) {
+    const names = new Set();
+    const seen = new Set();
+    const visit = (file, text, root) => {
+        const real = (0, realPath_1.realPath)(file);
+        if (seen.has(real))
+            return;
+        seen.add(real);
+        const parsed = (0, parseCommonJsExports_1.parseCommonJsExports)(text);
+        for (const name of parsed.exports)
+            if (root || name !== "default")
+                names.add(name);
+        for (const specifier of parsed.reexports) {
+            let target;
+            try {
+                target = resolve(real, specifier);
+            }
+            catch {
+                continue;
+            }
+            if (!node_path_1.default.isAbsolute(target))
+                continue;
+            if ([".json", ".node", ".mjs"].includes(node_path_1.default.extname(target)))
+                continue;
+            const physical = (0, realPath_1.realPath)(target);
+            if (seen.has(physical))
+                continue;
+            const nested = readSource(physical);
+            if (nested === null)
+                seen.add(physical);
+            else
+                visit(physical, nested, false);
+        }
+    };
+    visit(filename, source, true);
+    return [...names];
+}
+//# sourceMappingURL=commonJsExportNames.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commonJsExportNames.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/commonJsExportNames.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA4C;AAC5C,0DAA6B;AAE7B,kEAA+D;AAC/D,yCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,6BACE,MAAc,EACd,QAAgB,EAChB,UAA2C,EAC3C,OAAO,GAAkD,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAC7E,IAAA,2BAAa,EAAC,MAAM,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAE1C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,KAAK,GAAG,CAAC,IAAY,EAAE,IAAY,EAAE,IAAa,EAAQ,EAAE;QAChE,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO;QAC3B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,MAAM,MAAM,GAAG,IAAA,2CAAoB,EAAC,IAAI,CAAC,CAAC;QAC1C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,OAAO;YAC/B,IAAI,IAAI,IAAI,IAAI,KAAK,SAAS;gBAAE,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClD,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACzC,IAAI,MAAc,CAAC;YACnB,IAAI,CAAC;gBAAC,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC;gBAAC,SAAS;YAAC,CAAC;YAC9D,IAAI,CAAC,mBAAI,CAAC,UAAU,CAAC,MAAM,CAAC;gBAAE,SAAS;YACvC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,mBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;gBAAE,SAAS;YACxE,MAAM,QAAQ,GAAG,IAAA,mBAAQ,EAAC,MAAM,CAAC,CAAC;YAClC,IAAI,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,SAAS;YACjC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;YACpC,IAAI,MAAM,KAAK,IAAI;gBAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;;gBACnC,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACtC,CAAC;IACH,CAAC,CAAC;IACF,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC9B,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;AACpB,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * The ESM source that stands in for a CommonJS module an ESM `import` reaches.
+ *
+ * The caller selects this adaptation when hook-served CommonJS source needs the
+ * ordinary CommonJS loading lane rather than an ESM loader's narrower
+ * module-local require. The generated source uses public `createRequire` and
+ * the caller's source-aware load boundary, sharing Node's CommonJS cache.
+ * Evaluation occurs with the importer; native load failures still propagate.
+ *
+ * `default` captures `module.exports`. Detected named exports read only own
+ * properties, once after loading; missing/inherited properties and throwing
+ * getters yield undefined, as Node's translator does. Own-property inspection
+ * errors propagate. The supplied marker capability selects either a namespace
+ * `module.exports` alias or the older ordinary named-property behavior,
+ * including its own-property check for a detected `default` name.
+ *
+ * @param url The module's URL, which its `require` resolves from.
+ * @param filename The module's path, which the CommonJS loader loads.
+ * @param names The names Node's static export detection finds for it.
+ * @param moduleExportsKey Whether the runtime's namespace carries
+ *   `module.exports`.
+ * @evidence contracts/common.md#principled-implementation Public createRequire routes loading through the shared CommonJS cache; deduplicated detected names preserve Node's own-only projection, getter-error suppression and capability-selected marker behavior without guessing dynamic exports.
+ * @evidence contracts/common.md#clear-and-simple-design One source builder isolates the ESM-to-CommonJS adaptation; callers supply actual detected names and loader capability rather than embedding another compatibility policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported createRequire and generated ESM adapt the selected public loader lane. JSON quoting protects caller text; only named-property getter errors are suppressed by the specified Node policy, while native load and own-inspection failures propagate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish caller-selected loader adaptation, captured default, own-only names, getter errors and marker/version behavior; parameters identify URL, native filename and supplied capability.
+ * @evidence contracts/performance.md#efficient-algorithms Set deduplication processes N names and their text; temporary arrays/lines and joining scale with generated bytes. Execution separately delegates native module resolution/evaluation/cache work and own-property/getter observations whose cost is not bounded by generation size.
+ * @evidence contracts/performance.md#reuse-equivalent-work The generated facade invokes createRequire so imports and ordinary require share Node's CommonJS evaluation cache; source generation itself remains caller-owned and does not cache mutable name inputs.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary names and source lines end with the call; the returned source and Node's module cache belong to the runtime loader.
+ * @evidence contracts/portability.md#os-neutral-implementation Generated public createRequire receives the caller's module URL and native filename as independently JSON-quoted values, leaving native resolution and filesystem spelling to Node and the caller's source boundary. Supplied marker capability selects namespace representation without OS-name guessing or path rewriting.
+ */
+export declare function commonJsImportFacade(url: string, filename: string, names: readonly string[], moduleExportsKey: boolean): string;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonJsImportFacade = commonJsImportFacade;
+/**
+ * The ESM source that stands in for a CommonJS module an ESM `import` reaches.
+ *
+ * The caller selects this adaptation when hook-served CommonJS source needs the
+ * ordinary CommonJS loading lane rather than an ESM loader's narrower
+ * module-local require. The generated source uses public `createRequire` and
+ * the caller's source-aware load boundary, sharing Node's CommonJS cache.
+ * Evaluation occurs with the importer; native load failures still propagate.
+ *
+ * `default` captures `module.exports`. Detected named exports read only own
+ * properties, once after loading; missing/inherited properties and throwing
+ * getters yield undefined, as Node's translator does. Own-property inspection
+ * errors propagate. The supplied marker capability selects either a namespace
+ * `module.exports` alias or the older ordinary named-property behavior,
+ * including its own-property check for a detected `default` name.
+ *
+ * @param url The module's URL, which its `require` resolves from.
+ * @param filename The module's path, which the CommonJS loader loads.
+ * @param names The names Node's static export detection finds for it.
+ * @param moduleExportsKey Whether the runtime's namespace carries
+ *   `module.exports`.
+ * @evidence contracts/common.md#principled-implementation Public createRequire routes loading through the shared CommonJS cache; deduplicated detected names preserve Node's own-only projection, getter-error suppression and capability-selected marker behavior without guessing dynamic exports.
+ * @evidence contracts/common.md#clear-and-simple-design One source builder isolates the ESM-to-CommonJS adaptation; callers supply actual detected names and loader capability rather than embedding another compatibility policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported createRequire and generated ESM adapt the selected public loader lane. JSON quoting protects caller text; only named-property getter errors are suppressed by the specified Node policy, while native load and own-inspection failures propagate.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish caller-selected loader adaptation, captured default, own-only names, getter errors and marker/version behavior; parameters identify URL, native filename and supplied capability.
+ * @evidence contracts/performance.md#efficient-algorithms Set deduplication processes N names and their text; temporary arrays/lines and joining scale with generated bytes. Execution separately delegates native module resolution/evaluation/cache work and own-property/getter observations whose cost is not bounded by generation size.
+ * @evidence contracts/performance.md#reuse-equivalent-work The generated facade invokes createRequire so imports and ordinary require share Node's CommonJS evaluation cache; source generation itself remains caller-owned and does not cache mutable name inputs.
+ *
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary names and source lines end with the call; the returned source and Node's module cache belong to the runtime loader.
+ * @evidence contracts/portability.md#os-neutral-implementation Generated public createRequire receives the caller's module URL and native filename as independently JSON-quoted values, leaving native resolution and filesystem spelling to Node and the caller's source boundary. Supplied marker capability selects namespace representation without OS-name guessing or path rewriting.
+ */
+function commonJsImportFacade(url, filename, names, moduleExportsKey) {
+    const lines = [
+        `import { createRequire as __ttscCreateRequire } from "node:module";`,
+        `const __ttscHasOwn = Object.hasOwn;`,
+        `const __ttscModule = __ttscCreateRequire(${JSON.stringify(url)})(${JSON.stringify(filename)});`,
+        `export default __ttscModule;`,
+    ];
+    if (moduleExportsKey)
+        lines.push(`export { __ttscModule as "module.exports" };`);
+    [...new Set(names)].forEach((name, index) => {
+        if (name === "default") {
+            if (!moduleExportsKey)
+                lines.push(`__ttscHasOwn(__ttscModule, "default");`);
+            return;
+        }
+        if (name === "module.exports" && moduleExportsKey)
+            return;
+        lines.push(`let __ttscExport${index};`, `if (__ttscHasOwn(__ttscModule, ${JSON.stringify(name)})) {`, `  try { __ttscExport${index} = __ttscModule[${JSON.stringify(name)}]; } catch {}`, `}`, `export { __ttscExport${index} as ${JSON.stringify(name)} };`);
+    });
+    return `${lines.join("\n")}\n`;
+}
+//# sourceMappingURL=commonJsImportFacade.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commonJsImportFacade.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/commonJsImportFacade.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8BACE,GAAW,EACX,QAAgB,EAChB,KAAwB,EACxB,gBAAyB;IAEzB,MAAM,KAAK,GAAG;QACZ,qEAAqE;QACrE,qCAAqC;QACrC,4CAA4C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI;QAChG,8BAA8B;KAC/B,CAAC;IACF,IAAI,gBAAgB;QAClB,KAAK,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;IAC7D,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC1C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,gBAAgB;gBACnB,KAAK,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YACvD,OAAO;QACT,CAAC;QACD,IAAI,IAAI,KAAK,gBAAgB,IAAI,gBAAgB;YAAE,OAAO;QAC1D,KAAK,CAAC,IAAI,CACR,mBAAmB,KAAK,GAAG,EAC3B,kCAAkC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,EAC5D,uBAAuB,KAAK,mBAAmB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,EAClF,GAAG,EACH,wBAAwB,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAC9D,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACjC,CAAC"}

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

@@ -0,0 +1,36 @@
+/**
+ * Derive a dependency build address within its owning run or process cache.
+ *
+ * A key addresses one build context: a dependency project's whole file set, or
+ * with `options.root` one TypeScript root that project's file set does not
+ * contain, compiled alone through its options. Their encodings differ, but the
+ * returned 64-bit truncated digest is not a collision-free generation
+ * identity.
+ *
+ * Compiler identity is supplied by the build coordinator after inspecting the
+ * actual executable; an unavailable proof uses a fresh identity there.
+ *
+ * @evidence contracts/common.md#principled-implementation SHA-256 separates project, isolated-root content, plugin loading policy, emit policy, compiler proof and descriptor process identity with explicit delimiters, so distinct supported build contexts do not intentionally share an address.
+ * @evidence contracts/common.md#clear-and-simple-design One key function combines caller-established identity inputs; executable observation and build memo validity remain with the coordinator that knows when a build is requested.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Default descriptor evaluation uses a module-instance random nonce rather than a recycled pid or shared path-only address; a supplied nonce remains the coordinator's evaluator-identity responsibility.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish project and isolated-root context encoding, compiler proof ownership and truncated-digest limits; nonce comments distinguish probabilistic evaluator separation from guaranteed uniqueness.
+ * @evidence contracts/performance.md#efficient-algorithms Hashing processes B input bytes with fixed digest state; interpolated text and UTF-8 conversion also scale with supplied strings. Module initialization draws the default 16-byte native nonce, whose latency/failure is not bounded by output width. The 16-hex address is a 64-bit truncation, not a collision-free or security identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work Run/process containers scope ordinary module snapshots; the coordinator supplies selected plugin policy, current compiler proof and isolated-root content. The supplied or module-instance random nonce separates evaluator encodings probabilistically, not with an absolute noncollision guarantee; a key alone does not validate edited project dependencies.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Module initialization retains one default descriptor nonce while this module instance remains reachable, even when a caller supplies an override. Digest objects and intermediate strings are call-local; generated directory storage remains with the cache owner.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Caller-established filename and option coordinates are opaque text identity inputs here; hashing makes no native path-equivalence, case, alias or process-liveness decision. Native coordinate selection and cache ownership belong to the coordinator.
+ */
+export declare function dependencyCacheKey(tsconfig: string, options?: {
+    /** Current executable content proof, or a fresh non-reusable identity. */
+    compilerIdentity?: string;
+    /** Whether this build belongs to descriptor evaluation. */
+    descriptorLoad?: boolean;
+    /** Evaluator identity; absent selects this module instance's random nonce. */
+    descriptorNonce?: string;
+    /** Effective false-only plugin loading policy captured for this build. */
+    plugins?: false;
+    /**
+     * The single root a root build compiles, with the digest of its content;
+     * absent for a project build.
+     */
+    root?: string;
+}): string;

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

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyCacheKey = dependencyCacheKey;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+/**
+ * Derive a dependency build address within its owning run or process cache.
+ *
+ * A key addresses one build context: a dependency project's whole file set, or
+ * with `options.root` one TypeScript root that project's file set does not
+ * contain, compiled alone through its options. Their encodings differ, but the
+ * returned 64-bit truncated digest is not a collision-free generation
+ * identity.
+ *
+ * Compiler identity is supplied by the build coordinator after inspecting the
+ * actual executable; an unavailable proof uses a fresh identity there.
+ *
+ * @evidence contracts/common.md#principled-implementation SHA-256 separates project, isolated-root content, plugin loading policy, emit policy, compiler proof and descriptor process identity with explicit delimiters, so distinct supported build contexts do not intentionally share an address.
+ * @evidence contracts/common.md#clear-and-simple-design One key function combines caller-established identity inputs; executable observation and build memo validity remain with the coordinator that knows when a build is requested.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Default descriptor evaluation uses a module-instance random nonce rather than a recycled pid or shared path-only address; a supplied nonce remains the coordinator's evaluator-identity responsibility.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish project and isolated-root context encoding, compiler proof ownership and truncated-digest limits; nonce comments distinguish probabilistic evaluator separation from guaranteed uniqueness.
+ * @evidence contracts/performance.md#efficient-algorithms Hashing processes B input bytes with fixed digest state; interpolated text and UTF-8 conversion also scale with supplied strings. Module initialization draws the default 16-byte native nonce, whose latency/failure is not bounded by output width. The 16-hex address is a 64-bit truncation, not a collision-free or security identity.
+ * @evidence contracts/performance.md#reuse-equivalent-work Run/process containers scope ordinary module snapshots; the coordinator supplies selected plugin policy, current compiler proof and isolated-root content. The supplied or module-instance random nonce separates evaluator encodings probabilistically, not with an absolute noncollision guarantee; a key alone does not validate edited project dependencies.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Module initialization retains one default descriptor nonce while this module instance remains reachable, even when a caller supplies an override. Digest objects and intermediate strings are call-local; generated directory storage remains with the cache owner.
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Caller-established filename and option coordinates are opaque text identity inputs here; hashing makes no native path-equivalence, case, alias or process-liveness decision. Native coordinate selection and cache ownership belong to the coordinator.
+ */
+function dependencyCacheKey(tsconfig, options = {}) {
+    const descriptorLoad = options.descriptorLoad ?? process.env.TTSC_PLUGIN_DESCRIPTOR_LOAD === "1";
+    return (node_crypto_1.default
+        .createHash("sha256")
+        .update(tsconfig)
+        .update("\0runtime-es2025")
+        .update("\0private-output-volume-root-v1")
+        .update(`\0compiler:${options.compilerIdentity ?? ""}`)
+        .update(options.plugins === false ? "\0plugins:disabled" : "\0plugins:discover")
+        .update(options.root === undefined ? "" : `\0root:${options.root}`)
+        // Descriptor evaluation promises a result bound to this process's exact
+        // input observations. Reusing an emit another evaluator built can pair
+        // that process's old source/config bytes with this process's later hashes.
+        // Keep ordinary ttsx worker sharing, but isolate descriptor builds with a
+        // probabilistically distinct evaluator nonce; the registry instance's
+        // `builtProjects` map still shares an owning project's result.
+        .update(descriptorLoad
+        ? `\0descriptor-process:${options.descriptorNonce ?? descriptorProcessCacheNonce}`
+        : "")
+        .digest("hex")
+        .slice(0, 16));
+}
+// Descriptor evaluation needs its own input-bound dependency context. Recycled
+// pids are not a sufficient key while disk storage persists. One default random
+// nonce per module instance reduces accidental evaluator sharing; finite nonce
+// and truncated hash widths do not certify collision-free generation identity.
+// `builtProjects` still shares repeated imports within its registry instance.
+const descriptorProcessCacheNonce = node_crypto_1.default.randomBytes(16).toString("hex");
+//# sourceMappingURL=dependencyCacheKey.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyCacheKey.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/dependencyCacheKey.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAiC;AAEjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4BACE,QAAgB,EAChB,OAAO,GAkBH,EAAE;IAEN,MAAM,cAAc,GAClB,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,2BAA2B,KAAK,GAAG,CAAC;IAC5E,OAAO,CACL,qBAAM;SACH,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,QAAQ,CAAC;SAChB,MAAM,CAAC,kBAAkB,CAAC;SAC1B,MAAM,CAAC,iCAAiC,CAAC;SACzC,MAAM,CAAC,cAAc,OAAO,CAAC,gBAAgB,IAAI,EAAE,EAAE,CAAC;SACtD,MAAM,CACL,OAAO,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,oBAAoB,CACxE;SACA,MAAM,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,OAAO,CAAC,IAAI,EAAE,CAAC;QACnE,wEAAwE;QACxE,uEAAuE;QACvE,2EAA2E;QAC3E,0EAA0E;QAC1E,sEAAsE;QACtE,+DAA+D;SAC9D,MAAM,CACL,cAAc;QACZ,CAAC,CAAC,wBACE,OAAO,CAAC,eAAe,IAAI,2BAC7B,EAAE;QACJ,CAAC,CAAC,EAAE,CACP;SACA,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAChB,CAAC;AACJ,CAAC;AAED,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,+EAA+E;AAC/E,8EAA8E;AAC9E,MAAM,2BAA2B,GAAG,qBAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * The directory dependency builds are cached under.
+ *
+ * A plugin-descriptor evaluator keeps its builds beside its own result file, so
+ * the parent's cleanup of that evaluation removes them too. Otherwise the first
+ * manifest's per-run `depCacheDir` is used, shared by every process of one run
+ * and removed with it.
+ *
+ * Without any manifest there is no run to share with: a child whose environment
+ * dropped `TTSX_RUNTIME_MANIFEST`, or one that loads its first TypeScript after
+ * the launcher removed the manifest. Its builds go to a directory private to
+ * this process with removal attempted by one exit callback. A shared directory
+ * keyed only by the tsconfig path would let an edited dependency keep running
+ * its first build until the temp directory was cleared. A later manifest-less
+ * acquisition attempts to sweep recognized abandoned process directories;
+ * unknown, unowned or non-gone records and native failures can remain
+ * indefinitely. Canonical spellings protect against retargeting the original
+ * alias, not replacement of the observed physical namespace. Descriptor/run
+ * root cleanup is the selecting caller's responsibility, not an outcome
+ * certified here.
+ *
+ * @param env Environment to read the descriptor-evaluation variables from.
+ * @evidence contracts/common.md#principled-implementation Descriptor-owned output, a checked run's depCacheDir and a manifest-less process directory are distinct lifetime authorities; selecting in that order keeps dependency emit with the owner that removes it.
+ * @evidence contracts/common.md#clear-and-simple-design One root selector owns the three supported execution contexts, with process-directory acquisition isolated in a private helper.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A missing manifest selects a genuinely process-owned cache rather than persistent path-only reuse; descriptor channels are explicit host inputs, not fixture-specific names.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain descriptor, run and process ownership and cleanup after forced termination, with the injected environment documented following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Environment selection follows native Windows alias rules. Native realpath/mkdtemp postflight selects a physical temp child; preserving that namespace and distinct host-label ownership remain premises, not path-handle guarantees.
+ * @evidence contracts/performance.md#efficient-algorithms Environment/path selection processes its key/text inputs. Registry access may first read/decode/snapshot inherited manifest bytes or rebuild its M-entry view, then selection scans until a cache is found. First manifest-less acquisition pays sibling names/records/native probes and canonical-child IO; later orphan requests reuse the stored root but still perform context selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work All manifest-less dependency builds in one process share its lazily acquired root; descriptor and run roots share only their explicit owning evaluation or run, avoiding cross-run stale path-only cache reuse.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The process retains one private directory and exit callback. Failed admission attempts rollback and can report combined admission/removal failure; canonical acquisition can fail before this rollback scope. Exit cleanup and later admitted sweeping are best effort, with no historical quota or guaranteed reclamation time; descriptor/run roots transfer cleanup to their owners.
+ */
+export declare function dependencyCacheRoot(env?: NodeJS.ProcessEnv): string;

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

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyCacheRoot = dependencyCacheRoot;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const SidecarEnvironment_1 = require("../../../compiler/internal/sharedHost/SidecarEnvironment");
+const createCanonicalTempDirectory_1 = require("../../../internal/createCanonicalTempDirectory");
+const ProcessOwnedDirectory_1 = require("./ProcessOwnedDirectory");
+const RuntimeManifestRegistry_1 = require("./RuntimeManifestRegistry");
+/**
+ * The directory dependency builds are cached under.
+ *
+ * A plugin-descriptor evaluator keeps its builds beside its own result file, so
+ * the parent's cleanup of that evaluation removes them too. Otherwise the first
+ * manifest's per-run `depCacheDir` is used, shared by every process of one run
+ * and removed with it.
+ *
+ * Without any manifest there is no run to share with: a child whose environment
+ * dropped `TTSX_RUNTIME_MANIFEST`, or one that loads its first TypeScript after
+ * the launcher removed the manifest. Its builds go to a directory private to
+ * this process with removal attempted by one exit callback. A shared directory
+ * keyed only by the tsconfig path would let an edited dependency keep running
+ * its first build until the temp directory was cleared. A later manifest-less
+ * acquisition attempts to sweep recognized abandoned process directories;
+ * unknown, unowned or non-gone records and native failures can remain
+ * indefinitely. Canonical spellings protect against retargeting the original
+ * alias, not replacement of the observed physical namespace. Descriptor/run
+ * root cleanup is the selecting caller's responsibility, not an outcome
+ * certified here.
+ *
+ * @param env Environment to read the descriptor-evaluation variables from.
+ * @evidence contracts/common.md#principled-implementation Descriptor-owned output, a checked run's depCacheDir and a manifest-less process directory are distinct lifetime authorities; selecting in that order keeps dependency emit with the owner that removes it.
+ * @evidence contracts/common.md#clear-and-simple-design One root selector owns the three supported execution contexts, with process-directory acquisition isolated in a private helper.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A missing manifest selects a genuinely process-owned cache rather than persistent path-only reuse; descriptor channels are explicit host inputs, not fixture-specific names.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain descriptor, run and process ownership and cleanup after forced termination, with the injected environment documented following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Environment selection follows native Windows alias rules. Native realpath/mkdtemp postflight selects a physical temp child; preserving that namespace and distinct host-label ownership remain premises, not path-handle guarantees.
+ * @evidence contracts/performance.md#efficient-algorithms Environment/path selection processes its key/text inputs. Registry access may first read/decode/snapshot inherited manifest bytes or rebuild its M-entry view, then selection scans until a cache is found. First manifest-less acquisition pays sibling names/records/native probes and canonical-child IO; later orphan requests reuse the stored root but still perform context selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work All manifest-less dependency builds in one process share its lazily acquired root; descriptor and run roots share only their explicit owning evaluation or run, avoiding cross-run stale path-only cache reuse.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The process retains one private directory and exit callback. Failed admission attempts rollback and can report combined admission/removal failure; canonical acquisition can fail before this rollback scope. Exit cleanup and later admitted sweeping are best effort, with no historical quota or guaranteed reclamation time; descriptor/run roots transfer cleanup to their owners.
+ */
+function dependencyCacheRoot(env = process.env) {
+    // Descriptor evaluators are disposable and must not leave one isolated emit
+    // generation in the shared temp cache per load. Their result file already
+    // lives in the evaluator-owned directory that the parent removes in
+    // `finally`; put dependency emits beside it so that cleanup owns both.
+    const descriptorOutput = SidecarEnvironment_1.SidecarEnvironment.read(env, "TTSC_PLUGIN_DESCRIPTOR_OUT");
+    if (SidecarEnvironment_1.SidecarEnvironment.read(env, "TTSC_PLUGIN_DESCRIPTOR_LOAD") === "1" &&
+        descriptorOutput !== undefined &&
+        node_path_1.default.isAbsolute(descriptorOutput)) {
+        return node_path_1.default.join(node_path_1.default.dirname(descriptorOutput), "dependency-cache");
+    }
+    const owner = RuntimeManifestRegistry_1.RuntimeManifestRegistry.runtimeManifests().find((candidate) => candidate.depCacheDir.length !== 0);
+    return owner !== undefined ? owner.depCacheDir : processPrivateRoot();
+}
+/** Parent of the per-process directories of manifest-less runtimes. */
+const PROCESS_ROOT_PARENT = node_path_1.default.join(node_os_1.default.tmpdir(), "ttsx-dep");
+/** Prefix of a per-process directory's name, which the sweep recognizes. */
+const PROCESS_ROOT_PREFIX = "process-";
+let processRoot;
+/**
+ * This process's private dependency cache, created on first use with an owner
+ * record, and removed on exit. Creating it first sweeps the directories of
+ * processes on this host that are gone.
+ */
+function processPrivateRoot() {
+    if (processRoot !== undefined)
+        return processRoot;
+    ProcessOwnedDirectory_1.ProcessOwnedDirectory.sweep(PROCESS_ROOT_PARENT, (name) => name.startsWith(PROCESS_ROOT_PREFIX), true);
+    node_fs_1.default.mkdirSync(PROCESS_ROOT_PARENT, { recursive: true });
+    const directory = (0, createCanonicalTempDirectory_1.createCanonicalTempDirectory)(`${PROCESS_ROOT_PREFIX}${process.pid}-`, PROCESS_ROOT_PARENT);
+    try {
+        ProcessOwnedDirectory_1.ProcessOwnedDirectory.admit(directory, process.pid);
+    }
+    catch (error) {
+        try {
+            node_fs_1.default.rmSync(directory, { force: true, recursive: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "ttsx: failed to admit and remove the private dependency cache");
+        }
+        throw error;
+    }
+    process.once("exit", () => {
+        try {
+            node_fs_1.default.rmSync(directory, { force: true, recursive: true });
+        }
+        catch {
+            // Best effort: the next manifest-less process sweeps what remains.
+        }
+    });
+    processRoot = directory;
+    return directory;
+}
+//# sourceMappingURL=dependencyCacheRoot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyCacheRoot.js","sourceRoot":"","sources":["../../../../src/launcher/internal/runtime/dependencyCacheRoot.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,sDAAyB;AACzB,0DAA6B;AAE7B,iGAA8F;AAC9F,iGAA8F;AAC9F,mEAAgE;AAChE,uEAAoE;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,6BACE,GAAG,GAAsB,OAAO,CAAC,GAAG;IAEpC,4EAA4E;IAC5E,0EAA0E;IAC1E,oEAAoE;IACpE,uEAAuE;IACvE,MAAM,gBAAgB,GAAG,uCAAkB,CAAC,IAAI,CAC9C,GAAG,EACH,4BAA4B,CAC7B,CAAC;IACF,IACE,uCAAkB,CAAC,IAAI,CAAC,GAAG,EAAE,6BAA6B,CAAC,KAAK,GAAG;QACnE,gBAAgB,KAAK,SAAS;QAC9B,mBAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,EACjC,CAAC;QACD,OAAO,mBAAI,CAAC,IAAI,CAAC,mBAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,kBAAkB,CAAC,CAAC;IACvE,CAAC;IACD,MAAM,KAAK,GAAG,iDAAuB,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAC3D,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,CAClD,CAAC;IACF,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,kBAAkB,EAAE,CAAC;AACxE,CAAC;AAED,uEAAuE;AACvE,MAAM,mBAAmB,GAAG,mBAAI,CAAC,IAAI,CAAC,iBAAE,CAAC,MAAM,EAAE,EAAE,UAAU,CAAC,CAAC;AAE/D,4EAA4E;AAC5E,MAAM,mBAAmB,GAAG,UAAU,CAAC;AAEvC,IAAI,WAA+B,CAAC;AAEpC;;;;GAIG;AACH,SAAS,kBAAkB;IACzB,IAAI,WAAW,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAClD,6CAAqB,CAAC,KAAK,CACzB,mBAAmB,EACnB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAC9C,IAAI,CACL,CAAC;IACF,iBAAE,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,IAAA,2DAA4B,EAC5C,GAAG,mBAAmB,GAAG,OAAO,CAAC,GAAG,GAAG,EACvC,mBAAmB,CACpB,CAAC;IACF,IAAI,CAAC;QACH,6CAAqB,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC;YACH,iBAAE,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;YACtB,MAAM,IAAI,cAAc,CACtB,CAAC,KAAK,EAAE,YAAY,CAAC,EACrB,+DAA+D,CAChE,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;QACxB,IAAI,CAAC;YACH,iBAAE,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,CAAC;QAAC,MAAM,CAAC;YACP,mEAAmE;QACrE,CAAC;IACH,CAAC,CAAC,CAAC;IACH,WAAW,GAAG,SAAS,CAAC;IACxB,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,23 @@
+import type { DependencyBuildLockObservation } from "./DependencyBuildLockObservation";
+/**
+ * Classify the current state of a dependency build lock directory.
+ *
+ * Unreadable generation identity is active uncertainty. A readable owner is
+ * abandoned only when the local pid is provably gone; an ownerless generation
+ * becomes recoverable after the protocol's stale interval. Failed owner
+ * read/parse/validation also uses that owner-missing policy; it is not proof
+ * that the file or a running process is absent. Reads and age probes are
+ * sequential observations, not an atomic snapshot or incarnation lease. `now`
+ * is the caller's millisecond timestamp; age follows observed mtime.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation identity fences every holder observation; a valid owner requires conservative local liveness evidence, while missing owner data uses the explicit stale-generation policy without stealing an unreadable identity.
+ * @evidence contracts/common.md#clear-and-simple-design Separate generation, owner, age and label helpers supply one state classifier; the discriminated result makes recovery authority explicit to callers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fixture age or broad pid-probe failure marks a valid owner dead; ownerless recovery is the protocol's supported corruption policy rather than a fabricated lease.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe uncertainty and recovery grounds, and the acquisition-order comment explains why an unreadable generation cannot be stolen safely.
+ * @evidence contracts/portability.md#os-neutral-implementation Native fs/path and conservative host/pid probes supply observations. Missing-directory age is released, other stat errors yield zero age; owner read errors instead yield no valid owner and can enter the stale-age policy. Neither path spelling nor hostname convention authenticates stable namespace or machine identity.
+ * @evidence contracts/performance.md#efficient-algorithms At most two record reads and one stat avoid history scans, but actual path/record bytes, trimming/grammar, JSON parsing, diagnostic host/time text and native liveness/IO contribute cost. Record contents are read before validation without a fixed byte cap.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Lock state changes between observations, so an earlier classification cannot replace a fresh recovery decision.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous record reads retain no handle or history; the returned fence transfers an observation to its caller without owning the lock.
+ */
+export declare function inspectDependencyBuildLock(lockDir: string, now: number): DependencyBuildLockObservation;

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectDependencyBuildLock = inspectDependencyBuildLock;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const DependencyBuildGeneration_1 = require("./DependencyBuildGeneration");
+const DependencyBuildLockProtocol_1 = require("./DependencyBuildLockProtocol");
+const RuntimeFilesystem_1 = require("./RuntimeFilesystem");
+const isLocalProcessGone_1 = require("./isLocalProcessGone");
+/**
+ * Classify the current state of a dependency build lock directory.
+ *
+ * Unreadable generation identity is active uncertainty. A readable owner is
+ * abandoned only when the local pid is provably gone; an ownerless generation
+ * becomes recoverable after the protocol's stale interval. Failed owner
+ * read/parse/validation also uses that owner-missing policy; it is not proof
+ * that the file or a running process is absent. Reads and age probes are
+ * sequential observations, not an atomic snapshot or incarnation lease. `now`
+ * is the caller's millisecond timestamp; age follows observed mtime.
+ *
+ * @evidence contracts/common.md#principled-implementation Generation identity fences every holder observation; a valid owner requires conservative local liveness evidence, while missing owner data uses the explicit stale-generation policy without stealing an unreadable identity.
+ * @evidence contracts/common.md#clear-and-simple-design Separate generation, owner, age and label helpers supply one state classifier; the discriminated result makes recovery authority explicit to callers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No fixture age or broad pid-probe failure marks a valid owner dead; ownerless recovery is the protocol's supported corruption policy rather than a fabricated lease.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe uncertainty and recovery grounds, and the acquisition-order comment explains why an unreadable generation cannot be stolen safely.
+ * @evidence contracts/portability.md#os-neutral-implementation Native fs/path and conservative host/pid probes supply observations. Missing-directory age is released, other stat errors yield zero age; owner read errors instead yield no valid owner and can enter the stale-age policy. Neither path spelling nor hostname convention authenticates stable namespace or machine identity.
+ * @evidence contracts/performance.md#efficient-algorithms At most two record reads and one stat avoid history scans, but actual path/record bytes, trimming/grammar, JSON parsing, diagnostic host/time text and native liveness/IO contribute cost. Record contents are read before validation without a fixed byte cap.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Lock state changes between observations, so an earlier classification cannot replace a fresh recovery decision.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Synchronous record reads retain no handle or history; the returned fence transfers an observation to its caller without owning the lock.
+ */
+function inspectDependencyBuildLock(lockDir, now) {
+    const currentDir = node_path_1.default.join(lockDir, DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_CURRENT_DIR);
+    const generation = readDependencyLockGeneration(currentDir);
+    if (generation === null) {
+        if (dependencyLockAgeMs(currentDir, now) === null) {
+            return { state: "released" };
+        }
+        // `current` exists without a readable generation id. Acquisition writes the
+        // id into the candidate BEFORE the atomic rename, so this is a transient or
+        // corrupt state; keep waiting rather than steal on ambiguous evidence.
+        return {
+            state: "active",
+            owner: "lock generation without a readable id",
+            fence: { generation: "" },
+        };
+    }
+    const fence = { generation };
+    const owner = readDependencyLockOwner(currentDir);
+    if (owner !== null) {
+        const label = describeDependencyLockOwner(owner);
+        if ((0, isLocalProcessGone_1.isLocalProcessGone)(owner)) {
+            return {
+                state: "abandoned",
+                reason: `${label} is no longer running`,
+                fence,
+            };
+        }
+        return { state: "active", owner: label, fence };
+    }
+    const ageMs = dependencyLockAgeMs(currentDir, now);
+    if (ageMs === null) {
+        return { state: "released" };
+    }
+    if (ageMs > DEP_BUILD_LOCK_STALE_MS) {
+        return {
+            state: "abandoned",
+            reason: `lock generation has no ${DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_OWNER_FILE} and is ${DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.formatDuration(ageMs)} old`,
+            fence,
+        };
+    }
+    return {
+        state: "active",
+        owner: `lock generation with no ${DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_OWNER_FILE}`,
+        fence,
+    };
+}
+const DEP_BUILD_LOCK_STALE_MS = 30_000;
+function readDependencyLockOwner(generationDir) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(generationDir, DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_OWNER_FILE), "utf8"));
+        if (typeof parsed.hostname !== "string" ||
+            typeof parsed.pid !== "number" ||
+            !Number.isInteger(parsed.pid) ||
+            parsed.pid <= 0) {
+            return null;
+        }
+        return {
+            hostname: parsed.hostname,
+            pid: parsed.pid,
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readDependencyLockGeneration(generationDir) {
+    try {
+        const generation = node_fs_1.default
+            .readFileSync(node_path_1.default.join(generationDir, DependencyBuildLockProtocol_1.DependencyBuildLockProtocol.DEP_BUILD_LOCK_GENERATION_FILE), "utf8")
+            .trim();
+        return DependencyBuildGeneration_1.DependencyBuildGeneration.isDependencyGeneration(generation)
+            ? generation
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Age of an observed lock directory, or `null` when it no longer exists. */
+function dependencyLockAgeMs(generationDir, now) {
+    try {
+        return Math.max(0, now - node_fs_1.default.statSync(generationDir).mtimeMs);
+    }
+    catch (error) {
+        return RuntimeFilesystem_1.RuntimeFilesystem.isMissingPathError(error) ? null : 0;
+    }
+}
+function describeDependencyLockOwner(owner) {
+    const started = owner.startedAt === undefined ? "" : ` started at ${owner.startedAt}`;
+    return `pid ${owner.pid} on ${owner.hostname}${started}`;
+}
+//# sourceMappingURL=inspectDependencyBuildLock.js.map

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

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