ttsc 0.31.1 → 0.31.2

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

@@ -21,20 +21,26 @@ import { PluginBuildEnvironmentReadings } from "./PluginBuildEnvironmentReadings
  * possible metadata-restored change. The build itself never reads through here:
  * it keys each binary on a fresh read.
  *
+ * A caller that names its project lets a reading this process does not hold
+ * prove the SDK and executables from that project's plugin cache records
+ * (#1725) instead of reading the whole GOROOT in every new process.
+ *
  * @param directory The directory a build runs `go` in.
  * @param refresh Whether to read the environment again rather than reuse it.
+ * @param projectRoot Project whose plugin cache root holds the records.
  * @evidence contracts/common.md#principled-implementation Variable serialization is sorted and length-delimited; reuse additionally requires unchanged pre-read metadata for every external dependency, including all contributing GOROOT directories and files, under the witness's documented metadata-distinguishability premise.
  * @evidence contracts/common.md#clear-and-simple-design One process-local map owns environment memoization; fresh construction and witness validation remain separate operations shared with build verification.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Refresh performs the real environment read rather than assuming that a stable compiler path or quiet source tree implies a stable toolchain.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain why environment probing is retained, its variable/path invalidation, and why builds still read fresh; descriptive prose and tags are separated.
  * @evidence contracts/portability.md#os-neutral-implementation Native environment and filesystem identity are delegated to the shared platform-aware probe and metadata witness rather than inferred from an OS name.
  * @evidence contracts/performance.md#efficient-algorithms The delegated owner serializes/hashes variable names/values after text-sensitive sorting and validates witnessed native paths. A qualified hit avoids cold tool/content preparation but not native lookup/path/link/text costs. Misses/refresh delegate actual Go/toolchain/SDK readings; V/P counts alone do not bound all bytes or native work.
- * @evidence contracts/performance.md#reuse-equivalent-work Directory and all effective variables identify a candidate reading; the complete external-path witness must hold, otherwise the environment is read and its record replaced.
+ * @evidence contracts/performance.md#reuse-equivalent-work Directory and all effective variables identify a candidate reading; the complete external-path witness must hold, otherwise the environment is read and its record replaced. A miss naming a project proves the SDK and executables from that project's record store across processes.
  * @evidence contracts/performance.md#bound-retention-and-release-resources PluginBuildEnvironmentReadings owns the process-shared map and asynchronous worker/request lifetimes, not this forwarding call. Existing keys are replaced, but distinct directory/variable combinations retain historical witnesses without an eviction bound; consumers and the owner govern that retention.
  */
 export function processPluginBuildEnvironment(
   directory: string,
   refresh = false,
+  projectRoot?: string,
 ): string {
-  return PluginBuildEnvironmentReadings.read(directory, refresh);
+  return PluginBuildEnvironmentReadings.read(directory, refresh, projectRoot);
 }

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

@@ -0,0 +1,45 @@
+import { PluginContentIdentities } from "./PluginContentIdentities";
+
+/**
+ * The `pluginSourceDigest` of a plugin source directory, proven from the
+ * records of `projectRoot`'s plugin cache when the caller names its project.
+ *
+ * WARNING (#1725): a consumer that proves a reported plugin-source state in a
+ * new process, such as a bundler worker, a capability host or the language
+ * server, read every source byte again because its own memo starts empty. The
+ * load that reported the state already recorded this digest
+ * (`PluginContentIdentities`), so a process that names the same project reuses
+ * it while the files' metadata still holds. Without a project, or when no store
+ * can be opened, the bytes are read as before.
+ *
+ * @param directory The source directory.
+ * @param projectRoot Project whose plugin cache root holds the records.
+ * @param env Environment selecting that cache root; this process's by default.
+ * @returns The digest, as lowercase hex.
+ * @throws When a listed source file cannot be read, as `pluginSourceDigest`
+ *   does.
+ * @evidence contracts/common.md#principled-implementation The record store applies its separable-signature rule to exactly the files the digest reads; every unproved premise falls back to the content reader.
+ * @evidence contracts/common.md#clear-and-simple-design Store opening and the population proof stay with PluginContentIdentities; this entry only names the project for consumers outside the loader.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No path, timestamp or process memo stands for content; the store refuses a root inside the source.
+ * @evidence contracts/common.md#meaningful-documentation The paragraphs state the regression, the reuse premise and the fallback.
+ * @evidence contracts/portability.md#os-neutral-implementation Cache-root selection and device-keyed references are delegated to the shared owners.
+ * @evidence contracts/performance.md#efficient-algorithms A proven digest stats the selected files; an unproven one also reads their bytes once. Opening the store writes two reference probes.
+ * @evidence contracts/performance.md#reuse-equivalent-work The digest the load recorded is reused across processes under the same project's store.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources The store lives for this call; records belong to the cache root's single-file pruning.
+ */
+export function provenPluginSourceDigest(
+  directory: string,
+  projectRoot?: string,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  return PluginContentIdentities.sourceDirectory(
+    projectRoot === undefined
+      ? undefined
+      : PluginContentIdentities.open({
+          projectRoot,
+          env,
+          sources: [directory],
+        }),
+    directory,
+  );
+}

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

@@ -8,8 +8,9 @@ import { SourceBuildCacheLayout } from "./SourceBuildCacheLayout";
 /**
  * Opportunistically bound a part of the cache root whose entries are single
  * files: the descriptor evaluations under `descriptors/`, the capability
- * answers under `capabilities/`, and the lowered orphan sources under
- * `ttsx-orphan/`.
+ * answers under `capabilities/`, the plugin content identities under
+ * `identities/`, the plugin-load answers under `answers/`, and the lowered
+ * orphan sources under `ttsx-orphan/`.
  *
  * The policy is the plugin cache's (`CachePrunePolicy`). An entry's last use is
  * its modification time: a write sets it, and every hit records a use by

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

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * The version of this ttsc package, read from its own manifest once per
+ * process, or `"0.0.0"` when the manifest cannot be read or names none.
+ *
+ * WARNING (#1726): a reader that only needs ttsc's own version must take it
+ * here, never from `pluginBuildVersions`, which also resolves the project's
+ * `typescript` package. A plugin descriptor evaluator opens a record store
+ * while its module resolution recorder runs, and on a runtime whose
+ * `require.resolve` consults resolve hooks every such lookup became an input of
+ * the descriptor: absent `typescript` candidates below the cache root's
+ * ancestors, whose proofs the system temporary directory's metadata then
+ * withdrew. Reading a file here resolves no module.
+ *
+ * The host installation is assumed stable for the process lifetime; changing
+ * its manifest does not refresh the label.
+ *
+ * @evidence contracts/common.md#principled-implementation The label is this package's manifest version, the same value plugin keys and record identities have always named; an unreadable manifest yields the documented default instead of a guess.
+ * @evidence contracts/common.md#clear-and-simple-design One reader owns the host label; `pluginBuildVersions` composes it with the project's compiler version.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The manifest beside the compiled module is read directly; no module resolution or fixture version stands in for it.
+ * @evidence contracts/common.md#meaningful-documentation The paragraphs state the value, the regression that motivates a resolution-free reader and the process-stable premise.
+ * @evidence contracts/portability.md#os-neutral-implementation The manifest path is joined with Node path APIs relative to this module, without separator or case assumptions.
+ * @evidence contracts/performance.md#efficient-algorithms The first call reads and parses one small manifest; later calls return the retained label.
+ * @evidence contracts/performance.md#reuse-equivalent-work Every caller in the process shares one reading of an installation assumed stable for that process.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One label string is retained for the process lifetime; the synchronous read leaves no descriptor open.
+ */
+export function ttscPackageVersion(): string {
+  if (version !== undefined) return version;
+  try {
+    const manifest = JSON.parse(
+      fs.readFileSync(
+        path.resolve(__dirname, "..", "..", "..", "..", "package.json"),
+        "utf8",
+      ),
+    ) as { version?: string };
+    version = manifest.version ?? "0.0.0";
+  } catch {
+    version = "0.0.0";
+  }
+  return version;
+}
+
+let version: string | undefined;

package/src/plugin/internal/writeCapabilityResolution.ts

@@ -8,8 +8,8 @@ import { CapabilityResolutionFormat } from "./CapabilityResolutionFormat";
 import type { ITtscCapabilityPluginSource } from "./ITtscCapabilityPluginSource";
 import type { ITtscCapabilityResolutionEntry } from "./ITtscCapabilityResolutionEntry";
 import type { ITtscCapabilityResolutionPlugin } from "./ITtscCapabilityResolutionPlugin";
+import { PluginContentIdentities } from "./source/PluginContentIdentities";
 import { SourceBuildCacheLayout } from "./source/SourceBuildCacheLayout";
-import { pluginSourceDigest } from "./source/pluginSourceDigest";
 import { pluginSourceFilesSignature } from "./source/pluginSourceFilesSignature";
 import { pluginSourceState } from "./source/pluginSourceState";
 
@@ -71,6 +71,12 @@ export function writeCapabilityResolution(
 
     /** Pre-load authority key; a moved evaluation authority refuses the write. */
     expectedAuthority?: string;
+
+    /**
+     * Record store of the project's plugin cache, which proves the runtime and
+     * the plugin sources and SDK from metadata instead of their bytes (#1725).
+     */
+    identities?: PluginContentIdentities.Store;
   },
   answer: {
     /**
@@ -180,8 +186,8 @@ export function writeCapabilityResolution(
       return null;
     }
   }
-  const evidence = CapabilityResolutionFormat.sourceEvidence(
-    CapabilityResolutionFormat.clockReference(file),
+  const evidence = PluginContentIdentities.sourceEvidence(
+    PluginContentIdentities.mintReference(path.dirname(file)),
   );
   const entry: ITtscCapabilityResolutionEntry = {
     hostInputHashes,
@@ -191,7 +197,13 @@ export function writeCapabilityResolution(
     pluginSources: Object.fromEntries(
       Object.entries(answer.pluginSources).map(([directory, state]) => [
         directory,
-        recordPluginSource(directory, state, evidence),
+        recordPluginSource(
+          directory,
+          state,
+          evidence,
+          path.resolve(options.cwd),
+          options.identities,
+        ),
       ]),
     ),
     plugins: answer.plugins.map((plugin) => ({
@@ -239,23 +251,32 @@ export function writeCapabilityResolution(
  * when both signatures agree, every stamp was separable from a reference minted
  * before the read, and the digest gives the very state the load reported, so
  * the entry never vouches for sources the binary was not built from. Anything
- * else records the state alone, which a read proves in full.
+ * else records the state alone, which a read proves in full. The digest comes
+ * from the project's record store when its metadata still holds there, which
+ * places it inside the same two signatures, so a new process does not read
+ * every source byte again (#1725).
  */
 function recordPluginSource(
   directory: string,
   state: string,
-  evidence: ReturnType<typeof CapabilityResolutionFormat.sourceEvidence>,
+  evidence: ReturnType<typeof PluginContentIdentities.sourceEvidence>,
+  projectRoot: string,
+  identities: PluginContentIdentities.Store | undefined,
 ): ITtscCapabilityPluginSource {
   try {
     const before = pluginSourceFilesSignature(directory, evidence);
-    const digest = pluginSourceDigest(directory);
+    const digest = PluginContentIdentities.sourceDirectory(
+      identities,
+      directory,
+    );
     const after = pluginSourceFilesSignature(directory, evidence);
     if (
       before !== undefined &&
       after !== undefined &&
       before.signature === after.signature &&
       after.separable &&
-      pluginSourceState(directory, { sourceDigest: digest }) === state
+      pluginSourceState(directory, { projectRoot, sourceDigest: digest }) ===
+        state
     ) {
       return { digest, signature: after.signature, state };
     }

package/src/plugin/resolveCapabilityPlugins.ts

@@ -15,6 +15,7 @@ import { CapabilityResolutionFormat } from "./internal/CapabilityResolutionForma
 import type { ITtscCapabilityResolutionEntry } from "./internal/ITtscCapabilityResolutionEntry";
 import { loadProjectPlugins } from "./internal/load/loadProjectPlugins";
 import { readCapabilityResolution } from "./internal/readCapabilityResolution";
+import { PluginContentIdentities } from "./internal/source/PluginContentIdentities";
 import { writeCapabilityResolution } from "./internal/writeCapabilityResolution";
 
 /**
@@ -102,12 +103,26 @@ export function resolveCapabilityPluginResolution(options: {
   // the same cwd. NUL cannot occur in a filename, so this discovery key cannot
   // collide with an explicitly supplied path.
   const tsconfig = options.tsconfig ?? `${String.fromCharCode(0)}discovered`;
-  const runtimeProved = capabilityRuntimeAuthorityComplete(cwd);
+  // WARNING (#1725): every lookup proved the runtime by streaming it, and a hit
+  // proved the plugin sources and the whole GOROOT by their bytes, in each
+  // process. One store of the project's plugin cache serves every proof of
+  // this resolution, opened only once the runtime may be cached at all.
+  const identities = capabilityRecordStore(cwd);
+  const runtimeProved = capabilityRuntimeAuthorityComplete(cwd, identities);
   const authority = runtimeProved
-    ? CapabilityResolutionFormat.resolutionFile({ cwd, tsconfig })
+    ? CapabilityResolutionFormat.resolutionFile({
+        cwd,
+        tsconfig,
+        identities: identities(),
+      })
     : null;
   const cached = runtimeProved
-    ? readCapabilityResolution({ cwd, tsconfig, version })
+    ? readCapabilityResolution({
+        cwd,
+        tsconfig,
+        version,
+        identities: identities(),
+      })
     : null;
   E2ETrace.capabilityResolution("lookup", {
     cwd,
@@ -118,7 +133,14 @@ export function resolveCapabilityPluginResolution(options: {
     cacheHit: cached !== null,
   });
   if (cached !== null)
-    return resolved(cached, options.capability, cwd, tsconfig, authority);
+    return resolved(
+      cached,
+      options.capability,
+      cwd,
+      tsconfig,
+      authority,
+      identities,
+    );
 
   const binary = resolveBinary();
   if (binary === null || binary === undefined)
@@ -178,12 +200,21 @@ export function resolveCapabilityPluginResolution(options: {
       runtimeProved &&
       authority !== null &&
       (authorityUnchanged =
-        CapabilityResolutionFormat.resolutionFile({ cwd, tsconfig }) ===
-        authority) &&
+        CapabilityResolutionFormat.resolutionFile({
+          cwd,
+          tsconfig,
+          identities: identities(),
+        }) === authority) &&
       loaded.descriptorReadsDeclared &&
       loaded.discoveryInputsComplete
         ? writeCapabilityResolution(
-            { cwd, tsconfig, version, expectedAuthority: authority },
+            {
+              cwd,
+              tsconfig,
+              version,
+              expectedAuthority: authority,
+              identities: identities(),
+            },
             answer,
           )
         : null;
@@ -213,10 +244,40 @@ export function resolveCapabilityPluginResolution(options: {
           plugins: CapabilityPluginResult.select(answer, options.capability),
           status: "resolved",
         }
-      : resolved(recorded, options.capability, cwd, tsconfig, authority);
+      : resolved(
+          recorded,
+          options.capability,
+          cwd,
+          tsconfig,
+          authority,
+          identities,
+        );
   });
 }
 
+/**
+ * The record store of `cwd`'s plugin cache, opened on first use and kept for
+ * the resolution and its later freshness queries, or `undefined` when none can
+ * be opened. A kept store's references only grow older, which can make fewer
+ * stamps separable but never more.
+ */
+function capabilityRecordStore(
+  cwd: string,
+): () => PluginContentIdentities.Store | undefined {
+  let opened = false;
+  let store: PluginContentIdentities.Store | undefined;
+  return () => {
+    if (!opened) {
+      opened = true;
+      store = PluginContentIdentities.open({
+        projectRoot: cwd,
+        env: process.env,
+      });
+    }
+    return store;
+  };
+}
+
 /**
  * Whether the keyed executable is the actual sole descriptor runtime.
  *
@@ -228,7 +289,10 @@ export function resolveCapabilityPluginResolution(options: {
  * operation's existing decision and preserves short-circuited comparisons as
  * unobserved, without repeating native queries.
  */
-function capabilityRuntimeAuthorityComplete(cwd: string): boolean {
+function capabilityRuntimeAuthorityComplete(
+  cwd: string,
+  identities: () => PluginContentIdentities.Store | undefined,
+): boolean {
   if (SidecarEnvironment.read(process.env, "NODE_OPTIONS")?.trim()) {
     E2ETrace.capabilityResolution("runtime-authority", {
       cwd,
@@ -254,6 +318,7 @@ function capabilityRuntimeAuthorityComplete(cwd: string): boolean {
       runtime,
       process.env,
       cwd,
+      identities(),
     );
     let executableMatches: boolean | undefined;
     const proved =
@@ -291,6 +356,7 @@ function resolved(
   cwd: string,
   tsconfig: string,
   authority: string | null,
+  identities: () => PluginContentIdentities.Store | undefined,
 ): ITtscCapabilityPluginResolution {
   const proof = JSON.stringify(entry);
   return {
@@ -298,12 +364,20 @@ function resolved(
       try {
         if (
           authority === null ||
-          !capabilityRuntimeAuthorityComplete(cwd) ||
-          CapabilityResolutionFormat.resolutionFile({ cwd, tsconfig }) !==
-            authority
+          !capabilityRuntimeAuthorityComplete(cwd, identities) ||
+          CapabilityResolutionFormat.resolutionFile({
+            cwd,
+            tsconfig,
+            identities: identities(),
+          }) !== authority
         )
           return false;
-        const current = readCapabilityResolution({ cwd, tsconfig, version });
+        const current = readCapabilityResolution({
+          cwd,
+          tsconfig,
+          version,
+          identities: identities(),
+        });
         return current !== null && JSON.stringify(current) === proof;
       } catch {
         return false;