@ttsc/unplugin 0.28.5 → 0.29.0

package/lib/core/transform.js

@@ -7,8 +7,10 @@ var os = require('node:os');
 var path = require('node:path');
 var ttsc = require('ttsc');
 var pathIdentity = require('ttsc/path-identity');
+var projectDiscovery = require('./projectDiscovery.js');
 var tsconfigPaths = require('./tsconfigPaths.js');
 
+const TTSC_SEMANTIC_CONFIG_PATH = "TTSC_SEMANTIC_CONFIG_PATH";
 /**
  * A verdict about one generation that later deliveries replay instead of
  * repeating the whole compile behind it.
@@ -110,6 +112,8 @@ class TtscPassVerdictError extends TtscTerminalGenerationError {
 const TRANSFORM_GENERATION_FAILURES = new WeakMap();
 /** Retry baselines retained only for attempts that could not be published. */
 const TRANSFORM_FAILED_GENERATION_VALIDATIONS = new WeakMap();
+/** Internal retained clock-probe ownership for published generations. */
+const TRANSFORM_CLOCK_REFERENCE_DIRECTORIES = 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. */
@@ -245,8 +249,7 @@ function clearTtscTransformCache(cache) {
  * @param id - Bundler module id (may carry a query string or virtual prefix).
  * @param source - Current file content supplied by the bundler.
  * @param options - Resolved plugin options.
- * @param aliases - Raw bundler alias configuration (Vite array or webpack
- *   object).
+ * @param aliases - Raw Vite alias configuration (object or array).
  * @param cache - Optional project cache. Callers with a real `buildStart`
  *   boundary declare it through {@link beginTtscTransformBuild}; other hosts
  *   retain persistent validation.
@@ -346,9 +349,11 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
                     }
                     // 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.
+                    // build (samchon/ttsc#1308). Its project config and selection inputs
+                    // still decide whether a later generation will contain this module,
+                    // so hosts must receive the same universal watch-input batch.
                     reportMissingProgramOutput(cached, error, epoch);
+                    notifyWatchInputs(hooks, cached, file);
                     markCachedSourceServed(cached, file);
                     return undefined;
                 }
@@ -404,6 +409,7 @@ async function transformTtsc(id, source, options, aliases, cache, hooks) {
                 throw error;
             }
             reportMissingProgramOutput(cached, error, epoch);
+            notifyWatchInputs(hooks, cached, file);
             markCachedSourceServed(cached, file);
             return undefined;
         }
@@ -555,7 +561,7 @@ function evictGeneration(cache, key, generation) {
         void generation.then(disposeCachedTransform, () => undefined);
     }
 }
