ttsc 0.31.0 → 0.31.1

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

@@ -8,13 +8,12 @@ import { OwnedSynchronousProcess } from "../../../internal/OwnedSynchronousProce
 import { SourceNativeRetirement } from "../../../internal/SourceNativeRetirement";
 import { createCanonicalTempDirectory } from "../../../internal/createCanonicalTempDirectory";
 import { runHoldingLock } from "../../../internal/runHoldingLock";
-import { NativeSourcePackages } from "./NativeSourcePackages";
-import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { GoSourceInputs } from "./GoSourceInputs";
 import { GoToolResolution } from "./GoToolResolution";
 import type { IPluginModuleReplaceDirectory } from "./IPluginModuleReplaceDirectory";
 import type { ITtscBuildContributor } from "./ITtscBuildContributor";
 import type { ITtscSourceBuildCachePaths } from "./ITtscSourceBuildCachePaths";
+import { NativeSourcePackages } from "./NativeSourcePackages";
 import { PluginBinaryUse } from "./PluginBinaryUse";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
 import type { PluginBuildLockLease } from "./PluginBuildLockLease";
@@ -22,6 +21,7 @@ import { PluginBuildLockProtocol } from "./PluginBuildLockProtocol";
 import { SourceBuildCacheLayout } from "./SourceBuildCacheLayout";
 import type { SourceBuildFilesystemOperations } from "./SourceBuildFilesystemOperations";
 import { SourcePluginAdmission } from "./SourcePluginAdmission";
+import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { acquirePluginBuildLock } from "./acquirePluginBuildLock";
 import { computeCacheKey } from "./computeCacheKey";
 import { copiesPluginSourceEntry } from "./copiesPluginSourceEntry";
@@ -44,12 +44,12 @@ import { withGoBuildCacheLease } from "./withGoBuildCacheLease";
  * Build one Go source plugin into a cached executable.
  *
  * `opts.env` is the effective environment for this build; the caller merges
- * inherited and constructor layers using native environment-name identity so
- * a programmatic `TtscCompiler` instance
- * can pin its own Go toolchain (`TTSC_GO_BINARY`), Go build cache
- * (`TTSC_GO_CACHE_DIR`), and Go build variables (`GOFLAGS`, `CGO_*`, …) without
- * mutating the shared `process.env`. CLI callers omit it and inherit
- * `process.env`, so ambient behavior is unchanged.
+ * inherited and constructor layers using native environment-name identity so a
+ * programmatic `TtscCompiler` instance can pin its own Go toolchain
+ * (`TTSC_GO_BINARY`), Go build cache (`TTSC_GO_CACHE_DIR`), and Go build
+ * variables (`GOFLAGS`, `CGO_*`, …) without mutating the shared `process.env`.
+ * CLI callers omit it and inherit `process.env`, so ambient behavior is
+ * unchanged.
  *
  * The cache key includes source and toolchain readings. Before publication the
  * scratch inputs are compared with their recorded digests and the external
@@ -65,16 +65,16 @@ import { withGoBuildCacheLease } from "./withGoBuildCacheLease";
  * Optional loader-required package ownership enters the key. Its cold producer
  * admits the entry and linked sources through Go metadata in the actual
  * materialized workspace before compilation; legacy cache artifacts have a
- * different key. Existing binary hits trust the cache producer and key rather than rehashing
- * executable bytes. Default caches are managed locally, while explicit roots
- * retain caller-managed pruning policy. Every returned cache key registers a
- * reader token retained by this process until exit; registration shares the
- * builder/collector lease, and other consumers register independent readers.
- * Failure to establish ownership propagates. Private opt-in tracing records the
- * mandatory key-creation and pre-build witness gates and adds one diagnostic
- * observation after Go returns. That diagnostic read adds metadata work, not
- * publication permission. A discarded epoch is separately recorded when the
- * bounded build owner starts again.
+ * different key. Existing binary hits trust the cache producer and key rather
+ * than rehashing executable bytes. Default caches are managed locally, while
+ * explicit roots retain caller-managed pruning policy. Every returned cache key
+ * registers a reader token retained by this process until exit; registration
+ * shares the builder/collector lease, and other consumers register independent
+ * readers. Failure to establish ownership propagates. Private opt-in tracing
+ * records the mandatory key-creation and pre-build witness gates and adds one
+ * diagnostic observation after Go returns. That diagnostic read adds metadata
+ * work, not publication permission. A discarded epoch is separately recorded
+ * when the bounded build owner starts again.
  *
  * Explicit worker scopes check cancellation between build phases, copied source
  * entries and native commands, including reader admission and final
