ttsc 0.30.3 → 0.31.0

package/lib/compiler/internal/runSingleFileEmit.js

@@ -7,47 +7,85 @@ exports.runSingleFileEmit = runSingleFileEmit;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const createCanonicalTempDirectory_1 = require("../../internal/createCanonicalTempDirectory");
+const EmitOwnershipIndex_1 = require("./EmitOwnershipIndex");
+const runBuild_1 = require("./build/runBuild");
+const CompilerProjectSelection_1 = require("./project/CompilerProjectSelection");
 const readProjectConfig_1 = require("./project/readProjectConfig");
-const resolveEmittedJavaScript_1 = require("./resolveEmittedJavaScript");
-const runBuild_1 = require("./runBuild");
+const readEffectiveCompilerOptions_1 = require("./readEffectiveCompilerOptions");
 /**
  * Emit one source file by building its project into a temporary directory.
  *
- * The full project is compiled with `forceListEmittedFiles` so that the emitted
- * file list is available for `resolveEmittedJavaScript`. The temp directory is
- * always cleaned up in the `finally` block, even on error.
+ * The full project is compiled with its `rootDir` pinned, and the output is
+ * selected through the producing build's emitted-source provenance and current
+ * physical source identity. Missing or ambiguous ownership is refused without
+ * source-map or filename-precedence inference. Temp-directory removal in
+ * `finally` is attempted after acquisition, including failure paths. Removal
+ * failure propagates on success and is aggregated with an earlier operation
+ * failure rather than replacing it.
+ *
+ * A launcher-supplied selection shares its project and original compiler argument
+ * cwd with public output planning. Response freshness is checked before native
+ * work and publication; these sequential checks do not pin bytes atomically.
+ * Callers without that record retain explicit config/nearest-file discovery.
  *
  * @returns The transformed JavaScript source text.
- * @throws When the build exits non-zero or no output is produced for the file.
+ * @throws When the build exits non-zero, proves no JavaScript for the requested
+ *   source or cannot establish unique ownership.
+ * @evidence contracts/common.md#principled-implementation The supplied invocation selection or legacy locator establishes one project and compiler argument base; current response observations, effective rootDir precedence and isolated emission preserve that producing invocation; its emitted-source provenance and current physical source identity select the actual written output before optional caller-directed writing.
+ * @evidence contracts/common.md#clear-and-simple-design One operation owns project emission, optional public copy and returned text. A supplied existing selection replaces repeated discovery; delegated option interpretation and provenance retain their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Missing or ambiguous provenance cannot become ownership through basename, source-map presence or extension precedence; inferred-root pinning addresses the compiler's injected-outDir requirement.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain exact-source selection, missing owned output and temporary lifetime; the private realpath helper describes unavailable identity without a test-specific premise.
+ * @evidence contracts/performance.md#efficient-algorithms A supplied project avoids another discovery; otherwise legacy discovery remains. Sequential response freshness checks and effective-option inspection precede one full project build, followed by publication reobservation. Output enumeration visits directory entries and sorts output paths; provenance indexing resolves native output identities and processes source associations. Only selected output content is read here, with optional caller output writing; path/association/output bytes and delegated native/build costs remain part of this call.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This invocation observes the project's current compiler/plugin effects and owns no valid-generation cache; equivalent build sharing belongs to higher-level runtime owners.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One accepted private output directory reaches removal in finally after success, build failure, lookup failure or output writing; acquisition has its own failure limitations. The index and selected text live until return/throw and transfer text to the caller, without an output-byte ceiling or timeout supplied here. Cleanup failure propagates after success and aggregates with the original failure and cause after an unsuccessful operation, so neither outcome is hidden.
+ * @evidence contracts/portability.md#os-neutral-implementation Native paths and filesystem identities use Node APIs, child execution uses argument arrays, and optional output targets resolve from the invocation cwd on each supported host.
  */
