ttsc 0.20.1 → 0.22.0

package/lib/launcher/internal/watchTopology.js

@@ -4,12 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WatchTopology = void 0;
+exports.reloadInputsForFailedTopologyRefresh = reloadInputsForFailedTopologyRefresh;
+exports.syncWatchers = syncWatchers;
+exports.literalGlobRoot = literalGlobRoot;
+exports.projectInputWatchDirectories = projectInputWatchDirectories;
+exports.projectInputActiveWatchDirectories = projectInputActiveWatchDirectories;
+exports.projectInputAvailableWatchDirectory = projectInputAvailableWatchDirectory;
+exports.projectInputReplacementStrandsWatchers = projectInputReplacementStrandsWatchers;
+exports.projectInputTopologyMayAffect = projectInputTopologyMayAffect;
+exports.projectInputEventShouldNotify = projectInputEventShouldNotify;
+exports.projectInputReloadEventShouldNotify = projectInputReloadEventShouldNotify;
+exports.projectInputMembershipInvalidatesProgram = projectInputMembershipInvalidatesProgram;
+exports.planCompilerDirectoryWatchEvent = planCompilerDirectoryWatchEvent;
+const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const readConfigJson_1 = require("../../compiler/internal/project/readConfigJson");
 const readProjectConfig_1 = require("../../compiler/internal/project/readProjectConfig");
 const resolveTsgo_1 = require("../../compiler/internal/resolveTsgo");
 const spawnNative_1 = require("../../compiler/internal/spawnNative");
+const schema_1 = require("../../flags/schema");
+const projectInputPathIdentity_1 = require("../../internal/projectInputPathIdentity");
+const singleFileOutput_1 = require("./singleFileOutput");
 /**
  * Keeps the launcher watch set aligned with the compiler's current program.
  *
@@ -21,14 +37,39 @@ const spawnNative_1 = require("../../compiler/internal/spawnNative");
 class WatchTopology {
     options;
     callbacks;
+    analysisOnly = false;
+    closed = false;
     directories = new Map();
     directoryWatchers = new Map();
     extraInputs = [];
     extraWatchers = new Map();
+    compilerFileStamps = new Map();
     files = new Map();
     fileWatchers = new Map();
     observedDirectories = new Map();
+    outputFiles = new Map();
     outputs = new Map();
+    projectInputFingerprints = new Map();
+    projectInputMatches = new Map();
+    projectInputs = {
+        files: [],
+        globs: [],
+        reloadDirectories: [],
+        reloadFiles: [],
+        root: "",
+    };
+    declaredProjectInputs = {
+        files: [],
+        globs: [],
+        reloadDirectories: [],
+        reloadFiles: [],
+        root: "",
+    };
+    projectInputRejectedWatchRoots = new Set();
+    projectInputWatchRoots = new Map();
+    projectInputWatchers = new Map();
+    projectInputLinkWatchers = new Map();
+    reloadFiles = new Map();
     constructor(options, callbacks) {
         this.options = options;
         this.callbacks = callbacks;
@@ -36,17 +77,56 @@ class WatchTopology {
     /** Re-resolve compiler inputs and notify only when their membership changed. */
     refresh(notify) {
         const next = resolveWatchTopology(this.options, this.extraInputs);
-        const changed = mapsEqual(this.files, next.files) === false ||
+        const projectInputProgramChange = next.analysisOnly &&
+            mapsEqual(this.reloadFiles, next.reloadFiles) &&
+            mapsEqual(this.outputFiles, next.outputFiles) &&
+            mapsEqual(this.outputs, next.outputs)
+            ? projectInputCompilerMembershipChange(this.projectInputs, this.files, next.files)
+            : undefined;
+        const changed = this.analysisOnly !== next.analysisOnly ||
+            mapsEqual(this.files, next.files) === false ||
             mapsEqual(this.directories, next.directories) === false ||
-            mapsEqual(this.outputs, next.outputs) === false;
+            mapsEqual(this.outputFiles, next.outputFiles) === false ||
+            mapsEqual(this.outputs, next.outputs) === false ||
+            mapsEqual(this.reloadFiles, next.reloadFiles) === false;
+        this.analysisOnly = next.analysisOnly;
         this.files = next.files;
+        // Stamp the tracked set as it is resolved, so the first event that cannot
+        // name what changed compares against the state the compiler just saw rather
+        // than against nothing, which would make it nominate everything once.
+        for (const key of [...this.compilerFileStamps.keys()]) {
+            if (!next.files.has(key))
+                this.compilerFileStamps.delete(key);
+        }
+        for (const [key, file] of next.files) {
+            // Only a file with no stamp yet is seeded. Restamping one that already
+            // has a baseline would advance it past a change nobody reported, and the
+            // next unnamed event would then read that change as no change at all.
+            if (!this.compilerFileStamps.has(key)) {
+                this.compilerFileStamps.set(key, compilerFileStamp(file));
+            }
+        }
         this.directories = next.directories;
+        this.outputFiles = next.outputFiles;
         this.outputs = next.outputs;
+        this.reloadFiles = next.reloadFiles;
         this.syncFileWatchers();
         this.syncDirectoryWatchers();
         this.syncExtraWatchers();
+        this.syncProjectInputWatchers();
         if (notify && changed) {
-            this.callbacks.onTopologyChange();
+            if (projectInputProgramChange !== undefined) {
+                this.callbacks.onInputChange({
+                    invalidate: true,
+                    kind: "project",
+                    path: projectInputProgramChange.length === 1
+                        ? projectInputProgramChange[0]
+                        : undefined,
+                });
+            }
+            else {
+                this.callbacks.onTopologyChange();
+            }
         }
     }
     /** Add Go plugin source trees discovered by the real build lane. */
@@ -57,42 +137,168 @@ class WatchTopology {
         this.extraInputs = next;
         this.refresh(false);
     }
