ttsc 0.31.1 → 0.31.3

package/src/launcher/internal/runtime/installRuntimeHooks.ts

@@ -15,11 +15,13 @@ import { runBuild } from "../../../compiler/internal/build/runBuild";
 import { readProjectConfig } from "../../../compiler/internal/project/readProjectConfig";
 import { resolveOwningProjectConfig } from "../../../compiler/internal/project/resolveOwningProjectConfig";
 import { resolveTsgo } from "../../../compiler/internal/resolveTsgo";
+import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { spawnNative } from "../../../compiler/internal/spawnNative";
 import { E2ETrace } from "../../../internal/E2ETrace";
 import { createCanonicalTempDirectory } from "../../../internal/createCanonicalTempDirectory";
 import { runtimeExecutableIdentity } from "../../../internal/runtimeExecutableIdentity";
 import { moduleResolutionBaseSelects } from "../../../plugin/internal/load/moduleResolutionBaseSelects";
+import { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import { recordCacheFileUse } from "../../../plugin/internal/source/recordCacheFileUse";
 import { buildSingleRootProject } from "../buildSingleRootProject";
 import { inlineServedSourceMap } from "../inlineServedSourceMap";
@@ -684,6 +686,17 @@ function observePluginDescriptorInputOnce(record: {
       (record.hash !== undefined && record.hash !== observedHash) ||
       (record.realpath !== undefined && record.realpath !== observedRealpath) ||
       (record.signature !== undefined && record.signature !== afterSignature);
+    // A missing path's signature is its nearest existing ancestor's metadata,
+    // so a write anywhere in that ancestor refuses the proof; the trace names
+    // which observation moved.
+    if (unstable)
+      E2ETrace.capabilityResolution("plugin-descriptor-input-unstable", {
+        resolved: record.resolved,
+        recordedSignature: record.signature,
+        beforeSignature,
+        afterSignature,
+        hashChanged: record.hash !== undefined && record.hash !== observedHash,
+      });
     return `${JSON.stringify({
       ...record,
       hash: observedHash,
@@ -1479,12 +1492,63 @@ function orphanCacheRoot(): string {
  * Read afresh at every use, never remembered by path: a long-lived process can
  * lower orphans before and after the compiler at that path is replaced, and an
  * entry lowered by the new one must not be recorded under the old one's key for
- * a later process to adopt.
+ * a later process to adopt. A fresh use proves an unchanged compiler from the
+ * run's plugin cache records (`runtimeRecordStore`), which observe its metadata
+ * again each time.
  */
 function compilerIdentity(binary: string): string {
-  return runtimeExecutableIdentity(binary) ?? crypto.randomUUID();
+  return (
+    runtimeExecutableIdentity(binary, runtimeRecordStore()) ??
+    crypto.randomUUID()
+  );
 }
 
+/**
+ * The record store of this run's plugin cache root, or `undefined` without one.
+ *
+ * WARNING (#1726): every ttsx process and every descriptor evaluation streamed
+ * the whole compiler executable (24.5 MB) to key its orphan and dependency
+ * builds, although the bytes had not changed since the last process. The root
+ * is the one a descriptor evaluator's parent load selected
+ * (`TTSC_PLUGIN_RECORD_ROOT`), or the cache root of this run's manifest; a
+ * process with neither streams as before and never selects a root itself.
+ */
+function runtimeRecordStore(): PluginContentIdentities.Store | undefined {
+  const descriptorRoot =
+    process.env.TTSC_PLUGIN_DESCRIPTOR_LOAD === "1"
+      ? SidecarEnvironment.read(process.env, "TTSC_PLUGIN_RECORD_ROOT")
+      : undefined;
+  const owner = RuntimeManifestRegistry.runtimeManifests().find(
+    (candidate) =>
+      typeof candidate.orphanCacheDir === "string" &&
+      candidate.orphanCacheDir.length !== 0,
+  );
+  const root =
+    descriptorRoot !== undefined && path.isAbsolute(descriptorRoot)
+      ? descriptorRoot
+      : owner === undefined
+        ? undefined
+        : path.dirname(owner.orphanCacheDir!);
+  if (root === undefined) return undefined;
+  // One store per root serves the process: its references only grow older,
+  // which can make fewer stamps separable but never more, and each identity
+  // still observes the compiler's metadata afresh.
+  if (runtimeStore?.root !== root)
+    runtimeStore = {
+      root,
+      store: PluginContentIdentities.open({
+        projectRoot: root,
+        cacheDir: root,
+        env: process.env,
+      }),
+    };
+  return runtimeStore.store;
+}
+
+let runtimeStore:
+  | { root: string; store: PluginContentIdentities.Store | undefined }
+  | undefined;
+
 /** The version of this ttsc package, which owns the orphan post-processing. */
 function ownPackageVersion(): string {
   if (ownPackageVersionCache === undefined) {
@@ -2020,6 +2084,7 @@ function dependencyCachePaths(
   try {
     compilerProof = runtimeExecutableIdentity(
       resolveTsgo({ cwd: path.dirname(tsconfig) }).binary,
+      runtimeRecordStore(),
     );
   } catch {
     // An unobservable executable gets a unique, non-reusable generation key.
@@ -2045,7 +2110,7 @@ function dependencyCachePaths(
 function assertCompilerStillCurrent(tsconfig: string, proof?: string): void {
   if (proof === undefined) return;
   const binary = resolveTsgo({ cwd: path.dirname(tsconfig) }).binary;
-  const current = runtimeExecutableIdentity(binary);
+  const current = runtimeExecutableIdentity(binary, runtimeRecordStore());
   if (current !== proof) {
     E2ETrace.capabilityResolution("runtime-compiler-publication-refused", {
       tsconfig,

package/src/launcher/internal/ttscserver/captureLSPPluginSelectionInputs.ts

@@ -34,7 +34,8 @@ import { LSPProjectInputDigest } from "./LSPProjectInputDigest";
  * detected drift; unavailable markers or changes between reads are not a proof
  * that the complete filesystem stayed fixed throughout capture.
  *
- * @param loaded The plugin load of the session.
+ * @param loaded The plugin load of the session, with the project whose plugin
+ *   cache proves its plugin sources from records.
  * @returns The inputs, or `undefined` when the load no longer describes the
  *   filesystem and the selection has to be loaded again.
  * @evidence contracts/common.md#principled-implementation The manifest groups candidate/source-file digests by directory. Recorded content and physical-target proofs and all plugin-source states are compared again before return; a detected mismatch rejects capture, while sequential reads and unproven paths do not certify every post-load change.
@@ -53,6 +54,7 @@ export function captureLSPPluginSelectionInputs(loaded: {
   hostInputRealpaths: Readonly<Record<string, string | null>>;
   hostInputs: readonly string[];
   pluginSources: Readonly<Record<string, string>>;
+  project?: { root: string };
 }): ILSPPluginSelectionInputs | undefined {
   const excluded = new Set(
     loaded.deferredHostInputs.map((file) => path.resolve(file)),
@@ -85,8 +87,15 @@ export function captureLSPPluginSelectionInputs(loaded: {
     )
   )
     return undefined;
+  // The load's project names the plugin cache whose records prove the sources
+  // and the SDK, so a session start does not read them again (#1725).
   for (const [directory, state] of Object.entries(loaded.pluginSources))
-    if (!pluginSourceStateHolds(directory, state)) return undefined;
+    if (
+      !pluginSourceStateHolds(directory, state, {
+        projectRoot: loaded.project?.root,
+      })
+    )
+      return undefined;
   return {
     omittedNames: GoSourceInputs.OMITTED_SOURCE_FILE_NAMES,
     omittedSuffixes: GoSourceInputs.OMITTED_SOURCE_FILE_SUFFIXES,

package/src/launcher/internal/ttscserver/runTtscserver.ts

@@ -13,6 +13,7 @@ import { spawnNative } from "../../../compiler/internal/spawnNative";
 import { E2ETrace } from "../../../internal/E2ETrace";
 import { resolveNodeBinary } from "../../../internal/resolveNodeBinary";
 import { loadProjectPlugins } from "../../../plugin/internal/load/loadProjectPlugins";
+import type { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import type { ITtscLoadedNativePlugin } from "../../../structures/internal/ITtscLoadedNativePlugin";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectIdentity } from "../../../structures/internal/ITtscProjectIdentity";
@@ -165,6 +166,13 @@ type LSPExecutionContext = {
    */
   selectionInputs?: ILSPPluginSelectionInputs;
 
+  /**
+   * Record store the confirming plugin load opened, which proves the Node
+   * runtime from metadata instead of streaming it again (#1726); absent for a
+   * project without plugins, which gains no cache directory.
+   */
+  identities?: PluginContentIdentities.Store;
+
   tsgoBinary: string;
 };
 
@@ -196,6 +204,7 @@ function resolveTtscserverEnv(launch: LSPLaunchOptions): TtscserverEnvironment {
   const context = resolveLspExecutionContext(launch);
   const env = lspSidecarEnvironment({
     cwd: context.projectContext?.logicalProjectRoot ?? path.resolve(launch.cwd),
+    identities: context.identities,
     pluginConfigOrigin: context.projectContext?.pluginConfigOrigin,
     tsgoBinary: context.tsgoBinary,
   });
@@ -244,6 +253,7 @@ function resolveTtscserverEnv(launch: LSPLaunchOptions): TtscserverEnvironment {
 
 function lspSidecarEnvironment(options: {
   cwd: string;
+  identities: PluginContentIdentities.Store | undefined;
   pluginConfigOrigin: string | undefined;
   tsgoBinary: string;
 }): NodeJS.ProcessEnv {
@@ -253,7 +263,7 @@ function lspSidecarEnvironment(options: {
       SidecarEnvironment.read(process.env, "TTSC_TTSX_BINARY") ??
       path.join(__dirname, "..", "..", "..", "launcher", "ttsx.js"),
   });
-  const node = resolveNodeBinary(env, options.cwd);
+  const node = resolveNodeBinary(env, options.cwd, options.identities);
   SidecarEnvironment.write(env, "TTSC_NODE_BINARY", node);
   SidecarEnvironment.write(
     env,
@@ -305,6 +315,7 @@ function resolveLspExecutionContext(
       resolveFrom: __filename,
     });
     const initialProjectInputs = captureInitialLSPProjectInputs({
+      identities: loaded.identities,
       nativePlugins: loaded.nativePlugins,
       pluginConfigOrigin,
       project: selectedProject,
@@ -323,6 +334,7 @@ function resolveLspExecutionContext(
       resolveFrom: __filename,
     });
     const confirmedProjectInputs = captureInitialLSPProjectInputs({
+      identities: confirmation.identities,
       nativePlugins: confirmation.nativePlugins,
       pluginConfigOrigin,
       project: confirmedProject,
@@ -345,6 +357,9 @@ function resolveLspExecutionContext(
         initialProjectInputs: confirmedProjectInputs,
         nativePlugins: confirmation.nativePlugins,
         selectionInputs,
+        ...(confirmation.identities === undefined
+          ? {}
+          : { identities: confirmation.identities }),
         projectContext: {
           ...confirmedProject.identity,
           ...(pluginConfigOrigin === undefined ? {} : { pluginConfigOrigin }),
@@ -377,6 +392,7 @@ function loadLSPProjectPlugins(
 }
 
 function captureInitialLSPProjectInputs(options: {
+  identities: PluginContentIdentities.Store | undefined;
   nativePlugins: readonly ITtscLoadedNativePlugin[];
   pluginConfigOrigin: string | undefined;
   project: ITtscParsedProjectConfig;
@@ -414,6 +430,7 @@ function captureInitialLSPProjectInputs(options: {
     }
     const env = lspSidecarEnvironment({
       cwd: options.project.root,
+      identities: options.identities,
       pluginConfigOrigin: options.pluginConfigOrigin,
       tsgoBinary: options.tsgoBinary,
     });

package/src/launcher/internal/watch/WatchTopology.ts

@@ -14,9 +14,9 @@ import { type ProjectInputPathIdentityContext } from "../../../internal/pathIden
 import { createProjectInputPathIdentityContext } from "../../../internal/pathIdentity/createProjectInputPathIdentityContext";
 import { isProjectInputPathIdentityWithin } from "../../../internal/pathIdentity/isProjectInputPathIdentityWithin";
 import { resolveProjectInputPath } from "../../../internal/pathIdentity/resolveProjectInputPath";
+import { PluginContentIdentities } from "../../../plugin/internal/source/PluginContentIdentities";
 import { collectPluginSourceDirectories } from "../../../plugin/internal/source/collectPluginSourceDirectories";
 import { pluginSourceCovers } from "../../../plugin/internal/source/pluginSourceCovers";
-import { pluginSourceDigest } from "../../../plugin/internal/source/pluginSourceDigest";
 import { prunesPluginSourceDirectory } from "../../../plugin/internal/source/prunesPluginSourceDirectory";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectInputSnapshot } from "../../../structures/internal/ITtscProjectInputSnapshot";
@@ -84,6 +84,13 @@ export class WatchTopology {
    */
   private pluginInputStates = new Map<string, string>();
 
+  /**
+   * The record store of the latest plugin load that reported the inputs, which
+   * proves their states from the plugin cache's records (#1728). Absent before
+   * a load reports one, or when it opened none; the states are read then.
+   */
+  private pluginInputIdentities: PluginContentIdentities.Store | undefined;
+
   /**
    * The plugin inputs notifications named since the last decision, by path key,
    * each with the locations noted for it (`notePluginNotification`).
@@ -331,17 +338,33 @@ export class WatchTopology {
    * observation. This does not freeze the source tree or prove every transient
    * edit was seen.
    *
+   * WARNING (#1728): take each baseline through the reporting load's record
+   * store (`identities`), never by reading the sources again. The load proves
+   * the same directories from the plugin cache's records a moment later, and a
+   * content read here cost every watch session start 0.3-0.6 s for typia's Go
+   * module. The store proves only a digest whose metadata still holds and is
+   * separable from its reference, so the baseline is the digest a content read
+   * would return at this moment.
+   *
+   * @param inputs Plugin source directories and files the load reported.
+   * @param identities The reporting load's record store, if it opened one.
    * @evidence contracts/common.md#principled-implementation Published plugin inputs define the source corpus, and retaining existing pre-build baselines keeps unreported edits visible.
    * @evidence contracts/common.md#clear-and-simple-design Deduplication, baseline retention and compiler/watch reconciliation remain ordered phases.
    * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual plugin source digest applies its owning source-selection and pruning policy; named plugins or fixture output do not replace observed input state.
    * @evidence contracts/common.md#meaningful-documentation Native prose explains baseline timing and why existing inputs are not restamped following the documentation skill.
    * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and canonical backend registration govern source trees; lexical keys preserve declarations and unknown names, folding ASCII only under measured insensitive parents rather than an OS-derived rule.
-   * @evidence contracts/performance.md#efficient-algorithms Input/path keys deduplicate with text and native case/ancestor work; only newly admitted inputs compute initial source digests. Those reads scan the selected pruned corpus, then refresh(false) also pays project/compiler listing, directory traversal and watcher reconciliation; fixed publication count does not bound delegated bytes or backend work.
-   * @evidence contracts/performance.md#reuse-equivalent-work Unchanged ordered input sets return immediately; existing inputs reuse their recorded digest until actual notification processing establishes changed consumed state.
+   * @evidence contracts/performance.md#efficient-algorithms Input/path keys deduplicate with text and native case/ancestor work; only newly admitted inputs compute initial source digests, each proven from the selected files' metadata when the load's records hold and read from the selected pruned corpus otherwise; refresh(false) also pays project/compiler listing, directory traversal and watcher reconciliation; fixed publication count does not bound delegated bytes or backend work.
+   * @evidence contracts/performance.md#reuse-equivalent-work Unchanged ordered input sets return immediately; existing inputs reuse their recorded digest until actual notification processing establishes changed consumed state; a new input's digest is the one the load recorded while its metadata holds.
    * @evidence contracts/performance.md#bound-retention-and-release-resources Publications replace input/digest populations and case-observation caches without a population cap; synchronization attempts obsolete watcher closure. Native/supplied closure has its own lifetime and can throw; owner close does not prove every backend has stopped or every retained snapshot byte was released.
    */
-  public setExtraInputs(inputs: readonly string[]): void {
+  public setExtraInputs(
+    inputs: readonly string[],
+    identities?: PluginContentIdentities.Store,
+  ): void {
     this.beginLexicalTransaction();
+    // The latest load's store also serves later notifications; its references
+    // only grow older, which can make fewer stamps separable but never more.
+    this.pluginInputIdentities = identities;
     const next = uniqueExistingPaths(inputs, this.lexicalIdentities);
     if (arraysEqual(this.extraInputs, next)) return;
     this.extraInputs = next;
@@ -354,7 +377,8 @@ export class WatchTopology {
       const key = this.pathKey(input);
       states.set(
         key,
-        this.pluginInputStates.get(key) ?? pluginInputState(input),
+        this.pluginInputStates.get(key) ??
+          pluginInputState(input, this.pluginInputIdentities),
       );
     }
     this.pluginInputStates = states;
@@ -1664,7 +1688,7 @@ export class WatchTopology {
       const key = this.pathKey(input);
       const locations = pending.get(key);
       if (locations === undefined) continue;
-      const state = pluginInputState(input);
+      const state = pluginInputState(input, this.pluginInputIdentities);
       if (this.pluginInputStates.get(key) === state) continue;
       this.pluginInputStates.set(key, state);
       for (const location of locations) {
@@ -2739,12 +2763,17 @@ function isRecord(value: unknown): value is Record<string, unknown> {
  * What a plugin build keys a plugin input on: the digest of the files its build
  * reads from a source directory (`pluginSourceDigest`), or a file's bytes. An
  * input that cannot be read has a state of its own, so the change that made it
- * unreadable is reported and the build names the failure.
+ * unreadable is reported and the build names the failure. A directory's digest
+ * comes from the load's record store while the selected files' metadata holds
+ * there (#1728), and from the files otherwise.
  */
-function pluginInputState(input: string): string {
+function pluginInputState(
+  input: string,
+  identities: PluginContentIdentities.Store | undefined,
+): string {
   try {
     return WatchPaths.isDirectory(input)
-      ? `directory:${pluginSourceDigest(input)}`
+      ? `directory:${PluginContentIdentities.sourceDirectory(identities, input)}`
       : `file:${fingerprintProjectInputFile(input)}`;
   } catch (error) {
     return `unreadable:${error instanceof Error ? error.message : String(error)}`;

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;
   }
 
   /**