ttsc 0.32.1 → 0.33.0

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

@@ -21,6 +21,7 @@ import { PluginBuildLockProtocol } from "./PluginBuildLockProtocol";
 import { PluginContentIdentities } from "./PluginContentIdentities";
 import { SourceBuildCacheLayout } from "./SourceBuildCacheLayout";
 import type { SourceBuildFilesystemOperations } from "./SourceBuildFilesystemOperations";
+import { SourcePackageArtifacts } from "./SourcePackageArtifacts";
 import { SourcePluginAdmission } from "./SourcePluginAdmission";
 import { SourcePluginWorkspace } from "./SourcePluginWorkspace";
 import { acquirePluginBuildLock } from "./acquirePluginBuildLock";
@@ -31,6 +32,7 @@ import { ensureExecutableGoToolchain } from "./ensureExecutableGoToolchain";
 import { pluginModuleReplaceDirectories } from "./pluginModuleReplaceDirectories";
 import { pluginSourceDigest } from "./pluginSourceDigest";
 import { pruneGoBuildCacheRoot } from "./pruneGoBuildCacheRoot";
+import { prunePackageArtifactRoot } from "./prunePackageArtifactRoot";
 import { prunePluginCacheRoot } from "./prunePluginCacheRoot";
 import { reclaimPluginBuildLock } from "./reclaimPluginBuildLock";
 import { releasePluginBuildLock } from "./releasePluginBuildLock";
@@ -383,6 +385,11 @@ function buildSourcePluginAttempt(
         pluginName: opts.pluginName,
         quiet,
         source,
+        artifactRoot: path.join(
+          paths.root,
+          SourceBuildCacheLayout.PACKAGE_ARTIFACTS_DIRNAME,
+        ),
+        ttscVersion: opts.ttscVersion,
       });
     },
   );
