ttsc 0.31.1 → 0.31.2

package/src/plugin/internal/source/hashPluginBuildEnvironment.ts

@@ -6,6 +6,7 @@ import { GoEnvironmentReading } from "./GoEnvironmentReading";
 import { GoSourceInputs } from "./GoSourceInputs";
 import { GoToolResolution } from "./GoToolResolution";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import { PluginContentIdentities } from "./PluginContentIdentities";
 import type { SourceBuildFilesystemOperations } from "./SourceBuildFilesystemOperations";
 import { spawnGoTool } from "./spawnGoTool";
 
@@ -42,14 +43,17 @@ import { spawnGoTool } from "./spawnGoTool";
  *   variable carries: the Go tool, the Go environment file `go env -w` writes,
  *   the executables the C toolchain commands name, and GOROOT. A consumer that
  *   keeps the reading compares their metadata before reusing it.
+ * @param identities Record store that lets a new process prove the GOROOT
+ *   corpus and executable bytes from their metadata (`PluginContentIdentities`,
+ *   #1722); without it every process reads them.
  * @evidence contracts/common.md#principled-implementation Fixed artifact flags, observed compiler bytes/version, selected reported-or-fallback build values, named command executables and selected SDK files enter the same framed identity used by source-state reporting. Fallback values and metadata-qualified reuse are explicit premises, not complete observation of arbitrary toolchain inputs.
  * @evidence contracts/common.md#clear-and-simple-design Private helpers separate compiler identity, Go-reported settings, external variables and SDK content while sharing one hash sink and optional pre-read witness.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Cache signatures include real identity/change metadata and effective invocation context; failed SDK witnessing refuses reuse rather than accepting a VERSION-only proxy.
  * @evidence contracts/common.md#meaningful-documentation Native documentation names the input classes and witness purpose; private comments explain context-sensitive compiler memoization and SDK exclusions without treating a passing check as proof.
  * @evidence contracts/portability.md#os-neutral-implementation Node path/stat/process APIs resolve native tool identities; platform-specific executable suffixes and environment lookup are isolated in GoToolResolution, and Go supplies its own effective build settings.
  * @evidence contracts/performance.md#efficient-algorithms SDK traversal sorts reached entry names and selected file paths, performs native stat/realpath/link queries and serializes topology/metadata/path text. Matching manifests share aggregate hashes; changes read full selected files via the caller adapter, retaining file buffers with population/topology data. Compiler misses capture at most three complete version/byte readings when native metadata moves during a reading; only a stable attempt enters the memo. Go env can run up to three times for its file witness, and command tokens can each perform executable searches/full reads. Environment sorting/framing and command substring parsing also process name/value/command bytes; E/D/F/B alone do not capture native lookup or text comparison costs.
- * @evidence contracts/performance.md#reuse-equivalent-work Compiler memo identity includes selected path/file metadata and invocation cwd/environment; SDK aggregate reuse requires matching complete ordered metadata/topology. Both rely on native metadata distinguishability and sequential observation premises, not independently rehashed content on each hit. Physical directories expand once per selection policy while aliases retain edges; optional caller witnesses receive reached selected dependencies.
- * @evidence contracts/performance.md#bound-retention-and-release-resources Compiler, Go-environment-path and SDK maps retain historical distinct tool/context/root keys without eviction. SDK population/topology and full individual file reads contribute transient bytes; synchronous probes delegate process/capture lifetime to their owner and do not certify arbitrary descendants are gone. No independent entry/record/file/output byte ceiling is imposed here.
+ * @evidence contracts/performance.md#reuse-equivalent-work Compiler memo identity includes selected path/file metadata and invocation cwd/environment; SDK aggregate reuse requires matching complete ordered metadata/topology. With a record store, a new process reuses the SDK aggregate and executable digests only while their signatures match the recorded ones and every stamp is separable from a freshly minted reference (#1722); `go version` and `go env` stay live because they report toolchain selection no file metadata shows. All of this relies on native metadata distinguishability and sequential observation premises. Physical directories expand once per selection policy while aliases retain edges; optional caller witnesses receive reached selected dependencies.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Compiler, Go-environment-path and SDK maps retain historical distinct tool/context/root keys without eviction; persisted records belong to the single-file collector. SDK population/topology and full individual file reads contribute transient bytes; synchronous probes delegate process/capture lifetime to their owner and do not certify arbitrary descendants are gone. No independent entry/record/file/output byte ceiling is imposed here.
  */
 export function hashPluginBuildEnvironment(
   hash: { update(data: string): unknown },
@@ -58,6 +62,7 @@ export function hashPluginBuildEnvironment(
   env: NodeJS.ProcessEnv,
   filesystem: SourceBuildFilesystemOperations,
   witness?: PluginBuildEnvironmentWitness.Record,
+  identities?: PluginContentIdentities.Store,
 ): void {
   // Fixed artifact policy must invalidate binaries and reported source states
   // together, including binaries cached before this policy was introduced.
@@ -68,11 +73,25 @@ export function hashPluginBuildEnvironment(
     hash.update(
       JSON.stringify([
         "go",
-        resolveGoCompilerIdentity(goBinary, env, directory, witness),
+        resolveGoCompilerIdentity(
+          goBinary,
+          env,
+          directory,
+          witness,
+          identities,
+        ),
       ]),
     );
   }
-  hashGoBuildEnvironment(hash, goBinary, directory, env, filesystem, witness);
+  hashGoBuildEnvironment(
+    hash,
+    goBinary,
+    directory,
+    env,
+    filesystem,
+    witness,
+    identities,
+  );
   hashExternalGoBuildEnvironment(hash, env);
 }
 
@@ -173,6 +192,7 @@ function resolveGoCompilerIdentity(
   env: NodeJS.ProcessEnv = process.env,
   cwd: string = process.cwd(),
   witness?: PluginBuildEnvironmentWitness.Record,
+  identities?: PluginContentIdentities.Store,
 ): string {
   const selected = GoToolResolution.resolveGoToolForBuild(
     goBinary,
@@ -217,7 +237,13 @@ function resolveGoCompilerIdentity(
       compilerEnv,
       cwd,
     );
-    identity = computeGoCompilerIdentity(selected, resolved, compilerEnv, cwd);
+    identity = computeGoCompilerIdentity(
+      selected,
+      resolved,
+      compilerEnv,
+      cwd,
+      identities,
+    );
     if (!PluginBuildEnvironmentWitness.holds(observed)) continue;
     for (const [file, signature] of observed)
       if (witness !== undefined && !witness.has(file))
@@ -269,10 +295,13 @@ function computeGoCompilerIdentity(
   resolved: string,
   env: NodeJS.ProcessEnv,
   cwd: string,
+  identities: PluginContentIdentities.Store | undefined,
 ): string {
   if (!fs.existsSync(resolved)) {
     return "missing";
   }
+  // `go version` stays a live probe: it answers which toolchain the effective
+  // environment selects (GOTOOLCHAIN, go.mod), which no file metadata shows.
   const version = spawnGoTool(goBinary, ["version"], {
     cwd,
     encoding: "utf8",
@@ -283,10 +312,27 @@ function computeGoCompilerIdentity(
     version.error !== undefined
       ? ((version.error as NodeJS.ErrnoException).code ?? version.error.message)
       : `${version.status ?? 0}:${version.stdout}${version.stderr}`;
-  const binaryHash = hashFile(resolved);
+  const binaryHash = hashExecutable(resolved, identities);
   return `sha256:${binaryHash}:${versionText}`;
 }
 
+/**
+ * The content digest of an executable, proven from its metadata in a process
+ * that has the record store (#1722) and read in full otherwise.
+ */
+function hashExecutable(
+  file: string,
+  identities: PluginContentIdentities.Store | undefined,
+): string {
+  return PluginContentIdentities.digest(
+    identities,
+    "executable",
+    file,
+    (references) => PluginContentIdentities.fileObservation(references, file),
+    () => hashFile(file),
+  );
+}
+
 function resolveExecutableIdentityPath(
   binary: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -352,7 +398,8 @@ function hashGoBuildEnvironment(
   cwd: string,
   env: NodeJS.ProcessEnv,
   filesystem: SourceBuildFilesystemOperations,
-  witness?: PluginBuildEnvironmentWitness.Record,
+  witness: PluginBuildEnvironmentWitness.Record | undefined,
+  identities: PluginContentIdentities.Store | undefined,
 ): void {
   const values = resolveGoBuildEnvironment(
     goBinary,
@@ -360,6 +407,7 @@ function hashGoBuildEnvironment(
     env,
     filesystem,
     witness,
+    identities,
   );
   for (const key of GO_BUILD_ENV_KEYS) {
     const value = values.get(key);
@@ -374,7 +422,8 @@ function resolveGoBuildEnvironment(
   cwd: string,
   env: NodeJS.ProcessEnv,
   filesystem: SourceBuildFilesystemOperations,
-  witness?: PluginBuildEnvironmentWitness.Record,
+  witness: PluginBuildEnvironmentWitness.Record | undefined,
+  identities: PluginContentIdentities.Store | undefined,
 ): Map<string, string> {
   const values = new Map<string, string>();
   if (goBinary !== undefined) {
@@ -384,6 +433,7 @@ function resolveGoBuildEnvironment(
       env,
       GO_BUILD_ENV_KEYS,
       witness,
+      identities,
     );
     if (parsed !== undefined) {
       try {
@@ -392,7 +442,14 @@ function resolveGoBuildEnvironment(
           if (typeof raw === "string" && raw !== "") {
             values.set(
               key,
-              normalizeGoBuildEnvValue(key, raw, env, filesystem, witness),
+              normalizeGoBuildEnvValue(
+                key,
+                raw,
+                env,
+                filesystem,
+                witness,
+                identities,
+              ),
             );
           }
         }
@@ -408,7 +465,14 @@ function resolveGoBuildEnvironment(
     if (value !== undefined && value !== "") {
       values.set(
         key,
-        normalizeGoBuildEnvValue(key, value, env, filesystem, witness),
+        normalizeGoBuildEnvValue(
+          key,
+          value,
+          env,
+          filesystem,
+          witness,
+          identities,
+        ),
       );
     }
   }
@@ -420,7 +484,8 @@ function normalizeGoBuildEnvValue(
   value: string,
   env: NodeJS.ProcessEnv,
   filesystem: SourceBuildFilesystemOperations,
-  witness?: PluginBuildEnvironmentWitness.Record,
+  witness: PluginBuildEnvironmentWitness.Record | undefined,
+  identities: PluginContentIdentities.Store | undefined,
 ): string {
   if (key === "GOROOT") {
     // Root/version observations also cover a missing SDK. The complete SDK
@@ -428,10 +493,15 @@ function normalizeGoBuildEnvValue(
     // nested content changes that do not move the root or VERSION metadata.
     PluginBuildEnvironmentWitness.add(witness, value);
     PluginBuildEnvironmentWitness.add(witness, path.join(value, "VERSION"));
-    return resolveGoRootCacheIdentity(value, filesystem, witness);
+    return resolveGoRootCacheIdentity(value, filesystem, witness, identities);
   }
   if (GO_BUILD_COMMAND_ENV_KEYS.has(key)) {
-    return `${value}\0${resolveCommandCacheIdentity(value, env, witness)}`;
+    return `${value}\0${resolveCommandCacheIdentity(
+      value,
+      env,
+      witness,
+      identities,
+    )}`;
   }
   return value;
 }
@@ -451,7 +521,8 @@ function normalizeGoBuildEnvValue(
 function resolveCommandCacheIdentity(
   command: string,
   env: NodeJS.ProcessEnv,
-  witness?: PluginBuildEnvironmentWitness.Record,
+  witness: PluginBuildEnvironmentWitness.Record | undefined,
+  identities: PluginContentIdentities.Store | undefined,
 ): string {
   const tokens = splitGoCommand(command);
   if (tokens === null) {
@@ -473,7 +544,7 @@ function resolveCommandCacheIdentity(
   }
   let identity: string;
   try {
-    identity = `command:sha256:${hashFile(resolved)}`;
+    identity = `command:sha256:${hashExecutable(resolved, identities)}`;
   } catch {
     return `command:unreadable:${resolved}`;
   }
@@ -487,7 +558,7 @@ function resolveCommandCacheIdentity(
     if (!GoToolResolution.isExecutableFile(operand)) return;
     PluginBuildEnvironmentWitness.add(witness, operand);
     try {
-      identity += `;${index + 1}:sha256:${hashFile(operand)}`;
+      identity += `;${index + 1}:sha256:${hashExecutable(operand, identities)}`;
     } catch {
       identity += `;${index + 1}:unreadable:${operand}`;
     }
@@ -544,6 +615,9 @@ interface GoRootIdentitySnapshot {
   files: string[];
   topology: string[];
   signature: string;
+
+  /** Whether every file stamp precedes its device's minted reference. */
+  separable: boolean;
 }
 
 interface GoRootIdentityCacheEntry {
@@ -554,19 +628,31 @@ interface GoRootIdentityCacheEntry {
 // GOROOT is usually stable but its selected source/tool payloads contribute to
 // every plugin key. Retain only the final aggregate
 // identity, guarded by a fresh metadata/topology manifest on every call. A
-// changed or incomplete manifest falls through to a full content read.
+// changed or incomplete manifest falls through to the record store, then to a
+// full content read.
+//
+// WARNING (#1186, #1722): this map lives only as long as the process. #1186
+// stopped at it, so every CLI launch, worker and bundler restart still read the
+// whole SDK (3,723 files, 135 MB for the bundled toolchain). The record store
+// below is what carries the identity across processes; never drop it in favor
+// of this memo alone.
 const goRootIdentityCache = new Map<string, GoRootIdentityCacheEntry>();
 
 function resolveGoRootCacheIdentity(
   goRoot: string,
   filesystem: SourceBuildFilesystemOperations,
-  witness?: PluginBuildEnvironmentWitness.Record,
+  witness: PluginBuildEnvironmentWitness.Record | undefined,
+  identities: PluginContentIdentities.Store | undefined,
 ): string {
   const resolved = resolveRealPath(goRoot);
   if (!fs.existsSync(resolved)) {
     return `missing:${goRoot}`;
   }
-  const snapshot = collectGoRootIdentitySnapshot(resolved, witness);
+  const snapshot = collectGoRootIdentitySnapshot(
+    resolved,
+    witness,
+    identities?.references,
+  );
   if (!snapshot.complete)
     PluginBuildEnvironmentWitness.refuse(witness, resolved);
   if (snapshot.complete) {
@@ -575,15 +661,37 @@ function resolveGoRootCacheIdentity(
       return cached.identity;
     }
   }
-  const hash = crypto.createHash("sha256");
-  hash.update(JSON.stringify(snapshot.topology));
-  for (const file of snapshot.files) {
-    const relative = path.relative(resolved, file).split(path.sep).join("/");
-    const contents = filesystem.readFile(file);
-    hash.update(JSON.stringify([relative, contents.length]));
-    hash.update(contents);
-  }
-  const identity = `sha256:${hash.digest("hex")}`;
+  // The first observation is the snapshot the witness just recorded; a second
+  // one, after the content read, brackets that read for publication.
+  let observed = 0;
+  const identity = PluginContentIdentities.digest(
+    snapshot.complete ? identities : undefined,
+    "goroot",
+    resolved,
+    (references) => {
+      const current =
+        observed++ === 0
+          ? snapshot
+          : collectGoRootIdentitySnapshot(resolved, undefined, references);
+      return current.complete
+        ? { separable: current.separable, signature: current.signature }
+        : undefined;
+    },
+    () => {
+      const hash = crypto.createHash("sha256");
+      hash.update(JSON.stringify(snapshot.topology));
+      for (const file of snapshot.files) {
+        const relative = path
+          .relative(resolved, file)
+          .split(path.sep)
+          .join("/");
+        const contents = filesystem.readFile(file);
+        hash.update(JSON.stringify([relative, contents.length]));
+        hash.update(contents);
+      }
+      return `sha256:${hash.digest("hex")}`;
+    },
+  );
   if (snapshot.complete) {
     goRootIdentityCache.set(resolved, {
       identity,
@@ -596,9 +704,10 @@ function resolveGoRootCacheIdentity(
 function collectGoRootIdentitySnapshot(
   root: string,
   witness?: PluginBuildEnvironmentWitness.Record,
+  references?: ReadonlyMap<bigint, bigint>,
 ): GoRootIdentitySnapshot {
   const out: string[] = [];
-  const state = { complete: true };
+  const state = { complete: true, separable: references !== undefined };
   const topology: string[] = [];
   walkGoRootIdentity(root, out, topology, state, witness);
   out.sort();
@@ -613,6 +722,11 @@ function collectGoRootIdentitySnapshot(
         state.complete = false;
         continue;
       }
+      if (
+        references === undefined ||
+        !PluginContentIdentities.separable(references, stats)
+      )
+        state.separable = false;
       signature.update(
         [
           relative,
@@ -634,6 +748,7 @@ function collectGoRootIdentitySnapshot(
     files: out,
     topology,
     signature: signature.digest("hex"),
+    separable: state.separable,
   };
 }
 

package/src/plugin/internal/source/pluginBuildEnvironment.ts

@@ -3,6 +3,7 @@ import fs from "node:fs";
 
 import { GoToolResolution } from "./GoToolResolution";
 import type { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import type { PluginContentIdentities } from "./PluginContentIdentities";
 import { hashPluginBuildEnvironment } from "./hashPluginBuildEnvironment";
 import { resolveGoCompiler } from "./resolveGoCompiler";
 
@@ -19,12 +20,16 @@ import { resolveGoCompiler } from "./resolveGoCompiler";
  * GOROOT metadata. Witnessing a newly selected environment file can repeat the
  * probe to observe it before reading. Compiler identity reuses a
  * metadata-and-context memo; a changed SDK manifest rehashes all contributing
- * content rather than only edited files.
+ * content rather than only edited files. A supplied record store lets a new
+ * process take the SDK and executable digests from records instead of their
+ * bytes, while `go env` and `go version` still run.
  *
  * @param directory The directory a build runs `go` in.
  * @param env The effective environment, `process.env` by default.
  * @param witness Receives the paths the reading depends on and no variable
  *   carries (`hashPluginBuildEnvironment`).
+ * @param identities Record store that lets a new process prove the SDK and
+ *   executables from metadata (#1722).
  * @evidence contracts/common.md#principled-implementation The digest uses the same resolved compiler and environment serializer as the binary key, so reported toolchain state denotes the inputs actually used by the build.
  * @evidence contracts/common.md#clear-and-simple-design Compiler selection, executable resolution and hashing each stay with their owning helper; this function only composes one environment reading.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The result comes from real Go/environment inputs, not a fixed compiler version or a caller-specific substitute.
@@ -32,13 +37,14 @@ import { resolveGoCompiler } from "./resolveGoCompiler";
  * @evidence contracts/portability.md#os-neutral-implementation Executable identity is resolved before probing, and Node filesystem/process boundaries implement native spelling rather than assuming Windows or POSIX paths are interchangeable.
  * @evidence contracts/performance.md#efficient-algorithms The wrapper resolves the compiler/tool under the supplied environment before delegating full environment hashing. Native resolution/probes, SDK metadata/name/path sorting and changed-manifest full content reads contribute cost; the final hash output is fixed-width but streamed identity/input text and full-file buffers are not. No independent duplicate source-directory digest scan is added here.
  *
- * @evidenceExclude contracts/performance.md#reuse-equivalent-work This is the fresh-reading boundary required by builds; processPluginBuildEnvironment owns reuse when a consumer permits it.
+ * @evidence contracts/performance.md#reuse-equivalent-work This is the fresh-reading boundary required by builds: the Go probes run on every call. Content digests of the SDK and executables are shared across processes only through the supplied record store's separable-signature proof; processPluginBuildEnvironment owns reuse of the whole reading when a consumer permits it.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Its digest and filesystem adapter are call-local; retained compiler/content memo ownership belongs to the hasher.
  */
 export function pluginBuildEnvironment(
   directory: string,
   env: NodeJS.ProcessEnv = process.env,
   witness?: PluginBuildEnvironmentWitness.Record,
+  identities?: PluginContentIdentities.Store,
 ): string {
   const goBinary = GoToolResolution.resolveGoToolForBuild(
     resolveGoCompiler(env).binary,
@@ -54,6 +60,7 @@ export function pluginBuildEnvironment(
     env,
     { readFile: (location) => fs.readFileSync(location) },
     witness,
+    identities,
   );
   return hash.digest("hex");
 }

package/src/plugin/internal/source/pluginBuildEnvironmentWorker.ts

@@ -2,24 +2,40 @@ import { parentPort } from "node:worker_threads";
 
 import { serializeCompilerError } from "../../../internal/serializeCompilerError";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import { PluginContentIdentities } from "./PluginContentIdentities";
 import { pluginBuildEnvironment } from "./pluginBuildEnvironment";
 
 /**
  * Observe one requested native toolchain environment on the exclusive worker.
  * Explicit environment values reach every Go/toolchain reader; no caller
  * process globals are written. Only actual readings and pre-read witnesses
- * cross the worker boundary, and failures retain their real error details.
+ * cross the worker boundary, and failures retain their real error details. A
+ * request that names its project lets this isolate prove the SDK and the
+ * executables from the plugin cache's records instead of their bytes (#1722).
  */
 parentPort?.on(
   "message",
-  (request: { directory: string; env: NodeJS.ProcessEnv }) => {
+  (request: {
+    directory: string;
+    env: NodeJS.ProcessEnv;
+    projectRoot?: string;
+  }) => {
     try {
       const witness: PluginBuildEnvironmentWitness.Record = new Map();
+      const identities =
+        request.projectRoot === undefined
+          ? undefined
+          : PluginContentIdentities.open({
+              projectRoot: request.projectRoot,
+              env: request.env,
+              sources: [request.directory],
+            });
       parentPort!.postMessage({
         environment: pluginBuildEnvironment(
           request.directory,
           request.env,
           witness,
+          identities,
         ),
         witness,
       });

package/src/plugin/internal/source/pluginBuildVersions.ts

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 
+import { ttscPackageVersion } from "./ttscPackageVersion";
+
 /**
  * Package-version labels used by plugin build keys (`computeCacheKey`) and
  * persisted transform identities. These are metadata inputs, not a measurement
@@ -21,42 +23,19 @@ import path from "node:path";
  * @param projectRoot The project base used to resolve
  *   `typescript/package.json`.
  * @evidence contracts/common.md#principled-implementation Package-version labels supply the same metadata tuple used by plugin keys; absent/unreadable metadata receives the documented unknown/default label rather than an executable identity certificate.
- * @evidence contracts/common.md#clear-and-simple-design Host-version and project-version readers are separate because one installation is stable within the process while project resolution varies per call.
+ * @evidence contracts/common.md#clear-and-simple-design The host label comes from its own owner (`ttscPackageVersion`), which a reader needing only that label calls without this function's project resolution; the project-version reader is separate because project resolution varies per call.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Node package resolution determines the actual project dependency; no particular project or fixture version is embedded.
  * @evidence contracts/common.md#meaningful-documentation Native prose explains persisted-output consumers, metadata fallbacks and the process-stable host premise without claiming that version labels establish executable or output equivalence.
  * @evidence contracts/portability.md#os-neutral-implementation Node createRequire and path APIs locate package metadata using native module resolution without manual separator or case normalization.
  * @evidence contracts/performance.md#efficient-algorithms Each call performs project package resolution and, when successful, reads/parses its manifest bytes; module search/path work and metadata size are not fixed by one logical manifest lookup. The host manifest is attempted only on the first invocation, including native path and JSON costs.
  * @evidence contracts/performance.md#reuse-equivalent-work All callers share the host installation's process-stable version; the project compiler version is resolved afresh so different project roots do not share a false identity.
- * @evidence contracts/performance.md#bound-retention-and-release-resources This helper retains one host-version label for the process lifetime, whose text follows its manifest value rather than a fixed byte limit; the helper's retained label count is independent of project count. Native module-resolution caches belong to Node, and synchronous file reads leave no persistent descriptor here.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The host-version owner retains one label for the process lifetime, whose text follows its manifest value rather than a fixed byte limit; the retained label count is independent of project count. Native module-resolution caches belong to Node, and synchronous file reads leave no persistent descriptor here.
  */
 export function pluginBuildVersions(projectRoot: string): {
   tsgo: string;
   ttsc: string;
 } {
-  return { tsgo: readTsgoVersion(projectRoot), ttsc: readTtscVersion() };
-}
-
-let cachedTtscVersion: string | null = null;
-
-function readTtscVersion(): string {
-  if (cachedTtscVersion !== null) return cachedTtscVersion;
-  try {
-    const file = path.resolve(
-      __dirname,
-      "..",
-      "..",
-      "..",
-      "..",
-      "package.json",
-    );
-    const pkg = JSON.parse(fs.readFileSync(file, "utf8")) as {
-      version?: string;
-    };
-    cachedTtscVersion = pkg.version ?? "0.0.0";
-  } catch {
-    cachedTtscVersion = "0.0.0";
-  }
-  return cachedTtscVersion;
+  return { tsgo: readTsgoVersion(projectRoot), ttsc: ttscPackageVersion() };
 }
 
 function readTsgoVersion(projectRoot: string): string {

package/src/plugin/internal/source/pluginSourceState.ts

@@ -1,8 +1,9 @@
 import crypto from "node:crypto";
 
+import { PluginContentIdentities } from "./PluginContentIdentities";
 import { pluginBuildEnvironment } from "./pluginBuildEnvironment";
-import { pluginSourceDigest } from "./pluginSourceDigest";
 import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
+import { provenPluginSourceDigest } from "./provenPluginSourceDigest";
 
 /**
  * The state of one plugin source directory as a plugin binary is built from it:
@@ -25,7 +26,9 @@ import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
  * process's own environment the environment is read once per directory and set
  * of variables (`processPluginBuildEnvironment`), and a proof that must not
  * accept a stale one compares through `pluginSourceStateHolds`, which reads it
- * again before it refutes a state.
+ * again before it refutes a state. A caller that names its project proves the
+ * sources and the SDK from that project's plugin cache records instead of
+ * reading them in every new process (#1725).
  *
  * @param directory The source directory.
  * @param options.env An effective environment other than this process's, which
@@ -34,6 +37,7 @@ import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
  *   caller already read it.
  * @param options.environment The directory's `pluginBuildEnvironment`, when the
  *   caller already read it, as a plugin build's key does.
+ * @param options.projectRoot Project whose plugin cache root holds the records.
  * @returns The state, as lowercase hex.
  * @throws When a listed source file cannot be read, as the build itself would.
  * @evidence contracts/common.md#principled-implementation The state combines source and environment digests because both affect compiled plugin behavior; supplied readings preserve the exact inputs a build already keyed on.
@@ -42,7 +46,7 @@ import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain module-root versus overlay environment meaning and the provenance required for supplied digests.
  * @evidence contracts/portability.md#os-neutral-implementation Native source and toolchain identity are delegated to the shared filesystem/process readers; the final digest is platform-independent serialized text.
  * @evidence contracts/performance.md#efficient-algorithms Composition serializes/hashes supplied digest strings whose public inputs are not length-validated; owning generated digests are fixed-width hex. Missing readings delegate native source enumeration/full reads and environment variable/witness/tool/SDK work, without establishing an unmeasured dominant cost ranking.
- * @evidence contracts/performance.md#reuse-equivalent-work Supplied source/environment strings are trusted producer readings, not independently revalidated here. Process-environment memos require their owner's variable/path witness checks; explicit injected environments are read fresh. Equality inherits the selected-source and native metadata premises.
+ * @evidence contracts/performance.md#reuse-equivalent-work Supplied source/environment strings are trusted producer readings, not independently revalidated here. Process-environment memos require their owner's variable/path witness checks; explicit injected environments are read fresh. A named project lets missing source and SDK readings come from its record store across processes. Equality inherits the selected-source and native metadata premises.
  *
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This function retains no resource or state after returning; process-environment memo lifetime belongs to its separate owner.
  */
@@ -51,19 +55,31 @@ export function pluginSourceState(
   options: {
     env?: NodeJS.ProcessEnv;
     environment?: string;
+    projectRoot?: string;
     sourceDigest?: string;
   } = {},
 ): string {
+  const sourceDigest =
+    options.sourceDigest ??
+    provenPluginSourceDigest(directory, options.projectRoot, options.env);
+  const environment =
+    options.environment ??
+    (options.env === undefined
+      ? processPluginBuildEnvironment(directory, false, options.projectRoot)
+      : pluginBuildEnvironment(
+          directory,
+          options.env,
+          undefined,
+          options.projectRoot === undefined
+            ? undefined
+            : PluginContentIdentities.open({
+                projectRoot: options.projectRoot,
+                env: options.env,
+                sources: [directory],
+              }),
+        ));
   return crypto
     .createHash("sha256")
-    .update(
-      `source=${options.sourceDigest ?? pluginSourceDigest(directory)}\n` +
-        `environment=${
-          options.environment ??
-          (options.env === undefined
-            ? processPluginBuildEnvironment(directory)
-            : pluginBuildEnvironment(directory, options.env))
-        }\n`,
-    )
+    .update(`source=${sourceDigest}\nenvironment=${environment}\n`)
     .digest("hex");
 }

package/src/plugin/internal/source/pluginSourceStateHolds.ts

@@ -1,6 +1,6 @@
-import { pluginSourceDigest } from "./pluginSourceDigest";
 import { pluginSourceState } from "./pluginSourceState";
 import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
+import { provenPluginSourceDigest } from "./provenPluginSourceDigest";
 
 /**
  * Whether one plugin source directory still holds the state a transform
@@ -16,12 +16,16 @@ import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
  * is refuted. A compile keys its binaries on a fresh read, so a state it
  * reported after a change gets one comparison with a refreshed environment.
  * That retry does not guarantee equality for a changing or differently keyed
- * environment, and a supplied source digest remains the caller's premise.
+ * environment, and a supplied source digest remains the caller's premise. A
+ * caller that names its project proves the sources and the SDK from that
+ * project's plugin cache records instead of reading them in every new process
+ * (#1725).
  *
  * @param directory The source directory, as the envelope names it.
  * @param state The state the envelope reported.
  * @param options.sourceDigest The directory's `pluginSourceDigest`, when the
  *   caller holds one it can vouch for.
+ * @param options.projectRoot Project whose plugin cache root holds the records.
  * @throws When a listed source file cannot be read, as the build itself would.
  * @evidence contracts/common.md#principled-implementation Equality uses shared state composition and one real environment refresh after mismatch. This allows changed observations to be reconsidered without certifying the second comparison must match; supplied digest validity and native witness premises remain with their owners.
  * @evidence contracts/common.md#clear-and-simple-design One source reading is passed through both attempts and only the environment owner performs the refresh.
@@ -29,17 +33,20 @@ import { processPluginBuildEnvironment } from "./processPluginBuildEnvironment";
  * @evidence contracts/common.md#meaningful-documentation The prose states source-digest provenance, environment invalidation and the reason a mismatching state gets a fresh comparison.
  * @evidence contracts/portability.md#os-neutral-implementation Source reads and Go/environment witnesses use the same native boundary implementations as builds, rather than comparing OS names or guessed installation paths.
  * @evidence contracts/performance.md#efficient-algorithms At most one source digest computation is requested and reused by both comparisons; supplied strings bypass it. Native enumeration/file bytes, full environment identity/witness checks, optional tool/SDK refresh and digest-string hashing contribute work; mismatch repeats environment resolution once rather than bounding total cost by comparison count.
- * @evidence contracts/performance.md#reuse-equivalent-work A caller's proven source digest and the process owner's still-valid environment are reused; a mismatch forces the owning environment refresh before returning false.
+ * @evidence contracts/performance.md#reuse-equivalent-work A caller's proven source digest and the process owner's still-valid environment are reused; a mismatch forces the owning environment refresh before returning false. A named project lets the source and SDK readings come from its record store across processes.
  *
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The proof owns no retained source buffer, process or watcher; its caller owns any saved source digest.
  */
 export function pluginSourceStateHolds(
   directory: string,
   state: string,
-  options: { sourceDigest?: string } = {},
+  options: { projectRoot?: string; sourceDigest?: string } = {},
 ): boolean {
-  const sourceDigest = options.sourceDigest ?? pluginSourceDigest(directory);
-  if (pluginSourceState(directory, { sourceDigest }) === state) return true;
-  processPluginBuildEnvironment(directory, true);
-  return pluginSourceState(directory, { sourceDigest }) === state;
+  const projectRoot = options.projectRoot;
+  const sourceDigest =
+    options.sourceDigest ?? provenPluginSourceDigest(directory, projectRoot);
+  if (pluginSourceState(directory, { projectRoot, sourceDigest }) === state)
+    return true;
+  processPluginBuildEnvironment(directory, true, projectRoot);
+  return pluginSourceState(directory, { projectRoot, sourceDigest }) === state;
 }