-function runSingleFileEmit(options) {
+function runSingleFileEmit(options, selection) {
     const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
     const sourceFile = realpathIfExists(node_path_1.default.isAbsolute(options.file)
         ? options.file
         : node_path_1.default.resolve(cwd, options.file));
-    const project = (0, readProjectConfig_1.readProjectConfig)({
-        cwd,
-        file: options.file,
-        projectRoot: options.projectRoot,
-        tsconfig: options.tsconfig,
-    });
+    const project = selection?.project ??
+        (0, readProjectConfig_1.readProjectConfig)({
+            cwd,
+            file: options.file,
+            projectRoot: options.projectRoot,
+            tsconfig: options.tsconfig,
+        });
     const tsconfig = project.path;
-    const projectRoot = project.root;
+    const compilerArgsCwd = selection?.compilerArgsCwd ?? project.root;
+    if (selection !== undefined)
+        CompilerProjectSelection_1.CompilerProjectSelection.assertCurrent(selection);
+    // The root tsgo lays the outputs against: a `--rootDir` forwarded on the
+    // command line, which reaches it after the config; otherwise the declared
+    // one, which `readProjectConfig` already absolutized; otherwise the project's
+    // own directory, which `pinInferredRootDir` hands it below.
+    const effective = (0, readEffectiveCompilerOptions_1.readEffectiveCompilerOptions)(project, options.passthrough, options.binary, options.env, compilerArgsCwd)?.("rootDir");
+    const rootDir = typeof effective === "string"
+        ? node_path_1.default.resolve(compilerArgsCwd, effective)
+        : project.root;
+    if (selection !== undefined)
+        CompilerProjectSelection_1.CompilerProjectSelection.assertCurrent(selection);
     const outDir = (0, createCanonicalTempDirectory_1.createCanonicalTempDirectory)("ttsc-single-file-");
+    let failed = false;
+    let failure;
     try {
         const result = (0, runBuild_1.runBuild)({
             ...options,
             cwd,
+            compilerArgsCwd,
             emit: true,
-            forceListEmittedFiles: true,
+            forceEmitProvenance: true,
             isolateOutputsTo: outDir,
             outDir,
             // The private temp directory above is an `outDir` this lane injected, not
             // one the project declared, and tsgo answers an inferred common source
             // directory with TS5011 as soon as any `outDir` is in play. Pinning the
             // root tsgo would infer keeps `ttsc <file.ts>` working on a project that
-            // declares no output at all, and it is the same root
-            // `resolveEmittedJavaScript` mirrors below (issue #1172).
+            // declares no output at all, while the producing invocation reports its
+            // actual source/output ownership separately.
             pinInferredRootDir: true,
             resolvedProject: project,
             tsconfig,
@@ -58,16 +96,19 @@ function runSingleFileEmit(options) {
                 "\n" +
                 (result.stderr || result.stdout));
         }
-        const emitted = (0, resolveEmittedJavaScript_1.resolveEmittedJavaScript)({
-            emittedFiles: result.emittedFiles,
-            outDir,
-            projectRoot,
-            sourceFile,
-        });
+        const emitted = new EmitOwnershipIndex_1.EmitOwnershipIndex({
+            emitDir: outDir,
+            rootDir,
+            emittedSources: result.emittedSources,
+            emittedSourceProofFailures: result.emittedSourceProofFailures,
+            outputs: EmitOwnershipIndex_1.EmitOwnershipIndex.listOutputs(outDir),
+        }).find(sourceFile);
         if (emitted === null) {
-            throw new Error(`ttsc single-file emit: no output produced for ${sourceFile}`);
+            throw new Error(`ttsc single-file emit: ${tsconfig} emitted no JavaScript owned by ${sourceFile}; check that the project includes the source and its options permit JavaScript emission`);
         }
         const transformed = node_fs_1.default.readFileSync(emitted, "utf8");
+        if (selection !== undefined)
+            CompilerProjectSelection_1.CompilerProjectSelection.assertCurrent(selection);
         if (options.out) {
             const target = node_path_1.default.isAbsolute(options.out)
                 ? options.out
@@ -77,13 +118,27 @@ function runSingleFileEmit(options) {
         }
         return transformed;
     }
+    catch (error) {
+        failed = true;
+        failure = error;
+        throw error;
+    }
     finally {
-        node_fs_1.default.rmSync(outDir, { recursive: true, force: true });
+        try {
+            node_fs_1.default.rmSync(outDir, { recursive: true, force: true });
+        }
+        catch (cleanupError) {
+            if (failed) {
+                throw new AggregateError([failure, cleanupError], "ttsc: single-file emission and temporary output cleanup failed", { cause: failure });
+            }
+            throw cleanupError;
+        }
     }
 }
 /**
- * Resolve symlinks on `file` when it exists; return the original path when the
- * file is not yet on disk (e.g. a synthetic path used in tests).
+ * Resolve a physical target when native realpath succeeds; otherwise preserve
+ * the requested lexical spelling so project diagnostics and ownership lookup
+ * decide its actual outcome.
  */
 function realpathIfExists(file) {
     try {

package/lib/compiler/internal/runSingleFileEmit.js.map

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

package/lib/compiler/internal/sharedHost/SEMANTIC_CONFIG_PATH_ENV.d.ts

@@ -0,0 +1,2 @@
+/** Internal channel preserving a generated wrapper's user-authored config owner. */
+export declare const SEMANTIC_CONFIG_PATH_ENV = "TTSC_SEMANTIC_CONFIG_PATH";

package/lib/compiler/internal/sharedHost/SEMANTIC_CONFIG_PATH_ENV.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_CONFIG_PATH_ENV = void 0;
+/** Internal channel preserving a generated wrapper's user-authored config owner. */
+exports.SEMANTIC_CONFIG_PATH_ENV = "TTSC_SEMANTIC_CONFIG_PATH";
+//# sourceMappingURL=SEMANTIC_CONFIG_PATH_ENV.js.map

package/lib/compiler/internal/sharedHost/SEMANTIC_CONFIG_PATH_ENV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SEMANTIC_CONFIG_PATH_ENV.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/SEMANTIC_CONFIG_PATH_ENV.ts"],"names":[],"mappings":";;;AAAA,oFAAoF;AACvE,QAAA,wBAAwB,GAAG,2BAA2B,CAAC"}

package/lib/compiler/internal/sharedHost/SidecarEnvironment.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Native environment-name identity for child and isolated-worker environments.
+ * Construction and Windows scans use own enumerable string names; they do not
+ * reproduce Node's inclusion of inherited enumerable environment entries.
+ *
+ * Merge establishes layer precedence; read and write use that same identity for
+ * invocation-owned channels. Replace lets an isolated worker adopt a complete
+ * request snapshot without inheriting stale names from its preceding request.
+ *
+ * @evidence contracts/common.md#principled-implementation The namespace groups child-environment operations under one native name policy, so precedence and channel presence cannot disagree about Windows aliases.
+ * @evidence contracts/common.md#clear-and-simple-design Construction, observation, channel mutation and complete replacement share one native name policy; the single public identity avoids separate environment policies in sidecar consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Members use supplied-object operations without replacing process.env or child-process APIs; a worker explicitly owns the mutable process.env target it adopts.
+ * @evidence contracts/common.md#meaningful-documentation The namespace explains its plain-object boundary and each member documents precedence, undefined and native alias behavior according to the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Each member uses Windows case-insensitive name identity only on Windows; POSIX spelling remains exact throughout merge, lookup and removal.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This namespace groups declarations; the member functions own and describe the actual environment scans and temporary indexes.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace holds no coordinator or cached request result; supplied environments remain mutable and member calls observe current data.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no environment objects, native resources or historical entries between calls.
+ */
+export declare namespace SidecarEnvironment {
+    /**
+     * Replace an owned environment with a complete native-name snapshot.
+     *
+     * Worker process.env is case-sensitive even on Windows. Canonicalizing the
+     * snapshot restores native name identity before existing SDK readers run.
+     * Missing and undefined-valued entries are removed, including stale aliases;
+     * POSIX retains distinct spellings. The caller must own the mutable target.
+     *
+     * @evidence contracts/common.md#principled-implementation Merge selects each native name's authoritative value before target mutation; clearing old own names then assigning defined values makes sequential worker requests independent of prior spelling or presence.
+     * @evidence contracts/common.md#clear-and-simple-design The worker delegates complete environment adoption to the same namespace that owns native merge and lookup instead of duplicating Windows alias rules.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Only the caller-owned target is mutated through supported environment property operations; no foreign method or global environment object is replaced.
+     * @evidence contracts/common.md#meaningful-documentation The comment states worker case behavior, full replacement, undefined removal and target ownership with descriptive prose separated from acknowledgments.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows native names are canonicalized through merge while POSIX spellings remain independent; deletion precedes assignment so case-sensitive worker copies cannot retain an old alias.
+     * @evidence contracts/performance.md#efficient-algorithms Merge scans the incoming E names once; target deletion and defined-value assignment visit T and E names respectively, with temporary snapshot storage proportional to distinct incoming names. No per-name nested scan or sorting is added.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each snapshot is mutable invocation authority and must be applied anew; previous requests cannot authorize its environment.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The caller retains its target, while the normalized temporary snapshot ends with this synchronous call; no history or native resource is acquired.
+     */
+    function replace(target: NodeJS.ProcessEnv, snapshot: NodeJS.ProcessEnv): void;
+    /**
+     * Merge plain environment layers in precedence order, preserving native
+     * names.
+     *
+     * Windows names are case-insensitive. Within one layer the lexicographically
+     * first own spelling wins, matching Node spawn's duplicate selection for this
+     * own-entry boundary; later layers override earlier layers independently of
+     * spelling. POSIX names remain case-sensitive.
+     *
+     * @evidence contracts/common.md#principled-implementation Layer order expresses caller authority; Windows folds name identity while selecting each layer's lexicographically first spelling, matching Node's duplicate-name rule without allowing an inherited alias to defeat an override.
+     * @evidence contracts/common.md#clear-and-simple-design One environment merge owns native name identity for every sidecar constructor; callers supply distinct default, caller and resolved-value layers instead of embedding precedence in object spreads.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported plain-object operations prepare an explicit child environment without replacing process.env or the spawning API.
+     * @evidence contracts/common.md#meaningful-documentation Purpose and precedence paragraphs define Windows duplicate handling and POSIX spelling preservation following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows case-insensitive environment identity is isolated here; POSIX keys retain exact spelling, and the returned object contains no ambiguous Windows aliases.
+     * @evidence contracts/performance.md#efficient-algorithms E entries across supplied layers require name enumeration/copying plus uppercase and comparison text costs on Windows. A per-layer map selects minimum spellings without sorting; its distinct names coexist with Object.keys arrays and the accumulated returned environment. Plain-object property reads remain part of the supplied-data boundary.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Environment layers can change between child runs and the result is independently mutable; this operation owns no equivalent-request coordinator or stable invalidation identity.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary name indexes end with the call, and the merged object transfers to its caller; no historical environment, handle or task is retained.
+     */
+    function merge(...layers: readonly (NodeJS.ProcessEnv | undefined)[]): NodeJS.ProcessEnv;
+    /**
+     * Read a plain child-environment name using the host's native identity rule.
+     * Undefined includes an absent layer or a selected undefined-valued
+     * spelling.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact lookup serves POSIX names; the minimum matching spelling serves Windows aliases using the same selection Node applies to plain spawn environments.
+     * @evidence contracts/common.md#clear-and-simple-design One accessor supplies channel-presence decisions without duplicating Windows alias handling in every cleanup helper.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The accessor inspects supplied data rather than modifying a global environment or guessing an expected channel value.
+     * @evidence contracts/common.md#meaningful-documentation The comment states native name semantics and the meaning of undefined, separated from tags according to the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Case folding occurs only for Windows environment identity; POSIX variables with different case remain distinct.
+     * @evidence contracts/performance.md#efficient-algorithms POSIX performs one supplied-object property lookup, including its name/data access costs. Windows allocates an Object.keys array and scans E own names with uppercase/comparison text costs to select the minimum spelling, without a full sort or historical index.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The caller owns a mutable environment, so previous reads have no stable validity identity or coordinated reuse boundary.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This synchronous accessor retains no environment history, descriptor or task.
+     */
+    function read(env: NodeJS.ProcessEnv | undefined, name: string): string | undefined;
+    /**
+     * Set or remove an invocation-owned channel on a plain child environment.
+     * Removing a Windows name also removes every differently cased alias.
+     *
+     * @evidence contracts/common.md#principled-implementation All spellings of a Windows channel share one native identity; removing aliases before a write or deletion establishes one authoritative value, while POSIX changes only the requested exact name.
+     * @evidence contracts/common.md#clear-and-simple-design One write boundary owns channel replacement and removal, avoiding partial deletion rules scattered through sidecar constructors.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation mutates only the explicitly supplied child environment; it neither replaces foreign methods nor changes process.env.
+     * @evidence contracts/common.md#meaningful-documentation The native comment explains undefined-driven removal and Windows alias cleanup following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native environment identity determines the deletion set; Windows emits one uppercase spelling and POSIX preserves exact names.
+     * @evidence contracts/performance.md#efficient-algorithms Windows deletion allocates an Object.keys array and visits E names with uppercase/text and property-deletion costs; POSIX deletes one supplied key directly. The optional value assignment remains caller-data work; neither branch sorts names or launches a child.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Channel writes are invocation effects on mutable caller data and cannot be replaced by a previous result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The mutated environment remains caller-owned; this helper retains no additional state or native resources.
+     */
+    function write(env: NodeJS.ProcessEnv, name: string, value: string | undefined): void;
+}

package/lib/compiler/internal/sharedHost/SidecarEnvironment.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SidecarEnvironment = void 0;
+/**
+ * Native environment-name identity for child and isolated-worker environments.
+ * Construction and Windows scans use own enumerable string names; they do not
+ * reproduce Node's inclusion of inherited enumerable environment entries.
+ *
+ * Merge establishes layer precedence; read and write use that same identity for
+ * invocation-owned channels. Replace lets an isolated worker adopt a complete
+ * request snapshot without inheriting stale names from its preceding request.
+ *
+ * @evidence contracts/common.md#principled-implementation The namespace groups child-environment operations under one native name policy, so precedence and channel presence cannot disagree about Windows aliases.
+ * @evidence contracts/common.md#clear-and-simple-design Construction, observation, channel mutation and complete replacement share one native name policy; the single public identity avoids separate environment policies in sidecar consumers.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Members use supplied-object operations without replacing process.env or child-process APIs; a worker explicitly owns the mutable process.env target it adopts.
+ * @evidence contracts/common.md#meaningful-documentation The namespace explains its plain-object boundary and each member documents precedence, undefined and native alias behavior according to the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Each member uses Windows case-insensitive name identity only on Windows; POSIX spelling remains exact throughout merge, lookup and removal.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This namespace groups declarations; the member functions own and describe the actual environment scans and temporary indexes.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace holds no coordinator or cached request result; supplied environments remain mutable and member calls observe current data.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The namespace retains no environment objects, native resources or historical entries between calls.
+ */
+var SidecarEnvironment;
+(function (SidecarEnvironment) {
+    /**
+     * Replace an owned environment with a complete native-name snapshot.
+     *
+     * Worker process.env is case-sensitive even on Windows. Canonicalizing the
+     * snapshot restores native name identity before existing SDK readers run.
+     * Missing and undefined-valued entries are removed, including stale aliases;
+     * POSIX retains distinct spellings. The caller must own the mutable target.
+     *
+     * @evidence contracts/common.md#principled-implementation Merge selects each native name's authoritative value before target mutation; clearing old own names then assigning defined values makes sequential worker requests independent of prior spelling or presence.
+     * @evidence contracts/common.md#clear-and-simple-design The worker delegates complete environment adoption to the same namespace that owns native merge and lookup instead of duplicating Windows alias rules.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Only the caller-owned target is mutated through supported environment property operations; no foreign method or global environment object is replaced.
+     * @evidence contracts/common.md#meaningful-documentation The comment states worker case behavior, full replacement, undefined removal and target ownership with descriptive prose separated from acknowledgments.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows native names are canonicalized through merge while POSIX spellings remain independent; deletion precedes assignment so case-sensitive worker copies cannot retain an old alias.
+     * @evidence contracts/performance.md#efficient-algorithms Merge scans the incoming E names once; target deletion and defined-value assignment visit T and E names respectively, with temporary snapshot storage proportional to distinct incoming names. No per-name nested scan or sorting is added.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each snapshot is mutable invocation authority and must be applied anew; previous requests cannot authorize its environment.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The caller retains its target, while the normalized temporary snapshot ends with this synchronous call; no history or native resource is acquired.
+     */
+    function replace(target, snapshot) {
+        const selected = merge(snapshot);
+        for (const key of Object.keys(target))
+            delete target[key];
+        for (const [key, value] of Object.entries(selected))
+            if (value !== undefined)
+                target[key] = value;
+    }
+    SidecarEnvironment.replace = replace;
+    /**
+     * Merge plain environment layers in precedence order, preserving native
+     * names.
+     *
+     * Windows names are case-insensitive. Within one layer the lexicographically
+     * first own spelling wins, matching Node spawn's duplicate selection for this
+     * own-entry boundary; later layers override earlier layers independently of
+     * spelling. POSIX names remain case-sensitive.
+     *
+     * @evidence contracts/common.md#principled-implementation Layer order expresses caller authority; Windows folds name identity while selecting each layer's lexicographically first spelling, matching Node's duplicate-name rule without allowing an inherited alias to defeat an override.
+     * @evidence contracts/common.md#clear-and-simple-design One environment merge owns native name identity for every sidecar constructor; callers supply distinct default, caller and resolved-value layers instead of embedding precedence in object spreads.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported plain-object operations prepare an explicit child environment without replacing process.env or the spawning API.
+     * @evidence contracts/common.md#meaningful-documentation Purpose and precedence paragraphs define Windows duplicate handling and POSIX spelling preservation following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Windows case-insensitive environment identity is isolated here; POSIX keys retain exact spelling, and the returned object contains no ambiguous Windows aliases.
+     * @evidence contracts/performance.md#efficient-algorithms E entries across supplied layers require name enumeration/copying plus uppercase and comparison text costs on Windows. A per-layer map selects minimum spellings without sorting; its distinct names coexist with Object.keys arrays and the accumulated returned environment. Plain-object property reads remain part of the supplied-data boundary.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Environment layers can change between child runs and the result is independently mutable; this operation owns no equivalent-request coordinator or stable invalidation identity.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Temporary name indexes end with the call, and the merged object transfers to its caller; no historical environment, handle or task is retained.
+     */
+    function merge(...layers) {
+        const result = Object.create(null);
+        for (const layer of layers) {
+            if (layer === undefined)
+                continue;
+            if (process.platform !== "win32") {
+                Object.assign(result, layer);
+                continue;
+            }
+            const names = new Map();
+            for (const key of Object.keys(layer)) {
+                const identity = key.toUpperCase();
+                const previous = names.get(identity);
+                if (previous === undefined || key < previous)
+                    names.set(identity, key);
+            }
+            for (const [identity, key] of names)
+                result[identity] = layer[key];
+        }
+        return result;
+    }
+    SidecarEnvironment.merge = merge;
+    /**
+     * Read a plain child-environment name using the host's native identity rule.
+     * Undefined includes an absent layer or a selected undefined-valued
+     * spelling.
+     *
+     * @evidence contracts/common.md#principled-implementation Exact lookup serves POSIX names; the minimum matching spelling serves Windows aliases using the same selection Node applies to plain spawn environments.
+     * @evidence contracts/common.md#clear-and-simple-design One accessor supplies channel-presence decisions without duplicating Windows alias handling in every cleanup helper.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The accessor inspects supplied data rather than modifying a global environment or guessing an expected channel value.
+     * @evidence contracts/common.md#meaningful-documentation The comment states native name semantics and the meaning of undefined, separated from tags according to the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Case folding occurs only for Windows environment identity; POSIX variables with different case remain distinct.
+     * @evidence contracts/performance.md#efficient-algorithms POSIX performs one supplied-object property lookup, including its name/data access costs. Windows allocates an Object.keys array and scans E own names with uppercase/comparison text costs to select the minimum spelling, without a full sort or historical index.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work The caller owns a mutable environment, so previous reads have no stable validity identity or coordinated reuse boundary.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This synchronous accessor retains no environment history, descriptor or task.
+     */
+    function read(env, name) {
+        if (env === undefined)
+            return undefined;
+        if (process.platform !== "win32")
+            return env[name];
+        const identity = name.toUpperCase();
+        let selected;
+        for (const key of Object.keys(env)) {
+            if (key.toUpperCase() === identity &&
+                (selected === undefined || key < selected)) {
+                selected = key;
+            }
+        }
+        return selected === undefined ? undefined : env[selected];
+    }
+    SidecarEnvironment.read = read;
+    /**
+     * Set or remove an invocation-owned channel on a plain child environment.
+     * Removing a Windows name also removes every differently cased alias.
+     *
+     * @evidence contracts/common.md#principled-implementation All spellings of a Windows channel share one native identity; removing aliases before a write or deletion establishes one authoritative value, while POSIX changes only the requested exact name.
+     * @evidence contracts/common.md#clear-and-simple-design One write boundary owns channel replacement and removal, avoiding partial deletion rules scattered through sidecar constructors.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The operation mutates only the explicitly supplied child environment; it neither replaces foreign methods nor changes process.env.
+     * @evidence contracts/common.md#meaningful-documentation The native comment explains undefined-driven removal and Windows alias cleanup following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native environment identity determines the deletion set; Windows emits one uppercase spelling and POSIX preserves exact names.
+     * @evidence contracts/performance.md#efficient-algorithms Windows deletion allocates an Object.keys array and visits E names with uppercase/text and property-deletion costs; POSIX deletes one supplied key directly. The optional value assignment remains caller-data work; neither branch sorts names or launches a child.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Channel writes are invocation effects on mutable caller data and cannot be replaced by a previous result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The mutated environment remains caller-owned; this helper retains no additional state or native resources.
+     */
+    function write(env, name, value) {
+        const identity = process.platform === "win32" ? name.toUpperCase() : name;
+        if (process.platform === "win32") {
+            for (const key of Object.keys(env)) {
+                if (key.toUpperCase() === identity)
+                    delete env[key];
+            }
+        }
+        else {
+            delete env[name];
+        }
+        if (value !== undefined)
+            env[identity] = value;
+    }
+    SidecarEnvironment.write = write;
+})(SidecarEnvironment || (exports.SidecarEnvironment = SidecarEnvironment = {}));
+//# sourceMappingURL=SidecarEnvironment.js.map

package/lib/compiler/internal/sharedHost/SidecarEnvironment.js.map

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

package/lib/compiler/internal/sharedHost/TSGO_ARGS_CWD_ENV.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Native argument base paired with TTSC_TSGO_ARGS. It anchors upstream option
+ * and response parsing while the Program and plugin root remain independent.
+ * Absence retains the ordinary Program cwd; hosts declare compilerArgsCwd
+ * support before the launcher publishes a distinct base.
+ */
+export declare const TSGO_ARGS_CWD_ENV = "TTSC_TSGO_ARGS_CWD";

package/lib/compiler/internal/sharedHost/TSGO_ARGS_CWD_ENV.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSGO_ARGS_CWD_ENV = void 0;
+/**
+ * Native argument base paired with TTSC_TSGO_ARGS. It anchors upstream option
+ * and response parsing while the Program and plugin root remain independent.
+ * Absence retains the ordinary Program cwd; hosts declare compilerArgsCwd
+ * support before the launcher publishes a distinct base.
+ */
+exports.TSGO_ARGS_CWD_ENV = "TTSC_TSGO_ARGS_CWD";
+//# sourceMappingURL=TSGO_ARGS_CWD_ENV.js.map

package/lib/compiler/internal/sharedHost/TSGO_ARGS_CWD_ENV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSGO_ARGS_CWD_ENV.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/TSGO_ARGS_CWD_ENV.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,iBAAiB,GAAG,oBAAoB,CAAC"}

package/lib/compiler/internal/sharedHost/TSGO_ARGS_ENV.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Environment channel carrying the JSON-encoded tsgo argv ttsc forwards to a
+ * native sidecar. Mirrors `driver.TsgoArgsEnv` on the Go side; see
+ * `TsgoArguments.ts::createNativeTsgoArgs` for why the payload is not a CLI
+ * flag.
+ */
+export declare const TSGO_ARGS_ENV = "TTSC_TSGO_ARGS";

package/lib/compiler/internal/sharedHost/TSGO_ARGS_ENV.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSGO_ARGS_ENV = void 0;
+/**
+ * Environment channel carrying the JSON-encoded tsgo argv ttsc forwards to a
+ * native sidecar. Mirrors `driver.TsgoArgsEnv` on the Go side; see
+ * `TsgoArguments.ts::createNativeTsgoArgs` for why the payload is not a CLI
+ * flag.
+ */
+exports.TSGO_ARGS_ENV = "TTSC_TSGO_ARGS";
+//# sourceMappingURL=TSGO_ARGS_ENV.js.map

package/lib/compiler/internal/sharedHost/TSGO_ARGS_ENV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSGO_ARGS_ENV.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/TSGO_ARGS_ENV.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,aAAa,GAAG,gBAAgB,CAAC"}

package/lib/compiler/internal/sharedHost/assertSharedHostCompatibility.d.ts

@@ -0,0 +1,24 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * Requires equal loader-supplied binary strings for all entries other than
+ * linked transform libraries. Compiler callers supply transform-stage subsets;
+ * a linked check-stage entry is not excluded by this function.
+ *
+ * BuildExecution uses the emit diagnostic; in-memory and resident transform
+ * setup use the source-to-source diagnostic. The pass argument selects that
+ * wording. Equal strings here do not authenticate executable bytes or physical
+ * equivalence of differently spelled paths.
+ *
+ * @evidence contracts/common.md#principled-implementation Linked transform libraries are excluded; every other supplied entry constrains the common binary string. Transform-stage filtering and physical executable identity remain caller/loader responsibilities.
+ * @evidence contracts/common.md#clear-and-simple-design One owner-path comparison handles both pass kinds, with diagnostic wording chosen only when a conflicting owner is encountered.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Compatibility follows loaded plugin stage and ownership discriminants, without special-casing plugin names or retrying an incompatible emit through another backend.
+ * @evidence contracts/common.md#meaningful-documentation The comment states linked-library exclusion and explains the pass argument's diagnostic purpose in separate paragraphs following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This predicate compares loader-provided owner identities without filesystem or process access; native binary resolution and identity normalization remain the loader's boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms One scan performs up to P discriminant and binary-string comparisons with one remembered string reference. Work also depends on compared path lengths and conflict-message construction; no secondary population-sized sets are built.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each supplied plugin population belongs to its current pass; this predicate owns no stable cross-request producer identity or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The remembered owner is local to this check; no plugin table, descriptor or running host is retained.
+ */
+export declare function assertSharedHostCompatibility(plugins: readonly ITtscLoadedNativePlugin[], pass: "emit" | "source-to-source"): void;

package/lib/compiler/internal/sharedHost/assertSharedHostCompatibility.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSharedHostCompatibility = assertSharedHostCompatibility;
+const isLinkedTransform_1 = require("./isLinkedTransform");
+/**
+ * Requires equal loader-supplied binary strings for all entries other than
+ * linked transform libraries. Compiler callers supply transform-stage subsets;
+ * a linked check-stage entry is not excluded by this function.
+ *
+ * BuildExecution uses the emit diagnostic; in-memory and resident transform
+ * setup use the source-to-source diagnostic. The pass argument selects that
+ * wording. Equal strings here do not authenticate executable bytes or physical
+ * equivalence of differently spelled paths.
+ *
+ * @evidence contracts/common.md#principled-implementation Linked transform libraries are excluded; every other supplied entry constrains the common binary string. Transform-stage filtering and physical executable identity remain caller/loader responsibilities.
+ * @evidence contracts/common.md#clear-and-simple-design One owner-path comparison handles both pass kinds, with diagnostic wording chosen only when a conflicting owner is encountered.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Compatibility follows loaded plugin stage and ownership discriminants, without special-casing plugin names or retrying an incompatible emit through another backend.
+ * @evidence contracts/common.md#meaningful-documentation The comment states linked-library exclusion and explains the pass argument's diagnostic purpose in separate paragraphs following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation This predicate compares loader-provided owner identities without filesystem or process access; native binary resolution and identity normalization remain the loader's boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms One scan performs up to P discriminant and binary-string comparisons with one remembered string reference. Work also depends on compared path lengths and conflict-message construction; no secondary population-sized sets are built.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each supplied plugin population belongs to its current pass; this predicate owns no stable cross-request producer identity or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The remembered owner is local to this check; no plugin table, descriptor or running host is retained.
+ */
+function assertSharedHostCompatibility(plugins, pass) {
+    let owner;
+    for (const plugin of plugins) {
+        if ((0, isLinkedTransform_1.isLinkedTransform)(plugin))
+            continue;
+        if (owner === undefined) {
+            owner = plugin.binary;
+            continue;
+        }
+        if (owner === plugin.binary)
+            continue;
+        const phrase = pass === "emit"
+            ? "multiple compiler native backends cannot share one emit pass"
+            : "multiple transform native backends cannot share one source-to-source pass";
+        throw new Error("ttsc: " +
+            phrase +
+            "; compose transform libraries through one aggregate native host");
+    }
+}
+//# sourceMappingURL=assertSharedHostCompatibility.js.map

package/lib/compiler/internal/sharedHost/assertSharedHostCompatibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertSharedHostCompatibility.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/assertSharedHostCompatibility.ts"],"names":[],"mappings":";;;AACA,2DAAwD;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uCACE,OAA2C,EAC3C,IAAiC;IAEjC,IAAI,KAAyB,CAAC;IAC9B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,IAAA,qCAAiB,EAAC,MAAM,CAAC;YAAE,SAAS;QACxC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;YACtB,SAAS;QACX,CAAC;QACD,IAAI,KAAK,KAAK,MAAM,CAAC,MAAM;YAAE,SAAS;QACtC,MAAM,MAAM,GACV,IAAI,KAAK,MAAM;YACb,CAAC,CAAC,8DAA8D;YAChE,CAAC,CAAC,2EAA2E,CAAC;QAClF,MAAM,IAAI,KAAK,CACb,QAAQ;YACN,MAAM;YACN,iEAAiE,CACpE,CAAC;IACJ,CAAC;AACH,CAAC"}

package/lib/compiler/internal/sharedHost/clearInheritedSemanticConfigPath.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Remove an outer wrapper's config owner, retaining only a caller-named value.
+ * Native environment-name identity also applies to differently cased names.
+ *
+ * @evidence contracts/common.md#principled-implementation Only the caller's explicit channel value establishes this invocation's semantic owner; absence removes inherited authority rather than anchoring a nested build to an unrelated wrapper.
+ * @evidence contracts/common.md#clear-and-simple-design This helper owns semantic-config inheritance policy and delegates native name identity to the shared environment boundary.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Channel cleanup changes only the supplied child environment and does not alter the global process environment or invent a config path.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains retained caller authority and alias handling, following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared reader and writer preserve POSIX case distinctions and clear every Windows alias of the invocation channel.
+ * @evidence contracts/performance.md#efficient-algorithms The shared boundary performs at most one scan of each supplied environment on Windows, with Object.keys allocation and uppercase/comparison/deletion text costs. POSIX uses direct supplied-object key operations; the selected path text is transferred rather than parsed or resolved here.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Environment mutation is this invocation's ownership effect and cannot be replaced by a prior cleanup result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Both environment objects remain caller-owned; no historical wrapper authority or native handle is retained here.
+ */
+export declare function clearInheritedSemanticConfigPath(env: NodeJS.ProcessEnv, callerEnv: NodeJS.ProcessEnv | undefined): void;