@ttsc/unplugin 0.31.5 → 0.32.1

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";
@@ -33,6 +34,7 @@ import type { TtscTransformHooks } from "./watch/TtscTransformHooks";
 import type { TtscWatchSelection } from "./watch/TtscWatchSelection";
 import { notifyRejectedGenerationInputs } from "./watch/notifyRejectedGenerationInputs";
 import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDirectories";
+import { recordedDependencyWitnesses } from "./watch/recordedDependencyWitnesses";
 
 /**
  * Apply the ttsc plugin transform to a single source file.
@@ -67,38 +69,40 @@ import { prepareProjectRecordDirectories } from "./watch/prepareProjectRecordDir
  * @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;
@@ -125,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),
@@ -142,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,
@@ -168,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.
@@ -179,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);
@@ -192,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;
         },
       );
@@ -205,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
@@ -217,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({
@@ -233,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,
@@ -260,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.
@@ -282,21 +320,31 @@ export async function transformTtsc(
           cache === undefined
             ? undefined
             : TRANSFORM_CACHE_CASE_POLICIES.get(cache)?.get(key),
+        // A cache without a list of its own takes the names the project's
+        // record carries from an earlier process (samchon/ttsc#1743).
         witnessedDependencies:
           cache === undefined
             ? undefined
-            : TRANSFORM_CACHE_DEPENDENCY_WITNESSES.get(cache)?.get(key),
+            : (TRANSFORM_CACHE_DEPENDENCY_WITNESSES.get(cache)?.get(key) ??
+              recordedDependencyWitnesses(hooks?.project, tsconfig)),
       });
       cache?.set(key, transformed);
     }
     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) {
@@ -316,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/transform/watch/TtscWatchInputBaseline.ts

@@ -23,7 +23,8 @@ import type { TtscWatchInputFileBaseline } from "./TtscWatchInputFileBaseline";
 export interface TtscWatchInputBaseline extends TtscWatchInputFileBaseline {
   /**
    * Current version-one native codec facts, captured only for requested kinds.
-   * These observations do not certify a producer's identityStable flag or scope.
+   * These observations do not certify a producer's identityStable flag or
+   * scope.
    */
   nativePredicates?: Partial<
     Record<

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

@@ -115,9 +115,11 @@ function isNativePredicateBaselines(value: unknown): boolean {
       stableStringify(Object.keys(state).sort()) !==
         stableStringify(["digest", "realpath"]) ||
       !isContentHash(state.digest) ||
-      !(state.realpath === null ||
+      !(
+        state.realpath === null ||
         (typeof state.realpath === "string" &&
-          isAbsoluteFilesystemPath(state.realpath)))
+          isAbsoluteFilesystemPath(state.realpath))
+      )
     ) {
       return false;
     }

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

@@ -73,10 +73,9 @@ const HANDED = new WeakMap<
  * loses acceptance and enters persistence again without rereading generation
  * inputs. Hosts and bridge readers own current byte proof, including concurrent
  * changes and unreadable/torn bytes; availability here cannot exclude removal
