ttsc 0.31.0 → 0.31.2

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

@@ -4,6 +4,7 @@ import { SHARE_ENV, Worker } from "node:worker_threads";
 
 import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import { PluginContentIdentities } from "./PluginContentIdentities";
 import { pluginBuildEnvironment } from "./pluginBuildEnvironment";
 
 /**
@@ -74,25 +75,92 @@ export namespace PluginBuildEnvironmentReadings {
       : undefined;
   }
 
+  /**
+   * Qualify a batch in one synchronous observation transaction. Shared SDK
+   * paths and the complete variable identity are read once, even when several
+   * plugin directories use them. Missing readings remain explicitly missing.
+   *
+   * WARNING (#1712): this map belongs only to the following synchronous proof.
+   * Never retain it across an await, delivery, build boundary or publication. A
+   * process-permanent positive witness would miss changed Go tools and GOENV
+   * files (#1516); independently checking it in every helper instead multiplies
+   * a thousands-file GOROOT scan by modules and proof layers.
+   *
+   * @evidence contracts/common.md#principled-implementation One current variable snapshot and native path observation are compared against each reading's own expected witness; conflicting expected states cannot both pass.
+   * @evidence contracts/common.md#clear-and-simple-design One batch operation owns shared validation without changing synchronous reads or native worker publication boundaries.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Undefined is retained for absent or stale authority; no positive verdict survives this explicit observation transaction.
+   * @evidence contracts/common.md#meaningful-documentation Native paragraphs state scope, missing semantics and the performance/correctness regressions prevented by the lifetime restriction.
+   * @evidence contracts/portability.md#os-neutral-implementation Existing native witness keys preserve filesystem, link and ambient-variable distinctions; no platform case assumption is added.
+   * @evidence contracts/performance.md#efficient-algorithms Full variables are indexed once; each distinct witnessed path is queried once while each reading compares its own witness entries. Work is proportional to variable bytes, total witness entries and unique native dependencies rather than repeated native SDK scans.
+   * @evidence contracts/performance.md#reuse-equivalent-work Only current native observations within this synchronous batch are shared; the returned digests do not authorize reuse after another asynchronous boundary.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources The native observation map is call-local and the digest map transfers to its immediate proof caller; no handle or historical registry is acquired.
+   */
+  export function cachedAll(
+    directories: Iterable<string>,
+  ): ReadonlyMap<string, string | undefined> {
+    let variables: string | undefined;
+    const current = new Map<string, string>();
+    const result = new Map<string, string | undefined>();
+    for (const directory of directories) {
+      if (result.has(directory)) continue;
+      const known = readings.get(
+        directory + (variables ??= key("", process.env)),
+      );
+      result.set(
+        directory,
+        known !== undefined &&
+          PluginBuildEnvironmentWitness.holds(known.witness, undefined, current)
+          ? known.environment
+          : undefined,
+      );
+    }
+    return result;
+  }
+
   /**
    * Read synchronously for clients whose API owns synchronous native work.
    * Explicit refresh preserves the original fresh-comparison semantics.
    *
+   * WARNING (#1725): the map above ends with the process, and every consumer
+   * that proves a plugin-source state starts a new one: a bundler worker, a
+   * capability host, the language server. Without the project's record store
+   * each of them walked and hashed the whole GOROOT (1.7 s for the bundled
+   * toolchain) on its first proof. A caller that names its project lets a miss
+   * prove the SDK and executables from the plugin cache's records.
+   *
+   * @param directory Plugin source directory whose build environment is read.
+   * @param refresh Bypass a cached reading.
+   * @param projectRoot Project whose plugin cache root holds the records.
    * @evidence contracts/common.md#principled-implementation The same native reader constructs a digest paired with its pre-read witness; optional cached reuse validates current variables/metadata. A fresh synchronous reading is published without a separate post-read qualification here and relies on the native reader's premises.
    * @evidence contracts/common.md#clear-and-simple-design The synchronous boundary shares cached authority and delegates fresh observation to its owning reader.
    * @evidence contracts/common.md#prohibited-implementation-shortcuts A requested refresh actually probes the selected native toolchain.
    * @evidence contracts/common.md#meaningful-documentation Native prose identifies the synchronous execution owner and explicit refresh meaning.
    * @evidence contracts/portability.md#os-neutral-implementation Native Go selection and filesystem witnesses remain delegated to the shared reader.
    * @evidence contracts/performance.md#efficient-algorithms Hits pay complete variable-text indexing and native witness queries. Misses/refresh merge environment values, perform actual toolchain/SDK/content work, then rebuild the full variable-text key for publication; native/path/file/name/value bytes contribute cost beyond invocation count.
-   * @evidence contracts/performance.md#reuse-equivalent-work Synchronous and asynchronous clients share the same qualified readings.
+   * @evidence contracts/performance.md#reuse-equivalent-work Synchronous and asynchronous clients share the same qualified readings; a miss of a caller naming its project takes SDK and executable digests from the record store across processes.
    * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Retention belongs to the namespace; this call publishes one replacement record.
    */