+    /**
+     * Reconcile project-rule dependencies, retaining absent files and empty glob
+     * populations as live topology.
+     */
+    setProjectInputs(inputs) {
+        const next = normalizeProjectInputSnapshot(inputs);
+        // The declared spellings are recorded even when the normalized snapshot did
+        // not move, because a republication can carry a new alias for identities
+        // that already matched, and anchoring the spelling that was retired would
+        // leave the live one unwatched.
+        this.declaredProjectInputs =
+            inputs.declared === undefined
+                ? inputs
+                : { ...inputs.declared, root: inputs.root };
+        if (projectInputSnapshotsEqual(this.projectInputs, next)) {
+            this.syncProjectInputWatchers();
+            return;
+        }
+        this.projectInputs = next;
+        this.projectInputRejectedWatchRoots.clear();
+        const declarations = new Set([
+            next,
+            inputs,
+            { ...(inputs.declared ?? inputs), root: inputs.root },
+        ].flatMap((snapshot) => [
+            ...snapshot.files.map((file) => projectInputDeclarationKey("file", file)),
+            ...snapshot.globs.map((glob) => projectInputDeclarationKey("glob", glob)),
+            ...(snapshot.reloadFiles ?? []).map((file) => projectInputDeclarationKey("reload", file)),
+            ...(snapshot.reloadDirectories ?? []).map((directory) => projectInputDeclarationKey("reload-directory", directory)),
+        ]));
+        for (const key of this.projectInputWatchRoots.keys()) {
+            if (!declarations.has(key))
+                this.projectInputWatchRoots.delete(key);
+        }
+        this.projectInputMatches = this.collectProjectInputMatches();
+        this.projectInputFingerprints = fingerprintProjectInputMatches(this.projectInputMatches);
+        this.syncProjectInputWatchers();
+    }
     /** Close every watcher so SIGINT/SIGTERM can drain the event loop. */
     close() {
+        this.closed = true;
         closeWatchers(this.fileWatchers);
         closeWatchers(this.directoryWatchers);
         closeWatchers(this.extraWatchers);
+        closeWatchers(this.projectInputWatchers);
+        closeWatchers(this.projectInputLinkWatchers);
     }
     syncFileWatchers() {
-        syncWatchers(this.fileWatchers, this.files, (location) => node_fs_1.default.watch(location, { persistent: true }, () => {
-            this.callbacks.onInputChange();
+        const files = process.platform === "win32" ? new Map() : this.files;
+        syncWatchers(this.fileWatchers, files, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), { persistent: true }, () => {
+            // A per-file watcher fires on any filesystem attention its target
+            // receives, and it carries no filename to distinguish an edit from
+            // a touch. It answers the same question the unnamed directory event
+            // answers, so it answers it the same way: from the bytes.
+            if (!this.compilerFileMoved(location))
+                return;
+            this.callbacks.onInputChange({
+                kind: this.classifyCompilerInput(location),
+                path: location,
+            });
         }), (location, error) => this.callbacks.onError(location, error));
     }
+    /** Whether a tracked file's bytes differ from the last stamp taken. */
+    compilerFileMoved(location) {
+        const key = pathKey(location);
+        const stamp = compilerFileStamp(location);
+        if (this.compilerFileStamps.get(key) === stamp)
+            return false;
+        this.compilerFileStamps.set(key, stamp);
+        return true;
+    }
     syncDirectoryWatchers() {
         const desired = new Map(this.directories);
         for (const [key, location] of this.observedDirectories) {
             if (isDirectory(location) === false ||
-                this.isCompilerOutputDirectory(location)) {
+                this.isCompilerOutputDirectory(location) ||
+                this.isProjectInputDirectory(location)) {
                 this.observedDirectories.delete(key);
                 continue;
             }
             desired.set(key, location);
         }
-        syncWatchers(this.directoryWatchers, desired, (location) => node_fs_1.default.watch(location, { persistent: true }, (_event, filename) => {
+        if (process.platform === "win32") {
+            for (const [key, location] of desired) {
+                if ([...desired].some(([candidateKey, candidate]) => candidateKey !== key && isPathWithin(candidate, location))) {
+                    desired.delete(key);
+                }
+            }
+        }
+        syncWatchers(this.directoryWatchers, desired, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), {
+            persistent: true,
+            recursive: process.platform === "win32",
+        }, (event, filename) => {
             const changed = filename === null
                 ? undefined
                 : node_path_1.default.resolve(location, filename.toString());
-            // File watchers own ordinary source/config edits. Directory watchers
-            // only reconcile membership, so an emit in an unrelated output folder
-            // cannot schedule another build.
-            if (changed !== undefined &&
-                this.files.has(pathKey(changed)) &&
-                node_fs_1.default.existsSync(changed)) {
+            const pluginInput = changed ?? location;
+            if (this.isPluginInput(pluginInput)) {
+                this.callbacks.onInputChange({
+                    kind: "plugin",
+                    path: pluginInput,
+                });
                 return;
             }
-            this.refreshFromDirectory(location, changed);
+            const plan = planCompilerDirectoryWatchEvent({
+                changed,
+                event,
+                exists: node_fs_1.default.existsSync,
+                location,
+                platform: process.platform,
+                trackedFiles: this.files,
+            });
+            this.rearmFileWatchers(plan.rearm);
+            for (const file of this.compilerChangesToReport(plan.changes, changed, event)) {
+                this.callbacks.onInputChange({
+                    kind: this.classifyCompilerInput(file),
+                    path: file,
+                });
+            }
+            if (plan.refresh)
+                this.refreshFromDirectory(location, changed);
         }), (location, error) => this.callbacks.onError(location, error));
     }
+    /**
+     * Narrow a plan's changes to the tracked files that actually moved.
+     *
+     * A backend that cannot name what changed forces the plan to nominate every
+     * tracked file under the watched directory, which is the only safe answer it
+     * can give from an event carrying no filename. macOS delivers such events for
+     * ordinary activity elsewhere in the project, so the compiler lane would wake
+     * for sources nobody touched. Only a content notification passes through: it
+     * is the one event that claims the bytes moved. A rename claims the directory
+     * entry was rewritten and an unnamed event claims nothing, so both are
+     * decided from the bytes, which is the question neither of them answered.
+     */
+    compilerChangesToReport(changes, changed, event) {
+        // A content notification is taken at its word: the backend is telling us
+        // these bytes changed, and second-guessing it would lose an edit that
+        // landed inside the clock's resolution. A rename says the directory entry
+        // was rewritten, which is a different claim — a file can be moved back, or
+        // replaced by an identical copy, without its content moving at all — and an
+        // event that cannot name anything makes no claim about content either.
+        // Those two are decided from the bytes, and the rearm they drive is
+        // unaffected, because rebinding is about the inode and not the content.
+        if (changed !== undefined && event !== "rename") {
+            for (const file of changes)
+                this.recordCompilerFileStamp(file);
+            return [...changes];
+        }
+        return changes.filter((file) => this.compilerFileMoved(file));
+    }
+    recordCompilerFileStamp(file) {
+        this.compilerFileStamps.set(pathKey(file), compilerFileStamp(file));
+    }
+    rearmFileWatchers(files) {
+        for (const file of files) {
+            const key = pathKey(file);
+            this.fileWatchers.get(key)?.close();
+            this.fileWatchers.delete(key);
+        }
+        this.syncFileWatchers();
+    }
     syncExtraWatchers() {
         const directories = new Map();
         for (const input of this.extraInputs) {
@@ -100,31 +306,453 @@ class WatchTopology {
                 directories.set(pathKey(directory), directory);
             }
         }
-        syncWatchers(this.extraWatchers, directories, (location) => node_fs_1.default.watch(location, { persistent: true }, () => {
-            this.callbacks.onInputChange();
+        syncWatchers(this.extraWatchers, directories, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), { persistent: true }, (_event, filename) => {
+            const changed = filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename.toString());
+            this.callbacks.onInputChange({
+                kind: "plugin",
+                path: changed ?? location,
+            });
+        }), (location, error) => this.callbacks.onError(location, error));
+    }
+    syncProjectInputWatchers() {
+        if (this.closed)
+            return;
+        const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+        const desired = new Map();
+        for (const file of this.projectInputDeclarations("file")) {
+            if (this.isProjectInputCompilerOutput(file, identities))
+                continue;
+            const location = this.projectInputWatchRoot("file", file, node_path_1.default.dirname(file));
+            if (location !== undefined) {
+                this.retainProjectInputWatchRoot(desired, identities, location);
+            }
+        }
+        for (const glob of this.projectInputDeclarations("glob")) {
+            const root = literalGlobRoot(glob);
+            if (this.isProjectInputCompilerOutputDirectory(root, identities)) {
+                continue;
+            }
+            const location = this.projectInputWatchRoot("glob", glob, root);
+            if (location !== undefined) {
+                this.retainProjectInputWatchRoot(desired, identities, location);
+            }
+        }
+        for (const file of this.projectInputDeclarations("reload")) {
+            if (this.isProjectInputCompilerOutput(file, identities))
+                continue;
+            const location = this.projectInputWatchRoot("reload", file, node_path_1.default.dirname(file));
+            if (location !== undefined) {
+                this.retainProjectInputWatchRoot(desired, identities, location);
+            }
+        }
+        for (const directory of this.projectInputDeclarations("reload-directory")) {
+            if (this.isProjectInputCompilerOutputDirectory(directory, identities)) {
+                continue;
+            }
+            const location = this.projectInputWatchRoot("reload-directory", directory, directory);
+            if (location !== undefined) {
+                this.retainProjectInputWatchRoot(desired, identities, location);
+            }
+        }
+        const active = new Map();
+        for (const location of projectInputActiveWatchDirectories(desired.values(), identities)) {
+            const identity = identities.resolve(location);
+            active.set(identity.key, identity.path);
+        }
+        syncWatchers(this.projectInputWatchers, active, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), { persistent: true, recursive: true }, (_event, filename) => {
+            const changed = filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename.toString());
+            this.refreshProjectInputs(location, changed);
+        }), (location, error) => {
+            const key = identities.resolve(location).key;
+            const firstFailure = !this.projectInputRejectedWatchRoots.has(key);
+            this.projectInputRejectedWatchRoots.add(key);
+            this.callbacks.onError(location, error);
+            if (firstFailure) {
+                queueMicrotask(() => this.syncProjectInputWatchers());
+            }
+        });
+        this.syncProjectInputLinkWatchers(identities);
+        this.callbacks.onProjectInputWatchRoots?.([...this.projectInputWatchers.keys()].sort());
+    }
+    /**
+     * Watch the directory that holds a declaration which is itself a link.
+     *
+     * A recursive watcher cannot report the link being replaced. The backend that
+     * keys its handles by path skips an entry it already knows, and the handle it
+     * put on the entry followed the link to the target's inode, which unlinking
+     * and recreating the link never touches. A plain directory watch has neither
+     * property: it reports the entry by name the moment it moves. These are kept
+     * apart from the recursive roots because they are not roots — they observe
+     * one directory, they are never reported as watch roots, and an ancestor
+     * covering them does not make them redundant.
+     */
+    syncProjectInputLinkWatchers(identities) {
+        const desired = new Map();
+        for (const kind of ["file", "reload"]) {
+            for (const declaration of this.projectInputDeclarations(kind)) {
+                const declared = node_path_1.default.resolve(declaration);
+                // The test is whether the declaration is itself a link, not whether its
+                // spelling is canonical. Comparing against the resolved identity would
+                // admit every declaration whose ancestor is aliased — which on macOS is
+                // every declaration under the system temporary directory — and it would
+                // still miss the retarget, because the watcher goes below the link.
+                if (!isSymbolicLink(declared))
+                    continue;
+                if (this.isProjectInputCompilerOutput(declared, identities))
+                    continue;
+                const parent = nearestExistingDirectory(node_path_1.default.dirname(declared));
+                if (parent === undefined)
+                    continue;
+                desired.set(identities.resolve(parent).key, parent);
+            }
+        }
+        syncWatchers(this.projectInputLinkWatchers, desired, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), { persistent: true }, (_event, filename) => {
+            const changed = filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename.toString());
+            this.refreshProjectInputs(location, changed);
         }), (location, error) => this.callbacks.onError(location, error));
     }
