@ttsc/unplugin 0.28.2 → 0.28.4

package/lib/core/transform.js

@@ -9,6 +9,115 @@ var ttsc = require('ttsc');
 var pathIdentity = require('ttsc/path-identity');
 var tsconfigPaths = require('./tsconfigPaths.js');
 
+/**
+ * A verdict about one generation that later deliveries replay instead of
+ * repeating the whole compile behind it.
+ *
+ * The two kinds are replayed on different evidence, and each carries its own: a
+ * pass verdict knows the pass it belongs to, and an unstable generation knows
+ * the recorded environment it was proven against.
+ */
+class TtscTerminalGenerationError extends Error {
+}
+/**
+ * The compile succeeded and produced no output for one requested module,
+ * because the program does not contain it.
+ *
+ * Not a terminal generation error, and deliberately not a build failure. It is
+ * a fact about one file, and the answer to it is to leave that file to the host
+ * (samchon/ttsc#1308). It is a distinct type rather than a message match so the
+ * decision travels as a type: `@ttsc/metro` used to recognise this case by
+ * searching the message text for "did not return output", which is how one
+ * product came to hold two different answers to one condition.
+ */
+class TtscMissingProgramOutputError extends Error {
+    /** The module the bundler asked for. */
+    file;
+    /** The project config whose program does not contain it. */
+    tsconfig;
+    constructor(file, tsconfig) {
+        super(`ttsc: ${file} is not part of the program described by ${tsconfig}, so it was left untransformed. Add it to that project's "include" if ttsc plugins should apply to it.`);
+        this.name = "TtscMissingProgramOutputError";
+        this.file = file;
+        this.tsconfig = tsconfig;
+    }
+}
+/**
+ * A bounded proof failure that stays authoritative until its inputs change.
+ *
+ * This is the adapter failing to _obtain_ a coherent snapshot — a race it lost
+ * — so a later attempt may well succeed with the same inputs. It is retried
+ * when its recorded environment moves, and a new delivery epoch grants it the
+ * one fresh attempt the per-pass cache clear used to give it
+ * (samchon/ttsc#1300).
+ */
+class TtscUnstableGenerationError extends TtscTerminalGenerationError {
+    validation;
+    constructor(message, validation) {
+        super(message);
+        this.name = "TtscUnstableGenerationError";
+        this.validation = validation;
+    }
+}
+/**
+ * A compile this pass already attempted, whose envelope failed outright.
+ *
+ * The envelope cannot say whether the host reported diagnostics about the
+ * project or failed to run at all: an ordinary type error arrives as an
+ * `"exception"` carrying the compiler's own diagnostic text, exactly as a
+ * crashed host would. Sniffing that message to tell the two apart would be a
+ * guess, so the adapter uses the one boundary it genuinely owns. Inside a pass
+ * the answer is already settled, so every later module replays it instead of
+ * repeating a whole-project transform to reach the same verdict, which is what
+ * made a single broken save cost one compile per delivered module
+ * (samchon/ttsc#1303).
+ *
+ * The scope is exactly the pass. A host whose `buildStart` repeats drops the
+ * verdict at its next rebuild, so a transient host failure costs that one
+ * rebuild. A host with no pass boundary never retains one at all and keeps
+ * retrying on its very next delivery. Between them sits a host that opens
+ * exactly one pass for its whole process — Bun's runtime plugin, and a Vite dev
+ * server configured with `server.watch: null` — where the verdict lasts the
+ * session. That follows from what those hosts already publish about themselves,
+ * that their session is one immutable load session and the remedy for changed
+ * inputs is to restart, and it is the deliberate trade: without it, one type
+ * error costs such a session a whole-project compile per delivered module,
+ * which is the workload samchon/ttsc#970 is about.
+ *
+ * It carries the original error's message, stack and `cause` rather than
+ * replacing them, so what a bundler reports is what it reported before the
+ * verdict existed.
+ */
+class TtscPassVerdictError extends TtscTerminalGenerationError {
+    /** The delivery pass this verdict belongs to, and its whole scope. */
+    epoch;
+    constructor(original, epoch) {
+        super(original instanceof Error
+            ? original.message
+            : formatUnknownError(original), { cause: original });
+        if (original instanceof Error) {
+            this.name = original.name;
+            if (original.stack !== undefined)
+                this.stack = original.stack;
+        }
+        else {
+            this.name = "TtscPassVerdictError";
+        }
+        this.epoch = epoch;
+    }
+}
+/** Proof witnesses retained beside a compiler result without extending its API. */
+const TRANSFORM_GENERATION_FAILURES = new WeakMap();
+/** Retry baselines retained only for attempts that could not be published. */
+const TRANSFORM_FAILED_GENERATION_VALIDATIONS = new WeakMap();
+/** Cache promises whose unchanged terminal verdict may be replayed. */
+const TERMINAL_TRANSFORM_GENERATIONS = new WeakMap();
+/** Maximum witnesses printed and retained for each failed transform attempt. */
+const MAX_GENERATION_PROOF_FAILURES = 8;
+/** Maximum exact mutation paths kept after a tracker already proved a change. */
+const MAX_GENERATION_MUTATION_PATHS = 8;
+/** One retry absorbs a transient watch write without admitting an infinite loop. */
+const TRANSFORM_GENERATION_ATTEMPTS = 2;
 const DEFAULT_FILESYSTEM_OPERATIONS = Object.freeze({
     exists: fs.existsSync,
     lstat: (location) => fs.lstatSync(location, { bigint: true }),
@@ -21,10 +130,27 @@ const DEFAULT_FILESYSTEM_OPERATIONS = Object.freeze({
 const TRANSFORM_CACHE_FILESYSTEM = new WeakMap();
 const TRANSFORM_RESULT_FILESYSTEM = new WeakMap();
 /**
- * Caches whose owner has declared a real per-build lifecycle by calling
- * {@link beginTtscTransformBuild} before transforms begin.
+ * The current delivery epoch of each cache whose owner has declared a real
+ * per-pass lifecycle by calling {@link beginTtscTransformBuild}.
+ *
+ * A _delivery epoch_ is one bundler pass: the window inside which each module
+ * is requested at most once, so its first delivery may be settled against the
+ * state the pass started from. It is deliberately not the same fact as whether
+ * the generation is still valid, which the recorded snapshot answers.
+ * Conflating the two is what made every host with a repeating `buildStart` —
+ * webpack and Rspack watch, Rollup and Rolldown watch, `vite build --watch`,
+ * esbuild rebuild — discard a perfectly good whole-project compile on every
+ * edit (samchon/ttsc#1300).
+ *
+ * Absent from the map means persistent validation: a host with no pass boundary
+ * at all (a watching Vite dev server, Metro, the Turbopack loader), where every
+ * delivery proves the generation for itself.
  */
-const BUILD_SCOPED_TRANSFORM_CACHES = new WeakSet();
+const TRANSFORM_CACHE_EPOCHS = new WeakMap();
+/** The pass a delivery belongs to, or `undefined` under persistent validation. */
+function transformCacheEpoch(cache) {
+    return cache === undefined ? undefined : TRANSFORM_CACHE_EPOCHS.get(cache);
+}
 function createHostPathIdentityContext(filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
     return pathIdentity.createFilesystemPathIdentityContext({
         caseSensitive: filesystem.caseSensitive,
@@ -64,27 +190,37 @@ function resultFilesystem(result) {
     return (TRANSFORM_RESULT_FILESYSTEM.get(result) ?? DEFAULT_FILESYSTEM_OPERATIONS);
 }
 /**
- * Start a host build, clearing its prior generation and enabling constant-time
- * first delivery for modules compiled during this build.
+ * Open a new delivery pass, enabling constant-time first delivery for every
+ * module this pass asks for.
+ *
+ * This deliberately retains the cached generation. The pass boundary is a
+ * statement about _deliveries_ — each module is requested at most once inside
+ * it — not about whether the compiled program is still correct, which the
+ * generation's own recorded snapshot answers and which
+ * {@link matchesCachedSource} proves once at the pass's first delivery. Clearing
+ * here instead made a host whose `buildStart` repeats recompile the whole
+ * project on every rebuild even when no compiler input had changed
+ * (samchon/ttsc#1300). Use {@link resetTtscTransformCache} to actually discard a
+ * generation and its watchers.
  *
- * Hosts without a guaranteed build-start callback use persistent validation
- * unless they have another immutable lifecycle. Bun runtime setup, for example,
+ * Hosts without a guaranteed pass boundary use persistent validation unless
+ * they have another immutable lifecycle. Bun runtime setup, for example,
  * defines one process-scoped module-loading session.
  */
 function beginTtscTransformBuild(cache) {
-    clearTtscTransformCache(cache);
-    BUILD_SCOPED_TRANSFORM_CACHES.add(cache);
+    TRANSFORM_CACHE_EPOCHS.set(cache, (TRANSFORM_CACHE_EPOCHS.get(cache) ?? 0) + 1);
 }
 /**
- * Clear a cache and return it to persistent validation mode.
+ * Discard every generation, dispose its watchers, and return the cache to
+ * persistent validation mode.
  *
- * This is distinct from {@link beginTtscTransformBuild}: hosts such as Vite's
- * development server may invoke `buildStart` only once for a process that spans
- * many edits, so that callback cannot authorize build-scoped shortcuts.
+ * This is the unconditional lifecycle boundary, and it is distinct from
+ * {@link beginTtscTransformBuild}: a pass ending is not a reason to throw a
+ * proven compile away, while a session ending is.
  */
 function resetTtscTransformCache(cache) {
     clearTtscTransformCache(cache);
-    BUILD_SCOPED_TRANSFORM_CACHES.delete(cache);
+    TRANSFORM_CACHE_EPOCHS.delete(cache);
 }
 /** Dispose generation-owned filesystem resources before clearing a cache. */
 function clearTtscTransformCache(cache) {
@@ -140,10 +276,33 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
         tsconfig,
     });
     for (;;) {
+        // Read once per iteration, before the cache is consulted, so a delivery
+        // belongs to the pass that was current when it started examining the
+        // generation. A pass opened while this one awaits an in-flight compile is
+        // picked up by the next iteration, which is the one that runs when the
+        // entry it awaited turns out to have been superseded.
+        const epoch = transformCacheEpoch(cache);
         let transformed = cache?.get(key);
         if (transformed !== undefined) {
-            // A rejected in-flight generation must not stay cached: evict it (only if
-            // it is still the current entry) so a later call re-runs the transform.
+            const terminal = TERMINAL_TRANSFORM_GENERATIONS.get(transformed);
+            if (terminal !== undefined) {
+                // A terminal verdict is an answer about one observed environment, not an
+                // invitation for every later module to repeat the whole compile.
+                if (replaysTerminalGeneration(terminal, epoch, {
+                    currentFile: file,
+                    currentSource: source,
+                    filesystem,
+                })) {
+                    throw terminal;
+                }
+                evictGeneration(cache, key, transformed);
+                if (cache?.get(key) !== undefined) {
+                    continue;
+                }
+                transformed = undefined;
+            }
+        }
+        if (transformed !== undefined) {
             const cached = await awaitOrEvict(cache, key, transformed);
             TRANSFORM_RESULT_FILESYSTEM.set(cached.result, filesystem);
             // While this caller awaited the old Promise, another caller may have
@@ -151,8 +310,7 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
             if (cache?.get(key) !== transformed) {
                 continue;
             }
-            const buildScoped = cache !== undefined && BUILD_SCOPED_TRANSFORM_CACHES.has(cache);
-            if (!buildScoped) {
+            if (epoch === undefined) {
                 await settleProjectMutationEvents(cached);
                 if (cache?.get(key) !== transformed) {
                     continue;
@@ -167,15 +325,33 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
                 projectRoot: cached.projectRoot,
                 result: cached.result,
             }) &&
-                matchesCachedSource(cached, file, source, buildScoped)) {
-                reportSuccessDiagnostics(cached.result);
+                matchesCachedSource(cached, file, source, epoch)) {
+                reportSuccessDiagnostics(cached, epoch);
                 // A resolved `"exception"` / `"failure"` envelope makes this throw;
-                // that is a failed generation too, so evict before surfacing it.
-                const code = selectOrEvict(cache, key, transformed, {
-                    file,
-                    projectRoot: cached.projectRoot,
-                    result: cached.result,
-                });
+                // that is a failed generation too, so it is retained for this pass or
+                // evicted outside one before being surfaced.
+                let code;
+                try {
+                    code = selectOrEvict(cache, key, transformed, epoch, {
+                        file,
+                        projectRoot: cached.projectRoot,
+                        result: cached.result,
+                        tsconfig: cached.tsconfig,
+                    });
+                }
+                catch (error) {
+                    if (!(error instanceof TtscMissingProgramOutputError)) {
+                        notifyFailedGenerationInputs(hooks, cached);
+                        throw error;
+                    }
+                    // The compile is fine and simply has nothing for this module, so the
+                    // module goes back to the host untransformed rather than failing the
+                    // build (samchon/ttsc#1308). It still counts as delivered in this
+                    // pass, and there is nothing to watch for a file with no output.
+                    reportMissingProgramOutput(cached, error, epoch);
+                    markCachedSourceServed(cached, file);
+                    return undefined;
+                }
                 notifyWatchInputs(hooks, cached, file);
                 markCachedSourceServed(cached, file);
                 return createTransformResult(source, code);
@@ -195,6 +371,10 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
                 compilerOptions: options.compilerOptions,
                 currentFile: file,
                 currentSource: source,
+                // 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.
+                deliveryEpoch: epoch,
                 filesystem,
                 plugins: options.plugins,
                 trackProjectMembership: cache !== undefined,
@@ -208,12 +388,25 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
             continue;
         }
         const { projectRoot, result } = cached;
-        reportSuccessDiagnostics(result);
-        const code = selectOrEvict(cache, key, generation, {
-            file,
-            projectRoot,
-            result,
-        });
+        reportSuccessDiagnostics(cached, epoch);
+        let code;
+        try {
+            code = selectOrEvict(cache, key, generation, epoch, {
+                file,
+                projectRoot,
+                result,
+                tsconfig: cached.tsconfig,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof TtscMissingProgramOutputError)) {
+                notifyFailedGenerationInputs(hooks, cached);
+                throw error;
+            }
+            reportMissingProgramOutput(cached, error, epoch);
+            markCachedSourceServed(cached, file);
+            return undefined;
+        }
         notifyWatchInputs(hooks, cached, file);
         markCachedSourceServed(cached, file);
         if (isVolatileFile(envelopeDerivation(cached), { file, projectRoot, result })) {
@@ -223,38 +416,133 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
     }
 }
 /**
- * Await a cached generation, evicting it on rejection.
+ * Await a cached generation, retaining only terminal proof failures.
  *
  * The cache stores the in-flight transform Promise before it settles so
- * concurrent callers share one compilation. A rejected generation must not
- * remain the authoritative cached result, or a transient toolchain/host failure
- * becomes permanent for a long-lived worker. Eviction is identity-guarded so a
- * newer generation another caller installed under the same key survives.
+ * concurrent callers share one compilation. Ordinary compiler and host
+ * rejections are evicted so a transient failure cannot become permanent. A
+ * bounded stabilization failure is different: it already spent its retry and
+ * repeating it for every later module recreates the issue this gate prevents.
+ * It stays authoritative until its retained input baseline changes or the cache
+ * owner starts a new lifecycle.
  */
 async function awaitOrEvict(cache, key, generation) {
     try {
         return await generation;
     }
     catch (error) {
-        evictGeneration(cache, key, generation);
+        if (error instanceof TtscUnstableGenerationError &&
+            cache?.get(key) === generation) {
+            TERMINAL_TRANSFORM_GENERATIONS.set(generation, error);
+        }
+        else {
+            evictGeneration(cache, key, generation);
+        }
         throw error;
     }
 }
 /**
- * Extract the transformed source, evicting the generation when the result is a
- * host `"exception"` or compiler `"failure"` (which makes
- * {@link selectTransformedSource} throw). Such a failed generation must not be
- * replayed to later callers of an unchanged module.
+ * Extract the transformed source, and decide what a throwing generation is.
+ *
+ * {@link selectTransformedSource} throws for two different reasons, and only one
+ * of them is about the generation. A host `"exception"` or a compiler
+ * `"failure"` means the compile produced nothing for anyone: inside a pass that
+ * verdict is retained and replayed, because evicting it made every remaining
+ * module repeat the whole-project transform only to reach the identical answer
+ * (samchon/ttsc#1303), and outside a pass it keeps being evicted so a
+ * long-lived worker retries on its very next delivery exactly as before.
+ *
+ * A `"success"` envelope that has no output for the module asking is the other
+ * reason, and it is a fact about that one file: an ordinary condition for a
+ * module the bundle reaches and the tsconfig program does not contain. It is
+ * neither retained nor evicted. The error reaches the caller, and the
+ * generation, which compiled perfectly well for every other module, stays.
  */
-function selectOrEvict(cache, key, generation, props) {
+function selectOrEvict(cache, key, generation, epoch, props) {
     try {
         return selectTransformedSource(props);
     }
     catch (error) {
-        evictGeneration(cache, key, generation);
+        const verdict = retainPassVerdict(cache, key, generation, epoch, props.result, error);
+        if (verdict !== undefined) {
+            throw verdict;
+        }
+        // A generation that compiled fine and simply has no output for the module
+        // asking is not a failed generation. Discarding it made every later module
+        // recompile the whole project to reach the same answer, which is the cost
+        // samchon/ttsc#1303 is about, for a bundle that merely reaches a file the
+        // tsconfig program does not contain.
+        if (props.result.type !== "success") {
+            evictGeneration(cache, key, generation);
+        }
         throw error;
     }
 }
+/**
+ * Retain the verdict of a compile this pass already attempted, or return
+ * `undefined` when nothing may be retained.
+ *
+ * Only inside a delivery pass. A pass is the window in which every delivery is
+ * settled against the state the pass started from, so an attempt it already
+ * made is part of that state and the remaining modules replay it rather than
+ * each repeating a whole-project transform to reach the same answer. Outside a
+ * pass there is no such window, and a long-lived worker must keep retrying on
+ * its very next delivery so a transient host failure never becomes permanent.
+ */
+function retainPassVerdict(cache, key, generation, epoch, result, error) {
+    // Only an envelope that failed outright is a statement about the generation.
+    // `selectTransformedSource` also throws for a file the compile simply has no
+    // output for, which is an ordinary condition for a module the bundle reaches
+    // but the tsconfig program does not contain, and which says nothing about the
+    // other modules. Retaining that would fail the whole pass, naming a file none
+    // of them asked about.
+    if (result.type === "success" ||
+        epoch === undefined ||
+        cache?.get(key) !== generation) {
+        return undefined;
+    }
+    const existing = TERMINAL_TRANSFORM_GENERATIONS.get(generation);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const verdict = new TtscPassVerdictError(error, epoch);
+    TERMINAL_TRANSFORM_GENERATIONS.set(generation, verdict);
+    return verdict;
+}
+/**
+ * Whether a terminal verdict still answers for this delivery.
+ *
+ * Inside the pass that produced or confirmed it, it is replayed without
+ * re-probing anything: the pass settles every delivery against the state it
+ * started from, so re-walking the project once per module would spend exactly
+ * the cost this gate exists to remove.
+ *
+ * Across passes the two kinds part company. A pass verdict is dropped, because
+ * a new pass is the first boundary at which the host itself claims something
+ * may have changed, and the compile it stood for was never proven against a
+ * recorded environment. An unstable generation was, so it keeps its own rule:
+ * one fresh attempt per pass, and otherwise replayed until that recorded
+ * environment provably moves.
+ */
+function replaysTerminalGeneration(terminal, epoch, props) {
+    if (terminal instanceof TtscPassVerdictError) {
+        // A pass verdict has no recorded environment to re-confirm against, so the
+        // pass that produced it is its whole scope.
+        return epoch !== undefined && terminal.epoch === epoch;
+    }
+    if (!(terminal instanceof TtscUnstableGenerationError)) {
+        return false;
+    }
+    // An unstable generation does have one, and confirming it per delivery is the
+    // behaviour its own contract describes, so the pass does not cache that
+    // answer. A new pass still grants the fresh attempt the per-pass cache clear
+    // used to give it.
+    if (epoch !== undefined &&
+        terminal.validation.cached.deliveryEpoch !== epoch) {
+        return false;
+    }
+    return !failedGenerationEnvironmentChanged(terminal.validation, props);
+}
 /**
  * Delete a failed generation from the cache only when it is still the entry
  * stored under `key`. The identity check prevents an older failed generation's
@@ -318,6 +606,7 @@ function envelopeGraphIndexes(state, props) {
         members: new Set(),
         speculative: new Set(),
         inputProofs: new Map(),
+        inputProofFailures: new Map(),
         inputProofConflicts: new Set(),
     };
     const graph = props.result.type === "exception" ? undefined : props.result.graph;
@@ -335,7 +624,11 @@ function envelopeGraphIndexes(state, props) {
                 .filter((target) => typeof target === "string" && target.length !== 0)
                 .map((target) => {
                 const absoluteTarget = path.resolve(props.projectRoot, target);
-                built.members.add(derivationIdentity(state, absoluteTarget));
+                const targetIdentity = derivationIdentity(state, absoluteTarget);
+                built.members.add(targetIdentity);
+                if (!built.spellings.has(targetIdentity)) {
+                    built.spellings.set(targetIdentity, absoluteTarget);
+                }
                 return absoluteTarget;
             }));
             built.edges.set(identity, entries);
@@ -343,7 +636,10 @@ function envelopeGraphIndexes(state, props) {
         built.globals.push(...selectListedFiles(props.projectRoot, graph.globals));
         built.configs.push(...selectListedFiles(props.projectRoot, graph.configs));
         for (const input of [...built.globals, ...built.configs]) {
-            built.members.add(derivationIdentity(state, input));
+            const identity = derivationIdentity(state, input);
+            built.members.add(identity);
+            if (!built.spellings.has(identity))
+                built.spellings.set(identity, input);
         }
         const candidateEntries = Object.entries(graph.candidates ?? {}).filter((entry) => Array.isArray(entry[1]));
         // Every candidate source is an importing file the compiler read, so fold
@@ -351,7 +647,12 @@ function envelopeGraphIndexes(state, props) {
         // candidate could be classified speculative before a later entry proves
         // the same path is a realized source.
         for (const [source] of candidateEntries) {
-            built.members.add(derivationIdentity(state, path.resolve(props.projectRoot, source)));
+            const absoluteSource = path.resolve(props.projectRoot, source);
+            const identity = derivationIdentity(state, absoluteSource);
+            built.members.add(identity);
+            if (!built.spellings.has(identity)) {
+                built.spellings.set(identity, absoluteSource);
+            }
         }
         const realized = new Set(built.members);
         for (const [source, candidates] of candidateEntries) {
@@ -369,6 +670,17 @@ function envelopeGraphIndexes(state, props) {
                 if (!realized.has(identity))
                     built.speculative.add(identity);
                 built.members.add(identity);
+                if (!built.spellings.has(identity)) {
+                    built.spellings.set(identity, path.resolve(props.projectRoot, candidate));
+                }
+            }
+        }
+        const transformSources = new Set();
+        if (props.result.type === "success") {
+            for (const output of Object.keys(props.result.typescript)) {
+                if (!isDeclarationFile(output)) {
+                    transformSources.add(derivationIdentity(state, path.resolve(props.projectRoot, output)));
+                }
             }
         }
         for (const [input, hash] of Object.entries(graph.inputHashes ?? {})) {
@@ -388,8 +700,9 @@ function envelopeGraphIndexes(state, props) {
             }
             const absolute = path.resolve(props.projectRoot, input);
             const identity = derivationIdentity(state, absolute);
-            if (!built.members.has(identity))
+            if (!built.members.has(identity) && !transformSources.has(identity)) {
                 continue;
+            }
             const proof = {
                 hash,
                 path: absolute,
@@ -406,6 +719,23 @@ function envelopeGraphIndexes(state, props) {
                 built.inputProofs.set(identity, proof);
             }
         }
+        for (const [input, reason] of Object.entries(graph.inputProofFailures ?? {})) {
+            if (typeof reason !== "string" || !/^[a-z0-9-]{1,64}$/.test(reason)) {
+                continue;
+            }
+            const absolute = path.resolve(props.projectRoot, input);
+            const identity = derivationIdentity(state, absolute);
+            if (!built.members.has(identity) && !transformSources.has(identity)) {
+                continue;
+            }
+            if (built.inputProofs.has(identity)) {
+                built.inputProofs.delete(identity);
+                built.inputProofConflicts.add(identity);
+            }
+            if (!built.inputProofFailures.has(identity)) {
+                built.inputProofFailures.set(identity, reason);
+            }
+        }
     }
     state.graph = built;
     return built;
@@ -452,9 +782,51 @@ function collectDeclaredIdentities(state, projectRoot, listed) {
  * Envelope keys mirror the `typescript` keys (project-relative); values may be
  * project-relative or absolute. Every path is absolutized against the project
  * root and deduplicated; the file itself is dropped (the bundler already
- * watches the module it transforms), and so is the disposed temp-dir tsconfig
- * (see {@link TtscCachedProjectTransform.temporaryTsconfig}).
+ * watches the module it transforms), and so is every path in the disposed
+ * transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ */
+/**
+ * Register the failed generation's own project inputs so the host can observe
+ * the fix.
+ *
+ * A successful delivery registers the derived watch inputs, which is how a
+ * type-only file that no bundler graph contains still invalidates the modules
+ * depending on it. A failed one used to register nothing: `selectWatchInputs`
+ * returns an empty list for an `"exception"` envelope, and the throw happens
+ * before `notifyWatchInputs` is reached at all. When the failing compile is the
+ * first of a watching session, that leaves no channel through which the fix can
+ * arrive: the user repairs a file the bundler does not track, nothing is
+ * invalidated, and the error stays on screen (samchon/ttsc#1312).
+ *
+ * The generation records the project walk even when the compile failed, so the
+ * files a fix would touch are exactly what it already holds. The cost is paid
+ * only on a failure, and only until the next compile succeeds and narrows the
+ * set back to the derived inputs.
  */
+function notifyFailedGenerationInputs(hooks, cached) {
+    const addWatchFile = hooks?.addWatchFile;
+    if (addWatchFile === undefined) {
+        return;
+    }
+    for (const key of Object.keys(cached.inputHashes)) {
+        const input = path.resolve(cached.projectRoot, key);
+        if (isTransformScratchInput(input, cached.scratchDirectory)) {
+            continue;
+        }
+        // No evidence argument, deliberately. `missing: false` would be a claim
+        // this path cannot back: a failed generation is replayed for the rest of
+        // its pass without re-proving its inputs, so the walk that recorded them
+        // may be older than the delivery, and one of them having been deleted is a
+        // live reason for that compile to have failed. Letting the adapter probe
+        // also routes an absent input to the missing-input poll, which is the only
+        // channel through which restoring it can invalidate anything: a bundler
+        // watch on a path that does not exist registers nothing, and no module
+        // graph carries a type-only input. It costs one `existsSync` per input,
+        // and only where the adapter reads evidence at all, which is Vite serve.
+        addWatchFile(input);
+    }
+}
 function notifyWatchInputs(hooks, cached, file) {
     const addWatchFile = hooks?.addWatchFile;
     if (addWatchFile === undefined) {
@@ -466,6 +838,7 @@ function notifyWatchInputs(hooks, cached, file) {
         file,
         projectRoot: cached.projectRoot,
         result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
         temporaryTsconfig: cached.temporaryTsconfig,
     })) {
         // Hand the adapter the identity this generation already resolved and the
@@ -535,6 +908,7 @@ function deriveWatchInputs(state, props, fileIdentity) {
         const spelling = path.resolve(input);
         if (spelling === currentSpelling ||
             spelling === temporarySpelling ||
+            isTransformScratchInput(spelling, props.scratchDirectory) ||
             lexicalSeen.has(spelling)) {
             return;
         }
@@ -543,6 +917,8 @@ function deriveWatchInputs(state, props, fileIdentity) {
         output.push(input);
     };
     const appendPhysical = (input) => {
+        if (isTransformScratchInput(input, props.scratchDirectory))
+            return;
         const identity = derivationIdentity(state, input);
         if (excluded.has(identity) || physicalSeen.has(identity))
             return;
@@ -786,11 +1162,22 @@ function stripQuery(id) {
     return query === -1 ? id : id.slice(0, query);
 }
 /**
- * Returns `true` for TypeScript declaration files (`.d.ts`, `.d.mts`,
- * `.d.cts`).
+ * Returns `true` for every declaration-file spelling TypeScript-Go accepts.
+ * Besides the standard `.d.ts`, `.d.mts`, and `.d.cts` forms, TypeScript-Go
+ * treats an arbitrary-extension source such as `styles.d.css.ts` as a
+ * declaration file too.
  */
 function isDeclarationFile(id) {
-    return id.endsWith(".d.ts") || id.endsWith(".d.mts") || id.endsWith(".d.cts");
+    // Module ids can cross process/platform boundaries (for example, a Windows
+    // id inspected by a POSIX host). TypeScript-Go normalizes both separators
+    // before taking the basename, so a `.d.` directory component must not turn
+    // an ordinary source into a declaration file.
+    const normalized = id.replaceAll("\\", "/");
+    const base = normalized.slice(normalized.lastIndexOf("/") + 1);
+    return (base.endsWith(".d.ts") ||
+        base.endsWith(".d.mts") ||
+        base.endsWith(".d.cts") ||
+        (base.endsWith(".ts") && base.includes(".d.")));
 }
 /**
  * Returns `true` when the caller has explicitly opted out of all plugins. An
@@ -818,25 +1205,44 @@ function createTransformResult(source, code) {
  * state.
  *
  * Always compares the current module's in-memory source with the generation
- * snapshot. A cache whose owner called {@link beginTtscTransformBuild} can use
- * that comparison alone for a stable generation's first module delivery in the
- * current build. An incomplete generation may not take this shortcut: otherwise
- * a sibling output captured during a filesystem race could still be served
- * once. Later graph-bearing requests validate the file's derived input set and
- * project membership; graph-free envelopes conservatively re-hash the complete
- * project and out-of-walk snapshots. Any mismatch forces a complete
+ * snapshot. A cache with a delivery epoch can use that comparison alone for a
+ * stable generation's first delivery of each module in the current pass, once
+ * the pass's own first delivery has proven the whole generation still matches
+ * the filesystem. An incomplete generation may not take this shortcut:
+ * otherwise a sibling output captured during a filesystem race could still be
+ * served once. Later graph-bearing requests validate the file's derived input
+ * set and project membership; graph-free envelopes conservatively re-hash the
+ * complete project and out-of-walk snapshots. Any mismatch forces a complete
  * re-transform.
  */
-function matchesCachedSource(cached, file, source, buildScoped) {
+function matchesCachedSource(cached, file, source, epoch) {
     const identities = envelopeDerivation(cached).identityContext;
     const currentKey = toProjectKey(cached.projectRoot, file, identities);
-    if (cached.inputHashes[currentKey] !== hashText(source)) {
+    const identity = pathIdentityKey(file, identities);
+    const expected = cached.sourceHashes?.[identity] ??
+        cached.inputHashes[currentKey] ??
+        cached.externalInputHashes?.[identity];
+    if (expected !== hashText(source)) {
         return false;
     }
-    if (buildScoped &&
-        cached.projectSnapshotComplete === true &&
-        !cached.servedFiles?.has(pathIdentityKey(file, identities))) {
-        return true;
+    if (epoch !== undefined && cached.projectSnapshotComplete === true) {
+        if (cached.deliveryEpoch !== epoch) {
+            // The pass's first delivery. The generation was settled against an
+            // earlier pass, so prove the whole of it once — every input the envelope
+            // declares, the directory membership, the universal host inputs, and the
+            // out-of-walk snapshot — before any of this pass's deliveries may be
+            // settled against it. That proof is what a per-pass recompile used to buy
+            // (samchon/ttsc#1300), at a walk instead of a compile.
+            if (!matchesCompleteInputSnapshot(cached, currentKey, source)) {
+                return false;
+            }
+            cached.deliveryEpoch = epoch;
+            cached.servedFiles?.clear();
+            return true;
+        }
+        if (!cached.servedFiles?.has(identity)) {
+            return true;
+        }
     }
     if (cached.result.type !== "exception" &&
         cached.result.graph !== undefined &&
@@ -886,6 +1292,7 @@ function matchesNarrowPersistentInputs(cached, file) {
         file,
         projectRoot: cached.projectRoot,
         result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
         temporaryTsconfig: cached.temporaryTsconfig,
     });
     for (const input of inputs) {
@@ -1104,6 +1511,7 @@ function isMissingPathError(error) {
 function captureUniversalHostInputValidation(cached, currentFile) {
     const filesystem = resultFilesystem(cached.result);
     const state = envelopeDerivation(cached);
+    const failures = createGenerationProofFailures();
     const validation = {
         entries: new Map(),
         covered: new Set(),
@@ -1113,6 +1521,7 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         filesystem,
         projectRoot: cached.projectRoot,
         result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
         temporaryTsconfig: cached.temporaryTsconfig,
     })) {
         const generationHashes = cached.result.type === "exception"
@@ -1128,8 +1537,14 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         let readable = false;
         if (expected === undefined) {
             const current = path.resolve(currentFile);
-            if (path.resolve(input) !== current)
-                return undefined;
+            if (path.resolve(input) !== current) {
+                recordGenerationProofFailure(failures, {
+                    domain: "host",
+                    kind: "content-proof-missing",
+                    path: input,
+                });
+                return { failures };
+            }
             // The current module may be supplied from an unsaved editor buffer. Its
             // generation snapshot is overlaid below from `currentSource`, so a disk
             // fingerprint would be both unavailable and the wrong authority. The
@@ -1139,7 +1554,12 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         else {
             const current = hostInputStateHash(input, filesystem);
             if (expected !== current) {
-                return undefined;
+                recordGenerationProofFailure(failures, {
+                    domain: "host",
+                    kind: "content-changed",
+                    path: input,
+                });
+                return { failures };
             }
             // A path both sides agree they could not read carries no bytes for a
             // signature to stand for. It still belongs in the manifest, so the
@@ -1150,16 +1570,35 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         if (generationRealpaths !== undefined) {
             if (!Object.prototype.hasOwnProperty.call(generationRealpaths, absoluteInput) ||
                 !sameHostInputRealpath(generationRealpaths[absoluteInput], hostInputRealpath(input, filesystem), state.identityContext)) {
-                return undefined;
+                recordGenerationProofFailure(failures, {
+                    domain: "host",
+                    kind: Object.prototype.hasOwnProperty.call(generationRealpaths, absoluteInput)
+                        ? "realpath-changed"
+                        : "realpath-proof-missing",
+                    path: input,
+                });
+                return { failures };
             }
         }
         validation.covered.add(path.resolve(input));
         const before = inputMetadataEvidence(input, filesystem);
-        if (!matchesRecordedInput(cached, input))
-            return undefined;
+        if (!matchesRecordedInput(cached, input)) {
+            recordGenerationProofFailure(failures, {
+                domain: "host",
+                kind: "snapshot-mismatch",
+                path: input,
+            });
+            return { failures };
+        }
         const after = inputMetadataSignature(input, filesystem);
-        if (before?.signature !== after)
-            return undefined;
+        if (before?.signature !== after) {
+            recordGenerationProofFailure(failures, {
+                domain: "host",
+                kind: "changed-during-validation",
+                path: input,
+            });
+            return { failures };
+        }
         if (before !== undefined) {
             // Do not key this manifest by physical identity. A symlink/junction
             // spelling and its selected target deliberately share that identity,
@@ -1179,8 +1618,14 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         const probe = missingPathProbe(input, filesystem);
         if (probe.blocker !== undefined) {
             const signature = inputMetadataSignature(probe.blocker, filesystem);
-            if (signature === undefined)
-                return undefined;
+            if (signature === undefined) {
+                recordGenerationProofFailure(failures, {
+                    domain: "host",
+                    kind: "blocker-metadata-unavailable",
+                    path: probe.blocker,
+                });
+                return { failures };
+            }
             // A blocker proves a kind and an identity, not content: it is the
             // non-directory ancestor that makes everything below it unreachable, and
             // it cannot stop being that without its metadata moving. So it keeps a
@@ -1207,7 +1652,7 @@ function captureUniversalHostInputValidation(cached, currentFile) {
         names.add(normalizeHostInputName(probe.name, state.identityContext.caseSensitive(probe.directory)));
     }
     cached.hostInputValidation = validation;
-    return validation;
+    return { failures, validation };
 }
 /**
  * The recorded state of an input the generation read nothing from: absent, or
@@ -1505,14 +1950,21 @@ function matchesCompleteInputSnapshot(cached, currentKey, source) {
     const declaredInputs = declaredProjectInputKeys(state, cached);
     const current = collectProjectInputSnapshot(cached.projectRoot, state.identityContext, resultFilesystem(cached.result), cached.inputSignatures === undefined
         ? undefined
-        : { hashes: cached.inputHashes, signatures: cached.inputSignatures });
+        : { hashes: cached.inputHashes, signatures: cached.inputSignatures }, {
+        // Judge membership by the rule the compile ran under, and read only the
+        // inputs this comparison actually consults.
+        declaredKeys: declaredInputs,
+        policy: cached.membershipPolicy,
+    });
     if (!walkSnapshotComplete(current, declaredInputs)) {
         return false;
     }
     if (!sameProjectDirectories(cached.projectDirectories, current.projectDirectories)) {
         return false;
     }
-    current.hashes[currentKey] = hashText(source);
+    if (Object.prototype.hasOwnProperty.call(cached.inputHashes, currentKey)) {
+        current.hashes[currentKey] = hashText(source);
+    }
     if (!sameHashes(cached.inputHashes, current.hashes, declaredInputs)) {
         return false;
     }
@@ -1580,18 +2032,30 @@ function matchesExternalInputRealpaths(cached) {
 }
 /**
  * Capture external-input hashes without attaching post-compile state to an
- * earlier graph. Graph members must carry compiler-time proof and still match
- * it now; plugin-declared dependency-only paths retain the historical
- * post-compile snapshot because their own protocol does not claim generation
- * fingerprints.
+ * earlier graph. Graph members and out-of-walk transformed sources must carry
+ * compiler-time proof and still match it now; plugin-declared dependency-only
+ * paths retain the historical post-compile snapshot because their own protocol
+ * does not claim generation fingerprints.
  */
 function captureExternalInputSnapshot(cached, paths) {
     const state = envelopeDerivation(cached);
     const filesystem = resultFilesystem(cached.result);
     const graph = envelopeGraphIndexes(state, cached);
+    // A non-declaration transform output is a compiler-realized source even when
+    // a malformed or legacy graph omitted its node. Its output was computed from
+    // compiler-time bytes, so a post-compile host read cannot prove coherence.
+    const transformSources = new Set();
+    if (cached.result.type === "success") {
+        for (const output of Object.keys(cached.result.typescript)) {
+            if (!isDeclarationFile(output)) {
+                transformSources.add(derivationIdentity(state, path.resolve(cached.projectRoot, output)));
+            }
+        }
+    }
     const hashes = {};
     const realpaths = {};
     const signatures = {};
+    const failures = createGenerationProofFailures();
     let complete = true;
     // Sandwich every read between two metadata signatures. Only a signature that
     // survived its own read, and whose stamp's tick the filesystem's clock has
@@ -1609,21 +2073,47 @@ function captureExternalInputSnapshot(cached, paths) {
         // through to the recorded-state branch below, the same evidence a
         // plugin-declared dependency path carries. Its absence still invalidates
         // the generation when it appears, because `missing` is recorded state.
-        const speculativeOnly = graph.speculative.has(identity) &&
+        const realizedTransformSource = transformSources.has(identity);
+        const speculativeOnly = !realizedTransformSource &&
+            graph.speculative.has(identity) &&
             !graph.inputProofs.has(identity) &&
             !graph.inputProofConflicts.has(identity);
-        if (graph.members.has(identity) && !speculativeOnly) {
+        if ((realizedTransformSource || graph.members.has(identity)) &&
+            !speculativeOnly) {
             const proof = graph.inputProofs.get(identity);
             if (proof === undefined || graph.inputProofConflicts.has(identity)) {
                 complete = false;
+                recordGenerationProofFailure(failures, {
+                    domain: "external",
+                    kind: graph.inputProofConflicts.has(identity)
+                        ? "graph-proof-conflict"
+                        : "graph-proof-missing",
+                    detail: graph.inputProofFailures.get(identity),
+                    path: input,
+                });
                 continue;
             }
             const before = inputMetadataEvidence(input, filesystem);
             const currentHash = graphInputStateHash(input, filesystem);
+            const currentRealpath = hostInputRealpath(input, filesystem);
             const after = inputMetadataSignature(input, filesystem);
-            if (currentHash !== proof.hash ||
-                !sameHostInputRealpath(proof.realpath, hostInputRealpath(input, filesystem), state.identityContext)) {
+            const realpathMatches = sameHostInputRealpath(proof.realpath, currentRealpath, state.identityContext);
+            if (currentHash !== proof.hash || !realpathMatches) {
                 complete = false;
+                if (currentHash !== proof.hash) {
+                    recordGenerationProofFailure(failures, {
+                        domain: "external",
+                        kind: "graph-content-changed",
+                        path: input,
+                    });
+                }
+                if (!realpathMatches) {
+                    recordGenerationProofFailure(failures, {
+                        domain: "external",
+                        kind: "graph-realpath-changed",
+                        path: input,
+                    });
+                }
             }
             else if (currentHash !== null) {
                 // The recorded hash is the compiler's own proof, so a signature may
@@ -1643,27 +2133,30 @@ function captureExternalInputSnapshot(cached, paths) {
         if (hash !== null)
             record(input, before, after);
     }
-    return { complete, hashes, realpaths, signatures };
+    return { complete, failures, hashes, realpaths, signatures };
 }
-/** Verify every graph member still has the state read by the compiler. */
-function matchesCompilerGraphInputProofs(cached) {
+/** Explain every graph member that no longer matches the compiler's state. */
+function compilerGraphInputProofFailures(cached) {
+    const failures = createGenerationProofFailures();
     if (cached.result.type === "exception" ||
         cached.result.graph === undefined ||
         (cached.result.graph.inputHashes === undefined &&
-            cached.result.graph.inputRealpaths === undefined)) {
+            cached.result.graph.inputRealpaths === undefined &&
+            cached.result.graph.inputProofFailures === undefined)) {
         // Legacy sidecars remain compatible for ordinary in-project graphs. Their
         // out-of-walk members are still rejected by captureExternalInputSnapshot,
         // where a post-compile snapshot cannot prove the compiler's generation.
-        return true;
+        return failures;
     }
     const state = envelopeDerivation(cached);
     const filesystem = resultFilesystem(cached.result);
     const graph = envelopeGraphIndexes(state, cached);
-    if (graph.inputProofConflicts.size !== 0) {
-        return false;
-    }
     for (const identity of graph.members) {
         const proof = graph.inputProofs.get(identity);
+        const spelling = proof?.path ?? graph.spellings.get(identity) ?? cached.projectRoot;
+        if (isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            continue;
+        }
         // A speculative candidate has no compile-time read to prove. Requiring one
         // would void every generation of every project whose resolution passes over
         // a higher-priority spelling, which is every project with a dependency
@@ -1672,13 +2165,41 @@ function matchesCompilerGraphInputProofs(cached) {
         if (proof === undefined && graph.speculative.has(identity)) {
             continue;
         }
-        if (proof === undefined ||
-            graphInputStateHash(proof.path, filesystem) !== proof.hash ||
-            !sameHostInputRealpath(proof.realpath, hostInputRealpath(proof.path, filesystem), state.identityContext)) {
-            return false;
+        if (graph.inputProofConflicts.has(identity)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-conflict",
+                detail: graph.inputProofFailures.get(identity),
+                path: spelling,
+            });
+            continue;
+        }
+        if (proof === undefined) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-missing",
+                detail: graph.inputProofFailures.get(identity),
+                path: spelling,
+            });
+            continue;
+        }
+        const currentHash = graphInputStateHash(proof.path, filesystem);
+        if (currentHash !== proof.hash) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "content-changed",
+                path: proof.path,
+            });
+        }
+        if (!sameHostInputRealpath(proof.realpath, hostInputRealpath(proof.path, filesystem), state.identityContext)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "realpath-changed",
+                path: proof.path,
+            });
         }
     }
-    return true;
+    return failures;
 }
 /** Compare one derived input with the snapshot that owned it at generation. */
 function matchesRecordedInput(cached, input) {
@@ -1725,23 +2246,36 @@ function markCachedSourceServed(cached, file) {
  * slash path. Exported so hosts without a per-build boundary (`@ttsc/metro`)
  * can fold the identical input universe into their own cache fingerprints.
  */
-function collectProjectInputHashes(projectRoot, identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
-    return collectProjectInputSnapshot(projectRoot, identities, filesystem)
-        .hashes;
+function collectProjectInputHashes(projectRoot, identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy) {
+    return collectProjectInputSnapshot(projectRoot, identities, filesystem, undefined, {
+        policy,
+    }).hashes;
 }
 /** Hash project files and snapshot the directory topology in one walk. */
-function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, proven) {
+function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, proven, options) {
     const hashes = {};
     const fileSignatures = {};
     const provenSignatures = {};
     const unstableFiles = new Set();
     let attributed = true;
-    const walked = walkProjectInputs(projectRoot, filesystem);
+    const walked = walkProjectInputs(projectRoot, filesystem, options?.policy);
+    const walkFailures = [...walked.failures];
     let complete = walked.complete;
     for (const file of walked.files) {
         try {
-            const before = inputMetadataEvidence(file, filesystem);
             const key = toProjectKey(projectRoot, file, identities);
+            // A caller validating a generation compares hashes over that
+            // generation's declared inputs alone (`sameHashes` takes the declared key
+            // set), so reading anything else is work whose result is never consulted.
+            // Skipping it is what keeps a directory full of emitted files from
+            // costing a read per file on the pass that first sees them
+            // (samchon/ttsc#1307). Capture passes supply no restriction and still
+            // record the whole walk.
+            if (options?.declaredKeys !== undefined &&
+                !options.declaredKeys.has(key)) {
+                continue;
+            }
+            const before = inputMetadataEvidence(file, filesystem);
             // A file whose signature still equals the one captured around the read
             // that produced the recorded hash carries that content, so the whole
             // project does not have to be re-read to prove one delivery. A signature
@@ -1764,6 +2298,7 @@ function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAU
                 before.signature !== after) {
                 complete = false;
                 unstableFiles.add(key);
+                walkFailures.push({ kind: "file-changed-during-read", path: file });
             }
             else {
                 fileSignatures[key] = after;
@@ -1780,6 +2315,7 @@ function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAU
             // File watchers may observe a transform while another process is moving
             // or deleting files. The missing key invalidates older cache entries.
             complete = false;
+            walkFailures.push({ kind: "file-read-failed", path: file });
             try {
                 unstableFiles.add(toProjectKey(projectRoot, file, identities));
             }
@@ -1798,26 +2334,36 @@ function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAU
         projectDirectories: walked.directories,
         provenSignatures,
         unstableFiles,
+        walkFailures,
     };
 }
 /**
- * Enumerate every regular file under `root`, skipping well-known output and
- * tooling directories (see {@link isIgnoredProjectDirectory}).
+ * Enumerate every regular file under `root`, skipping the directories no
+ * configuration can name ({@link isIgnoredProjectDirectory}) and the ones the
+ * resolved configuration excludes ({@link isExcludedProjectDirectory}).
  *
  * Uses an iterative DFS instead of `fs.readdirSync` recursion to avoid
  * unbounded call-stack depth on deep project trees. The result is sorted so
  * that hash comparisons are deterministic across OS-level directory orderings.
  */
-function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy = tsconfigPaths.PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
     let complete = true;
-    const directories = [];
+    const failures = [];
     const files = [];
+    // Collected in one pass, then digested in a second. A directory's digest has
+    // to know whether each child directory can hold program inputs, and the walk
+    // learns that only after descending, so the two cannot be one pass.
+    const visited = [];
     const stack = [root];
     while (stack.length !== 0) {
         const current = stack.pop();
         const before = projectDirectorySignature(current, filesystem);
         if (before === undefined) {
             complete = false;
+            failures.push({
+                kind: "directory-metadata-unavailable",
+                path: current,
+            });
             continue;
         }
         let entries;
@@ -1826,39 +2372,112 @@ function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
         }
         catch {
             complete = false;
+            failures.push({ kind: "directory-read-failed", path: current });
             continue;
         }
         const after = projectDirectorySignature(current, filesystem);
         if (after === undefined || before !== after) {
             complete = false;
+            failures.push({
+                kind: after === undefined
+                    ? "directory-metadata-unavailable"
+                    : "directory-changed-during-walk",
+                path: current,
+            });
         }
-        directories.push({
+        const visit = {
+            childDirectories: [],
+            entries: [],
+            ownInput: false,
             path: current,
             // If membership moved during enumeration, force the next delivery to
             // replace this generation instead of blessing a torn directory/file
             // snapshot as stable.
-            signature: after !== undefined && before === after
-                ? after
+            stable: after !== undefined && before === after
+                ? undefined
                 : `unstable:${before}:${after ?? "missing"}`,
-        });
+        };
         for (const entry of entries) {
             if (isIgnoredProjectDirectory(entry.name)) {
                 continue;
             }
             const file = path.join(current, entry.name);
+            if (entry.isDirectory() && isExcludedProjectDirectory(file, policy)) {
+                continue;
+            }
+            const possible = isPossibleProgramEntry(entry, policy);
+            visit.entries.push({
+                kind: [
+                    entry.isDirectory(),
+                    entry.isFile(),
+                    entry.isSymbolicLink(),
+                ].join(":"),
+                name: entry.name,
+                possible,
+            });
             if (entry.isDirectory()) {
+                visit.childDirectories.push(file);
                 stack.push(file);
             }
-            else if (entry.isFile()) {
+            else if (entry.isFile() && possible) {
+                // Only a file that could enter the program is hashed. A file that
+                // could not is either irrelevant to every generation, or it is one the
+                // compiler actually read, in which case the graph reports it and
+                // `isProjectWalkPath` now agrees it is out of the walk, so it is
+                // recorded and proven by the out-of-walk snapshot instead. Hashing an
+                // emitted tree here bought nothing and cost a read per file, including
+                // in `@ttsc/metro`, whose fingerprint re-keys every transformed file
+                // (samchon/ttsc#1307).
                 files.push(file);
+                visit.ownInput = true;
             }
         }
+        visited.push(visit);
+    }
+    // A directory matters to program membership only if its subtree can hold a
+    // program input. Propagate that up from the directories that hold one, so a
+    // bundler creating `out/` and filling it with JavaScript a project admitting
+    // none can never compile is not a membership change at any level: not in the
+    // directory itself, and not in the parent that now lists it
+    // (samchon/ttsc#1307).
+    const byPath = new Map(visited.map((visit) => [visit.path, visit]));
+    const relevant = new Set();
+    for (const visit of visited) {
+        if (!visit.ownInput) {
+            continue;
+        }
+        let current = visit.path;
+        while (current !== undefined && !relevant.has(current)) {
+            relevant.add(current);
+            const parent = path.dirname(current);
+            current = parent === current || !byPath.has(parent) ? undefined : parent;
+        }
     }
+    const directories = visited.map((visit) => {
+        const membership = visit.entries
+            .filter((entry) => entry.possible &&
+            (!visit.childDirectories.includes(path.join(visit.path, entry.name)) ||
+                relevant.has(path.join(visit.path, entry.name))))
+            .map((entry) => `${entry.name}:${entry.kind}`);
+        return {
+            path: visit.path,
+            relevant: relevant.has(visit.path),
+            signature: visit.stable ??
+                hashText(membership.sort().join(String.fromCharCode(0))),
+        };
+    });
     directories.sort((left, right) => left.path.localeCompare(right.path));
     files.sort();
-    return { complete, directories, files };
+    return { complete, directories, failures, files };
 }
-/** Return a cheap identity for one directory's immediate membership. */
+/**
+ * Return a directory's metadata stamp, used to detect that its membership moved
+ * _while_ the walk was enumerating it, and to feed the observed-clock floor.
+ *
+ * This is the right instrument for that job and the wrong one for comparing two
+ * generations: it moves for ignored entries too. {@link walkProjectInputs}
+ * records the filtered membership digest for the comparison instead.
+ */
 function projectDirectorySignature(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
     try {
         const stats = filesystem.statBigInt(directory);
@@ -1883,9 +2502,24 @@ function projectDirectorySignature(directory, filesystem = DEFAULT_FILESYSTEM_OP
 }
 /** Compare two deterministic project-directory membership snapshots. */
 function sameProjectDirectories(left, right) {
-    return (left.length === right.length &&
-        left.every((directory, index) => directory.path === right[index]?.path &&
-            directory.signature === right[index]?.signature));
+    // Compare only the directories that can hold program inputs, on either side.
+    // A directory irrelevant on both is not part of the program's membership at
+    // all, so its appearance, disappearance or churn says nothing: that is a
+    // bundler's output tree. One that gained or lost relevance is present in the
+    // comparison from the side where it counts, and so is caught.
+    const select = (snapshots) => new Map(snapshots
+        .filter((directory) => directory.relevant)
+        .map((directory) => [directory.path, directory]));
+    const leftRelevant = select(left);
+    const rightRelevant = select(right);
+    const paths = new Set([...leftRelevant.keys(), ...rightRelevant.keys()]);
+    for (const location of paths) {
+        if (leftRelevant.get(location)?.signature !==
+            rightRelevant.get(location)?.signature) {
+            return false;
+        }
+    }
+    return true;
 }
 /**
  * Open one directory's change notification through the cache-owned watch seam,
@@ -1902,14 +2536,16 @@ function openDirectoryWatch(filesystem, directory, listener, onError) {
     return { close: () => watcher.close() };
 }
 /** Watch every walked directory for membership changes after generation. */
-async function createProjectMutationTracker(directories, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+async function createProjectMutationTracker(directories, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy = tsconfigPaths.PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
     const tracker = {
+        changes: new Set(),
+        changesOmitted: false,
         close: () => undefined,
         failed: false,
         membershipChanged: false,
     };
     if (process.platform === "win32" && filesystem.watch === undefined) {
-        await registerWindowsProjectMutationTracker(tracker, directories.map((directory) => ({ directory: directory.path })), false, filesystem);
+        await registerWindowsProjectMutationTracker(tracker, directories.map((directory) => ({ directory: directory.path })), false, filesystem, (location, filename) => reportsProgramMembership(path.join(location, filename), filename, policy, filesystem));
         return tracker;
     }
     const watchers = [];
@@ -1920,9 +2556,17 @@ async function createProjectMutationTracker(directories, filesystem = DEFAULT_FI
     };
     for (const directory of directories) {
         try {
-            watchers.push(openDirectoryWatch(filesystem, directory.path, (eventType) => {
-                if (eventType === "rename")
-                    tracker.membershipChanged = true;
+            watchers.push(openDirectoryWatch(filesystem, directory.path, (eventType, filename) => {
+                if (eventType !== "rename") {
+                    return;
+                }
+                if (filename !== null &&
+                    !reportsProgramMembership(path.join(directory.path, filename), filename, policy, filesystem)) {
+                    return;
+                }
+                recordProjectMutation(tracker, filename === null
+                    ? directory.path
+                    : path.join(directory.path, filename));
             }, () => {
                 tracker.failed = true;
             }));
@@ -1958,6 +2602,8 @@ async function createHostInputMutationTracker(inputs, filesystem, covered, event
         names: [...location.names],
     }));
     const tracker = {
+        changes: new Set(),
+        changesOmitted: false,
         close: () => undefined,
         // Coverage is the caller's claim, and it is required rather than derived
         // from the input list: an input is watched by its exact name here, but only
@@ -1991,7 +2637,9 @@ async function createHostInputMutationTracker(inputs, filesystem, covered, event
                     ? null
                     : normalizeHostInputName(filename, caseSensitive);
                 if (reported === null || names.has(reported)) {
-                    tracker.membershipChanged = true;
+                    recordProjectMutation(tracker, filename === null
+                        ? location.directory
+                        : path.join(location.directory, filename));
                 }
             }, () => {
                 tracker.failed = true;
@@ -2003,6 +2651,92 @@ async function createHostInputMutationTracker(inputs, filesystem, covered, event
     }
     return tracker;
 }
+/**
+ * Whether a path lies inside a directory the configuration excludes.
+ *
+ * Lexical, exactly like the walk and like {@link isProjectWalkPath}, and for the
+ * reason that predicate states: walk membership is lexical, so resolving a path
+ * to physical identity first would collapse two spellings the walk keeps apart
+ * and claim it covered a subtree it never followed. A junction whose target the
+ * walk hashes under its own name is exactly that, and canonicalizing here would
+ * suppress every event in it.
+ *
+ * `strictly` excludes an exact match, for the case where the excluded entry
+ * names a file rather than a directory: `exclude` accepts one, the walk applies
+ * exclusion to directories alone, so that file is still hashed and its events
+ * must keep counting.
+ */
+function insideExcludedProjectDirectory(location, policy, strictly) {
+    if (policy.excludedDirectories.length === 0) {
+        return false;
+    }
+    const resolved = path.resolve(location);
+    return policy.excludedDirectories.some((excluded) => {
+        const target = path.resolve(excluded);
+        if (strictly && target === resolved) {
+            return false;
+        }
+        return pathIsWithin(resolved, target);
+    });
+}
+/**
+ * Whether one directory event can be a change to the program's membership.
+ *
+ * The live tracker has to answer the same question the membership digest does,
+ * or the two disagree about the same project: a bundler writing content-hashed
+ * output fires a rename per rebuild, and treating that as membership kept the
+ * cost samchon/ttsc#1307 removes on every host that has no build boundary,
+ * which is every host the narrow path exists for.
+ *
+ * A name that could be a program input counts, unless it sits under a directory
+ * the walk never descends into. A name that could not still counts when the
+ * path is now a directory, because the walk's watches were opened for the
+ * directories that existed when the generation was captured, so a directory
+ * created since is not watched and the sources that may appear in it would
+ * otherwise be invisible. A directory the configuration excludes is the
+ * exception: the walk cannot see inside it, so the tracker must not either, or
+ * emptying and recreating an `outDir` costs a compile per build. An event whose
+ * name the host did not report is unattributable and always counts.
+ */
+function reportsProgramMembership(location, filename, policy, filesystem) {
+    if (isPossibleProgramFileName(filename, policy)) {
+        // A name the program could admit. It still says nothing if it lies inside a
+        // directory the walk never descends into, because the digest cannot see
+        // there either and the tracker must not be the one side that reacts.
+        return !insideExcludedProjectDirectory(location, policy, true);
+    }
+    let directory;
+    try {
+        directory = filesystem.lstat(location).isDirectory();
+    }
+    catch {
+        // Gone again, or unreadable. Its name could not have been a program input,
+        // and a directory removed under this one reports its own contents leaving
+        // through the watch that was opened on it.
+        return false;
+    }
+    if (!directory) {
+        return false;
+    }
+    // A directory counts, because it can hold sources and the tracker is not
+    // watching it yet, unless the configuration says the program does not contain
+    // it. Emptying and recreating an `outDir`, which is what `emptyOutDir` and
+    // `output.clean` do on every build, would otherwise void the generation once
+    // per build on every host that has no build boundary.
+    return !insideExcludedProjectDirectory(location, policy, false);
+}
+/** Record enough exact mutation evidence without retaining an event stream. */
+function recordProjectMutation(tracker, changed) {
+    tracker.membershipChanged = true;
+    if (tracker.changes.has(changed))
+        return;
+    if (tracker.changes.size < MAX_GENERATION_MUTATION_PATHS) {
+        tracker.changes.add(changed);
+    }
+    else {
+        tracker.changesOmitted = true;
+    }
+}
 let windowsProjectMutationBroker;
 /**
  * Register directory watches in an isolated Windows process.
@@ -2011,8 +2745,21 @@ let windowsProjectMutationBroker;
  * temporary tree is deleted. Isolation turns that unrecoverable process abort
  * into an ordinary broker exit and a conservative cache miss in the host.
  */
-async function registerWindowsProjectMutationTracker(tracker, locations, allEvents, filesystem) {
+async function registerWindowsProjectMutationTracker(tracker, locations, allEvents, filesystem, 
+/**
+ * Optional filter for the project-directory tracker, whose events have to be
+ * narrowed to program membership exactly as the in-process watcher's are. The
+ * name-watching trackers pass none, since they already watch exact names.
+ */
+membership) {
     const broker = getWindowsProjectMutationBroker();
+    // The child watches canonical directories, and reports its events under that
+    // spelling. Everything else in the adapter speaks the walk's own spelling,
+    // which on Windows can be an 8.3 short form of the same directory, so keep
+    // the way back: a filter that compared the child's spelling against the
+    // configuration's would be comparing two names for one directory that share
+    // no common prefix (samchon/ttsc#1307).
+    const spellings = new Map();
     const normalized = locations.map((location) => {
         let directory;
         try {
@@ -2021,6 +2768,7 @@ async function registerWindowsProjectMutationTracker(tracker, locations, allEven
         catch {
             directory = path.resolve(location.directory);
         }
+        spellings.set(directory, location.directory);
         return {
             directory,
             ...(location.names === undefined ? {} : { names: location.names }),
@@ -2034,7 +2782,12 @@ async function registerWindowsProjectMutationTracker(tracker, locations, allEven
     const ready = new Promise((resolve) => {
         resolveReady = resolve;
     });
-    broker.trackers.set(id, { ready: resolveReady, tracker });
+    broker.trackers.set(id, {
+        membership,
+        ready: resolveReady,
+        spellings,
+        tracker,
+    });
     tracker.drain = () => drainWindowsProjectMutationBroker(broker);
     tracker.close = () => {
         const active = broker.trackers.get(id);
@@ -2128,7 +2881,22 @@ function getWindowsProjectMutationBroker() {
         if (record.ready === true)
             registration.ready();
         if (record.ready !== true && record.failed !== true) {
-            registration.tracker.membershipChanged = true;
+            if (typeof record.directory === "string") {
+                // The walk's spelling for this directory, which is what every
+                // comparison and every recorded witness downstream expects.
+                const reported = registration.spellings.get(record.directory) ?? record.directory;
+                if (typeof record.filename === "string" &&
+                    registration.membership !== undefined &&
+                    !registration.membership(reported, record.filename)) {
+                    return;
+                }
+                recordProjectMutation(registration.tracker, typeof record.filename === "string"
+                    ? path.join(reported, record.filename)
+                    : reported);
+            }
+            else {
+                registration.tracker.membershipChanged = true;
+            }
         }
     });
     windowsProjectMutationBroker = broker;
@@ -2212,7 +2980,7 @@ const WINDOWS_WATCH_BROKER_SOURCE = [
     "      const names = location.names === undefined ? undefined : new Set(location.names.map((name) => name.toLowerCase()));",
     "      const watcher = fs.watch(location.directory, { persistent: false }, (event, filename) => {",
     "        const matches = names === undefined || filename === null || names.has(String(filename).toLowerCase());",
-    '        if (matches && (message.allEvents || event === "rename")) process.send?.({ id: message.id });',
+    '        if (matches && (message.allEvents || event === "rename")) process.send?.({ directory: location.directory, filename: filename === null ? null : String(filename), id: message.id });',
     "      });",
     '      watcher.on("error", () => process.send?.({ failed: true, id: message.id }));',
     "      watchers.push(watcher);",
@@ -2303,7 +3071,7 @@ async function settleProjectMutationEvents(cached) {
  * Missing paths and files reached through symlinks or Windows junctions are
  * out-of-walk inputs that only the reference graph can prove relevant.
  */
-function isProjectWalkPath(root, file, _identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+function isProjectWalkPath(root, file, _identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy = tsconfigPaths.PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
     // Walk membership is lexical. Resolving `file` to physical identity first
     // would turn `root/alias/value.ts` into `root/target/value.ts`, hide the
     // symlink segment from the lstat loop below, and falsely claim the project
@@ -2317,7 +3085,20 @@ function isProjectWalkPath(root, file, _identities = createHostPathIdentityConte
         return false;
     }
     const segments = relative.split(path.sep);
-    if (segments.some(isIgnoredProjectDirectory)) {
+    // The last segment is the file itself, which the walk names rather than
+    // descends into, so only the directory components decide walk membership.
+    if (segments.slice(0, -1).some(isIgnoredProjectDirectory)) {
+        return false;
+    }
+    if (isExcludedProjectDirectory(path.dirname(path.resolve(file)), policy)) {
+        return false;
+    }
+    // The walk hashes only files that could enter the program, so a path it does
+    // not hash is out of the walk by definition. Answering otherwise would leave
+    // a graph input the compiler really read in neither snapshot: absent from
+    // `inputHashes` because the walk skipped it, and absent from the out-of-walk
+    // snapshot because this predicate claimed the walk covered it.
+    if (!isPossibleProgramFileName(path.basename(file), policy)) {
         return false;
     }
     let current = resolvedRoot;
@@ -2419,12 +3200,13 @@ function matchesCachedExternalInputs(cached) {
 }
 /**
  * Derive the absolute out-of-walk input set of a whole project transform: the
- * union of every reference-graph member (edge keys and targets, globals, the
- * config chain) and every plugin-reported dependency, minus everything the
- * project walk already hashes and the disposed temp-dir tsconfig. These are the
- * inputs {@link matchesCachedSource}'s walk cannot see. Resolution candidates
- * that are still missing remain in this set even under the project root: the
- * first walk cannot hash a file that has not been created yet.
+ * union of every transformed source key, reference-graph member (edge keys and
+ * targets, globals, the config chain), and plugin-reported dependency, minus
+ * everything the project walk already hashes and the disposed transform scratch
+ * tree. These are the inputs {@link matchesCachedSource}'s walk cannot see.
+ * Resolution candidates that are still missing remain in this set even under
+ * the project root: the first walk cannot hash a file that has not been created
+ * yet.
  *
  * A `dependenciesComplete` declaration deliberately does not narrow the stored
  * set: other files in the same whole-project result can still own the omitted
@@ -2441,6 +3223,10 @@ function selectExternalInputPaths(props) {
     const identities = createHostPathIdentityContext(filesystem);
     const resolutionCandidates = new Set();
     const graph = props.result.graph;
+    // Every transform output key names the source file whose transformed text it
+    // carries. Keep an out-of-walk source in the external snapshot instead of
+    // injecting it into the project-walk key universe (samchon/ttsc#252).
+    members.push(...Object.keys(props.result.typescript));
     if (graph !== undefined) {
         for (const [source, targets] of Object.entries(graph.edges ?? {})) {
             members.push(source);
@@ -2497,9 +3283,10 @@ function selectExternalInputPaths(props) {
         const identity = pathIdentityKey(absolute, identities);
         const missingCandidate = resolutionCandidates.has(identity) && !filesystem.exists(absolute);
         if (identity === excluded ||
+            isTransformScratchInput(absolute, props.scratchDirectory) ||
             seen.has(spelling) ||
             (!missingCandidate &&
-                isProjectWalkPath(props.projectRoot, absolute, identities, filesystem))) {
+                isProjectWalkPath(props.projectRoot, absolute, identities, filesystem, props.membershipPolicy))) {
             continue;
         }
         // Preserve distinct lexical aliases even when they currently select the
@@ -2560,6 +3347,7 @@ function selectNotifiableAbsentInputs(props) {
             const absolute = path.resolve(props.projectRoot, candidate);
             const spelling = path.resolve(absolute);
             if (seen.has(spelling) ||
+                isTransformScratchInput(absolute, props.scratchDirectory) ||
                 (excluded !== undefined &&
                     pathIdentityKey(absolute, identities) === excluded) ||
                 props.filesystem.exists(absolute)) {
@@ -2661,21 +3449,44 @@ function insideProject(directory, projectRoot) {
  */
 const NOTIFIABLE_ABSENCE_DIRECTORY_LIMIT = 512;
 function isIgnoredProjectDirectory(name) {
-    return (name === ".git" ||
-        name === ".ttsc" ||
-        name === ".cache" ||
-        name === ".next" ||
-        name === ".nuxt" ||
-        name === ".svelte-kit" ||
-        name === ".turbo" ||
-        name === ".vite" ||
-        name === "build" ||
-        name === "coverage" ||
-        name === "dist" ||
-        name === "node_modules" ||
-        name === "out" ||
-        name === "temp" ||
-        name === "tmp");
+    // The residue of what used to be a fifteen-name list, kept to the three
+    // directories no tsconfig can name and no program can contain: the VCS
+    // store, the package manager's tree (TypeScript's own default `exclude`
+    // carries it too), and ttsc's own plugin cache. Everything else the old list
+    // guessed at, and guessing was wrong in both directions: a bundler writing
+    // to an unnamed directory changed project membership with its own output,
+    // while a real source directory named `build` or `temp` was dropped from the
+    // walk and its new files were never seen (samchon/ttsc#1307). Those are now
+    // decided by `ITtscProjectMembershipPolicy`, which reads the configuration
+    // that actually knows.
+    return name === ".git" || name === ".ttsc" || name === "node_modules";
+}
+/**
+ * Whether the resolved configuration keeps this directory out of the program.
+ *
+ * Compared by physical containment rather than by name, so `outDir: "./dist"`
+ * excludes that one directory instead of every directory called `dist` at every
+ * depth, which is the distinction the name list could not draw.
+ */
+function isExcludedProjectDirectory(directory, policy) {
+    return insideExcludedProjectDirectory(directory, policy, false);
+}
+/**
+ * Whether this entry could enter the program, and so whether its appearance or
+ * removal is a membership change.
+ *
+ * A directory always could, since it can hold sources. A file could only if it
+ * carries an extension the resolved configuration admits, which is what makes a
+ * bundle emitted beside the sources invisible to a project that compiles no
+ * JavaScript.
+ */
+function isPossibleProgramEntry(entry, policy) {
+    return entry.isFile() ? isPossibleProgramFileName(entry.name, policy) : true;
+}
+/** The same question for a bare file name, for callers holding no `Dirent`. */
+function isPossibleProgramFileName(name, policy) {
+    const lowered = name.toLowerCase();
+    return policy.inputExtensions.some((extension) => lowered.endsWith(extension));
 }
 /**
  * Compare two project-walk snapshots.
@@ -2732,6 +3543,103 @@ function walkSnapshotComplete(snapshot, declared) {
     }
     return true;
 }
+/** Preserve exact project-walk and mutation witnesses for one failed attempt. */
+function recordProjectSnapshotFailures(failures, props) {
+    const recordWalk = (snapshot) => {
+        for (const failure of snapshot.walkFailures) {
+            if (failure.kind.startsWith("file-") && props.declared !== undefined) {
+                try {
+                    const key = toProjectKey(props.projectRoot, failure.path, props.identities);
+                    if (!props.declared.has(key))
+                        continue;
+                }
+                catch {
+                    // An unidentifiable failed input taints the complete project walk.
+                }
+            }
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind: failure.kind,
+                path: failure.path,
+            });
+        }
+    };
+    recordWalk(props.before);
+    recordWalk(props.snapshot);
+    const keys = props.declared ??
+        new Set([
+            ...Object.keys(props.before.hashes),
+            ...Object.keys(props.snapshot.hashes),
+        ]);
+    for (const key of keys) {
+        if (props.before.hashes[key] !== props.snapshot.hashes[key]) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind: "input-content-changed",
+                path: path.resolve(props.projectRoot, key),
+            });
+        }
+        if (props.before.fileSignatures[key] !== props.snapshot.fileSignatures[key]) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind: "input-metadata-changed",
+                path: path.resolve(props.projectRoot, key),
+            });
+        }
+    }
+    const leftDirectories = new Map(props.before.projectDirectories.map((entry) => [
+        entry.path,
+        entry.signature,
+    ]));
+    const rightDirectories = new Map(props.snapshot.projectDirectories.map((entry) => [
+        entry.path,
+        entry.signature,
+    ]));
+    for (const directory of new Set([
+        ...leftDirectories.keys(),
+        ...rightDirectories.keys(),
+    ])) {
+        if (leftDirectories.get(directory) !== rightDirectories.get(directory)) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind: "directory-membership-changed",
+                path: directory,
+            });
+        }
+    }
+    const recordTracker = (tracker, kind) => {
+        if (tracker?.membershipChanged !== true)
+            return;
+        if (tracker.changes.size === 0) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind,
+                path: props.projectRoot,
+            });
+            return;
+        }
+        for (const changed of tracker.changes) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind,
+                path: changed,
+            });
+        }
+        if (tracker.changesOmitted) {
+            failures.omitted = Math.min(Number.MAX_SAFE_INTEGER, failures.omitted + 1);
+        }
+    };
+    recordTracker(props.tracker, "project-membership-event");
+    recordTracker(props.hostInputTracker, "host-input-event");
+    recordTracker(props.candidateTracker, "candidate-event");
+    if (failures.entries.length === 0) {
+        recordGenerationProofFailure(failures, {
+            domain: "project",
+            kind: "snapshot-incomplete",
+            path: props.projectRoot,
+        });
+    }
+}
 /** {@link selectDeclaredProjectInputKeys} memoized per envelope generation. */
 function declaredProjectInputKeys(state, cached) {
     if (state.declaredInputKeysBuilt !== true) {
@@ -2739,6 +3647,7 @@ function declaredProjectInputKeys(state, cached) {
             identities: state.identityContext,
             projectRoot: cached.projectRoot,
             result: cached.result,
+            scratchDirectory: cached.scratchDirectory,
         });
         state.declaredInputKeysBuilt = true;
     }
@@ -2759,7 +3668,10 @@ function selectDeclaredProjectInputKeys(props) {
     const add = (entry) => {
         if (typeof entry !== "string" || entry.length === 0)
             return;
-        keys.add(toProjectKey(props.projectRoot, path.resolve(props.projectRoot, entry), props.identities));
+        const absolute = path.resolve(props.projectRoot, entry);
+        if (isTransformScratchInput(absolute, props.scratchDirectory))
+            return;
+        keys.add(toProjectKey(props.projectRoot, absolute, props.identities));
     };
     for (const [source, targets] of Object.entries(graph.edges ?? {})) {
         add(source);
@@ -2791,46 +3703,231 @@ function selectDeclaredProjectInputKeys(props) {
     }
     return keys;
 }
+/** Create an empty bounded witness collection for one transform attempt. */
+function createGenerationProofFailures() {
+    return { entries: [], omitted: 0, seen: new Set() };
+}
+/** Retain one unique proof witness without allowing diagnostics to grow freely. */
+function recordGenerationProofFailure(failures, failure) {
+    const key = JSON.stringify([
+        failure.domain,
+        failure.kind,
+        failure.path,
+        failure.detail,
+    ]);
+    if (failures.seen.has(key))
+        return;
+    if (failures.entries.length < MAX_GENERATION_PROOF_FAILURES) {
+        // `seen` follows the same bound as `entries`: retaining every discarded
+        // identity would make a bounded diagnostic an unbounded memory sink.
+        failures.seen.add(key);
+        failures.entries.push(failure);
+    }
+    else {
+        failures.omitted = Math.min(Number.MAX_SAFE_INTEGER, failures.omitted + 1);
+    }
+}
+/** Fold one bounded witness collection into another. */
+function mergeGenerationProofFailures(target, source) {
+    for (const failure of source.entries) {
+        recordGenerationProofFailure(target, failure);
+    }
+    target.omitted = Math.min(Number.MAX_SAFE_INTEGER, target.omitted + source.omitted);
+}
+/** Hash the declared-input-relevant failure shape without retaining it. */
+function projectWalkFailureFingerprint(snapshot, declared, projectRoot, identities) {
+    const relevantUnstableFiles = declared === undefined
+        ? [...snapshot.unstableFiles]
+        : [...snapshot.unstableFiles].filter((key) => declared.has(key));
+    const relevantFailures = snapshot.walkFailures.filter((failure) => {
+        if (!failure.kind.startsWith("file-"))
+            return true;
+        if (declared === undefined)
+            return true;
+        try {
+            return declared.has(toProjectKey(projectRoot, failure.path, identities));
+        }
+        catch {
+            return true;
+        }
+    });
+    return hashText(JSON.stringify({
+        complete: walkSnapshotComplete(snapshot, declared),
+        directoryComplete: snapshot.directoryComplete,
+        failures: relevantFailures
+            .map((failure) => `${failure.kind}\0${path.resolve(failure.path)}`)
+            .sort(),
+        unstableFiles: relevantUnstableFiles.sort(),
+    }));
+}
+/** Compact state of one exact out-of-walk input in a failed generation. */
+function failedGenerationInputState(input, filesystem) {
+    let directory = "not-directory";
+    try {
+        if (filesystem.stat(input).isDirectory()) {
+            directory = hashText(filesystem
+                .readdir(input)
+                .map((entry) => [
+                entry.name,
+                entry.isDirectory(),
+                entry.isFile(),
+                entry.isSymbolicLink(),
+            ].join(":"))
+                .sort()
+                .join("\0"));
+        }
+    }
+    catch {
+        directory = "unavailable";
+    }
+    return hashText(JSON.stringify([
+        inputMetadataSignature(input, filesystem) ?? "missing",
+        hostInputStateHash(input, filesystem) ?? MISSING_INPUT_STATE,
+        hostInputRealpath(input, filesystem),
+        directory,
+    ]));
+}
+/** Snapshot every input outside the project walk that could change a retry. */
+function captureFailedGenerationInputStates(cached, failures) {
+    const filesystem = resultFilesystem(cached.result);
+    const inputs = new Set((cached.externalInputPaths ?? []).map((input) => path.resolve(input)));
+    for (const input of selectPersistentHostInputs({
+        filesystem,
+        projectRoot: cached.projectRoot,
+        result: cached.result,
+        scratchDirectory: cached.scratchDirectory,
+        temporaryTsconfig: cached.temporaryTsconfig,
+    })) {
+        inputs.add(path.resolve(input));
+    }
+    for (const failure of failures.entries) {
+        if (failure.path !== undefined)
+            inputs.add(path.resolve(failure.path));
+    }
+    return new Map([...inputs]
+        .sort()
+        .map((input) => [input, failedGenerationInputState(input, filesystem)]));
+}
+/** Capture source baselines for project and out-of-walk transform outputs. */
+function captureTransformSourceHashes(cached, currentFile, currentSourceHash) {
+    const filesystem = resultFilesystem(cached.result);
+    const identities = envelopeDerivation(cached).identityContext;
+    const hashes = {};
+    if (cached.result.type === "success") {
+        for (const output of Object.keys(cached.result.typescript)) {
+            const file = path.resolve(cached.projectRoot, output);
+            const hash = hostInputStateHash(file, filesystem);
+            if (hash !== null)
+                hashes[pathIdentityKey(file, identities)] = hash;
+        }
+    }
+    hashes[pathIdentityKey(currentFile, identities)] = currentSourceHash;
+    return hashes;
+}
 /**
- * Project roots already told they cannot reuse a compile, so a build reports
- * the condition once instead of once per module.
- */
-const REPORTED_UNREUSABLE_GENERATIONS = new Set();
-/**
- * Report, once per project root, that a generation cannot be reused.
+ * Whether a terminal proof failure's observed environment actually changed.
  *
- * Every module of the build then recompiles the whole project, so the condition
- * is the difference between one compile and one compile per module. It stayed
- * invisible for the whole life of samchon/ttsc#970: consumers saw only a build
- * that never finished, and each investigation had to rediscover the cause from
- * outside. A named reason turns the next occurrence into a bug report instead
- * of an archaeology session.
+ * This is deliberately a confirmation test: inability to re-probe retains the
+ * old verdict instead of turning every module request into another compile.
+ * Cache lifecycle reset remains the unconditional recovery boundary.
  */
-function reportUnreusableGeneration(cached, evidence) {
-    const missing = [
-        ...(evidence.walkStable ? [] : ["a stable project snapshot"]),
-        ...(evidence.graphProofs ? [] : ["compiler proofs for its graph inputs"]),
-        ...(evidence.externalInputs
-            ? []
-            : ["a complete out-of-walk input snapshot"]),
-        ...(evidence.universalInputs ? [] : ["a universal host-input manifest"]),
-    ];
-    const key = `${cached.projectRoot}\0${missing.join(",")}`;
-    if (REPORTED_UNREUSABLE_GENERATIONS.has(key)) {
-        return;
+function failedGenerationEnvironmentChanged(validation, props) {
+    try {
+        const identities = envelopeDerivation(validation.cached).identityContext;
+        const currentSourceHash = hashText(props.currentSource);
+        const expectedSourceHash = validation.cached.sourceHashes?.[pathIdentityKey(props.currentFile, identities)];
+        if (expectedSourceHash !== undefined &&
+            expectedSourceHash !== currentSourceHash) {
+            return true;
+        }
+        const current = collectProjectInputSnapshot(validation.cached.projectRoot, identities, props.filesystem, undefined, { policy: validation.cached.membershipPolicy });
+        if (validation.projectWalkComplete !==
+            walkSnapshotComplete(current, validation.declaredInputs) ||
+            validation.projectWalkFailures !==
+                projectWalkFailureFingerprint(current, validation.declaredInputs, validation.cached.projectRoot, identities) ||
+            !sameHashes(validation.projectInputHashes, current.hashes, validation.declaredInputs) ||
+            !sameProjectDirectories(validation.cached.projectDirectories ?? [], current.projectDirectories)) {
+            return true;
+        }
+        for (const [input, recorded] of validation.inputStates) {
+            if (failedGenerationInputState(input, props.filesystem) !== recorded) {
+                return true;
+            }
+        }
+        return false;
     }
-    REPORTED_UNREUSABLE_GENERATIONS.add(key);
-    process.stderr.write(`ttsc: the transform cache cannot reuse this project's compile, so every ` +
-        `module recompiles the whole project.\n` +
-        `  project: ${cached.projectRoot}\n` +
-        `  missing: ${missing.join("; ")}\n` +
-        `  Please report this at https://github.com/samchon/ttsc/issues with ` +
-        `this message.\n`);
+    catch {
+        return false;
+    }
+}
+/** Render one input without leaking source content or control characters. */
+function formatGenerationFailurePath(projectRoot, input) {
+    const absolute = path.resolve(input);
+    const relative = path.relative(projectRoot, absolute);
+    const display = relative === ""
+        ? "."
+        : relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)
+            ? relative
+            : absolute;
+    return JSON.stringify(display.split(path.sep).join("/"));
+}
+/** Build the terminal error shared by every waiter of an unstable generation. */
+function createUnstableGenerationError(projectRoot, attempts, validation) {
+    const lines = [
+        `ttsc: could not capture a reusable transform generation after ${attempts.length} attempts.`,
+        `  project: ${projectRoot}`,
+    ];
+    attempts.forEach((failures, index) => {
+        lines.push(`  attempt ${index + 1}:`);
+        if (failures.entries.length === 0) {
+            lines.push("    - project/generation-proof-incomplete");
+        }
+        for (const failure of failures.entries) {
+            const input = failure.path === undefined
+                ? ""
+                : `: ${formatGenerationFailurePath(projectRoot, failure.path)}`;
+            const detail = failure.detail === undefined
+                ? ""
+                : ` (producer: ${JSON.stringify(failure.detail)})`;
+            lines.push(`    - ${failure.domain}/${failure.kind}${input}${detail}`);
+        }
+        if (failures.omitted !== 0) {
+            lines.push(`    - ... ${failures.omitted} additional witness(es) omitted`);
+        }
+    });
+    lines.push("  Stop writes to the listed inputs before compilation, or fix the producer that omitted or contradicted the listed proof.");
+    return new TtscUnstableGenerationError(lines.join("\n"), validation);
 }
 function hashText(input) {
     return crypto.createHash("sha256").update(input).digest("hex");
 }
 async function transformProject(props) {
+    const attempts = [];
+    for (let attempt = 0; attempt < TRANSFORM_GENERATION_ATTEMPTS; attempt += 1) {
+        const cached = await captureTransformGeneration(props);
+        if (!props.trackProjectMembership ||
+            cached.result.type !== "success" ||
+            cached.projectSnapshotComplete === true) {
+            return cached;
+        }
+        attempts.push(TRANSFORM_GENERATION_FAILURES.get(cached.result) ??
+            createGenerationProofFailures());
+        if (attempt + 1 === TRANSFORM_GENERATION_ATTEMPTS) {
+            const validation = TRANSFORM_FAILED_GENERATION_VALIDATIONS.get(cached.result);
+            if (validation === undefined) {
+                disposeCachedTransform(cached);
+                throw new Error("ttsc: failed transform generation has no retry validation baseline");
+            }
+            throw createUnstableGenerationError(path.dirname(props.tsconfig), attempts, validation);
+        }
+        disposeCachedTransform(cached);
+    }
+    throw new Error("ttsc: transform generation retry loop did not terminate");
+}
+/** Capture one whole-project transform attempt and all of its reuse proofs. */
+async function captureTransformGeneration(props) {
     const projectRoot = path.dirname(props.tsconfig);
     const scratchDirectory = createTransformScratchDirectory(projectRoot, props.filesystem);
     let tracker;
@@ -2843,9 +3940,14 @@ async function transformProject(props) {
         const configured = createTransformTsconfig(props, scratchDirectory);
         const temporaryTsconfig = configured.path === props.tsconfig ? undefined : configured.path;
         const identities = createHostPathIdentityContext(props.filesystem);
-        const before = collectProjectInputSnapshot(projectRoot, identities, props.filesystem);
+        // Read from the project's own tsconfig rather than the generated one: a
+        // relative `outDir` is anchored at the config that declares it, and the
+        // generated config lives in a system temp directory. The caller's
+        // compiler-options overlay still wins, since it wins for the compile too.
+        const membershipPolicy = tsconfigPaths.mergeMembershipPolicyOverlay(tsconfigPaths.readProjectMembershipPolicy(props.tsconfig), props.compilerOptions, projectRoot);
+        const before = collectProjectInputSnapshot(projectRoot, identities, props.filesystem, undefined, { policy: membershipPolicy });
         tracker = props.trackProjectMembership
-            ? await createProjectMutationTracker(before.projectDirectories, props.filesystem)
+            ? await createProjectMutationTracker(before.projectDirectories, props.filesystem, membershipPolicy)
             : undefined;
         const result = withTransformScratchEnvironment(scratchDirectory, () => new ttsc.TtscCompiler({
             cwd: projectRoot,
@@ -2870,6 +3972,7 @@ async function transformProject(props) {
             filesystem: props.filesystem,
             projectRoot,
             result,
+            scratchDirectory,
             temporaryTsconfig,
         });
         // The generation's absent resolution candidates, which get a watcher of
@@ -2885,6 +3988,7 @@ async function transformProject(props) {
                 filesystem: props.filesystem,
                 projectRoot,
                 result,
+                scratchDirectory,
                 temporaryTsconfig,
             })
             : { candidates: [], watched: [] };
@@ -2908,11 +4012,13 @@ async function transformProject(props) {
                 : undefined;
         const externalInputPaths = selectExternalInputPaths({
             filesystem: props.filesystem,
+            membershipPolicy,
             projectRoot,
             result,
+            scratchDirectory,
             temporaryTsconfig,
         });
-        const inputSnapshot = collectProjectInputSnapshot(projectRoot, identities, props.filesystem);
+        const inputSnapshot = collectProjectInputSnapshot(projectRoot, identities, props.filesystem, undefined, { policy: membershipPolicy });
         // Whether the recorded snapshot describes one coherent state of the
         // project. A membership event during the compile taints it exactly like an
         // unstable walk pair; whether notifications can be *opened* is a separate
@@ -2922,6 +4028,7 @@ async function transformProject(props) {
             identities,
             projectRoot,
             result,
+            scratchDirectory,
         });
         const walkStable = walkSnapshotComplete(before, declaredInputs) &&
             walkSnapshotComplete(inputSnapshot, declaredInputs) &&
@@ -2937,29 +4044,44 @@ async function transformProject(props) {
         // Overlay the in-memory source only after proving the two on-disk snapshots
         // stable; an unsaved editor buffer must not look like a compile-time race.
         const currentFileKey = toProjectKey(projectRoot, props.currentFile, identities);
-        inputSnapshot.hashes[currentFileKey] = hashText(props.currentSource);
-        // That overlay makes this one key the only recorded hash a disk signature
-        // cannot stand for: the bytes it names came from the bundler, not the file.
-        delete inputSnapshot.provenSignatures[currentFileKey];
+        const currentSourceHash = hashText(props.currentSource);
+        const projectInputHashes = { ...inputSnapshot.hashes };
+        if (Object.prototype.hasOwnProperty.call(inputSnapshot.hashes, currentFileKey)) {
+            inputSnapshot.hashes[currentFileKey] = currentSourceHash;
+            // That overlay makes this one key the only recorded hash a disk signature
+            // cannot stand for: the bytes it names came from the bundler, not the file.
+            delete inputSnapshot.provenSignatures[currentFileKey];
+        }
         const cached = {
+            // The pass this compile was started for. Its snapshot describes the
+            // project as of this compile, so it is settled for this pass and any
+            // later pass must re-prove it.
+            ...(props.deliveryEpoch === undefined
+                ? {}
+                : { deliveryEpoch: props.deliveryEpoch }),
             // Capture the out-of-walk input hashes while the generation is fresh so
             // cache validation can re-check them; computed before dispose so the
-            // exclusion of the temp-dir tsconfig is the only reason it never keys.
+            // scratch-tree exclusion is the only reason its disposed artifacts never
+            // key the persistent generation.
             externalInputHashes: {},
             externalInputRealpaths: {},
             externalInputPaths,
             inputHashes: inputSnapshot.hashes,
             inputSignatures: inputSnapshot.provenSignatures,
+            membershipPolicy,
             projectDirectories: inputSnapshot.projectDirectories,
+            tsconfig: props.tsconfig,
             projectSnapshotComplete: false,
             projectRoot,
             result,
+            scratchDirectory,
             servedFiles: new Set(),
             // Remember the generated temp-dir tsconfig (disposed below) so watch
             // derivation can drop it from the envelope's config chain; a registered
             // but deleted file would invalidate every persistent-cache snapshot.
             ...(temporaryTsconfig === undefined ? {} : { temporaryTsconfig }),
         };
+        cached.sourceHashes = captureTransformSourceHashes(cached, props.currentFile, currentSourceHash);
         const externalInputSnapshot = captureExternalInputSnapshot(cached, externalInputPaths);
         cached.externalInputHashes = externalInputSnapshot.hashes;
         cached.externalInputRealpaths = externalInputSnapshot.realpaths;
@@ -2968,21 +4090,39 @@ async function transformProject(props) {
         // cannot be reused can say which evidence it lacked. The extra work runs
         // only on the failing path, where the alternative is recompiling the whole
         // project for every remaining module.
-        const graphProofs = matchesCompilerGraphInputProofs(cached);
-        const universalInputs = captureUniversalHostInputValidation(cached, props.currentFile) !==
-            undefined;
+        const failures = createGenerationProofFailures();
+        if (!walkStable) {
+            recordProjectSnapshotFailures(failures, {
+                before,
+                candidateTracker,
+                declared: declaredInputs,
+                hostInputTracker,
+                identities,
+                projectRoot,
+                snapshot: inputSnapshot,
+                tracker,
+            });
+        }
+        const graphFailures = compilerGraphInputProofFailures(cached);
+        mergeGenerationProofFailures(failures, graphFailures);
+        mergeGenerationProofFailures(failures, externalInputSnapshot.failures);
+        const universalInputCapture = captureUniversalHostInputValidation(cached, props.currentFile);
+        mergeGenerationProofFailures(failures, universalInputCapture.failures);
+        const graphProofs = graphFailures.entries.length === 0 && graphFailures.omitted === 0;
+        const universalInputs = universalInputCapture.validation !== undefined;
         const stableProjectSnapshot = walkStable &&
             graphProofs &&
             externalInputSnapshot.complete &&
             universalInputs;
-        // Only a caching host loses anything here: without a cache every delivery
-        // compiles by design, so an unprovable generation costs it nothing.
-        if (!stableProjectSnapshot && props.trackProjectMembership) {
-            reportUnreusableGeneration(cached, {
-                externalInputs: externalInputSnapshot.complete,
-                graphProofs,
-                universalInputs,
-                walkStable,
+        if (!stableProjectSnapshot) {
+            TRANSFORM_GENERATION_FAILURES.set(result, failures);
+            TRANSFORM_FAILED_GENERATION_VALIDATIONS.set(result, {
+                cached,
+                declaredInputs,
+                inputStates: captureFailedGenerationInputStates(cached, failures),
+                projectInputHashes,
+                projectWalkComplete: walkSnapshotComplete(inputSnapshot, declaredInputs),
+                projectWalkFailures: projectWalkFailureFingerprint(inputSnapshot, declaredInputs, projectRoot, identities),
             });
         }
         cached.projectSnapshotComplete = stableProjectSnapshot;
@@ -3033,16 +4173,23 @@ async function transformProject(props) {
         }
     }
 }
-/** Exclude the disposed overlay tsconfig from live host-input tracking. */
+/** Exclude disposed transform scratch from live host-input tracking. */
 function selectPersistentHostInputs(props) {
     if (props.result.type === "exception")
         return [];
     const inputs = selectListedFiles(props.projectRoot, props.result.hostInputs);
-    if (props.temporaryTsconfig === undefined)
+    if (props.scratchDirectory === undefined &&
+        props.temporaryTsconfig === undefined)
         return inputs;
     const identities = createHostPathIdentityContext(props.filesystem);
-    const temporary = pathIdentityKey(props.temporaryTsconfig, identities);
-    return inputs.filter((input) => pathIdentityKey(input, identities) !== temporary);
+    const temporary = props.temporaryTsconfig === undefined
+        ? undefined
+        : pathIdentityKey(props.temporaryTsconfig, identities);
+    return inputs.filter((input) => {
+        if (isTransformScratchInput(input, props.scratchDirectory))
+            return false;
+        return pathIdentityKey(input, identities) !== temporary;
+    });
 }
 function createTransformTsconfig(props, scratchDirectory) {
     const compilerOptions = normalizeCompilerOptionsForGeneratedTsconfig({
@@ -3133,6 +4280,11 @@ function pathIsWithin(child, parent) {
             !relative.startsWith(`..${path.sep}`) &&
             !path.isAbsolute(relative)));
 }
+/** Whether an input is owned by the disposable transform scratch tree. */
+function isTransformScratchInput(input, scratchDirectory) {
+    return (scratchDirectory !== undefined &&
+        pathIsWithin(path.resolve(input), path.resolve(scratchDirectory)));
+}
 /** Route all compiler/plugin scratch to one owned directory outside project. */
 function transformScratchEnvironment(directory) {
     return {
@@ -3278,10 +4430,37 @@ function readPaths(value) {
 function createAliasPaths(aliases) {
     const paths = {};
     for (const alias of normalizeAliases(aliases)) {
-        if (typeof alias.find !== "string" || alias.find.length === 0) {
+        if (typeof alias.find !== "string") {
+            // Vite's array form accepts a `RegExp` find, and `{ find: /^~/ }` is a
+            // common way to spell a prefix alias. A tsconfig `paths` map has no
+            // regular-expression form, so there is nothing to translate it into
+            // (samchon/ttsc#1315). Reducing the simple prefix cases to a string is
+            // possible in principle and deliberately not done: telling `/^~/` from
+            // `/^~(?=\/)/` or `/^@app/` — which matches `@apple` too — means
+            // implementing enough of a regular-expression engine that a wrong
+            // reduction becomes likely, and a mistranslated alias resolves imports to
+            // the wrong file silently, which is worse than not forwarding it.
+            //
+            // Not reported, unlike the wildcard below, and that asymmetry is the
+            // whole point: Vite merges two `RegExp` aliases of its own into every
+            // resolved config, `/^\/?@vite\/env/` and `/^\/?@vite\/client/`. Measured
+            // on a bare project with no user aliases at all, `resolve.alias` has
+            // exactly those two entries under both `serve` and `build`, so a report
+            // on this form would fire twice for every Vite user in every build, name
+            // aliases they never wrote, and say nothing about their configuration.
+            // A diagnostic that cannot distinguish the user's input from the host's
+            // is noise, and noise is what teaches people to stop reading the channel
+            // the out-of-program report depends on. The documentation carries this
+            // form instead, in both README and guide.
+            continue;
+        }
+        if (alias.find.length === 0) {
             continue;
         }
         if (alias.find.includes("*")) {
+            // A `paths` key reads `*` as its own wildcard, so forwarding a `find`
+            // that already contains one cannot preserve the caller's meaning.
+            reportUntranslatableAlias(JSON.stringify(alias.find), 'a "paths" key already reads "*" as its own wildcard');
             continue;
         }
         const key = alias.find.replace(/\/+$/, "");
@@ -3296,9 +4475,50 @@ function createAliasPaths(aliases) {
     }
     return paths;
 }
+/**
+ * Alias descriptions already reported in this process.
+ *
+ * The message is about configuration rather than about a module:
+ * `resolve.alias` is resolved once and then consulted on every delivery, so
+ * reporting per delivery would repeat one statement about the config for every
+ * file in the bundle. Keyed by the description, so a Vite dev server that
+ * reloads its config reports again only when the alias itself changed.
+ */
+const REPORTED_UNTRANSLATABLE_ALIASES = new Set();
+/**
+ * Tell the user once that an alias they declared is not reaching the compile.
+ *
+ * A dropped alias is not silent in its consequence — the compile resolves
+ * through the tsconfig's own `paths`, and a module that resolves for the
+ * bundler but not for the compiler surfaces as the out-of-program report
+ * (samchon/ttsc#1308) — but that report names the module, not the alias, so the
+ * user cannot learn from it that a configuration they wrote was ignored.
+ *
+ * Only the wildcard form reaches here. Every entry it names was written by the
+ * user, because nothing injects one; the `RegExp` form is left to the
+ * documentation precisely because Vite does inject those, and
+ * {@link createAliasPaths} carries that measurement.
+ */
+function reportUntranslatableAlias(description, reason) {
+    if (REPORTED_UNTRANSLATABLE_ALIASES.has(description)) {
+        return;
+    }
+    REPORTED_UNTRANSLATABLE_ALIASES.add(description);
+    process.stderr.write(`ttsc: the Vite alias ${description} was not forwarded to the compile, because ${reason}. Declare it in your tsconfig's "paths" if ttsc must resolve through it.\n`);
+}
+/**
+ * Collect the host's declared aliases without deciding which of them can be
+ * expressed as `paths`.
+ *
+ * That decision belongs to {@link createAliasPaths} alone. It used to be split:
+ * this function's type guard required a string `find` and dropped Vite's
+ * `RegExp` form before `createAliasPaths` ever saw it, which left
+ * `createAliasPaths`'s own non-string branch unreachable and put the drop
+ * somewhere nothing could report it (samchon/ttsc#1315).
+ */
 function normalizeAliases(aliases) {
     if (Array.isArray(aliases)) {
-        return aliases.filter(isAlias);
+        return aliases.filter(isDeclaredAlias);
     }
     if (typeof aliases === "object" && aliases !== null) {
         return Object.entries(aliases)
@@ -3343,12 +4563,11 @@ function isRelativeSpecifier(value) {
         value.startsWith(".\\") ||
         value.startsWith("..\\"));
 }
-function isAlias(value) {
+function isDeclaredAlias(value) {
     return (typeof value === "object" &&
         value !== null &&
         "find" in value &&
         "replacement" in value &&
-        typeof value.find === "string" &&
         typeof value.replacement === "string");
 }
 /**
@@ -3381,19 +4600,57 @@ function selectTransformedSource(props) {
     if (source !== undefined) {
         return source;
     }
-    throw new Error(`ttsc transform did not return output for ${props.file}`);
+    throw new TtscMissingProgramOutputError(props.file, props.tsconfig);
+}
+/**
+ * Tell the user once that a module was left untransformed, and why.
+ *
+ * The condition is ordinary and the build continues, but it must never be
+ * silent: a file the program does not contain keeps whatever plugin syntax it
+ * carries, so a typia `assert<T>()` in it becomes a runtime failure rather than
+ * a build failure. One line per file per generation per pass, on the channel
+ * the generation's other non-fatal diagnostics already use, so a bundle that
+ * reaches many such files does not repeat itself per delivery.
+ */
+function reportMissingProgramOutput(cached, error, epoch) {
+    const reported = (cached.missingOutputReported ??= new Set());
+    if (cached.missingOutputEpoch !== epoch) {
+        cached.missingOutputEpoch = epoch;
+        reported.clear();
+    }
+    if (reported.has(error.file)) {
+        return;
+    }
+    reported.add(error.file);
+    process.stderr.write(`${error.message}
+`);
 }
 /**
- * Forward non-fatal plugin diagnostics to stderr.
+ * Forward non-fatal plugin diagnostics to stderr, once per generation per pass.
  *
  * A `success` result may still carry warnings or informational messages from
- * plugins. These are surfaced via stderr rather than throwing so the build
- * continues. Failures and exceptions are handled by the caller.
+ * plugins — `@ttsc/lint` reports every rule below error severity this way.
+ * These are surfaced via stderr rather than throwing so the build continues.
+ * Failures and exceptions are handled by the caller.
+ *
+ * They describe one compile of one program, so writing them per delivery
+ * printed the same warning once per module and scaled the noise with exactly
+ * the reuse the cache exists to provide (samchon/ttsc#1304). A pass that reuses
+ * a retained generation still surfaces them once, because a build's warnings
+ * are part of what that build reports; a host with no pass boundary surfaces
+ * them once per generation, which is the same rule with one pass.
  */
-function reportSuccessDiagnostics(result) {
+function reportSuccessDiagnostics(cached, epoch) {
+    const result = cached.result;
     if (result.type !== "success" || result.diagnostics === undefined) {
         return;
     }
+    if (cached.diagnosticsReported === true &&
+        cached.diagnosticsEpoch === epoch) {
+        return;
+    }
+    cached.diagnosticsReported = true;
+    cached.diagnosticsEpoch = epoch;
     const text = formatDiagnostics(result.diagnostics);
     if (text.length !== 0) {
         process.stderr.write(`${text}\n`);
@@ -3417,7 +4674,7 @@ function formatDiagnostics(diagnostics) {
         diag.line === undefined
             ? undefined
             : `${diag.line}:${diag.character ?? 1}`,
-        diag.messageText,
+        stripTerminalEscapes(diag.messageText),
     ]
         .filter((part) => part !== undefined && part !== "")
         .join(": "))
@@ -3425,15 +4682,38 @@ function formatDiagnostics(diagnostics) {
 }
 function formatUnknownError(error) {
     if (error instanceof Error) {
-        return error.message;
+        return stripTerminalEscapes(error.message);
     }
     if (typeof error === "object" &&
         error !== null &&
         "message" in error &&
         typeof error.message === "string") {
-        return error.message;
+        return stripTerminalEscapes(error.message);
     }
-    return String(error);
+    return stripTerminalEscapes(String(error));
+}
+/**
+ * Remove terminal colour and cursor sequences from text the adapter surfaces.
+ *
+ * An ordinary type error reaches the adapter as an `"exception"` envelope whose
+ * `error` is the host's own rendered output, colour and all, and the envelope
+ * carries no structured diagnostics to format instead. What the adapter hands
+ * back is not going to a terminal: it becomes the `Error` a bundler reports, so
+ * it lands in a Vite overlay, a webpack error report or a CI annotation, where
+ * the escapes render as literal noise around the file and line the reader needs
+ * (samchon/ttsc#1312).
+ *
+ * The colour originates in the host's rendering rather than in anything this
+ * adapter configures, so this is the adapter-side repair, applied to every
+ * message it surfaces rather than to one call site.
+ */
+function stripTerminalEscapes(text) {
+    // Built from a char code so no control byte lives in this source file, and
+    // written with `[[]` (a class holding one literal bracket) so the pattern
+    // needs no backslash escapes to survive the string it is assembled from.
+    const escape = String.fromCharCode(27);
+    const controlSequence = new RegExp(escape + "[[][0-9;?]*[ -/]*[@-~]", "g");
+    return text.replace(controlSequence, "");
 }
 /**
  * Locate the tsconfig that should govern the transform for `file`.