-  export function read(directory: string, refresh = false): string {
+  export function read(
+    directory: string,
+    refresh = false,
+    projectRoot?: string,
+  ): string {
     const known = refresh ? undefined : cached(directory);
     if (known !== undefined) return known;
     const env = SidecarEnvironment.merge(process.env);
     const witness: PluginBuildEnvironmentWitness.Record = new Map();
-    const environment = pluginBuildEnvironment(directory, env, witness);
+    const environment = pluginBuildEnvironment(
+      directory,
+      env,
+      witness,
+      projectRoot === undefined
+        ? undefined
+        : PluginContentIdentities.open({
+            projectRoot,
+            env,
+            sources: [directory],
+          }),
+    );
     readings.set(key(directory, env), { environment, witness });
     return environment;
   }
@@ -106,6 +174,14 @@ export namespace PluginBuildEnvironmentReadings {
    * requests can create a worker after retirement. Refresh bypasses a cached
    * reading but can still share an equivalent in-flight request.
    *
+   * A caller that names its project lets the worker prove the SDK and
+   * executables from the plugin cache's records (#1722). The worker is its own
+   * isolate, so without them it reads the whole GOROOT once per process, which
+   * a bundler or runtime restarting on every edit pays every time.
+   *
+   * @param directory Plugin source directory whose build environment is read.
+   * @param refresh Bypass a cached reading.
+   * @param projectRoot Project whose plugin cache root holds the records.
    * @evidence contracts/common.md#principled-implementation Worker results publish only under their exact current variable identity and still-current native pre-read witness; changed or unwitnessable transfer windows reject instead of publishing authority or retrying indefinitely.
    * @evidence contracts/common.md#clear-and-simple-design Qualified hits return immediately; equivalent misses share one pending promise and exclusive queued worker request.
    * @evidence contracts/common.md#prohibited-implementation-shortcuts Go/environment/SDK preparation occurs in the worker rather than blocking the async host or fabricating a digest from compiler output.
@@ -118,6 +194,7 @@ export namespace PluginBuildEnvironmentReadings {
   export async function prepare(
     directory: string,
     refresh = false,
+    projectRoot?: string,
   ): Promise<string> {
     const known = refresh ? undefined : cached(directory);
     if (known !== undefined) return known;
@@ -126,7 +203,7 @@ export namespace PluginBuildEnvironmentReadings {
     const existing = pending.get(identity);
     if (existing !== undefined) return existing;
     const request = (async () => {
-      const reading = await observe(directory, env);
+      const reading = await observe(directory, env, projectRoot);
       if (
         identity !== key(directory, process.env) ||
         !PluginBuildEnvironmentWitness.holds(reading.witness)
@@ -158,6 +235,7 @@ export namespace PluginBuildEnvironmentReadings {
   function observe(
     directory: string,
     env: NodeJS.ProcessEnv,
+    projectRoot: string | undefined,
   ): Promise<Reading> {
     const request = queue.then(
       () =>
@@ -198,7 +276,7 @@ export namespace PluginBuildEnvironmentReadings {
           current.on("error", onError);
           current.on("exit", onExit);
           try {
-            current.postMessage({ directory, env });
+            current.postMessage({ directory, env, projectRoot });
           } catch (error) {
             release(false);
             reject(error);

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

@@ -144,7 +144,9 @@ export namespace PluginBuildEnvironmentWitness {
    * observation. The existing private opt-in trace retains the first actual
    * mismatch without repeating its lookup or changing the refusal. An optional
    * observation label separates preparation and build epochs in that trace; it
-   * does not change validation or authorize publication.
+   * does not change validation or authorize publication. A supplied native
+   * observation map belongs to one synchronous batch only; never reuse it after
+   * an await, delivery, environment mutation or publication boundary.
    *
    * @evidence contracts/common.md#principled-implementation Universal comparison requires every dependency to match its pre-read signature and immediately rejects a refused or changed path.
    * @evidence contracts/common.md#clear-and-simple-design Validation uses the same signature helper as capture, keeping identity and timestamp policy in one place.
@@ -153,16 +155,24 @@ export namespace PluginBuildEnvironmentWitness {
    * @evidence contracts/portability.md#os-neutral-implementation Validation reads actual Node metadata using the same link-following semantics as capture.
    * @evidence contracts/performance.md#efficient-algorithms Validation iterates dependencies until mismatch and performs native stat/link queries or ambient-variable serialization. Windows environment matching enumerates names and lowercases text per witnessed variable, so P alone does not bound that work. Native path/link/name/value/numeric bytes contribute cost; file content is not read and unavailable native observations share the helper's missing marker. An enabled private trace serializes the first mismatch's already-computed text through its existing bounded sink.
    *
-   * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call must establish current validity; caching that answer would conceal external changes.
+   * @evidence contracts/performance.md#reuse-equivalent-work A caller-owned synchronous batch may share current native observations, comparing each witness against its own expected state; ordinary calls and all later observation phases establish new validity.
    * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Validation retains no handles or additional historical state.
    */
-  export function holds(witness: Record, observation?: string): boolean {
+  export function holds(
+    witness: Record,
+    observation?: string,
+    currentReadings?: Map<string, string>,
+  ): boolean {
     for (const [file, recorded] of witness) {
-      const current = file.startsWith(ENVIRONMENT_PREFIX)
-        ? environmentSignature(file.slice(ENVIRONMENT_PREFIX.length))
-        : file.startsWith(LINK_PREFIX)
-          ? linkSignature(file.slice(LINK_PREFIX.length))
-          : signature(file);
+      let current = currentReadings?.get(file);
+      if (current === undefined) {
+        current = file.startsWith(ENVIRONMENT_PREFIX)
+          ? environmentSignature(file.slice(ENVIRONMENT_PREFIX.length))
+          : file.startsWith(LINK_PREFIX)
+            ? linkSignature(file.slice(LINK_PREFIX.length))
+            : signature(file);
+        currentReadings?.set(file, current);
+      }
       if (current !== recorded) {
         E2ETrace.capabilityResolution(
           "plugin-build-environment-witness-mismatch",