+    /** Drop the watcher that just reported a directory replacement. */
+    retireProjectInputWatcher(location, identities) {
+        const key = identities.resolve(location).key;
+        // A plain directory watcher binds an inode, so a replacement strands it
+        // exactly as it strands a recursive root. Both maps are keyed the same way,
+        // so both are retired together and the next sync reinstalls whichever the
+        // declarations still call for.
+        for (const watchers of [
+            this.projectInputWatchers,
+            this.projectInputLinkWatchers,
+        ]) {
+            const watcher = watchers.get(key);
+            if (watcher === undefined)
+                continue;
+            watcher.close();
+            watchers.delete(key);
+        }
+    }
+    retainProjectInputWatchRoot(desired, identities, location) {
+        const available = projectInputAvailableWatchDirectory(location, this.projectInputRejectedWatchRoots, identities, this.projectInputs.root);
+        if (available === undefined)
+            return;
+        const identity = identities.resolve(available);
+        desired.set(identity.key, identity.path);
+    }
+    /**
+     * One snapshot holding every spelling of every declaration.
+     *
+     * Consumers that decide from a population rather than from a single path have
+     * to see both, or half of them answer from the file a link pointed at when
+     * the snapshot was published while the event they are judging resolved to the
+     * file it points at now.
+     */
+    projectInputPopulation() {
+        return {
+            files: this.projectInputDeclarations("file"),
+            globs: this.projectInputDeclarations("glob"),
+            reloadDirectories: this.projectInputDeclarations("reload-directory"),
+            reloadFiles: this.projectInputDeclarations("reload"),
+            root: this.projectInputs.root,
+        };
+    }
+    /**
+     * Every spelling of one declaration that has to be anchored separately.
+     *
+     * The retained snapshot is normalized to physical identities, which is what
+     * every comparison needs but not what every watcher needs: a declaration
+     * reached through a symlink resolves to its target's directory, so anchoring
+     * the normalized form alone watches the bytes and never the link. Retargeting
+     * or replacing the link then goes unobserved, even though it is exactly what
+     * decides which bytes the declaration names next. Both spellings are planned
+     * through the same root selection, so the project-root hoist and the
+     * nearest-existing-ancestor boundary still bound each of them, and the active
+     * set drops one again whenever they coincide or share an ancestor.
+     */
+    projectInputDeclarations(kind) {
+        const select = (snapshot) => kind === "file"
+            ? snapshot.files
+            : kind === "glob"
+                ? snapshot.globs
+                : kind === "reload"
+                    ? (snapshot.reloadFiles ?? [])
+                    : (snapshot.reloadDirectories ?? []);
+        const seen = new Set();
+        const declarations = [];
+        for (const entry of [
+            ...select(this.projectInputs),
+            ...select(this.declaredProjectInputs),
+        ]) {
+            const key = (0, projectInputPathIdentity_1.resolveProjectInputPath)(entry);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            declarations.push(entry);
+        }
+        return declarations;
+    }
+    projectInputWatchRoot(kind, declaration, target) {
+        const key = projectInputDeclarationKey(kind, declaration);
+        const retained = this.projectInputWatchRoots.get(key);
+        if (retained !== undefined && isDirectory(retained))
+            return retained;
+        const resolved = projectInputRecursiveWatchRoot(target, this.projectInputs.root);
+        if (resolved !== undefined)
+            this.projectInputWatchRoots.set(key, resolved);
+        return resolved;
+    }
+    refreshProjectInputs(location, changed) {
+        try {
+            const previous = this.projectInputMatches;
+            const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+            // One population for the whole decision. Every question below is asked of
+            // the same declarations, and rebuilding it per question would both cost
+            // more and let two answers disagree about what was declared.
+            const population = this.projectInputPopulation();
+            const directlyMatched = changed !== undefined &&
+                (previous.has(identities.resolve(changed).key) ||
+                    matchesProjectInput(population, changed, identities));
+            const topologyMatched = changed !== undefined &&
+                projectInputTopologyMayAffect(population, changed, previous, identities);
+            if (changed !== undefined &&
+                (this.isProjectInputCompilerOutput(changed, identities) ||
+                    (directlyMatched === false && topologyMatched === false))) {
+                return;
+            }
+            // Rearm before snapshotting. A watcher that has to be replaced stops
+            // delivering the moment it is closed, so a scan taken first would become
+            // the baseline for a window in which nothing was watched, and anything
+            // written there would never be announced again. Reinstalling first makes
+            // the scan below observe whatever the gap swallowed.
+            if (changed !== undefined &&
+                projectInputReplacementStrandsWatchers(population, changed, identities)) {
+                this.retireProjectInputWatcher(location, identities);
+                this.syncProjectInputWatchers();
+            }
+            const next = this.collectProjectInputMatches();
+            const membershipChanged = mapsEqual(previous, next) === false;
+            const nextFingerprints = changed === undefined ||
+                membershipChanged ||
+                directlyMatched ||
+                topologyMatched
+                ? fingerprintProjectInputMatches(next)
+                : this.projectInputFingerprints;
+            const contentChanged = mapsEqual(this.projectInputFingerprints, nextFingerprints) === false;
+            const changedInputs = projectInputChangedPaths({
+                next,
+                nextFingerprints,
+                previous,
+                previousFingerprints: this.projectInputFingerprints,
+            });
+            // Both spellings classify the event. The normalized form names the file a
+            // link pointed at when the snapshot was published, so after a retarget it
+            // names the wrong one; only the declared form resolves to what the link
+            // points at now, which is the selection this lane exists to protect.
+            const reload = projectInputReloadEventShouldNotify({
+                changed,
+                changedInputs,
+                globs: population.globs,
+                reloadDirectories: population.reloadDirectories ?? [],
+                reloadFiles: population.reloadFiles ?? [],
+            });
+            const invalidate = projectInputMembershipInvalidatesProgram({
+                changed,
+                changedInputs,
+                contentChanged,
+                next,
+                previous,
+            });
+            this.projectInputMatches = next;
+            this.projectInputFingerprints = nextFingerprints;
+            this.syncProjectInputWatchers();
+            // A JSON/TS/JS project-input member can simultaneously enter or leave
+            // the compiler Program. Reconcile the compiler watch snapshot before
+            // scheduling its resident invalidation, so runWatch's post-cycle refresh
+            // does not rediscover the same delta as a broader execution reload.
+            if (invalidate)
+                this.refresh(false);
+            if (projectInputEventShouldNotify({
+                contentChanged,
+                directlyMatched,
+                membershipChanged,
+            }) &&
+                (changed === undefined ||
+                    this.isProjectInputCompilerOutput(changed, identities) === false)) {
+                this.callbacks.onInputChange(reload
+                    ? { kind: "config", path: changed }
+                    : {
+                        ...(invalidate ? { invalidate: true } : {}),
+                        kind: "project",
+                        path: changed,
+                    });
+            }
+        }
+        catch (error) {
+            // A rename can invalidate the old filesystem object before the
+            // replacement is readable. Rebind ancestor ownership even when the
+            // population scan races that transient gap, so a later create cannot be
+            // stranded without a watcher.
+            this.syncProjectInputWatchers();
+            this.callbacks.onError(location, error);
+        }
+    }
+    collectProjectInputMatches() {
+        const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+        const matches = new Map();
+        // Both spellings are scanned, and each is resolved here rather than when
+        // the snapshot arrived. A declaration reached through a symlink otherwise
+        // keeps the identity it had when it was published, so retargeting the link
+        // moves no key, changes no fingerprint, and the cycle never learns that the
+        // bytes it depends on are now a different file.
+        for (const file of this.projectInputDeclarations("file")) {
+            if (node_fs_1.default.existsSync(file) &&
+                this.isProjectInputCompilerOutput(file, identities) === false) {
+                const identity = identities.resolve(file);
+                matches.set(identity.key, identity.path);
+            }
+        }
+        for (const file of this.projectInputDeclarations("reload")) {
+            if (node_fs_1.default.existsSync(file) &&
+                this.isProjectInputCompilerOutput(file, identities) === false) {
+                const identity = identities.resolve(file);
+                matches.set(identity.key, identity.path);
+            }
+        }
+        for (const directory of this.projectInputDeclarations("reload-directory")) {
+            if (isDirectory(directory) &&
+                this.isProjectInputCompilerOutputDirectory(directory, identities) ===
+                    false) {
+                const identity = identities.resolve(directory);
+                matches.set(identity.key, identity.path);
+            }
+        }
+        for (const glob of this.projectInputDeclarations("glob")) {
+            const root = literalGlobRoot(glob);
+            if (isDirectory(root) === false ||
+                this.isProjectInputCompilerOutputDirectory(root, identities)) {
+                continue;
+            }
+            const stack = [root];
+            while (stack.length !== 0) {
+                const current = stack.pop();
+                let entries;
+                try {
+                    entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+                }
+                catch (error) {
+                    if (isVanishedFilesystemEntry(error))
+                        continue;
+                    throw error;
+                }
+                for (const entry of entries) {
+                    const location = node_path_1.default.join(current, entry.name);
+                    if (this.isProjectInputCompilerOutput(location, identities)) {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        stack.push(location);
+                    }
+                    else if (entry.isFile() &&
+                        matchesProjectInputGlob(glob, location, identities)) {
+                        const identity = identities.resolve(location);
+                        matches.set(identity.key, identity.path);
+                    }
+                }
+            }
+        }
+        return matches;
+    }
     refreshFromDirectory(location, changed) {
         if (changed !== undefined &&
             isDirectory(changed) &&
-            this.isCompilerOutputDirectory(changed) === false) {
+            this.isCompilerOutputDirectory(changed) === false &&
+            this.isProjectInputDirectory(changed) === false) {
             this.observedDirectories.set(pathKey(changed), changed);
         }
         try {
             this.refresh(true);
         }
         catch (error) {
+            for (const reload of reloadInputsForFailedTopologyRefresh(this.reloadFiles.values(), changed)) {
+                this.callbacks.onInputChange({ kind: "config", path: reload });
+            }
             this.callbacks.onError(location, error);
         }
     }
     isCompilerOutputDirectory(location) {
         return [...this.outputs.values()].some((output) => isPathWithin(output, location));
     }
