ttsc 0.31.0 → 0.31.2

package/src/plugin/internal/CapabilityResolutionFormat.ts

@@ -1,27 +1,29 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
 import path from "node:path";
 
 import { SidecarEnvironment } from "../../compiler/internal/sharedHost/SidecarEnvironment";
 import { runtimeExecutableIdentity } from "../../internal/runtimeExecutableIdentity";
+import type { PluginContentIdentities } from "./source/PluginContentIdentities";
 import { SourceBuildCacheLayout } from "./source/SourceBuildCacheLayout";
 import { resolveSourceBuildCachePaths } from "./source/resolveSourceBuildCachePaths";
 
 /**
  * The on-disk format of the capability-resolution cache, shared by its reader
- * and writer so both agree on the entry's location, version tag, and how a
- * plugin source's metadata signature is taken. What proves an entry still
- * describes the project is the host inputs' states and the plugin sources'
- * states, each by the rule its producer applies.
+ * and writer so both agree on the entry's location and version tag. What proves
+ * an entry still describes the project is the host inputs' states and the
+ * plugin sources' states, each by the rule its producer applies; a plugin
+ * source's metadata signature and the clock reference it is judged against
+ * belong to `PluginContentIdentities`, which every cross-process plugin proof
+ * shares.
  *
- * @evidence contracts/common.md#principled-implementation Reader and writer share format/key and source-metadata witness rules. Metadata acceleration requires a matching device and older reported mtime, relying on native metadata/clock semantics rather than certifying arbitrary timestamp restoration or content mutation.
- * @evidence contracts/common.md#clear-and-simple-design The namespace owns format identity and witness construction, while entry acceptance and answer production stay with their reader/writer.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Version tags and NUL delimiters encode the persistence contract; unavailable clock/device evidence causes full content proof rather than guessed reuse.
- * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains format evolution, unforgeable path separation and clock proof premises in separate paragraphs; function/tag spacing follows the documentation skill.
- * @evidence contracts/portability.md#os-neutral-implementation Native path joins, cache-root resolution and bigint stat device identities preserve OS-neutral filesystem behavior; clock witnesses are matched per device rather than assumed from platform names.
- * @evidence contracts/performance.md#efficient-algorithms Key construction orders and serializes environment/name bytes, streams runtime content and delegates native ancestor/manifest/cache-layout selection. Clock witnesses create/query/remove a probe, and each source witness queries native metadata and formats numeric text; path/native/text costs remain distinct from source-content proof owned by the reader.
- * @evidence contracts/performance.md#reuse-equivalent-work Project/version keys share one answer across requested capabilities; digest reuse additionally requires matching signature and device-clock separation.
- * @evidence contracts/performance.md#bound-retention-and-release-resources Clock probes are call-owned and removed in finally; cache entries belong to the source-cache pruning owner rather than a process-global answer collection. Failed probe removal can leave a small file and is best effort.
+ * @evidence contracts/common.md#principled-implementation Reader and writer share format/key rules; source-metadata witnesses come from the shared identity owner, so this cache and the build path apply one separable-stamp rule.
+ * @evidence contracts/common.md#clear-and-simple-design The namespace owns format identity and entry location, while entry acceptance, answer production and metadata witnesses stay with their owners.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Version tags and NUL delimiters encode the persistence contract rather than guessed reuse.
+ * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains format evolution, unforgeable path separation and the witness owner in separate paragraphs; function/tag spacing follows the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path joins and cache-root resolution preserve OS-neutral filesystem behavior.
+ * @evidence contracts/performance.md#efficient-algorithms Key construction orders and serializes environment/name bytes, streams runtime content and delegates native ancestor/manifest/cache-layout selection.
+ * @evidence contracts/performance.md#reuse-equivalent-work Project/version keys share one answer across requested capabilities.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Cache entries belong to the source-cache pruning owner; this namespace retains nothing.
  */
 export namespace CapabilityResolutionFormat {
   /**
@@ -106,6 +108,13 @@ export namespace CapabilityResolutionFormat {
 
     /** Effective environment selecting workspace-local or explicit storage. */
     env?: NodeJS.ProcessEnv;
+
+    /**
+     * Record store of the project's plugin cache. WARNING (#1725): without it
+     * every lookup streamed the whole runtime executable, several times per
+     * capability resolution, in every process.
+     */
+    identities?: PluginContentIdentities.Store;
   }): string | null {
     const environment = SidecarEnvironment.merge(options.env ?? process.env);
     const runtime =
@@ -115,7 +124,7 @@ export namespace CapabilityResolutionFormat {
     let root: string;
     let runtimeIdentity: string;
     try {
-      const observed = runtimeExecutableIdentity(runtime);
+      const observed = runtimeExecutableIdentity(runtime, options.identities);
       if (observed === undefined) return null;
       runtimeIdentity = observed;
       root = resolveSourceBuildCachePaths(
@@ -152,97 +161,4 @@ export namespace CapabilityResolutionFormat {
       `${key}.json`,
     );
   }
-
-  /**
-   * A clock reference for plugin source signatures, minted by a write of the
-   * cache's own beside the entry: the modification stamp a fresh probe file got
-   * there, by the device that reported it.
-   *
-   * A stamp strictly older than the same device's fresh reference satisfies
-   * this cache's separation policy. Reuse still assumes the filesystem's
-   * reported metadata reflects writes; the comparison cannot certify arbitrary
-   * timestamp restoration or future clock behavior. The probe is the cache's
-   * own file, named for this call, and removal is attempted at once, so
-   * concurrent readers never lend each other a reference. A failed write, or a
-   * plugin source on another device, leaves nothing separable, and the proof
-   * reads the files.
-   *
-   * @param entry The entry file, whose directory the probe is written in.
-   * @evidence contracts/common.md#principled-implementation A unique freshly-written file supplies its native device/mtime reference; acquisition failure clears the witness, and the source observer requires a matching device and strictly older reported stamp under the metadata policy.
-   * @evidence contracts/common.md#clear-and-simple-design The function returns only device-to-stamp evidence and owns its transient probe from creation through cleanup.
-   * @evidence contracts/common.md#prohibited-implementation-shortcuts Random probe identity avoids borrowing a concurrent call's witness; failed acquisition does not substitute wall-clock guesses for device evidence.
-   * @evidence contracts/common.md#meaningful-documentation Native JSDoc explains ended ticks, cross-device refusal and probe lifetime in separate paragraphs; tag separation follows the documentation skill.
-   * @evidence contracts/portability.md#os-neutral-implementation Native joins and bigint lstat use the actual filesystem's device/stamp values; no fixed timestamp precision or OS-specific temp path is assumed.
-   * @evidence contracts/performance.md#efficient-algorithms Probe path/UUID/hrtime text construction and mkdir/write/lstat/removal queries produce a witness without reading plugin source bytes; native path/directory work remains and is not bounded by source count.
-   *
-   * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each proof needs a fresh clock reference; sharing an earlier probe would defeat the rollback/separation premise.
-   *
-   * @evidence contracts/performance.md#bound-retention-and-release-resources The unique call-owned probe is removed in finally even after acquisition failure; removal is best effort and the returned map contains at most its single observed device.
-   */
-  export function clockReference(entry: string): ReadonlyMap<bigint, bigint> {
-    const references = new Map<bigint, bigint>();
-    const probe = path.join(
-      path.dirname(entry),
-      `clock-${process.pid}-${crypto.randomUUID()}.probe`,
-    );
-    try {
-      fs.mkdirSync(path.dirname(probe), { recursive: true });
-      fs.writeFileSync(probe, `${process.hrtime.bigint()}\n`);
-      const stats = fs.lstatSync(probe, { bigint: true });
-      references.set(stats.dev, stats.mtimeNs);
-    } catch {
-      references.clear();
-    } finally {
-      try {
-        fs.rmSync(probe, { force: true });
-      } catch {
-        // A leftover probe contains this call's hrtime text, not source data.
-      }
-    }
-    return references;
-  }
-
-  /**
-   * One plugin source file's metadata signature, and whether its stamp is
-   * separable from `reference`, for `pluginSourceFilesSignature`.
-   *
-   * The files the digest reads are regular files (`collectPluginSourceFiles`),
-   * so these fields are the observer's metadata signature. Native metadata
-   * reflecting a write/replacement is a reuse premise; the signature is not
-   * itself a content hash or proof against arbitrary timestamp restoration.
-   *
-   * @param reference The clock reference minted for this proof.
-   * @evidence contracts/common.md#principled-implementation lstat device/inode/link/mode/size/timestamps form the regular-file metadata signature; strict mtime-before-reference marks separation for a matching device under the cache's native metadata policy, without observing content.
-   * @evidence contracts/common.md#clear-and-simple-design A closure carries one proof's device references and maps each requested file to signature/separation together.
-   * @evidence contracts/common.md#prohibited-implementation-shortcuts Unreadable files return no witness, and unmatched device or same/newer stamps cannot authorize digest reuse.
-   * @evidence contracts/common.md#meaningful-documentation Native JSDoc states the regular-file premise and reference origin, with separate acknowledgment prose following the documentation skill.
-   * @evidence contracts/portability.md#os-neutral-implementation Metadata comes from native bigint lstat and actual device IDs; separators join numeric fields only and no host path is manually parsed.
-   * @evidence contracts/performance.md#efficient-algorithms Each invocation performs native path/lstat work and formats seven bigint fields without reading content; fixed field count does not remove native lookup or numeric-text costs.
-   * @evidence contracts/performance.md#reuse-equivalent-work The closure reuses one reference map across files in the same proof, while each file's current metadata is read anew.
-   * @evidence contracts/performance.md#bound-retention-and-release-resources The closure retains the supplied reference map until its consumer releases it; clockReference supplies at most one entry, but arbitrary callers can supply larger or mutable maps. No file handle/global source population is retained and reference immutability is a caller premise.
-   */
-  export function sourceEvidence(
-    reference: ReadonlyMap<bigint, bigint>,
-  ): (file: string) => { separable: boolean; signature: string } | undefined {
-    return (file) => {
-      try {
-        const stats = fs.lstatSync(file, { bigint: true });
-        const minted = reference.get(stats.dev);
-        return {
-          separable: minted !== undefined && stats.mtimeNs < minted,
-          signature: [
-            stats.dev,
-            stats.ino,
-            stats.nlink,
-            stats.mode,
-            stats.size,
-            stats.mtimeNs,
-            stats.ctimeNs,
-          ].join(":"),
-        };
-      } catch {
-        return undefined;
-      }
-    };
-  }
 }

package/src/plugin/internal/load/PluginDescriptorEvaluationCache.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 
 import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { runtimeExecutableIdentity } from "../../../internal/runtimeExecutableIdentity";
+import type { PluginContentIdentities } from "../source/PluginContentIdentities";
 import { SourceBuildCacheLayout } from "../source/SourceBuildCacheLayout";
 import { recordCacheFileUse } from "../source/recordCacheFileUse";
 import { resolveSourceBuildCachePaths } from "../source/resolveSourceBuildCachePaths";
@@ -127,20 +128,26 @@ export namespace PluginDescriptorEvaluationCache {
 
     /** Ttsc build version, invalidating answers from another build. */
     version: string;
+
+    /**
+     * Record store proving the runtimes' bytes from metadata (#1723); without
+     * it each runtime is streamed again.
+     */
+    identities?: PluginContentIdentities.Store;
   }): string | null {
     const environment = SidecarEnvironment.merge(props.env);
     // Startup preloads can run before the descriptor recorder and read inputs
     // it never sees; a stable option string cannot prove their current meaning.
     if (SidecarEnvironment.read(environment, "NODE_OPTIONS")?.trim())
       return null;
-    const runtime = runtimeIdentity(props.runtime);
+    const runtime = runtimeIdentity(props.runtime, props.identities);
     if (runtime === null) return null;
     const additionalRuntime =
       props.additionalRuntime === undefined
         ? undefined
         : props.additionalRuntime === props.runtime
           ? runtime
-          : runtimeIdentity(props.additionalRuntime);
+          : runtimeIdentity(props.additionalRuntime, props.identities);
     if (additionalRuntime === null) return null;
     let root: string;
     try {
@@ -358,8 +365,11 @@ export namespace PluginDescriptorEvaluationCache {
    * content digest and bracketed lexical/physical metadata, so replaced bytes
    * cannot reuse an evaluation by restoring size/timestamps. Null is unproved.
    */
-  function runtimeIdentity(runtime: string): string | null {
-    return runtimeExecutableIdentity(runtime) ?? null;
+  function runtimeIdentity(
+    runtime: string,
+    identities: PluginContentIdentities.Store | undefined,
+  ): string | null {
+    return runtimeExecutableIdentity(runtime, identities) ?? null;
   }
 
   /**