ttsc 0.30.4 → 0.31.1

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearInheritedSemanticConfigPath = clearInheritedSemanticConfigPath;
+const SEMANTIC_CONFIG_PATH_ENV_1 = require("./SEMANTIC_CONFIG_PATH_ENV");
+const SidecarEnvironment_1 = require("./SidecarEnvironment");
+/**
+ * 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.
+ */
+function clearInheritedSemanticConfigPath(env, callerEnv) {
+    SidecarEnvironment_1.SidecarEnvironment.write(env, SEMANTIC_CONFIG_PATH_ENV_1.SEMANTIC_CONFIG_PATH_ENV, SidecarEnvironment_1.SidecarEnvironment.read(callerEnv, SEMANTIC_CONFIG_PATH_ENV_1.SEMANTIC_CONFIG_PATH_ENV));
+}
+//# sourceMappingURL=clearInheritedSemanticConfigPath.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clearInheritedSemanticConfigPath.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/clearInheritedSemanticConfigPath.ts"],"names":[],"mappings":";;;AAAA,yEAAsE;AACtE,6DAA0D;AAE1D;;;;;;;;;;;;;GAaG;AACH,0CACE,GAAsB,EACtB,SAAwC;IAExC,uCAAkB,CAAC,KAAK,CACtB,GAAG,EACH,mDAAwB,EACxB,uCAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,mDAAwB,CAAC,CAC7D,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * Drop a forwarded-tsgo payload this invocation did not publish itself.
+ *
+ * Every sidecar env starts from `process.env`, so a ttsc that is itself running
+ * inside a plugin sidecar — `@ttsc/lint` evaluating a config file through
+ * `ttsx`, for instance — would otherwise hand the outer run's `--strict` to its
+ * own sidecars, and `driver.LoadProgram` would apply it. The forwarded argv is
+ * per-invocation state the spawning host owns, the same rule
+ * `TTSC_PLUGIN_CONFIG_DIR` already follows. A caller that named the variable
+ * explicitly keeps it. Its argument-cwd companion follows the same explicit
+ * ownership, and publication of a new payload owns both channels.
+ *
+ * @evidence contracts/common.md#principled-implementation A nested sidecar keeps forwarded argv only when its caller declares that channel; otherwise outer invocation flags cannot silently change its compiler options.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns tsgo-payload inheritance policy and shares native environment-name handling with the other invocation channels.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup removes unrelated inherited authority rather than rewriting compiler behavior or substituting an expected diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation Separate paragraphs explain nested-sidecar contamination and explicit preservation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native name lookup and replacement use the shared boundary, including Windows aliases and POSIX exact-name identity.
+ * @evidence contracts/performance.md#efficient-algorithms Cleanup delegates at most two caller-name scans and two child-name scans on Windows, including their Object.keys arrays and uppercase/comparison/deletion text costs. POSIX uses direct supplied-object key operations; neither branch parses or constructs a copy of forwarded payload text.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The mutable child channel belongs to the current spawn and has no reusable cross-invocation cleanup result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mutation retains no payload history, table, descriptor or running task.
+ */
+export declare function clearInheritedTsgoArgs(env: NodeJS.ProcessEnv, callerEnv: NodeJS.ProcessEnv | undefined): void;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearInheritedTsgoArgs = clearInheritedTsgoArgs;
+const SidecarEnvironment_1 = require("./SidecarEnvironment");
+const TSGO_ARGS_CWD_ENV_1 = require("./TSGO_ARGS_CWD_ENV");
+const TSGO_ARGS_ENV_1 = require("./TSGO_ARGS_ENV");
+/**
+ * Drop a forwarded-tsgo payload this invocation did not publish itself.
+ *
+ * Every sidecar env starts from `process.env`, so a ttsc that is itself running
+ * inside a plugin sidecar — `@ttsc/lint` evaluating a config file through
+ * `ttsx`, for instance — would otherwise hand the outer run's `--strict` to its
+ * own sidecars, and `driver.LoadProgram` would apply it. The forwarded argv is
+ * per-invocation state the spawning host owns, the same rule
+ * `TTSC_PLUGIN_CONFIG_DIR` already follows. A caller that named the variable
+ * explicitly keeps it. Its argument-cwd companion follows the same explicit
+ * ownership, and publication of a new payload owns both channels.
+ *
+ * @evidence contracts/common.md#principled-implementation A nested sidecar keeps forwarded argv only when its caller declares that channel; otherwise outer invocation flags cannot silently change its compiler options.
+ * @evidence contracts/common.md#clear-and-simple-design One helper owns tsgo-payload inheritance policy and shares native environment-name handling with the other invocation channels.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Cleanup removes unrelated inherited authority rather than rewriting compiler behavior or substituting an expected diagnostic.
+ * @evidence contracts/common.md#meaningful-documentation Separate paragraphs explain nested-sidecar contamination and explicit preservation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native name lookup and replacement use the shared boundary, including Windows aliases and POSIX exact-name identity.
+ * @evidence contracts/performance.md#efficient-algorithms Cleanup delegates at most two caller-name scans and two child-name scans on Windows, including their Object.keys arrays and uppercase/comparison/deletion text costs. POSIX uses direct supplied-object key operations; neither branch parses or constructs a copy of forwarded payload text.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The mutable child channel belongs to the current spawn and has no reusable cross-invocation cleanup result.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This mutation retains no payload history, table, descriptor or running task.
+ */
+function clearInheritedTsgoArgs(env, callerEnv) {
+    SidecarEnvironment_1.SidecarEnvironment.write(env, TSGO_ARGS_ENV_1.TSGO_ARGS_ENV, SidecarEnvironment_1.SidecarEnvironment.read(callerEnv, TSGO_ARGS_ENV_1.TSGO_ARGS_ENV));
+    SidecarEnvironment_1.SidecarEnvironment.write(env, TSGO_ARGS_CWD_ENV_1.TSGO_ARGS_CWD_ENV, SidecarEnvironment_1.SidecarEnvironment.read(callerEnv, TSGO_ARGS_CWD_ENV_1.TSGO_ARGS_CWD_ENV));
+}
+//# sourceMappingURL=clearInheritedTsgoArgs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clearInheritedTsgoArgs.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/clearInheritedTsgoArgs.ts"],"names":[],"mappings":";;;AAAA,6DAA0D;AAC1D,2DAAwD;AACxD,mDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCACE,GAAsB,EACtB,SAAwC;IAExC,uCAAkB,CAAC,KAAK,CACtB,GAAG,EACH,6BAAa,EACb,uCAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,6BAAa,CAAC,CAClD,CAAC;IACF,uCAAkB,CAAC,KAAK,CACtB,GAAG,EACH,qCAAiB,EACjB,uCAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,qCAAiB,CAAC,CACtD,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,27 @@
+/**
+ * Merge inherited and caller environments with native variable-name identity,
+ * then clear per-invocation payloads this lane never published: forwarded tsgo
+ * arguments, semantic config ownership and the linked-plugin manifest.
+ *
+ * Use it at every spawn whose child can reach `driver.LoadProgram` — the
+ * `api-compile` / `api-transform` hosts, and the plugin loader, whose `ttsx`
+ * descriptor evaluation compiles a project of its own. One rule at every site
+ * beats four sites each reasoning about whether the variable could be present.
+ *
+ * `tsgoBinary` is the caller's explicit TypeScript-Go executable. It wins over
+ * an inherited or caller `TTSC_TSGO_BINARY`, as it does in `resolveTsgo`. This
+ * transports a selected executable hint to consumers of that channel; it
+ * neither validates its bytes nor certifies the compiler embedded in an
+ * arbitrary native host or every descendant's eventual selection.
+ *
+ * @evidence contracts/common.md#principled-implementation Native-aware layer merging gives caller values precedence over inherited values and places the explicit compiler hint in the final channel layer; unrelated invocation channels are then cleared or restored from the caller's own declarations.
+ * @evidence contracts/common.md#clear-and-simple-design One constructor serves compile, transform and descriptor-evaluation children, with each channel's ownership policy delegated to its named helper.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A fresh explicit environment carries selected authority without mutating process.env, patching spawn behavior or guessing a compiler from the outer sidecar's identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe consumers, per-invocation cleanup and explicit compiler precedence following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared merge treats Windows names case-insensitively across layers while POSIX names retain exact spelling; cleanup follows that same native identity rule.
+ * @evidence contracts/performance.md#efficient-algorithms Environment construction and the fixed channel operations enumerate/copy names and, on Windows, allocate key arrays/maps and uppercase/compare/delete name text. Returned environment strings transfer to the caller; channel payloads are not parsed here, and no subprocess probe is needed for name identity.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Per-invocation environment authority changes and the returned object is mutable; no stable equivalent-request producer authorizes shared objects.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The new environment transfers to the spawning caller without retaining outer payloads or environment history in this module.
+ */
+export declare function inheritedSidecarEnv(callerEnv: NodeJS.ProcessEnv | undefined, tsgoBinary?: string): NodeJS.ProcessEnv;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inheritedSidecarEnv = inheritedSidecarEnv;
+const SidecarEnvironment_1 = require("./SidecarEnvironment");
+const clearInheritedSemanticConfigPath_1 = require("./clearInheritedSemanticConfigPath");
+const clearInheritedTsgoArgs_1 = require("./clearInheritedTsgoArgs");
+const publishLinkedTransformPlugins_1 = require("./publishLinkedTransformPlugins");
+/**
+ * Merge inherited and caller environments with native variable-name identity,
+ * then clear per-invocation payloads this lane never published: forwarded tsgo
+ * arguments, semantic config ownership and the linked-plugin manifest.
+ *
+ * Use it at every spawn whose child can reach `driver.LoadProgram` — the
+ * `api-compile` / `api-transform` hosts, and the plugin loader, whose `ttsx`
+ * descriptor evaluation compiles a project of its own. One rule at every site
+ * beats four sites each reasoning about whether the variable could be present.
+ *
+ * `tsgoBinary` is the caller's explicit TypeScript-Go executable. It wins over
+ * an inherited or caller `TTSC_TSGO_BINARY`, as it does in `resolveTsgo`. This
+ * transports a selected executable hint to consumers of that channel; it
+ * neither validates its bytes nor certifies the compiler embedded in an
+ * arbitrary native host or every descendant's eventual selection.
+ *
+ * @evidence contracts/common.md#principled-implementation Native-aware layer merging gives caller values precedence over inherited values and places the explicit compiler hint in the final channel layer; unrelated invocation channels are then cleared or restored from the caller's own declarations.
+ * @evidence contracts/common.md#clear-and-simple-design One constructor serves compile, transform and descriptor-evaluation children, with each channel's ownership policy delegated to its named helper.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts A fresh explicit environment carries selected authority without mutating process.env, patching spawn behavior or guessing a compiler from the outer sidecar's identity.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs describe consumers, per-invocation cleanup and explicit compiler precedence following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The shared merge treats Windows names case-insensitively across layers while POSIX names retain exact spelling; cleanup follows that same native identity rule.
+ * @evidence contracts/performance.md#efficient-algorithms Environment construction and the fixed channel operations enumerate/copy names and, on Windows, allocate key arrays/maps and uppercase/compare/delete name text. Returned environment strings transfer to the caller; channel payloads are not parsed here, and no subprocess probe is needed for name identity.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Per-invocation environment authority changes and the returned object is mutable; no stable equivalent-request producer authorizes shared objects.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The new environment transfers to the spawning caller without retaining outer payloads or environment history in this module.
+ */
+function inheritedSidecarEnv(callerEnv, tsgoBinary) {
+    const env = SidecarEnvironment_1.SidecarEnvironment.merge(process.env, callerEnv, tsgoBinary === undefined ? undefined : { TTSC_TSGO_BINARY: tsgoBinary });
+    (0, clearInheritedTsgoArgs_1.clearInheritedTsgoArgs)(env, callerEnv);
+    (0, clearInheritedSemanticConfigPath_1.clearInheritedSemanticConfigPath)(env, callerEnv);
+    (0, publishLinkedTransformPlugins_1.publishLinkedTransformPlugins)(env, callerEnv, []);
+    return env;
+}
+//# sourceMappingURL=inheritedSidecarEnv.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inheritedSidecarEnv.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/inheritedSidecarEnv.ts"],"names":[],"mappings":";;;AAAA,6DAA0D;AAC1D,yFAAsF;AACtF,qEAAkE;AAClE,mFAAgF;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,6BACE,SAAwC,EACxC,UAAmB;IAEnB,MAAM,GAAG,GAAG,uCAAkB,CAAC,KAAK,CAClC,OAAO,CAAC,GAAG,EACX,SAAS,EACT,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,UAAU,EAAE,CACxE,CAAC;IACF,IAAA,+CAAsB,EAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACvC,IAAA,mEAAgC,EAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACjD,IAAA,6DAA6B,EAAC,GAAG,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * Reports whether the given transform source is linked into another compiler
+ * host instead of owning the process itself.
+ *
+ * @evidence contracts/common.md#principled-implementation Both transform stage and linked ownership must hold; a check-stage descriptor never becomes a transform library merely by sharing the kind spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One discriminant predicate supplies filtering and host selection, so each consumer uses the same ownership distinction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Declared stage and kind decide ownership, independent of plugin names, binary filenames or expected consumer outcomes.
+ * @evidence contracts/common.md#meaningful-documentation The native sentence identifies the ownership distinction without reciting the equality expressions, following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Stage and kind are platform-independent descriptor values; this predicate owns no native path or process boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Two literal discriminant comparisons choose no growing-workload algorithm or processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The predicate reads a supplied descriptor and coordinates no cross-request work.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No state, handle or task is acquired or retained by this predicate.
+ */
+export declare function isLinkedTransform(plugin: ITtscLoadedNativePlugin): boolean;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLinkedTransform = isLinkedTransform;
+/**
+ * Reports whether the given transform source is linked into another compiler
+ * host instead of owning the process itself.
+ *
+ * @evidence contracts/common.md#principled-implementation Both transform stage and linked ownership must hold; a check-stage descriptor never becomes a transform library merely by sharing the kind spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One discriminant predicate supplies filtering and host selection, so each consumer uses the same ownership distinction.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Declared stage and kind decide ownership, independent of plugin names, binary filenames or expected consumer outcomes.
+ * @evidence contracts/common.md#meaningful-documentation The native sentence identifies the ownership distinction without reciting the equality expressions, following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Stage and kind are platform-independent descriptor values; this predicate owns no native path or process boundary.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Two literal discriminant comparisons choose no growing-workload algorithm or processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The predicate reads a supplied descriptor and coordinates no cross-request work.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources No state, handle or task is acquired or retained by this predicate.
+ */
+function isLinkedTransform(plugin) {
+    return plugin.stage === "transform" && plugin.kind === "linked";
+}
+//# sourceMappingURL=isLinkedTransform.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isLinkedTransform.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/isLinkedTransform.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH,2BAAkC,MAA+B;IAC/D,OAAO,MAAM,CAAC,KAAK,KAAK,WAAW,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;AAClE,CAAC"}

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

