ttsc 0.31.1 → 0.31.3

package/src/internal/javascriptRuntimeCapabilities.ts

@@ -4,6 +4,8 @@ import path from "node:path";
 
 import { captureProcessOutput } from "../compiler/internal/captureProcessOutput";
 import { SidecarEnvironment } from "../compiler/internal/sharedHost/SidecarEnvironment";
+import type { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
+import { PluginLoadAnswers } from "../plugin/internal/source/PluginLoadAnswers";
 import { E2ETrace } from "./E2ETrace";
 import type { IJavaScriptRuntimeCapabilities } from "./IJavaScriptRuntimeCapabilities";
 import { OwnedSynchronousProcess } from "./OwnedSynchronousProcess";
@@ -20,28 +22,56 @@ import { spawnSyncWithLowDescriptors } from "./spawnSyncWithLowDescriptors";
  * Cache-ineligible candidates do not acquire executable proofs used only by
  * cache lookup and publication.
  *
- * @evidence contracts/common.md#principled-implementation A child reports its own feature availability and executable; byte-aware before/after identity and same-executable proof authorize reuse only for a stable absolute runtime without NODE_OPTIONS preload authority.
+ * With a record store, the executable identity is proven from metadata and a
+ * probe answer recorded for that identity is reused by a later process (#1723);
+ * a recorded answer must still name an executable this runtime is.
+ *
+ * @param runtime The interpreter to probe.
+ * @param env Caller environment merged over this process's.
+ * @param cwd Working directory of the probe.
+ * @param identities Optional record store of the caller's plugin cache.
+ * @evidence contracts/common.md#principled-implementation A child reports its own feature availability and executable; byte-aware before/after identity and same-executable proof authorize reuse only for a stable absolute runtime without NODE_OPTIONS preload authority, in process or through an answer recorded under that identity.
  * @evidence contracts/common.md#clear-and-simple-design One probe owner coordinates identity, spawning and parsing; the shared fingerprint helper owns file-content proof and the low-descriptor helper owns the POSIX launch distinction.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Feature availability comes from the actual interpreter rather than its name; descriptor fallback handles a supported kernel constraint and failures produce unsupported capabilities, not fabricated success.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain measured capabilities, reuse restrictions and freshness, with comments separating platform launch and cache permission from tags.
  * @evidence contracts/portability.md#os-neutral-implementation Shared environment merge and lookup apply native name identity to caller precedence and NODE_OPTIONS preload authority, including Windows aliases; Node spawn receives an executable and argv without shell syntax, and only POSIX descriptor exhaustion uses the isolated broker.
- * @evidence contracts/performance.md#efficient-algorithms Environment merge/name handling first decides cache eligibility. Eligible hits read B executable bytes; eligible misses acquire before/after content proofs around the actual probe. Ineligible calls retain the fresh child without reading executable bytes solely for the forbidden cache. Probe spawning/parsing, a possible descriptor-exhaustion retry and capture-file reads add text/environment/native lookup costs and transient output storage; this adapter sets no explicit byte quota.
- * @evidence contracts/performance.md#reuse-equivalent-work Stable absolute candidates that report their own executable share measured capability results, including false feature flags; changed executable bytes, link/target identity, preload options or wrapper identity require another probe, while failed probes without executable identity are not reused.
+ * @evidence contracts/performance.md#efficient-algorithms Environment merge/name handling first decides cache eligibility. Eligible hits prove the executable from a record (three stats and one small read) or read B executable bytes; eligible misses acquire before/after identities around the actual probe. Ineligible calls retain the fresh child without reading executable bytes solely for the forbidden cache. Probe spawning/parsing, a possible descriptor-exhaustion retry and capture-file reads add text/environment/native lookup costs and transient output storage; this adapter sets no explicit byte quota.
+ * @evidence contracts/performance.md#reuse-equivalent-work Stable absolute candidates that report their own executable share measured capability results, including false feature flags, within the process and across processes through the record store keyed by the full identity; changed executable bytes, link/target identity, preload options or wrapper identity require another probe, while failed probes without executable identity are not reused.
  * @evidence contracts/performance.md#bound-retention-and-release-resources The synchronous probe owns child completion and fallback captures; finally attempts capture close/removal, whose helper suppresses cleanup failures, so native/file release is unconfirmed on failure. Capability entries retain absolute spellings and path/identity text with no eviction quota; failed identity validation can remove an entry. Returned capability copies transfer to callers.
  */
 export function javascriptRuntimeCapabilities(
   runtime: string,
   env: NodeJS.ProcessEnv,
   cwd: string,
+  identities?: PluginContentIdentities.Store,
 ): IJavaScriptRuntimeCapabilities {
   const effectiveEnv = SidecarEnvironment.merge(process.env, env);
   const cacheKey = runtimeCapabilityCacheKey(runtime, effectiveEnv);
   const beforeIdentity =
-    cacheKey === undefined ? undefined : runtimeExecutableIdentity(runtime);
+    cacheKey === undefined
+      ? undefined
+      : runtimeExecutableIdentity(runtime, identities);
   if (cacheKey !== undefined && beforeIdentity !== undefined) {
     const cached = runtimeCapabilityCache.get(cacheKey);
     if (cached?.identity === beforeIdentity) return { ...cached.capabilities };
     runtimeCapabilityCache.delete(cacheKey);
+    // WARNING (#1723): a launch is a new process, so the memo above is empty
+    // on every CLI run. The same proven executable answers the same probe; the
+    // record store carries that answer across processes.
+    const recorded = recordedCapabilities(
+      PluginLoadAnswers.read(identities, RUNTIME_CAPABILITIES, [
+        cacheKey,
+        beforeIdentity,
+      ]),
+      runtime,
+    );
+    if (recorded !== undefined) {
+      runtimeCapabilityCache.set(cacheKey, {
+        capabilities: { ...recorded },
+        identity: beforeIdentity,
+      });
+      return recorded;
+    }
   }
   const args = [
     "-e",
@@ -113,7 +143,9 @@ export function javascriptRuntimeCapabilities(
   // This removes a process spawn from the common path without
   // authorizing a replaced or redirected runtime in a long-lived host.
   const afterIdentity =
-    cacheKey === undefined ? undefined : runtimeExecutableIdentity(runtime);
+    cacheKey === undefined
+      ? undefined
+      : runtimeExecutableIdentity(runtime, identities);
   if (
     cacheKey !== undefined &&
     capabilities.executable !== undefined &&
@@ -125,10 +157,44 @@ export function javascriptRuntimeCapabilities(
       capabilities: { ...capabilities },
       identity: afterIdentity,
     });
+    PluginLoadAnswers.write(
+      identities,
+      RUNTIME_CAPABILITIES,
+      [cacheKey, afterIdentity],
+      capabilities,
+    );
   }
   return capabilities;
 }
 
+/** Answer family of measured runtime capabilities (`PluginLoadAnswers`). */
+const RUNTIME_CAPABILITIES = "javascript-runtime-capabilities";
+
+/**
+ * A recorded probe answer in the shape the probe produces, still naming an
+ * executable this runtime is, or `undefined`.
+ */
+function recordedCapabilities(
+  value: unknown,
+  runtime: string,
+): IJavaScriptRuntimeCapabilities | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const recorded = value as Partial<IJavaScriptRuntimeCapabilities>;
+  if (
+    typeof recorded.bun !== "boolean" ||
+    typeof recorded.registerHooks !== "boolean" ||
+    typeof recorded.executable !== "string" ||
+    !path.isAbsolute(recorded.executable) ||
+    !sameRuntimeExecutable(runtime, recorded.executable)
+  )
+    return undefined;
+  return {
+    bun: recorded.bun,
+    executable: recorded.executable,
+    registerHooks: recorded.registerHooks,
+  };
+}
+
 type RuntimeCapabilityCacheEntry = {
   capabilities: IJavaScriptRuntimeCapabilities;
   identity: string;

package/src/internal/pluginSource.ts

@@ -22,5 +22,6 @@ export * from "../plugin/internal/source/pluginSourceDigest";
 export * from "../plugin/internal/source/pluginSourceState";
 export * from "../plugin/internal/source/pluginSourceStateHolds";
 export * from "../plugin/internal/source/processPluginBuildEnvironment";
+export * from "../plugin/internal/source/provenPluginSourceDigest";
 export * from "../plugin/internal/source/PluginBuildEnvironmentReadings";
 export * from "../plugin/internal/source/prunesPluginSourceDirectory";

package/src/internal/resolveNodeBinary.ts

@@ -1,4 +1,5 @@
 import { SidecarEnvironment } from "../compiler/internal/sharedHost/SidecarEnvironment";
+import type { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
 import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
 
 /**
@@ -7,6 +8,10 @@ import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
  * Bun can directly evaluate a descriptor, but it does not implement the
  * synchronous `module.registerHooks` contract used by those loaders.
  *
+ * @param env Effective environment naming `TTSC_NODE_BINARY`.
+ * @param cwd Working directory of the probes.
+ * @param identities Optional record store that lets probes of an unchanged
+ *   runtime be answered across processes (#1723).
  * @evidence contracts/common.md#principled-implementation Ordered candidates are accepted only after an actual runtime probe reports non-Bun registerHooks support and its absolute executable; names alone do not establish the loader capability.
  * @evidence contracts/common.md#clear-and-simple-design Candidate precedence and duplicate suppression remain here, while the shared probe owns launch, capability parsing and freshness policy.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The node spelling is a supported final discovery candidate, not an assumed successful runtime; incompatible candidates are skipped without patching modules or globals.
@@ -19,6 +24,7 @@ import { javascriptRuntimeCapabilities } from "./javascriptRuntimeCapabilities";
 export function resolveNodeBinary(
   env: NodeJS.ProcessEnv = process.env,
   cwd: string = process.cwd(),
+  identities?: PluginContentIdentities.Store,
 ): string | undefined {
   const candidates = [
     SidecarEnvironment.read(env, "TTSC_NODE_BINARY"),
@@ -31,7 +37,12 @@ export function resolveNodeBinary(
     if (candidate === undefined || candidate.trim() === "") continue;
     if (seen.has(candidate)) continue;
     seen.add(candidate);
-    const capabilities = javascriptRuntimeCapabilities(candidate, env, cwd);
+    const capabilities = javascriptRuntimeCapabilities(
+      candidate,
+      env,
+      cwd,
+      identities,
+    );
     if (
       !capabilities.bun &&
       capabilities.registerHooks &&

package/src/internal/runtimeExecutableIdentity.ts

@@ -3,64 +3,44 @@ import fs from "node:fs";
 import path from "node:path";
 import { threadId } from "node:worker_threads";
 
+import { PluginContentIdentities } from "../plugin/internal/source/PluginContentIdentities";
 import { E2ETrace } from "./E2ETrace";
 
 /**
  * Fingerprint an absolute executable's spelling, target and actual bytes.
  *
  * A changed link, file, or read failure yields no reusable identity. Metadata
- * brackets the streamed read; it is not used to reuse an earlier content hash.
- * Concurrent writes that evade every filesystem observation remain outside this
- * snapshot guarantee.
+ * brackets the streamed read. Concurrent writes that evade every filesystem
+ * observation remain outside this snapshot guarantee.
  *
- * @evidence contracts/common.md#principled-implementation The identity joins lexical-link metadata, the selected physical file metadata and SHA-256 of that opened file; matching metadata alone cannot authorize reuse after bytes change. Descriptor and pathname observations must still agree after reading.
- * @evidence contracts/common.md#clear-and-simple-design This one native owner supplies the same content proof to runtime capability and plugin caches; callers decide whether their other inputs permit reuse.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported Node filesystem and crypto APIs inspect the actual candidate; no fixture identity, foreign mutation or metadata-only shortcut substitutes for content.
- * @evidence contracts/common.md#meaningful-documentation Native prose explains absolute-path scope, failure meaning, hash freshness and the remaining concurrent-mutation limitation, with separate prose and tags.
- * @evidence contracts/portability.md#os-neutral-implementation Node native realpath and bigint stat preserve link/target identity on supported hosts; absolute paths use native platform semantics, and unreadable or non-regular targets cannot be reused.
- * @evidence contracts/performance.md#efficient-algorithms A sequential read hashes B bytes with one 64 KiB buffer instead of a complete executable allocation. Native path/realpath/stat observations and serialized physical spelling/metadata add text/lookup costs; B and spelling lengths have no quota here. Returned identity storage includes the physical path as well as the fixed-length digest.
- *
- * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation establishes whether later work is equivalent; retaining a digest by metadata would reproduce the stale-byte defect it must prevent.
+ * With a record store, the bytes of an unchanged executable are proven from its
+ * metadata instead of streamed again (`PluginContentIdentities`, #1723): the
+ * recorded digest stands only while the physical file's identity, size and both
+ * stamps match the record and its modification stamp is separable from a
+ * reference the store minted. A plugin load asks for this identity several
+ * times, and every launch is a new process, so streaming an 85 MB runtime each
+ * time cost about 0.9 s per launch. Without a store, or when that proof is
+ * unavailable, the file is streamed as before.
  *
- * @evidence contracts/performance.md#bound-retention-and-release-resources One descriptor and one fixed buffer belong to this synchronous call; finally attempts closure after read/observation failures as well as success. A close failure returns no identity but cannot confirm native release. Returned path/metadata/digest text transfers to the caller and no helper history survives. Opt-in opened/closed/close-failed observations carry one trace-only call id and actual descriptor, PID/thread and already observed physical identity. The existing finally performs the single close; no observer retries it or converts an unavailable identity to success. An observed close is release of this Node descriptor, not proof that an OS image lock or another actor has released the executable.
+ * @param runtime The executable, absolute.
+ * @param identities Optional record store of the caller's plugin cache.
+ * @evidence contracts/common.md#principled-implementation The identity joins lexical-link metadata, the selected physical file metadata and the SHA-256 of that file's bytes, streamed under metadata brackets or proven by a record whose separable signature still matches; descriptor and pathname observations must still agree after a read.
+ * @evidence contracts/common.md#clear-and-simple-design This one native owner supplies the same identity to runtime capability and plugin caches; the record store owns metadata reuse and a private helper owns the bracketed stream.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Metadata alone never stands for bytes: reuse needs a record written under unchanged separable metadata around an actual read, which a same-tick rewrite or restored timestamps cannot satisfy because change time and the minted reference move.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains absolute-path scope, failure meaning, the record proof and the remaining concurrent-mutation limitation, with separate prose and tags.
+ * @evidence contracts/portability.md#os-neutral-implementation Node native realpath and bigint stat preserve link/target identity on supported hosts; absolute paths use native platform semantics, and unreadable or non-regular targets cannot be reused.
+ * @evidence contracts/performance.md#efficient-algorithms A proven record costs three stats and one small file read; otherwise a sequential read hashes B bytes with one 64 KiB buffer instead of a complete executable allocation. Native path/realpath/stat observations and serialized metadata add text/lookup costs.
+ * @evidence contracts/performance.md#reuse-equivalent-work Processes share an executable digest only through the record store's separable-signature proof; without a store every call streams the file.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One descriptor and one fixed buffer belong to a streamed read; finally attempts closure after read/observation failures as well as success. A close failure returns no identity but cannot confirm native release. Opt-in opened/closed/close-failed observations carry one trace-only call id and actual descriptor, PID/thread and already observed physical identity. Records belong to the single-file collector.
  */
-export function runtimeExecutableIdentity(runtime: string): string | undefined {
+export function runtimeExecutableIdentity(
+  runtime: string,
+  identities?: PluginContentIdentities.Store,
+): string | undefined {
   if (!path.isAbsolute(runtime)) return undefined;
   const startedAt = new Date().toISOString();
-  let descriptor: number | undefined;
-  let traceLease: Readonly<Record<string, string | number>> | undefined;
   let stage = "lexical-stat";
-  const unavailable = (
-    reason: string,
-    expected?: string,
-    observed?: string,
-    observations?: { before: fs.BigIntStats; after: fs.BigIntStats },
-  ) => {
-    E2ETrace.capabilityResolution("runtime-executable-identity-unavailable", {
-      runtime,
-      stage,
-      reason,
-      expected,
-      observed,
-      expectedAtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.before.atimeNs),
-      observedAtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.after.atimeNs),
-      expectedBirthtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.before.birthtimeNs),
-      observedBirthtimeNs:
-        observations === undefined
-          ? undefined
-          : String(observations.after.birthtimeNs),
-    });
-    return undefined;
-  };
+  let refused: IUnavailable | undefined;
   try {
     const lexical = fs.lstatSync(runtime, { bigint: true });
     stage = "physical-realpath";
@@ -68,93 +48,30 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
     stage = "physical-stat";
     const physical = fs.statSync(physicalPath, { bigint: true });
     if (!physical.isFile())
-      return unavailable("not-regular", undefined, fileIdentity(physical));
-    stage = "open";
-    descriptor = fs.openSync(physicalPath, "r");
-    if (process.env.TTSC_E2E_TRACE) {
-      traceLease = {
-        callId: String(++identityTraceOrdinal),
-        runtime,
-        physicalPath,
-        descriptor,
-        pid: process.pid,
-        threadId,
-        dev: String(physical.dev),
-        ino: String(physical.ino),
-      };
-      E2ETrace.capabilityResolution(
-        "runtime-executable-identity-opened",
-        traceLease,
-      );
-    }
-    stage = "opened-stat";
-    const opened = fs.fstatSync(descriptor, { bigint: true });
-    if (fileIdentity(opened) !== fileIdentity(physical))
-      return unavailable(
-        "opened-file-changed",
-        fileIdentity(physical),
-        fileIdentity(opened),
-      );
-    const hash = crypto.createHash("sha256");
-    const buffer = Buffer.allocUnsafe(64 * 1024);
-    let remaining = opened.size;
-    stage = "read";
-    while (remaining > 0n) {
-      const requested =
-        remaining > BigInt(buffer.length) ? buffer.length : Number(remaining);
-      const length = fs.readSync(descriptor, buffer, 0, requested, null);
-      if (length === 0)
-        return unavailable(
-          "premature-eof",
-          String(opened.size),
-          String(opened.size - remaining),
-        );
-      hash.update(buffer.subarray(0, length));
-      remaining -= BigInt(length);
-    }
-    stage = "post-read-opened-stat";
-    const afterOpened = fs.fstatSync(descriptor, { bigint: true });
-    if (fileIdentity(afterOpened) !== fileIdentity(opened))
-      return unavailable(
-        "opened-file-changed-during-read",
-        fileIdentity(opened),
-        fileIdentity(afterOpened),
-        { before: opened, after: afterOpened },
-      );
-    stage = "post-read-realpath";
-    const afterPath = fs.realpathSync.native(runtime);
-    if (afterPath !== physicalPath)
-      return unavailable("physical-target-changed", physicalPath, afterPath);
-    stage = "post-read-lexical-stat";
-    const afterLexical = fs.lstatSync(runtime, { bigint: true });
-    if (fileIdentity(afterLexical) !== fileIdentity(lexical))
-      return unavailable(
-        "lexical-file-changed-during-read",
-        fileIdentity(lexical),
-        fileIdentity(afterLexical),
-      );
-    stage = "post-read-physical-stat";
-    const afterPhysical = fs.statSync(physicalPath, { bigint: true });
-    if (fileIdentity(afterPhysical) !== fileIdentity(physical))
-      return unavailable(
-        "physical-file-changed-during-read",
-        fileIdentity(physical),
-        fileIdentity(afterPhysical),
-      );
-    const digest = hash.digest("hex");
-    E2ETrace.capabilityResolution("runtime-executable-identity-observed", {
-      runtime,
-      physicalPath,
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      lexical: fileIdentity(lexical),
-      physical: fileIdentity(physical),
-      digest,
-      openedAtimeNs: String(opened.atimeNs),
-      afterOpenedAtimeNs: String(afterOpened.atimeNs),
-      openedBirthtimeNs: String(opened.birthtimeNs),
-      afterOpenedBirthtimeNs: String(afterOpened.birthtimeNs),
-    });
+      return unavailable(runtime, {
+        stage,
+        reason: "not-regular",
+        observed: fileIdentity(physical),
+      });
+    const read = (): string => {
+      const streamed = streamDigest(runtime, physicalPath, physical, lexical, {
+        startedAt,
+      });
+      if (typeof streamed === "string") return streamed;
+      refused = streamed;
+      throw new Error(streamed.reason);
+    };
+    const digest =
+      identities === undefined
+        ? read()
+        : PluginContentIdentities.digest(
+            identities,
+            "executable",
+            physicalPath,
+            (references) =>
+              PluginContentIdentities.fileObservation(references, physicalPath),
+            read,
+          );
     return [
       physicalPath,
       fileIdentity(lexical),
@@ -163,10 +80,71 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
     ].join("\0");
   } catch (error) {
     return unavailable(
-      "filesystem-error",
-      undefined,
-      error instanceof Error ? error.message : String(error),
+      runtime,
+      refused ?? {
+        stage,
+        reason: "filesystem-error",
+        observed: error instanceof Error ? error.message : String(error),
+      },
     );
+  }
+}
+
+/** Why an identity could not be formed, at the stage that found it. */
+interface IUnavailable {
+  stage: string;
+  reason: string;
+  expected?: string;
+  observed?: string;
+  observations?: { before: fs.BigIntStats; after: fs.BigIntStats };
+}
+
+function unavailable(runtime: string, failure: IUnavailable): undefined {
+  E2ETrace.capabilityResolution("runtime-executable-identity-unavailable", {
+    runtime,
+    stage: failure.stage,
+    reason: failure.reason,
+    expected: failure.expected,
+    observed: failure.observed,
+    expectedAtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.before.atimeNs),
+    observedAtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.after.atimeNs),
+    expectedBirthtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.before.birthtimeNs),
+    observedBirthtimeNs:
+      failure.observations === undefined
+        ? undefined
+        : String(failure.observations.after.birthtimeNs),
+  });
+  return undefined;
+}
+
+/**
+ * Stream the physical file's bytes between metadata observations of the open
+ * descriptor, the physical path and the lexical spelling, returning the digest
+ * or what moved. The descriptor is closed in finally; a failed close refuses
+ * the identity.
+ */
+function streamDigest(
+  runtime: string,
+  physicalPath: string,
+  physical: fs.BigIntStats,
+  lexical: fs.BigIntStats,
+  timing: { startedAt: string },
+): string | IUnavailable {
+  let stage = "open";
+  let descriptor: number | undefined;
+  let traceLease: Readonly<Record<string, string | number>> | undefined;
+  let result: string | IUnavailable;
+  try {
+    result = observe();
   } finally {
     if (descriptor !== undefined) {
       try {
@@ -185,13 +163,121 @@ export function runtimeExecutableIdentity(runtime: string): string | undefined {
               error: error instanceof Error ? error.message : String(error),
             },
           );
-        stage = "close";
-        return unavailable(
-          "descriptor-close-error",
-          undefined,
-          error instanceof Error ? error.message : String(error),
+        // A digest whose descriptor could not be closed is refused, as before.
+        result = {
+          stage: "close",
+          reason: "descriptor-close-error",
+          observed: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }
+  }
+  return result;
+
+  function observe(): string | IUnavailable {
+    try {
+      descriptor = fs.openSync(physicalPath, "r");
+      if (process.env.TTSC_E2E_TRACE) {
+        traceLease = {
+          callId: String(++identityTraceOrdinal),
+          runtime,
+          physicalPath,
+          descriptor,
+          pid: process.pid,
+          threadId,
+          dev: String(physical.dev),
+          ino: String(physical.ino),
+        };
+        E2ETrace.capabilityResolution(
+          "runtime-executable-identity-opened",
+          traceLease,
         );
       }
+      stage = "opened-stat";
+      const opened = fs.fstatSync(descriptor, { bigint: true });
+      if (fileIdentity(opened) !== fileIdentity(physical))
+        return {
+          stage,
+          reason: "opened-file-changed",
+          expected: fileIdentity(physical),
+          observed: fileIdentity(opened),
+        };
+      const hash = crypto.createHash("sha256");
+      const buffer = Buffer.allocUnsafe(64 * 1024);
+      let remaining = opened.size;
+      stage = "read";
+      while (remaining > 0n) {
+        const requested =
+          remaining > BigInt(buffer.length) ? buffer.length : Number(remaining);
+        const length = fs.readSync(descriptor, buffer, 0, requested, null);
+        if (length === 0)
+          return {
+            stage,
+            reason: "premature-eof",
+            expected: String(opened.size),
+            observed: String(opened.size - remaining),
+          };
+        hash.update(buffer.subarray(0, length));
+        remaining -= BigInt(length);
+      }
+      stage = "post-read-opened-stat";
+      const afterOpened = fs.fstatSync(descriptor, { bigint: true });
+      if (fileIdentity(afterOpened) !== fileIdentity(opened))
+        return {
+          stage,
+          reason: "opened-file-changed-during-read",
+          expected: fileIdentity(opened),
+          observed: fileIdentity(afterOpened),
+          observations: { before: opened, after: afterOpened },
+        };
+      stage = "post-read-realpath";
+      const afterPath = fs.realpathSync.native(runtime);
+      if (afterPath !== physicalPath)
+        return {
+          stage,
+          reason: "physical-target-changed",
+          expected: physicalPath,
+          observed: afterPath,
+        };
+      stage = "post-read-lexical-stat";
+      const afterLexical = fs.lstatSync(runtime, { bigint: true });
+      if (fileIdentity(afterLexical) !== fileIdentity(lexical))
+        return {
+          stage,
+          reason: "lexical-file-changed-during-read",
+          expected: fileIdentity(lexical),
+          observed: fileIdentity(afterLexical),
+        };
+      stage = "post-read-physical-stat";
+      const afterPhysical = fs.statSync(physicalPath, { bigint: true });
+      if (fileIdentity(afterPhysical) !== fileIdentity(physical))
+        return {
+          stage,
+          reason: "physical-file-changed-during-read",
+          expected: fileIdentity(physical),
+          observed: fileIdentity(afterPhysical),
+        };
+      const digest = hash.digest("hex");
+      E2ETrace.capabilityResolution("runtime-executable-identity-observed", {
+        runtime,
+        physicalPath,
+        startedAt: timing.startedAt,
+        finishedAt: new Date().toISOString(),
+        lexical: fileIdentity(lexical),
+        physical: fileIdentity(physical),
+        digest,
+        openedAtimeNs: String(opened.atimeNs),
+        afterOpenedAtimeNs: String(afterOpened.atimeNs),
+        openedBirthtimeNs: String(opened.birthtimeNs),
+        afterOpenedBirthtimeNs: String(afterOpened.birthtimeNs),
+      });
+      return digest;
+    } catch (error) {
+      return {
+        stage,
+        reason: "filesystem-error",
+        observed: error instanceof Error ? error.message : String(error),
+      };
     }
   }
 }

package/src/launcher/internal/runTtsc.ts

@@ -19,6 +19,7 @@ import { createFilesystemPathIdentityContext } from "../../internal/pathIdentity
 import { isFilesystemPathIdentityWithin } from "../../internal/pathIdentity/isFilesystemPathIdentityWithin";
 import { resolvePhysicalPath } from "../../internal/pathIdentity/resolvePhysicalPath";
 import { resolveSafeCacheCleanupTargets } from "../../internal/resolveSafeCacheCleanupTargets";
+import type { PluginContentIdentities } from "../../plugin/internal/source/PluginContentIdentities";
 import { SourceBuildCacheLayout } from "../../plugin/internal/source/SourceBuildCacheLayout";
 import { legacyGlobalCacheTargets } from "../../plugin/internal/source/legacyGlobalCacheTargets";
 import { resolveCleanTargets } from "../../plugin/internal/source/resolveCleanTargets";
@@ -634,8 +635,11 @@ function runWatch(
   const invocation = {
     ...(checkOnly ? { ...options, emit: false } : options),
     cwd,
-    onWatchInputs: (inputs: readonly string[]) => {
-      topology?.setExtraInputs(inputs);
+    onWatchInputs: (
+      inputs: readonly string[],
+      identities?: PluginContentIdentities.Store,
+    ) => {
+      topology?.setExtraInputs(inputs, identities);
     },
     onProjectInputs: (inputs: ITtscProjectInputSnapshot) => {
       topology?.setProjectInputs(inputs);