ttsc 0.31.1 → 0.31.2

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

@@ -1,7 +1,10 @@
 import crypto from "node:crypto";
 
+import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { GoSourceInputs } from "./GoSourceInputs";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import type { PluginContentIdentities } from "./PluginContentIdentities";
+import { PluginLoadAnswers } from "./PluginLoadAnswers";
 import { spawnGoTool } from "./spawnGoTool";
 
 /**
@@ -25,6 +28,28 @@ export namespace GoEnvironmentReading {
    */
   const goEnvironmentFiles = new Map<string, string | null>();
 
+  /**
+   * Answer family that carries the same location hint across processes, so a
+   * new process does not run `go env` once merely to learn it (#1722). A wrong
+   * or stale hint only costs the existing rediscovery run.
+   */
+  const ENVIRONMENT_FILE_HINT = "go-environment-file";
+
+  /**
+   * What chooses the file's location: `GOENV`, else `os.UserConfigDir()`
+   * (`%AppData%`, `$XDG_CONFIG_HOME`, `$HOME`, Plan 9's `$home`). The hint
+   * across processes is keyed by these alone, because a launch rarely repeats
+   * every unrelated variable, such as a per-run trace path, and a hint that
+   * misses costs the rediscovery run on every launch.
+   */
+  const LOCATION_VARIABLES = [
+    "GOENV",
+    "APPDATA",
+    "XDG_CONFIG_HOME",
+    "HOME",
+    "home",
+  ] as const;
+
   /**
    * Run `go env -json` for the requested keys and `GOENV`, the file `go env -w`
    * writes, witnessing that file before the run reads it.
@@ -38,6 +63,11 @@ export namespace GoEnvironmentReading {
    * one witnessed. A file that keeps moving between runs leaves the reading
    * unwitnessable, so a kept reading or a build keyed on it never holds.
    *
+   * The location hint also comes from the record store when one is supplied, so
+   * a new process witnesses the right file on its first run instead of running
+   * `go env` once only to learn the name.
+   *
+   * @param identities Optional record store carrying the hint across processes.
    * @returns The parsed object, or `undefined` when native acquisition or JSON
    *   object decoding failed.
    * @evidence contracts/common.md#principled-implementation Actual Go supplies values and the environment-file path; pre-read metadata and bounded rediscovery preserve the earliest file witness instead of attaching a later state to an earlier read.
@@ -46,8 +76,8 @@ export namespace GoEnvironmentReading {
    * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain why file discovery can repeat and distinguish unavailable acquisition from current authority.
    * @evidence contracts/portability.md#os-neutral-implementation Go reports its actual environment-file location; native path metadata and the existing Go process owner supply observation and execution semantics.
    * @evidence contracts/performance.md#efficient-algorithms Hashing the complete tool/environment identity and up to three native Go queries process full name/value/output bytes. Requested keys contribute argument bytes; file discovery uses metadata rather than an SDK walk.
-   * @evidence contracts/performance.md#reuse-equivalent-work Only file-location discovery hints are shared across equal selected-tool/environment identities. Current Go values and file authority are reacquired for every call.
-   * @evidence contracts/performance.md#bound-retention-and-release-resources The module retains one file-location hint per historical tool/environment identity, without eviction, but no positive reading or native handle. Command capture/retirement belongs to spawnGoTool and the caller owns the transferred witness.
+   * @evidence contracts/performance.md#reuse-equivalent-work Only file-location discovery hints are shared: in process across equal selected-tool/environment identities, and through the record store across equal selected tools and location variables, since the reading verifies any hint against the file Go reports. Current Go values and file authority are reacquired for every call.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources The module retains one file-location hint per historical tool/environment identity, without eviction, but no positive reading or native handle; persisted hints belong to the single-file collector. Command capture/retirement belongs to spawnGoTool and the caller owns the transferred witness.
    */
   export function read(
     goBinary: string,
@@ -55,6 +85,7 @@ export namespace GoEnvironmentReading {
     env: NodeJS.ProcessEnv,
     keys: readonly string[],
     witness: PluginBuildEnvironmentWitness.Record | undefined,
+    identities?: PluginContentIdentities.Store,
   ): Record<string, unknown> | undefined {
     const memo = crypto.createHash("sha256").update(goBinary);
     for (const [key, value] of Object.entries(env).sort(([left], [right]) =>
@@ -65,6 +96,15 @@ export namespace GoEnvironmentReading {
     }
     const memoKey = memo.digest("hex");
     let named = goEnvironmentFiles.get(memoKey);
+    if (named === undefined) {
+      const hinted = PluginLoadAnswers.read(
+        identities,
+        ENVIRONMENT_FILE_HINT,
+        hintKey(goBinary, env),
+      );
+      if (hinted === null || typeof hinted === "string") named = hinted;
+    }
+    const remembered = named;
     for (let attempt = 0; attempt < 3; attempt += 1) {
       if (named !== undefined && named !== null)
         PluginBuildEnvironmentWitness.add(witness, named);
@@ -94,16 +134,45 @@ export namespace GoEnvironmentReading {
         parsed.GOENV !== "off"
           ? parsed.GOENV
           : null;
-      if (reported === named) return parsed;
+      if (reported === named) {
+        goEnvironmentFiles.set(memoKey, named);
+        if (named !== remembered)
+          PluginLoadAnswers.write(
+            identities,
+            ENVIRONMENT_FILE_HINT,
+            hintKey(goBinary, env),
+            named,
+          );
+        return parsed;
+      }
       if (named !== undefined && named !== null) witness?.delete(named);
       named = reported;
       goEnvironmentFiles.set(memoKey, named);
       // No file to witness: the reading depends on none.
-      if (named === null) return parsed;
-      if (witness === undefined) return parsed;
+      if (named === null || witness === undefined) {
+        if (named !== remembered)
+          PluginLoadAnswers.write(
+            identities,
+            ENVIRONMENT_FILE_HINT,
+            hintKey(goBinary, env),
+            named,
+          );
+        return parsed;
+      }
     }
     if (named !== undefined && named !== null)
       PluginBuildEnvironmentWitness.refuse(witness, named);
     return undefined;
   }
+
+  // A wrong hint is safe: the reading compares it with the `GOENV` Go reports
+  // and runs again with the reported file witnessed.
+  function hintKey(goBinary: string, env: NodeJS.ProcessEnv): unknown {
+    return [
+      goBinary,
+      LOCATION_VARIABLES.map(
+        (name) => SidecarEnvironment.read(env, name) ?? null,
+      ),
+    ];
+  }
 }

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

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -7,9 +8,14 @@ import { SourceNativeRetirement } from "../../../internal/SourceNativeRetirement
 import { createCanonicalTempDirectory } from "../../../internal/createCanonicalTempDirectory";
 import { GoSourceInputs } from "./GoSourceInputs";
 import { GoToolResolution } from "./GoToolResolution";
+import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
+import { PluginContentIdentities } from "./PluginContentIdentities";
+import { PluginLoadAnswers } from "./PluginLoadAnswers";
 import { SourcePluginAdmission } from "./SourcePluginAdmission";
 import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { ensureExecutableGoToolchain } from "./ensureExecutableGoToolchain";
+import { hashPluginBuildEnvironment } from "./hashPluginBuildEnvironment";
+import { pluginSourceDigest } from "./pluginSourceDigest";
 import { resolveGoCompiler } from "./resolveGoCompiler";
 import { resolvePluginGoModule } from "./resolvePluginGoModule";
 import { spawnGoTool } from "./spawnGoTool";
@@ -26,7 +32,7 @@ import { spawnGoTool } from "./spawnGoTool";
  * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes metadata selection from compilation and later materialized admission.
  * @evidence contracts/portability.md#os-neutral-implementation Native path/fs operations and the shared Go tool selector preserve environment-name and path identity without blanket case folding; Go itself applies target platform and cgo selection.
  * @evidence contracts/performance.md#efficient-algorithms One list command observes all distinct package entries in each prepared context. Context materialization traverses and copies admitted host/contributor files; workspace setup delegates manifest commands and list skips dependency loading. Framing and JSON parsing process complete output bytes, and retained results scale with selected packages/files.
- * @evidence contracts/performance.md#reuse-equivalent-work Entries are deduplicated within a contextual observation; callers group equivalent module contexts for one load. No metadata result is cached across source, environment or toolchain changes. Cold admission uses the already prepared real build workspace.
+ * @evidence contracts/performance.md#reuse-equivalent-work Entries are deduplicated within a contextual observation; callers group equivalent module contexts for one load. With a record store, a successful selection is answered across loads and processes under an identity built from the content of everything Go reads, so any source, overlay, contributor, manifest, Go variable or toolchain change observes Go again (#1721); erroneous selections are never recorded. Cold admission uses the already prepared real build workspace.
  * @evidence contracts/performance.md#bound-retention-and-release-resources Each metadata scratch has finally-based retirement-aware cleanup, and capture resources belong to spawnGoTool. Unknown native retirement retains scratch under the existing scope; results and complete output remain caller-owned with no independent byte ceiling.
  */
 export namespace NativeSourcePackages {
@@ -59,6 +65,35 @@ export namespace NativeSourcePackages {
     Error?: { Err: string };
   }
 
+  /**
+   * One load's readings, shared by its package selections and its builds:
+   * source directory digests and module build-environment digests, each by
+   * absolute directory. The builds fill and report the same maps, so a load
+   * reads each directory and each module's toolchain once.
+   *
+   * @evidence contracts/common.md#principled-implementation Both maps carry readings already taken in this load under its fixed effective environment; builds still take their own environment reading with a witness.
+   * @evidence contracts/common.md#clear-and-simple-design Two maps already owned by the loader travel together.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts The maps never outlive the load; cross-process reuse belongs to the record store.
+   * @evidence contracts/common.md#meaningful-documentation Members state their keys and values.
+   * @evidence contracts/portability.md#os-neutral-implementation Keys are native absolute paths.
+   * @evidenceExclude contracts/performance.md#efficient-algorithms A record type runs no algorithm.
+   * @evidence contracts/performance.md#reuse-equivalent-work Selections and builds of one load share one reading per directory and module.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources The loader owns both maps for one load.
+   */
+  export interface SelectionReadings {
+    /** `pluginSourceDigest` of each directory this load read. */
+    sources?: Map<string, string>;
+
+    /** Build-environment digest of each module root this load read. */
+    environments?: Map<string, string>;
+
+    /**
+     * Witness of each reading in `environments`, so a build of the same
+     * directory keys on that reading instead of probing Go again.
+     */
+    witnesses?: Map<string, PluginBuildEnvironmentWitness.Record>;
+  }
+
   /**
    * Observe entries together in a private module layout for their context.
    *
@@ -68,7 +103,7 @@ export namespace NativeSourcePackages {
    * @evidence contracts/common.md#meaningful-documentation Native prose states this operation's authority and delegated boundaries; fields retain separate native comments.
    * @evidence contracts/portability.md#os-neutral-implementation Native copy/path and selected tool/environment owners preserve platform identity; contribution target containment is checked.
    * @evidence contracts/performance.md#efficient-algorithms Copies admitted host/contributor bytes and enumerates entries; workspace setup reads manifests and one list command skips dependencies.
-   * @evidence contracts/performance.md#reuse-equivalent-work All entries share one prepared context; optional readers are scoped to one load and the same selected tool/effective environment.
+   * @evidence contracts/performance.md#reuse-equivalent-work All entries share one prepared context; optional readers are scoped to one load and the same selected tool/effective environment. A supplied record store answers an equal selection without copying or running Go, under the content identity of the module, contributors, overlays, proposal manifests, toolchain/environment digest, Go variables, entries and command; an answer is recorded only when the copies matched their keyed digests, no package reported an error and the overlays still held their digests after Go ran.
    * @evidence contracts/performance.md#bound-retention-and-release-resources Finally releases owned scratch through retirement authority; unknown native closure defers removal and capture cleanup remains delegated.
    */
   export function inspect(opts: {
@@ -78,6 +113,18 @@ export namespace NativeSourcePackages {
     packages: readonly { entry: string; source?: string; name?: string }[];
     readers?: Map<string, SourcePluginWorkspace.GoModReader>;
     proposal?: boolean;
+
+    /**
+     * Record store under which an equal selection is answered without Go
+     * (#1721); without it every load runs the full observation.
+     */
+    identities?: PluginContentIdentities.Store;
+
+    /**
+     * The load's source and environment readings, shared with its builds so one
+     * load reads each directory and each module's toolchain once.
+     */
+    readings?: SelectionReadings;
   }): Package[] {
     const env = SidecarEnvironment.merge(opts.env ?? process.env);
     const { moduleRoot } = resolvePluginGoModule(opts.source, opts.pluginName);
@@ -88,6 +135,22 @@ export namespace NativeSourcePackages {
       moduleRoot,
     );
     ensureExecutableGoToolchain(goBinary, compiler.bundled);
+    // WARNING (#1721): never drop this lookup or narrow its identity. Without
+    // it every warm launch and every unplugin generation copied the module
+    // twice and ran `go list` twice (6 s+ on Windows) to rediscover an answer
+    // its unchanged inputs already determined.
+    const identity =
+      opts.identities === undefined
+        ? undefined
+        : selectionIdentity(opts, moduleRoot, goBinary, env, opts.identities);
+    if (identity !== undefined) {
+      const recalled = recallSelection(
+        PluginLoadAnswers.read(opts.identities, SELECTION_ANSWER, identity),
+        moduleRoot,
+        opts.packages.length,
+      );
+      if (recalled !== undefined) return recalled;
+    }
     const scratch = createCanonicalTempDirectory("ttsc-package-selection-");
     let taskFailure: { error: unknown } | undefined;
     try {
@@ -96,6 +159,12 @@ export namespace NativeSourcePackages {
         retainedPaths: [scratch],
       });
       SourcePluginWorkspace.materialize(moduleRoot, scratch);
+      // An answer is recorded only for the copy its identity describes: a
+      // module edited between the identity reading and the copy observed
+      // other bytes than the key names.
+      let copiesKeyed =
+        identity === undefined ||
+        pluginSourceDigest(scratch) === identity.module;
       if (opts.proposal === true) {
         // Only root manifests change. Relative Go inputs retain the source
         // module layout, while its irrelevant graph/toolchain stays inactive.
@@ -128,12 +197,17 @@ export namespace NativeSourcePackages {
             `ttsc: package selection target already exists: ${target}`,
           );
         SourcePluginWorkspace.materialize(input.source, target);
+        if (identity !== undefined)
+          copiesKeyed &&=
+            pluginSourceDigest(target) ===
+            identity.entries.find((entry) => entry[0] === input.entry)?.[2];
       }
       const reader = SourcePluginWorkspace.createGoModReader(
         goBinary,
         opts.pluginName,
         env,
         opts.readers,
+        opts.identities,
       );
       SourcePluginWorkspace.writeGoWork(
         scratch,
@@ -143,13 +217,33 @@ export namespace NativeSourcePackages {
         env,
         reader,
       );
-      return read({
+      const observed = read({
         cwd: scratch,
         entries: opts.packages.map((input) => input.entry),
         env: GoSourceInputs.goBuildEnv(goBinary, undefined, env),
         goBinary,
         pluginName: opts.pluginName,
       });
+      if (
+        identity !== undefined &&
+        copiesKeyed &&
+        observed.every((input) => input.Error === undefined) &&
+        JSON.stringify(overlayDigests(opts.identities)) ===
+          JSON.stringify(identity.overlays)
+      )
+        PluginLoadAnswers.write(
+          opts.identities,
+          SELECTION_ANSWER,
+          identity,
+          observed.map((input) => ({
+            ...input,
+            Dir:
+              input.Dir === undefined
+                ? undefined
+                : path.relative(scratch, input.Dir),
+          })),
+        );
+      return observed;
     } catch (error) {
       taskFailure = { error };
       throw error;
@@ -173,13 +267,15 @@ export namespace NativeSourcePackages {
    * @evidence contracts/common.md#meaningful-documentation Native prose states this operation's authority and delegated boundaries; fields retain separate native comments.
    * @evidence contracts/portability.md#os-neutral-implementation Native module roots retain their selected spelling, without blanket case folding.
    * @evidence contracts/performance.md#efficient-algorithms One grouping pass plus contextual copies and metadata work for each distinct module; output storage scales with input population.
-   * @evidence contracts/performance.md#reuse-equivalent-work Equivalent entries in a module share one list; overlay module observations share the load's selected-tool readers, without global metadata caching.
+   * @evidence contracts/performance.md#reuse-equivalent-work Equivalent entries in a module share one list; overlay module observations share the load's selected-tool readers, and the load's readings and record store reach each contextual observation so equal selections are answered from their content identity.
    * @evidence contracts/performance.md#bound-retention-and-release-resources Grouping/maps/results live for this call/load; scratch and native captures remain with inspect/read.
    */
   export function ownPackages(
     inputs: readonly { source: string; label: string }[],
     env: NodeJS.ProcessEnv,
     readers = new Map<string, SourcePluginWorkspace.GoModReader>(),
+    identities?: PluginContentIdentities.Store,
+    readings?: SelectionReadings,
   ): Package[] {
     const groups = new Map<string, Array<{ index: number; entry: string }>>();
     inputs.forEach((input, index) => {
@@ -196,6 +292,8 @@ export namespace NativeSourcePackages {
         pluginName: first.label,
         env,
         readers,
+        identities,
+        readings,
         packages: group.map(({ entry }) => ({ entry })),
       });
       group.forEach(({ index }, offset) => {
@@ -220,13 +318,15 @@ export namespace NativeSourcePackages {
    * @evidence contracts/common.md#meaningful-documentation Native prose states deterministic proposal authority and mandatory final ownership confirmation.
    * @evidence contracts/portability.md#os-neutral-implementation Native module/tool/environment owners preserve candidate-relative tool and source layout identity.
    * @evidence contracts/performance.md#efficient-algorithms Groups inputs by module and actual/prospective mode, copies each admitted module once per context, and batches entries through Go metadata; retained work scales with source bytes and distinct contexts.
-   * @evidence contracts/performance.md#reuse-equivalent-work Equivalent entries share one observation and per-load manifest readers; no result crosses a load or changed context.
+   * @evidence contracts/performance.md#reuse-equivalent-work Equivalent entries share one observation and per-load manifest readers; a result crosses loads only through the record store's content identity, so a changed context observes Go again.
    * @evidence contracts/performance.md#bound-retention-and-release-resources Group records live for this call; scratch/process cleanup remains with inspect and no independent output byte cap is imposed.
    */
   export function propose(
     inputs: readonly { source: string; label: string; ownModule?: boolean }[],
     env: NodeJS.ProcessEnv,
     readers = new Map<string, SourcePluginWorkspace.GoModReader>(),
+    identities?: PluginContentIdentities.Store,
+    readings?: SelectionReadings,
   ): Array<{ observation: Package; ownModule: boolean }> {
     const groups = new Map<
       string,
@@ -249,6 +349,8 @@ export namespace NativeSourcePackages {
         pluginName: first.label,
         env,
         readers,
+        identities,
+        readings,
         proposal: !group[0]!.ownModule,
         packages: group.map(({ entry }) => ({ entry })),
       });
@@ -426,3 +528,158 @@ export namespace NativeSourcePackages {
 function genericHostSource(): string {
   return path.resolve(__dirname, "../../../..", "cmd/utility-host");
 }
+
+/** Answer family of package selections (`PluginLoadAnswers`). */
+const SELECTION_ANSWER = "go-package-selection";
+
+/** Fields `read` asks Go for; part of the selection identity. */
+const SELECTION_FIELDS = "-json=Dir,Name,GoFiles,CgoFiles,Error";
+
+/**
+ * Everything a package selection's answer depends on, by content: the copied
+ * module, each contributor copied into it, every ttsc overlay the generated
+ * workspace uses, the generic host manifests a proposal substitutes, the
+ * toolchain and build environment Go reads, every `GO*`/`CGO_*` variable the
+ * `go list` process receives, the entries and the fixed command. Paths stay
+ * out, so equal content in another location shares the answer, as the binary
+ * key does.
+ */
+interface ISelectionIdentity {
+  format: 1;
+  command: readonly string[];
+  mode: "proposal" | "actual";
+  module: string;
+  environment: string;
+  variables: [string, string][];
+  manifests: (string | null)[] | null;
+  overlays: string[];
+  entries: [string, string | null, string | null][];
+}
+
+function selectionIdentity(
+  opts: Parameters<typeof NativeSourcePackages.inspect>[0],
+  moduleRoot: string,
+  goBinary: string,
+  env: NodeJS.ProcessEnv,
+  identities: PluginContentIdentities.Store,
+): ISelectionIdentity | undefined {
+  try {
+    const readings = opts.readings ?? {};
+    const directory = (root: string): string => {
+      const resolved = path.resolve(root);
+      let digest = readings.sources?.get(resolved);
+      if (digest === undefined) {
+        digest = PluginContentIdentities.sourceDirectory(identities, resolved);
+        readings.sources?.set(resolved, digest);
+      }
+      return digest;
+    };
+    const resolvedRoot = path.resolve(moduleRoot);
+    let environment = readings.environments?.get(resolvedRoot);
+    if (environment === undefined) {
+      const hash = crypto.createHash("sha256");
+      const witness: PluginBuildEnvironmentWitness.Record = new Map();
+      hashPluginBuildEnvironment(
+        hash,
+        goBinary,
+        moduleRoot,
+        env,
+        { readFile: (location) => fs.readFileSync(location) },
+        witness,
+        identities,
+      );
+      environment = hash.digest("hex");
+      readings.environments?.set(resolvedRoot, environment);
+      readings.witnesses?.set(resolvedRoot, witness);
+    }
+    const host =
+      opts.proposal === true
+        ? resolvePluginGoModule(genericHostSource(), opts.pluginName).moduleRoot
+        : undefined;
+    return {
+      format: 1,
+      command: [
+        "list",
+        ...GoSourceInputs.BUILD_FLAGS,
+        "-find",
+        "-e",
+        SELECTION_FIELDS,
+      ],
+      mode: opts.proposal === true ? "proposal" : "actual",
+      module: directory(moduleRoot),
+      environment,
+      variables: Object.entries(
+        GoSourceInputs.goBuildEnv(goBinary, undefined, env),
+      )
+        .filter(
+          (entry): entry is [string, string] =>
+            entry[1] !== undefined && /^(GO|CGO_)/i.test(entry[0]),
+        )
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)),
+      manifests:
+        host === undefined
+          ? null
+          : ["go.mod", "go.sum"].map((name) =>
+              fileDigest(path.join(host, name)),
+            ),
+      overlays: SourcePluginWorkspace.findTtscOverlayDirs().map(directory),
+      entries: opts.packages.map((input) => [
+        input.entry,
+        input.name ?? null,
+        input.source === undefined ? null : directory(input.source),
+      ]),
+    };
+  } catch {
+    // An identity that cannot be formed only costs the real observation.
+    return undefined;
+  }
+}
+
+/** The digest of every overlay module, in the generated workspace's order. */
+function overlayDigests(
+  identities: PluginContentIdentities.Store | undefined,
+): string[] {
+  return SourcePluginWorkspace.findTtscOverlayDirs().map((directory) =>
+    PluginContentIdentities.sourceDirectory(identities, directory),
+  );
+}
+
+/** A small manifest's content digest, or null when it does not exist. */
+function fileDigest(file: string): string | null {
+  try {
+    return crypto
+      .createHash("sha256")
+      .update(fs.readFileSync(file))
+      .digest("hex");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+/**
+ * A recorded selection rebased onto the module it now describes, or `undefined`
+ * when the record does not have the shape `read` produces.
+ */
+function recallSelection(
+  value: unknown,
+  moduleRoot: string,
+  count: number,
+): NativeSourcePackages.Package[] | undefined {
+  if (!Array.isArray(value) || value.length !== count) return undefined;
+  try {
+    const packages = NativeSourcePackages.parse(
+      value.map((input) => JSON.stringify(input)).join("\n"),
+    );
+    if (packages.length !== count) return undefined;
+    return packages.map((input) => ({
+      ...input,
+      Dir:
+        input.Dir === undefined
+          ? undefined
+          : path.resolve(moduleRoot, input.Dir),
+    }));
+  } catch {
+    return undefined;
+  }
+}

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";
 
 /**
@@ -120,21 +121,46 @@ export namespace PluginBuildEnvironmentReadings {
    * 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;
   }
@@ -148,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.
@@ -160,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;
@@ -168,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)
@@ -200,6 +235,7 @@ export namespace PluginBuildEnvironmentReadings {
   function observe(
     directory: string,
     env: NodeJS.ProcessEnv,
+    projectRoot: string | undefined,
   ): Promise<Reading> {
     const request = queue.then(
       () =>
@@ -240,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);