@@ -0,0 +1,19 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * Return every plugin whose transform source is linked into another host binary
+ * rather than owning the process. The host binary passes these via
+ * `TTSC_LINKED_PLUGINS_JSON` so their Go code runs inside the same process.
+ *
+ * @evidence contracts/common.md#principled-implementation Filtering through the shared ownership predicate preserves source order and descriptor identities while selecting only statically linked transform libraries.
+ * @evidence contracts/common.md#clear-and-simple-design The collector delegates ownership classification rather than duplicating it beside manifest publication.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No plugin name or fixture dictates selection; stage and kind express the actual linked-library contract.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains which descriptors are returned and why the host forwards them, following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Filtering descriptor ownership does not interpret native paths or spawn processes; the native manifest consumer owns that boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms A single O(P) scan collects linked descriptors in order, using O(L) returned references for L matches without copying descriptor contents.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The input is caller-owned and the returned array is independently mutable; this collector coordinates no stable cross-request computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The filtered array transfers to the caller, and no historical plugin population or native resource remains here.
+ */
+export declare function linkedTransformPlugins(plugins: readonly ITtscLoadedNativePlugin[]): ITtscLoadedNativePlugin[];

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkedTransformPlugins = linkedTransformPlugins;
+const isLinkedTransform_1 = require("./isLinkedTransform");
+/**
+ * Return every plugin whose transform source is linked into another host binary
+ * rather than owning the process. The host binary passes these via
+ * `TTSC_LINKED_PLUGINS_JSON` so their Go code runs inside the same process.
+ *
+ * @evidence contracts/common.md#principled-implementation Filtering through the shared ownership predicate preserves source order and descriptor identities while selecting only statically linked transform libraries.
+ * @evidence contracts/common.md#clear-and-simple-design The collector delegates ownership classification rather than duplicating it beside manifest publication.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No plugin name or fixture dictates selection; stage and kind express the actual linked-library contract.
+ * @evidence contracts/common.md#meaningful-documentation The native comment explains which descriptors are returned and why the host forwards them, following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation Filtering descriptor ownership does not interpret native paths or spawn processes; the native manifest consumer owns that boundary.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms A single O(P) scan collects linked descriptors in order, using O(L) returned references for L matches without copying descriptor contents.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The input is caller-owned and the returned array is independently mutable; this collector coordinates no stable cross-request computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The filtered array transfers to the caller, and no historical plugin population or native resource remains here.
+ */
+function linkedTransformPlugins(plugins) {
+    return plugins.filter(isLinkedTransform_1.isLinkedTransform);
+}
+//# sourceMappingURL=linkedTransformPlugins.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linkedTransformPlugins.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/linkedTransformPlugins.ts"],"names":[],"mappings":";;;AACA,2DAAwD;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,gCACE,OAA2C;IAE3C,OAAO,OAAO,CAAC,MAAM,CAAC,qCAAiB,CAAC,CAAC;AAC3C,CAAC"}

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

