ttsc 0.22.0 → 0.24.0

package/lib/launcher/internal/watchTopology.js

@@ -39,11 +39,14 @@ class WatchTopology {
     callbacks;
     analysisOnly = false;
     closed = false;
+    compilerPostRegistrationMembershipRefresh = false;
+    compilerPostRegistrationReconciliationScheduled = false;
+    compilerPostRegistrationSkipUnobservedProjectInputWatchRoots = true;
     directories = new Map();
     directoryWatchers = new Map();
     extraInputs = [];
     extraWatchers = new Map();
-    compilerFileStamps = new Map();
+    compilerFileSnapshots = new Map();
     files = new Map();
     fileWatchers = new Map();
     observedDirectories = new Map();
@@ -65,10 +68,16 @@ class WatchTopology {
         reloadFiles: [],
         root: "",
     };
+    projectInputRecoveryScheduled = false;
+    projectInputPostRegistrationReconciliationScheduled = false;
     projectInputRejectedWatchRoots = new Set();
+    projectInputRequiredWatchRoots = new Map();
+    projectInputUnobservedWatchRoots = new Map();
     projectInputWatchRoots = new Map();
     projectInputWatchers = new Map();
     projectInputLinkWatchers = new Map();
+    projectInputCompilerOutputOverlaps = new WeakMap();
+    projectInputCompilerAcknowledgements = new Map();
     reloadFiles = new Map();
     constructor(options, callbacks) {
         this.options = options;
@@ -76,12 +85,21 @@ class WatchTopology {
     }
     /** Re-resolve compiler inputs and notify only when their membership changed. */
     refresh(notify) {
+        this.refreshCompilerInputs(notify, false);
+    }
+    refreshCompilerInputs(notify, skipUnobservedProjectInputWatchRoots) {
         const next = resolveWatchTopology(this.options, this.extraInputs);
-        const projectInputProgramChange = next.analysisOnly &&
+        const compilerProgramMembershipChange = next.analysisOnly &&
             mapsEqual(this.reloadFiles, next.reloadFiles) &&
             mapsEqual(this.outputFiles, next.outputFiles) &&
             mapsEqual(this.outputs, next.outputs)
-            ? projectInputCompilerMembershipChange(this.projectInputs, this.files, next.files)
+            ? compilerMembershipChange(this.files, next.files)
+            : [];
+        const projectInputProgramOverlap = projectInputCompilerMembershipChange(this.projectInputs, compilerProgramMembershipChange);
+        const projectInputProgramChange = compilerProgramMembershipChange.length !== 0 &&
+            projectInputProgramOverlap.length ===
+                compilerProgramMembershipChange.length
+            ? projectInputProgramOverlap
             : undefined;
         const changed = this.analysisOnly !== next.analysisOnly ||
             mapsEqual(this.files, next.files) === false ||
@@ -94,41 +112,105 @@ class WatchTopology {
         // 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()]) {
+        for (const key of [...this.compilerFileSnapshots.keys()]) {
             if (!next.files.has(key))
-                this.compilerFileStamps.delete(key);
+                this.compilerFileSnapshots.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));
+            if (!this.compilerFileSnapshots.has(key)) {
+                this.compilerFileSnapshots.set(key, compilerFileSnapshot(file));
             }
         }
         this.directories = next.directories;
         this.outputFiles = next.outputFiles;
         this.outputs = next.outputs;
         this.reloadFiles = next.reloadFiles;
-        this.syncFileWatchers();
-        this.syncDirectoryWatchers();
+        for (const key of this.projectInputCompilerAcknowledgements.keys()) {
+            if (!next.files.has(key)) {
+                this.projectInputCompilerAcknowledgements.delete(key);
+            }
+        }
+        const projectInputProgramReload = projectInputProgramOverlap.length === 0
+            ? false
+            : this.acknowledgeProjectInputCompilerMembership(projectInputProgramOverlap);
+        const fileWatcherRegistered = this.syncFileWatchers();
+        const directoryWatcherRegistered = this.syncDirectoryWatchers();
         this.syncExtraWatchers();
-        this.syncProjectInputWatchers();
+        this.syncProjectInputWatchers(skipUnobservedProjectInputWatchRoots);
+        if (fileWatcherRegistered || directoryWatcherRegistered) {
+            this.scheduleCompilerPostRegistrationReconciliation(directoryWatcherRegistered, skipUnobservedProjectInputWatchRoots);
+        }
         if (notify && changed) {
             if (projectInputProgramChange !== undefined) {
-                this.callbacks.onInputChange({
-                    invalidate: true,
-                    kind: "project",
-                    path: projectInputProgramChange.length === 1
-                        ? projectInputProgramChange[0]
-                        : undefined,
-                });
+                const changedPath = projectInputProgramChange.length === 1
+                    ? projectInputProgramChange[0]
+                    : undefined;
+                this.callbacks.onInputChange(projectInputProgramReload
+                    ? { kind: "config", path: changedPath }
+                    : {
+                        invalidate: true,
+                        kind: "project",
+                        path: changedPath,
+                    });
             }
             else {
                 this.callbacks.onTopologyChange();
             }
         }
     }
+    /**
+     * Hand one Program-membership transition from the compiler lane to the
+     * overlapping project-input lane.
+     *
+     * Windows can deliver the compiler membership refresh before the recursive
+     * project watcher names the same creation. The rebuild scheduled here already
+     * consumes the current project bytes, so publishing their strong fingerprints
+     * keeps the later parent event from rediscovering the same population delta.
+     * A newly tracked compiler file also remembers that fingerprint until its
+     * first named content delivery; identical bytes are the delayed creation,
+     * while different bytes are a real later edit and remain observable even
+     * inside filesystem timestamp resolution.
+     */
+    acknowledgeProjectInputCompilerMembership(changed) {
+        const matches = this.collectProjectInputMatches();
+        const fingerprints = fingerprintProjectInputMatches(matches);
+        const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+        const changedInputs = projectInputChangedPaths({
+            next: matches,
+            nextFingerprints: fingerprints,
+            previous: this.projectInputMatches,
+            previousFingerprints: this.projectInputFingerprints,
+        });
+        const population = this.projectInputPopulation();
+        const causedBy = projectInputCompilerMembershipProjectChanges(changed, population.globs);
+        const reload = projectInputReloadEventShouldNotify({
+            causedBy,
+            changed: causedBy.length === 1 ? causedBy[0] : undefined,
+            changedInputs,
+            globs: population.globs,
+            reloadDirectories: population.reloadDirectories,
+            reloadFiles: population.reloadFiles ?? [],
+        });
+        // The callback below consumes the complete population observed by this
+        // scan. Crucially, reload classification runs against the old baseline
+        // first, so a concurrent selection delta becomes one cold transition
+        // instead of disappearing behind the warm compiler-membership handoff.
+        this.projectInputMatches = matches;
+        this.projectInputFingerprints = fingerprints;
+        for (const location of changed) {
+            const compilerKey = pathKey(location);
+            if (!this.files.has(compilerKey))
+                continue;
+            const fingerprint = fingerprints.get(identities.resolve(location).key);
+            if (fingerprint !== undefined && fingerprint !== "") {
+                this.projectInputCompilerAcknowledgements.set(compilerKey, fingerprint);
+            }
+        }
+        return reload;
+    }
     /** Add Go plugin source trees discovered by the real build lane. */
     setExtraInputs(inputs) {
         const next = uniqueExistingPaths(inputs);
@@ -157,20 +239,11 @@ class WatchTopology {
         }
         this.projectInputs = next;
         this.projectInputRejectedWatchRoots.clear();
-        const declarations = new Set([
+        this.pruneProjectInputWatchRoots([
             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();
@@ -184,31 +257,43 @@ class WatchTopology {
         closeWatchers(this.projectInputWatchers);
         closeWatchers(this.projectInputLinkWatchers);
     }
-    syncFileWatchers() {
-        const files = process.platform === "win32" ? new Map() : this.files;
+    syncFileWatchers(skipMissing = false) {
+        const previous = new Map(this.fileWatchers);
+        const files = process.platform === "win32"
+            ? new Map()
+            : skipMissing
+                ? new Map([...this.files].filter(([, location]) => node_fs_1.default.existsSync(location)))
+                : 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))
+            const movement = this.compilerFileMovement(location);
+            if (movement.owner)
+                this.rearmFileWatchers([location], true);
+            if (!movement.content)
                 return;
             this.callbacks.onInputChange({
                 kind: this.classifyCompilerInput(location),
                 path: location,
             });
-        }), (location, error) => this.callbacks.onError(location, error));
+        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
+        return [...this.fileWatchers].some(([key, watcher]) => previous.get(key) !== watcher);
     }
-    /** Whether a tracked file's bytes differ from the last stamp taken. */
-    compilerFileMoved(location) {
+    /** Compare a tracked file's content and physical owner with its snapshot. */
+    compilerFileMovement(location) {
         const key = pathKey(location);
-        const stamp = compilerFileStamp(location);
-        if (this.compilerFileStamps.get(key) === stamp)
-            return false;
-        this.compilerFileStamps.set(key, stamp);
-        return true;
+        const previous = this.compilerFileSnapshots.get(key);
+        const next = compilerFileSnapshot(location);
+        this.compilerFileSnapshots.set(key, next);
+        return {
+            content: previous?.content !== next.content,
+            owner: previous?.owner !== next.owner,
+        };
     }
     syncDirectoryWatchers() {
+        const previous = new Map(this.directoryWatchers);
         const desired = new Map(this.directories);
         for (const [key, location] of this.observedDirectories) {
             if (isDirectory(location) === false ||
@@ -258,7 +343,79 @@ class WatchTopology {
             }
             if (plan.refresh)
                 this.refreshFromDirectory(location, changed);
-        }), (location, error) => this.callbacks.onError(location, error));
+        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
+        return [...this.directoryWatchers].some(([key, watcher]) => previous.get(key) !== watcher);
+    }
+    /**
+     * Reconcile tracked compiler files after a newly registered watcher returns.
+     *
+     * A file or directory watcher can be returned before its backend is ready to
+     * deliver the first event. The compiler-file stamps were captured before
+     * registration, so one coalesced microtask can recover a change in that
+     * handoff window. A real event updates the same stamp first and makes this
+     * bounded scan a no-op.
+     */
+    scheduleCompilerPostRegistrationReconciliation(refreshMembership, skipUnobservedProjectInputWatchRoots) {
+        if (this.closed)
+            return;
+        if (refreshMembership) {
+            this.compilerPostRegistrationMembershipRefresh = true;
+            this.compilerPostRegistrationSkipUnobservedProjectInputWatchRoots =
+                this.compilerPostRegistrationSkipUnobservedProjectInputWatchRoots &&
+                    skipUnobservedProjectInputWatchRoots;
+        }
+        if (this.compilerPostRegistrationReconciliationScheduled)
+            return;
+        this.compilerPostRegistrationReconciliationScheduled = true;
+        queueMicrotask(() => {
+            this.compilerPostRegistrationReconciliationScheduled = false;
+            if (this.closed)
+                return;
+            const refreshCompilerMembership = this.compilerPostRegistrationMembershipRefresh;
+            const skipUnobservedProjectInputWatchRoots = this.compilerPostRegistrationSkipUnobservedProjectInputWatchRoots;
+            this.compilerPostRegistrationMembershipRefresh = false;
+            this.compilerPostRegistrationSkipUnobservedProjectInputWatchRoots = true;
+            const changed = [];
+            const rearm = [];
+            for (const file of this.files.values()) {
+                const movement = this.compilerFileMovement(file);
+                if (movement.content)
+                    changed.push(file);
+                if (movement.owner)
+                    rearm.push(file);
+            }
+            // A replacement can move the path to a new inode without changing its
+            // cheap content stamp or topology key. Rebind its physical owner without
+            // inventing a content notification. Missing entries remain covered by
+            // their parent directory and are retried when recreation is observed.
+            this.rearmFileWatchers(rearm, true);
+            for (const file of changed) {
+                this.callbacks.onInputChange({
+                    kind: this.classifyCompilerInput(file),
+                    path: file,
+                });
+            }
+            if (!refreshCompilerMembership)
+                return;
+            try {
+                // Directory watchers own files not present in the current Program.
+                // Re-resolve even when every tracked stamp is unchanged so a swallowed
+                // startup event cannot strand a newly included source.
+                this.refreshCompilerInputs(true, skipUnobservedProjectInputWatchRoots);
+            }
+            catch (error) {
+                const reported = new Set(changed.map(pathKey));
+                const reconciledChange = changed.length === 1 ? changed[0] : undefined;
+                for (const reload of reloadInputsForFailedTopologyRefresh(this.reloadFiles.values(), reconciledChange)) {
+                    if (reported.has(pathKey(reload)))
+                        continue;
+                    this.callbacks.onInputChange({ kind: "config", path: reload });
+                }
+                this.callbacks.onError(reconciledChange === undefined
+                    ? (this.options.projectRoot ?? this.options.cwd)
+                    : node_path_1.default.dirname(reconciledChange), error);
+            }
+        });
     }
     /**
      * Narrow a plan's changes to the tracked files that actually moved.
@@ -282,22 +439,29 @@ class WatchTopology {
         // 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) => {
+                const key = pathKey(file);
+                const acknowledged = this.projectInputCompilerAcknowledgements.get(key);
+                this.projectInputCompilerAcknowledgements.delete(key);
+                this.recordCompilerFileSnapshot(file);
+                return (acknowledged === undefined ||
+                    acknowledged !== fingerprintProjectInputFile(file));
+            });
         }
-        return changes.filter((file) => this.compilerFileMoved(file));
+        return changes.filter((file) => this.compilerFileMovement(file).content);
     }
-    recordCompilerFileStamp(file) {
-        this.compilerFileStamps.set(pathKey(file), compilerFileStamp(file));
+    recordCompilerFileSnapshot(file) {
+        this.compilerFileSnapshots.set(pathKey(file), compilerFileSnapshot(file));
     }
-    rearmFileWatchers(files) {
+    rearmFileWatchers(files, skipMissing = false) {
         for (const file of files) {
             const key = pathKey(file);
             this.fileWatchers.get(key)?.close();
             this.fileWatchers.delete(key);
         }
-        this.syncFileWatchers();
+        if (this.syncFileWatchers(skipMissing)) {
+            this.scheduleCompilerPostRegistrationReconciliation(false, true);
+        }
     }
     syncExtraWatchers() {
         const directories = new Map();
@@ -314,20 +478,21 @@ class WatchTopology {
                 kind: "plugin",
                 path: changed ?? location,
             });
-        }), (location, error) => this.callbacks.onError(location, error));
+        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
     }
-    syncProjectInputWatchers() {
+    syncProjectInputWatchers(skipUnobservedProjectInputWatchRoots = false) {
         if (this.closed)
             return;
+        const previous = new Map(this.projectInputWatchers);
+        const previousLinks = new Map(this.projectInputLinkWatchers);
         const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
         const desired = new Map();
+        const required = 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);
-            }
+            this.retainProjectInputWatchRoot(required, desired, identities, location, node_path_1.default.dirname(file), skipUnobservedProjectInputWatchRoots);
         }
         for (const glob of this.projectInputDeclarations("glob")) {
             const root = literalGlobRoot(glob);
@@ -335,32 +500,27 @@ class WatchTopology {
                 continue;
             }
             const location = this.projectInputWatchRoot("glob", glob, root);
-            if (location !== undefined) {
-                this.retainProjectInputWatchRoot(desired, identities, location);
-            }
+            this.retainProjectInputWatchRoot(required, desired, identities, location, root, skipUnobservedProjectInputWatchRoots);
         }
         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);
-            }
+            this.retainProjectInputWatchRoot(required, desired, identities, location, node_path_1.default.dirname(file), skipUnobservedProjectInputWatchRoots);
         }
         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);
-            }
+            this.retainProjectInputWatchRoot(required, desired, identities, location, directory, skipUnobservedProjectInputWatchRoots);
         }
         const active = new Map();
         for (const location of projectInputActiveWatchDirectories(desired.values(), identities)) {
             const identity = identities.resolve(location);
             active.set(identity.key, identity.path);
         }
+        this.projectInputRequiredWatchRoots = required;
         syncWatchers(this.projectInputWatchers, active, (location) => node_fs_1.default.watch(watcherRegistrationPath(location), { persistent: true, recursive: true }, (_event, filename) => {
             const changed = filename === null
                 ? undefined
@@ -371,12 +531,24 @@ class WatchTopology {
             const firstFailure = !this.projectInputRejectedWatchRoots.has(key);
             this.projectInputRejectedWatchRoots.add(key);
             this.callbacks.onError(location, error);
-            if (firstFailure) {
-                queueMicrotask(() => this.syncProjectInputWatchers());
+            if (firstFailure && !this.closed) {
+                this.scheduleProjectInputWatcherRecovery();
             }
-        });
+        }, () => this.closed === false);
+        if (this.closed)
+            return;
+        if (!this.projectInputRecoveryScheduled) {
+            this.reportUnobservedProjectInputWatchRoots(required);
+        }
         this.syncProjectInputLinkWatchers(identities);
-        this.callbacks.onProjectInputWatchRoots?.([...this.projectInputWatchers.keys()].sort());
+        const watcherRegistered = [...this.projectInputWatchers].some(([key, watcher]) => previous.get(key) !== watcher) ||
+            [...this.projectInputLinkWatchers].some(([key, watcher]) => previousLinks.get(key) !== watcher);
+        if (watcherRegistered) {
+            this.scheduleProjectInputPostRegistrationReconciliation();
+        }
+        this.callbacks.onProjectInputWatchRoots?.([...this.projectInputWatchers.keys()]
+            .map((key) => active.get(key) ?? identities.resolve(key).path)
+            .sort());
     }
     /**
      * Watch the directory that holds a declaration which is itself a link.
@@ -415,7 +587,7 @@ class WatchTopology {
                 ? undefined
                 : node_path_1.default.resolve(location, filename.toString());
             this.refreshProjectInputs(location, changed);
-        }), (location, error) => this.callbacks.onError(location, error));
+        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
     }
     /** Drop the watcher that just reported a directory replacement. */
     retireProjectInputWatcher(location, identities) {
@@ -435,13 +607,127 @@ class WatchTopology {
             watchers.delete(key);
         }
     }
-    retainProjectInputWatchRoot(desired, identities, location) {
+    retainProjectInputWatchRoot(required, desired, identities, location, target, skipUnobservedProjectInputWatchRoots) {
+        const requiredIdentity = identities.resolve(location ?? target);
+        required.set(requiredIdentity.key, requiredIdentity.path);
+        if (skipUnobservedProjectInputWatchRoots) {
+            const retainedActiveRoot = [...this.projectInputWatchers.keys()].find((root) => (0, projectInputPathIdentity_1.isProjectInputPathIdentityWithin)(root, requiredIdentity.key));
+            if (retainedActiveRoot !== undefined) {
+                desired.set(retainedActiveRoot, retainedActiveRoot);
+                return;
+            }
+        }
+        if (location === undefined ||
+            (skipUnobservedProjectInputWatchRoots &&
+                this.projectInputUnobservedWatchRoots.has(requiredIdentity.key))) {
+            return;
+        }
         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);
     }
+    /**
+     * Retry a failed root on the next reconciliation instead of retiring it for
+     * the session.
+     *
+     * This immediate recovery pass still honors the rejected root so it can
+     * install a safe ancestor where one exists. Only the recovery fixpoint
+     * reports a genuinely uncovered lane; transient gaps between fallback
+     * candidates are not user-visible. The rejection then expires. A later
+     * compiler refresh or an unchanged project-input republication can retry the
+     * original root, while a permanently failing backend costs at most one
+     * attempt per sync.
+     */
+    scheduleProjectInputWatcherRecovery() {
+        if (this.projectInputRecoveryScheduled)
+            return;
+        this.projectInputRecoveryScheduled = true;
+        queueMicrotask(() => {
+            try {
+                let previousRejectionCount = -1;
+                while (this.closed === false &&
+                    previousRejectionCount !== this.projectInputRejectedWatchRoots.size) {
+                    previousRejectionCount = this.projectInputRejectedWatchRoots.size;
+                    this.syncProjectInputWatchers();
+                }
+            }
+            finally {
+                this.projectInputRejectedWatchRoots.clear();
+                this.projectInputRecoveryScheduled = false;
+                if (!this.closed) {
+                    this.reportUnobservedProjectInputWatchRoots(this.projectInputRequiredWatchRoots);
+                }
+            }
+        });
+    }
+    /**
+     * Reconcile the snapshot-to-watcher handoff after the caller's current turn.
+     *
+     * A recursive watcher can return before its backend is ready to deliver the
+     * first event. The publication baseline is necessarily captured before that
+     * watcher exists, so an input materialized synchronously after
+     * `setProjectInputs()` would otherwise depend entirely on that startup event.
+     * The ordinary fingerprint update makes this scan and a real backend event
+     * race safely: whichever arrives first records the new population and the
+     * other becomes a no-op.
+     */
+    scheduleProjectInputPostRegistrationReconciliation() {
+        if (this.closed ||
+            this.projectInputPostRegistrationReconciliationScheduled) {
+            return;
+        }
+        this.projectInputPostRegistrationReconciliationScheduled = true;
+        queueMicrotask(() => {
+            this.projectInputPostRegistrationReconciliationScheduled = false;
+            if (this.closed)
+                return;
+            this.refreshPublishedProjectInputIdentities();
+            this.refreshProjectInputs(this.projectInputs.root, undefined, true);
+        });
+    }
+    /**
+     * Re-resolve declarations after watcher registration.
+     *
+     * A missing path can become a symlink before the handoff scan. The retained
+     * normalized snapshot still names the pre-link spelling in that case, so a
+     * scan can find the first target file without installing the physical owner
+     * that must observe later target changes.
+     */
+    refreshPublishedProjectInputIdentities() {
+        const next = normalizeProjectInputSnapshot(this.declaredProjectInputs);
+        if (projectInputSnapshotsEqual(this.projectInputs, next))
+            return;
+        this.projectInputs = next;
+        this.pruneProjectInputWatchRoots([next, this.declaredProjectInputs]);
+    }
+    /** Drop retained owner choices for declarations no longer published. */
+    pruneProjectInputWatchRoots(snapshots) {
+        const declarations = new Set(snapshots.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);
+        }
+    }
+    /** Report only newly uncovered project-input roots as an observation loss. */
+    reportUnobservedProjectInputWatchRoots(required) {
+        const active = [...this.projectInputWatchers.keys()];
+        const unavailable = new Map([...required].filter(([key]) => active.every((root) => !(0, projectInputPathIdentity_1.isProjectInputPathIdentityWithin)(root, key))));
+        const newlyUnavailable = [...unavailable]
+            .filter(([key]) => !this.projectInputUnobservedWatchRoots.has(key))
+            .map(([, location]) => location)
+            .sort();
+        this.projectInputUnobservedWatchRoots = unavailable;
+        if (newlyUnavailable.length !== 0) {
+            this.callbacks.onProjectInputWatchUnavailable?.(newlyUnavailable);
+        }
+    }
     /**
      * One snapshot holding every spelling of every declaration.
      *
@@ -504,7 +790,7 @@ class WatchTopology {
             this.projectInputWatchRoots.set(key, resolved);
         return resolved;
     }
-    refreshProjectInputs(location, changed) {
+    refreshProjectInputs(location, changed, skipUnobservedProjectInputWatchRoots = false) {
         try {
             const previous = this.projectInputMatches;
             const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
@@ -547,19 +833,20 @@ class WatchTopology {
                 previous,
                 previousFingerprints: this.projectInputFingerprints,
             });
+            const reconciledChange = changed ?? (changedInputs.length === 1 ? changedInputs[0] : undefined);
             // 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,
+                changed: reconciledChange,
                 changedInputs,
                 globs: population.globs,
                 reloadDirectories: population.reloadDirectories ?? [],
                 reloadFiles: population.reloadFiles ?? [],
             });
             const invalidate = projectInputMembershipInvalidatesProgram({
-                changed,
+                changed: reconciledChange,
                 changedInputs,
                 contentChanged,
                 next,
@@ -567,26 +854,28 @@ class WatchTopology {
             });
             this.projectInputMatches = next;
             this.projectInputFingerprints = nextFingerprints;
-            this.syncProjectInputWatchers();
+            this.syncProjectInputWatchers(skipUnobservedProjectInputWatchRoots);
             // 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 (invalidate) {
+                this.refreshCompilerInputs(false, skipUnobservedProjectInputWatchRoots);
+            }
             if (projectInputEventShouldNotify({
                 contentChanged,
                 directlyMatched,
                 membershipChanged,
             }) &&
-                (changed === undefined ||
-                    this.isProjectInputCompilerOutput(changed, identities) === false)) {
+                (reconciledChange === undefined ||
+                    this.isProjectInputCompilerOutput(reconciledChange, identities) ===
+                        false)) {
                 this.callbacks.onInputChange(reload
-                    ? { kind: "config", path: changed }
+                    ? { kind: "config", path: reconciledChange }
                     : {
                         ...(invalidate ? { invalidate: true } : {}),
                         kind: "project",
-                        path: changed,
+                        path: reconciledChange,
                     });
             }
         }
@@ -595,7 +884,7 @@ class WatchTopology {
             // 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.syncProjectInputWatchers(skipUnobservedProjectInputWatchRoots);
             this.callbacks.onError(location, error);
         }
     }
@@ -691,7 +980,14 @@ class WatchTopology {
     }
     isProjectInputCompilerOutputDirectory(location, identities) {
         const root = this.projectInputs.root;
+        let overlaps = this.projectInputCompilerOutputOverlaps.get(identities);
+        if (overlaps === undefined) {
+            overlaps = new Map();
+            this.projectInputCompilerOutputOverlaps.set(identities, overlaps);
+        }
         return [...this.outputs.values()].some((output) => {
+            if (!identities.isWithin(output, location))
+                return false;
             // 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
@@ -701,7 +997,14 @@ class WatchTopology {
             // rebuild, while an input that does not is never seen again.
             if (root !== "" && identities.isWithin(output, root))
                 return false;
-            return identities.isWithin(output, location);
+            let overlapsCompilerInput = overlaps.get(output);
+            if (overlapsCompilerInput === undefined) {
+                overlapsCompilerInput = [...this.files.values()].some((input) => identities.isWithin(output, input));
+                overlaps.set(output, overlapsCompilerInput);
+            }
+            if (overlapsCompilerInput)
+                return false;
+            return true;
         });
     }
     isProjectInputCompilerOutput(location, identities) {
@@ -791,7 +1094,7 @@ function resolveWatchTopology(options, extraInputs) {
             const compilerInputs = listCompilerInputs(project, options);
             const compilerOutputs = resolveCompilerOutputs(project, options);
             addPaths(outputFiles, compilerOutputs.files);
-            addPaths(outputFiles, inferAdjacentCompilerOutputs(project, options, compilerInputs));
+            addPaths(outputFiles, inferPerSourceCompilerOutputs(project, options, compilerInputs));
             addPaths(outputs, compilerOutputs.directories);
             addPaths(files, compilerInputs);
         }
@@ -876,13 +1179,16 @@ function listCompilerInputs(project, options) {
     if (result.error) {
         throw new Error(`ttsc: failed to list compiler inputs: ${result.error.message}`);
     }
-    const outputs = resolveCompilerOutputs(project, options);
+    // `--listFilesOnly` is the authority for compiler inputs. A path may also be
+    // a predicted product of another input, but that collision does not revoke
+    // its Program membership—especially while the compiler is reporting an
+    // overwrite diagnostic. Product inference is used only to classify future
+    // filesystem events, never to subtract from the compiler's answer.
     const inputs = (0, spawnNative_1.outputText)(result.stdout)
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter((line) => node_path_1.default.isAbsolute(line))
-        .map((line) => node_path_1.default.resolve(line))
-        .filter((file) => isCompilerOutput(file, outputs) === false);
+        .map((line) => node_path_1.default.resolve(line));
     if (result.status !== 0 && inputs.length === 0) {
         throw new Error(`ttsc: failed to list compiler inputs:\n${(0, spawnNative_1.outputText)(result.stderr) || (0, spawnNative_1.outputText)(result.stdout)}`);
     }
@@ -899,19 +1205,6 @@ function resolveCompilerOutputs(project, options) {
     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));
     }
@@ -920,47 +1213,72 @@ function resolveCompilerOutputs(project, options) {
         files: [...files],
     };
 }
-function inferAdjacentCompilerOutputs(project, options, inputs) {
+function inferPerSourceCompilerOutputs(project, options, inputs) {
     const emit = effectiveCompilerEmit(project, options);
     const outputs = new Set();
+    // TypeScript-Go 7 requires an explicit rootDir when output layout would
+    // otherwise need inference. While reporting TS5011 it still emits relative
+    // to the config directory, so the watch model must use that same recovery
+    // layout rather than the legacy common-source-directory rule.
+    const sourceRoot = emit.rootDir ?? project.root;
     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);
+        const mappedStem = (directory, adjacentWhenOutside) => {
+            if (directory === undefined)
+                return stem;
+            if (!isPathWithin(sourceRoot, input)) {
+                return adjacentWhenOutside ? stem : undefined;
+            }
+            return node_path_1.default.resolve(directory, node_path_1.default.relative(sourceRoot, stem));
+        };
+        if (extension === ".json") {
+            if (emit.javascript &&
+                emit.resolveJsonModule &&
+                emit.outDir !== undefined) {
+                const jsonStem = mappedStem(emit.outDir, false);
+                if (jsonStem !== undefined)
+                    outputs.add(`${jsonStem}.json`);
+            }
+            continue;
+        }
+        if (!isCompilerEmittableSourceExtension(extension))
+            continue;
         if (emit.javascript &&
-            emit.outDir === undefined &&
-            emit.outFile === undefined &&
-            (!isJavaScriptSourceExtension(extension) ||
+            (emit.outDir !== undefined ||
+                !isJavaScriptSourceExtension(extension) ||
                 (extension === ".jsx" && emit.jsx !== "preserve"))) {
-            const javascriptExtension = extension === ".mts"
+            const javascriptExtension = extension === ".mts" || extension === ".mjs"
                 ? ".mjs"
-                : extension === ".cts"
+                : extension === ".cts" || extension === ".cjs"
                     ? ".cjs"
-                    : extension === ".tsx" && emit.jsx === "preserve"
+                    : (extension === ".tsx" || extension === ".jsx") &&
+                        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 javascriptStem = mappedStem(emit.outDir, true);
+            if (javascriptStem !== undefined) {
+                const javascript = javascriptStem + javascriptExtension;
+                outputs.add(javascript);
+                if (emit.sourceMap)
+                    outputs.add(`${javascript}.map`);
+            }
+        }
+        if (emit.declaration) {
             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`);
+            const declarationStem = mappedStem(emit.declarationDir ?? emit.outDir, true);
+            if (declarationStem !== undefined) {
+                const declaration = declarationStem + declarationExtension;
+                outputs.add(declaration);
+                if (emit.declarationMap)
+                    outputs.add(`${declaration}.map`);
+            }
         }
     }
     return [...outputs];
@@ -1013,16 +1331,16 @@ function effectiveCompilerEmit(project, options) {
             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;
+    const compilerCwd = project.root;
     return {
         declaration,
         declarationDir: cliDeclarationDir === null
             ? undefined
             : cliDeclarationDir !== undefined
-                ? node_path_1.default.resolve(options.cwd, cliDeclarationDir)
+                ? node_path_1.default.resolve(compilerCwd, cliDeclarationDir)
                 : typeof compilerOptions.declarationDir === "string"
                     ? node_path_1.default.resolve(compilerOptions.declarationDir)
                     : undefined,
@@ -1032,23 +1350,18 @@ function effectiveCompilerEmit(project, options) {
         outDir: cliOutDir === null
             ? undefined
             : cliOutDir !== undefined
-                ? node_path_1.default.resolve(options.cwd, cliOutDir)
+                ? node_path_1.default.resolve(compilerCwd, 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,
+        resolveJsonModule: passthroughBooleanOption(passthrough, "--resolveJsonModule") ??
+            compilerOptions.resolveJsonModule === true,
         rootDir: cliRootDir === null
             ? undefined
             : cliRootDir !== undefined
-                ? node_path_1.default.resolve(options.cwd, cliRootDir)
+                ? node_path_1.default.resolve(compilerCwd, cliRootDir)
                 : typeof compilerOptions.rootDir === "string"
                     ? node_path_1.default.resolve(compilerOptions.rootDir)
                     : undefined,
@@ -1056,7 +1369,7 @@ function effectiveCompilerEmit(project, options) {
         tsBuildInfoFile: cliTsBuildInfoFile === null
             ? undefined
             : cliTsBuildInfoFile !== undefined
-                ? node_path_1.default.resolve(options.cwd, cliTsBuildInfoFile)
+                ? node_path_1.default.resolve(compilerCwd, cliTsBuildInfoFile)
                 : typeof compilerOptions.tsBuildInfoFile === "string"
                     ? node_path_1.default.resolve(compilerOptions.tsBuildInfoFile)
                     : undefined,
@@ -1124,10 +1437,6 @@ function passthroughOptionMatches(token, name) {
         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)));
-}
 function collectTopologyDirectories(files, roots) {
     const directories = new Map();
     for (const root of roots) {
@@ -1191,9 +1500,13 @@ function isDirectory(location) {
         return false;
     }
 }
-function syncWatchers(watchers, desired, create, onError) {
+function syncWatchers(watchers, desired, create, onError, shouldContinue = () => true) {
     let complete = true;
     for (const [key, location] of desired) {
+        if (!shouldContinue()) {
+            complete = false;
+            break;
+        }
         if (watchers.has(key))
             continue;
         try {
@@ -1412,19 +1725,23 @@ function projectInputRecursiveWatchRoot(target, projectRoot, identities = (0, pr
     return undefined;
 }
 /**
- * A cheap identity for a tracked file's current bytes.
+ * Cheap content and physical-owner identities for a tracked file.
  *
- * 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.
+ * Modification time and size answer "did the bytes move" without reading the
+ * file. Device and inode answer whether a POSIX per-file watcher still owns the
+ * path. Keeping the answers separate lets an identical atomic replacement
+ * rebind its watcher without inventing a compiler notification.
  */
-function compilerFileStamp(location) {
+function compilerFileSnapshot(location) {
     try {
         const stats = node_fs_1.default.statSync(location);
-        return `${stats.mtimeMs}:${stats.size}`;
+        return {
+            content: `${stats.mtimeMs}:${stats.size}`,
+            owner: `${stats.dev}:${stats.ino}`,
+        };
     }
     catch {
-        return "";
+        return { content: "", owner: "" };
     }
 }
 function isSymbolicLink(location) {
@@ -1613,14 +1930,15 @@ function projectInputReloadEventShouldNotify(input) {
     // 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;
+        const causes = input.causedBy ?? (input.changed === undefined ? [] : [input.changed]);
         // 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);
+        return causes.some((location) => {
+            const parent = identities.resolve(node_path_1.default.dirname(location)).key;
+            return parent === directory.key && exemptedFrom(directory, location);
+        });
     };
     const isReloadDirectoryEvent = (location) => namesDirectory(location) || holdsAsImmediateEntry(location);
     const isReloadDirectoryDelta = (location) => {
@@ -1673,7 +1991,7 @@ function projectInputPathMayAffectProgram(location) {
     const extension = node_path_1.default.extname(location).toLowerCase();
     return extension === ".json" || isCompilerEmittableSourceExtension(extension);
 }
-function projectInputCompilerMembershipChange(snapshot, previous, next) {
+function compilerMembershipChange(previous, next) {
     const changed = new Map();
     for (const [key, location] of previous) {
         if (next.has(key) === false)
@@ -1683,54 +2001,84 @@ function projectInputCompilerMembershipChange(snapshot, previous, 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 projectInputCompilerMembershipChange(snapshot, changed) {
+    return changed.filter((location) => matchesProjectInput(snapshot, location) &&
+        projectInputPathMayAffectProgram(location));
+}
+/**
+ * Name a compiler-membership transition as the recursive project watcher does.
+ *
+ * Creating the first member below a missing glob root makes Windows report the
+ * root directory before it reports the member. Reload-directory fingerprints
+ * must see that same causal path: the new root then explains its ancestor's
+ * immediate-entry delta instead of turning ordinary project data into a cold
+ * selection reload. The deepest matching glob owns the most specific delivery.
+ */
+function projectInputCompilerMembershipProjectChanges(locations, globs) {
+    const identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)();
+    const roots = globs.map((glob) => identities.resolve(literalGlobRoot(glob)));
+    const changes = new Map();
+    for (const location of locations) {
+        const candidate = identities.resolve(location);
+        const root = roots
+            .filter((entry) => identities.isWithin(entry.path, candidate.path))
+            .sort((left, right) => right.path.length - left.path.length)[0];
+        const change = root ?? candidate;
+        changes.set(change.key, change.path);
+    }
+    return [...changes.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, "");
-        }
+        fingerprints.set(key, isDirectory(location)
+            ? fingerprintProjectInputDirectory(location)
+            : fingerprintProjectInputFile(location));
     }
     return fingerprints;
 }
+function fingerprintProjectInputFile(location) {
+    try {
+        return node_crypto_1.default
+            .createHash("sha256")
+            .update(node_fs_1.default.readFileSync(location))
+            .digest("hex");
+    }
+    catch {
+        return "";
+    }
+}
 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>";
+    try {
+        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");
+            return entry.name + "\0" + kind + "\0" + target;
+        })
+            .sort();
+        return node_crypto_1.default.createHash("sha256").update(entries.join("\0")).digest("hex");
+    }
+    catch {
+        return "";
+    }
 }
 function matchesProjectInputGlob(pattern, location, identities = (0, projectInputPathIdentity_1.createProjectInputPathIdentityContext)()) {
     const root = identities.resolve(literalGlobRoot(pattern));