ttsc 0.31.1 → 0.31.2

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/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 &&