@ttsc/unplugin 0.32.0 → 0.32.1

package/src/core/transform/TtscPrecompilation.ts

@@ -0,0 +1,103 @@
+import path from "node:path";
+
+import { isTransformTarget } from "../isTransformTarget";
+import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions";
+import type { TtscTransformCache } from "./cache/TtscTransformCache";
+import { transformCacheEpoch } from "./cache/transformCacheEpoch";
+import { transformFilesystem } from "./cache/transformFilesystem";
+import { pluginsAreDisabled } from "./utils/pluginsAreDisabled";
+
+/**
+ * Schedule explicitly selected source entries before the host reaches their
+ * imports. Compilation and proof stay with the ordinary transform core.
+ *
+ * A host often discovers its next workspace project only after the preceding
+ * project's transform finishes (#1764). Starting known entries together avoids
+ * that dependency on host traversal order. Walking unrelated projects would
+ * execute plugins the user never selected, so this owner uses only the supplied
+ * entries. Preparation leaves module delivery and host registration to the
+ * actual request.
+ *
+ * @evidence contracts/common.md#principled-implementation Explicit entries authorize scheduling; the supplied core capture retains project selection, configuration identity and all generation proofs. The context contains the current working directory, options, aliases and delivery epoch, not new cache authority.
+ * @evidence contracts/common.md#clear-and-simple-design One scheduler owns per-cache startup deduplication and reset; the transform core owns compiled generations and their disposal.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No directory-wide discovery, plugin substitution or skipped proof is introduced; preparation never impersonates a host module delivery.
+ * @evidence contracts/common.md#meaningful-documentation Native prose explains host traversal order, explicit effectful selection and separation from delivery; members state context lifetime and failure ownership.
+ * @evidence contracts/portability.md#os-neutral-implementation Entries resolve through native path semantics from the current cwd and read through the cache's filesystem boundary; source eligibility uses the adapter's existing shared predicate.
+ * @evidence contracts/performance.md#efficient-algorithms Each new context serializes cwd, options and aliases, then resolves and deduplicates E entries and reads their source bytes once. Capture starts without waiting for other entries; native capture and proof retain their own costs. Repeated requests serialize the context but do not reread the entries.
+ * @evidence contracts/performance.md#reuse-equivalent-work One latest context per cache and epoch starts each entry once; ordinary project keys deduplicate entries in the same project. Context equality controls scheduling only, and retained results still need normal admission.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources A WeakMap retains one context string per live cache. Startup rejection handlers consume each detached promise; running captures and native resources remain cache-owned and withdrawal disposes their fulfilled generations. No cancellation deadline or entry-count cap is added.
+ */
+export namespace TtscPrecompilation {
+  const contexts = new WeakMap<TtscTransformCache, string>();
+
+  /**
+   * Start every eligible explicit entry without waiting for its siblings.
+   * Failed speculative preparation is reported when its module is requested, so
+   * an unrelated delivered project's load can proceed.
+   *
+   * @evidence contracts/common.md#principled-implementation The context is installed before captures start, so recursive and concurrent deliveries cannot restart the same batch; only supported source entries reach normal core capture.
+   * @evidence contracts/common.md#clear-and-simple-design One synchronous loop separates startup ownership from asynchronous capture settlement.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed entry reads are not fabricated as empty source, and rejected captures do not become successful output. Actual delivery remains the error boundary.
+   * @evidence contracts/common.md#meaningful-documentation Prose states parallel startup and deferred error reporting; callback and context ownership remain explicit.
+   * @evidence contracts/portability.md#os-neutral-implementation Native absolute entry paths are passed as exact paths to capture and source reads use the same cache-owned filesystem as generation validation.
+   * @evidence contracts/performance.md#efficient-algorithms Context serialization precedes one E-entry deduplicating loop and actual source-byte reads; captures overlap their asynchronous work rather than being awaited sequentially.
+   * @evidence contracts/performance.md#reuse-equivalent-work Identical latest cwd, options, aliases and epoch skip scheduling; project Promise identity and normal input proof decide compile reuse, independently of this scheduling record.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources Context state follows its weak cache key. Every started capture receives a rejection handler immediately; its own core/cache owners release native resources, including withdrawal during capture.
+   */
+  export function start(
+    cache: TtscTransformCache,
+    options: ResolvedTtscUnpluginOptions,
+    aliasPaths: Record<string, string[]> | undefined,
+    capture: (file: string, source: string) => Promise<unknown>,
+  ): void {
+    if (
+      options.precompile?.length === 0 ||
+      options.precompile === undefined ||
+      pluginsAreDisabled(options.plugins)
+    )
+      return;
+    // Entry, project and projectRoot paths all use cwd. The same relative
+    // options under another directory select different work, even if the
+    // host retains its cache; capture coordinates must belong to this call.
+    const cwd = process.cwd();
+    const context = JSON.stringify([
+      cwd,
+      options,
+      aliasPaths,
+      transformCacheEpoch(cache),
+    ]);
+    if (contexts.get(cache) === context) return;
+    contexts.set(cache, context);
+    const entries = new Set<string>();
+    const filesystem = transformFilesystem(cache);
+    for (const entry of options.precompile) {
+      if (!isTransformTarget(entry)) continue;
+      const file = path.resolve(cwd, entry);
+      if (entries.has(file)) continue;
+      entries.add(file);
+      try {
+        const source = filesystem.readFile(file).toString("utf8");
+        void capture(file, source).catch(() => undefined);
+      } catch {
+        // A missing entry must not poison another project's load. Its actual
+        // host delivery still owns the native read error and recovery.
+      }
+    }
+  }
+
+  /**
+   * End startup ownership when the cache withdraws its generations.
+   *
+   * @evidence contracts/common.md#principled-implementation Withdrawal removes scheduling state with generation ownership so a later lifecycle can prepare the same entries again.
+   * @evidence contracts/common.md#clear-and-simple-design One weak-key deletion shares the cache's existing reset boundary.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Clearing scheduling permission does not admit or cancel any compiled result.
+   * @evidence contracts/common.md#meaningful-documentation The headline identifies the same generation withdrawal boundary used by callers.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation WeakMap deletion performs no native operation.
+   * @evidenceExclude contracts/performance.md#efficient-algorithms One identity deletion chooses no traversal or processing strategy.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work This operation withdraws the previous scheduling record rather than reusing work.
+   * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Deletion releases the single scheduling record; native resources remain owned by generation withdrawal.
+   */
+  export function clear(cache: TtscTransformCache): void {
+    contexts.delete(cache);
+  }
+}