+    isCompilerOutput(location) {
+        return (this.outputFiles.has(pathKey(location)) ||
+            this.isCompilerOutputDirectory(location));
+    }
+    isProjectInputCompilerOutputDirectory(location, identities) {
+        const root = this.projectInputs.root;
+        return [...this.outputs.values()].some((output) => {
+            // An output directory that is the project itself, or holds it, is not a
+            // place where only build products live -- the sources are there too. A
+            // project emitting in place declares exactly that, and honouring it
+            // literally would classify every declared input as a product and leave
+            // the whole lane unwatched without anything failing to say so. Watching
+            // is the safe side here: a product that gets watched costs an extra
+            // rebuild, while an input that does not is never seen again.
+            if (root !== "" && identities.isWithin(output, root))
+                return false;
+            return identities.isWithin(output, location);
+        });
+    }
+    isProjectInputCompilerOutput(location, identities) {
+        const key = identities.resolve(location).key;
+        return ([...this.outputFiles.values()].some((output) => identities.resolve(output).key === key) || this.isProjectInputCompilerOutputDirectory(location, identities));
+    }
+    isProjectInputDirectory(location) {
+        const resolved = node_path_1.default.resolve(location);
+        const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+        return (this.projectInputs.files.some((file) => identities.isWithin(resolved, file) ||
+            identities.isWithin(node_path_1.default.dirname(file), resolved)) ||
+            (this.projectInputs.reloadFiles ?? []).some((file) => identities.isWithin(resolved, file) ||
+                identities.isWithin(node_path_1.default.dirname(file), resolved)) ||
+            (this.projectInputs.reloadDirectories ?? []).some((directory) => identities.isWithin(resolved, directory) ||
+                identities.isWithin(directory, resolved)) ||
+            this.projectInputs.globs.some((glob) => {
+                const root = literalGlobRoot(glob);
+                return (identities.isWithin(root, resolved) ||
+                    identities.isWithin(resolved, root));
+            }));
+    }
+    classifyCompilerInput(location) {
+        if (this.isPluginInput(location))
+            return "plugin";
+        return this.reloadFiles.has(pathKey(location)) ? "config" : "compiler";
+    }
+    isPluginInput(location) {
+        const resolved = node_path_1.default.resolve(location);
+        return this.extraInputs.some((input) => pathKey(input) === pathKey(resolved) || isPathWithin(input, resolved));
+    }
 }
 exports.WatchTopology = WatchTopology;
