ttsc 0.22.0 → 0.23.0

package/src/launcher/internal/watchTopology.ts

@@ -36,6 +36,7 @@ type WatchTopologyOptions = Pick<
 type WatchTopologyCallbacks = {
   onError(location: string, error: unknown): void;
   onInputChange(change: WatchInputChange): void;
+  onProjectInputWatchUnavailable?(roots: readonly string[]): void;
   onProjectInputWatchRoots?(roots: readonly string[]): void;
   onTopologyChange(): void;
 };
@@ -56,6 +57,16 @@ type ResolvedWatchTopology = {
   reloadFiles: Map<string, string>;
 };
 
+type CompilerFileSnapshot = {
+  content: string;
+  owner: string;
+};
+
+type CompilerFileMovement = {
+  content: boolean;
+  owner: boolean;
+};
+
 export type CompilerDirectoryWatchEventPlan = {
   changes: string[];
   rearm: string[];
@@ -73,11 +84,14 @@ export type CompilerDirectoryWatchEventPlan = {
 export class WatchTopology {
   private analysisOnly = false;
   private closed = false;
+  private compilerPostRegistrationMembershipRefresh = false;
+  private compilerPostRegistrationReconciliationScheduled = false;
+  private compilerPostRegistrationSkipUnobservedProjectInputWatchRoots = true;
   private directories = new Map<string, string>();
   private directoryWatchers = new Map<string, fs.FSWatcher>();
   private extraInputs: readonly string[] = [];
   private extraWatchers = new Map<string, fs.FSWatcher>();
-  private compilerFileStamps = new Map<string, string>();
+  private compilerFileSnapshots = new Map<string, CompilerFileSnapshot>();
   private files = new Map<string, string>();
   private fileWatchers = new Map<string, fs.FSWatcher>();
   private observedDirectories = new Map<string, string>();
@@ -99,10 +113,19 @@ export class WatchTopology {
     reloadFiles: [],
     root: "",
   };
+  private projectInputRecoveryScheduled = false;
+  private projectInputPostRegistrationReconciliationScheduled = false;
   private projectInputRejectedWatchRoots = new Set<string>();
+  private projectInputRequiredWatchRoots = new Map<string, string>();
+  private projectInputUnobservedWatchRoots = new Map<string, string>();
   private projectInputWatchRoots = new Map<string, string>();
   private projectInputWatchers = new Map<string, fs.FSWatcher>();
   private projectInputLinkWatchers = new Map<string, fs.FSWatcher>();
+  private projectInputCompilerOutputOverlaps = new WeakMap<
+    ProjectInputPathIdentityContext,
+    Map<string, boolean>
+  >();
+  private projectInputCompilerAcknowledgements = new Map<string, string>();
   private reloadFiles = new Map<string, string>();
 
   public constructor(
@@ -112,17 +135,30 @@ export class WatchTopology {
 
   /** Re-resolve compiler inputs and notify only when their membership changed. */
   public refresh(notify: boolean): void {
+    this.refreshCompilerInputs(notify, false);
+  }
+
+  private refreshCompilerInputs(
+    notify: boolean,
+    skipUnobservedProjectInputWatchRoots: boolean,
+  ): void {
     const next = resolveWatchTopology(this.options, this.extraInputs);
-    const projectInputProgramChange =
+    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 ||
@@ -136,41 +172,118 @@ export 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()]) {
-      if (!next.files.has(key)) this.compilerFileStamps.delete(key);
+    for (const key of [...this.compilerFileSnapshots.keys()]) {
+      if (!next.files.has(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.
+   */
+  private acknowledgeProjectInputCompilerMembership(
+    changed: readonly string[],
+  ): boolean {
+    const matches = this.collectProjectInputMatches();
+    const fingerprints = fingerprintProjectInputMatches(matches);
+    const identities = 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. */
   public setExtraInputs(inputs: readonly string[]): void {
     const next = uniqueExistingPaths(inputs);
@@ -199,29 +312,11 @@ export class WatchTopology {
     }
     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.pruneProjectInputWatchRoots([
+      next,
+      inputs,
+      { ...(inputs.declared ?? inputs), root: inputs.root },
+    ]);
     this.projectInputMatches = this.collectProjectInputMatches();
     this.projectInputFingerprints = fingerprintProjectInputMatches(
       this.projectInputMatches,
@@ -239,9 +334,16 @@ export class WatchTopology {
     closeWatchers(this.projectInputLinkWatchers);
   }
 
-  private syncFileWatchers(): void {
+  private syncFileWatchers(skipMissing = false): boolean {
+    const previous = new Map(this.fileWatchers);
     const files =
-      process.platform === "win32" ? new Map<string, string>() : this.files;
+      process.platform === "win32"
+        ? new Map<string, string>()
+        : skipMissing
+          ? new Map(
+              [...this.files].filter(([, location]) => fs.existsSync(location)),
+            )
+          : this.files;
     syncWatchers(
       this.fileWatchers,
       files,
@@ -254,7 +356,9 @@ export class WatchTopology {
             // 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;
+            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,
@@ -262,19 +366,27 @@ export class WatchTopology {
           },
         ),
       (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. */
-  private compilerFileMoved(location: string): boolean {
+  /** Compare a tracked file's content and physical owner with its snapshot. */
+  private compilerFileMovement(location: string): CompilerFileMovement {
     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,
+    };
   }
 
-  private syncDirectoryWatchers(): void {
+  private syncDirectoryWatchers(): boolean {
+    const previous = new Map(this.directoryWatchers);
     const desired = new Map(this.directories);
     for (const [key, location] of this.observedDirectories) {
       if (
@@ -345,9 +457,89 @@ export class WatchTopology {
           },
         ),
       (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.
+   */
+  private scheduleCompilerPostRegistrationReconciliation(
+    refreshMembership: boolean,
+    skipUnobservedProjectInputWatchRoots: boolean,
+  ): void {
+    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: string[] = [];
+      const rearm: string[] = [];
+      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)
+            : path.dirname(reconciledChange),
+          error,
+        );
+      }
+    });
+  }
+
   /**
    * Narrow a plan's changes to the tracked files that actually moved.
    *
@@ -374,23 +566,36 @@ export 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);
   }
 
-  private recordCompilerFileStamp(file: string): void {
-    this.compilerFileStamps.set(pathKey(file), compilerFileStamp(file));
+  private recordCompilerFileSnapshot(file: string): void {
+    this.compilerFileSnapshots.set(pathKey(file), compilerFileSnapshot(file));
   }
 
-  private rearmFileWatchers(files: readonly string[]): void {
+  private rearmFileWatchers(
+    files: readonly string[],
+    skipMissing = false,
+  ): void {
     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);
+    }
   }
 
   private syncExtraWatchers(): void {
@@ -419,13 +624,19 @@ export class WatchTopology {
           },
         ),
       (location, error) => this.callbacks.onError(location, error),
+      () => this.closed === false,
     );
   }
 
-  private syncProjectInputWatchers(): void {
+  private syncProjectInputWatchers(
+    skipUnobservedProjectInputWatchRoots = false,
+  ): void {
     if (this.closed) return;
+    const previous = new Map(this.projectInputWatchers);
+    const previousLinks = new Map(this.projectInputLinkWatchers);
     const identities = createProjectInputPathIdentityContext();
     const desired = new Map<string, string>();
+    const required = new Map<string, string>();
     for (const file of this.projectInputDeclarations("file")) {
       if (this.isProjectInputCompilerOutput(file, identities)) continue;
       const location = this.projectInputWatchRoot(
@@ -433,9 +644,14 @@ export class WatchTopology {
         file,
         path.dirname(file),
       );
-      if (location !== undefined) {
-        this.retainProjectInputWatchRoot(desired, identities, location);
-      }
+      this.retainProjectInputWatchRoot(
+        required,
+        desired,
+        identities,
+        location,
+        path.dirname(file),
+        skipUnobservedProjectInputWatchRoots,
+      );
     }
     for (const glob of this.projectInputDeclarations("glob")) {
       const root = literalGlobRoot(glob);
@@ -443,9 +659,14 @@ export 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;
@@ -454,9 +675,14 @@ export class WatchTopology {
         file,
         path.dirname(file),
       );
-      if (location !== undefined) {
-        this.retainProjectInputWatchRoot(desired, identities, location);
-      }
+      this.retainProjectInputWatchRoot(
+        required,
+        desired,
+        identities,
+        location,
+        path.dirname(file),
+        skipUnobservedProjectInputWatchRoots,
+      );
     }
     for (const directory of this.projectInputDeclarations("reload-directory")) {
       if (this.isProjectInputCompilerOutputDirectory(directory, identities)) {
@@ -467,9 +693,14 @@ export class WatchTopology {
         directory,
         directory,
       );
-      if (location !== undefined) {
-        this.retainProjectInputWatchRoot(desired, identities, location);
-      }
+      this.retainProjectInputWatchRoot(
+        required,
+        desired,
+        identities,
+        location,
+        directory,
+        skipUnobservedProjectInputWatchRoots,
+      );
     }
     const active = new Map<string, string>();
     for (const location of projectInputActiveWatchDirectories(
@@ -479,6 +710,7 @@ export class WatchTopology {
       const identity = identities.resolve(location);
       active.set(identity.key, identity.path);
     }
+    this.projectInputRequiredWatchRoots = required;
     syncWatchers(
       this.projectInputWatchers,
       active,
@@ -499,14 +731,31 @@ export 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);
+    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()].sort(),
+      [...this.projectInputWatchers.keys()]
+        .map((key) => active.get(key) ?? identities.resolve(key).path)
+        .sort(),
     );
   }
 
@@ -557,6 +806,7 @@ export class WatchTopology {
           },
         ),
       (location, error) => this.callbacks.onError(location, error),
+      () => this.closed === false,
     );
   }
 
@@ -582,10 +832,31 @@ export class WatchTopology {
   }
 
   private retainProjectInputWatchRoot(
+    required: Map<string, string>,
     desired: Map<string, string>,
     identities: ProjectInputPathIdentityContext,
-    location: string,
+    location: string | undefined,
+    target: string,
+    skipUnobservedProjectInputWatchRoots: boolean,
   ): void {
+    const requiredIdentity = identities.resolve(location ?? target);
+    required.set(requiredIdentity.key, requiredIdentity.path);
+    if (skipUnobservedProjectInputWatchRoots) {
+      const retainedActiveRoot = [...this.projectInputWatchers.keys()].find(
+        (root) => 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,
@@ -597,6 +868,130 @@ export class WatchTopology {
     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.
+   */
+  private scheduleProjectInputWatcherRecovery(): void {
+    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.
+   */
+  private scheduleProjectInputPostRegistrationReconciliation(): void {
+    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.
+   */
+  private refreshPublishedProjectInputIdentities(): void {
+    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. */
+  private pruneProjectInputWatchRoots(
+    snapshots: readonly ITtscProjectInputSnapshot[],
+  ): void {
+    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. */
+  private reportUnobservedProjectInputWatchRoots(
+    required: ReadonlyMap<string, string>,
+  ): void {
+    const active = [...this.projectInputWatchers.keys()];
+    const unavailable = new Map(
+      [...required].filter(([key]) =>
+        active.every((root) => !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.
    *
@@ -669,7 +1064,11 @@ export class WatchTopology {
     return resolved;
   }
 
-  private refreshProjectInputs(location: string, changed?: string): void {
+  private refreshProjectInputs(
+    location: string,
+    changed?: string,
+    skipUnobservedProjectInputWatchRoots = false,
+  ): void {
     try {
       const previous = this.projectInputMatches;
       const identities = createProjectInputPathIdentityContext();
@@ -725,19 +1124,21 @@ export 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,
@@ -745,28 +1146,31 @@ export 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,
               },
         );
       }
@@ -775,7 +1179,7 @@ export 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);
     }
   }
@@ -894,7 +1298,13 @@ export class WatchTopology {
     identities: ProjectInputPathIdentityContext,
   ): boolean {
     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
@@ -903,7 +1313,15 @@ export class WatchTopology {
       // 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);
+      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;
     });
   }
 
@@ -1035,7 +1453,7 @@ function resolveWatchTopology(
       addPaths(outputFiles, compilerOutputs.files);
       addPaths(
         outputFiles,
-        inferAdjacentCompilerOutputs(project, options, compilerInputs),
+        inferPerSourceCompilerOutputs(project, options, compilerInputs),
       );
       addPaths(outputs, compilerOutputs.directories);
       addPaths(files, compilerInputs);
@@ -1144,13 +1562,16 @@ function listCompilerInputs(
       `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 = outputText(result.stdout)
     .split(/\r?\n/)
     .map((line) => line.trim())
     .filter((line) => path.isAbsolute(line))
-    .map((line) => path.resolve(line))
-    .filter((file) => isCompilerOutput(file, outputs) === false);
+    .map((line) => path.resolve(line));
   if (result.status !== 0 && inputs.length === 0) {
     throw new Error(
       `ttsc: failed to list compiler inputs:\n${outputText(result.stderr) || outputText(result.stdout)}`,
@@ -1175,17 +1596,6 @@ function resolveCompilerOutputs(
   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));
   }
@@ -1195,54 +1605,82 @@ function resolveCompilerOutputs(
   };
 }
 
-function inferAdjacentCompilerOutputs(
+function inferPerSourceCompilerOutputs(
   project: ITtscParsedProjectConfig,
   options: WatchTopologyOptions,
   inputs: readonly string[],
 ): string[] {
   const emit = effectiveCompilerEmit(project, options);
   const outputs = new Set<string>();
+  // 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 = path.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: string | undefined,
+      adjacentWhenOutside: boolean,
+    ): string | undefined => {
+      if (directory === undefined) return stem;
+      if (!isPathWithin(sourceRoot, input)) {
+        return adjacentWhenOutside ? stem : undefined;
+      }
+      return path.resolve(directory, path.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"
+        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`);
+      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 &&
-      emit.outDir === undefined &&
-      emit.declarationDir === undefined &&
-      emit.outFile === undefined
-    ) {
+    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];
@@ -1273,7 +1711,7 @@ type EffectiveCompilerEmit = {
   javascript: boolean;
   jsx?: unknown;
   outDir?: string;
-  outFile?: string;
+  resolveJsonModule: boolean;
   rootDir?: string;
   sourceMap: boolean;
   tsBuildInfoFile?: string;
@@ -1327,7 +1765,6 @@ function effectiveCompilerEmit(
     passthrough,
     "--declarationDir",
   );
-  const cliOutFile = passthroughPathOption(passthrough, "--outFile");
   const cliRootDir = passthroughPathOption(passthrough, "--rootDir");
   const cliTsBuildInfoFile = passthroughPathOption(
     passthrough,
@@ -1335,13 +1772,14 @@ function effectiveCompilerEmit(
   );
   const jsx =
     passthroughStringOption(passthrough, "--jsx") ?? compilerOptions.jsx;
+  const compilerCwd = project.root;
   return {
     declaration,
     declarationDir:
       cliDeclarationDir === null
         ? undefined
         : cliDeclarationDir !== undefined
-          ? path.resolve(options.cwd, cliDeclarationDir)
+          ? path.resolve(compilerCwd, cliDeclarationDir)
           : typeof compilerOptions.declarationDir === "string"
             ? path.resolve(compilerOptions.declarationDir)
             : undefined,
@@ -1352,25 +1790,20 @@ function effectiveCompilerEmit(
       cliOutDir === null
         ? undefined
         : cliOutDir !== undefined
-          ? path.resolve(options.cwd, cliOutDir)
+          ? path.resolve(compilerCwd, cliOutDir)
           : options.outDir !== undefined
             ? path.resolve(options.cwd, options.outDir)
             : typeof compilerOptions.outDir === "string"
               ? path.resolve(compilerOptions.outDir)
               : undefined,
-    outFile:
-      cliOutFile === null
-        ? undefined
-        : cliOutFile !== undefined
-          ? path.resolve(options.cwd, cliOutFile)
-          : typeof compilerOptions.outFile === "string"
-            ? path.resolve(compilerOptions.outFile)
-            : undefined,
+    resolveJsonModule:
+      passthroughBooleanOption(passthrough, "--resolveJsonModule") ??
+      compilerOptions.resolveJsonModule === true,
     rootDir:
       cliRootDir === null
         ? undefined
         : cliRootDir !== undefined
-          ? path.resolve(options.cwd, cliRootDir)
+          ? path.resolve(compilerCwd, cliRootDir)
           : typeof compilerOptions.rootDir === "string"
             ? path.resolve(compilerOptions.rootDir)
             : undefined,
@@ -1379,7 +1812,7 @@ function effectiveCompilerEmit(
       cliTsBuildInfoFile === null
         ? undefined
         : cliTsBuildInfoFile !== undefined
-          ? path.resolve(options.cwd, cliTsBuildInfoFile)
+          ? path.resolve(compilerCwd, cliTsBuildInfoFile)
           : typeof compilerOptions.tsBuildInfoFile === "string"
             ? path.resolve(compilerOptions.tsBuildInfoFile)
             : undefined,
@@ -1458,16 +1891,6 @@ function passthroughOptionMatches(token: string, name: string): boolean {
   return resolveFlagSpec(token)?.name === resolveFlagSpec(name)?.name;
 }
 
-function isCompilerOutput(
-  file: string,
-  outputs: { directories: readonly string[]; files: readonly string[] },
-): boolean {
-  return (
-    outputs.files.some((output) => pathKey(output) === pathKey(file)) ||
-    outputs.directories.some((directory) => isPathWithin(directory, file))
-  );
-}
-
 function collectTopologyDirectories(
   files: Iterable<string>,
   roots: readonly string[],
@@ -1544,9 +1967,14 @@ export function syncWatchers<T extends SynchronizedWatcher>(
   desired: ReadonlyMap<string, string>,
   create: (location: string, key: string) => T,
   onError: (location: string, error: unknown) => void,
+  shouldContinue: () => boolean = () => true,
 ): boolean {
   let complete = true;
   for (const [key, location] of desired) {
+    if (!shouldContinue()) {
+      complete = false;
+      break;
+    }
     if (watchers.has(key)) continue;
     try {
       const watcher = create(location, key);
@@ -1794,18 +2222,22 @@ function projectInputRecursiveWatchRoot(
 }
 
 /**
- * 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: string): string {
+function compilerFileSnapshot(location: string): CompilerFileSnapshot {
   try {
     const stats = fs.statSync(location);
-    return `${stats.mtimeMs}:${stats.size}`;
+    return {
+      content: `${stats.mtimeMs}:${stats.size}`,
+      owner: `${stats.dev}:${stats.ino}`,
+    };
   } catch {
-    return "";
+    return { content: "", owner: "" };
   }
 }
 
@@ -2002,6 +2434,7 @@ function projectInputChangedPaths(input: {
  * bytes remain quiet before this classifier is observed.
  */
 export function projectInputReloadEventShouldNotify(input: {
+  causedBy?: readonly string[];
   changed?: string;
   changedInputs: readonly string[];
   reloadDirectories?: readonly string[];
@@ -2071,13 +2504,16 @@ export function projectInputReloadEventShouldNotify(input: {
   // resolution moved. A missed reselection is a wrong answer; a spare restart is
   // a slow one.
   const explains = (directory: ProjectInputPathIdentity): boolean => {
-    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(path.dirname(input.changed)).key;
-    return parent === directory.key && exemptedFrom(directory, input.changed);
+    return causes.some((location) => {
+      const parent = identities.resolve(path.dirname(location)).key;
+      return parent === directory.key && exemptedFrom(directory, location);
+    });
   };
   const isReloadDirectoryEvent = (location: string): boolean =>
     namesDirectory(location) || holdsAsImmediateEntry(location);
@@ -2154,11 +2590,10 @@ function projectInputPathMayAffectProgram(location: string): boolean {
   return extension === ".json" || isCompilerEmittableSourceExtension(extension);
 }
 
-function projectInputCompilerMembershipChange(
-  snapshot: ITtscProjectInputSnapshot,
+function compilerMembershipChange(
   previous: ReadonlyMap<string, string>,
   next: ReadonlyMap<string, string>,
-): string[] | undefined {
+): string[] {
   const changed = new Map<string, string>();
   for (const [key, location] of previous) {
     if (next.has(key) === false) changed.set(key, location);
@@ -2166,64 +2601,100 @@ function projectInputCompilerMembershipChange(
   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 projectInputCompilerMembershipChange(
+  snapshot: ITtscProjectInputSnapshot,
+  changed: readonly string[],
+): string[] {
+  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: readonly string[],
+  globs: readonly string[],
+): string[] {
+  const identities = createProjectInputPathIdentityContext();
+  const roots = globs.map((glob) => identities.resolve(literalGlobRoot(glob)));
+  const changes = new Map<string, string>();
+  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: ReadonlyMap<string, string>,
 ): Map<string, string> {
   const fingerprints = new Map<string, string>();
   for (const [key, location] of matches) {
-    try {
-      fingerprints.set(
-        key,
-        isDirectory(location)
-          ? fingerprintProjectInputDirectory(location)
-          : crypto
-              .createHash("sha256")
-              .update(fs.readFileSync(location))
-              .digest("hex"),
-      );
-    } catch {
-      fingerprints.set(key, "");
-    }
+    fingerprints.set(
+      key,
+      isDirectory(location)
+        ? fingerprintProjectInputDirectory(location)
+        : fingerprintProjectInputFile(location),
+    );
   }
   return fingerprints;
 }
 
+function fingerprintProjectInputFile(location: string): string {
+  try {
+    return crypto
+      .createHash("sha256")
+      .update(fs.readFileSync(location))
+      .digest("hex");
+  } catch {
+    return "";
+  }
+}
+
 function fingerprintProjectInputDirectory(location: string): string {
-  const entries = fs
-    .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 = fs.readlinkSync(path.join(location, entry.name));
-        } catch {
-          target = "<unreadable>";
+  try {
+    const entries = fs
+      .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 = fs.readlinkSync(path.join(location, entry.name));
+          } catch {
+            target = "<unreadable>";
+          }
         }
-      }
-      return entry.name + "\0" + kind + "\0" + target;
-    })
-    .sort();
-  return crypto.createHash("sha256").update(entries.join("\0")).digest("hex");
+        return entry.name + "\0" + kind + "\0" + target;
+      })
+      .sort();
+    return crypto.createHash("sha256").update(entries.join("\0")).digest("hex");
+  } catch {
+    return "";
+  }
 }
 
 function matchesProjectInputGlob(