@@ -101,7 +101,10 @@ export function buildSourcePlugin(opts: {
   env?: NodeJS.ProcessEnv;
 
   /** Loader-required ownership of the entry and named linked packages. */
-  packageOwnership?: readonly { entry: string; kind: "executable" | "linked" }[];
+  packageOwnership?: readonly {
+    entry: string;
+    kind: "executable" | "linked";
+  }[];
 
   /**
    * Digests of the environment each build directory is keyed on, shared by
@@ -123,6 +126,9 @@ export function buildSourcePlugin(opts: {
    */
   sourceDigests?: Map<string, string>;
 
+  /** Pinned-tool manifest readers shared only by this loader request. */
+  goModReaders?: Map<string, SourcePluginWorkspace.GoModReader>;
+
   ttscVersion: string;
   tsgoVersion: string;
 }): string {
@@ -136,7 +142,7 @@ export function buildSourcePlugin(opts: {
     const environmentDigests = new Map(opts.environmentDigests);
     try {
       const binary = buildSourcePluginAttempt(
-        opts,
+        attempt === 0 ? opts : { ...opts, goModReaders: undefined },
         env,
         sourceDigests,
         environmentDigests,
@@ -174,7 +180,9 @@ function buildSourcePluginAttempt(
 ): string {
   OwnedSynchronousProcess.checkpoint();
   const { dir, entry, source } = resolveSourceBuildTarget(opts);
-  const overlayDirs = [...(opts.overlayDirs ?? SourcePluginWorkspace.findTtscOverlayDirs())].sort();
+  const overlayDirs = [
+    ...(opts.overlayDirs ?? SourcePluginWorkspace.findTtscOverlayDirs()),
+  ].sort();
   const contributors = opts.contributors ?? [];
   const compiler = resolveGoCompiler(env);
   const goBinary = GoToolResolution.resolveGoToolForBuild(
@@ -186,6 +194,12 @@ function buildSourcePluginAttempt(
   OwnedSynchronousProcess.checkpoint();
   // The digest of every directory the key covers, as the key read it, which
   // the build proves against what it compiled.
+  const goModReader = SourcePluginWorkspace.createGoModReader(
+    goBinary,
+    opts.pluginName,
+    env,
+    opts.goModReaders,
+  );
   const environmentWitness: PluginBuildEnvironmentWitness.Record = new Map();
   const key = computeCacheKey({
     contributors,
@@ -194,6 +208,7 @@ function buildSourcePluginAttempt(
     entry,
     env,
     environmentWitness,
+    goModReader,
     filesystem: opts.filesystem,
     goBinary,
     overlayDirs,
@@ -317,6 +332,7 @@ function buildSourcePluginAttempt(
         env,
         environmentWitness,
         goBinary,
+        goModReader,
         normalizeGoToolPermissions: compiler.bundled,
         key,
         keyedDigests: sourceDigests,
@@ -394,7 +410,10 @@ function compileSourcePlugin(opts: {
   binaryPath: string;
   cacheDir: string;
   contributors: readonly ITtscBuildContributor[];
-  packageOwnership?: readonly { entry: string; kind: "executable" | "linked" }[];
+  packageOwnership?: readonly {
+    entry: string;
+    kind: "executable" | "linked";
+  }[];
   dir: string;
   entry: string;
   env: NodeJS.ProcessEnv;
@@ -406,6 +425,7 @@ function compileSourcePlugin(opts: {
   goBuildCacheRoot: string;
   manageGoBuildCache: boolean;
   normalizeGoToolPermissions: boolean;
+  goModReader: SourcePluginWorkspace.GoModReader;
   key: string;
 
   /** The digest of every directory the key covers, as the key read it. */
@@ -461,6 +481,7 @@ function compileSourcePlugin(opts: {
       opts.dir,
       opts.env,
       opts.goBinary,
+      opts.goModReader,
     );
     OwnedSynchronousProcess.checkpoint();
     // Every source the build would otherwise read in place, an overlay and
@@ -487,11 +508,7 @@ function compileSourcePlugin(opts: {
       opts.goBinary,
       opts.env,
     );
-    const goModReader = SourcePluginWorkspace.createGoModReader(
-      opts.goBinary,
-      opts.pluginName,
-      opts.env,
-    );
+    const goModReader = opts.goModReader;
     OwnedSynchronousProcess.checkpoint();
     if (opts.contributors.length > 0) {
       mergeContributors({
@@ -543,12 +560,20 @@ function compileSourcePlugin(opts: {
             const observations = NativeSourcePackages.read({
               cwd: scratchDir,
               entries: opts.packageOwnership.map((input) => input.entry),
-              env: GoSourceInputs.goBuildEnv(opts.goBinary, goBuildCacheRoot, opts.env),
+              env: GoSourceInputs.goBuildEnv(
+                opts.goBinary,
+                goBuildCacheRoot,
+                opts.env,
+              ),
               goBinary: opts.goBinary,
               pluginName: opts.pluginName,
             });
             opts.packageOwnership.forEach((input, index) => {
-              NativeSourcePackages.kind(observations[index]!, `${opts.pluginName} ${input.entry}`, input.kind);
+              NativeSourcePackages.kind(
+                observations[index]!,
+                `${opts.pluginName} ${input.entry}`,
+                input.kind,
+              );
             });
           }
           runGoBuild(
@@ -629,10 +654,14 @@ function compileSourcePlugin(opts: {
     taskFailure = { error };
     throw error;
   } finally {
-    SourceNativeRetirement.releaseResource(scratchDir, () => {
-      fs.rmSync(scratchDir, { recursive: true, force: true });
-      SourceNativeRetirement.forget(opts.cacheDir);
-    }, taskFailure);
+    SourceNativeRetirement.releaseResource(
+      scratchDir,
+      () => {
+        fs.rmSync(scratchDir, { recursive: true, force: true });
+        SourceNativeRetirement.forget(opts.cacheDir);
+      },
+      taskFailure,
+    );
   }
 }
 
@@ -1009,7 +1038,6 @@ function resolveSourceBuildTarget(opts: {
   return { dir: moduleRoot, entry, source };
 }
 
-
 /**
  * The path, below a build's scratch directory, of the tree holding its copies
  * of the sources outside the module.

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

@@ -6,6 +6,7 @@ import { GoToolResolution } from "./GoToolResolution";
 import type { ITtscBuildContributor } from "./ITtscBuildContributor";
 import type { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
 import type { SourceBuildFilesystemOperations } from "./SourceBuildFilesystemOperations";
+import type { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { hashPluginBuildEnvironment } from "./hashPluginBuildEnvironment";
 import { pluginModuleReplaceDirectories } from "./pluginModuleReplaceDirectories";
 import { pluginSourceDigest } from "./pluginSourceDigest";
@@ -20,8 +21,8 @@ import { pluginSourceDigest } from "./pluginSourceDigest";
  * source files. An optional required package-ownership population also frames
  * the key, separating binaries admitted by the matching cold producer from
  * legacy artifacts; requests without that authority retain their existing key.
- * Contributors are sorted by name; unique names remove input
- * order dependence, while equal-name rows retain the sort's input order.
+ * Contributors are sorted by name; unique names remove input order dependence,
+ * while equal-name rows retain the sort's input order.
  *
  * Each source directory enters the key as its digest (`pluginSourceDigest`),
  * which the transform envelope reports, with the environment below, as the
@@ -53,7 +54,10 @@ export function computeCacheKey(inputs: {
   env?: NodeJS.ProcessEnv;
 
   /** Required package ownership, admitted by the matching cold producer. */
-  packageOwnership?: readonly { entry: string; kind: "executable" | "linked" }[];
+  packageOwnership?: readonly {
+    entry: string;
+    kind: "executable" | "linked";
+  }[];
 
   /**
    * Digests of the environment each build directory is keyed on
@@ -72,6 +76,7 @@ export function computeCacheKey(inputs: {
   /** Byte adapter for delegated SDK identity; plugin source digests use fs. */
   filesystem?: Partial<SourceBuildFilesystemOperations>;
   goBinary?: string;
+  goModReader?: SourcePluginWorkspace.GoModReader;
   overlayDirs?: readonly string[];
 
   /**
@@ -102,11 +107,23 @@ export function computeCacheKey(inputs: {
   hash.update(JSON.stringify(["platform", process.platform, process.arch]));
   hash.update(JSON.stringify(["entry", inputs.entry]));
   if (inputs.packageOwnership !== undefined)
-    hash.update(JSON.stringify(["package-ownership", 1,
-      [...inputs.packageOwnership].sort((left, right) =>
-        left.entry < right.entry ? -1 : left.entry > right.entry ? 1 :
-          left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0),
-    ]));
+    hash.update(
+      JSON.stringify([
+        "package-ownership",
+        1,
+        [...inputs.packageOwnership].sort((left, right) =>
+          left.entry < right.entry
+            ? -1
+            : left.entry > right.entry
+              ? 1
+              : left.kind < right.kind
+                ? -1
+                : left.kind > right.kind
+                  ? 1
+                  : 0,
+        ),
+      ]),
+    );
   // Private materialization changes native package working directories. Keep
   // binaries produced by the former absolute-ancestry layout out of this
   // layout's cache admissions, including callers with no SDK overlays.
@@ -139,6 +156,7 @@ export function computeCacheKey(inputs: {
     inputs.dir,
     env,
     goBinary,
+    inputs.goModReader,
   )) {
     hashSourceDirectory(
       hash,

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

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
+import { GoEnvironmentReading } from "./GoEnvironmentReading";
 import { GoSourceInputs } from "./GoSourceInputs";
 import { GoToolResolution } from "./GoToolResolution";
 import { PluginBuildEnvironmentWitness } from "./PluginBuildEnvironmentWitness";
@@ -377,7 +378,13 @@ function resolveGoBuildEnvironment(
 ): Map<string, string> {
   const values = new Map<string, string>();
   if (goBinary !== undefined) {
-    const parsed = readGoEnvironment(goBinary, cwd, env, witness);
+    const parsed = GoEnvironmentReading.read(
+      goBinary,
+      cwd,
+      env,
+      GO_BUILD_ENV_KEYS,
+      witness,
+    );
     if (parsed !== undefined) {
       try {
         for (const key of GO_BUILD_ENV_KEYS) {
@@ -408,81 +415,6 @@ function resolveGoBuildEnvironment(
   return values;
 }
 
-/**
- * The Go environment file each Go tool and environment was last seen to name,
- * which lets a reading witness that file before `go env` reads it.
- */
-const goEnvironmentFiles = new Map<string, string | null>();
-
-/**
- * Run `go env -json` for the build keys and `GOENV`, the file `go env -w`
- * writes, witnessing that file before the run reads it.
- *
- * The file decides the reading without being part of it, so only its metadata
- * is kept, and it must be taken before the read: metadata taken after would
- * describe an edit that landed between the two, and a reading of the old
- * content would pass as proven. Which file `go env` reads is known only from
- * its answer, so the file this Go tool and environment named last is witnessed
- * first, and a reading that names another is taken again with that 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.
- *
- * @returns The parsed answer, or `undefined` when `go env` failed.
- */
-function readGoEnvironment(
-  goBinary: string,
-  cwd: string,
-  env: NodeJS.ProcessEnv,
-  witness: PluginBuildEnvironmentWitness.Record | undefined,
-): Record<string, unknown> | undefined {
-  const memo = crypto.createHash("sha256").update(goBinary);
-  for (const [key, value] of Object.entries(env).sort(([left], [right]) =>
-    left < right ? -1 : left > right ? 1 : 0,
-  )) {
-    if (value !== undefined)
-      memo.update(`\0${key.length}:${key}${value.length}:${value}`);
-  }
-  const memoKey = memo.digest("hex");
-  let named = goEnvironmentFiles.get(memoKey);
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    if (named !== undefined && named !== null)
-      PluginBuildEnvironmentWitness.add(witness, named);
-    const result = spawnGoTool(
-      goBinary,
-      ["env", "-json", ...GO_BUILD_ENV_KEYS, "GOENV"],
-      {
-        cwd,
-        encoding: "utf8",
-        env: GoSourceInputs.goBuildEnv(goBinary, undefined, env),
-        windowsHide: true,
-      },
-    );
-    if (result.error !== undefined || result.status !== 0) return undefined;
-    let parsed: Record<string, unknown>;
-    try {
-      parsed = JSON.parse(result.stdout) as Record<string, unknown>;
-    } catch {
-      return undefined;
-    }
-    const reported =
-      typeof parsed.GOENV === "string" &&
-      parsed.GOENV !== "" &&
-      parsed.GOENV !== "off"
-        ? parsed.GOENV
-        : null;
-    if (reported === 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 !== undefined && named !== null)
-    PluginBuildEnvironmentWitness.refuse(witness, named);
-  return undefined;
-}
-
 function normalizeGoBuildEnvValue(
   key: string,
   value: string,

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

@@ -2,12 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { resolvePhysicalPath } from "../../../internal/pathIdentity/resolvePhysicalPath";
-import { GoSourceInputs } from "./GoSourceInputs";
 import { GoToolResolution } from "./GoToolResolution";
 import type { IPluginModuleReplaceDirectory } from "./IPluginModuleReplaceDirectory";
+import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { resolveGoCompiler } from "./resolveGoCompiler";
 import { selectPluginModuleReplaceDirectories } from "./selectPluginModuleReplaceDirectories";
-import { spawnGoTool } from "./spawnGoTool";
 
 /**
  * The local directories outside a plugin's Go module that its `go.mod`
@@ -38,19 +37,21 @@ import { spawnGoTool } from "./spawnGoTool";
  *   fails or supplies an unusable JSON result. A no-marker manifest skips Go
  *   parsing here; this is not general go.mod validation.
  * @evidence contracts/common.md#principled-implementation When the replace marker triggers a query, Go parses its grammar. Unversioned local targets selected outside best-effort root/target spellings are reported, resolving relative paths from the original module; unavailable identity resolution does not certify complete physical containment.
- * @evidence contracts/common.md#clear-and-simple-design A cheap no-replace scan avoids an unnecessary subprocess, while Go JSON parsing and physical containment stay in one owning operation.
+ * @evidence contracts/common.md#clear-and-simple-design A cheap no-replace scan avoids unnecessary parsing; the common selected-tool/load reader owns Go syntax, and this operation owns current physical containment.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The implementation uses Go's supported mod-edit interface instead of a handwritten grammar or special-casing particular dependency names.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain external versus internal replacement ownership, original-directory resolution and returned spellings; failure behavior is documented.
  * @evidence contracts/portability.md#os-neutral-implementation Node path and physical-path resolution determine containment; Go local-path syntax accepts native absolute paths and Windows-relative backslashes only on Windows.
- * @evidence contracts/performance.md#efficient-algorithms Full manifest read/UTF-8 marker scan can skip Go parsing. Otherwise native tool/env/capture and full JSON work precede a pass over all parsed directives, not only returned ones; each selected local target uses native best-effort identity resolution, which can traverse ancestors/probe case. Sorting returned module/version strings processes their bytes, with complete manifest/output/path arrays retained transiently and no replacement content digest scan here.
+ * @evidence contracts/performance.md#efficient-algorithms Full manifest read/UTF-8 marker scan can skip Go parsing. Otherwise selected-tool reader acquisition and a current manifest read precede a pass over all parsed directives, not only returned ones. Equivalent bytes share Go JSON acquisition only in the supplied fixed-environment load registry; a new syntax record pays native tool/env/capture and full JSON costs; each selected local target uses native best-effort identity resolution, which can traverse ancestors/probe case. Sorting returned module/version strings processes their bytes, with complete manifest/output/path arrays retained transiently and no replacement content digest scan here.
  *
- * @evidenceExclude contracts/performance.md#reuse-equivalent-work This reader establishes the current module directives; callers share resulting source readings in computeCacheKey, not a stale directive memo here.
- * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires no retained handle or historical registry; spawnGoTool owns synchronous capture and its cleanup attempts, which can fail. Manifest/JSON/native identity contexts are call-owned and selected records transfer to the caller without pinning future directory state.
+ * @evidence contracts/performance.md#reuse-equivalent-work The optional pinned-tool/load reader or registry shares Go parsing of identical current bytes with package observation and workspace creation. Physical replacement containment is recomputed every call, never borrowed from that syntax memo.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation acquires no retained handle; the supplied load registry retains syntax readers until its caller releases the load. Without it the reader is call-owned. Native capture cleanup remains delegated and can fail; current physical identity contexts are call-owned and returned directories do not pin future state.
  */
 export function pluginModuleReplaceDirectories(
   moduleRoot: string,
   env: NodeJS.ProcessEnv,
   goBinary?: string,
+  reader?: SourcePluginWorkspace.GoModReader,
+  readers?: Map<string, SourcePluginWorkspace.GoModReader>,
 ): IPluginModuleReplaceDirectory[] {
   const root = path.resolve(moduleRoot);
   let text: string;
@@ -70,27 +71,14 @@ export function pluginModuleReplaceDirectories(
       env,
       root,
     );
-  const result = spawnGoTool(go, ["mod", "edit", "-json"], {
-    cwd: root,
-    encoding: "utf8",
-    env: GoSourceInputs.goBuildEnv(go, undefined, env),
-    windowsHide: true,
-  });
-  if (result.error !== undefined || result.status !== 0)
-    throw new Error(
-      `ttsc: reading ${path.join(root, "go.mod")} failed: ${
-        result.error?.message ?? (result.stderr || result.stdout)
-      }`,
-    );
-  const parsed = JSON.parse(result.stdout) as {
-    Replace?: readonly {
-      New?: { Path?: string; Version?: string };
-      Old?: { Path?: string; Version?: string };
-    }[];
-  };
+  const parsed = (
+    reader ?? SourcePluginWorkspace.createGoModReader(go, root, env, readers)
+  ).read(root);
+  // Parsed syntax may be shared; physical containment is current native state
+  // and must be recomputed even when these manifest bytes are unchanged.
   return selectPluginModuleReplaceDirectories(
     root,
-    parsed.Replace ?? [],
+    parsed.directives,
     resolvePhysicalPath,
   );
 }