@ttsc/unplugin 0.27.0 → 0.28.1

package/README.md

@@ -312,7 +312,7 @@ The transform host reports the program's reference graph (the transform envelope
 
 Transform plugins may additionally report, per file, the source files they consulted (the envelope's `dependencies` field); the adapter registers those as watch files too, union semantics. A plugin that declares such a list [complete](https://ttsc.dev/docs/development/concepts/protocol#dependency-completeness) for a file narrows the registration instead: only its own list plus the tsconfig chain, so files the transform never consulted stop invalidating it. The JavaScript host also reports the descriptor's loaded CommonJS graph, every package manifest inspected by auto-discovery, and plugin-declared `hostInputs`. First-party plugins use that last field for implicit config discovery and evaluated config dependencies. These remain universal without turning arbitrary project assets into configuration. Files a plugin declares `volatile` (output depending on non-file inputs such as environment or time) bypass the adapter's transform cache and are marked uncacheable where the bundler exposes that control.
 
-The transform cache snapshots every regular file reached by the non-following project walk plus graph-reported inputs outside that walk (`node_modules` declarations, monorepo sibling sources, files reached through symlinks or Windows junctions, and out-of-root `extends` ancestry). One whole-project compile already contains every module's output. Adapters with a guaranteed build boundary clear the previous generation there, then check only the supplied source on each module's first delivery from a complete generation in that build. An incomplete generation never takes that shortcut. Later deliveries of a graph-bearing generation validate that file's reference closure, globals, configs, resolution candidates, plugin dependencies, and exact host inputs. Generation-scoped directory notifications detect new, removed, or renamed project inputs without repeating a directory-stat pass per module; Windows isolates those notifications so deletion of a watched temporary tree cannot crash the host. The project is snapshotted before and after compilation, while every graph member carries the compiler filesystem's content and physical-identity proof; only a complete generation that still matches both may authorize narrow reuse. This also rejects an in-project or external A→B→A change whose restored post-compile bytes would otherwise hide the transient state used by the compiler. `dependenciesComplete` narrows file inputs by the same contract as watch registration. Envelopes without a graph, an unavailable watcher, or an unstable/incomplete generation retain complete-snapshot validation. Bun runtime setup defines one process-scoped loading session. Long-lived hosts without either boundary (Metro workers, the Turbopack loader, and Vite's development server, whose initial `buildStart` spans later HMR edits) apply the file-specific validation on every generation hit.
+The transform cache snapshots every regular file reached by the non-following project walk plus graph-reported inputs outside that walk (`node_modules` declarations, monorepo sibling sources, files reached through symlinks or Windows junctions, and out-of-root `extends` ancestry). One whole-project compile already contains every module's output. Adapters with a guaranteed build boundary clear the previous generation there, then check only the supplied source on each module's first delivery from a complete generation in that build. An incomplete generation never takes that shortcut. Later deliveries of a graph-bearing generation validate that file's reference closure, globals, configs, resolution candidates, plugin dependencies, and exact host inputs. Every input a generation has already proven carries the nanosecond metadata signature captured around the read that proved it, so a later delivery that finds the signature unchanged reuses that proof instead of re-reading the bytes; any signature change falls back to the full content comparison. A signature is recorded only for a read nothing raced, only for an input whose recorded state came from bytes that were read, since the metadata of a path nothing could read holds still while the bytes behind it appear, and only once the observed filesystem's own clock has provably left the tick that minted the input's modification stamp. A filesystem stamps writes once per clock tick, so a same-length rewrite landing inside the recorded stamp's tick would leave the signature unchanged; until some stamp the same filesystem minted later separates that tick, the content comparison keeps running, and the signature is re-earned the moment it can be. The reference instants come from the filesystem itself, never from the process clock: every stamp the adapter observes raises a floor kept per reporting device, and the adapter also stamps a probe in its own scratch directory (the way git separates racily-clean index entries with the index file's own timestamp) to cover a tree whose files were all written inside one tick. The probe counts only when the scratch volume is the inputs' volume, so on a split-volume layout the observed stamps carry the rule alone; an input they cannot separate is re-read rather than trusted. Both sides of every comparison are therefore stamps of equal granularity minted by one clock, so a filesystem clock running behind the host changes nothing. The floor is a maximum over stamps it merely observed, so what defeats it is a stamp that was set into the future rather than minted, such as a stamp-preserving extraction or copy from a machine whose clock ran ahead. A restored past stamp is harmless, since it never raises the floor. A clock that jumps backwards strands the floor above the present the same way, which is a different hazard from a clock running at a constant offset: an offset moves both stamps being compared and changes nothing, while a jump moves only the present. No stamp-based freshness proof survives either one. Sibling modules therefore share one proof of the closure and the globals rather than repeating it per module. Generation-scoped directory notifications detect new, removed, or renamed project inputs without repeating a directory-stat pass per module; Windows isolates those notifications so deletion of a watched temporary tree cannot crash the host. An absent resolution candidate is the one input a metadata signature cannot stand for, since a path that is not there has no metadata to compare. The generation therefore registers those names with a watcher of their own, along with the directory components of the spelling that lead to them, down to the project's own root, and a delivery reads the notification instead of re-probing each candidate. That makes the notification the sole positive evidence for this one input class, which is why the registration reaches past the candidate itself: a watcher opened on a path that traverses a link follows it, so retargeting the link would otherwise move the answer without disturbing what is watched, and a package link inside `node_modules` is exactly that. It stops at the project root, and a candidate whose spelling leaves the project subtree before reaching it is not claimed at all: above that line the components are the machine's own layout rather than the project's, which nobody retargets and which changes for reasons no generation should hear about. It listens for renames alone, since every event that can change a candidate's answer is one — the file appearing, a component being created, replaced or retargeted — while the directories carrying them have their attributes moved by anything written below. A candidate whose watch could not be opened, whose watcher has since failed, or that belongs to a set spanning more directories than the generation will watch, is probed exactly as before: a host that runs out of watch descriptors would fail the tracker outright, which costs every delivery a whole-project comparison rather than one probe. What none of that covers is a filesystem that accepts a watch and then reports nothing, which some network mounts do; that is the same assumption the project-membership proof beside it already rests on, though a wider one here: the project walk skips `node_modules`, so a candidate under it was never covered by that proof and kept a notification-independent probe until now. A project on such a mount should be treated as one where notifications do not work rather than one where they merely have not fired. The barrier that lets a synchronous edit reach those watchers before a delivery reads their verdict is the watcher's own acknowledgement rather than a fixed wait: an in-process watcher answers on the next turn of the loop its callbacks are queued on, and the Windows broker answers by an ordered round-trip, so a delivery waits for the crossing instead of guessing at it. The project is snapshotted before and after compilation, while every graph member carries the compiler filesystem's content and physical-identity proof; only a complete generation that still matches both may authorize narrow reuse. This also rejects an in-project or external A→B→A change whose restored post-compile bytes would otherwise hide the transient state used by the compiler. `dependenciesComplete` narrows file inputs by the same contract as watch registration, and a project reaches it without a type-driven plugin: ttsc's own transform lanes print syntactically, so the host declares every file complete when no plugin can contribute to it, and the first-party `@ttsc/banner` and `@ttsc/strip` declare their own contribution the same way. Such a delivery validates the universal inputs and the file itself instead of its reference closure. A narrowed file's diagnostics narrow with it: an edit to a file the declaration dropped no longer re-runs the compile, so a type error introduced there surfaces at the next compile the build runs for another reason rather than at the edit. Run the compiler's own check beside the bundler when you want it at the edit. Envelopes without a graph, and generations whose watchers could not be opened or have since failed, retain complete-snapshot validation: losing a notification is the absence of a membership proof rather than evidence of a change, so such a generation keeps validating against its own recorded state (the directory snapshot, the input hashes, and the universal descriptor inputs whose every rejection is evidence of a change rather than an inability to prove one) instead of being discarded. A reported membership event is evidence, and still replaces the generation. Only an unstable or incomplete generation is refused outright. Bun runtime setup defines one process-scoped loading session. A dev server started without a watcher takes the build-scoped lifecycle instead of persistent validation. `server.watch: null` leaves the session no channel through which a file change could ever reach it, so what per-delivery validation buys there is incoherence rather than freshness: modules delivered before an edit and after it would come from two different compilations of one program. Each module's first delivery in such a session is therefore settled against the generation the session started from, exactly as under a build, while a module the session already delivered keeps revalidating on its next request. Long-lived hosts without either boundary (Metro workers, the Turbopack loader, and a watching Vite development server, whose initial `buildStart` spans later HMR edits) apply the file-specific validation on every generation hit.
 
 ## Sponsors
 

package/lib/core/index.d.ts

@@ -10,7 +10,7 @@ import { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInpu
 export declare const sourceFilePattern: RegExp;
 declare const unplugin: UnpluginInstance<TtscUnpluginOptions | undefined, false>;
 export type { TtscUnpluginCompilerOptionsJson, TtscUnpluginOptions, } from "./options";
-export type { TtscTransformFilesystemOperations, TtscTransformHooks, } from "./transform";
+export type { TtscTransformFilesystemOperations, TtscTransformHooks, TtscWatchInputEvidence, } from "./transform";
 export { beginTtscTransformBuild, collectExternalInputHashes, collectProjectInputHashes, createTtscTransformCache, isProjectWalkPath, resetTtscTransformCache, resolveOptions, transformTtsc, unplugin, };
 export default unplugin;
 /**

package/lib/core/index.js

@@ -30,8 +30,10 @@ const virtualModulePattern = /\0/;
  * The factory resolves raw options once, creates a per-build transform cache,
  * and captures Vite alias configuration via the `vite.configResolved` hook so
  * that path aliases are forwarded to the generated tsconfig overlay. Real build
- * lifecycles use a per-build cache; Vite's development server keeps persistent
- * validation because its one `buildStart` spans later HMR edits.
+ * lifecycles use a per-build cache; a watching Vite development server keeps
+ * persistent validation because its one `buildStart` spans later HMR edits,
+ * while a dev server configured without a watcher takes the build-scoped path
+ * with them, having declared it will observe no edit at all.
  */
 const unpluginFactory = (rawOptions = {}) => {
     const options$1 = options.resolveOptions(rawOptions);
@@ -39,6 +41,7 @@ const unpluginFactory = (rawOptions = {}) => {
     const missingInputs = viteServe.createViteServeMissingInputWatch();
     let aliases;
     let viteCommand;
+    let viteWatching = true;
     return {
         name,
         enforce: "pre",
@@ -50,6 +53,16 @@ const unpluginFactory = (rawOptions = {}) => {
                 // serve-time poll, even though the closed server stays attached
                 // (see the dispose note in viteServe.ts).
                 viteCommand = config.command;
+                // `server.watch: null` disables Vite's watcher outright, which is how
+                // a one-shot consumer (a `vitest --run` suite above all) configures the
+                // dev server. Nothing can then deliver a change event, so every watch
+                // registration is dead weight, and not cheap dead weight: Vite's
+                // import analysis resolves each registered path like a real import of
+                // the transformed module, once per module, which is the dominant cost
+                // of a delivered module in a project with a real dependency graph
+                // (samchon/ttsc#1246).
+                viteWatching =
+                    config.server?.watch !== null;
             },
             // Vite serve funnels every transform-context `addWatchFile()` into the
             // module's added-import graph (`_addedImports`), which import-analysis
@@ -67,7 +80,22 @@ const unpluginFactory = (rawOptions = {}) => {
             },
         },
         buildStart() {
-            if (viteCommand === "serve") {
+            // Persistent validation exists for a session that spans edits it can
+            // observe, and a dev server told to open no watcher is not one:
+            // `server.watch: null` leaves Vite with no change channel at all, so no
+            // edit can reach the session, nothing invalidates what one touched, and
+            // no client is hot-updated. Validating each delivery there does not buy
+            // freshness, it buys incoherence — modules delivered before an edit and
+            // after it would come from two different compilations of one program —
+            // while costing a full derived-input proof per delivered module. The
+            // build-scoped lifecycle settles each module's first delivery against the
+            // generation the session started from, exactly as a build does, and still
+            // revalidates a module this session already delivered. A one-shot suite
+            // configures precisely this server (`vitest --run` sets `server.watch =
+            // null`) and is the workload behind samchon/ttsc#970
+            // (samchon/ttsc#1260). The neighbouring watch-registration decision reads
+            // the same two properties for the same reason.
+            if (viteCommand === "serve" && viteWatching) {
                 transform.resetTtscTransformCache(transformCache);
             }
             else {
@@ -94,11 +122,24 @@ const unpluginFactory = (rawOptions = {}) => {
                 // (a superseding resolution candidate, a not-yet-generated
                 // dependency), so those are watched on the filesystem instead and
                 // invalidate this module when created.
-                addWatchFile: (watched) => {
-                    if (viteCommand === "serve" &&
-                        missingInputs.serving() &&
-                        !fs.existsSync(watched)) {
-                        missingInputs.watch(watched, path.resolve(file));
+                addWatchFile: (watched, evidence) => {
+                    if (viteCommand === "serve" && missingInputs.serving()) {
+                        // Trust the generation's recorded existence when it supplied one:
+                        // every cache hit revalidates it, and probing each input again
+                        // costs one `existsSync` per input per delivered module.
+                        const missing = evidence?.missing ?? !fs.existsSync(watched);
+                        if (missing) {
+                            missingInputs.watch(watched, path.resolve(file), evidence?.identity);
+                            return;
+                        }
+                    }
+                    // A dev server configured without a watcher can never deliver a
+                    // change event, so a registration here buys nothing, and it is not
+                    // free: Vite's import analysis resolves every registered path like a
+                    // real import of the transformed module, once per module. The
+                    // adapter's own missing-input poll above stays active either way,
+                    // because it never depended on Vite's watcher.
+                    if (viteCommand === "serve" && !viteWatching) {
                         return;
                     }
                     this.addWatchFile(watched);

package/lib/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":["options","resolveOptions","createTtscTransformCache","createViteServeMissingInputWatch","resetTtscTransformCache","beginTtscTransformBuild","stripQuery","transformTtsc","createUnplugin","isDeclarationFile"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":["options","resolveOptions","createTtscTransformCache","createViteServeMissingInputWatch","resetTtscTransformCache","beginTtscTransformBuild","stripQuery","transformTtsc","createUnplugin","isDeclarationFile"],"mappings":"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"}

package/lib/core/index.mjs

@@ -27,8 +27,10 @@ const virtualModulePattern = /\0/;
  * The factory resolves raw options once, creates a per-build transform cache,
  * and captures Vite alias configuration via the `vite.configResolved` hook so
  * that path aliases are forwarded to the generated tsconfig overlay. Real build
- * lifecycles use a per-build cache; Vite's development server keeps persistent
- * validation because its one `buildStart` spans later HMR edits.
+ * lifecycles use a per-build cache; a watching Vite development server keeps
+ * persistent validation because its one `buildStart` spans later HMR edits,
+ * while a dev server configured without a watcher takes the build-scoped path
+ * with them, having declared it will observe no edit at all.
  */
 const unpluginFactory = (rawOptions = {}) => {
     const options = resolveOptions(rawOptions);
@@ -36,6 +38,7 @@ const unpluginFactory = (rawOptions = {}) => {
     const missingInputs = createViteServeMissingInputWatch();
     let aliases;
     let viteCommand;
+    let viteWatching = true;
     return {
         name,
         enforce: "pre",
@@ -47,6 +50,16 @@ const unpluginFactory = (rawOptions = {}) => {
                 // serve-time poll, even though the closed server stays attached
                 // (see the dispose note in viteServe.ts).
                 viteCommand = config.command;
+                // `server.watch: null` disables Vite's watcher outright, which is how
+                // a one-shot consumer (a `vitest --run` suite above all) configures the
+                // dev server. Nothing can then deliver a change event, so every watch
+                // registration is dead weight, and not cheap dead weight: Vite's
+                // import analysis resolves each registered path like a real import of
+                // the transformed module, once per module, which is the dominant cost
+                // of a delivered module in a project with a real dependency graph
+                // (samchon/ttsc#1246).
+                viteWatching =
+                    config.server?.watch !== null;
             },
             // Vite serve funnels every transform-context `addWatchFile()` into the
             // module's added-import graph (`_addedImports`), which import-analysis
@@ -64,7 +77,22 @@ const unpluginFactory = (rawOptions = {}) => {
             },
         },
         buildStart() {
-            if (viteCommand === "serve") {
+            // Persistent validation exists for a session that spans edits it can
+            // observe, and a dev server told to open no watcher is not one:
+            // `server.watch: null` leaves Vite with no change channel at all, so no
+            // edit can reach the session, nothing invalidates what one touched, and
+            // no client is hot-updated. Validating each delivery there does not buy
+            // freshness, it buys incoherence — modules delivered before an edit and
+            // after it would come from two different compilations of one program —
+            // while costing a full derived-input proof per delivered module. The
+            // build-scoped lifecycle settles each module's first delivery against the
+            // generation the session started from, exactly as a build does, and still
+            // revalidates a module this session already delivered. A one-shot suite
+            // configures precisely this server (`vitest --run` sets `server.watch =
+            // null`) and is the workload behind samchon/ttsc#970
+            // (samchon/ttsc#1260). The neighbouring watch-registration decision reads
+            // the same two properties for the same reason.
+            if (viteCommand === "serve" && viteWatching) {
                 resetTtscTransformCache(transformCache);
             }
             else {
@@ -91,11 +119,24 @@ const unpluginFactory = (rawOptions = {}) => {
                 // (a superseding resolution candidate, a not-yet-generated
                 // dependency), so those are watched on the filesystem instead and
                 // invalidate this module when created.
-                addWatchFile: (watched) => {
-                    if (viteCommand === "serve" &&
-                        missingInputs.serving() &&
-                        !fs.existsSync(watched)) {
-                        missingInputs.watch(watched, path.resolve(file));
+                addWatchFile: (watched, evidence) => {
+                    if (viteCommand === "serve" && missingInputs.serving()) {
+                        // Trust the generation's recorded existence when it supplied one:
+                        // every cache hit revalidates it, and probing each input again
+                        // costs one `existsSync` per input per delivered module.
+                        const missing = evidence?.missing ?? !fs.existsSync(watched);
+                        if (missing) {
+                            missingInputs.watch(watched, path.resolve(file), evidence?.identity);
+                            return;
+                        }
+                    }
+                    // A dev server configured without a watcher can never deliver a
+                    // change event, so a registration here buys nothing, and it is not
+                    // free: Vite's import analysis resolves every registered path like a
+                    // real import of the transformed module, once per module. The
+                    // adapter's own missing-input poll above stays active either way,
+                    // because it never depended on Vite's watcher.
+                    if (viteCommand === "serve" && !viteWatching) {
                         return;
                     }
                     this.addWatchFile(watched);

package/lib/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"index.mjs","sources":["../../src/core/index.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/lib/core/transform.d.ts

@@ -32,6 +32,27 @@ interface TtscProjectDirectorySnapshot {
 /** Generation-scoped directory watchers used to detect membership changes. */
 interface TtscProjectMutationTracker {
     close: () => void;
+    /**
+     * Absolute spellings whose creation, change or removal this tracker would
+     * report, when it watches exact names rather than whole directories.
+     *
+     * A validation that finds an input here needs no filesystem call of its own:
+     * the tracker is the evidence, and every path that leaves this set falls back
+     * to being proven by hand. Empty for a tracker that watches directories as a
+     * whole, which cannot answer for one name.
+     */
+    covered?: ReadonlySet<string>;
+    /**
+     * Wait until every event this tracker's watcher has already dispatched has
+     * been applied to it.
+     *
+     * An in-process watcher drains on the next macrotask turn, because its
+     * callbacks are already queued on this loop. A watcher living in the Windows
+     * broker drains by round-trip instead: the child replies after its own turn,
+     * and IPC preserves order, so the reply cannot overtake an event the child
+     * had already sent (samchon/ttsc#1272).
+     */
+    drain?: () => Promise<void>;
     failed: boolean;
     membershipChanged: boolean;
     settle?: Promise<void>;
@@ -73,15 +94,68 @@ export interface TtscCachedProjectTransform {
      * compiler reported rather than a normalized replacement spelling.
      */
     externalInputPaths?: string[];
+    /**
+     * Metadata signature of each out-of-walk input, captured around the read that
+     * proved its {@link externalInputHashes} entry and recorded only once the
+     * observed filesystem's clock provably left the stamp's tick
+     * ({@link stampSeparable}). An input whose signature still holds carries the
+     * recorded content, so revalidation may skip the read.
+     *
+     * Keyed by lexical spelling rather than by physical identity, for the reason
+     * {@link TtscHostInputValidation} states: a symlink or junction spelling and
+     * its selected target deliberately share one identity but have different
+     * metadata, so an identity key would let the two overwrite each other's
+     * signature and force both to be re-read on every delivery.
+     */
+    externalInputSignatures?: Record<string, string>;
     /**
      * SHA-256 hash of each project-relative input path at the time of the
      * transform.
      */
     inputHashes: Record<string, string>;
+    /**
+     * Metadata signature of each {@link inputHashes} entry whose hash was proven
+     * against an unracing read of the file on disk, in a tick the observed
+     * filesystem's clock had provably left ({@link stampSeparable}).
+     *
+     * The generation's own current file is absent at capture: its recorded hash
+     * comes from the bundler's in-memory source, so the walk that produced it
+     * compared nothing. A later delivery of a sibling does compare that file's
+     * disk bytes against the recorded hash, and may record a signature then.
+     */
+    inputSignatures?: Record<string, string>;
     /** Metadata snapshot of every directory in the stable generation walk. */
     projectDirectories?: TtscProjectDirectorySnapshot[];
     /** Live notification state for universal host-input changes. */
     hostInputMutationTracker?: TtscProjectMutationTracker;
+    /**
+     * Live notification state for the generation's absent resolution candidates
+     * and the directories that carry them.
+     *
+     * Separate from the universal-input tracker because it listens for a
+     * different thing. Every event that can make an absent candidate present is a
+     * rename — the file appearing, a component of the path being created,
+     * replaced, or retargeted — so a change event on one of these names is never
+     * evidence this tracker exists to collect. What it is, on a backend that
+     * reports a write below a directory as a change to that directory's own entry
+     * (Windows does), is a dev server's steady traffic: listening for every event
+     * would replace the generation each time a bundler wrote inside
+     * `node_modules`. The filter therefore drops noise without dropping proof.
+     * The one appearance it cannot see is a Windows junction retargeted in place
+     * through `FSCTL_SET_REPARSE_POINT`, which no mainstream tool does; every
+     * package manager replaces the entry instead, which is a rename.
+     */
+    candidateMutationTracker?: TtscProjectMutationTracker;
+    /**
+     * Universal descriptor/config inputs proven once at generation time, then by
+     * metadata.
+     *
+     * Recorded state of the generation, like the input hashes and the directory
+     * snapshot beside it, rather than state derived from the envelope: an entry
+     * carries the manifest that proved it, so nothing can present one
+     * generation's recorded inputs under another envelope's proof.
+     */
+    hostInputValidation?: TtscHostInputValidation;
     /** Live notification state for file/directory creation, deletion, and rename. */
     projectMutationTracker?: TtscProjectMutationTracker;
     /**
@@ -137,6 +211,23 @@ export interface TtscTransformFilesystemOperations {
     statBigInt(location: string): fs.BigIntStats;
     /** Override path parsing when the observed filesystem is not the host. */
     platform?: NodeJS.Platform;
+    /**
+     * Open one directory's change notification, or throw when the observed
+     * filesystem cannot provide one.
+     *
+     * Left undefined, generations watch the host filesystem: `fs.watch` on POSIX
+     * and an isolated broker process on Windows. An embedder observing another
+     * filesystem supplies its own; a generation whose watch cannot be opened
+     * keeps validating from recorded state instead of losing its cache.
+     *
+     * Supplying one replaces the Windows broker as well, so an embedder that
+     * wraps Node's own `fs.watch` there gives up the isolation that contains the
+     * native abort Node's Windows fs-event backend can raise when a watched
+     * temporary tree is deleted.
+     */
+    watch?(directory: string, listener: (eventType: string, filename: string | null) => void, onError: () => void): {
+        close: () => void;
+    };
 }
 /** Normalize one directory entry under the owning filesystem's case policy. */
 export declare function normalizeHostInputName(name: string, caseSensitive: boolean): string;
@@ -159,6 +250,23 @@ export declare function beginTtscTransformBuild(cache: TtscTransformCache): void
  * many edits, so that callback cannot authorize build-scoped shortcuts.
  */
 export declare function resetTtscTransformCache(cache: TtscTransformCache): void;
+/**
+ * What the generation already knows about one derived watch input, handed to
+ * the adapter so it does not rederive it per input per delivery.
+ *
+ * Both facts are generation state: the identity is the memoized
+ * {@link pathIdentityKey} of the input, and `missing` is the existence the
+ * generation recorded and every cache hit revalidates. An adapter that computes
+ * them itself pays a `realpath`, a case-sensitivity directory listing, and an
+ * `existsSync` for every input of every delivered module, which is O(modules x
+ * inputs) for one build (samchon/ttsc#1246).
+ */
+export interface TtscWatchInputEvidence {
+    /** Memoized filesystem identity of the input. */
+    identity: string;
+    /** Whether the generation recorded this input as absent. */
+    missing: boolean;
+}
 /**
  * Hooks the bundler adapter passes into {@link transformTtsc} so transform
  * side-channels (plugin-reported dependencies and host resolution candidates)
@@ -178,7 +286,7 @@ export interface TtscTransformHooks {
      * persistent-cache invalidation. See {@link selectWatchInputs} for the exact
      * derivation.
      */
-    addWatchFile?: (file: string) => void;
+    addWatchFile?: (file: string, evidence?: TtscWatchInputEvidence) => void;
     /**
      * Invoked when the plugin declared the transformed file volatile (the
      * envelope's `volatile` list): its output depends on non-file inputs that no
@@ -213,6 +321,41 @@ export interface TtscTransformHooks {
  *   per build, not per compilation.
  */
 export declare function transformTtsc(id: string, source: string, options: ResolvedTtscUnpluginOptions, aliases?: unknown, cache?: TtscTransformCache, hooks?: TtscTransformHooks): Promise<TtscTransformResult | undefined>;
+interface TtscHostInputValidation {
+    /** Lexical input spellings that existed when the generation was captured. */
+    readonly entries: Map<string, {
+        path: string;
+        /**
+         * Whether the recorded state of this input came from reading its bytes.
+         * An input that existed but could not be read records a missing state, so
+         * no signature may stand in for it: its metadata holds still while the
+         * bytes behind it appear.
+         */
+        readable: boolean;
+        realpath: string | null;
+        /**
+         * The signature that may stand in for this entry's content comparison, or
+         * `undefined` when none may. A blocker keeps one regardless: it proves a
+         * kind and an identity rather than content.
+         */
+        signature: string | undefined;
+        strict?: true;
+    }>;
+    /**
+     * Lexical spellings the manifest accounts for, omitted from the per-module
+     * dependency loop below.
+     *
+     * Spellings, not identities: a symlink and its target share one identity but
+     * are two inputs, and skipping the alias because the manifest proved the
+     * target would leave the alias's own retarget unvalidated.
+     */
+    readonly covered: Set<string>;
+    /**
+     * Missing paths grouped by the nearest directory whose listing proves them
+     * absent.
+     */
+    readonly missing: Map<string, Set<string>>;
+}
 /**
  * Strip a query string or hash fragment from a bundler module id.
  *