-/** Close one generation's directory watchers exactly once. */
+/** Release one generation's watchers and retained clock probe exactly once. */
 function disposeCachedTransform(cached) {
     const trackers = [
         cached.projectMutationTracker,
@@ -565,8 +571,21 @@ function disposeCachedTransform(cached) {
     cached.projectMutationTracker = undefined;
     cached.hostInputMutationTracker = undefined;
     cached.candidateMutationTracker = undefined;
-    for (const tracker of trackers)
-        tracker?.close();
+    const clockReferenceDirectory = TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached);
+    TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.delete(cached);
+    for (const tracker of trackers) {
+        try {
+            tracker?.close();
+        }
+        catch {
+            // Disposal is scheduled behind fulfilled generation Promises, so it has
+            // no caller that can recover from a close failure. Keep releasing every
+            // independent resource and leave no rejected cleanup Promise behind.
+        }
+    }
+    if (clockReferenceDirectory !== undefined) {
+        disposeFilesystemClockReference(clockReferenceDirectory);
+    }
 }
 /**
  * Derivation states keyed by the compiler result object. One result object is
@@ -597,17 +616,22 @@ function envelopeGraphIndexes(state, props) {
     if (state.graph !== undefined) {
         return state.graph;
     }
+    const platform = resultFilesystem(props.result).platform ?? process.platform;
+    const pathApi = platform === "win32" ? path.win32 : path.posix;
     const built = {
         edges: new Map(),
         spellings: new Map(),
         candidates: [],
         globals: [],
         configs: [],
-        members: new Set(),
+        resolutionInputs: [],
+        memberSpellings: new Set(),
         speculative: new Set(),
         inputProofs: new Map(),
         inputProofFailures: new Map(),
         inputProofConflicts: new Set(),
+        inputObservations: new Map(),
+        inputObservationConflicts: new Set(),
     };
     const graph = props.result.type === "exception" ? undefined : props.result.graph;
     if (graph !== undefined) {
@@ -617,7 +641,7 @@ function envelopeGraphIndexes(state, props) {
             }
             const absolute = path.resolve(props.projectRoot, source);
             const identity = derivationIdentity(state, absolute);
-            built.members.add(identity);
+            built.memberSpellings.add(absolute);
             built.spellings.set(identity, absolute);
             const entries = built.edges.get(identity) ?? [];
             entries.push(...targets
@@ -625,7 +649,7 @@ function envelopeGraphIndexes(state, props) {
                 .map((target) => {
                 const absoluteTarget = path.resolve(props.projectRoot, target);
                 const targetIdentity = derivationIdentity(state, absoluteTarget);
-                built.members.add(targetIdentity);
+                built.memberSpellings.add(absoluteTarget);
                 if (!built.spellings.has(targetIdentity)) {
                     built.spellings.set(targetIdentity, absoluteTarget);
                 }
@@ -637,7 +661,7 @@ function envelopeGraphIndexes(state, props) {
         built.configs.push(...selectListedFiles(props.projectRoot, graph.configs));
         for (const input of [...built.globals, ...built.configs]) {
             const identity = derivationIdentity(state, input);
-            built.members.add(identity);
+            built.memberSpellings.add(path.resolve(input));
             if (!built.spellings.has(identity))
                 built.spellings.set(identity, input);
         }
@@ -649,12 +673,22 @@ function envelopeGraphIndexes(state, props) {
         for (const [source] of candidateEntries) {
             const absoluteSource = path.resolve(props.projectRoot, source);
             const identity = derivationIdentity(state, absoluteSource);
-            built.members.add(identity);
+            built.memberSpellings.add(absoluteSource);
             if (!built.spellings.has(identity)) {
                 built.spellings.set(identity, absoluteSource);
             }
         }
-        const realized = new Set(built.members);
+        const realized = new Set(built.memberSpellings);
+        built.resolutionInputs.push(...selectListedFiles(props.projectRoot, graph.resolutionInputs));
+        for (const input of built.resolutionInputs) {
+            const spelling = path.resolve(input);
+            const identity = derivationIdentity(state, input);
+            if (!realized.has(spelling))
+                built.speculative.add(spelling);
+            built.memberSpellings.add(spelling);
+            if (!built.spellings.has(identity))
+                built.spellings.set(identity, input);
+        }
         for (const [source, candidates] of candidateEntries) {
             built.candidates.push({
                 source: derivationIdentity(state, path.resolve(props.projectRoot, source)),
@@ -663,26 +697,61 @@ function envelopeGraphIndexes(state, props) {
             for (const candidate of candidates) {
                 if (typeof candidate !== "string" || candidate.length === 0)
                     continue;
-                const identity = derivationIdentity(state, path.resolve(props.projectRoot, candidate));
+                const absoluteCandidate = path.resolve(props.projectRoot, candidate);
+                const identity = derivationIdentity(state, absoluteCandidate);
                 // Edges, globals, configs, and every candidate source are folded in
                 // above, so a path absent from that set is one the envelope reported
                 // only as a candidate.
-                if (!realized.has(identity))
-                    built.speculative.add(identity);
-                built.members.add(identity);
+                if (!realized.has(absoluteCandidate)) {
+                    built.speculative.add(absoluteCandidate);
+                }
+                built.memberSpellings.add(absoluteCandidate);
                 if (!built.spellings.has(identity)) {
-                    built.spellings.set(identity, path.resolve(props.projectRoot, candidate));
+                    built.spellings.set(identity, absoluteCandidate);
                 }
             }
         }
-        const transformSources = new Set();
+        const transformSourceSpellings = 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)));
+                    const absoluteOutput = path.resolve(props.projectRoot, output);
+                    transformSourceSpellings.add(absoluteOutput);
                 }
             }
         }
+        for (const [input, reported] of Object.entries(graph.inputObservations ?? {})) {
+            if (input.length === 0)
+                continue;
+            const absolute = path.resolve(props.projectRoot, input);
+            const spelling = path.resolve(absolute);
+            if (!built.memberSpellings.has(spelling) &&
+                !transformSourceSpellings.has(spelling)) {
+                continue;
+            }
+            const normalized = normalizeGraphInputObservation(reported, platform);
+            if (normalized === undefined) {
+                built.inputObservationConflicts.add(spelling);
+                if (!built.inputProofFailures.has(spelling)) {
+                    built.inputProofFailures.set(spelling, "malformed-observation");
+                }
+                continue;
+            }
+            const previous = built.inputObservations.get(spelling);
+            const merged = previous === undefined
+                ? normalized
+                : mergeGraphInputObservations(previous, normalized);
+            if (merged === undefined) {
+                built.inputObservations.delete(spelling);
+                built.inputObservationConflicts.add(spelling);
+                if (!built.inputProofFailures.has(spelling)) {
+                    built.inputProofFailures.set(spelling, "conflicting-observation");
+                }
+            }
+            else if (!built.inputObservationConflicts.has(spelling)) {
+                built.inputObservations.set(spelling, merged);
+            }
+        }
         for (const [input, hash] of Object.entries(graph.inputHashes ?? {})) {
             if (hash !== null &&
                 (typeof hash !== "string" || !/^[0-9a-f]{64}$/.test(hash))) {
@@ -695,28 +764,31 @@ function envelopeGraphIndexes(state, props) {
             const reportedRealpath = graph.inputRealpaths[input];
             if (reportedRealpath !== null &&
                 (typeof reportedRealpath !== "string" ||
-                    !path.isAbsolute(reportedRealpath))) {
+                    !pathApi.isAbsolute(reportedRealpath))) {
                 continue;
             }
             const absolute = path.resolve(props.projectRoot, input);
-            const identity = derivationIdentity(state, absolute);
-            if (!built.members.has(identity) && !transformSources.has(identity)) {
+            const spelling = path.resolve(absolute);
+            if (!built.memberSpellings.has(spelling) &&
+                !transformSourceSpellings.has(spelling)) {
                 continue;
             }
             const proof = {
                 hash,
                 path: absolute,
-                realpath: reportedRealpath === null ? null : path.resolve(reportedRealpath),
+                realpath: reportedRealpath === null
+                    ? null
+                    : pathIdentity.resolveFilesystemPath(reportedRealpath, platform),
             };
-            const previous = built.inputProofs.get(identity);
+            const previous = built.inputProofs.get(spelling);
             if (previous !== undefined &&
                 (previous.hash !== proof.hash ||
                     !sameHostInputRealpath(previous.realpath, proof.realpath, state.identityContext))) {
-                built.inputProofs.delete(identity);
-                built.inputProofConflicts.add(identity);
+                built.inputProofs.delete(spelling);
+                built.inputProofConflicts.add(spelling);
             }
-            else if (!built.inputProofConflicts.has(identity)) {
-                built.inputProofs.set(identity, proof);
+            else if (!built.inputProofConflicts.has(spelling)) {
+                built.inputProofs.set(spelling, proof);
             }
         }
         for (const [input, reason] of Object.entries(graph.inputProofFailures ?? {})) {
@@ -724,22 +796,213 @@ function envelopeGraphIndexes(state, props) {
                 continue;
             }
             const absolute = path.resolve(props.projectRoot, input);
-            const identity = derivationIdentity(state, absolute);
-            if (!built.members.has(identity) && !transformSources.has(identity)) {
+            const spelling = path.resolve(absolute);
+            if (!built.memberSpellings.has(spelling) &&
+                !transformSourceSpellings.has(spelling)) {
+                continue;
+            }
+            const observation = built.inputObservations.get(spelling);
+            const legacyProjection = observation === undefined
+                ? undefined
+                : legacyProjectionOfGraphInputObservation(observation);
+            if (built.speculative.has(spelling) &&
+                !built.inputProofs.has(spelling) &&
+                legacyProjection?.failure === reason) {
                 continue;
             }
-            if (built.inputProofs.has(identity)) {
-                built.inputProofs.delete(identity);
-                built.inputProofConflicts.add(identity);
+            if (built.inputObservations.has(spelling)) {
+                built.inputObservations.delete(spelling);
+                built.inputObservationConflicts.add(spelling);
             }
-            if (!built.inputProofFailures.has(identity)) {
-                built.inputProofFailures.set(identity, reason);
+            if (built.inputProofs.has(spelling)) {
+                built.inputProofs.delete(spelling);
+                built.inputProofConflicts.add(spelling);
+            }
+            if (!built.inputProofFailures.has(spelling)) {
+                built.inputProofFailures.set(spelling, reason);
             }
         }
     }
     state.graph = built;
     return built;
 }
+/** Normalize one untrusted predicate proof without filling missing predicates. */
+function normalizeGraphInputObservation(value, platform = process.platform) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const entry = value;
+    const observation = {};
+    if (Object.prototype.hasOwnProperty.call(entry, "accessibleEntries")) {
+        const accessible = entry.accessibleEntries;
+        if (typeof accessible !== "object" ||
+            accessible === null ||
+            Array.isArray(accessible)) {
+            return undefined;
+        }
+        const lists = accessible;
+        if (!Array.isArray(lists.directories) ||
+            !lists.directories.every((name) => typeof name === "string") ||
+            !Array.isArray(lists.files) ||
+            !lists.files.every((name) => typeof name === "string")) {
+            return undefined;
+        }
+        observation.accessibleEntries = {
+            directories: [...lists.directories],
+            files: [...lists.files],
+        };
+    }
+    if (Object.prototype.hasOwnProperty.call(entry, "fileExists")) {
+        if (typeof entry.fileExists !== "boolean")
+            return undefined;
+        observation.fileExists = entry.fileExists;
+    }
+    if (Object.prototype.hasOwnProperty.call(entry, "directoryExists")) {
+        if (typeof entry.directoryExists !== "boolean")
+            return undefined;
+        observation.directoryExists = entry.directoryExists;
+    }
+    if (Object.prototype.hasOwnProperty.call(entry, "stat")) {
+        if (entry.stat !== "missing" &&
+            entry.stat !== "file" &&
+            entry.stat !== "directory") {
+            return undefined;
+        }
+        observation.stat = entry.stat;
+    }
+    if (Object.prototype.hasOwnProperty.call(entry, "readFile")) {
+        const read = entry.readFile;
+        if (typeof read !== "object" || read === null || Array.isArray(read)) {
+            return undefined;
+        }
+        const result = read;
+        if (result.ok === false && result.hash === undefined) {
+            observation.readFile = { ok: false };
+        }
+        else if (result.ok === true &&
+            typeof result.hash === "string" &&
+            /^[0-9a-f]{64}$/.test(result.hash)) {
+            observation.readFile = { hash: result.hash, ok: true };
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (Object.prototype.hasOwnProperty.call(entry, "realpath")) {
+        const realpath = entry.realpath;
+        if (typeof realpath !== "object" ||
+            realpath === null ||
+            Array.isArray(realpath)) {
+            return undefined;
+        }
+        const result = realpath;
+        if (result.ok === false && result.path === undefined) {
+            observation.realpath = { ok: false };
+        }
+        else if (result.ok === true &&
+            typeof result.path === "string" &&
+            (platform === "win32" ? path.win32 : path.posix).isAbsolute(result.path)) {
+            observation.realpath = {
+                ok: true,
+                path: pathIdentity.resolveFilesystemPath(result.path, platform),
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    return Object.keys(observation).length !== 0 &&
+        graphInputObservationCompatible(observation)
+        ? observation
+        : undefined;
+}
+/** Join duplicate lexical keys only when every repeated predicate agrees. */
+function mergeGraphInputObservations(left, right) {
+    for (const property of [
+        "accessibleEntries",
+        "directoryExists",
+        "fileExists",
+        "readFile",
+        "realpath",
+        "stat",
+    ]) {
+        if (left[property] !== undefined &&
+            right[property] !== undefined &&
+            JSON.stringify(left[property]) !== JSON.stringify(right[property])) {
+            return undefined;
+        }
+    }
+    const merged = { ...left, ...right };
+    return graphInputObservationCompatible(merged) ? merged : undefined;
+}
+/** Whether one predicate set can describe a single stable filesystem state. */
+function graphInputObservationCompatible(observation) {
+    const { accessibleEntries, directoryExists, fileExists, readFile, stat } = observation;
+    const hasAccessibleEntries = accessibleEntries !== undefined &&
+        (accessibleEntries.directories.length !== 0 ||
+            accessibleEntries.files.length !== 0);
+    if (hasAccessibleEntries &&
+        (fileExists === true ||
+            directoryExists === false ||
+            (stat !== undefined && stat !== "directory") ||
+            readFile?.ok === true)) {
+        return false;
+    }
+    if (fileExists === true && directoryExists === true)
+        return false;
+    if (stat === "directory" &&
+        (fileExists === true || directoryExists === false)) {
+        return false;
+    }
+    if (stat === "file" && (fileExists === false || directoryExists === true)) {
+        return false;
+    }
+    if (stat === "missing" && (fileExists === true || directoryExists === true)) {
+        return false;
+    }
+    if (readFile?.ok === true &&
+        (fileExists === false ||
+            directoryExists === true ||
+            (stat !== undefined && stat !== "file"))) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Reconstruct a legacy hash/realpath pair only when the rich predicates prove
+ * that projection without collapsing an unreadable file or failed file probe
+ * into generic absence.
+ */
+function legacyProjectionOfGraphInputObservation(observation) {
+    if (observation.readFile?.ok === true) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: observation.readFile.hash,
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const directory = observation.stat === "directory" || observation.directoryExists === true;
+    if (directory) {
+        return observation.realpath?.ok === true
+            ? {
+                hash: hashText("ttsc:host-input:directory\0"),
+                realpath: observation.realpath.path,
+            }
+            : { failure: "realpath-unavailable" };
+    }
+    const file = observation.stat === "file" || observation.fileExists === true;
+    if (file) {
+        return { failure: "content-unavailable" };
+    }
+    const missing = observation.stat === "missing" ||
+        observation.fileExists === false ||
+        observation.directoryExists === false ||
+        observation.readFile?.ok === false;
+    return missing
+        ? { hash: null, realpath: null }
+        : { failure: "unsupported-input-kind" };
+}
 /**
  * {@link pathIdentityKey} memoized inside one envelope's derivation state.
  * Callers always pass already-resolved absolute paths, so the input string is a
@@ -774,21 +1037,8 @@ function collectDeclaredIdentities(state, projectRoot, listed) {
     return output;
 }
 /**
- * Forward every derived watch input for `file` to the adapter's `addWatchFile`
- * hook: the plugin-reported `dependencies[file]` list unioned with the
- * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
- * `configs`, and resolution candidates).
- *
- * 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 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.
+ * Register the failed generation's project and external 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
@@ -799,67 +1049,168 @@ function collectDeclaredIdentities(state, projectRoot, listed) {
  * 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.
+ * A failure envelope can retain exact external input spellings from its graph
+ * and host metadata. A pre-transform typecheck failure may have no graph yet;
+ * its structured diagnostics, or the host's standard diagnostic lines when it
+ * could return only an exception, still name the external files that need a
+ * repair. 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) {
+    const addWatchFiles = hooks?.addWatchFiles;
+    if (addWatchFile === undefined && addWatchFiles === undefined) {
         return;
     }
+    const inputs = [];
+    const seen = new Set();
+    const append = (input) => {
+        const spelling = path.resolve(input);
+        if (seen.has(spelling) ||
+            isTransformScratchInput(spelling, cached.scratchDirectory)) {
+            return;
+        }
+        seen.add(spelling);
+        // No evidence, deliberately. A failed generation is replayed for the rest
+        // of its pass without re-proving its inputs, so the adapter must observe
+        // the current availability itself.
+        inputs.push({ file: spelling });
+    };
     for (const key of Object.keys(cached.inputHashes)) {
-        const input = path.resolve(cached.projectRoot, key);
-        if (isTransformScratchInput(input, cached.scratchDirectory)) {
-            continue;
+        append(path.resolve(cached.projectRoot, key));
+    }
+    // The project walk deliberately excludes node_modules and cannot reach
+    // sibling-project or out-of-root inputs. The generation already retained
+    // their exact lexical spellings, so keep that ownership on the failure path
+    // instead of deriving a narrower second answer.
+    for (const input of cached.externalInputPaths ?? []) {
+        append(input);
+    }
+    if (cached.result.type === "failure") {
+        for (const diagnostic of cached.result.diagnostics) {
+            if (typeof diagnostic.file === "string" && diagnostic.file.length !== 0) {
+                append(path.resolve(cached.projectRoot, diagnostic.file));
+            }
+        }
+    }
+    else if (cached.result.type === "exception") {
+        for (const diagnostic of selectExceptionDiagnosticFiles(cached.result.error)) {
+            append(path.resolve(cached.projectRoot, diagnostic));
         }
-        // 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);
+    }
+    if (addWatchFiles !== undefined) {
+        addWatchFiles(inputs);
+        return;
+    }
+    for (const input of inputs) {
+        addWatchFile(input.file);
     }
 }
+/**
+ * Extract file spellings only from the two standard TypeScript diagnostic
+ * forms.
+ */
+function selectExceptionDiagnosticFiles(error) {
+    const files = [];
+    for (const line of formatUnknownError(error).split(/\r?\n/)) {
+        const colon = /^(.+):\d+:\d+\s+-\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(line);
+        const parenthesized = /^(.+?)\(\d+,\d+\):\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(line);
+        const file = colon?.[1] ?? parenthesized?.[1];
+        if (file !== undefined && file.trim().length !== 0) {
+            files.push(file.trim());
+        }
+    }
+    return files;
+}
+/**
+ * Forward every derived watch input for `file` to the adapter's `addWatchFile`
+ * hook: the plugin-reported `dependencies[file]` list unioned with the
+ * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
+ * `configs`, and resolution candidates).
+ *
+ * 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 every path in the disposed
+ * transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ */
 function notifyWatchInputs(hooks, cached, file) {
     const addWatchFile = hooks?.addWatchFile;
-    if (addWatchFile === undefined) {
+    const addWatchFiles = hooks?.addWatchFiles;
+    if (addWatchFile === undefined && addWatchFiles === undefined) {
         return;
     }
     const state = envelopeDerivation(cached);
     const external = cached.externalInputHashes ?? {};
-    for (const input of selectWatchInputs({
+    const inputs = selectWatchInputs({
         file,
         projectRoot: cached.projectRoot,
         result: cached.result,
         scratchDirectory: cached.scratchDirectory,
         temporaryTsconfig: cached.temporaryTsconfig,
-    })) {
+    }).map((input) => {
         // Hand the adapter the identity this generation already resolved and the
-        // existence state it already recorded. Both are memoized per generation,
-        // while an adapter deriving them itself pays a `realpath`, a directory
-        // listing, and an `existsSync` per input on every delivery of every module
-        // (samchon/ttsc#1246).
+        // exact state it already recorded. Both are memoized per generation, while
+        // an adapter deriving them itself pays repeated filesystem reads and can
+        // accidentally attach a later state to an earlier transform.
         const identity = derivationIdentity(state, input);
-        addWatchFile(input, {
-            identity,
-            missing: external[identity] === MISSING_INPUT_STATE,
-        });
+        const spelling = path.resolve(input);
+        const observation = cached.externalInputObservations?.[spelling];
+        const missing = observation?.fileExists === false ||
+            state.graph?.inputProofs.get(spelling)?.hash === null ||
+            external[identity] === MISSING_INPUT_STATE;
+        const projectKey = toProjectKey(cached.projectRoot, input, state.identityContext);
+        const externalHash = Object.prototype.hasOwnProperty.call(external, identity)
+            ? external[identity]
+            : undefined;
+        const projectHash = Object.prototype.hasOwnProperty.call(cached.inputHashes, projectKey)
+            ? cached.inputHashes[projectKey]
+            : undefined;
+        const graphRealpaths = cached.externalInputRealpaths ?? {};
+        const stateEvidence = observation !== undefined
+            ? { codec: "predicates", observation }
+            : externalHash !== undefined &&
+                Object.prototype.hasOwnProperty.call(graphRealpaths, identity)
+                ? {
+                    codec: "graph",
+                    hash: externalHash,
+                    realpath: graphRealpaths[identity] ?? null,
+                }
+                : externalHash !== undefined
+                    ? { codec: "host", hash: externalHash }
+                    : projectHash !== undefined
+                        ? { codec: "host", hash: projectHash }
+                        : undefined;
+        return {
+            file: input,
+            evidence: {
+                identity,
+                missing,
+                ...(stateEvidence === undefined ? {} : { state: stateEvidence }),
+                unavailable: observation?.fileExists === false
+                    ? "not-file"
+                    : missing
+                        ? "missing"
+                        : undefined,
+            },
+        };
+    });
+    if (addWatchFiles !== undefined) {
+        addWatchFiles(inputs);
+        return;
+    }
+    for (const input of inputs) {
+        addWatchFile(input.file, input.evidence);
     }
 }
 /**
  * Derive the absolute, deduplicated watch-input list for a single file.
  *
- * By default the derivation is a union: `dependencies[file] ∪ reach(edges,
- * file) ∪ globals ∪ configs`. The plugin-reported list can only widen the
- * host-owned language-semantic bound, never narrow it. Resolution candidates
- * remain part of that host-owned bound in both modes.
+ * By default the derivation unions plugin dependencies, the reachable graph,
+ * globals, configs, importer resolver inputs, and universal resolver inputs.
+ * The plugin-reported list can only widen the host-owned language-semantic
+ * bound, never narrow it. Resolver inputs remain in that bound in both modes.
  *
  * An envelope that lists `file` in `dependenciesComplete` narrows it to
  * `dependencies[file] ∪ configs`: the plugin declared its reported list the
@@ -871,10 +1222,12 @@ function notifyWatchInputs(hooks, cached, file) {
  * volatile keeps the baseline: the two declarations contradict, so the
  * conservative one wins.
  *
- * The derived list is a pure function of the envelope and the file's filesystem
- * identity, so it is computed at most once per generation per file: sibling and
- * repeated deliveries replay the per-envelope memo ({@link envelopeDerivation})
- * instead of re-walking the graph. Returns an empty list on exceptions.
+ * The derived list is a pure function of the envelope and the delivered file's
+ * normalized lexical spelling. Graph traversal uses its filesystem identity,
+ * but lexical inputs exclude only that exact spelling, so two aliases of one
+ * source require distinct lists. Repeated deliveries of one spelling replay the
+ * per-envelope memo ({@link envelopeDerivation}) instead of re-walking the
+ * graph. Returns an empty list on exceptions.
  */
 function selectWatchInputs(props) {
     if (props.result.type === "exception") {
@@ -882,12 +1235,13 @@ function selectWatchInputs(props) {
     }
     const state = envelopeDerivation(props);
     const fileIdentity = derivationIdentity(state, props.file);
-    const memoized = state.watchInputs.get(fileIdentity);
+    const fileSpelling = path.resolve(props.file);
+    const memoized = state.watchInputs.get(fileSpelling);
     if (memoized !== undefined) {
         return memoized;
     }
     const derived = deriveWatchInputs(state, props, fileIdentity);
-    state.watchInputs.set(fileIdentity, derived);
+    state.watchInputs.set(fileSpelling, derived);
     return derived;
 }
 /** Compute one file's watch-input list over the shared per-envelope state. */
@@ -934,7 +1288,7 @@ function deriveWatchInputs(state, props, fileIdentity) {
             !isVolatileFile(state, props),
     }))
         appendPhysical(input);
-    // Resolution candidates, plugin dependencies, and universal host inputs
+    // Resolver inputs, plugin dependencies, and universal host inputs
     // preserve lexical aliases. Physical deduplication would collapse
     // `alias/selection.cjs` into the selected target path, so a bundler would
     // watch only the target and miss a symlink/junction retarget.
@@ -951,22 +1305,23 @@ function selectHostInputs(props) {
         : selectListedFiles(props.projectRoot, props.result.hostInputs);
 }
 /**
- * Return the module-resolution paths that can supersede a currently resolved
- * module reachable from `file`. They remain host-owned even when a plugin
- * declares `dependenciesComplete`: plugin code cannot vouch for a compiler
- * resolution change that occurs without any plugin input changing.
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
  *
- * Candidate entries and their source identities come from the shared
- * per-envelope state, so one delivery scans only the candidates themselves
- * instead of re-resolving every candidate source.
+ * Importer entries and their source identities come from the shared
+ * per-envelope state, so one delivery scans only the recorded inputs instead of
+ * re-resolving every source.
  */
 function selectResolutionCandidateInputs(graph, state, props) {
-    if (props.result.type === "exception" ||
-        props.result.graph?.candidates === undefined) {
+    if (props.result.type === "exception" || props.result.graph === undefined) {
         return [];
     }
     const reachable = new Set(selectReachableSources(graph, state, props.file).map((source) => derivationIdentity(state, source)));
-    const output = [];
+    const output = [...graph.resolutionInputs];
+    if (props.result.graph.candidates === undefined)
+        return output;
     for (const entry of graph.candidates) {
         if (!reachable.has(entry.source)) {
             continue;
@@ -1095,9 +1450,11 @@ function declaresCompleteDependencies(state, props) {
     return declared.has(derivationIdentity(state, props.file));
 }
 /**
- * Extract the absolute, deduplicated dependency list for a single file from the
- * compiler result. Mirrors {@link selectTransformedSource}'s key lookup: fast
- * project-relative match first, then a per-envelope identity index. Returns an
+ * Extract the absolute, lexical-spelling-deduplicated dependency list for a
+ * single file from the compiler result. Mirrors
+ * {@link selectTransformedSource}'s key lookup: fast project-relative match
+ * first, then a per-envelope identity index. Distinct lexical aliases must
+ * survive so bundlers observe a later symlink or junction retarget. Returns an
  * empty list on exceptions or when the plugin reported nothing.
  */
 function selectFileDependencies(props) {
@@ -1120,17 +1477,15 @@ function selectFileDependencies(props) {
     }
     const output = [];
     const seen = new Set();
-    const fileIdentity = derivationIdentity(state, props.file);
     for (const entry of entries) {
         if (typeof entry !== "string" || entry.length === 0) {
             continue;
         }
         const absolute = path.resolve(props.projectRoot, entry);
-        const identity = derivationIdentity(state, absolute);
-        if (identity === fileIdentity || seen.has(identity)) {
+        if (seen.has(absolute)) {
             continue;
         }
-        seen.add(identity);
+        seen.add(absolute);
         output.push(absolute);
     }
     return output;
@@ -1233,6 +1588,7 @@ function matchesCachedSource(cached, file, source, epoch) {
             // 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.
+            refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem(cached.result));
             if (!matchesCompleteInputSnapshot(cached, currentKey, source)) {
                 return false;
             }
@@ -1244,6 +1600,7 @@ function matchesCachedSource(cached, file, source, epoch) {
             return true;
         }
     }
+    refreshFilesystemClockReference(TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached), resultFilesystem(cached.result));
     if (cached.result.type !== "exception" &&
         cached.result.graph !== undefined &&
         cached.projectSnapshotComplete === true &&
@@ -1310,26 +1667,36 @@ function matchesNarrowPersistentInputs(cached, file) {
 }
 /**
  * Validate one derived input against the generation, skipping the content read
- * while the recorded metadata signature still holds.
+ * while the recorded metadata signature still holds and its freshly minted
+ * clock reference remains safe.
  *
  * Sibling deliveries of one generation share most of their derived inputs, and
  * `graph.globals` is shared by every one of them, so re-reading and re-hashing
  * the whole derived set per delivery multiplies one generation's proven bytes
  * by the module count. The derived set is proven the same way the universal
  * descriptor inputs are ({@link matchesUniversalHostInputs}), under the same
- * rules: an unchanged signature stands in for the content comparison, and any
- * signature change falls back to the full comparison. A signature is recorded
- * only around a read nothing raced, only for a recorded state that came from
- * reading the input rather than from failing to, and only while the observed
- * filesystem's own clock has provably left the stamp's tick
- * ({@link stampSeparable}), so a same-length rewrite inside that tick cannot
- * hide behind an unchanged signature.
+ * rules: a currently separable unchanged signature stands in for the content
+ * comparison, and any signature or clock-ordering change falls back to the full
+ * comparison. A signature is recorded only around a read nothing raced, only
+ * for a recorded state that came from reading the input rather than from
+ * failing to, and only while the observed filesystem's own clock has provably
+ * left the stamp's tick ({@link stampSeparable}), so a same-length rewrite
+ * inside that tick cannot hide behind an unchanged signature.
  *
  * The signature carries the physical identity of both the lexical path and its
  * link target ({@link inputMetadataSignature}), so retargeting a symlink or
  * junction moves it and the skipped realpath comparison cannot be evaded.
  */
 function matchesProvenInput(cached, state, input) {
+    const observation = cached.externalInputObservations?.[path.resolve(input)];
+    if (observation !== undefined) {
+        if (observation.fileExists === false &&
+            Object.keys(observation).length === 1 &&
+            notifiesAbsence(cached, input)) {
+            return true;
+        }
+        return matchesRecordedInput(cached, input);
+    }
     const slot = inputSignatureSlot(cached, state, input);
     if (slot === undefined) {
         return matchesRecordedInput(cached, input);
@@ -1344,7 +1711,9 @@ function matchesProvenInput(cached, state, input) {
     }
     const filesystem = resultFilesystem(cached.result);
     const before = inputMetadataEvidence(input, filesystem);
-    if (before !== undefined && slot.signatures[slot.key] === before.signature) {
+    if (before !== undefined &&
+        before.separable &&
+        slot.signatures[slot.key] === before.signature) {
         return true;
     }
     if (!matchesRecordedInput(cached, input)) {
@@ -1393,6 +1762,9 @@ function notifiesAbsence(cached, input) {
  */
 function inputSignatureSlot(cached, state, input) {
     const identity = derivationIdentity(state, input);
+    if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+        return undefined;
+    }
     const external = cached.externalInputHashes ?? {};
     if (Object.prototype.hasOwnProperty.call(external, identity)) {
         // The recorded hash is identity-keyed because aliases of one physical file
@@ -1437,7 +1809,8 @@ function matchesUniversalHostInputEntries(cached, validation) {
     for (const entry of validation.entries.values()) {
         const evidence = inputMetadataEvidence(entry.path, filesystem);
         if (entry.signature !== undefined &&
-            evidence?.signature === entry.signature)
+            evidence?.signature === entry.signature &&
+            (entry.strict === true || evidence.separable))
             continue;
         if (entry.strict === true)
             return false;
@@ -1666,8 +2039,8 @@ function captureUniversalHostInputValidation(cached, currentFile) {
  */
 const MISSING_INPUT_STATE = "missing";
 /**
- * The highest stamp each observed filesystem clock has provably minted, keyed
- * by the operations object that observes it and, inside, by reporting device.
+ * The current stamp an adapter-owned probe has minted, keyed by the operations
+ * object that observes it and, inside, by reporting device.
  *
  * A filesystem stamps a write once per clock tick, so two same-length writes
  * inside one tick are indistinguishable by metadata alone. A signature may
@@ -1675,99 +2048,99 @@ const MISSING_INPUT_STATE = "missing";
  * it, and that guarantee needs a reference instant the observed filesystem
  * itself produced: once some stamp on the same device is strictly newer than an
  * input's modification stamp, that input's tick is provably over, so any later
- * write must mint a newer stamp and move the signature. That is git's
- * racily-clean index rule, adapted to a read-only contract: where git compares
- * entries against the index file's own timestamp, this floor accumulates every
- * stamp the cache-owned operations report, seeded per generation by
- * {@link mintFilesystemClockReference}.
- *
- * The process clock never participates: both sides of every comparison are
- * stamps the same filesystem clock minted, at the same granularity, so a
- * filesystem clock running behind (or ahead of) the host process changes
- * nothing.
+ * write must mint a newer stamp and move the signature. This adapts git's
+ * racily-clean index rule: both sides of the comparison come from the same
+ * reporting device, and the newer side is a write the adapter itself made.
  *
- * Accumulating observed stamps is deliberately weaker than git's own reference,
- * which is a single stamp git minted itself. A stamp this floor accepts may
- * instead have been _set_ rather than minted, and a set stamp is dangerous only
- * when it lands in the future: the floor is a maximum, so a restored past stamp
- * never raises it. One future-dated file — a stamp-preserving extraction or
- * copy from a machine whose clock ran ahead — pushes its device's floor past
- * the present and reopens the same-tick window for every other input on that
- * device until the clock catches up. A clock that jumps backwards strands the
- * floor above the present the same way, a different hazard from the constant
- * offset the paragraph above is about: an offset moves both operands together
- * and changes nothing, a jump moves only the present.
+ * A timestamp merely observed on another input cannot advance the reference.
+ * Tools may assign modification times, and a filesystem clock can move
+ * backwards independently of the process clock. Neither a passive historical
+ * maximum nor `Date.now()` proves what stamp a write would mint now. The probe
+ * is therefore rewritten immediately before every validation that may reuse a
+ * content signature, and its previous reference is cleared before the write. A
+ * failed refresh or a different reporting device declines the optimization and
+ * retains the content comparison (samchon/ttsc#1344).
  *
- * The minted probe is not enough on its own to replace observed stamps: it
- * lands on the scratch volume, which is frequently not the inputs' volume (a
- * project on `D:` with `TEMP` on `C:`), and a probe-only floor would then
- * decline every _content_ signature, so every input carrying bytes would be
- * re-read on every delivery. A strict blocker keeps its signature either way,
- * because it proves a kind rather than content. Observed stamps keep the common
- * case working; the probe covers the case they cannot, a tree whose files were
- * all written inside one tick.
+ * The probe lives in an adapter-owned temporary directory outside the project.
+ * That directory may be on another volume, such as `C:` when a project lives on
+ * `D:`. Such a split-volume generation safely keeps reading content because no
+ * same-device reference exists; it never substitutes a process-clock guess or
+ * writes a probe into the user's project.
  */
-const FILESYSTEM_CLOCK_FLOORS = new WeakMap();
-/** Return one observed filesystem's per-device clock floor, creating it. */
-function filesystemClockFloors(filesystem) {
-    let floors = FILESYSTEM_CLOCK_FLOORS.get(filesystem);
-    if (floors === undefined) {
-        floors = new Map();
-        FILESYSTEM_CLOCK_FLOORS.set(filesystem, floors);
-    }
-    return floors;
-}
-/** Raise a device's clock floor with the stamps one observation reported. */
-function observeFilesystemClock(filesystem, stats) {
-    const floors = filesystemClockFloors(filesystem);
-    const stamp = stats.mtimeNs > stats.ctimeNs ? stats.mtimeNs : stats.ctimeNs;
-    const current = floors.get(stats.dev);
-    if (current === undefined || stamp > current) {
-        floors.set(stats.dev, stamp);
+const FILESYSTEM_CLOCK_REFERENCES = new WeakMap();
+/** Return one observed filesystem's current per-device references. */
+function filesystemClockReferences(filesystem) {
+    let references = FILESYSTEM_CLOCK_REFERENCES.get(filesystem);
+    if (references === undefined) {
+        references = new Map();
+        FILESYSTEM_CLOCK_REFERENCES.set(filesystem, references);
     }
+    return references;
 }
 /**
  * Report whether a later write to the observed path is guaranteed to move its
- * modification stamp: the device's clock floor holds a stamp strictly newer, so
- * the tick that minted the stamp is provably over. The floor was observed
+ * modification stamp: the device's current probe holds a stamp strictly newer,
+ * so the tick that minted the stamp is provably over. The probe was written
  * before the caller's content read began, which is the ordering the guarantee
  * needs — a stamp minted before the read proves every post-read write lands in
  * a newer tick.
  */
 function stampSeparable(filesystem, stats) {
-    const floor = filesystemClockFloors(filesystem).get(stats.dev);
-    return floor !== undefined && stats.mtimeNs < floor;
+    const reference = filesystemClockReferences(filesystem).get(stats.dev);
+    return reference !== undefined && stats.mtimeNs < reference;
 }
 /**
- * Mint a reference instant for this generation and feed it into the observed
- * filesystem's clock floor.
+ * Replace every prior clock proof with one reference minted by a fresh write.
  *
- * The scratch directory is a write the adapter already owns, deliberately
+ * The reference directory is storage the adapter already owns, deliberately
  * outside the project root, so stamping a probe file there produces a
  * freshly-minted "now" without touching the user's project — the analogue of
  * git writing its index. The probe is observed through the cache-owned
  * operations and keyed by the device those operations report, so it only ever
- * separates stamps on the filesystem that actually minted it; when the scratch
- * volume differs from the inputs' volume, or the observed filesystem cannot see
- * the probe at all, nothing is proven and signature recording simply stays
- * declined until passively observed stamps separate an input on their own.
+ * separates stamps on the filesystem that actually minted it. When its volume
+ * differs from the inputs' volume, or the observed filesystem cannot see the
+ * probe at all, nothing is proven and content comparison continues.
  *
- * Relocating the scratch directory onto the inputs' volume would make the probe
- * universal, but it would also move every compiler and plugin temporary write
- * into the project's parent (frequently a monorepo root or a home directory)
- * for those layouts. That is a product decision about where ttsc writes, not a
- * property of this rule, so the cross-volume case degrades to more reads here
- * rather than being bought with it.
+ * Forcing the reference onto the inputs' volume would require writing into the
+ * user's project or an otherwise unowned neighboring directory. That is not a
+ * valid price for this optimization, so the cross-volume case degrades to more
+ * reads instead.
  */
-function mintFilesystemClockReference(scratchDirectory, filesystem) {
+function refreshFilesystemClockReference(referenceDirectory, filesystem) {
+    const references = filesystemClockReferences(filesystem);
+    references.clear();
+    if (referenceDirectory === undefined)
+        return;
     try {
-        const probe = path.join(scratchDirectory, "clock-reference");
-        fs.writeFileSync(probe, "");
-        observeFilesystemClock(filesystem, filesystem.lstat(probe));
+        const probe = path.join(referenceDirectory, "clock-reference");
+        fs.writeFileSync(probe, `${process.hrtime.bigint()}\n`);
+        const stats = filesystem.lstat(probe);
+        if (stats.isFile()) {
+            references.set(stats.dev, stats.mtimeNs);
+        }
     }
     catch {
-        // The absence of a reference declines signature recording; it never
-        // invalidates a generation.
+        // A failed refresh leaves no reference, so content comparison continues.
+        references.clear();
+    }
+}
+/** Remove only the known probe and its now-empty owned directory. */
+function disposeFilesystemClockReference(referenceDirectory) {
+    try {
+        fs.rmSync(path.join(referenceDirectory, "clock-reference"), {
+            force: true,
+        });
+    }
+    catch {
+        // The probe may already have disappeared; the directory removal below is
+        // still safe because it is deliberately non-recursive.
+    }
+    try {
+        fs.rmdirSync(referenceDirectory);
+    }
+    catch {
+        // Eviction schedules cleanup without awaiting its Promise. A foreign entry
+        // or a concurrent removal leaves, at worst, an empty temporary directory.
     }
 }
 /** Metadata identity whose stability lets a generation reuse a content hash. */
@@ -1778,12 +2151,10 @@ function inputMetadataSignature(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS
 function inputMetadataEvidence(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
     try {
         const link = filesystem.lstat(file);
-        observeFilesystemClock(filesystem, link);
         let target = link;
         if (link.isSymbolicLink()) {
             try {
                 target = filesystem.statBigInt(file);
-                observeFilesystemClock(filesystem, target);
             }
             catch {
                 // Keep a broken link in the existing-input manifest. Its own metadata
@@ -1849,7 +2220,18 @@ function hostInputStateHash(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
 }
 /** Fingerprint the text/kind state returned by TypeScript-Go's filesystem. */
 function graphInputStateHash(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const kind = compilerStatKind(file, filesystem);
+    const readHash = graphInputReadHash(file, filesystem, kind);
+    if (readHash !== null)
+        return readHash;
+    return kind === "directory" ? hashText("ttsc:host-input:directory\0") : null;
+}
+/** Hash only a successful compiler-style ReadFile result, without kind fallback. */
+function graphInputReadHash(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, observedKind) {
+    const kind = observedKind ?? compilerStatKind(file, filesystem);
     try {
+        if (kind === "directory")
+            return null;
         const bytes = filesystem.readFile(file);
         if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
             const even = bytes.subarray(2, 2 + Math.floor((bytes.length - 2) / 2) * 2);
@@ -1869,15 +2251,131 @@ function graphInputStateHash(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
         return hashText(content);
     }
     catch {
+        return null;
+    }
+}
+/** Current result of TypeScript-Go's Stat predicate. */
+function compilerStatKind(file, filesystem) {
+    try {
+        return filesystem.stat(file).isDirectory() ? "directory" : "file";
+    }
+    catch {
+        return "missing";
+    }
+}
+/** Return the exact recorded predicates that no longer hold for one spelling. */
+function graphInputObservationFailures(file, observation, filesystem, identities) {
+    const failures = [];
+    if (observation.accessibleEntries !== undefined) {
+        const current = compilerAccessibleEntries(file, filesystem);
+        if (JSON.stringify(current) !== JSON.stringify(observation.accessibleEntries)) {
+            failures.push("accessible-entries-changed");
+        }
+    }
+    const kind = observation.fileExists !== undefined ||
+        observation.directoryExists !== undefined ||
+        observation.stat !== undefined ||
+        observation.readFile !== undefined
+        ? compilerStatKind(file, filesystem)
+        : undefined;
+    if (observation.fileExists !== undefined &&
+        (kind === "file") !== observation.fileExists) {
+        failures.push("file-exists-changed");
+    }
+    if (observation.directoryExists !== undefined &&
+        (kind === "directory") !== observation.directoryExists) {
+        failures.push("directory-exists-changed");
+    }
+    if (observation.stat !== undefined && kind !== observation.stat) {
+        failures.push("stat-changed");
+    }
+    if (observation.readFile !== undefined) {
+        const currentHash = graphInputReadHash(file, filesystem, kind);
+        if ((observation.readFile.ok && currentHash !== observation.readFile.hash) ||
+            (!observation.readFile.ok && currentHash !== null)) {
+            failures.push("read-file-changed");
+        }
+    }
+    if (observation.realpath !== undefined) {
+        const currentRealpath = compilerInputRealpathObservation(file, filesystem);
+        if (observation.realpath.ok !== currentRealpath.ok ||
+            (observation.realpath.ok &&
+                currentRealpath.ok &&
+                !sameHostInputRealpath(observation.realpath.path, currentRealpath.path, identities))) {
+            failures.push("realpath-changed");
+        }
+    }
+    return failures;
+}
+/** Replay TypeScript-Go's accessible-entry classification and sorted order. */
+function compilerAccessibleEntries(directory, filesystem) {
+    const directories = [];
+    const files = [];
+    const pathApi = filesystem.platform === "win32" ? path.win32 : path.posix;
+    let entries;
+    try {
+        entries = filesystem.readdir(directory);
+    }
+    catch {
+        return { directories, files };
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            directories.push(entry.name);
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(entry.name);
+            continue;
+        }
+        if (!entry.isSymbolicLink())
+            continue;
         try {
-            return filesystem.stat(file).isDirectory()
-                ? hashText("ttsc:host-input:directory\0")
-                : null;
+            const target = filesystem.stat(pathApi.join(directory, entry.name));
+            if (target.isDirectory())
+                directories.push(entry.name);
+            else if (target.isFile())
+                files.push(entry.name);
         }
         catch {
-            return null;
+            // TypeScript-Go omits inaccessible and broken linked entries.
         }
     }
+    directories.sort();
+    files.sort();
+    return { directories, files };
+}
+/** Validate one predicate-preserving graph proof against a filesystem view. */
+function validateGraphInputObservation(file, observation, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const normalized = normalizeGraphInputObservation(observation, filesystem.platform);
+    if (normalized === undefined)
+        return ["proof-conflict"];
+    return graphInputObservationFailures(file, normalized, filesystem, createHostPathIdentityContext(filesystem));
+}
+/** Whether every compiler-time predicate still returns its recorded value. */
+function matchesGraphInputObservation(file, observation, filesystem, identities) {
+    return (graphInputObservationFailures(file, observation, filesystem, identities)
+        .length === 0);
+}
+/** Replay TypeScript-Go's Realpath result, including its lexical fallback. */
+function compilerInputRealpathObservation(file, filesystem) {
+    try {
+        const realpath = filesystem.realpath(file);
+        return realpath.length === 0
+            ? { ok: false }
+            : {
+                ok: true,
+                path: pathIdentity.resolveFilesystemPath(realpath, filesystem.platform),
+            };
+    }
+    catch {
+        // TypeScript-Go's OS and io filesystems return the cleaned input spelling
+        // when native realpath resolution fails; they do not expose the failure.
+        return {
+            ok: true,
+            path: pathIdentity.resolveFilesystemPath(file, filesystem.platform),
+        };
+    }
 }
 /** Physical target selected by a lexical host-input path. */
 function hostInputRealpath(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
@@ -2021,6 +2519,9 @@ function matchesExternalInputRealpaths(cached) {
     const state = envelopeDerivation(cached);
     const filesystem = resultFilesystem(cached.result);
     for (const input of cached.externalInputPaths ?? []) {
+        if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+            continue;
+        }
         const identity = derivationIdentity(state, input);
         if (!Object.prototype.hasOwnProperty.call(expected, identity))
             continue;
@@ -2044,15 +2545,16 @@ function captureExternalInputSnapshot(cached, paths) {
     // 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();
+    const transformSourceSpellings = 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)));
+                transformSourceSpellings.add(path.resolve(cached.projectRoot, output));
             }
         }
     }
     const hashes = {};
+    const observations = {};
     const realpaths = {};
     const signatures = {};
     const failures = createGenerationProofFailures();
@@ -2069,26 +2571,55 @@ function captureExternalInputSnapshot(cached, paths) {
     };
     for (const input of paths) {
         const identity = derivationIdentity(state, input);
-        // A member the envelope reported only as a resolution candidate falls
+        const spelling = path.resolve(input);
+        const predicateObservation = graph.inputObservations.get(spelling);
+        const predicateConflict = graph.inputObservationConflicts.has(spelling);
+        if (graph.speculative.has(spelling) &&
+            (predicateObservation !== undefined || predicateConflict)) {
+            if (predicateConflict || predicateObservation === undefined) {
+                complete = false;
+                recordGenerationProofFailure(failures, {
+                    domain: "external",
+                    kind: "graph-proof-conflict",
+                    detail: graph.inputProofFailures.get(spelling),
+                    path: input,
+                });
+                continue;
+            }
+            const mismatches = graphInputObservationFailures(input, predicateObservation, filesystem, state.identityContext);
+            if (mismatches.length !== 0)
+                complete = false;
+            for (const kind of mismatches) {
+                recordGenerationProofFailure(failures, {
+                    domain: "external",
+                    kind: `graph-${kind}`,
+                    path: input,
+                });
+            }
+            observations[spelling] = predicateObservation;
+            continue;
+        }
+        // A member the envelope reported only as a resolver input falls
         // 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 realizedTransformSource = transformSources.has(identity);
+        const realizedTransformSource = transformSourceSpellings.has(spelling);
         const speculativeOnly = !realizedTransformSource &&
-            graph.speculative.has(identity) &&
-            !graph.inputProofs.has(identity) &&
-            !graph.inputProofConflicts.has(identity);
-        if ((realizedTransformSource || graph.members.has(identity)) &&
+            graph.speculative.has(spelling) &&
+            !graph.inputProofs.has(spelling) &&
+            !graph.inputProofConflicts.has(spelling) &&
+            !graph.inputProofFailures.has(spelling);
+        if ((realizedTransformSource || graph.memberSpellings.has(spelling)) &&
             !speculativeOnly) {
-            const proof = graph.inputProofs.get(identity);
-            if (proof === undefined || graph.inputProofConflicts.has(identity)) {
+            const proof = graph.inputProofs.get(spelling);
+            if (proof === undefined || graph.inputProofConflicts.has(spelling)) {
                 complete = false;
                 recordGenerationProofFailure(failures, {
                     domain: "external",
-                    kind: graph.inputProofConflicts.has(identity)
+                    kind: graph.inputProofConflicts.has(spelling)
                         ? "graph-proof-conflict"
                         : "graph-proof-missing",
-                    detail: graph.inputProofFailures.get(identity),
+                    detail: graph.inputProofFailures.get(spelling),
                     path: input,
                 });
                 continue;
@@ -2133,7 +2664,14 @@ function captureExternalInputSnapshot(cached, paths) {
         if (hash !== null)
             record(input, before, after);
     }
-    return { complete, failures, hashes, realpaths, signatures };
+    return {
+        complete,
+        failures,
+        hashes,
+        observations,
+        realpaths,
+        signatures,
+    };
 }
 /** Explain every graph member that no longer matches the compiler's state. */
 function compilerGraphInputProofFailures(cached) {
@@ -2141,6 +2679,7 @@ function compilerGraphInputProofFailures(cached) {
     if (cached.result.type === "exception" ||
         cached.result.graph === undefined ||
         (cached.result.graph.inputHashes === undefined &&
+            cached.result.graph.inputObservations === undefined &&
             cached.result.graph.inputRealpaths === undefined &&
             cached.result.graph.inputProofFailures === undefined)) {
         // Legacy sidecars remain compatible for ordinary in-project graphs. Their
@@ -2151,34 +2690,89 @@ function compilerGraphInputProofFailures(cached) {
     const state = envelopeDerivation(cached);
     const filesystem = resultFilesystem(cached.result);
     const graph = envelopeGraphIndexes(state, cached);
-    for (const identity of graph.members) {
-        const proof = graph.inputProofs.get(identity);
-        const spelling = proof?.path ?? graph.spellings.get(identity) ?? cached.projectRoot;
+    const predicateSpellings = new Set();
+    const predicateConflictSpellings = new Set();
+    for (const [spelling, observation] of graph.inputObservations) {
+        predicateSpellings.add(spelling);
+        for (const kind of graphInputObservationFailures(spelling, observation, filesystem, state.identityContext)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind,
+                path: spelling,
+            });
+        }
+    }
+    for (const spelling of graph.inputObservationConflicts) {
+        predicateSpellings.add(spelling);
+        predicateConflictSpellings.add(spelling);
+        recordGenerationProofFailure(failures, {
+            domain: "graph",
+            kind: "proof-conflict",
+            detail: graph.inputProofFailures.get(spelling),
+            path: spelling,
+        });
+    }
+    for (const spelling of graph.memberSpellings) {
+        const proof = graph.inputProofs.get(spelling);
         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
-        // typed by a declaration file (samchon/ttsc#1245). It is validated instead
-        // against the state {@link captureExternalInputSnapshot} recorded for it.
-        if (proof === undefined && graph.speculative.has(identity)) {
+        if (predicateConflictSpellings.has(spelling)) {
             continue;
         }
-        if (graph.inputProofConflicts.has(identity)) {
+        if (graph.inputProofConflicts.has(spelling)) {
             recordGenerationProofFailure(failures, {
                 domain: "graph",
                 kind: "proof-conflict",
-                detail: graph.inputProofFailures.get(identity),
+                detail: graph.inputProofFailures.get(spelling),
                 path: spelling,
             });
             continue;
         }
+        if (graph.inputProofFailures.has(spelling)) {
+            recordGenerationProofFailure(failures, {
+                domain: "graph",
+                kind: "proof-missing",
+                detail: graph.inputProofFailures.get(spelling),
+                path: spelling,
+            });
+            continue;
+        }
+        const observation = graph.inputObservations.get(spelling);
+        if (observation !== undefined && proof !== undefined) {
+            const projection = legacyProjectionOfGraphInputObservation(observation);
+            if (projection.failure !== undefined ||
+                projection.hash !== proof.hash ||
+                !sameHostInputRealpath(projection.realpath, proof.realpath, state.identityContext)) {
+                recordGenerationProofFailure(failures, {
+                    domain: "graph",
+                    kind: "proof-conflict",
+                    detail: projection.failure,
+                    path: spelling,
+                });
+            }
+            // The rich predicates were already replayed above. Their legacy
+            // projection is an internal producer-consistency check, never a reason
+            // to read the same filesystem input again. A projection that cannot
+            // represent the observation is itself inconsistent with a supplied
+            // legacy proof, rather than permission to trust either representation.
+            continue;
+        }
+        if (graph.speculative.has(spelling) &&
+            predicateSpellings.has(spelling) &&
+            !graph.inputProofFailures.has(spelling)) {
+            continue;
+        }
+        // A legacy sidecar can report a resolver candidate without a compiler
+        // predicate. Validate it against the generation snapshot instead.
+        if (proof === undefined && graph.speculative.has(spelling)) {
+            continue;
+        }
         if (proof === undefined) {
             recordGenerationProofFailure(failures, {
                 domain: "graph",
                 kind: "proof-missing",
-                detail: graph.inputProofFailures.get(identity),
+                detail: graph.inputProofFailures.get(spelling),
                 path: spelling,
             });
             continue;
@@ -2210,6 +2804,10 @@ function matchesRecordedInput(cached, input) {
         ? cached.inputHashes[projectKey]
         : undefined;
     const identity = derivationIdentity(state, input);
+    const observation = cached.externalInputObservations?.[path.resolve(input)];
+    if (observation !== undefined) {
+        return matchesGraphInputObservation(input, observation, filesystem, state.identityContext);
+    }
     const externalHash = (cached.externalInputHashes ?? {})[identity];
     const externalRealpaths = cached.externalInputRealpaths;
     const graphInput = externalRealpaths !== undefined &&
@@ -2247,9 +2845,20 @@ function markCachedSourceServed(cached, file) {
  * can fold the identical input universe into their own cache fingerprints.
  */
 function collectProjectInputHashes(projectRoot, identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy) {
-    return collectProjectInputSnapshot(projectRoot, identities, filesystem, undefined, {
+    return collectProjectInputHashSnapshot(projectRoot, identities, filesystem, policy).hashes;
+}
+/**
+ * Hash the project walk and retain whether every attempted directory and file
+ * was observed coherently. Cache-key hosts must reject an incomplete set.
+ */
+function collectProjectInputHashSnapshot(projectRoot, identities = createHostPathIdentityContext(), filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy) {
+    const snapshot = collectProjectInputSnapshot(projectRoot, identities, filesystem, undefined, {
         policy,
-    }).hashes;
+    });
+    return {
+        complete: snapshot.complete && snapshot.directoryComplete,
+        hashes: snapshot.hashes,
+    };
 }
 /** Hash project files and snapshot the directory topology in one walk. */
 function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, proven, options) {
@@ -2278,10 +2887,11 @@ function collectProjectInputSnapshot(projectRoot, identities, filesystem = DEFAU
             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
-            // that was already proven stays proven: its stamp has not moved since the
-            // clock provably left its tick.
+            // project does not have to be re-read to prove one delivery. Recheck the
+            // clock ordering as well: rollback can make a formerly safe floor unable
+            // to answer for a new write (samchon/ttsc#1344).
             if (before !== undefined &&
+                before.separable &&
                 proven !== undefined &&
                 proven.signatures[key] === before.signature &&
                 Object.prototype.hasOwnProperty.call(proven.hashes, key)) {
@@ -2398,7 +3008,7 @@ function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, pol
                 : `unstable:${before}:${after ?? "missing"}`,
         };
         for (const entry of entries) {
-            if (isIgnoredProjectDirectory(entry.name)) {
+            if (projectDiscovery.isIgnoredProjectDirectory(entry.name)) {
                 continue;
             }
             const file = path.join(current, entry.name);
@@ -2472,7 +3082,7 @@ function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, pol
 }
 /**
  * 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.
+ * _while_ the walk was enumerating it.
  *
  * This is the right instrument for that job and the wrong one for comparing two
  * generations: it moves for ignored entries too. {@link walkProjectInputs}
@@ -2481,9 +3091,6 @@ function walkProjectInputs(root, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, pol
 function projectDirectorySignature(directory, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
     try {
         const stats = filesystem.statBigInt(directory);
-        // Directory stamps are minted by the same clock as file stamps, so every
-        // walk observation also raises the clock floor that separates them.
-        observeFilesystemClock(filesystem, stats);
         if (!stats.isDirectory()) {
             return undefined;
         }
@@ -2535,6 +3142,25 @@ function openDirectoryWatch(filesystem, directory, listener, onError) {
     watcher.on("error", onError);
     return { close: () => watcher.close() };
 }
+/** Detach and close every watcher, then preserve the first cleanup failure. */
+function closeDirectoryWatches(watchers) {
+    const owned = watchers.splice(0);
+    let failed = false;
+    let failure;
+    for (const watcher of owned) {
+        try {
+            watcher.close();
+        }
+        catch (error) {
+            if (!failed) {
+                failed = true;
+                failure = error;
+            }
+        }
+    }
+    if (failed)
+        throw failure;
+}
 /** Watch every walked directory for membership changes after generation. */
 async function createProjectMutationTracker(directories, filesystem = DEFAULT_FILESYSTEM_OPERATIONS, policy = tsconfigPaths.PERMISSIVE_PROJECT_MEMBERSHIP_POLICY) {
     const tracker = {
@@ -2549,11 +3175,7 @@ async function createProjectMutationTracker(directories, filesystem = DEFAULT_FI
         return tracker;
     }
     const watchers = [];
-    tracker.close = () => {
-        for (const watcher of watchers)
-            watcher.close();
-        watchers.length = 0;
-    };
+    tracker.close = () => closeDirectoryWatches(watchers);
     for (const directory of directories) {
         try {
             watchers.push(openDirectoryWatch(filesystem, directory.path, (eventType, filename) => {
@@ -2620,11 +3242,7 @@ async function createHostInputMutationTracker(inputs, filesystem, covered, event
         return tracker;
     }
     const watchers = [];
-    tracker.close = () => {
-        for (const watcher of watchers)
-            watcher.close();
-        watchers.length = 0;
-    };
+    tracker.close = () => closeDirectoryWatches(watchers);
     for (const location of locations) {
         try {
             const names = new Set(location.names);
@@ -2795,14 +3413,40 @@ membership) {
             return;
         broker.trackers.delete(id);
         active.ready();
-        broker.child.send?.({ id, op: "remove" });
+        let failed = false;
+        let failure;
+        try {
+            broker.child.send?.({ id, op: "remove" });
+        }
+        catch (error) {
+            failed = true;
+            failure = error;
+        }
         if (broker.trackers.size === 0) {
-            broker.child.disconnect?.();
-            broker.child.kill();
             if (windowsProjectMutationBroker === broker) {
                 windowsProjectMutationBroker = undefined;
             }
+            try {
+                broker.child.disconnect?.();
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    failure = error;
+                }
+            }
+            try {
+                broker.child.kill();
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    failure = error;
+                }
+            }
         }
+        if (failed)
+            throw failure;
     };
     broker.child.send?.({
         allEvents,
@@ -3087,7 +3731,7 @@ function isProjectWalkPath(root, file, _identities = createHostPathIdentityConte
     const segments = relative.split(path.sep);
     // 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)) {
+    if (segments.slice(0, -1).some(projectDiscovery.isIgnoredProjectDirectory)) {
         return false;
     }
     if (isExcludedProjectDirectory(path.dirname(path.resolve(file)), policy)) {
@@ -3144,10 +3788,197 @@ function collectExternalInputHashes(paths, filesystem = DEFAULT_FILESYSTEM_OPERA
     }
     return hashes;
 }
+/** Capture the stable file predicate used by implicit project discovery. */
+function captureWatchInputFileBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const capture = () => {
+        const identities = createHostPathIdentityContext(filesystem);
+        let fileExists = false;
+        try {
+            fileExists = filesystem.stat(file).isFile();
+        }
+        catch {
+            // Project discovery rejects every candidate not proven to be a file.
+        }
+        return {
+            fileExists,
+            identity: pathIdentityKey(file, identities),
+        };
+    };
+    try {
+        const before = capture();
+        const after = capture();
+        return stableStringify(before) === stableStringify(after)
+            ? after
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Capture one stable main-process baseline that can be compared with any
+ * generation-owned watch-input evidence. Two equal broad observations are
+ * required so a cache key never publishes a torn path state.
+ */
+function captureWatchInputBaseline(file, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
+    const capture = () => {
+        const identities = createHostPathIdentityContext(filesystem);
+        const stat = compilerStatKind(file, filesystem);
+        return {
+            directoryExists: stat === "directory",
+            fileExists: stat === "file",
+            graphHash: graphInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE,
+            graphReadHash: graphInputReadHash(file, filesystem),
+            hostHash: hostInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE,
+            identity: pathIdentityKey(file, identities),
+            realpath: compilerInputRealpathObservation(file, filesystem),
+            stat,
+        };
+    };
+    try {
+        const before = capture();
+        const after = capture();
+        return stableStringify(before) === stableStringify(after)
+            ? after
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Compare generation evidence with the main process's exact key baseline. */
+function watchInputEvidenceMatchesBaseline(evidence, baseline) {
+    if (!isWatchInputKeyBaseline(baseline) ||
+        evidence.identity !== baseline.identity ||
+        evidence.state === undefined) {
+        return false;
+    }
+    const broad = broadWatchInputBaseline(baseline);
+    if (evidence.state.codec === "host") {
+        return broad !== undefined && evidence.state.hash === broad.hostHash;
+    }
+    const identities = createHostPathIdentityContext();
+    if (evidence.state.codec === "graph") {
+        return (broad !== undefined &&
+            evidence.state.hash === broad.graphHash &&
+            sameHostInputRealpath(evidence.state.realpath, broad.realpath.ok ? broad.realpath.path : null, identities));
+    }
+    const observation = evidence.state.observation;
+    if (observation.fileExists !== undefined &&
+        observation.fileExists !== baseline.fileExists) {
+        return false;
+    }
+    if (observation.directoryExists !== undefined &&
+        (broad === undefined ||
+            observation.directoryExists !== broad.directoryExists)) {
+        return false;
+    }
+    if (observation.stat !== undefined &&
+        (broad === undefined || observation.stat !== broad.stat)) {
+        return false;
+    }
+    if (observation.readFile !== undefined &&
+        (broad === undefined ||
+            (observation.readFile.ok &&
+                observation.readFile.hash !== broad.graphReadHash) ||
+            (!observation.readFile.ok && broad.graphReadHash !== null))) {
+        return false;
+    }
+    if (observation.realpath !== undefined) {
+        if (broad === undefined) {
+            return false;
+        }
+        if (observation.realpath.ok !== broad.realpath.ok) {
+            return false;
+        }
+        if (observation.realpath.ok &&
+            broad.realpath.ok &&
+            !sameHostInputRealpath(observation.realpath.path, broad.realpath.path, identities)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Validate the complete narrow or broad shape stored in a key baseline. */
+function isWatchInputKeyBaseline(baseline) {
+    if (!isPlainRecord(baseline))
+        return false;
+    const keys = Object.keys(baseline).sort();
+    if (typeof baseline.fileExists !== "boolean" ||
+        typeof baseline.identity !== "string" ||
+        !isAbsoluteFilesystemPath(baseline.identity)) {
+        return false;
+    }
+    if (stableStringify(keys) === stableStringify(["fileExists", "identity"])) {
+        return true;
+    }
+    if (stableStringify(keys) !==
+        stableStringify([
+            "directoryExists",
+            "fileExists",
+            "graphHash",
+            "graphReadHash",
+            "hostHash",
+            "identity",
+            "realpath",
+            "stat",
+        ])) {
+        return false;
+    }
+    if (typeof baseline.directoryExists !== "boolean" ||
+        !isWatchInputStateHash(baseline.graphHash) ||
+        !(baseline.graphReadHash === null || isContentHash(baseline.graphReadHash)) ||
+        !isWatchInputStateHash(baseline.hostHash) ||
+        !isWatchInputRealpathBaseline(baseline.realpath) ||
+        (baseline.stat !== "directory" &&
+            baseline.stat !== "file" &&
+            baseline.stat !== "missing")) {
+        return false;
+    }
+    return (baseline.fileExists === (baseline.stat === "file") &&
+        baseline.directoryExists === (baseline.stat === "directory"));
+}
+/** Whether an unknown value is one ordinary JSON object. */
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/** Whether one identity can name an absolute path on either supported syntax. */
+function isAbsoluteFilesystemPath(value) {
+    return path.posix.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+/** Whether a serialized hash is a content digest. */
+function isContentHash(value) {
+    return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+/** Whether a baseline state is either a digest or the missing marker. */
+function isWatchInputStateHash(value) {
+    return value === MISSING_INPUT_STATE || isContentHash(value);
+}
+/** Validate the serialized Realpath predicate as an exact discriminated union. */
+function isWatchInputRealpathBaseline(value) {
+    if (!isPlainRecord(value) || typeof value.ok !== "boolean")
+        return false;
+    const keys = Object.keys(value).sort();
+    if (value.ok === false) {
+        return stableStringify(keys) === stableStringify(["ok"]);
+    }
+    return (stableStringify(keys) === stableStringify(["ok", "path"]) &&
+        typeof value.path === "string" &&
+        isAbsoluteFilesystemPath(value.path));
+}
+/** Return a broad baseline after the complete entry has been validated. */
+function broadWatchInputBaseline(baseline) {
+    return "directoryExists" in baseline ? baseline : undefined;
+}
 /**
  * Re-check a cached mixed graph/dependency input set with its owning codec,
  * reusing the recorded hash of any input whose metadata signature still holds
- * and reporting the signatures this pass captured.
+ * under a freshly minted same-device reference and reporting the signatures
+ * this pass captured.
  *
  * The caller adopts those signatures only once every input is proven unchanged,
  * so a signature never outlives the content comparison that justified it.
@@ -3170,6 +4001,13 @@ function matchesCachedExternalInputs(cached) {
         Object.keys(cached.externalInputHashes ?? {})) {
         const identity = derivationIdentity(state, file);
         const spelling = path.resolve(file);
+        const observation = cached.externalInputObservations?.[spelling];
+        if (observation !== undefined) {
+            if (!matchesGraphInputObservation(file, observation, filesystem, state.identityContext)) {
+                matches = false;
+            }
+            continue;
+        }
         // Reuse the recorded hash of an out-of-walk input whose signature still
         // equals the one captured around the read that proved it. The signature is
         // keyed by this exact spelling, so an alias of the same physical file
@@ -3178,6 +4016,7 @@ function matchesCachedExternalInputs(cached) {
         if (before !== undefined &&
             Object.prototype.hasOwnProperty.call(recordedSignatures, spelling) &&
             Object.prototype.hasOwnProperty.call(recordedHashes, identity) &&
+            before.separable &&
             before.signature === recordedSignatures[spelling]) {
             continue;
         }
@@ -3223,6 +4062,13 @@ function selectExternalInputPaths(props) {
     const identities = createHostPathIdentityContext(filesystem);
     const resolutionCandidates = new Set();
     const graph = props.result.graph;
+    const graphState = envelopeDerivation({
+        result: props.result,
+    });
+    const graphIndexes = envelopeGraphIndexes(graphState, {
+        projectRoot: props.projectRoot,
+        result: props.result,
+    });
     // 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).
@@ -3234,7 +4080,11 @@ function selectExternalInputPaths(props) {
                 members.push(...targets);
             }
         }
-        for (const listed of [graph.globals, graph.configs]) {
+        for (const listed of [
+            graph.globals,
+            graph.configs,
+            graph.resolutionInputs,
+        ]) {
             if (Array.isArray(listed)) {
                 members.push(...listed);
             }
@@ -3249,7 +4099,12 @@ function selectExternalInputPaths(props) {
                 }
                 const absolute = path.resolve(props.projectRoot, candidate);
                 members.push(candidate);
-                resolutionCandidates.add(pathIdentityKey(absolute, identities));
+                resolutionCandidates.add(path.resolve(absolute));
+            }
+        }
+        for (const input of graph.resolutionInputs ?? []) {
+            if (typeof input === "string" && input.length !== 0) {
+                resolutionCandidates.add(path.resolve(props.projectRoot, input));
             }
         }
     }
@@ -3265,7 +4120,7 @@ function selectExternalInputPaths(props) {
                 // Plugin discovery inputs deliberately include absent config and
                 // resolution probes. A project walk cannot snapshot a path that does
                 // not exist yet, even when its spelling lies below projectRoot.
-                resolutionCandidates.add(pathIdentityKey(path.resolve(props.projectRoot, input), identities));
+                resolutionCandidates.add(path.resolve(props.projectRoot, input));
             }
         }
     }
@@ -3281,7 +4136,10 @@ function selectExternalInputPaths(props) {
         const absolute = path.resolve(props.projectRoot, member);
         const spelling = path.resolve(absolute);
         const identity = pathIdentityKey(absolute, identities);
-        const missingCandidate = resolutionCandidates.has(identity) && !filesystem.exists(absolute);
+        const observation = graphIndexes.inputObservations.get(spelling);
+        const missingCandidate = resolutionCandidates.has(spelling) &&
+            (observation?.fileExists === false ||
+                (observation === undefined && !filesystem.exists(absolute)));
         if (identity === excluded ||
             isTransformScratchInput(absolute, props.scratchDirectory) ||
             seen.has(spelling) ||
@@ -3324,6 +4182,13 @@ function selectNotifiableAbsentInputs(props) {
         return empty;
     }
     const identities = createHostPathIdentityContext(props.filesystem);
+    const graphState = envelopeDerivation({
+        result: props.result,
+    });
+    const graphIndexes = envelopeGraphIndexes(graphState, {
+        projectRoot: props.projectRoot,
+        result: props.result,
+    });
     const excluded = props.temporaryTsconfig === undefined
         ? undefined
         : pathIdentityKey(props.temporaryTsconfig, identities);
@@ -3336,7 +4201,10 @@ function selectNotifiableAbsentInputs(props) {
     // them. Sharing a set would let one silently answer for the other.
     const seen = new Set();
     const chain = new Set();
-    for (const candidates of Object.values(graph.candidates ?? {})) {
+    for (const candidates of [
+        ...Object.values(graph.candidates ?? {}),
+        graph.resolutionInputs ?? [],
+    ]) {
         if (!Array.isArray(candidates)) {
             continue;
         }
@@ -3346,11 +4214,14 @@ function selectNotifiableAbsentInputs(props) {
             }
             const absolute = path.resolve(props.projectRoot, candidate);
             const spelling = path.resolve(absolute);
+            const observation = graphIndexes.inputObservations.get(spelling);
+            const absentAsFile = observation?.fileExists === false ||
+                (observation === undefined && !props.filesystem.exists(absolute));
             if (seen.has(spelling) ||
                 isTransformScratchInput(absolute, props.scratchDirectory) ||
                 (excluded !== undefined &&
                     pathIdentityKey(absolute, identities) === excluded) ||
-                props.filesystem.exists(absolute)) {
+                !absentAsFile) {
                 continue;
             }
             seen.add(spelling);
@@ -3448,19 +4319,6 @@ function insideProject(directory, projectRoot) {
  * number; the bound stays sound and is merely not tight.
  */
 const NOTIFIABLE_ABSENCE_DIRECTORY_LIMIT = 512;
-function isIgnoredProjectDirectory(name) {
-    // 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.
  *
@@ -3685,6 +4543,9 @@ function selectDeclaredProjectInputKeys(props) {
     if (Array.isArray(graph.configs))
         for (const input of graph.configs)
             add(input);
+    if (Array.isArray(graph.resolutionInputs))
+        for (const input of graph.resolutionInputs)
+            add(input);
     for (const [source, candidates] of Object.entries(graph.candidates ?? {})) {
         add(source);
         if (Array.isArray(candidates))
@@ -3898,6 +4759,10 @@ function createUnstableGenerationError(projectRoot, attempts, validation) {
         }
     });
     lines.push("  Stop writes to the listed inputs before compilation, or fix the producer that omitted or contradicted the listed proof.");
+    // The failed snapshot remains useful as immutable retry evidence, but it can
+    // never serve a module. Release every live resource before its terminal
+    // verdict is retained in the cache.
+    disposeCachedTransform(validation.cached);
     return new TtscUnstableGenerationError(lines.join("\n"), validation);
 }
 function hashText(input) {
@@ -3907,9 +4772,10 @@ 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) {
+        if (cached.configStateComplete !== false &&
+            (!props.trackProjectMembership ||
+                cached.result.type !== "success" ||
+                cached.projectSnapshotComplete === true)) {
             return cached;
         }
         attempts.push(TRANSFORM_GENERATION_FAILURES.get(cached.result) ??
@@ -3930,21 +4796,43 @@ async function transformProject(props) {
 async function captureTransformGeneration(props) {
     const projectRoot = path.dirname(props.tsconfig);
     const scratchDirectory = createTransformScratchDirectory(projectRoot, props.filesystem);
+    let clockReferenceDirectory;
+    let retainClockReferenceDirectory = false;
     let tracker;
     let retainTracker = false;
     let hostInputTracker;
     let candidateTracker;
     let retainHostInputTracker = false;
     let retainCandidateTracker = false;
+    let captured;
     try {
-        const configured = createTransformTsconfig(props, scratchDirectory);
+        if (props.trackProjectMembership) {
+            try {
+                clockReferenceDirectory = createTransformScratchDirectory(projectRoot, props.filesystem);
+            }
+            catch {
+                // A retained probe is an optimization. The live compiler scratch can
+                // still authorize capture, and later validations will compare bytes.
+            }
+        }
+        const materializesConfig = Object.keys(props.compilerOptions).length !== 0 ||
+            Object.keys(props.aliasPaths).length !== 0;
+        const tsconfigState = readTransformTsconfigState(props.tsconfig, materializesConfig);
+        const configured = createTransformTsconfig(props, scratchDirectory, tsconfigState);
         const temporaryTsconfig = configured.path === props.tsconfig ? undefined : configured.path;
+        const compilerEnvironment = transformScratchEnvironment(scratchDirectory);
+        if (temporaryTsconfig === undefined) {
+            delete compilerEnvironment[TTSC_SEMANTIC_CONFIG_PATH];
+        }
+        else {
+            compilerEnvironment[TTSC_SEMANTIC_CONFIG_PATH] = props.tsconfig;
+        }
         const identities = createHostPathIdentityContext(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 membershipPolicy = tsconfigPaths.mergeMembershipPolicyOverlay(tsconfigState.membershipPolicy, props.compilerOptions, projectRoot);
         const before = collectProjectInputSnapshot(projectRoot, identities, props.filesystem, undefined, { policy: membershipPolicy });
         tracker = props.trackProjectMembership
             ? await createProjectMutationTracker(before.projectDirectories, props.filesystem, membershipPolicy)
@@ -3961,13 +4849,16 @@ async function captureTransformGeneration(props) {
             plugins: props.plugins,
             projectRoot,
             tsconfig: configured.path,
-            env: transformScratchEnvironment(scratchDirectory),
+            env: compilerEnvironment,
         }).transform());
         TRANSFORM_RESULT_FILESYSTEM.set(result, props.filesystem);
+        const configStable = tsconfigState.signature === undefined ||
+            tsconfigState.signature ===
+                readTransformTsconfigState(props.tsconfig, true).signature;
         // Mint the generation's clock reference after the compile and before any
         // signature-recording read below, so every input written before the
         // compile sits in a provably finished tick when its signature is captured.
-        mintFilesystemClockReference(scratchDirectory, props.filesystem);
+        refreshFilesystemClockReference(clockReferenceDirectory ?? scratchDirectory, props.filesystem);
         const persistentHostInputs = selectPersistentHostInputs({
             filesystem: props.filesystem,
             projectRoot,
@@ -4030,7 +4921,8 @@ async function captureTransformGeneration(props) {
             result,
             scratchDirectory,
         });
-        const walkStable = walkSnapshotComplete(before, declaredInputs) &&
+        const walkStable = configStable &&
+            walkSnapshotComplete(before, declaredInputs) &&
             walkSnapshotComplete(inputSnapshot, declaredInputs) &&
             sameHashes(before.hashes, inputSnapshot.hashes, declaredInputs) &&
             sameHashes(before.fileSignatures, inputSnapshot.fileSignatures, declaredInputs) &&
@@ -4066,6 +4958,7 @@ async function captureTransformGeneration(props) {
             externalInputHashes: {},
             externalInputRealpaths: {},
             externalInputPaths,
+            configStateComplete: configStable,
             inputHashes: inputSnapshot.hashes,
             inputSignatures: inputSnapshot.provenSignatures,
             membershipPolicy,
@@ -4084,6 +4977,7 @@ async function captureTransformGeneration(props) {
         cached.sourceHashes = captureTransformSourceHashes(cached, props.currentFile, currentSourceHash);
         const externalInputSnapshot = captureExternalInputSnapshot(cached, externalInputPaths);
         cached.externalInputHashes = externalInputSnapshot.hashes;
+        cached.externalInputObservations = externalInputSnapshot.observations;
         cached.externalInputRealpaths = externalInputSnapshot.realpaths;
         cached.externalInputSignatures = externalInputSnapshot.signatures;
         // Evaluate every half, rather than short-circuiting, so a generation that
@@ -4091,6 +4985,13 @@ async function captureTransformGeneration(props) {
         // only on the failing path, where the alternative is recompiling the whole
         // project for every remaining module.
         const failures = createGenerationProofFailures();
+        if (!configStable) {
+            recordGenerationProofFailure(failures, {
+                domain: "project",
+                kind: "config-state-changed",
+                path: props.tsconfig,
+            });
+        }
         if (!walkStable) {
             recordProjectSnapshotFailures(failures, {
                 before,
@@ -4146,32 +5047,80 @@ async function captureTransformGeneration(props) {
         retainTracker = notifying && tracker !== undefined;
         retainHostInputTracker = notifying && hostInputTracker !== undefined;
         retainCandidateTracker = notifying && candidateTracker !== undefined;
-        return cached;
+        if (clockReferenceDirectory !== undefined) {
+            retainClockReferenceDirectory = true;
+        }
+        captured = cached;
     }
     finally {
+        let cleanupFailed = false;
+        let cleanupFailure;
         try {
-            if (!retainTracker && tracker !== undefined) {
-                tracker.close();
-            }
-        }
-        finally {
             try {
-                if (!retainHostInputTracker && hostInputTracker !== undefined) {
-                    hostInputTracker.close();
+                if (!retainTracker && tracker !== undefined) {
+                    tracker.close();
                 }
             }
             finally {
                 try {
-                    if (!retainCandidateTracker && candidateTracker !== undefined) {
-                        candidateTracker.close();
+                    if (!retainHostInputTracker && hostInputTracker !== undefined) {
+                        hostInputTracker.close();
                     }
                 }
                 finally {
-                    fs.rmSync(scratchDirectory, { force: true, recursive: true });
+                    try {
+                        if (!retainCandidateTracker && candidateTracker !== undefined) {
+                            candidateTracker.close();
+                        }
+                    }
+                    finally {
+                        try {
+                            fs.rmSync(scratchDirectory, { force: true, recursive: true });
+                        }
+                        finally {
+                            if (!retainClockReferenceDirectory &&
+                                clockReferenceDirectory !== undefined) {
+                                disposeFilesystemClockReference(clockReferenceDirectory);
+                            }
+                        }
+                    }
                 }
             }
         }
+        catch (error) {
+            cleanupFailed = true;
+            cleanupFailure = error;
+        }
+        if (cleanupFailed) {
+            // The generation never leaves this function when local cleanup fails.
+            // Close everything that was waiting to transfer, without letting a
+            // secondary teardown error replace the first failure.
+            for (const retained of [
+                retainTracker ? tracker : undefined,
+                retainHostInputTracker ? hostInputTracker : undefined,
+                retainCandidateTracker ? candidateTracker : undefined,
+            ]) {
+                try {
+                    retained?.close();
+                }
+                catch {
+                    // Continue releasing the other generation-owned resources.
+                }
+            }
+            if (retainClockReferenceDirectory &&
+                clockReferenceDirectory !== undefined) {
+                disposeFilesystemClockReference(clockReferenceDirectory);
+            }
+            throw cleanupFailure;
+        }
     }
+    if (captured === undefined) {
+        throw new Error("ttsc: transform generation capture produced no result");
+    }
+    if (clockReferenceDirectory !== undefined) {
+        TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.set(captured, clockReferenceDirectory);
+    }
+    return captured;
 }
 /** Exclude disposed transform scratch from live host-input tracking. */
 function selectPersistentHostInputs(props) {
@@ -4191,17 +5140,55 @@ function selectPersistentHostInputs(props) {
         return pathIdentityKey(input, identities) !== temporary;
     });
 }
-function createTransformTsconfig(props, scratchDirectory) {
-    const compilerOptions = normalizeCompilerOptionsForGeneratedTsconfig({
+/** Read every wrapper-dependent view and bind it to one config-chain state. */
+function readTransformTsconfigState(tsconfig, materializesConfig) {
+    const membershipPolicy = tsconfigPaths.readProjectMembershipPolicy(tsconfig);
+    if (!materializesConfig) {
+        return {
+            effectivePaths: {},
+            membershipPolicy,
+            templateCompilerOptions: {},
+            templateFileSpecs: {},
+        };
+    }
+    const effectivePaths = tsconfigPaths.readEffectiveTsconfigPaths(tsconfig);
+    const templateCompilerOptions = tsconfigPaths.readEffectiveTsconfigTemplateCompilerOptions(tsconfig);
+    const templateFileSpecs = tsconfigPaths.readEffectiveTsconfigTemplateFileSpecs(tsconfig);
+    const sources = tsconfigPaths.readTsconfigSourceSnapshot(tsconfig);
+    return {
+        effectivePaths,
+        membershipPolicy,
+        signature: hashText(JSON.stringify({
+            effectivePaths,
+            membershipPolicy,
+            sources,
+            templateCompilerOptions,
+            templateFileSpecs,
+        })),
+        templateCompilerOptions,
+        templateFileSpecs,
+    };
+}
+function createTransformTsconfig(props, scratchDirectory, state) {
+    const overlay = normalizeCompilerOptionsForGeneratedTsconfig({
         ...props.compilerOptions,
-        ...createAliasCompilerOptions(props),
+        ...createAliasCompilerOptions(props, state.effectivePaths),
     }, path.dirname(props.tsconfig));
-    if (Object.keys(compilerOptions).length === 0) {
+    if (Object.keys(overlay).length === 0) {
         return { path: props.tsconfig };
     }
+    // A `${configDir}` value survives every `extends` hop and binds only at the
+    // final consumer. The scratch wrapper would therefore move it out of the
+    // project even for an unrelated overlay. Re-state only those inherited
+    // values as absolute paths so the wrapper remains semantically transparent.
+    const compilerOptions = {
+        ...state.templateCompilerOptions,
+        ...overlay,
+    };
     const file = path.join(scratchDirectory, "tsconfig.json");
     fs.writeFileSync(file, JSON.stringify({
         extends: normalizePath(props.tsconfig),
+        ...state.templateFileSpecs,
         compilerOptions,
     }, null, 2), "utf8");
     return { path: file };
@@ -4334,15 +5321,17 @@ function withTransformScratchEnvironment(scratchDirectory, callback) {
 function normalizeCompilerOptionsForGeneratedTsconfig(compilerOptions, tsconfigDir) {
     const output = { ...compilerOptions };
     // Scalar path fields: resolve each against the original tsconfig directory.
-    for (const key of ["declarationDir", "outDir", "rootDir"]) {
+    for (const key of tsconfigPaths.CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS) {
         if (typeof output[key] === "string") {
-            output[key] = path.resolve(tsconfigDir, output[key]);
+            output[key] = tsconfigPaths.resolveConfigDirTemplatePath(tsconfigDir, output[key]);
         }
     }
     // Array path fields: resolve each element individually.
-    for (const key of ["rootDirs", "typeRoots"]) {
+    for (const key of tsconfigPaths.CONFIG_DIR_TEMPLATE_LIST_OPTIONS) {
         if (Array.isArray(output[key])) {
-            output[key] = output[key].map((entry) => typeof entry === "string" ? path.resolve(tsconfigDir, entry) : entry);
+            output[key] = output[key].map((entry) => typeof entry === "string"
+                ? tsconfigPaths.resolveConfigDirTemplatePath(tsconfigDir, entry)
+                : entry);
         }
     }
     const paths = readPaths(output.paths);
@@ -4392,13 +5381,13 @@ function normalizePluginConfigForGeneratedTsconfig(entry, tsconfigDir) {
  * No `baseUrl` is emitted: TypeScript-Go removed the option (TS5102), and all
  * targets are absolute so none is needed.
  */
-function createAliasCompilerOptions(props) {
+function createAliasCompilerOptions(props, effectivePaths) {
     if (Object.keys(props.aliasPaths).length === 0) {
         return {};
     }
     return {
         paths: {
-            ...tsconfigPaths.readEffectiveTsconfigPaths(props.tsconfig),
+            ...effectivePaths,
             ...readPaths(props.compilerOptions.paths),
             ...props.aliasPaths,
         },
@@ -4720,9 +5709,9 @@ function stripTerminalEscapes(text) {
  *
  * If `tsconfig` is supplied it is returned as-is (absolute) or resolved from
  * `process.cwd()` (relative). Otherwise the function walks ancestor directories
- * starting at `file`'s directory, returning the first `tsconfig.json` found.
- * Falls back to `<cwd>/tsconfig.json` when no ancestor contains one; the
- * compiler will error if that file does not exist, which is the correct
+ * starting at `file`'s directory, returning the first `tsconfig.json` proven to
+ * be a file. Falls back to `<cwd>/tsconfig.json` when no ancestor contains one;
+ * the compiler will error if that file does not exist, which is the correct
  * behavior for a mis-configured project.
  */
 function resolveTsconfig(file, tsconfig, filesystem = DEFAULT_FILESYSTEM_OPERATIONS) {
@@ -4731,18 +5720,9 @@ function resolveTsconfig(file, tsconfig, filesystem = DEFAULT_FILESYSTEM_OPERATI
             ? tsconfig
             : path.resolve(process.cwd(), tsconfig);
     }
-    let current = path.dirname(file);
-    while (true) {
-        const candidate = path.join(current, "tsconfig.json");
-        if (filesystem.exists(candidate)) {
-            return candidate;
-        }
-        const parent = path.dirname(current);
-        // Reached filesystem root, stop walking.
-        if (parent === current) {
-            break;
-        }
-        current = parent;
+    const discovered = projectDiscovery.findNearestProjectTsconfig(path.dirname(file), filesystem);
+    if (discovered !== undefined) {
+        return discovered;
     }
     return path.resolve(process.cwd(), "tsconfig.json");
 }
@@ -4767,15 +5747,21 @@ function normalizePath(file) {
 }
 
 exports.beginTtscTransformBuild = beginTtscTransformBuild;
+exports.captureWatchInputBaseline = captureWatchInputBaseline;
+exports.captureWatchInputFileBaseline = captureWatchInputFileBaseline;
 exports.collectExternalInputHashes = collectExternalInputHashes;
+exports.collectProjectInputHashSnapshot = collectProjectInputHashSnapshot;
 exports.collectProjectInputHashes = collectProjectInputHashes;
 exports.createTransformResult = createTransformResult;
 exports.createTtscTransformCache = createTtscTransformCache;
 exports.isDeclarationFile = isDeclarationFile;
 exports.isProjectWalkPath = isProjectWalkPath;
+exports.isWatchInputKeyBaseline = isWatchInputKeyBaseline;
 exports.normalizeHostInputName = normalizeHostInputName;
 exports.pathIdentityKey = pathIdentityKey;
 exports.resetTtscTransformCache = resetTtscTransformCache;
 exports.stripQuery = stripQuery;
 exports.transformTtsc = transformTtsc;
+exports.validateGraphInputObservation = validateGraphInputObservation;
+exports.watchInputEvidenceMatchesBaseline = watchInputEvidenceMatchesBaseline;
 //# sourceMappingURL=transform.js.map