- * after the check. A host that keeps no
- * snapshot of the file, Rollup's cache, is handed the digest of the bytes
- * written for the generation to compare against instead
- * (`TtscProjectRegistration.digest`).
+ * after the check. A host that keeps no snapshot of the file, Rollup's cache,
+ * is handed the digest of the bytes written for the generation to compare
+ * against instead (`TtscProjectRegistration.digest`).
  *
  * A record lives below the host's tool directory, or, when that cannot be
  * written, below the fallback the host accepts (`fallbackToolDirectory`,
@@ -226,7 +225,9 @@ function recordOf(
   cached: TtscCachedProjectTransform,
   inputs: readonly TtscWatchInput[],
 ): TtscProjectRecord {
+  const dependencies = cached.externalDependencyInputs ?? [];
   const record: TtscProjectRecord = {
+    ...(dependencies.length === 0 ? {} : { dependencies }),
     inputs: {},
     membership:
       cached.projectDirectories === undefined

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

@@ -0,0 +1,50 @@
+import { projectRecordFile } from "../../bridge/projectRecordFile";
+import { readProjectRecordFile } from "../../bridge/readProjectRecordFile";
+import type { TtscTransformHooks } from "./TtscTransformHooks";
+
+/**
+ * The dependency-only paths the project record of `tsconfig` carries
+ * (`TtscProjectRecord.dependencies`), for a transform cache that has no witness
+ * list of its own yet.
+ *
+ * A compile learns a plugin-reported dependency path only from its own
+ * envelope, and one it had no witness for compiles again
+ * (`onlyLearnedCompileFacts`). A transform cache keeps the paths in memory
+ * (`TRANSFORM_CACHE_DEPENDENCY_WITNESSES`), so every new cache, a dev-server
+ * start or a build process, compiled such a project twice (samchon/ttsc#1743).
+ * The record the previous process wrote names them. They only say what to read:
+ * the capture still witnesses each path afresh, a path the compile no longer
+ * reports costs one read, and one the record does not name is retried as
+ * before.
+ *
+ * @param project The host's record directories, when it keeps records.
+ * @param tsconfig The project's tsconfig, as the adapter names it.
+ * @returns The record's paths, or `undefined` when no readable record names
+ *   any.
+ * @evidence contracts/common.md#principled-implementation The record is the host's persisted project state, written from a completed generation; its paths are hints that the capture re-witnesses, never certified state.
+ * @evidence contracts/common.md#clear-and-simple-design One reader selects the first readable record of the host's directories, in the order the writer tries them.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts No witness or digest is taken from the record; an unreadable or absent record supplies nothing.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain the doubled first compile, the hint semantics and the absent cases.
+ * @evidence contracts/portability.md#os-neutral-implementation Record paths come from the host's own directories through `projectRecordFile`.
+ * @evidence contracts/performance.md#efficient-algorithms At most two record reads and JSON parses, only when a cache has no witness list for the key.
+ * @evidence contracts/performance.md#reuse-equivalent-work A new process reuses the dependency names the last generation's record holds instead of compiling once to learn them.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned list belongs to the caller; nothing is retained here.
+ */
+export function recordedDependencyWitnesses(
+  project: TtscTransformHooks["project"],
+  tsconfig: string,
+): readonly string[] | undefined {
+  if (project === undefined) return undefined;
+  for (const directory of [
+    project.toolDirectory,
+    ...(project.fallbackToolDirectory === undefined
+      ? []
+      : [project.fallbackToolDirectory]),
+  ]) {
+    const record = readProjectRecordFile(
+      projectRecordFile(directory, tsconfig),
+    );
+    if (record !== undefined) return record.dependencies;
+  }
+  return undefined;
+}

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

@@ -10,8 +10,7 @@ import { isWatchInputKeyBaseline } from "./isWatchInputKeyBaseline";
  *
  * A codec matches only the facts the baseline actually captured. Native,
  * listing and plugin-tree observations require their optional payloads;
- * membership is a
- * separate project walk and cannot match one path's baseline.
+ * membership is a separate project walk and cannot match one path's baseline.
  *
  * @evidence contracts/common.md#principled-implementation Identity and every recorded codec fact must agree with a validated baseline; native predicates additionally require a supported version, stable producer identity, matching raw digest and physical target. Narrow discovery facts and absent optional native/listing/tree payloads cannot establish broader observations.
  * @evidence contracts/common.md#clear-and-simple-design Codec branches reuse the strict baseline guard and native realpath comparator, with one private refinement exposing the broader carrier.

package/src/core/tsconfig/TsconfigReadTransaction.ts

@@ -7,14 +7,16 @@ import { resolveExtendsConfig } from "./resolveExtendsConfig";
 import { resolveRealPath } from "./resolveRealPath";
 
 /**
- * Share config observations and contextual selections within one synchronous read.
+ * Share config observations and contextual selections within one synchronous
+ * read.
  *
  * Lexical paths own parsing and relative extends resolution. Physical paths
  * only guard ancestry cycles. A completed selection can be borrowed when the
  * current ancestors intersect its encountered physical identities exactly as
  * they did originally; otherwise a different cycle cut requires evaluation.
  * Ordered source observations travel with a completed selection, including
- * unresolved file candidates, so reuse preserves the caller's invalidation inputs.
+ * unresolved file candidates, so reuse preserves the caller's invalidation
+ * inputs.
  *
  * Create a new transaction for each independent freshness observation. This
  * owner neither validates reuse across reads nor supplies compiler diagnostics.
@@ -94,12 +96,13 @@ export class TsconfigReadTransaction {
   /**
    * Select one declaration, preserving its lexical directory and observations.
    *
-   * An undefined own selection inherits. Null masks inheritance without supplying
-   * a value, as an invalid own file list does; a parent ignores that empty result.
-   * First queries search later bases first; last queries visit all bases forward.
-   * The caller's physical ancestor set is copied once and never mutated.
-   * Selectors must preserve the parsed inputs and give the same declaration for
-   * the same source; query reuse does not repeat their incidental effects.
+   * An undefined own selection inherits. Null masks inheritance without
+   * supplying a value, as an invalid own file list does; a parent ignores that
+   * empty result. First queries search later bases first; last queries visit
+   * all bases forward. The caller's physical ancestor set is copied once and
+   * never mutated. Selectors must preserve the parsed inputs and give the same
+   * declaration for the same source; query reuse does not repeat their
+   * incidental effects.
    *
    * @evidence contracts/common.md#principled-implementation A completed answer is reusable only when its encountered physical identities have the same intersection with current ancestry. That preserves every observed cycle decision, including cuts; own declarations and first/last traversal retain lexical origins and key-specific precedence.
    * @evidence contracts/common.md#clear-and-simple-design A query-local visitor owns selection and contextual completed answers; transaction nodes separately share lexical source, identity and edge observations across keys.

package/src/core/tsconfig/findDeclaredCompilerOption.ts

@@ -6,8 +6,9 @@ import { findDeclaredValue } from "./findDeclaredValue";
  *
  * Own key presence is significant even for null or undefined values; the caller
  * decides whether the selected option value is usable. An optional
- * decoded-source map or graph transaction belongs to one caller read; independent
- * option searches retain their selectors and physical ancestry contexts.
+ * decoded-source map or graph transaction belongs to one caller read;
+ * independent option searches retain their selectors and physical ancestry
+ * contexts.
  *
  * @evidence contracts/common.md#principled-implementation
  *   A wrapper preserves key presence through the generic selector, so the own

package/src/core/tsconfig/findDeclaredFileSpecs.ts

@@ -13,8 +13,9 @@ import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
  * anchored at the named declaring config, including independent link aliases.
  *
  * @returns The list and its directory, undefined when no array is selected, or
- *   null when the root config cannot be read as an object. A supplied transaction
- *   belongs to this freshness observation; later reads require a fresh owner.
+ *   null when the root config cannot be read as an object. A supplied
+ *   transaction belongs to this freshness observation; later reads require a
+ *   fresh owner.
  * @evidence contracts/common.md#principled-implementation
  *   Own invalid values stop inheritance at that node. Forward inherited
  *   traversal keeps the last array and ignores empty selections, preserving

package/src/core/tsconfig/findDeclaredPaths.ts

@@ -1,5 +1,5 @@
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import type { IDeclaredPaths } from "./IDeclaredPaths";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { findDeclaredValue } from "./findDeclaredValue";
 
 /**
@@ -7,8 +7,8 @@ import { findDeclaredValue } from "./findDeclaredValue";
  * rooted at `tsconfig`. The own config wins over its bases; within an `extends`
  * array, later entries win over earlier ones. `seen` breaks circular chains;
  * the compiler reports the actual config error. Optional decoded sources or
- * graph observations share only within the caller's current read; physical cycle
- * guards remain branch-local.
+ * graph observations share only within the caller's current read; physical
+ * cycle guards remain branch-local.
  *
  * @evidence contracts/common.md#principled-implementation
  *   The selector accepts a non-array paths record and the shared value reader

package/src/core/tsconfig/findDeclaredValue.ts

@@ -7,7 +7,8 @@ import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
  * remain anchored at the named config; physical identity only cuts branch
  * cycles. Independent aliases can therefore resolve different relative bases.
  * Missing or malformed configs remain best-effort absence; the compiler owns
- * configuration diagnostics. Unresolved file candidates remain observed inputs.
+ * configuration diagnostics. Unresolved file candidates remain observed
+ * inputs.
  *
  * A supplied transaction shares source, identity and edge observations across
  * keys. A decoded-source map remains supported for callers that own that map;

package/src/core/tsconfig/readEffectiveTsconfigTemplateCompilerOptions.ts

@@ -1,8 +1,8 @@
 import path from "node:path";
 
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { CONFIG_DIR_TEMPLATE_LIST_OPTIONS } from "./CONFIG_DIR_TEMPLATE_LIST_OPTIONS";
 import { CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS } from "./CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { absolutizePathsTarget } from "./absolutizePathsTarget";
 import { findDeclaredCompilerOption } from "./findDeclaredCompilerOption";
 import { findDeclaredPaths } from "./findDeclaredPaths";

package/src/core/tsconfig/readEffectiveTsconfigTemplateFileSpecs.ts

@@ -15,8 +15,8 @@ const CONFIG_DIR_TEMPLATE_FILE_SPECS = ["exclude", "files", "include"] as const;
  * Lists use the compiler's last-inherited-array rule: a later base declaring
  * null cannot erase an earlier array. Invalid elements are preserved so this
  * overlay does not hide the compiler's configuration diagnostics. The three
- * list searches share graph observations only within this call; a later call reads
- * current bytes in a fresh transaction.
+ * list searches share graph observations only within this call; a later call
+ * reads current bytes in a fresh transaction.
  *
  * @param configDir The directory `${configDir}` stands for, as
  *   `readEffectiveTsconfigTemplateCompilerOptions` takes it.

package/src/core/tsconfig/readProjectMembershipPolicy.ts

@@ -2,9 +2,9 @@ import path from "node:path";
 
 import { TYPESCRIPT_TRANSFORM_EXTENSIONS } from "../source/TYPESCRIPT_TRANSFORM_EXTENSIONS";
 import type { ITtscProjectMembershipPolicy } from "./ITtscProjectMembershipPolicy";
-import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { JAVASCRIPT_INPUT_EXTENSIONS } from "./JAVASCRIPT_INPUT_EXTENSIONS";
 import { OUTPUT_DIRECTORY_OPTIONS } from "./OUTPUT_DIRECTORY_OPTIONS";
+import { TsconfigReadTransaction } from "./TsconfigReadTransaction";
 import { absolutizePathsTarget } from "./absolutizePathsTarget";
 import { findDeclaredFileSpecs } from "./findDeclaredFileSpecs";
 import { findDeclaredValue } from "./findDeclaredValue";
@@ -40,9 +40,9 @@ const DEFAULT_INCLUDE_SPEC = "**/*";
  * refuses to guess in the direction that loses correctness.
  *
  * Source, identity and extends observations share this transaction. Completed
- * selections, including absence, require matching physical ancestry intersections.
- * Later calls start fresh, so unchanged metadata cannot conceal changed source
- * text or resolution.
+ * selections, including absence, require matching physical ancestry
+ * intersections. Later calls start fresh, so unchanged metadata cannot conceal
+ * changed source text or resolution.
  *
  * @evidence contracts/common.md#principled-implementation
  *   Config-derived root specs, allowed extensions and exclusion provenance

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