package/src/core/transform/cache/selectCachedGenerationAction.ts

@@ -43,6 +43,8 @@ export function selectCachedGenerationAction(props: {
   generation: Promise<TtscCachedProjectTransform>;
   key: string;
   source: string;
+  /** False only for speculative source reads before an actual module delivery. */
+  reportDivergence?: boolean;
   proof?: TtscGenerationProof.Transaction;
 }): "serve" | "retry" | "capture" {
   if (
@@ -57,6 +59,7 @@ export function selectCachedGenerationAction(props: {
       props.source,
       props.epoch,
       props.proof,
+      props.reportDivergence,
     )
   ) {
     return "serve";

package/src/core/transform/cache/withdrawTtscTransformGenerations.ts

@@ -1,3 +1,4 @@
+import { TtscPrecompilation } from "../TtscPrecompilation";
 import type { TtscTransformCache } from "./TtscTransformCache";
 import { disposeCachedTransform } from "./disposeCachedTransform";
 
@@ -35,6 +36,7 @@ export function withdrawTtscTransformGenerations(
   cache: TtscTransformCache,
 ): void {
   const generations = [...cache.values()];
+  TtscPrecompilation.clear(cache);
   cache.clear();
   for (const generation of generations) {
     void generation.then(disposeCachedTransform, () => undefined);

package/src/core/transform/generation/captureTransformGeneration.ts

@@ -127,6 +127,9 @@ export async function captureTransformGeneration(props: {
   /** Host-delivered text compared with the compiler's on-disk source baseline. */
   currentSource: string;
 
+  /** False for preparation, whose source read is not a host module delivery. */
+  reportDivergence?: boolean;
+
   /** Optional delivery epoch to which this captured observation belongs. */
   deliveryEpoch?: number;
 
@@ -638,7 +641,7 @@ export async function captureTransformGeneration(props: {
     // this generation. A delivered text that differs, because a plugin ordered
     // before ttsc rewrote the module or the file changed after the host read
     // it, must not replace them: every sibling delivery compares the disk and
-    // would recompile the project (samchon/ttsc#1394). It is reported once
+    // would recompile the project (samchon/ttsc#1394). An actual delivery is reported once
     // instead, and the file's own compile is served.
     const currentFileKey = toProjectKey(
       projectRoot,
@@ -691,7 +694,14 @@ export async function captureTransformGeneration(props: {
       props.currentFile,
       diskHash ?? deliveredHash,
     );
-    if (diskHash !== undefined && diskHash !== deliveredHash) {
+    // Preparation reads native source only to seed the ordinary capture. A
+    // later edit is handled by generation proof, not a warning about a host
+    // rewrite: no host delivered that speculative module (#1764).
+    if (
+      props.reportDivergence !== false &&
+      diskHash !== undefined &&
+      diskHash !== deliveredHash
+    ) {
       reportDivergentDelivery(cached, props.currentFile);
     }
     // An adopted compile was certified by its publisher, and is matched below

package/src/core/transform/generation/transformProject.ts

@@ -97,6 +97,9 @@ export async function transformProject(props: {
   /** Delivered module text compared against the compiler's disk observation. */
   currentSource: string;
 
+  /** False for preparation, whose source read is not a host module delivery. */
+  reportDivergence?: boolean;
+
   /**
    * Delivery pass this compile was started for; see
    * {@link TtscCachedProjectTransform.deliveryEpoch}.

package/src/core/transform/transformTtsc.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 
 import type { ResolvedTtscUnpluginOptions } from "../options/ResolvedTtscUnpluginOptions";
+import { TtscPrecompilation } from "./TtscPrecompilation";
 import type { TtscTransformResult } from "./TtscTransformResult";
 import { createAliasPaths } from "./alias/createAliasPaths";
 import { TERMINAL_TRANSFORM_GENERATIONS } from "./cache/TERMINAL_TRANSFORM_GENERATIONS";
@@ -68,38 +69,40 @@ import { recordedDependencyWitnesses } from "./watch/recordedDependencyWitnesses
  * @param hooks - Optional adapter callbacks; see {@link TtscTransformHooks}.
  *   Dependency notifications fire on cache hits too; watch registrations are
  *   per build, not per compilation.
- * @evidence contracts/common.md#principled-implementation Project selection and generation-qualified cache admission preserve compiler disk authority; fresh-only success additionally needs an explicit nonwatching lifecycle, coherent project declaration and actual host-cache withdrawal, because incomplete observation cannot support watch invalidation.
- * @evidence contracts/common.md#clear-and-simple-design One delivery coordinator composes project selection, cache admission, compilation, output selection and host notifications; dedicated owners handle proof and lifetime internals.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts Wrapper modules cannot poison source baselines; incomplete local results can share only explicitly nonwatching first deliveries in their exact pass. Unknown/watching lifecycles or unsupported withdrawal reject and evict them rather than invent persistent records or dependency closure.
- * @evidence contracts/common.md#meaningful-documentation Native paragraphs and argument tags explain project scope, no-transform outcomes, cache epochs and per-build notification responsibilities with links to maintained reference context.
- * @evidence contracts/performance.md#efficient-algorithms
- *   Selection/key construction pays ancestor/config/alias/option/path text work.
- *   Each iteration may prepare toolchain state, settle native notifications and
- *   replay source/project/external/universal proofs before selecting output.
- *   In-flight/valid completed reuse avoids compilation, not those checks or
- *   output/map/notification/record work. Capture misses pay whole native compile
- *   and input populations. The common proof owner skips redundant environment
- *   preparation for proven first deliveries and shares synchronous native proof
- *   queries; persistent/repeated delivery establishes fresh authority. Concurrent supersession can repeat the outer loop
- *   without a delivery-level retry/time bound here.
- * @evidence contracts/performance.md#reuse-equivalent-work Cache identity covers config/options/plugins/aliases; current generations, pass-qualified terminal verdicts and in-flight Promises are shared only while their source and dependency proof remains valid.
- * @evidence contracts/performance.md#bound-retention-and-release-resources
- *   Optional cache state retains current generation Promises/results and
- *   per-key dependency/case facts without a byte/key cap here. Native tasks
- *   belong to compiler/capture owners; uncached captures retain no notification
- *   or persistent clock probe. Fresh-only delivery releases capture resources,
- *   retaining only an explicitly admitted local pass result; rejected or failed
- *   incomplete handoff detaches its generation. Eviction/disposal attempt independent resource release
- *   and native failures need not close every handle or remove every probe.
- * @evidence contracts/portability.md#os-neutral-implementation Native module paths and project coordinates use supported path/filesystem abstractions, while actual case policy and watcher capability come from generation proof rather than OS-name assumptions.
+ * @evidence contracts/common.md#principled-implementation Project selection and generation-qualified admission preserve compiler disk authority; preparation shares selection, keys, capture and input proofs with delivery, while host effects and first-delivery permission remain exclusive to actual delivery. Fresh-only success still requires an explicit nonwatching lifecycle, coherent project declaration and supported host-cache withdrawal because incomplete observation cannot establish watch invalidation.
+ * @evidence contracts/common.md#clear-and-simple-design One coordinator mode shares project selection, admission, compilation and output selection between preparation and delivery; dedicated owners retain proof and lifetime internals, and delivery alone performs host notification.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts Wrapper modules cannot poison source baselines. Preparation skips handoff rather than postcompile proof, and superseded preparation stops without reviving withdrawn generations. Incomplete local results share only explicitly nonwatching first deliveries in their exact pass; unknown/watching lifecycles or unsupported withdrawal reject and evict without invented persistent records or dependency closure.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs and argument tags explain project scope, no-transform outcomes, cache epochs and per-build notifications; coordinator prose identifies delivery-only effects and postpreparation admission, with maintained invalidation reference context.
+ * @evidence contracts/performance.md#efficient-algorithms Selection and keys pay ancestor/config/alias/option/path-text work. Each iteration may prepare toolchains, settle notifications and replay source/project/external/universal proofs; reuse avoids compilation rather than those checks or output/map/notification/record work. Misses pay native compilation and input populations. Proven first deliveries skip redundant environment preparation and share synchronous proof queries; repeated delivery establishes fresh authority. Startup schedules explicit entries concurrently and skips delivery output/map/registration work. Supersession can repeat the outer loop without a retry or time bound.
+ * @evidence contracts/performance.md#reuse-equivalent-work Config/options/plugins/aliases key the ordinary project Promise shared by preparation, simultaneous loads and sibling entries; completed generations, pass-qualified terminal verdicts and in-flight work remain reusable only under current source and dependency proof.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Optional cache state retains generation Promises/results and per-key dependency/case facts without a byte/key cap. Native tasks belong to compiler/capture owners; uncached captures retain no notification or persistent clock probe. Fresh-only delivery releases capture resources while retaining an admitted local pass result; failed or rejected incomplete handoff detaches its generation. Superseded preparation preserves the new owner, and withdrawal schedules disposal of its pending fulfilled result. Eviction/disposal attempt independent release; native failure need not close every handle or remove every probe.
+ * @evidence contracts/portability.md#os-neutral-implementation Preparation and delivery use the same native project selection, path identity and cache-owned filesystem boundaries, with exact startup entry paths. Generation proof supplies case and watcher policy rather than OS-name assumptions.
  */
-export async function transformTtsc(
+export function transformTtsc(
   id: string,
   source: string,
   options: ResolvedTtscUnpluginOptions,
   aliases?: unknown,
   cache?: TtscTransformCache,
   hooks?: TtscTransformHooks,
+): Promise<TtscTransformResult | undefined> {
+  return runTransformTtsc(id, source, options, aliases, cache, hooks, false);
+}
+
+/**
+ * Coordinate capture and actual delivery through the same project cache.
+ * Preparation stops before handoff: it cannot mark a module served, publish a
+ * host record, acknowledge volatility or emit module diagnostics. A prepared
+ * generation must still pass ordinary admission when the host requests it.
+ */
+async function runTransformTtsc(
+  id: string,
+  source: string,
+  options: ResolvedTtscUnpluginOptions,
+  aliases: unknown,
+  cache: TtscTransformCache | undefined,
+  hooks: TtscTransformHooks | undefined,
+  preparing: boolean,
 ): Promise<TtscTransformResult | undefined> {
   const filesystem = transformFilesystem(cache);
   const exact = hooks?.exactPath === true;
@@ -126,7 +129,10 @@ export async function transformTtsc(
   // Writing the delivered record must not create a new member of that proof.
   prepareProjectRecordDirectories(hooks?.project);
 
-  const selection = resolveProjectSelection(file, options.project, filesystem);
+  const selection =
+    hooks?.projectSelection === undefined
+      ? resolveProjectSelection(file, options.project, filesystem)
+      : { tsconfig: path.resolve(hooks.projectSelection), consulted: [] };
   const tsconfig = selection.tsconfig;
   const selectedProjectRoot = path.resolve(
     options.projectRoot ?? path.dirname(tsconfig),
@@ -143,6 +149,19 @@ export async function transformTtsc(
     tsconfig,
   };
   const aliasPaths = createAliasPaths(aliases);
+  if (!preparing && cache !== undefined) {
+    TtscPrecompilation.start(cache, options, aliasPaths, (entry, text) =>
+      runTransformTtsc(
+        entry,
+        text,
+        options,
+        aliases,
+        cache,
+        { ...hooks, exactPath: true, projectSelection: undefined },
+        true,
+      ),
+    );
+  }
   const key = createTransformCacheKey({
     aliasPaths,
     compilerOptions: options.compilerOptions,
@@ -169,7 +188,10 @@ export async function transformTtsc(
             undefined,
             terminal.validation.cached.projectRoot,
           );
-          if (cache?.get(key) !== transformed) continue;
+          if (cache?.get(key) !== transformed) {
+            if (preparing) return undefined;
+            continue;
+          }
         }
         // A terminal verdict is an answer about one observed environment, not an
         // invitation for every later module to repeat the whole compile.
@@ -180,7 +202,13 @@ export async function transformTtsc(
             filesystem,
           })
         ) {
-          notifyRejectedGenerationInputs(hooks, terminal, file, watchSelection);
+          if (!preparing)
+            notifyRejectedGenerationInputs(
+              hooks,
+              terminal,
+              file,
+              watchSelection,
+            );
           throw terminal;
         }
         evictGeneration(cache, key, transformed);
@@ -193,12 +221,13 @@ export async function transformTtsc(
     if (transformed !== undefined) {
       const cached = await awaitOrEvict(cache, key, transformed).catch(
         (rejection: unknown) => {
-          notifyRejectedGenerationInputs(
-            hooks,
-            rejection,
-            file,
-            watchSelection,
-          );
+          if (!preparing)
+            notifyRejectedGenerationInputs(
+              hooks,
+              rejection,
+              file,
+              watchSelection,
+            );
           throw rejection;
         },
       );
@@ -206,6 +235,7 @@ export async function transformTtsc(
       // While this caller awaited the old Promise, another caller may have
       // invalidated it and installed a newer authoritative generation.
       if (cache?.get(key) !== transformed) {
+        if (preparing) return undefined;
         continue;
       }
       // A generation captured while native notifications were trusted keeps
@@ -218,11 +248,15 @@ export async function transformTtsc(
       if (epoch === undefined) {
         await settleProjectMutationEvents(cached);
         if (cache?.get(key) !== transformed) {
+          if (preparing) return undefined;
           continue;
         }
       }
       await TtscGenerationProof.prepare(cached, file, epoch);
-      if (cache?.get(key) !== transformed) continue;
+      if (cache?.get(key) !== transformed) {
+        if (preparing) return undefined;
+        continue;
+      }
       // No await between this observation and synchronous admission.
       const proof = TtscGenerationProof.create(cached, file, epoch);
       const action = selectCachedGenerationAction({
@@ -234,11 +268,13 @@ export async function transformTtsc(
         generation: transformed,
         key,
         source,
+        reportDivergence: !preparing,
       });
       if (action === "retry") {
         continue;
       }
       if (action === "serve") {
+        if (preparing) return undefined;
         return deliverCachedTransform({
           cache,
           cached,
@@ -261,6 +297,7 @@ export async function transformTtsc(
         projectRoot: selectedProjectRoot,
         currentFile: file,
         currentSource: source,
+        reportDivergence: !preparing,
         // Stamp the pass this compile was started for, not the one it happens
         // to finish in: a boundary crossed mid-compile leaves the generation
         // belonging to the earlier pass, so the next pass re-proves it.
@@ -296,11 +333,18 @@ export async function transformTtsc(
     const generation = transformed;
     const cached = await awaitOrEvict(cache, key, generation).catch(
       (rejection: unknown) => {
-        notifyRejectedGenerationInputs(hooks, rejection, file, watchSelection);
+        if (!preparing)
+          notifyRejectedGenerationInputs(
+            hooks,
+            rejection,
+            file,
+            watchSelection,
+          );
         throw rejection;
       },
     );
     if (cache !== undefined && cache.get(key) !== generation) {
+      if (preparing) return undefined;
       continue;
     }
     if (cache !== undefined) {
@@ -320,6 +364,7 @@ export async function transformTtsc(
         policies.set(key, reported);
       }
     }
+    if (preparing) return undefined;
     return deliverCachedTransform({
       cache,
       cached,

package/src/core/transform/validation/captureUniversalHostInputValidation.ts

@@ -42,7 +42,7 @@ import { matchesRecordedInput } from "./matchesRecordedInput";
  * @evidence contracts/common.md#meaningful-documentation Native prose explains failed admission and successful generation attachment; inline comments justify readable-state, blocker and tree distinctions.
  * @evidence contracts/portability.md#os-neutral-implementation The generation's filesystem view qualifies metadata and exact native absence. Grouped candidates retain original spelling because directory case policy alone does not define Unicode or short-name equivalence; their joined path follows that view's platform dialect. Physical targets and aliases remain distinct from content identity, and native plugin environment authority is not established by arbitrary filesystem injection.
  * @evidence contracts/performance.md#bound-retention-and-release-resources The generation retains manifest entries, lexical coverage, raw missing candidates and tree environments proportional to admitted inputs and their path/state text, without a total byte cap or native handle here. Failed attempt records are call-local and diagnostic witness counts are bounded by their owner; replacing or releasing the generation ends manifest ownership.
- * @evidence contracts/performance.md#efficient-algorithms Input selection materializes the union of producer lists/proof keys and scans U universal inputs and T plugin source trees. Comparisons include content bytes, physical identity/ancestor/case queries, paired metadata and exact candidate stat; source proof includes tree population/bytes and environment validation. These delegated costs and temporary input/manifest populations are not constant-time map insertion work.
+ * @evidence contracts/performance.md#efficient-algorithms Input selection materializes the union of producer lists/proof keys and scans U universal inputs and T plugin source trees. Async-owned environments share one synchronous batch, qualifying common SDK paths once across plugin directories. Comparisons include content bytes, physical identity/ancestor/case queries, paired metadata and exact candidate stat; source proof includes tree population/bytes and environment validation. These delegated costs and temporary input/manifest populations are not constant-time map insertion work.
  * @evidence contracts/performance.md#reuse-equivalent-work This shared generation manifest records exactly qualified lexical spellings, separable signatures and tree environments for later validators; changed proof requires new admission.
  */
 export function captureUniversalHostInputValidation(
@@ -295,13 +295,21 @@ export function captureUniversalHostInputValidation(
   // A plugin binary keyed on a source other than the disk's now, whether it
   // was built here or adopted from another worker, is output for a state
   // already gone (samchon/ttsc#1487).
-  for (const [directory, digest] of selectPluginSourceInputs(cached.result)) {
+  const sources = selectPluginSourceInputs(cached.result);
+  const prepared = usesPreparedPluginBuildEnvironments(cached.result);
+  // Plugin directories commonly share the thousands-file Go SDK. Qualify it
+  // once for this synchronous proof, not once per directory (#1764). The map
+  // must stay inside this call: an await or later delivery needs fresh native
+  // authority, even when source watchers heard no change (#1712, #1516).
+  const environments = prepared
+    ? PluginBuildEnvironmentReadings.cachedAll(sources.keys())
+    : undefined;
+  for (const [directory, digest] of sources) {
     // The environment is recorded as read before the proof, so it is never a
     // reading the proof did not see; one that moved meanwhile only makes the
     // next delivery prove the tree again.
-    const prepared = usesPreparedPluginBuildEnvironments(cached.result);
     const environment = prepared
-      ? PluginBuildEnvironmentReadings.cached(directory)
+      ? environments!.get(directory)
       : processPluginBuildEnvironment(directory, false, cached.projectRoot);
     if (
       environment === undefined ||

package/src/core/transform/validation/matchesCachedSource.ts

@@ -37,7 +37,9 @@ import { notificationsProveProgramUnchanged } from "./notificationsProveProgramU
  * rejects this generation for the delivery; its caller chooses replacement or
  * capture. Delivered text that differs while the disk still holds the bytes the
  * generation compiled is not one: it is reported and served, since the compile
- * read the disk (samchon/ttsc#1394).
+ * read the disk (samchon/ttsc#1394). Preparation performs the same comparison
+ * without reporting a host rewrite, because its native source read is not a
+ * delivered module.
  *
  * Its place in the adapter's invalidation model, and the units beside it, are
  * mapped in the maintainer page
@@ -73,6 +75,11 @@ export function matchesCachedSource(
   /** Current host pass, or undefined for persistent input validation. */
   epoch: number | undefined,
   proof?: TtscGenerationProof.Transaction,
+  /**
+   * Preparation compares the same native bytes without reporting a host
+   * rewrite.
+   */
+  reportDivergence = true,
 ): boolean {
   if (!nativeInputPredicatesHold(cached, proof)) return false;
   const pass = TtscGenerationProof.sharesPass(cached, file, epoch);
@@ -133,7 +140,7 @@ export function matchesCachedSource(
     ) {
       return false;
     }
-    reportDivergentDelivery(cached, file);
+    if (reportDivergence) reportDivergentDelivery(cached, file);
   }
   if (pass) return true;
   if (epoch !== undefined && cached.projectSnapshotComplete === true) {

package/src/core/transform/watch/TtscTransformHooks.ts

@@ -30,6 +30,16 @@ import type { TtscWatchInputEvidence } from "./TtscWatchInputEvidence";
  *   state at runtime.
  */
 export interface TtscTransformHooks {
+  /**
+   * Native config already selected by the host for this delivered module.
+   *
+   * A host that freezes routing and its discovery inputs in one transaction
+   * supplies that config here and retains those inputs in its watch channel.
+   * Startup entries select their own projects from the user's
+   * `options.project`, independently of another module's discovered route.
+   */
+  projectSelection?: string;
+
   /**
    * Invoked once per absolute watch-input path derived for the transformed file
    * `F`: the plugin-reported `dependencies[F]` list unioned with the host-owned

package/src/core/unplugin.ts

@@ -42,6 +42,7 @@ import type { TtscProjectRegistration } from "./transform/watch/TtscProjectRegis
 import { createViteBuildLifecycle } from "./vite/createViteBuildLifecycle";
 import { createViteServeInputWatch } from "./vite/createViteServeInputWatch";
 import { createViteServeWatchHooks } from "./vite/createViteServeWatchHooks";
+import { installViteDependencyScanPlugins } from "./vite/installViteDependencyScanPlugins";
 import { TTSC_SOURCE_MAP_STASH } from "./webpack/TTSC_SOURCE_MAP_STASH";
 import { registerTtscSourceMapLoader } from "./webpack/registerTtscSourceMapLoader";
 import { reportCompiledProjectRecords } from "./webpack/reportCompiledProjectRecords";
@@ -253,6 +254,37 @@ const unpluginFactory: UnpluginFactory<
           transformCache,
           hostDeclaresPolling(process.env, viteLifecycle.usePolling),
         );
+        installViteDependencyScanPlugins(
+          config,
+          isTransformTarget,
+          (source, file) => {
+            const startedAt = viteLifecycle.watching
+              ? serveInputs.begin()
+              : undefined;
+            return transformTtsc(
+              file,
+              source,
+              options,
+              aliases,
+              transformCache,
+              {
+                exactPath: true,
+                watching: viteLifecycle.watching,
+                ...createViteServeWatchHooks(
+                  "serve",
+                  viteLifecycle.watching,
+                  serveInputs,
+                  file,
+                  startedAt,
+                ),
+              },
+            );
+          },
+          (this?.meta as { rolldownVersion?: string } | undefined)
+            ?.rolldownVersion === undefined
+            ? "esbuild"
+            : "rolldown",
+        );
       },
       // Compiler dependencies belong to the filesystem watch graph. Vite's
       // transform-context addWatchFile also inserts runtime imports, so none