@@ -447,6 +454,7 @@ const CONTRIB_DIRNAME = "contrib";
 
 /** Run the actual `go build` and publish the binary; assumes the lock is held. */
 function compileSourcePlugin(opts: {
+  artifactRoot: string;
   binaryPath: string;
   cacheDir: string;
   contributors: readonly ITtscBuildContributor[];
@@ -476,6 +484,7 @@ function compileSourcePlugin(opts: {
   pluginName: string;
   quiet: boolean;
   source: string;
+  ttscVersion: string;
 }): string {
   OwnedSynchronousProcess.checkpoint();
   if (!opts.quiet) {
@@ -574,6 +583,8 @@ function compileSourcePlugin(opts: {
     const scratchBinaryName =
       process.platform === "win32" ? ".ttsc-plugin.exe" : ".ttsc-plugin";
     let attemptedGoBuildCacheRoot: string | undefined;
+    let publisherRecording: ReturnType<typeof SourcePackageArtifacts.record> =
+      null;
     try {
       withGoBuildCacheLease(
         opts.goBuildCacheRoot,
@@ -616,16 +627,57 @@ function compileSourcePlugin(opts: {
               );
             });
           }
-          runGoBuild(
-            scratchDir,
-            opts.entry,
-            scratchBinaryName,
-            opts.pluginName,
-            opts.goBinary,
-            goBuildCacheRoot,
-            opts.env,
-            opts.normalizeGoToolPermissions,
-          );
+          const recording = SourcePackageArtifacts.record({
+            cwd: scratchDir,
+            entry: opts.entry,
+            env: GoSourceInputs.goBuildEnv(
+              opts.goBinary,
+              goBuildCacheRoot,
+              opts.env,
+            ),
+            goBinary: opts.goBinary,
+            key: opts.key,
+            pluginName: opts.pluginName,
+            ttscVersion: opts.ttscVersion,
+          });
+          publisherRecording = recording;
+          const artifacts =
+            recording === null
+              ? SourcePackageArtifacts.prepare({
+                  artifactRoot: opts.artifactRoot,
+                  cwd: scratchDir,
+                  entry: opts.entry,
+                  env: GoSourceInputs.goBuildEnv(
+                    opts.goBinary,
+                    goBuildCacheRoot,
+                    opts.env,
+                  ),
+                  goBinary: opts.goBinary,
+                  pluginName: opts.pluginName,
+                  quiet: opts.quiet,
+                  ttscVersion: opts.ttscVersion,
+                })
+              : null;
+          try {
+            runGoBuild(
+              scratchDir,
+              opts.entry,
+              scratchBinaryName,
+              opts.pluginName,
+              opts.goBinary,
+              goBuildCacheRoot,
+              recording?.env ?? artifacts!.env,
+              opts.normalizeGoToolPermissions,
+              recording?.actionGraph,
+            );
+          } finally {
+            if (artifacts !== null)
+              SourcePackageArtifacts.reportUsage(
+                artifacts,
+                opts.pluginName,
+                opts.quiet,
+              );
+          }
           OwnedSynchronousProcess.checkpoint();
           if (process.env.TTSC_E2E_TRACE) {
             E2ETrace.capabilityResolution(
@@ -655,6 +707,7 @@ function compileSourcePlugin(opts: {
         // grow the cache unchecked behind a fresh daily marker. Cancellation
         // still releases the lease and scratch, but admits no new maintenance.
         pruneGoBuildCacheRoot(attemptedGoBuildCacheRoot, { force: true });
+        prunePackageArtifactRoot(attemptedGoBuildCacheRoot, opts.artifactRoot);
       }
     }
     // The toolchain was read for the key before the lock wait and the build,
@@ -685,6 +738,8 @@ function compileSourcePlugin(opts: {
       );
       throw pluginBuildEnvironmentChanged(opts.pluginName);
     }
+    if (publisherRecording !== null)
+      SourcePackageArtifacts.seal(publisherRecording);
     const builtBinary = path.join(scratchDir, scratchBinaryName);
     OwnedSynchronousProcess.checkpoint();
     publishBuiltBinary(builtBinary, opts.binaryPath);
@@ -697,7 +752,14 @@ function compileSourcePlugin(opts: {
     SourceNativeRetirement.releaseResource(
       scratchDir,
       () => {
-        fs.rmSync(scratchDir, { recursive: true, force: true });
+        // Retry transient Windows removal refusals only after native closure
+        // has authorized this resource callback.
+        fs.rmSync(scratchDir, {
+          recursive: true,
+          force: true,
+          maxRetries: 10,
+          retryDelay: 100,
+        });
         SourceNativeRetirement.forget(opts.cacheDir);
       },
       taskFailure,
@@ -1194,12 +1256,20 @@ function runGoBuild(
   goBuildCacheRoot: string,
   env: NodeJS.ProcessEnv,
   normalizeGoToolPermissions: boolean,
+  actionGraph?: string,
 ): void {
   OwnedSynchronousProcess.checkpoint();
   ensureExecutableGoToolchain(goBinary, normalizeGoToolPermissions);
   const result = spawnGoTool(
     goBinary,
-    ["build", ...GoSourceInputs.BUILD_FLAGS, "-o", binaryName, entry],
+    [
+      "build",
+      ...GoSourceInputs.BUILD_FLAGS,
+      ...(actionGraph ? [`-debug-actiongraph=${actionGraph}`] : []),
+      "-o",
+      binaryName,
+      entry,
+    ],
     {
       cwd,
       encoding: "utf8",

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

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { SourceNativeRetirement } from "../../../internal/SourceNativeRetirement";
+import { GoBuildCacheCoordination } from "./GoBuildCacheCoordination";
+import { SourceBuildCacheLayout } from "./SourceBuildCacheLayout";
+
+/**
+ * Reclaim a default-owned package artifact population after size or idle age.
+ *
+ * The entire base and overlay share an eviction generation. A Go-cache
+ * maintenance intent excludes cooperating builders while the native guard
+ * reader retains unknown process-tree outcomes. Explicit cache roots are never
+ * passed here. Metadata accounting is bounded and cannot establish a hard disk
+ * ceiling while another process writes or a protected generation remains.
+ *
+ * @evidence contracts/common.md#principled-implementation The same maintenance and native-guard gates used by the owning Go cache precede deletion of the sibling artifact population.
+ * @evidence contracts/common.md#clear-and-simple-design One idle/size decision reclaims a complete base-and-overlay generation, leaving future builds to prepare a fresh root.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Unknown files, aliases and unresolved native owners refuse reclamation rather than being silently ignored.
+ * @evidence contracts/common.md#meaningful-documentation The comment states whole-generation eviction and its concurrency and accounting limits.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path, directory and metadata APIs inspect ordinary entries on Windows and POSIX.
+ * @evidence contracts/performance.md#efficient-algorithms A bounded metadata walk visits at most 100000 entries and six directory levels; it reads no body bytes.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work This routine decides deletion from mutable ownership and filesystem state, not reusable compilation identity.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Sixteen GiB or 30 idle days triggers best-effort generation removal; active/unknown owners, locked files and errors can defer reclamation without a hard ceiling.
+ */
+export function prunePackageArtifactRoot(
+  goBuildRoot: string,
+  artifactRoot: string,
+  now: number = Date.now(),
+): void {
+  let intent:
+    | GoBuildCacheCoordination.GoBuildCacheCoordinationRecord
+    | undefined;
+  try {
+    const cacheRoot =
+      GoBuildCacheCoordination.canonicalGoBuildCacheRoot(goBuildRoot);
+    const parent = fs.realpathSync.native(path.dirname(artifactRoot));
+    if (
+      parent !== path.dirname(cacheRoot) ||
+      path.basename(artifactRoot) !==
+        SourceBuildCacheLayout.PACKAGE_ARTIFACTS_DIRNAME
+    )
+      return;
+    const info = fs.lstatSync(artifactRoot);
+    if (!info.isDirectory() || info.isSymbolicLink()) return;
+    const physical = fs.realpathSync.native(artifactRoot);
+    if (path.dirname(physical) !== parent) return;
+    if (SourceNativeRetirement.isProtected(physical)) return;
+
+    intent = GoBuildCacheCoordination.createGoBuildCacheCoordinationRecord(
+      cacheRoot,
+      GoBuildCacheCoordination.GO_BUILD_CACHE_MAINTENANCE_DIR,
+    );
+    if (!intent.startHeartbeat()) return;
+    if (
+      GoBuildCacheCoordination.collectLiveGoBuildCacheCoordinationRecords(
+        cacheRoot,
+        GoBuildCacheCoordination.GO_BUILD_CACHE_LEASE_DIR,
+        now,
+      ).length !== 0 ||
+      SourceNativeRetirement.isProtected(physical)
+    )
+      return;
+
+    const marker = path.join(physical, ".last-used");
+    const lastUsed = SourceBuildCacheLayout.readTimestamp(marker);
+    const expired = lastUsed !== null && now - lastUsed > 30 * DAY_MS;
+    const bytes = countArtifactBytes(physical);
+    if (expired || bytes > 16 * GIB) fs.rmSync(physical, { recursive: true });
+  } catch {
+    // A failed ownership observation or locked Windows body defers collection.
+  } finally {
+    intent?.finish();
+  }
+}
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const GIB = 1024 * 1024 * 1024;
+
+function countArtifactBytes(root: string): number {
+  let entries = 0;
+  let total = 0;
+  const walk = (directory: string, depth: number): void => {
+    if (depth > 6) throw new Error("artifact directory depth exceeds policy");
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (++entries > 100000)
+        throw new Error("artifact entry count exceeds policy");
+      const child = path.join(directory, entry.name);
+      const info = fs.lstatSync(child);
+      if (info.isSymbolicLink()) throw new Error("aliased artifact entry");
+      if (info.isDirectory()) walk(child, depth + 1);
+      else if (info.isFile()) total += info.size;
+      else throw new Error("unknown artifact entry");
+      if (!Number.isSafeInteger(total))
+        throw new Error("artifact size exceeds policy");
+    }
+  };
+  walk(root, 0);
+  return total;
+}

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

@@ -55,6 +55,7 @@ export function resolveCleanTargets(
   if (isTtscOwnedRoot) {
     targets.push(
       path.join(paths.root, SourceBuildCacheLayout.GO_BUILD_CACHE_DIRNAME),
+      path.join(paths.root, SourceBuildCacheLayout.PACKAGE_ARTIFACTS_DIRNAME),
     );
   }
   // An explicit TTSC_GO_CACHE_DIR is a ttsc-dedicated external cache; a

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

@@ -94,8 +94,10 @@ function resolveSourceBuildCacheRoot(
  * Walks up from `projectRoot` and returns, in order of preference: the NEAREST
  * ancestor that is a workspace root (holds `pnpm-workspace.yaml`, or a
  * `package.json` with a `workspaces` field); else the nearest ancestor that
- * contains an installation; else the outermost ttsc-only cache owner at or
- * below the nearest ordinary package manifest, or `projectRoot` itself.
+ * contains an installation within the package boundary; else the outermost
+ * ttsc-only cache owner at or below the nearest ordinary package manifest, or
+ * `projectRoot` itself. An unrelated ancestor's installation without its own
+ * package manifest cannot take ownership after a package boundary is crossed.
  *
  * A nonempty, unmarked ttsc-only `.cache/ttsc` payload is fallback cache
  * evidence rather than an installation. Empty or marked ttsc roots remain
@@ -116,13 +118,18 @@ function resolveWorkspaceRoot(projectRoot: string): string {
     if (isWorkspaceRootDir(dir)) {
       return dir;
     }
+    const packageHere = hasPackageManifest(dir);
     const nodeModules = classifyNodeModulesBoundary(dir);
-    if (nearestNodeModulesOwner === null && nodeModules === "installation") {
+    if (
+      nearestNodeModulesOwner === null &&
+      nodeModules === "installation" &&
+      (!packageBoundarySeen || packageHere)
+    ) {
       nearestNodeModulesOwner = dir;
     } else if (nodeModules === "ttsc-cache" && !packageBoundarySeen) {
       outermostTtscCacheOwner = dir;
     }
-    packageBoundarySeen ||= hasPackageManifest(dir);
+    packageBoundarySeen ||= packageHere;
     const parent = path.dirname(dir);
     if (parent === dir) {
       break;

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

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Return an existing ordinary identities directory below a selected record
+ * root, or leave temporary placement to the caller's system default.
+ *
+ * The returned physical path is a direct child of the selected root. The caller
+ * still uses createCanonicalTempDirectory to verify its own allocation; these
+ * observations do not hold the namespace against later mutation.
+ *
+ * @evidence contracts/common.md#principled-implementation Native realpath and link-preserving stat admit only a present ordinary identities directory whose physical parent is the selected root; an unproved path supplies no alternate temporary parent.
+ * @evidence contracts/common.md#clear-and-simple-design One small selector shares the same record-root placement rule between descriptor evaluation and child output capture; allocation and cleanup remain with their respective owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The function neither creates a cache root nor accepts a linked identities entry as evidence of an owned child; failed observations retain the ordinary caller path.
+ * @evidence contracts/common.md#meaningful-documentation The comment states the selected-root premise, returned physical path and remaining namespace race without claiming held-directory protection.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native path and filesystem APIs observe the actual root and child without assuming case policy or a fixed temporary volume; a junctioned selected root can resolve to its physical directory, while the identities entry itself must be ordinary.
+ * @evidence contracts/performance.md#efficient-algorithms A fixed number of native path observations and path-text operations selects the parent without enumeration; lookup depth and path length determine their underlying cost.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A record root or identities entry can be replaced between calls, so each allocation needs current observations instead of a remembered parent.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The selector acquires no handle or directory and retains no state; its returned path is caller-owned text.
+ */
+export function selectedRecordIdentityTempParent(
+  recordRoot: string | undefined,
+): string | undefined {
+  if (recordRoot === undefined || !path.isAbsolute(recordRoot))
+    return undefined;
+  try {
+    const physicalRoot = fs.realpathSync.native(recordRoot);
+    if (!fs.lstatSync(physicalRoot).isDirectory()) return undefined;
+    const identities = path.join(recordRoot, "identities");
+    const identityStats = fs.lstatSync(identities);
+    if (!identityStats.isDirectory() || identityStats.isSymbolicLink())
+      return undefined;
+    const physicalIdentities = fs.realpathSync.native(identities);
+    return path.dirname(physicalIdentities) === physicalRoot
+      ? physicalIdentities
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}