@@ -0,0 +1,25 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * Publish this invocation's linked transform plugins to a sidecar environment,
+ * or drop a manifest inherited from an outer ttsc run.
+ *
+ * `TTSC_LINKED_PLUGINS_JSON` names the plugins linked into the host binary this
+ * invocation selected. Every sidecar env starts from `process.env`, so a ttsc
+ * running inside another host's sidecar would otherwise hand the outer run's
+ * manifest to a nested build that linked nothing, and the Go host would run
+ * plugins it never chose, or fail on a payload it cannot parse. The manifest is
+ * per-invocation state the spawning host owns, the rule the forwarded tsgo
+ * payload already follows. A caller that named the variable explicitly keeps
+ * it.
+ *
+ * @evidence contracts/common.md#principled-implementation A nonempty selected linked list supplies this invocation's manifest; otherwise only an explicit caller channel may survive, preventing an outer host's libraries from executing in a nested unrelated pass.
+ * @evidence contracts/common.md#clear-and-simple-design Publication delegates the wire shape to NativePluginArguments and native name identity to the environment boundary; this helper owns only which invocation may supply the manifest.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor data selects the linked libraries; inherited unrelated manifests are removed instead of retrying a failed host with guessed plugin configuration.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain current-host ownership, nested-run contamination and explicit caller preservation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The writer removes Windows aliases before publishing one authoritative channel; POSIX changes only the exact protocol name.
+ * @evidence contracts/performance.md#efficient-algorithms A nonempty linked list projects L descriptors and serializes their config/name/stage data, including property traversal and caller conversion rather than only resulting wire bytes. Empty selection observes the caller channel instead. Windows environment scans allocate key arrays and process name text; each selected manifest is serialized once for this destination.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current linked descriptor configuration and destination environment are mutable invocation effects; this publisher owns no shared immutable manifest identity or invalidation coordinator.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Manifest text is stored only on the caller-owned environment; this module retains no linked-plugin population or running host.
+ */
+export declare function publishLinkedTransformPlugins(env: NodeJS.ProcessEnv, callerEnv: NodeJS.ProcessEnv | undefined, linked: readonly ITtscLoadedNativePlugin[]): void;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishLinkedTransformPlugins = publishLinkedTransformPlugins;
+const NativePluginArguments_1 = require("../build/NativePluginArguments");
+const SidecarEnvironment_1 = require("./SidecarEnvironment");
+/**
+ * Publish this invocation's linked transform plugins to a sidecar environment,
+ * or drop a manifest inherited from an outer ttsc run.
+ *
+ * `TTSC_LINKED_PLUGINS_JSON` names the plugins linked into the host binary this
+ * invocation selected. Every sidecar env starts from `process.env`, so a ttsc
+ * running inside another host's sidecar would otherwise hand the outer run's
+ * manifest to a nested build that linked nothing, and the Go host would run
+ * plugins it never chose, or fail on a payload it cannot parse. The manifest is
+ * per-invocation state the spawning host owns, the rule the forwarded tsgo
+ * payload already follows. A caller that named the variable explicitly keeps
+ * it.
+ *
+ * @evidence contracts/common.md#principled-implementation A nonempty selected linked list supplies this invocation's manifest; otherwise only an explicit caller channel may survive, preventing an outer host's libraries from executing in a nested unrelated pass.
+ * @evidence contracts/common.md#clear-and-simple-design Publication delegates the wire shape to NativePluginArguments and native name identity to the environment boundary; this helper owns only which invocation may supply the manifest.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor data selects the linked libraries; inherited unrelated manifests are removed instead of retrying a failed host with guessed plugin configuration.
+ * @evidence contracts/common.md#meaningful-documentation The native paragraphs explain current-host ownership, nested-run contamination and explicit caller preservation following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation The writer removes Windows aliases before publishing one authoritative channel; POSIX changes only the exact protocol name.
+ * @evidence contracts/performance.md#efficient-algorithms A nonempty linked list projects L descriptors and serializes their config/name/stage data, including property traversal and caller conversion rather than only resulting wire bytes. Empty selection observes the caller channel instead. Windows environment scans allocate key arrays and process name text; each selected manifest is serialized once for this destination.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current linked descriptor configuration and destination environment are mutable invocation effects; this publisher owns no shared immutable manifest identity or invalidation coordinator.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Manifest text is stored only on the caller-owned environment; this module retains no linked-plugin population or running host.
+ */
+function publishLinkedTransformPlugins(env, callerEnv, linked) {
+    SidecarEnvironment_1.SidecarEnvironment.write(env, LINKED_PLUGINS_ENV, linked.length !== 0
+        ? NativePluginArguments_1.NativePluginArguments.serializeNativePlugins(linked)
+        : SidecarEnvironment_1.SidecarEnvironment.read(callerEnv, LINKED_PLUGINS_ENV));
+}
+const LINKED_PLUGINS_ENV = "TTSC_LINKED_PLUGINS_JSON";
+//# sourceMappingURL=publishLinkedTransformPlugins.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publishLinkedTransformPlugins.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/publishLinkedTransformPlugins.ts"],"names":[],"mappings":";;;AACA,0EAAuE;AACvE,6DAA0D;AAE1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCACE,GAAsB,EACtB,SAAwC,EACxC,MAA0C;IAE1C,uCAAkB,CAAC,KAAK,CACtB,GAAG,EACH,kBAAkB,EAClB,MAAM,CAAC,MAAM,KAAK,CAAC;QACjB,CAAC,CAAC,6CAAqB,CAAC,sBAAsB,CAAC,MAAM,CAAC;QACtD,CAAC,CAAC,uCAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAC3D,CAAC;AACJ,CAAC;AAED,MAAM,kBAAkB,GAAG,0BAA0B,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * Resolve the caller-declared plugin config anchor to an absolute path, or
+ * `undefined` when the caller did not declare one.
+ *
+ * The anchor exists for embedders that compile through a generated tsconfig
+ * outside the project (the bundler adapters' alias overlay): they set
+ * `pluginConfigDir` to the real project directory. Build and transform
+ * environment composers use this result for `TTSC_PLUGIN_CONFIG_DIR`, with
+ * their own caller-environment precedence. This resolver does not inspect that
+ * environment or authenticate a config's physical ancestry. An absent anchor
+ * returns undefined for the consumer's ordinary discovery policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an explicit nonempty config anchor overrides discovery ancestry; path.resolve interprets a relative anchor from the declared cwd or current process directory.
+ * @evidence contracts/common.md#clear-and-simple-design One resolver serves generated-wrapper consumers while preserving undefined as the ordinary tsconfig-owned discovery policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The anchor comes from caller authority, not a hardcoded consumer name or a guessed project directory beside a temporary wrapper.
+ * @evidence contracts/common.md#meaningful-documentation Purpose and wrapper rationale explain both explicit and absent-anchor behavior in separate paragraphs following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation path.resolve performs native path anchoring; no slash replacement or OS-based case policy is used to turn the caller's spelling into identity.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This adapter delegates one native path-resolution operation and chooses no independent growing-workload algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Caller options and process cwd remain invocation inputs; this accessor coordinates no reusable computation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only an optional path string is returned; no filesystem handle, retained state or task is acquired.
+ */
+export declare function resolvePluginConfigDir(options: {
+    cwd?: string;
+    pluginConfigDir?: string;
+}): string | undefined;

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginConfigDir = resolvePluginConfigDir;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Resolve the caller-declared plugin config anchor to an absolute path, or
+ * `undefined` when the caller did not declare one.
+ *
+ * The anchor exists for embedders that compile through a generated tsconfig
+ * outside the project (the bundler adapters' alias overlay): they set
+ * `pluginConfigDir` to the real project directory. Build and transform
+ * environment composers use this result for `TTSC_PLUGIN_CONFIG_DIR`, with
+ * their own caller-environment precedence. This resolver does not inspect that
+ * environment or authenticate a config's physical ancestry. An absent anchor
+ * returns undefined for the consumer's ordinary discovery policy.
+ *
+ * @evidence contracts/common.md#principled-implementation Only an explicit nonempty config anchor overrides discovery ancestry; path.resolve interprets a relative anchor from the declared cwd or current process directory.
+ * @evidence contracts/common.md#clear-and-simple-design One resolver serves generated-wrapper consumers while preserving undefined as the ordinary tsconfig-owned discovery policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The anchor comes from caller authority, not a hardcoded consumer name or a guessed project directory beside a temporary wrapper.
+ * @evidence contracts/common.md#meaningful-documentation Purpose and wrapper rationale explain both explicit and absent-anchor behavior in separate paragraphs following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation path.resolve performs native path anchoring; no slash replacement or OS-based case policy is used to turn the caller's spelling into identity.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms This adapter delegates one native path-resolution operation and chooses no independent growing-workload algorithm.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Caller options and process cwd remain invocation inputs; this accessor coordinates no reusable computation across requests.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Only an optional path string is returned; no filesystem handle, retained state or task is acquired.
+ */
+function resolvePluginConfigDir(options) {
+    if (options.pluginConfigDir === undefined || options.pluginConfigDir === "") {
+        return undefined;
+    }
+    return node_path_1.default.resolve(options.cwd ?? process.cwd(), options.pluginConfigDir);
+}
+//# sourceMappingURL=resolvePluginConfigDir.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePluginConfigDir.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/resolvePluginConfigDir.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAE7B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAAuC,OAGtC;IACC,IAAI,OAAO,CAAC,eAAe,KAAK,SAAS,IAAI,OAAO,CAAC,eAAe,KAAK,EAAE,EAAE,CAAC;QAC5E,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;AAC7E,CAAC"}

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

@@ -0,0 +1,22 @@
+import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
+/**
+ * Picks the native binary that must own the compiler pass. Linked transform
+ * sources ride inside a host that uses driver.LoadProgram, so an executable
+ * transform wins when one is present.
+ *
+ * The caller supplies a nonempty ordered plugin population for this pass. An
+ * empty population is a setup error, not an implicit host identity.
+ *
+ * @evidence contracts/common.md#principled-implementation The first executable owner takes the pass; when every transform is linked, the first descriptor supplies the aggregate host. Empty input cannot represent a host and is rejected explicitly.
+ * @evidence contracts/common.md#clear-and-simple-design One selection rule serves build, transform and argument capability decisions instead of each consumer choosing a different owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor ownership and order govern selection, without a plugin-name priority or a guessed default executable.
+ * @evidence contracts/common.md#meaningful-documentation Separate paragraphs state executable preference and the nonempty input requirement following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The result is an existing descriptor; this selector neither resolves its binary path nor starts a native process.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms find stops at the first executable owner, requiring at most O(P) predicate checks and constant auxiliary state.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current pass ordering determines the owner; no cross-request host selection or invalidation coordinator belongs to this accessor.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned descriptor remains caller-owned and no process or retained plugin population is acquired.
+ */
+export declare function selectSharedHostPlugin(plugins: readonly ITtscLoadedNativePlugin[]): ITtscLoadedNativePlugin;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSharedHostPlugin = selectSharedHostPlugin;
+const isLinkedTransform_1 = require("./isLinkedTransform");
+/**
+ * Picks the native binary that must own the compiler pass. Linked transform
+ * sources ride inside a host that uses driver.LoadProgram, so an executable
+ * transform wins when one is present.
+ *
+ * The caller supplies a nonempty ordered plugin population for this pass. An
+ * empty population is a setup error, not an implicit host identity.
+ *
+ * @evidence contracts/common.md#principled-implementation The first executable owner takes the pass; when every transform is linked, the first descriptor supplies the aggregate host. Empty input cannot represent a host and is rejected explicitly.
+ * @evidence contracts/common.md#clear-and-simple-design One selection rule serves build, transform and argument capability decisions instead of each consumer choosing a different owner.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Descriptor ownership and order govern selection, without a plugin-name priority or a guessed default executable.
+ * @evidence contracts/common.md#meaningful-documentation Separate paragraphs state executable preference and the nonempty input requirement following the documentation skill.
+ *
+ * @evidenceExclude contracts/portability.md#os-neutral-implementation The result is an existing descriptor; this selector neither resolves its binary path nor starts a native process.
+ *
+ * @evidence contracts/performance.md#efficient-algorithms find stops at the first executable owner, requiring at most O(P) predicate checks and constant auxiliary state.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Current pass ordering determines the owner; no cross-request host selection or invalidation coordinator belongs to this accessor.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned descriptor remains caller-owned and no process or retained plugin population is acquired.
+ */
+function selectSharedHostPlugin(plugins) {
+    const selected = plugins.find((plugin) => !(0, isLinkedTransform_1.isLinkedTransform)(plugin)) ?? plugins[0];
+    if (selected === undefined) {
+        throw new Error("ttsc: a shared compiler pass requires at least one plugin");
+    }
+    return selected;
+}
+//# sourceMappingURL=selectSharedHostPlugin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectSharedHostPlugin.js","sourceRoot":"","sources":["../../../../src/compiler/internal/sharedHost/selectSharedHostPlugin.ts"],"names":[],"mappings":";;;AACA,2DAAwD;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCACE,OAA2C;IAE3C,MAAM,QAAQ,GACZ,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAA,qCAAiB,EAAC,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IACrE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CACb,2DAA2D,CAC5D,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/lib/compiler/internal/spawnNative.d.ts

@@ -1,29 +1,28 @@
 import { type SpawnSyncReturns } from "node:child_process";
 /**
  * Spawn a native binary (or a Node.js script when the path has a JS/TS
- * extension) and return its result with `stdout` and `stderr` as text.
+ * extension) and return its result with decoded or raw-buffer output streams.
  *
- * The child's streams are written to files rather than piped, and the files are
- * read once it exits. `spawnSync` buffers a _piped_ stream in this process's
- * memory and refuses to hold more than `maxBuffer` bytes, so a piped capture
- * has to name a ceiling — and any ceiling is a number nobody chose for this
- * machine, deciding that a large but legitimate compile said too much. A file
- * has no such limit: the bytes never pass through this heap on their way out of
- * the child, and how many there may be is the filesystem's business.
+ * Streams go to private files and are materialized after exit, avoiding the
+ * piped maxBuffer ceiling while retaining filesystem and runtime allocation
+ * limits. Filesystem read failures propagate after capture cleanup.
  *
  * When `options.encoding` is omitted it defaults to `"utf8"`. Pass `"buffer"`
  * when the caller needs raw bytes.
+ *
+ * @evidence contracts/common.md#principled-implementation Executable plus argv are passed directly to Node spawning; script candidates instead pass their path to process.execPath, and file-backed output reconstructs the normal stdout/stderr/output result fields.
+ * @evidence contracts/common.md#clear-and-simple-design This operation owns synchronous execution and capture lifetime; permission preparation, low-descriptor recovery and byte decoding remain explicit delegated boundaries.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No shell parses argv or foreign process API is replaced. Descriptor recovery is selected by the real resource-exhaustion contract in spawnSyncResilient rather than a fixture outcome.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain executable routing, capture limits, read errors and encoding ownership following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Node receives native executable and argument arrays, Windows hiding is an explicit process option, and POSIX permission preparation remains in ensureExecutable rather than shell-specific commands.
+ * @evidence contracts/performance.md#efficient-algorithms Argument-reference copying costs O(A); native argv/environment launch work, permission checks, capture acquisition and any broker retry/report costs are delegated but remain part of this call. Reads/decoding allocate complete output proportional to B child bytes. Each stream is read once after synchronous completion; neither output size nor child duration is capped here.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A child execution may have effects and depend on arbitrary filesystem state; this wrapper has no equivalence or invalidation contract permitting reuse of a previous process result.
+ *
+ * @evidence contracts/performance.md#bound-retention-and-release-resources An acquired capture reaches finally on spawn, recovery and read failures; acquisition has its own rollback attempts. Disposal attempts closure/removal with suppressed failures, so native release is not certified. Materialized output transfers to the caller, and capture/returned bytes grow without a configured ceiling; no timeout or descendant-join policy is supplied here.
  */
 export declare function spawnNative(binary: string, args: readonly string[], options: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     encoding?: BufferEncoding | "buffer";
 }): SpawnSyncReturns<string | Buffer>;
-/**
- * Ensure the binary has the executable bit set on POSIX systems. Silently skips
- * on Windows and swallows `chmod` errors to let the original spawn error
- * surface instead of masking it with a permission error.
- */
-export declare function ensureExecutable(binary: string): void;
-/** Coerce a `spawnSync` output value to a plain string, defaulting to `""`. */
-export declare function outputText(value: string | Buffer | null | undefined): string;