+function reloadInputsForFailedTopologyRefresh(reloadFiles, changed) {
+    const changedKey = changed === undefined ? undefined : pathKey(changed);
+    const reloads = new Map();
+    for (const location of reloadFiles) {
+        const resolved = node_path_1.default.resolve(location);
+        const key = pathKey(resolved);
+        if ((changedKey !== undefined && key === changedKey) ||
+            node_fs_1.default.existsSync(resolved) === false) {
+            reloads.set(key, resolved);
+        }
+    }
+    return [...reloads.values()].sort();
+}
 function resolveWatchTopology(options, extraInputs) {
+    let analysisOnly = options.emit === false;
     const files = new Map();
+    const outputFiles = new Map();
     const outputs = new Map();
+    const reloadFiles = new Map();
     const roots = [];
     if (options.files.length !== 0) {
         const project = (0, readProjectConfig_1.readProjectConfig)({
@@ -132,26 +760,59 @@ function resolveWatchTopology(options, extraInputs) {
             projectRoot: options.projectRoot,
             tsconfig: options.tsconfig,
         });
+        analysisOnly = watchTopologyAnalysisOnly(options, project);
         roots.push(project.root);
         addPaths(files, project.configPaths);
-        addPaths(outputs, resolveCompilerOutputs(project, options).directories);
-        addPaths(files, options.files.map((file) => node_path_1.default.resolve(options.cwd, file)));
+        addPaths(reloadFiles, project.configPaths);
+        const positionalInputs = options.files.map((file) => node_path_1.default.resolve(options.cwd, file));
+        if (positionalInputs.length === 1 &&
+            (options.emit ?? project.compilerOptions.noEmit !== true)) {
+            addPaths(outputFiles, [
+                (0, singleFileOutput_1.resolveSingleFileOutput)({
+                    cliOutDir: options.outDir,
+                    cwd: options.cwd,
+                    file: positionalInputs[0],
+                    passthrough: options.passthrough,
+                    tsconfig: options.tsconfig,
+                }),
+            ]);
+        }
+        addPaths(files, positionalInputs);
     }
     else {
-        for (const project of readReferencedProjects(options)) {
+        const projects = readReferencedProjects(options);
+        if (projects[0] !== undefined) {
+            analysisOnly = watchTopologyAnalysisOnly(options, projects[0]);
+        }
+        for (const project of projects) {
             roots.push(project.root);
             addPaths(files, project.configPaths);
-            addPaths(outputs, resolveCompilerOutputs(project, options).directories);
-            addPaths(files, listCompilerInputs(project, options));
+            addPaths(reloadFiles, project.configPaths);
+            const compilerInputs = listCompilerInputs(project, options);
+            const compilerOutputs = resolveCompilerOutputs(project, options);
+            addPaths(outputFiles, compilerOutputs.files);
+            addPaths(outputFiles, inferAdjacentCompilerOutputs(project, options, compilerInputs));
+            addPaths(outputs, compilerOutputs.directories);
+            addPaths(files, compilerInputs);
         }
     }
     addPaths(files, extraInputs);
     return {
+        analysisOnly,
         directories: collectTopologyDirectories(files.values(), roots),
         files,
+        outputFiles,
         outputs,
+        reloadFiles,
     };
 }
+function watchTopologyAnalysisOnly(options, project) {
+    if (options.emit !== undefined)
+        return options.emit === false;
+    const noEmit = passthroughBooleanOption(options.passthrough, "--noEmit") ??
+        project.compilerOptions.noEmit === true;
+    return noEmit;
+}
 function readReferencedProjects(options) {
     const root = (0, readProjectConfig_1.readProjectConfig)({
         cwd: options.cwd,
@@ -228,19 +889,241 @@ function listCompilerInputs(project, options) {
     return inputs;
 }
 function resolveCompilerOutputs(project, options) {
+    const emit = effectiveCompilerEmit(project, options);
+    const directories = new Set();
+    const files = new Set();
+    if (emit.outDir !== undefined &&
+        (emit.javascript || (emit.declaration && emit.declarationDir === undefined))) {
+        directories.add(emit.outDir);
+    }
+    if (emit.declaration && emit.declarationDir !== undefined) {
+        directories.add(emit.declarationDir);
+    }
+    if (emit.outFile !== undefined) {
+        if (emit.javascript) {
+            files.add(emit.outFile);
+            if (emit.sourceMap)
+                files.add(`${emit.outFile}.map`);
+        }
+        if (emit.declaration) {
+            const declaration = replaceOutputExtension(emit.outFile, ".d.ts");
+            files.add(declaration);
+            if (emit.declarationMap)
+                files.add(`${declaration}.map`);
+        }
+    }
+    if (emit.incremental) {
+        files.add(defaultTsBuildInfoFile(project, emit));
+    }
+    return {
+        directories: [...directories],
+        files: [...files],
+    };
+}
+function inferAdjacentCompilerOutputs(project, options, inputs) {
+    const emit = effectiveCompilerEmit(project, options);
+    const outputs = new Set();
+    for (const input of inputs) {
+        const extension = node_path_1.default.extname(input).toLowerCase();
+        if (!isCompilerEmittableSourceExtension(extension)) {
+            continue;
+        }
+        if (/\.d\.(?:ts|mts|cts)$/i.test(input))
+            continue;
+        const stem = input.slice(0, -extension.length);
+        if (emit.javascript &&
+            emit.outDir === undefined &&
+            emit.outFile === undefined &&
+            (!isJavaScriptSourceExtension(extension) ||
+                (extension === ".jsx" && emit.jsx !== "preserve"))) {
+            const javascriptExtension = extension === ".mts"
+                ? ".mjs"
+                : extension === ".cts"
+                    ? ".cjs"
+                    : extension === ".tsx" && emit.jsx === "preserve"
+                        ? ".jsx"
+                        : ".js";
+            const javascript = stem + javascriptExtension;
+            outputs.add(javascript);
+            if (emit.sourceMap)
+                outputs.add(`${javascript}.map`);
+        }
+        if (emit.declaration &&
+            emit.outDir === undefined &&
+            emit.declarationDir === undefined &&
+            emit.outFile === undefined) {
+            const declarationExtension = extension === ".mts" || extension === ".mjs"
+                ? ".d.mts"
+                : extension === ".cts" || extension === ".cjs"
+                    ? ".d.cts"
+                    : ".d.ts";
+            const declaration = stem + declarationExtension;
+            outputs.add(declaration);
+            if (emit.declarationMap)
+                outputs.add(`${declaration}.map`);
+        }
+    }
+    return [...outputs];
+}
+function isCompilerEmittableSourceExtension(extension) {
+    return [
+        ".cjs",
+        ".cts",
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".mts",
+        ".ts",
+        ".tsx",
+    ].includes(extension);
+}
+function isJavaScriptSourceExtension(extension) {
+    return [".cjs", ".js", ".jsx", ".mjs"].includes(extension);
+}
+function effectiveCompilerEmit(project, options) {
     const compilerOptions = project.compilerOptions;
-    const outDir = options.outDir
-        ? node_path_1.default.resolve(options.cwd, options.outDir)
-        : compilerOptions.outDir;
+    const passthrough = options.passthrough;
+    const noEmit = passthroughBooleanOption(passthrough, "--noEmit") ??
+        (options.emit === false
+            ? true
+            : options.emit === true
+                ? false
+                : compilerOptions.noEmit === true);
+    const composite = passthroughBooleanOption(passthrough, "--composite") ??
+        compilerOptions.composite === true;
+    const incremental = composite ||
+        (passthroughBooleanOption(passthrough, "--incremental") ??
+            compilerOptions.incremental === true);
+    const emitDeclarationOnly = passthroughBooleanOption(passthrough, "--emitDeclarationOnly") ??
+        (options.emit === true
+            ? false
+            : compilerOptions.emitDeclarationOnly === true);
+    const declaration = !noEmit &&
+        (composite ||
+            (passthroughBooleanOption(passthrough, "--declaration") ??
+                compilerOptions.declaration === true));
+    const javascript = !noEmit && !emitDeclarationOnly;
+    const sourceMap = javascript &&
+        (passthroughBooleanOption(passthrough, "--sourceMap") ??
+            compilerOptions.sourceMap === true) &&
+        !(passthroughBooleanOption(passthrough, "--inlineSourceMap") ??
+            compilerOptions.inlineSourceMap === true);
+    const declarationMap = declaration &&
+        (passthroughBooleanOption(passthrough, "--declarationMap") ??
+            compilerOptions.declarationMap === true);
+    const cliOutDir = passthroughPathOption(passthrough, "--outDir");
+    const cliDeclarationDir = passthroughPathOption(passthrough, "--declarationDir");
+    const cliOutFile = passthroughPathOption(passthrough, "--outFile");
+    const cliRootDir = passthroughPathOption(passthrough, "--rootDir");
+    const cliTsBuildInfoFile = passthroughPathOption(passthrough, "--tsBuildInfoFile");
+    const jsx = passthroughStringOption(passthrough, "--jsx") ?? compilerOptions.jsx;
     return {
-        directories: [outDir, compilerOptions.declarationDir]
-            .filter((value) => typeof value === "string")
-            .map((value) => node_path_1.default.resolve(value)),
-        files: [compilerOptions.outFile, compilerOptions.tsBuildInfoFile]
-            .filter((value) => typeof value === "string")
-            .map((value) => node_path_1.default.resolve(project.root, value)),
+        declaration,
+        declarationDir: cliDeclarationDir === null
+            ? undefined
+            : cliDeclarationDir !== undefined
+                ? node_path_1.default.resolve(options.cwd, cliDeclarationDir)
+                : typeof compilerOptions.declarationDir === "string"
+                    ? node_path_1.default.resolve(compilerOptions.declarationDir)
+                    : undefined,
+        declarationMap,
+        incremental,
+        javascript,
+        outDir: cliOutDir === null
+            ? undefined
+            : cliOutDir !== undefined
+                ? node_path_1.default.resolve(options.cwd, cliOutDir)
+                : options.outDir !== undefined
+                    ? node_path_1.default.resolve(options.cwd, options.outDir)
+                    : typeof compilerOptions.outDir === "string"
+                        ? node_path_1.default.resolve(compilerOptions.outDir)
+                        : undefined,
+        outFile: cliOutFile === null
+            ? undefined
+            : cliOutFile !== undefined
+                ? node_path_1.default.resolve(options.cwd, cliOutFile)
+                : typeof compilerOptions.outFile === "string"
+                    ? node_path_1.default.resolve(compilerOptions.outFile)
+                    : undefined,
+        rootDir: cliRootDir === null
+            ? undefined
+            : cliRootDir !== undefined
+                ? node_path_1.default.resolve(options.cwd, cliRootDir)
+                : typeof compilerOptions.rootDir === "string"
+                    ? node_path_1.default.resolve(compilerOptions.rootDir)
+                    : undefined,
+        sourceMap,
+        tsBuildInfoFile: cliTsBuildInfoFile === null
+            ? undefined
+            : cliTsBuildInfoFile !== undefined
+                ? node_path_1.default.resolve(options.cwd, cliTsBuildInfoFile)
+                : typeof compilerOptions.tsBuildInfoFile === "string"
+                    ? node_path_1.default.resolve(compilerOptions.tsBuildInfoFile)
+                    : undefined,
+        jsx,
     };
 }
+function defaultTsBuildInfoFile(project, emit) {
+    if (emit.tsBuildInfoFile !== undefined)
+        return emit.tsBuildInfoFile;
+    const configWithoutExtension = replaceOutputExtension(project.path, "");
+    if (emit.outDir === undefined)
+        return `${configWithoutExtension}.tsbuildinfo`;
+    const relative = emit.rootDir === undefined
+        ? node_path_1.default.basename(configWithoutExtension)
+        : node_path_1.default.relative(emit.rootDir, configWithoutExtension);
+    return node_path_1.default.resolve(emit.outDir, `${relative}.tsbuildinfo`);
+}
+function replaceOutputExtension(location, extension) {
+    const current = node_path_1.default.extname(location);
+    return current === ""
+        ? `${location}${extension}`
+        : `${location.slice(0, -current.length)}${extension}`;
+}
+function passthroughBooleanOption(tokens, name) {
+    let value;
+    for (let index = 0; index < (tokens?.length ?? 0); index++) {
+        const token = tokens?.[index];
+        if (token === undefined)
+            continue;
+        if (!passthroughOptionMatches(token, name))
+            continue;
+        const next = tokens?.[index + 1];
+        if (next === "true" || next === "false" || next === "null") {
+            value = next === "true";
+            index++;
+        }
+        else {
+            value = true;
+        }
+    }
+    return value;
+}
+function passthroughPathOption(tokens, name) {
+    let value;
+    for (let index = 0; index < (tokens?.length ?? 0); index++) {
+        const token = tokens?.[index];
+        if (token === undefined)
+            continue;
+        if (!passthroughOptionMatches(token, name))
+            continue;
+        if (index + 1 < (tokens?.length ?? 0)) {
+            const next = tokens?.[++index];
+            value = next === "null" ? null : next;
+        }
+    }
+    return value;
+}
+function passthroughStringOption(tokens, name) {
+    return passthroughPathOption(tokens, name)?.toLowerCase() ?? undefined;
+}
+function passthroughOptionMatches(token, name) {
+    if (!token.startsWith("-"))
+        return false;
+    if (token.includes("="))
+        return false;
+    return (0, schema_1.resolveFlagSpec)(token)?.name === (0, schema_1.resolveFlagSpec)(name)?.name;
+}
 function isCompilerOutput(file, outputs) {
     return (outputs.files.some((output) => pathKey(output) === pathKey(file)) ||
         outputs.directories.some((directory) => isPathWithin(directory, file)));
@@ -278,7 +1161,16 @@ function collectInputDirectories(input) {
     while (stack.length !== 0) {
         const current = stack.pop();
         directories.push(current);
-        for (const entry of node_fs_1.default.readdirSync(current, { withFileTypes: true })) {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isVanishedFilesystemEntry(error))
+                continue;
+            throw error;
+        }
+        for (const entry of entries) {
             if (entry.isDirectory()) {
                 stack.push(node_path_1.default.join(current, entry.name));
             }
@@ -286,6 +1178,11 @@ function collectInputDirectories(input) {
     }
     return directories;
 }
+function isVanishedFilesystemEntry(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
 function isDirectory(location) {
     try {
         return node_fs_1.default.statSync(location).isDirectory();
@@ -295,24 +1192,35 @@ function isDirectory(location) {
     }
 }
 function syncWatchers(watchers, desired, create, onError) {
-    for (const [key, watcher] of watchers) {
-        if (desired.has(key))
-            continue;
-        watcher.close();
-        watchers.delete(key);
-    }
+    let complete = true;
     for (const [key, location] of desired) {
         if (watchers.has(key))
             continue;
         try {
-            const watcher = create(location);
-            watcher.on("error", (error) => onError(location, error));
+            const watcher = create(location, key);
+            watcher.on("error", (error) => {
+                if (watchers.get(key) === watcher) {
+                    watchers.delete(key);
+                }
+                watcher.close();
+                onError(location, error);
+            });
             watchers.set(key, watcher);
         }
         catch (error) {
+            complete = false;
             onError(location, error);
         }
     }
+    if (!complete)
+        return false;
+    for (const [key, watcher] of watchers) {
+        if (desired.has(key))
+            continue;
+        watcher.close();
+        watchers.delete(key);
+    }
+    return true;
 }
 function closeWatchers(watchers) {
     for (const watcher of watchers.values())
@@ -335,6 +1243,553 @@ function uniqueExistingPaths(paths) {
     }
     return [...unique.values()];
 }
+function normalizeProjectInputSnapshot(snapshot) {
+    const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+    const files = new Map();
+    const globs = new Map();
+    const reloadDirectories = new Map();
+    const reloadFiles = new Map();
+    for (const file of snapshot.files) {
+        const identity = identities.resolve(file);
+        files.set(identity.key, identity.path);
+    }
+    for (const glob of snapshot.globs) {
+        const identity = identities.resolve(glob);
+        globs.set(identity.key, identity.path.split(node_path_1.default.sep).join("/"));
+    }
+    for (const file of snapshot.reloadFiles ?? []) {
+        const identity = identities.resolve(file);
+        reloadFiles.set(identity.key, identity.path);
+    }
+    for (const directory of snapshot.reloadDirectories ?? []) {
+        const identity = identities.resolve(directory);
+        reloadDirectories.set(identity.key, identity.path);
+    }
+    return {
+        files: [...files.values()].sort(),
+        globs: [...globs.values()].sort(),
+        reloadDirectories: [...reloadDirectories.values()].sort(),
+        reloadFiles: [...reloadFiles.values()].sort(),
+        root: identities.resolve(snapshot.root).path,
+    };
+}
+function projectInputSnapshotsEqual(left, right) {
+    const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+    return (
+    // Every sibling comparison in this class decides on identity, and this one
+    // is only safe today because both operands come from the same normalizer.
+    identities.resolve(left.root || ".").key ===
+        identities.resolve(right.root || ".").key &&
+        arraysEqual(left.files, right.files) &&
+        arraysEqual(left.globs, right.globs) &&
+        arraysEqual(left.reloadDirectories ?? [], right.reloadDirectories ?? []) &&
+        arraysEqual(left.reloadFiles ?? [], right.reloadFiles ?? []));
+}
+function literalGlobRoot(pattern) {
+    const resolved = node_path_1.default.resolve(pattern);
+    const normalized = resolved.split("\\").join("/");
+    const wildcard = normalized.search(/[*?]/);
+    if (wildcard === -1)
+        return node_path_1.default.dirname(resolved);
+    const separator = normalized.lastIndexOf("/", wildcard);
+    const prefix = separator < 0 ? "." : normalized.slice(0, separator);
+    const volumeRoot = node_path_1.default.parse(resolved).root;
+    const normalizedVolumeRoot = volumeRoot.split("\\").join("/");
+    if (prefix.length === 0 ||
+        prefix === normalizedVolumeRoot.replace(/\/$/, "")) {
+        return volumeRoot;
+    }
+    return node_path_1.default.resolve(prefix);
+}
+function projectInputDeclarationKey(kind, declaration) {
+    return `${kind}\0${(0, projectInputPathIdentity_1.resolveProjectInputPath)(declaration)}`;
+}
+/**
+ * Chooses the one stable recursive watcher root owned by a project-input
+ * declaration.
+ *
+ * Inputs inside the project share its physical root so directory replacement
+ * cannot strand a child handle. External inputs use the nearest existing
+ * ancestor of their declared parent, which is the explicit boundary for
+ * observing a currently missing external tree without polling every file --
+ * except that the boundary never rises to a directory holding the project,
+ * since such a root outranks the project's own in the active merge and leaves
+ * one handle over a shared system directory to carry everything. An external
+ * declaration that can only be owned that way falls back to its own tree, and
+ * is left unwatched when even that would contain the project.
+ */
+function projectInputWatchDirectories(target, projectRoot) {
+    const root = projectInputRecursiveWatchRoot(target, projectRoot);
+    return root === undefined ? [] : [root];
+}
+/**
+ * Removes recursive roots already covered by an ancestor without rewriting the
+ * declaration-specific roots retained by WatchTopology.
+ */
+function projectInputActiveWatchDirectories(directories, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const unique = new Map();
+    for (const directory of directories) {
+        // Coverage is decided on physical identity so two spellings of one
+        // directory cannot both survive, but the surviving entry keeps the
+        // caller's spelling: this function selects roots, it does not rename them.
+        const identity = identities.resolve(directory);
+        if (!unique.has(identity.key))
+            unique.set(identity.key, directory);
+    }
+    return [...unique]
+        .filter(([key]) => {
+        let ancestor = node_path_1.default.dirname(key);
+        while (ancestor !== key) {
+            if (unique.has(ancestor))
+                return false;
+            const parent = node_path_1.default.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        return true;
+    })
+        .map(([, directory]) => directory);
+}
+function projectInputAvailableWatchDirectory(location, rejected, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)(), projectRoot) {
+    const resolvedProjectRoot = projectRoot === undefined ? undefined : node_path_1.default.resolve(projectRoot);
+    let current = node_path_1.default.resolve(location);
+    while (true) {
+        const identity = identities.resolve(current);
+        // Escalation obeys the same ceiling root selection does. A watcher that
+        // failed once would otherwise be replaced by one over a directory holding
+        // the project, which outranks the project's own root in the active merge
+        // and re-opens, through the recovery path, the exact swallow that selection
+        // refuses to create. Giving up the failed root is the lesser loss.
+        if (resolvedProjectRoot !== undefined &&
+            identity.key !== identities.resolve(resolvedProjectRoot).key &&
+            identities.isWithin(identity.path, resolvedProjectRoot)) {
+            return undefined;
+        }
+        if (!rejected.has(identity.key))
+            return identity.path;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return undefined;
+        const fallback = nearestExistingDirectory(parent);
+        if (fallback === undefined)
+            return undefined;
+        current = fallback;
+    }
+}
+function projectInputRecursiveWatchRoot(target, projectRoot, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const resolvedTarget = node_path_1.default.resolve(target);
+    const resolvedProjectRoot = node_path_1.default.resolve(projectRoot);
+    if (identities.isWithin(resolvedProjectRoot, resolvedTarget)) {
+        return nearestExistingDirectory(resolvedProjectRoot);
+    }
+    // An external anchor rises to the declared parent so a tree that does not
+    // exist yet is still observed, and so siblings under it share one handle. It
+    // may not rise past the project, though: a directory that contains the
+    // project swallows the project's own root when the two are merged, and every
+    // in-project declaration then rides one recursive handle over a shared system
+    // directory — a temp root, or the filesystem root itself — which delivers
+    // nothing. Prefer the declared parent, fall back to the target's own tree,
+    // and decline rather than widen past the project.
+    for (const candidate of [
+        nearestExistingDirectory(node_path_1.default.dirname(resolvedTarget)),
+        nearestExistingDirectory(resolvedTarget),
+    ]) {
+        if (candidate === undefined)
+            continue;
+        // The project root cannot outrank itself in the merge, so it is the one
+        // container that is never a swallow — it is the owner the internal branch
+        // would have chosen anyway. A declaration reached through an in-project
+        // directory symlink lands here, and rejecting it would drop the hoist that
+        // keeps a replaced directory from stranding a child handle.
+        if (identities.resolve(candidate).key !==
+            identities.resolve(resolvedProjectRoot).key &&
+            identities.isWithin(candidate, resolvedProjectRoot)) {
+            continue;
+        }
+        return candidate;
+    }
+    return undefined;
+}
+/**
+ * A cheap identity for a tracked file's current bytes.
+ *
+ * Modification time and size together answer "did this move" without reading
+ * the file, which is all the unnamed-event path needs; a file that vanished
+ * answers as absent rather than as unchanged.
+ */
+function compilerFileStamp(location) {
+    try {
+        const stats = node_fs_1.default.statSync(location);
+        return `${stats.mtimeMs}:${stats.size}`;
+    }
+    catch {
+        return "";
+    }
+}
+function isSymbolicLink(location) {
+    try {
+        return node_fs_1.default.lstatSync(location).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function nearestExistingDirectory(location) {
+    let current = node_path_1.default.resolve(location);
+    while (true) {
+        if (isDirectory(current))
+            return current;
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function matchesProjectInput(snapshot, location, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const key = identities.resolve(location).key;
+    return (snapshot.files.some((file) => identities.resolve(file).key === key) ||
+        (snapshot.reloadFiles ?? []).some((file) => identities.resolve(file).key === key) ||
+        (snapshot.reloadDirectories ?? []).some((directory) => identities.isWithin(directory, location)) ||
+        snapshot.globs.some((glob) => matchesProjectInputGlob(glob, location, identities)));
+}
+/**
+ * Whether a replacement at this path leaves a recursive watcher bound to the
+ * object that was replaced.
+ *
+ * Only one backend needs the answer. Node routes a recursive watch to its own
+ * per-directory implementation when the platform is neither macOS nor Windows,
+ * and that implementation keys its handles by path: the handle for a directory
+ * renamed away stays bound to the object that left, and any child whose name
+ * survives the swap is skipped as already known. The native subtree backends
+ * both other platforms use follow the path, so retiring their watcher would buy
+ * nothing and would open a window in which no events are delivered.
+ *
+ * The answer is deliberately narrower than the rescan rule, because
+ * reinstalling a root costs one watch descriptor per entry beneath it, which an
+ * install storm would pay thousands of times. A directory appearing inside a
+ * glob root deserves a rescan but replaces nothing a root stands on, and a
+ * reload directory anchors the directory that contains it rather than itself,
+ * since its fingerprint is a digest of its own immediate entries and nothing
+ * below it can reach the declared corpus.
+ */
+function projectInputReplacementStrandsWatchers(snapshot, location, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)(), platform = process.platform) {
+    if (platform === "darwin" || platform === "win32")
+        return false;
+    const changed = node_path_1.default.resolve(location);
+    if (!isDirectory(changed))
+        return false;
+    return projectInputAnchorsDeclaration(snapshot, node_path_1.default.dirname(changed), identities);
+}
+function projectInputAnchorsDeclaration(snapshot, directory, identities) {
+    return (snapshot.files.some((file) => identities.isWithin(directory, file)) ||
+        (snapshot.reloadFiles ?? []).some((file) => identities.isWithin(directory, file)) ||
+        (snapshot.reloadDirectories ?? []).some((entry) => 
+        // A reload directory anchors the directory that contains it, never
+        // itself. Its own fingerprint is a digest of its immediate entries, so
+        // nothing below it can reach the corpus, and treating it as its own
+        // anchor would rearm for every entry created directly inside it —
+        // including `node_modules`, which contributors publish as one.
+        identities.isWithin(directory, entry) &&
+            identities.resolve(directory).key !== identities.resolve(entry).key) ||
+        snapshot.globs.some((glob) => identities.isWithin(directory, literalGlobRoot(glob))));
+}
+/**
+ * Decide whether an event that named no declared input can still have moved
+ * one.
+ *
+ * The admitted set is the only bound on how often a watch session re-reads and
+ * re-hashes its declared corpus, and both directions cost: too narrow drops an
+ * atomic replacement, too wide re-fingerprints on every entry an install
+ * creates. Exported so that boundary is pinned directly instead of being
+ * inferred from a rebuild that a silent rescan and a skipped rescan produce
+ * identically.
+ */
+function projectInputTopologyMayAffect(snapshot, location, previous, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const changed = node_path_1.default.resolve(location);
+    const anchors = (directory) => projectInputAnchorsDeclaration(snapshot, directory, identities);
+    // An atomic replacement never names the declared file whose bytes it changed;
+    // it names the directory that was swapped, and that directory can be one the
+    // declaration does not contain — renaming `docs` away reports the arriving
+    // `docs-old`, not `docs`. So a directory event is admitted from where it
+    // happened rather than from what it contains: its own parent must already lie
+    // on the path to a declared input. A tree no declaration reaches, such as
+    // `node_modules` under an ordinary project, then costs nothing per created
+    // entry instead of a population rescan and a full content re-fingerprint. A
+    // glob whose literal root covers that tree still admits every directory
+    // beneath it through the branch below, because a directory appearing inside a
+    // glob root can hold matches; the declaration decides that reach, not this
+    // rule.
+    if (isDirectory(changed) && anchors(node_path_1.default.dirname(changed)))
+        return true;
+    return (anchors(changed) ||
+        (snapshot.reloadDirectories ?? []).some((directory) => identities.isWithin(directory, changed)) ||
+        snapshot.globs.some((glob) => {
+            const root = literalGlobRoot(glob);
+            if (identities.isWithin(changed, root))
+                return true;
+            if (identities.isWithin(root, changed) === false)
+                return false;
+            if (isDirectory(changed))
+                return true;
+            return [...previous.values()].some((input) => identities.isWithin(changed, input));
+        }));
+}
+function projectInputEventShouldNotify(input) {
+    return input.contentChanged || input.membershipChanged;
+}
+function projectInputChangedPaths(input) {
+    const changed = new Map();
+    const keys = new Set([
+        ...input.previous.keys(),
+        ...input.next.keys(),
+        ...input.previousFingerprints.keys(),
+        ...input.nextFingerprints.keys(),
+    ]);
+    for (const key of keys) {
+        if (input.previous.has(key) === input.next.has(key) &&
+            input.previousFingerprints.get(key) === input.nextFingerprints.get(key)) {
+            continue;
+        }
+        const location = input.next.get(key) ?? input.previous.get(key);
+        if (location !== undefined)
+            changed.set(key, location);
+    }
+    return [...changed.values()];
+}
+/**
+ * Classify an exact execution-selection input ahead of ordinary project data.
+ *
+ * `changedInputs` carries fingerprint or membership deltas, so a filename-less
+ * event can still select the cold lane. A named exact event selects the cold
+ * lane only after the surrounding change detector admits the event; unchanged
+ * bytes remain quiet before this classifier is observed.
+ */
+function projectInputReloadEventShouldNotify(input) {
+    const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+    const reloadFiles = new Set(input.reloadFiles.map((location) => identities.resolve(location).key));
+    const reloadDirectories = (input.reloadDirectories ?? []).map((location) => identities.resolve(location));
+    // Territory a declared glob is rooted at, judged against the resolution
+    // directory that would otherwise claim it. A project root is published as a
+    // resolution directory because the config lives there, so the directory a
+    // glob is rooted at reads as a new immediate entry the moment it appears --
+    // and appearing is what a declared population does. The data lane already
+    // reports it, with program invalidation when the membership moved, which is
+    // the cold-Program-same-process transition that belongs to data.
+    //
+    // Data can only carve out strictly below a resolution directory. A glob
+    // rooted on that directory, or above it -- `literalGlobRoot` answers with the
+    // volume root for a pattern with no literal prefix -- would otherwise exempt
+    // everything the directory exists to classify, and the selection lane would
+    // retire in silence. Its role predates any glob drawn around it.
+    //
+    // Only glob roots, either way. A declared file sitting directly in a
+    // resolution directory is still a selection surface: its own bytes are what a
+    // project rule reads to decide, once per execution.
+    const globRoots = (input.globs ?? []).map((glob) => identities.resolve(literalGlobRoot(glob)));
+    const exemptedFrom = (directory, location) => globRoots.some((globRoot) => globRoot.key !== directory.key &&
+        identities.isWithin(directory.path, globRoot.path) &&
+        identities.isWithin(globRoot.path, location));
+    // A reload directory is a non-recursive surface: its digest covers its
+    // immediate entries' names, kinds, and link targets, so it moves only when the
+    // directory itself moves or when an entry it holds directly does. Matching the
+    // whole subtree instead makes a resolution ancestor -- the lint config graph
+    // publishes every node_modules level it searched, up to the filesystem root --
+    // read every edit beneath it as a selection change, which restarts the sidecar
+    // on each keystroke and ends warm reuse for any project inside one.
+    const holdsAsImmediateEntry = (location) => {
+        const parent = identities.resolve(node_path_1.default.dirname(location)).key;
+        return reloadDirectories.some((directory) => directory.key === parent && exemptedFrom(directory, location) === false);
+    };
+    const namesDirectory = (location) => {
+        const key = identities.resolve(location).key;
+        return reloadDirectories.some((directory) => directory.key === key);
+    };
+    // A digest delta on the directory itself is the only signal there is when the
+    // entry that appeared is not a declared match, so it cannot simply be dropped
+    // -- but it also cannot say what appeared. The event being classified in the
+    // same pass can: when it names data, the delta it caused is that data's, and
+    // when it names anything else, or nothing at all, the safe reading is that
+    // resolution moved. A missed reselection is a wrong answer; a spare restart is
+    // a slow one.
+    const explains = (directory) => {
+        if (input.changed === undefined)
+            return false;
+        // Only an immediate entry can move this directory's digest, so only an
+        // immediate entry can account for the delta. Asking whether the event was
+        // data somewhere else answers a different directory's question, and one
+        // exemption would then cancel every other directory's evidence.
+        const parent = identities.resolve(node_path_1.default.dirname(input.changed)).key;
+        return parent === directory.key && exemptedFrom(directory, input.changed);
+    };
+    const isReloadDirectoryEvent = (location) => namesDirectory(location) || holdsAsImmediateEntry(location);
+    const isReloadDirectoryDelta = (location) => {
+        if (holdsAsImmediateEntry(location))
+            return true;
+        const key = identities.resolve(location).key;
+        return reloadDirectories.some((directory) => directory.key === key && explains(directory) === false);
+    };
+    return ((input.changed !== undefined &&
+        (reloadFiles.has(identities.resolve(input.changed).key) ||
+            isReloadDirectoryEvent(input.changed))) ||
+        input.changedInputs.some((location) => reloadFiles.has(identities.resolve(location).key) ||
+            isReloadDirectoryDelta(location)));
+}
+/**
+ * Return whether a project-input population transition can reshape a Program.
+ *
+ * JSON is data to a ProjectRule but may simultaneously be a `resolveJsonModule`
+ * source. TypeScript and JavaScript paths can likewise overlap a project-input
+ * declaration. Their creation or deletion therefore requires a cold Program
+ * inside the existing resident process. A filename-less event cannot identify
+ * the changed member and is conservatively invalidating whenever the population
+ * moved.
+ */
+function projectInputMembershipInvalidatesProgram(input) {
+    if (input.contentChanged === true &&
+        (input.changedInputs ??
+            (input.changed === undefined ? [] : [input.changed])).some((location) => node_path_1.default.basename(location).toLowerCase() === "package.json")) {
+        return true;
+    }
+    if (mapsEqual(input.previous, input.next))
+        return false;
+    if (input.changed === undefined)
+        return true;
+    for (const [key, location] of input.previous) {
+        if (input.next.has(key) === false &&
+            projectInputPathMayAffectProgram(location)) {
+            return true;
+        }
+    }
+    for (const [key, location] of input.next) {
+        if (input.previous.has(key) === false &&
+            projectInputPathMayAffectProgram(location)) {
+            return true;
+        }
+    }
+    return false;
+}
+function projectInputPathMayAffectProgram(location) {
+    const extension = node_path_1.default.extname(location).toLowerCase();
+    return extension === ".json" || isCompilerEmittableSourceExtension(extension);
+}
+function projectInputCompilerMembershipChange(snapshot, previous, next) {
+    const changed = new Map();
+    for (const [key, location] of previous) {
+        if (next.has(key) === false)
+            changed.set(key, location);
+    }
+    for (const [key, location] of next) {
+        if (previous.has(key) === false)
+            changed.set(key, location);
+    }
+    if (changed.size === 0 ||
+        [...changed.values()].some((location) => matchesProjectInput(snapshot, location) === false ||
+            projectInputPathMayAffectProgram(location) === false)) {
+        return undefined;
+    }
+    return [...changed.values()].sort();
+}
+function fingerprintProjectInputMatches(matches) {
+    const fingerprints = new Map();
+    for (const [key, location] of matches) {
+        try {
+            fingerprints.set(key, isDirectory(location)
+                ? fingerprintProjectInputDirectory(location)
+                : node_crypto_1.default
+                    .createHash("sha256")
+                    .update(node_fs_1.default.readFileSync(location))
+                    .digest("hex"));
+        }
+        catch {
+            fingerprints.set(key, "");
+        }
+    }
+    return fingerprints;
+}
+function fingerprintProjectInputDirectory(location) {
+    const entries = node_fs_1.default
+        .readdirSync(location, { withFileTypes: true })
+        .map((entry) => {
+        const kind = entry.isDirectory()
+            ? "directory"
+            : entry.isFile()
+                ? "file"
+                : entry.isSymbolicLink()
+                    ? "symlink"
+                    : "other";
+        let target = "";
+        if (entry.isSymbolicLink()) {
+            try {
+                target = node_fs_1.default.readlinkSync(node_path_1.default.join(location, entry.name));
+            }
+            catch {
+                target = "<unreadable>";
+            }
+        }
+        return entry.name + "\0" + kind + "\0" + target;
+    })
+        .sort();
+    return node_crypto_1.default.createHash("sha256").update(entries.join("\0")).digest("hex");
+}
+function matchesProjectInputGlob(pattern, location, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
+    const root = identities.resolve(literalGlobRoot(pattern));
+    const candidate = identities.resolve(location);
+    if (!(0, projectInputPathIdentity_1.isProjectInputPathIdentityWithin)(root.key, candidate.key))
+        return false;
+    const sensitive = identities.caseSensitive(root.path);
+    const patternParts = node_path_1.default
+        .relative(root.path, identities.resolve(pattern).path)
+        .split(node_path_1.default.sep);
+    const candidateParts = node_path_1.default
+        .relative(root.path, candidate.path)
+        .split(node_path_1.default.sep);
+    return matchProjectInputGlobParts(sensitive
+        ? patternParts
+        : patternParts.map((segment) => segment.toLowerCase()), sensitive
+        ? candidateParts
+        : candidateParts.map((segment) => segment.toLowerCase()));
+}
+function matchProjectInputGlobParts(pattern, candidate) {
+    const memo = new Map();
+    const visit = (patternIndex, candidateIndex) => {
+        const key = `${String(patternIndex)}:${String(candidateIndex)}`;
+        const cached = memo.get(key);
+        if (cached !== undefined)
+            return cached;
+        let matched;
+        if (patternIndex === pattern.length) {
+            matched = candidateIndex === candidate.length;
+        }
+        else if (pattern[patternIndex] === "**") {
+            matched =
+                visit(patternIndex + 1, candidateIndex) ||
+                    (candidateIndex !== candidate.length &&
+                        visit(patternIndex, candidateIndex + 1));
+        }
+        else {
+            matched =
+                candidateIndex !== candidate.length &&
+                    matchProjectInputGlobSegment(pattern[patternIndex], candidate[candidateIndex]) &&
+                    visit(patternIndex + 1, candidateIndex + 1);
+        }
+        memo.set(key, matched);
+        return matched;
+    };
+    return visit(0, 0);
+}
+function matchProjectInputGlobSegment(pattern, candidate) {
+    let source = "^";
+    for (const char of pattern) {
+        if (char === "*")
+            source += ".*";
+        else if (char === "?")
+            source += ".";
+        else
+            source += char.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    }
+    return new RegExp(`${source}$`, "u").test(candidate);
+}
 function mapsEqual(left, right) {
     if (left.size !== right.size)
         return false;
@@ -350,11 +1805,75 @@ function isPathWithin(root, candidate) {
             relative.startsWith(`..${node_path_1.default.sep}`) === false &&
             !node_path_1.default.isAbsolute(relative)));
 }
+/**
+ * Plan one compiler-directory event without relying on backend timing.
+ *
+ * POSIX file watchers own ordinary content changes. A named rename re-arms the
+ * replaced file; an unnamed event conservatively re-arms and reports every
+ * surviving tracked input below the watch root. Windows has no per-file
+ * watchers here, so both named and unnamed directory events report inputs.
+ */
+function planCompilerDirectoryWatchEvent(input) {
+    const candidates = input.changed === undefined
+        ? [...input.trackedFiles.values()].filter((file) => input.exists(file) &&
+            isPathWithin(input.location, node_path_1.default.resolve(file)))
+        : input.trackedFiles.has(pathKeyForPlatform(input.changed, input.platform)) && input.exists(input.changed)
+            ? [input.changed]
+            : [];
+    if (input.changed === undefined) {
+        return {
+            changes: candidates,
+            rearm: input.platform === "win32" ? [] : candidates,
+            refresh: true,
+        };
+    }
+    if (candidates.length === 0) {
+        return { changes: [], rearm: [], refresh: true };
+    }
+    if (input.platform === "win32") {
+        return { changes: candidates, rearm: [], refresh: false };
+    }
+    if (input.event === "rename") {
+        return { changes: candidates, rearm: candidates, refresh: false };
+    }
+    return { changes: [], rearm: [], refresh: false };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+/**
+ * Resolve the spelling a filesystem watcher must be registered under.
+ *
+ * A watch declaration keeps its lexical spelling, because classification,
+ * containment, and notification are all expressed in the caller's own paths.
+ * The backend needs the canonical spelling instead. libuv stores the directory
+ * string it was handed, expands each delivered event that still exists on disk
+ * to its long path, and then requires the stored string to be that expansion's
+ * prefix. A short (8.3) component makes the two disagree, and the resulting
+ * assertion aborts the whole process (libuv issue 5010; upstream now returns an
+ * error instead, but the bundled libuv every supported Node ships still
+ * asserts). `os.tmpdir()` routinely yields such a path, so ordinary projects
+ * reach it, not only tests. macOS matches events against the watched path
+ * resolved through symlinks, so `/var` and `/private/var` must not be mixed
+ * either. Resolving here keeps every backend comparing two canonical spellings
+ * while callers keep resolving events against what they declared.
+ */
+function watcherRegistrationPath(location) {
+    try {
+        return node_fs_1.default.realpathSync.native?.(location) ?? node_fs_1.default.realpathSync(location);
+    }
+    catch {
+        // A vanished target makes fs.watch throw anyway, which syncWatchers already
+        // routes to the error path; an unreadable ancestor is better watched under
+        // its declared spelling than not watched at all.
+        return location;
+    }
+}
 function pathKey(location) {
+    return pathKeyForPlatform(location, process.platform);
+}
+function pathKeyForPlatform(location, platform) {
     const resolved = node_path_1.default.resolve(location);
-    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    return platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 //# sourceMappingURL=watchTopology.js.map