ttsc 0.31.0 → 0.31.2

package/src/internal/runtimeExecutableIdentity.ts

@@ -3,64 +3,44 @@ import fs from "node:fs";
 import path from "node:path";
 import { threadId } from "node:worker_threads";
 
+import { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
 import { E2ETrace } from "./E2ETrace";
 
 /**
  * Fingerprint an absolute executable's spelling, target and actual bytes.
  *
  * A changed link, file, or read failure yields no reusable identity. Metadata
- * brackets the streamed read; it is not used to reuse an earlier content hash.
- * Concurrent writes that evade every filesystem observation remain outside this
- * snapshot guarantee.
+ * brackets the streamed read. Concurrent writes that evade every filesystem
+ * observation remain outside this snapshot guarantee.
  *
- * @evidence contracts/common.md#principled-implementation The identity joins lexical-link metadata, the selected physical file metadata and SHA-256 of that opened file; matching metadata alone cannot authorize reuse after bytes change. Descriptor and pathname observations must still agree after reading.
- * @evidence contracts/common.md#clear-and-simple-design This one native owner supplies the same content proof to runtime capability and plugin caches; callers decide whether their other inputs permit reuse.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported Node filesystem and crypto APIs inspect the actual candidate; no fixture identity, foreign mutation or metadata-only shortcut substitutes for content.
- * @evidence contracts/common.md#meaningful-documentation Native prose explains absolute-path scope, failure meaning, hash freshness and the remaining concurrent-mutation limitation, with separate prose and tags.
- * @evidence contracts/portability.md#os-neutral-implementation Node native realpath and bigint stat preserve link/target identity on supported hosts; absolute paths use native platform semantics, and unreadable or non-regular targets cannot be reused.
- * @evidence contracts/performance.md#efficient-algorithms A sequential read hashes B bytes with one 64 KiB buffer instead of a complete executable allocation. Native path/realpath/stat observations and serialized physical spelling/metadata add text/lookup costs; B and spelling lengths have no quota here. Returned identity storage includes the physical path as well as the fixed-length digest.
- *
- * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation establishes whether later work is equivalent; retaining a digest by metadata would reproduce the stale-byte defect it must prevent.
+ * With a record store, the bytes of an unchanged executable are proven from its
+ * metadata instead of streamed again (`PluginContentIdentities`, #1723): the
+ * recorded digest stands only while the physical file's identity, size and both
+ * stamps match the record and its modification stamp is separable from a
+ * reference the store minted. A plugin load asks for this identity several
+ * times, and every launch is a new process, so streaming an 85 MB runtime each
+ * time cost about 0.9 s per launch. Without a store, or when that proof is
+ * unavailable, the file is streamed as before.
  *
- * @evidence contracts/performance.md#bound-retention-and-release-resources One descriptor and one fixed buffer belong to this synchronous call; finally attempts closure after read/observation failures as well as success. A close failure returns no identity but cannot confirm native release. Returned path/metadata/digest text transfers to the caller and no helper history survives. Opt-in opened/closed/close-failed observations carry one trace-only call id and actual descriptor, PID/thread and already observed physical identity. The existing finally performs the single close; no observer retries it or converts an unavailable identity to success. An observed close is release of this Node descriptor, not proof that an OS image lock or another actor has released the executable.
+ * @param runtime The executable, absolute.
+ * @param identities Optional record store of the caller's plugin cache.
+ * @evidence contracts/common.md#principled-implementation The identity joins lexical-link metadata, the selected physical file metadata and the SHA-256 of that file's bytes, streamed under metadata brackets or proven by a record whose separable signature still matches; descriptor and pathname observations must still agree after a read.
+ * @evidence contracts/common.md#clear-and-simple-design This one native owner supplies the same identity to runtime capability and plugin caches; the record store owns metadata reuse and a private helper owns the bracketed stream.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Metadata alone never stands for bytes: reuse needs a record written under unchanged separable metadata around an actual read, which a same-tick rewrite or restored timestamps cannot satisfy because change time and the minted reference move.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absolute-path scope, failure meaning, the record proof and the remaining concurrent-mutation limitation, with separate prose and tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native realpath and bigint stat preserve link/target identity on supported hosts; absolute paths use native platform semantics, and unreadable or non-regular targets cannot be reused.
+ * @evidence contracts/performance.md#efficient-algorithms A proven record costs three stats and one small file read; otherwise a sequential read hashes B bytes with one 64 KiB buffer instead of a complete executable allocation. Native path/realpath/stat observations and serialized metadata add text/lookup costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Processes share an executable digest only through the record store's separable-signature proof; without a store every call streams the file.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One descriptor and one fixed buffer belong to a streamed read; finally attempts closure after read/observation failures as well as success. A close failure returns no identity but cannot confirm native release. Opt-in opened/closed/close-failed observations carry one trace-only call id and actual descriptor, PID/thread and already observed physical identity. Records belong to the single-file collector.
  */
-export function runtimeExecutableIdentity(runtime: string): string | undefined {
+export function runtimeExecutableIdentity(
+  runtime: string,
+  identities?: PluginContentIdentities.Store,
+): string | undefined {
   if (!path.isAbsolute(runtime)) return undefined;
   const startedAt = new Date().toISOString();
-  let descriptor: number | undefined;
-  let traceLease: Readonly<Record<string, string | number>> | undefined;
   let stage = "lexical-stat";
-  const unavailable = (
-    reason: string,
-    expected?: string,
-    observed?: string,
-    observations?: { before: fs.BigIntStats; after: fs.BigIntStats },
-  ) => {
-    E2ETrace.capabilityResolution("runtime-executable-identity-unavailable", {
-      runtime,
-      stage,
-      reason,
-      expected,
-      observed,
-      expectedAtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.before.atimeNs),
-      observedAtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.after.atimeNs),
-      expectedBirthtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.before.birthtimeNs),
-      observedBirthtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.after.birthtimeNs),
-    });
-    return undefined;
-  };
+  let refused: IUnavailable | undefined;
   try {
     const lexical = fs.lstatSync(runtime, { bigint: true });
     stage = "physical-realpath";
@@ -68,93 +48,30 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
     stage = "physical-stat";
     const physical = fs.statSync(physicalPath, { bigint: true });
     if (!physical.isFile())
-      return unavailable("not-regular", undefined, fileIdentity(physical));
-    stage = "open";
-    descriptor = fs.openSync(physicalPath, "r");
-    if (process.env.TTSC_E2E_TRACE) {
-      traceLease = {
-        callId: String(++identityTraceOrdinal),
-        runtime,
-        physicalPath,
-        descriptor,
-        pid: process.pid,
-        threadId,
-        dev: String(physical.dev),
-        ino: String(physical.ino),
-      };
-      E2ETrace.capabilityResolution(
-        "runtime-executable-identity-opened",
-        traceLease,
-      );
-    }
-    stage = "opened-stat";
-    const opened = fs.fstatSync(descriptor, { bigint: true });
-    if (fileIdentity(opened) !== fileIdentity(physical))
-      return unavailable(
-        "opened-file-changed",
-        fileIdentity(physical),
-        fileIdentity(opened),
-      );
-    const hash = crypto.createHash("sha256");
-    const buffer = Buffer.allocUnsafe(64 * 1024);
-    let remaining = opened.size;
-    stage = "read";
-    while (remaining > 0n) {
-      const requested =
-        remaining > BigInt(buffer.length) ? buffer.length : Number(remaining);
-      const length = fs.readSync(descriptor, buffer, 0, requested, null);
-      if (length === 0)
-        return unavailable(
-          "premature-eof",
-          String(opened.size),
-          String(opened.size - remaining),
-        );
-      hash.update(buffer.subarray(0, length));
-      remaining -= BigInt(length);
-    }
-    stage = "post-read-opened-stat";
-    const afterOpened = fs.fstatSync(descriptor, { bigint: true });
-    if (fileIdentity(afterOpened) !== fileIdentity(opened))
-      return unavailable(
-        "opened-file-changed-during-read",
-        fileIdentity(opened),
-        fileIdentity(afterOpened),
-        { before: opened, after: afterOpened },
-      );
-    stage = "post-read-realpath";
-    const afterPath = fs.realpathSync.native(runtime);
-    if (afterPath !== physicalPath)
-      return unavailable("physical-target-changed", physicalPath, afterPath);
-    stage = "post-read-lexical-stat";
-    const afterLexical = fs.lstatSync(runtime, { bigint: true });
-    if (fileIdentity(afterLexical) !== fileIdentity(lexical))
-      return unavailable(
-        "lexical-file-changed-during-read",
-        fileIdentity(lexical),
-        fileIdentity(afterLexical),
-      );
-    stage = "post-read-physical-stat";
-    const afterPhysical = fs.statSync(physicalPath, { bigint: true });
-    if (fileIdentity(afterPhysical) !== fileIdentity(physical))
-      return unavailable(
-        "physical-file-changed-during-read",
-        fileIdentity(physical),
-        fileIdentity(afterPhysical),
-      );
-    const digest = hash.digest("hex");
-    E2ETrace.capabilityResolution("runtime-executable-identity-observed", {
-      runtime,
-      physicalPath,
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      lexical: fileIdentity(lexical),
-      physical: fileIdentity(physical),
-      digest,
-      openedAtimeNs: String(opened.atimeNs),
-      afterOpenedAtimeNs: String(afterOpened.atimeNs),
-      openedBirthtimeNs: String(opened.birthtimeNs),
-      afterOpenedBirthtimeNs: String(afterOpened.birthtimeNs),
-    });
+      return unavailable(runtime, {
+        stage,
+        reason: "not-regular",
+        observed: fileIdentity(physical),
+      });
+    const read = (): string => {
+      const streamed = streamDigest(runtime, physicalPath, physical, lexical, {
+        startedAt,
+      });
+      if (typeof streamed === "string") return streamed;
+      refused = streamed;
+      throw new Error(streamed.reason);
+    };
+    const digest =
+      identities === undefined
+        ? read()
+        : PluginContentIdentities.digest(
+            identities,
+            "executable",
+            physicalPath,
+            (references) =>
+              PluginContentIdentities.fileObservation(references, physicalPath),
+            read,
+          );
     return [
       physicalPath,
       fileIdentity(lexical),
@@ -163,10 +80,71 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
     ].join("\0");
   } catch (error) {
     return unavailable(
-      "filesystem-error",
-      undefined,
-      error instanceof Error ? error.message : String(error),
+      runtime,
+      refused ?? {
+        stage,
+        reason: "filesystem-error",
+        observed: error instanceof Error ? error.message : String(error),
+      },
     );
+  }
+}
+
+/** Why an identity could not be formed, at the stage that found it. */
+interface IUnavailable {
+  stage: string;
+  reason: string;
+  expected?: string;
+  observed?: string;
+  observations?: { before: fs.BigIntStats; after: fs.BigIntStats };
+}
+
+function unavailable(runtime: string, failure: IUnavailable): undefined {
+  E2ETrace.capabilityResolution("runtime-executable-identity-unavailable", {
+    runtime,
+    stage: failure.stage,
+    reason: failure.reason,
+    expected: failure.expected,
+    observed: failure.observed,
+    expectedAtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.before.atimeNs),
+    observedAtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.after.atimeNs),
+    expectedBirthtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.before.birthtimeNs),
+    observedBirthtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.after.birthtimeNs),
+  });
+  return undefined;
+}
+
+/**
+ * Stream the physical file's bytes between metadata observations of the open
+ * descriptor, the physical path and the lexical spelling, returning the digest
+ * or what moved. The descriptor is closed in finally; a failed close refuses
+ * the identity.
+ */
+function streamDigest(
+  runtime: string,
+  physicalPath: string,
+  physical: fs.BigIntStats,
+  lexical: fs.BigIntStats,
+  timing: { startedAt: string },
+): string | IUnavailable {
+  let stage = "open";
+  let descriptor: number | undefined;
+  let traceLease: Readonly<Record<string, string | number>> | undefined;
+  let result: string | IUnavailable;
+  try {
+    result = observe();
   } finally {
     if (descriptor !== undefined) {
       try {
@@ -185,13 +163,121 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
               error: error instanceof Error ? error.message : String(error),
             },
           );
-        stage = "close";
-        return unavailable(
-          "descriptor-close-error",
-          undefined,
-          error instanceof Error ? error.message : String(error),
+        // A digest whose descriptor could not be closed is refused, as before.
+        result = {
+          stage: "close",
+          reason: "descriptor-close-error",
+          observed: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }
+  }
+  return result;
+
+  function observe(): string | IUnavailable {
+    try {
+      descriptor = fs.openSync(physicalPath, "r");
+      if (process.env.TTSC_E2E_TRACE) {
+        traceLease = {
+          callId: String(++identityTraceOrdinal),
+          runtime,
+          physicalPath,
+          descriptor,
+          pid: process.pid,
+          threadId,
+          dev: String(physical.dev),
+          ino: String(physical.ino),
+        };
+        E2ETrace.capabilityResolution(
+          "runtime-executable-identity-opened",
+          traceLease,
         );
       }
+      stage = "opened-stat";
+      const opened = fs.fstatSync(descriptor, { bigint: true });
+      if (fileIdentity(opened) !== fileIdentity(physical))
+        return {
+          stage,
+          reason: "opened-file-changed",
+          expected: fileIdentity(physical),
+          observed: fileIdentity(opened),
+        };
+      const hash = crypto.createHash("sha256");
+      const buffer = Buffer.allocUnsafe(64 * 1024);
+      let remaining = opened.size;
+      stage = "read";
+      while (remaining > 0n) {
+        const requested =
+          remaining > BigInt(buffer.length) ? buffer.length : Number(remaining);
+        const length = fs.readSync(descriptor, buffer, 0, requested, null);
+        if (length === 0)
+          return {
+            stage,
+            reason: "premature-eof",
+            expected: String(opened.size),
+            observed: String(opened.size - remaining),
+          };
+        hash.update(buffer.subarray(0, length));
+        remaining -= BigInt(length);
+      }
+      stage = "post-read-opened-stat";
+      const afterOpened = fs.fstatSync(descriptor, { bigint: true });
+      if (fileIdentity(afterOpened) !== fileIdentity(opened))
+        return {
+          stage,
+          reason: "opened-file-changed-during-read",
+          expected: fileIdentity(opened),
+          observed: fileIdentity(afterOpened),
+          observations: { before: opened, after: afterOpened },
+        };
+      stage = "post-read-realpath";
+      const afterPath = fs.realpathSync.native(runtime);
+      if (afterPath !== physicalPath)
+        return {
+          stage,
+          reason: "physical-target-changed",
+          expected: physicalPath,
+          observed: afterPath,
+        };
+      stage = "post-read-lexical-stat";
+      const afterLexical = fs.lstatSync(runtime, { bigint: true });
+      if (fileIdentity(afterLexical) !== fileIdentity(lexical))
+        return {
+          stage,
+          reason: "lexical-file-changed-during-read",
+          expected: fileIdentity(lexical),
+          observed: fileIdentity(afterLexical),
+        };
+      stage = "post-read-physical-stat";
+      const afterPhysical = fs.statSync(physicalPath, { bigint: true });
+      if (fileIdentity(afterPhysical) !== fileIdentity(physical))
+        return {
+          stage,
+          reason: "physical-file-changed-during-read",
+          expected: fileIdentity(physical),
+          observed: fileIdentity(afterPhysical),
+        };
+      const digest = hash.digest("hex");
+      E2ETrace.capabilityResolution("runtime-executable-identity-observed", {
+        runtime,
+        physicalPath,
+        startedAt: timing.startedAt,
+        finishedAt: new Date().toISOString(),
+        lexical: fileIdentity(lexical),
+        physical: fileIdentity(physical),
+        digest,
+        openedAtimeNs: String(opened.atimeNs),
+        afterOpenedAtimeNs: String(afterOpened.atimeNs),
+        openedBirthtimeNs: String(opened.birthtimeNs),
+        afterOpenedBirthtimeNs: String(afterOpened.birthtimeNs),
+      });
+      return digest;
+    } catch (error) {
+      return {
+        stage,
+        reason: "filesystem-error",
+        observed: error instanceof Error ? error.message : String(error),
+      };
     }
   }
 }

package/src/launcher/internal/runtime/installRuntimeHooks.ts

@@ -15,11 +15,13 @@ import { runBuild } from "../../../compiler/internal/build/runBuild";
 import { readProjectConfig } from "../../../compiler/internal/project/readProjectConfig";
 import { resolveOwningProjectConfig } from "../../../compiler/internal/project/resolveOwningProjectConfig";
 import { resolveTsgo } from "../../../compiler/internal/resolveTsgo";
+import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { spawnNative } from "../../../compiler/internal/spawnNative";
 import { E2ETrace } from "../../../internal/E2ETrace";
 import { createCanonicalTempDirectory } from "../../../internal/createCanonicalTempDirectory";
 import { runtimeExecutableIdentity } from "../../../internal/runtimeExecutableIdentity";
 import { moduleResolutionBaseSelects } from "../../../plugin/internal/load/moduleResolutionBaseSelects";
+import { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import { recordCacheFileUse } from "../../../plugin/internal/source/recordCacheFileUse";
 import { buildSingleRootProject } from "../buildSingleRootProject";
 import { inlineServedSourceMap } from "../inlineServedSourceMap";
@@ -684,6 +686,17 @@ function observePluginDescriptorInputOnce(record: {
       (record.hash !== undefined && record.hash !== observedHash) ||
       (record.realpath !== undefined && record.realpath !== observedRealpath) ||
       (record.signature !== undefined && record.signature !== afterSignature);
+    // A missing path's signature is its nearest existing ancestor's metadata,
+    // so a write anywhere in that ancestor refuses the proof; the trace names
+    // which observation moved.
+    if (unstable)
+      E2ETrace.capabilityResolution("plugin-descriptor-input-unstable", {
+        resolved: record.resolved,
+        recordedSignature: record.signature,
+        beforeSignature,
+        afterSignature,
+        hashChanged: record.hash !== undefined && record.hash !== observedHash,
+      });
     return `${JSON.stringify({
       ...record,
       hash: observedHash,
@@ -1479,12 +1492,63 @@ function orphanCacheRoot(): string {
  * Read afresh at every use, never remembered by path: a long-lived process can
  * lower orphans before and after the compiler at that path is replaced, and an
  * entry lowered by the new one must not be recorded under the old one's key for
- * a later process to adopt.
+ * a later process to adopt. A fresh use proves an unchanged compiler from the
+ * run's plugin cache records (`runtimeRecordStore`), which observe its metadata
+ * again each time.
  */
 function compilerIdentity(binary: string): string {
-  return runtimeExecutableIdentity(binary) ?? crypto.randomUUID();
+  return (
+    runtimeExecutableIdentity(binary, runtimeRecordStore()) ??
+    crypto.randomUUID()
+  );
 }
 
+/**
+ * The record store of this run's plugin cache root, or `undefined` without one.
+ *
+ * WARNING (#1726): every ttsx process and every descriptor evaluation streamed
+ * the whole compiler executable (24.5 MB) to key its orphan and dependency
+ * builds, although the bytes had not changed since the last process. The root
+ * is the one a descriptor evaluator's parent load selected
+ * (`TTSC_PLUGIN_RECORD_ROOT`), or the cache root of this run's manifest; a
+ * process with neither streams as before and never selects a root itself.
+ */
+function runtimeRecordStore(): PluginContentIdentities.Store | undefined {
+  const descriptorRoot =
+    process.env.TTSC_PLUGIN_DESCRIPTOR_LOAD === "1"
+      ? SidecarEnvironment.read(process.env, "TTSC_PLUGIN_RECORD_ROOT")
+      : undefined;
+  const owner = RuntimeManifestRegistry.runtimeManifests().find(
+    (candidate) =>
+      typeof candidate.orphanCacheDir === "string" &&
+      candidate.orphanCacheDir.length !== 0,
+  );
+  const root =
+    descriptorRoot !== undefined && path.isAbsolute(descriptorRoot)
+      ? descriptorRoot
+      : owner === undefined
+        ? undefined
+        : path.dirname(owner.orphanCacheDir!);
+  if (root === undefined) return undefined;
+  // One store per root serves the process: its references only grow older,
+  // which can make fewer stamps separable but never more, and each identity
+  // still observes the compiler's metadata afresh.
+  if (runtimeStore?.root !== root)
+    runtimeStore = {
+      root,
+      store: PluginContentIdentities.open({
+        projectRoot: root,
+        cacheDir: root,
+        env: process.env,
+      }),
+    };
+  return runtimeStore.store;
+}
+
+let runtimeStore:
+  | { root: string; store: PluginContentIdentities.Store | undefined }
+  | undefined;
+
 /** The version of this ttsc package, which owns the orphan post-processing. */
 function ownPackageVersion(): string {
   if (ownPackageVersionCache === undefined) {
@@ -2020,6 +2084,7 @@ function dependencyCachePaths(
   try {
     compilerProof = runtimeExecutableIdentity(
       resolveTsgo({ cwd: path.dirname(tsconfig) }).binary,
+      runtimeRecordStore(),
     );
   } catch {
     // An unobservable executable gets a unique, non-reusable generation key.
@@ -2045,7 +2110,7 @@ function dependencyCachePaths(
 function assertCompilerStillCurrent(tsconfig: string, proof?: string): void {
   if (proof === undefined) return;
   const binary = resolveTsgo({ cwd: path.dirname(tsconfig) }).binary;
-  const current = runtimeExecutableIdentity(binary);
+  const current = runtimeExecutableIdentity(binary, runtimeRecordStore());
   if (current !== proof) {
     E2ETrace.capabilityResolution("runtime-compiler-publication-refused", {
       tsconfig,

package/src/launcher/internal/ttscserver/captureLSPPluginSelectionInputs.ts

@@ -34,7 +34,8 @@ import { LSPProjectInputDigest } from "./LSPProjectInputDigest";
  * detected drift; unavailable markers or changes between reads are not a proof
  * that the complete filesystem stayed fixed throughout capture.
  *
- * @param loaded The plugin load of the session.
+ * @param loaded The plugin load of the session, with the project whose plugin
+ *   cache proves its plugin sources from records.
  * @returns The inputs, or `undefined` when the load no longer describes the
  *   filesystem and the selection has to be loaded again.
  * @evidence contracts/common.md#principled-implementation The manifest groups candidate/source-file digests by directory. Recorded content and physical-target proofs and all plugin-source states are compared again before return; a detected mismatch rejects capture, while sequential reads and unproven paths do not certify every post-load change.
@@ -53,6 +54,7 @@ export function captureLSPPluginSelectionInputs(loaded: {
   hostInputRealpaths: Readonly<Record<string, string | null>>;
   hostInputs: readonly string[];
   pluginSources: Readonly<Record<string, string>>;
+  project?: { root: string };
 }): ILSPPluginSelectionInputs | undefined {
   const excluded = new Set(
     loaded.deferredHostInputs.map((file) => path.resolve(file)),
@@ -85,8 +87,15 @@ export function captureLSPPluginSelectionInputs(loaded: {
     )
   )
     return undefined;
+  // The load's project names the plugin cache whose records prove the sources
+  // and the SDK, so a session start does not read them again (#1725).
   for (const [directory, state] of Object.entries(loaded.pluginSources))
-    if (!pluginSourceStateHolds(directory, state)) return undefined;
+    if (
+      !pluginSourceStateHolds(directory, state, {
+        projectRoot: loaded.project?.root,
+      })
+    )
+      return undefined;
   return {
     omittedNames: GoSourceInputs.OMITTED_SOURCE_FILE_NAMES,
     omittedSuffixes: GoSourceInputs.OMITTED_SOURCE_FILE_SUFFIXES,

package/src/launcher/internal/ttscserver/runTtscserver.ts

@@ -13,6 +13,7 @@ import { spawnNative } from "../../../compiler/internal/spawnNative";
 import { E2ETrace } from "../../../internal/E2ETrace";
 import { resolveNodeBinary } from "../../../internal/resolveNodeBinary";
 import { loadProjectPlugins } from "../../../plugin/internal/load/loadProjectPlugins";
+import type { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectIdentity } from "../../../structures/internal/ITtscProjectIdentity";
@@ -165,6 +166,13 @@ type LSPExecutionContext = {
    */
   selectionInputs?: ILSPPluginSelectionInputs;
 
+  /**
+   * Record store the confirming plugin load opened, which proves the Node
+   * runtime from metadata instead of streaming it again (#1726); absent for a
+   * project without plugins, which gains no cache directory.
+   */
+  identities?: PluginContentIdentities.Store;
+
   tsgoBinary: string;
 };
 
@@ -196,6 +204,7 @@ function resolveTtscserverEnv(launch: LSPLaunchOptions): TtscserverEnvironment {
   const context = resolveLspExecutionContext(launch);
   const env = lspSidecarEnvironment({
     cwd: context.projectContext?.logicalProjectRoot ?? path.resolve(launch.cwd),
+    identities: context.identities,
     pluginConfigOrigin: context.projectContext?.pluginConfigOrigin,
     tsgoBinary: context.tsgoBinary,
   });
@@ -244,6 +253,7 @@ function resolveTtscserverEnv(launch: LSPLaunchOptions): TtscserverEnvironment {
 
 function lspSidecarEnvironment(options: {
   cwd: string;
+  identities: PluginContentIdentities.Store | undefined;
   pluginConfigOrigin: string | undefined;
   tsgoBinary: string;
 }): NodeJS.ProcessEnv {
@@ -253,7 +263,7 @@ function lspSidecarEnvironment(options: {
       SidecarEnvironment.read(process.env, "TTSC_TTSX_BINARY") ??
       path.join(__dirname, "..", "..", "..", "launcher", "ttsx.js"),
   });
-  const node = resolveNodeBinary(env, options.cwd);
+  const node = resolveNodeBinary(env, options.cwd, options.identities);
   SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
   SidecarEnvironment.write(
     env,
@@ -305,6 +315,7 @@ function resolveLspExecutionContext(
       resolveFrom: __filename,
     });
     const initialProjectInputs = captureInitialLSPProjectInputs({
+      identities: loaded.identities,
       nativePlugins: loaded.nativePlugins,
       pluginConfigOrigin,
       project: selectedProject,
@@ -323,6 +334,7 @@ function resolveLspExecutionContext(
       resolveFrom: __filename,
     });
     const confirmedProjectInputs = captureInitialLSPProjectInputs({
+      identities: confirmation.identities,
       nativePlugins: confirmation.nativePlugins,
       pluginConfigOrigin,
       project: confirmedProject,
@@ -345,6 +357,9 @@ function resolveLspExecutionContext(
         initialProjectInputs: confirmedProjectInputs,
         nativePlugins: confirmation.nativePlugins,
         selectionInputs,
+        ...(confirmation.identities === undefined
+          ? {}
+          : { identities: confirmation.identities }),
         projectContext: {
           ...confirmedProject.identity,
           ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
@@ -377,6 +392,7 @@ function loadLSPProjectPlugins(
 }
 
 function captureInitialLSPProjectInputs(options: {
+  identities: PluginContentIdentities.Store | undefined;
   nativePlugins: readonly ITtscLoadedNativePlugin[];
   pluginConfigOrigin: string | undefined;
   project: ITtscParsedProjectConfig;
@@ -414,6 +430,7 @@ function captureInitialLSPProjectInputs(options: {
     }
     const env = lspSidecarEnvironment({
       cwd: options.project.root,
+      identities: options.identities,
       pluginConfigOrigin: options.pluginConfigOrigin,
       tsgoBinary: options.tsgoBinary,
     });