ttsc 0.31.0 → 0.31.2

package/src/compiler/internal/build/BuildExecution.ts

@@ -5,6 +5,7 @@ import { createCanonicalTempDirectory } from "../../../internal/createCanonicalT
 import { resolveNodeBinary } from "../../../internal/resolveNodeBinary";
 import { hasProjectPluginEntries } from "../../../plugin/internal/load/hasProjectPluginEntries";
 import { loadProjectPlugins } from "../../../plugin/internal/load/loadProjectPlugins";
+import { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
@@ -70,19 +71,37 @@ export namespace BuildExecution {
    * Merge extra environment variables over `process.env`, always injecting
    * `TTSC_NODE_BINARY` selected by the runtime capability owner. Explicit
    * compatible overrides can select a different Node executable; this is not
-   * necessarily the current process binary.
+   * necessarily the current process binary. An invocation that loaded plugins
+   * passes its record store, so the runtime is proven from metadata instead of
+   * streamed again before every native spawn (#1723).
    */
   function mergeEnv(
-    extra?: NodeJS.ProcessEnv,
-    cwd: string = process.cwd(),
+    extra: NodeJS.ProcessEnv | undefined,
+    cwd: string,
+    identities: PluginContentIdentities.Store | undefined,
     ...later: readonly (NodeJS.ProcessEnv | undefined)[]
   ): NodeJS.ProcessEnv {
     const env = SidecarEnvironment.merge(process.env, extra, ...later);
-    const node = resolveNodeBinary(env, cwd);
+    const node = resolveNodeBinary(env, cwd, identities);
     SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
     return env;
   }
 
+  /**
+   * Merge extra environment variables over `process.env` for a spawn of the
+   * selected TypeScript-Go compiler itself.
+   *
+   * WARNING (#1726): the compiler never reads `TTSC_NODE_BINARY`, which only
+   * plugin sidecars consume (`mergeEnv`). Selecting it streamed the 85 MB Node
+   * executable twice and probed it on every launch, plugins or not, about 0.2 s
+   * of a 0.5 s build without plugins.
+   */
+  function compilerEnv(
+    extra: NodeJS.ProcessEnv | undefined,
+  ): NodeJS.ProcessEnv {
+    return SidecarEnvironment.merge(process.env, extra);
+  }
+
   /**
    * Build the environment for a native plugin spawn. Injects `TTSC_TSGO_BINARY`
    * and `TTSC_TTSX_BINARY` alongside the base env from `mergeEnv`, plus
@@ -123,6 +142,7 @@ export namespace BuildExecution {
           path.join(__dirname, "..", "..", "..", "launcher", "ttsx.js"),
       },
       execution.projectRoot,
+      execution.identities,
       extra,
       // The invocation's resolved compiler owns the final environment layer.
       { TTSC_TSGO_BINARY: execution.tsgo.binary },
@@ -453,7 +473,7 @@ export namespace BuildExecution {
    * @evidence contracts/common.md#prohibited-implementation-shortcuts The caught resolution failure is legitimate only for commands not requiring a project; ordinary compilation failures do not enter this bypass.
    * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain project-independent commands, existing-project behavior and null applicability; the catch comment states its deliberate broad premise.
    * @evidence contracts/portability.md#os-neutral-implementation Invocation cwd is resolved natively and spawnNative receives executable/argv separately with platform-aware environment merging.
-   * @evidence contracts/performance.md#efficient-algorithms Flag selection scans forwarded argument/name text before config IO. An applicable lane includes native cwd/config resolution, binary and runtime capability lookup, argv/env composition, complete captured output and diagnostic normalization; one requested command does not bound its native duration or output bytes.
+   * @evidence contracts/performance.md#efficient-algorithms Flag selection scans forwarded argument/name text before config IO. An applicable lane includes native cwd/config resolution, binary lookup, argv/env composition without runtime capability work (#1726), complete captured output and diagnostic normalization; one requested command does not bound its native duration or output bytes.
    *
    * @evidenceExclude contracts/performance.md#reuse-equivalent-work A project probe and effectful terminal invocation establish no retained or shared cross-request result.
    *
@@ -482,7 +502,7 @@ export namespace BuildExecution {
     const tsgo = resolveTsgo({ ...options, cwd });
     const res = spawnNative(tsgo.binary, [...(options.passthrough ?? [])], {
       cwd,
-      env: mergeEnv(options.env, cwd),
+      env: compilerEnv(options.env),
       encoding: "utf8",
     });
     if (res.error) {
@@ -796,7 +816,7 @@ export namespace BuildExecution {
    * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported compiler options express the check contract without intercepting writes or replacing compiler APIs; spawn errors remain errors.
    * @evidence contracts/common.md#meaningful-documentation Native prose explains the no-emit use and load-bearing argument precedence.
    * @evidence contracts/portability.md#os-neutral-implementation spawnNative uses the selected executable, separate argv and project cwd; environment composition handles native variable aliases and output text decoding is explicit UTF-8.
-   * @evidence contracts/performance.md#efficient-algorithms One argv composition includes delegated option-presence classification, threading/isolation text and argument copies. Environment composition can perform native runtime capability probes before the compiler launch; complete capture/decoding and diagnostic normalization follow. Work/storage depend on argument/env/path/report bytes and native child work, without an asserted measured cost ranking.
+   * @evidence contracts/performance.md#efficient-algorithms One argv composition includes delegated option-presence classification, threading/isolation text and argument copies. Environment composition only layers variables; the compiler reads no Node selection, so no runtime capability probe precedes the launch (#1726). Complete capture/decoding and diagnostic normalization follow. Work/storage depend on argument/env/path/report bytes and native child work, without an asserted measured cost ranking.
    *
    * @evidenceExclude contracts/performance.md#reuse-equivalent-work This executes the requested compiler pass; equivalence with other phases must be established by orchestration rather than caching a result here.
    *
@@ -822,7 +842,7 @@ export namespace BuildExecution {
       ],
       {
         cwd: execution.compilerSelection.compilerArgsCwd,
-        env: mergeEnv(options.env, execution.projectRoot),
+        env: compilerEnv(options.env),
         encoding: "utf8",
       },
     );
@@ -856,7 +876,7 @@ export namespace BuildExecution {
     options: RunBuildOptions,
     args: readonly string[],
   ): TtscBuildResult {
-    const env = mergeEnv(options.env, execution.projectRoot);
+    const env = compilerEnv(options.env);
     const userOptions = readEffectiveCompilerOptions(
       execution.project,
       options.passthrough,
@@ -1183,19 +1203,31 @@ export namespace BuildExecution {
     const tsgo = resolveTsgo({ ...options, cwd: projectRoot });
     let pluginSetupFailure: TtscBuildResult | undefined;
     let nativePlugins: ITtscLoadedNativePlugin[] = [];
+    // Opened only for an invocation that loads plugins, so a project without
+    // any never gains a cache directory; the load and every later native spawn
+    // of this invocation prove their unchanged inputs through it (#1722, #1723).
+    let identities: PluginContentIdentities.Store | undefined;
     try {
       if (
         compilerSelection.inspectionError === undefined &&
         hasProjectPluginEntries(project, options.plugins)
       ) {
+        const cacheDir =
+          options.cacheDir ??
+          SidecarEnvironment.read(options.env, "TTSC_CACHE_DIR");
+        const env = inheritedSidecarEnv(options.env, options.binary);
+        identities = PluginContentIdentities.open({
+          projectRoot,
+          cacheDir,
+          env,
+        });
         nativePlugins = loadProjectPlugins({
           binary: resolveBinary(options) ?? "",
-          cacheDir:
-            options.cacheDir ??
-            SidecarEnvironment.read(options.env, "TTSC_CACHE_DIR"),
+          cacheDir,
           cwd,
           entries: options.plugins,
-          env: inheritedSidecarEnv(options.env, options.binary),
+          env,
+          identities,
           onWatchInputs: options.onWatchInputs,
           pluginConfigDir: options.pluginConfigDir,
           projectRoot,
@@ -1215,6 +1247,7 @@ export namespace BuildExecution {
     return {
       compilerSelection,
       cwd,
+      ...(identities === undefined ? {} : { identities }),
       nativePlugins,
       pluginConfigDir: resolvePluginConfigDir({
         cwd,

package/src/compiler/internal/startResidentTransform.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 
 import { resolveNodeBinary } from "../../internal/resolveNodeBinary";
 import { loadProjectPlugins } from "../../plugin/internal/load/loadProjectPlugins";
+import type { PluginContentIdentities } from "../../plugin/internal/source/PluginContentIdentities";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
 import { ResidentTransformProcess } from "./ResidentTransformProcess";
@@ -94,7 +95,13 @@ export function startResidentTransform(
     ],
     binary: host.binary,
     cwd: project.root,
-    env: residentEnv(context, project.root, tsgoBinary, loaded.nativePlugins),
+    env: residentEnv(
+      context,
+      project.root,
+      tsgoBinary,
+      loaded.nativePlugins,
+      loaded.identities,
+    ),
   });
   return { process: resident, projectRoot: project.root };
 }
@@ -106,13 +113,15 @@ export function startResidentTransform(
  * plugin config anchor (an embedder compiling through a generated wrapper
  * tsconfig) so config-file discovery walks the real project instead of the
  * wrapper's temp-dir ancestry, and forwards linked transform plugins via
- * `TTSC_LINKED_PLUGINS_JSON`.
+ * `TTSC_LINKED_PLUGINS_JSON`. The load's record store proves the Node runtime
+ * from metadata instead of streaming it again (#1723).
  */
 function residentEnv(
   context: ITtscCompilerContext,
   projectRoot: string,
   tsgoBinary: string,
   nativePlugins: readonly ITtscLoadedNativePlugin[],
+  identities: PluginContentIdentities.Store | undefined,
 ): NodeJS.ProcessEnv {
   const pluginConfigDir = resolvePluginConfigDir(context);
   const env = SidecarEnvironment.merge(
@@ -128,7 +137,7 @@ function residentEnv(
     context.env,
     { TTSC_TSGO_BINARY: tsgoBinary },
   );
-  const node = resolveNodeBinary(env, projectRoot);
+  const node = resolveNodeBinary(env, projectRoot, identities);
   SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
   // The anchor is per-invocation state owned by this host: when this run
   // declared none (and the caller's env does not name one), drop any value

package/src/compiler/internal/transformProjectInMemory.ts

@@ -5,6 +5,7 @@ import { collectProjectHostInputs } from "../../plugin/internal/load/collectProj
 import { hashHostInputPaths } from "../../plugin/internal/load/hashHostInputPaths";
 import { loadProjectPlugins } from "../../plugin/internal/load/loadProjectPlugins";
 import { realpathHostInputPaths } from "../../plugin/internal/load/realpathHostInputPaths";
+import type { PluginContentIdentities } from "../../plugin/internal/source/PluginContentIdentities";
 import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
 import type { ITtscCompilerTransformation } from "../../structures/ITtscCompilerTransformation";
 import type { ITtscLoadedNativePlugin } from "../../structures/internal/ITtscLoadedNativePlugin";
@@ -301,6 +302,7 @@ function transformProjectWithPlugins(
     tsgoBinary,
     loaded.nativePlugins,
     checks,
+    loaded.identities,
   );
   const checkedHostInputs = mergeHostInputs(
     loaded.hostInputs,
@@ -414,6 +416,7 @@ function transformProjectWithPlugins(
         tsgoBinary,
         loaded.nativePlugins,
         plugin,
+        loaded.identities,
       ),
     },
   );
@@ -688,6 +691,7 @@ function runNativeChecks(
   tsgoBinary: string,
   nativePlugins: readonly ITtscLoadedNativePlugin[],
   checks: readonly ITtscLoadedNativePlugin[],
+  identities: PluginContentIdentities.Store | undefined,
 ): TtscBuildResult {
   let result: TtscBuildResult = {
     diagnostics: [],
@@ -716,6 +720,7 @@ function runNativeChecks(
             tsgoBinary,
             nativePlugins,
             plugin,
+            identities,
           ),
         },
       );
@@ -804,7 +809,9 @@ function serializeNativePlugins(
  * the caller declared a plugin config anchor (an embedder compiling through a
  * generated wrapper tsconfig) so config-file discovery walks the real project
  * instead of the wrapper's temp-dir ancestry. For transform plugins, also
- * passes `TTSC_LINKED_PLUGINS_JSON` when linked sources are present.
+ * passes `TTSC_LINKED_PLUGINS_JSON` when linked sources are present. The load's
+ * record store proves the Node runtime from metadata instead of streaming it
+ * before every spawn of every generation (#1723).
  */
 function nativePluginEnv(
   options: ITtscCompilerContext,
@@ -812,6 +819,7 @@ function nativePluginEnv(
   tsgoBinary: string,
   nativePlugins?: readonly ITtscLoadedNativePlugin[],
   plugin?: ITtscLoadedNativePlugin,
+  identities?: PluginContentIdentities.Store,
 ): NodeJS.ProcessEnv {
   const pluginConfigDir = resolvePluginConfigDir(options);
   const env = SidecarEnvironment.merge(
@@ -827,7 +835,7 @@ function nativePluginEnv(
     options.env,
     { TTSC_TSGO_BINARY: tsgoBinary },
   );
-  const node = resolveNodeBinary(env, projectRoot);
+  const node = resolveNodeBinary(env, projectRoot, identities);
   SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
   // The anchor is per-invocation state owned by this host: when this run
   // declared none (and the caller's env does not name one), drop any value

package/src/internal/javascriptRuntimeCapabilities.ts

@@ -4,6 +4,8 @@ import path from "node:path";
 
 import { captureProcessOutput } from "../compiler/internal/captureProcessOutput";
 import { SidecarEnvironment } from "../compiler/internal/sharedHost/SidecarEnvironment";
+import type { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
+import { PluginLoadAnswers } from "../plugin/internal/source/PluginLoadAnswers";
 import { E2ETrace } from "./E2ETrace";
 import type { IJavaScriptRuntimeCapabilities } from "./IJavaScriptRuntimeCapabilities";
 import { OwnedSynchronousProcess } from "./OwnedSynchronousProcess";
@@ -20,28 +22,56 @@ import { spawnSyncWithLowDescriptors } from "./spawnSyncWithLowDescriptors";
  * Cache-ineligible candidates do not acquire executable proofs used only by
  * cache lookup and publication.
  *
- * @evidence contracts/common.md#principled-implementation A child reports its own feature availability and executable; byte-aware before/after identity and same-executable proof authorize reuse only for a stable absolute runtime without NODE_OPTIONS preload authority.
+ * With a record store, the executable identity is proven from metadata and a
+ * probe answer recorded for that identity is reused by a later process (#1723);
+ * a recorded answer must still name an executable this runtime is.
+ *
+ * @param runtime The interpreter to probe.
+ * @param env Caller environment merged over this process's.
+ * @param cwd Working directory of the probe.
+ * @param identities Optional record store of the caller's plugin cache.
+ * @evidence contracts/common.md#principled-implementation A child reports its own feature availability and executable; byte-aware before/after identity and same-executable proof authorize reuse only for a stable absolute runtime without NODE_OPTIONS preload authority, in process or through an answer recorded under that identity.
  * @evidence contracts/common.md#clear-and-simple-design One probe owner coordinates identity, spawning and parsing; the shared fingerprint helper owns file-content proof and the low-descriptor helper owns the POSIX launch distinction.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Feature availability comes from the actual interpreter rather than its name; descriptor fallback handles a supported kernel constraint and failures produce unsupported capabilities, not fabricated success.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain measured capabilities, reuse restrictions and freshness, with comments separating platform launch and cache permission from tags.
  * @evidence contracts/portability.md#os-neutral-implementation Shared environment merge and lookup apply native name identity to caller precedence and NODE_OPTIONS preload authority, including Windows aliases; Node spawn receives an executable and argv without shell syntax, and only POSIX descriptor exhaustion uses the isolated broker.
- * @evidence contracts/performance.md#efficient-algorithms Environment merge/name handling first decides cache eligibility. Eligible hits read B executable bytes; eligible misses acquire before/after content proofs around the actual probe. Ineligible calls retain the fresh child without reading executable bytes solely for the forbidden cache. Probe spawning/parsing, a possible descriptor-exhaustion retry and capture-file reads add text/environment/native lookup costs and transient output storage; this adapter sets no explicit byte quota.
- * @evidence contracts/performance.md#reuse-equivalent-work Stable absolute candidates that report their own executable share measured capability results, including false feature flags; changed executable bytes, link/target identity, preload options or wrapper identity require another probe, while failed probes without executable identity are not reused.
+ * @evidence contracts/performance.md#efficient-algorithms Environment merge/name handling first decides cache eligibility. Eligible hits prove the executable from a record (three stats and one small read) or read B executable bytes; eligible misses acquire before/after identities around the actual probe. Ineligible calls retain the fresh child without reading executable bytes solely for the forbidden cache. Probe spawning/parsing, a possible descriptor-exhaustion retry and capture-file reads add text/environment/native lookup costs and transient output storage; this adapter sets no explicit byte quota.
+ * @evidence contracts/performance.md#reuse-equivalent-work Stable absolute candidates that report their own executable share measured capability results, including false feature flags, within the process and across processes through the record store keyed by the full identity; changed executable bytes, link/target identity, preload options or wrapper identity require another probe, while failed probes without executable identity are not reused.
  * @evidence contracts/performance.md#bound-retention-and-release-resources The synchronous probe owns child completion and fallback captures; finally attempts capture close/removal, whose helper suppresses cleanup failures, so native/file release is unconfirmed on failure. Capability entries retain absolute spellings and path/identity text with no eviction quota; failed identity validation can remove an entry. Returned capability copies transfer to callers.
  */
 export function javascriptRuntimeCapabilities(
   runtime: string,
   env: NodeJS.ProcessEnv,
   cwd: string,
+  identities?: PluginContentIdentities.Store,
 ): IJavaScriptRuntimeCapabilities {
   const effectiveEnv = SidecarEnvironment.merge(process.env, env);
   const cacheKey = runtimeCapabilityCacheKey(runtime, effectiveEnv);
   const beforeIdentity =
-    cacheKey === undefined ? undefined : runtimeExecutableIdentity(runtime);
+    cacheKey === undefined
+      ? undefined
+      : runtimeExecutableIdentity(runtime, identities);
   if (cacheKey !== undefined && beforeIdentity !== undefined) {
     const cached = runtimeCapabilityCache.get(cacheKey);
     if (cached?.identity === beforeIdentity) return { ...cached.capabilities };
     runtimeCapabilityCache.delete(cacheKey);
+    // WARNING (#1723): a launch is a new process, so the memo above is empty
+    // on every CLI run. The same proven executable answers the same probe; the
+    // record store carries that answer across processes.
+    const recorded = recordedCapabilities(
+      PluginLoadAnswers.read(identities, RUNTIME_CAPABILITIES, [
+        cacheKey,
+        beforeIdentity,
+      ]),
+      runtime,
+    );
+    if (recorded !== undefined) {
+      runtimeCapabilityCache.set(cacheKey, {
+        capabilities: { ...recorded },
+        identity: beforeIdentity,
+      });
+      return recorded;
+    }
   }
   const args = [
     "-e",
@@ -113,7 +143,9 @@ export function javascriptRuntimeCapabilities(
   // This removes a process spawn from the common path without
   // authorizing a replaced or redirected runtime in a long-lived host.
   const afterIdentity =
-    cacheKey === undefined ? undefined : runtimeExecutableIdentity(runtime);
+    cacheKey === undefined
+      ? undefined
+      : runtimeExecutableIdentity(runtime, identities);
   if (
     cacheKey !== undefined &&
     capabilities.executable !== undefined &&
@@ -125,10 +157,44 @@ export function javascriptRuntimeCapabilities(
       capabilities: { ...capabilities },
       identity: afterIdentity,
     });
+    PluginLoadAnswers.write(
+      identities,
+      RUNTIME_CAPABILITIES,
+      [cacheKey, afterIdentity],
+      capabilities,
+    );
   }
   return capabilities;
 }
 
+/** Answer family of measured runtime capabilities (`PluginLoadAnswers`). */
+const RUNTIME_CAPABILITIES = "javascript-runtime-capabilities";
+
+/**
+ * A recorded probe answer in the shape the probe produces, still naming an
+ * executable this runtime is, or `undefined`.
+ */
+function recordedCapabilities(
+  value: unknown,
+  runtime: string,
+): IJavaScriptRuntimeCapabilities | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const recorded = value as Partial<IJavaScriptRuntimeCapabilities>;
+  if (
+    typeof recorded.bun !== "boolean" ||
+    typeof recorded.registerHooks !== "boolean" ||
+    typeof recorded.executable !== "string" ||
+    !path.isAbsolute(recorded.executable) ||
+    !sameRuntimeExecutable(runtime, recorded.executable)
+  )
+    return undefined;
+  return {
+    bun: recorded.bun,
+    executable: recorded.executable,
+    registerHooks: recorded.registerHooks,
+  };
+}
+
 type RuntimeCapabilityCacheEntry = {
   capabilities: IJavaScriptRuntimeCapabilities;
   identity: string;

package/src/internal/nativeBinary.ts

@@ -4,8 +4,8 @@
  * The rules that find ttsc's platform binary (an absolute `TTSC_BINARY`, the
  * per-platform package, then the repository's own dev layout) are ttsc's alone.
  * A tool host that runs one of that binary's helper commands, as
- * `@ttsc/unplugin` runs its Linux watch helper, imports them from here, so the
- * helper always comes from the binary ttsc itself uses and no consumer carries
- * a copy of the rules.
+ * `@ttsc/unplugin` runs its native watch helpers, imports them from here, so
+ * the helper always comes from the binary ttsc itself uses and no consumer
+ * carries a copy of the rules.
  */
 export { resolveBinary } from "../compiler/internal/resolveBinary";

package/src/internal/pluginSource.ts

@@ -22,5 +22,6 @@ export * from "../plugin/internal/source/pluginSourceDigest";
 export * from "../plugin/internal/source/pluginSourceState";
 export * from "../plugin/internal/source/pluginSourceStateHolds";
 export * from "../plugin/internal/source/processPluginBuildEnvironment";
+export * from "../plugin/internal/source/provenPluginSourceDigest";
 export * from "../plugin/internal/source/PluginBuildEnvironmentReadings";
 export * from "../plugin/internal/source/prunesPluginSourceDirectory";

package/src/internal/resolveNodeBinary.ts

@@ -1,4 +1,5 @@
 import { SidecarEnvironment } from "../compiler/internal/sharedHost/SidecarEnvironment";
+import type { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
 import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
 
 /**
@@ -7,6 +8,10 @@ import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
  * Bun can directly evaluate a descriptor, but it does not implement the
  * synchronous `module.registerHooks` contract used by those loaders.
  *
+ * @param env Effective environment naming `TTSC_NODE_BINARY`.
+ * @param cwd Working directory of the probes.
+ * @param identities Optional record store that lets probes of an unchanged
+ *   runtime be answered across processes (#1723).
  * @evidence contracts/common.md#principled-implementation Ordered candidates are accepted only after an actual runtime probe reports non-Bun registerHooks support and its absolute executable; names alone do not establish the loader capability.
  * @evidence contracts/common.md#clear-and-simple-design Candidate precedence and duplicate suppression remain here, while the shared probe owns launch, capability parsing and freshness policy.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The node spelling is a supported final discovery candidate, not an assumed successful runtime; incompatible candidates are skipped without patching modules or globals.
@@ -19,6 +24,7 @@ import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
 export function resolveNodeBinary(
   env: NodeJS.ProcessEnv = process.env,
   cwd: string = process.cwd(),
+  identities?: PluginContentIdentities.Store,
 ): string | undefined {
   const candidates = [
     SidecarEnvironment.read(env, "TTSC_NODE_BINARY"),
@@ -31,7 +37,12 @@ export function resolveNodeBinary(
     if (candidate === undefined || candidate.trim() === "") continue;
     if (seen.has(candidate)) continue;
     seen.add(candidate);
-    const capabilities = javascriptRuntimeCapabilities(candidate, env, cwd);
+    const capabilities = javascriptRuntimeCapabilities(
+      candidate,
+      env,
+      cwd,
+      identities,
+    );
     if (
       !capabilities.bun &&
       capabilities.registerHooks &&