ttsc 0.31.6 → 0.32.1

package/src/launcher/internal/watch/WatchTopology.ts

@@ -7,10 +7,12 @@ import { CompilerProjectSelection } from "../../../compiler/internal/project/Com
 import { readJsoncFile } from "../../../compiler/internal/project/readJsoncFile";
 import { readProjectConfig } from "../../../compiler/internal/project/readProjectConfig";
 import { resolveTsgo } from "../../../compiler/internal/resolveTsgo";
+import { SidecarEnvironment } from "../../../compiler/internal/sharedHost/SidecarEnvironment";
 import { spawnNative } from "../../../compiler/internal/spawnNative";
 import { normalizeCompilerEnumValue } from "../../../flags/normalizeCompilerEnumValue";
 import { readCompilerOptionValues } from "../../../flags/readCompilerOptionValues";
 import { type ProjectInputPathIdentityContext } from "../../../internal/pathIdentity/ProjectInputPathIdentityContext";
+import { createCaseSensitivityObservations } from "../../../internal/pathIdentity/createCaseSensitivityObservations";
 import { createProjectInputPathIdentityContext } from "../../../internal/pathIdentity/createProjectInputPathIdentityContext";
 import { isProjectInputPathIdentityWithin } from "../../../internal/pathIdentity/isProjectInputPathIdentityWithin";
 import { resolveProjectInputPath } from "../../../internal/pathIdentity/resolveProjectInputPath";
@@ -46,26 +48,26 @@ import { watchDirectory } from "./watchDirectory";
  * output for source and declaration membership. An explicit reader supplies the
  * same absolute-path membership and failure contract for each resolved project.
  * Configuration files, project-reference roots, output inference and native
- * filesystem identity remain this topology's responsibility.
- * Response frames are observed once per project refresh at its compiler cwd;
- * that option view serves all project-output queries while the original argv
- * reaches compiler membership. A second observation rejects response changes
- * across membership resolution. Response files join the config reload set;
- * these observations do not pin files or detect a change restored in between.
+ * filesystem identity remain this topology's responsibility. Response frames
+ * are observed once per project refresh at its compiler cwd; that option view
+ * serves all project-output queries while the original argv reaches compiler
+ * membership. A second observation rejects response changes across membership
+ * resolution. Response files join the config reload set; these observations do
+ * not pin files or detect a change restored in between.
  *
  * `TTSC_WATCH_DEBUG_INPUTS` reports the named event, observed population deltas
  * and reload decision. These diagnostics reuse the decision's existing inputs;
  * they perform no extra filesystem observations.
  *
  * @evidence contracts/common.md#principled-implementation The compiler-input operation's membership, published rule inputs and actual content fingerprints qualify notifications; its native default obtains the real compiler list. Post-registration reconciliation compares baselines to recover observed handoff changes, not an atomic guarantee against every transient mutation. Explicit operations preserve native defaults without replacing global filesystem or compiler methods. Project-input attribution: Observed member deltas establish attribution; stale selected names cannot override them, while directory names retain supported population causality and unrelated multiple members remain unnamed.
- * @evidence contracts/common.md#clear-and-simple-design Compiler, plugin and project-input watch populations keep their own baselines and callbacks under one topology owner; small classifiers separate membership, selection and handle replacement. Four distinct operations own directory subscriptions, file subscriptions, immediate reload-directory reads and compiler membership; existing callers need no new argument. Project-input attribution: One private reconciliation separates member deltas from immediate resolution-directory digests before choosing a supported event name or an observed single member.
+ * @evidence contracts/common.md#clear-and-simple-design Compiler, plugin and project-input watch populations keep their own baselines and callbacks under one topology owner; small classifiers separate membership, selection and handle replacement. Five distinct operations own directory subscriptions, file subscriptions, immediate reload-directory reads, compiler membership and each decision's case-policy observations; existing callers need no new argument. Project-input attribution: One private reconciliation separates member deltas from immediate resolution-directory digests before choosing a supported event name or an observed single member.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported native backends and explicit gap/replacement ownership replace foreign watcher patching; failed observation is reported rather than represented as complete coverage. The constructor manufactures no observations and bypasses no input or content proof; supplied operations retain the existing callback and result contracts. Project-input attribution: Native event names do not manufacture a delta; the current and previous physical membership identify already observed names without filename or fixture exceptions.
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain membership authority, plugin fingerprinting, publication races, physical registration and public lifecycle operations following the documentation skill. Parameters identify each supplied operation and native default beside the constructor. Project-input attribution: Native paragraphs explain stale attention, directory causality, accompanying resolution digests and unselected immediate entries.
  * @evidence contracts/portability.md#os-neutral-implementation Native paths use Node APIs and registration uses realpath; compiler/plugin maps preserve lexical aliases and fold only measured insensitive ASCII components. Project inputs use physical identities, while unknown/native Unicode relations remain conservative event candidates rather than identity proof. Registration paths and read options are passed unchanged; compiler-input readers supply absolute membership paths without replacing the topology's native identity policy. Project-input attribution: The supplied filesystem identity transaction establishes selected names and ancestry without an OS-wide case assumption or lexical alias guess.
  *
- * @evidence contracts/performance.md#efficient-algorithms Identity-keyed maps separate membership, baselines and handle registries; reconciliation delegates project/config discovery, native compiler listing, filesystem traversal/hashing and backend callbacks, with costs described by its members. Construction retains operation references and empty indexes without a filesystem observation or build. Attribution indexed visits additionally pay path/key text, ancestor and native identity work; shared ancestor keys avoid repeating the same walk within a transaction.
- * @evidence contracts/performance.md#reuse-equivalent-work Current membership, content baselines and live registrations belong to one topology; reconciliation owners decide their reuse against fresh premises. Supplied operation identities are retained without adding an observation-result cache or assuming changed inputs remain equivalent. Project-input attribution: This classifier borrows one scan's deltas and identity transaction without retaining cross-event answers.
- * @evidence contracts/performance.md#bound-retention-and-release-resources Current and pending maps and live subscriptions remain topology-owned without a population cap; reconciliation attempts obsolete handle retirement. Constructor acquires no handle; directory arrays and attribution deltas are call-local. close invokes supplied close methods but does not await backend closure, and a thrown close can interrupt later map cleanup; retained snapshots remain until the facade is released.
+ * @evidence contracts/performance.md#efficient-algorithms Identity-keyed maps separate membership, baselines and handle registries; reconciliation delegates project/config discovery, native compiler listing, filesystem traversal/hashing and backend callbacks, with costs described by its members. A directory-triggered refresh additionally visits R active reload files even on failure and compares their metadata/owner snapshots, reading bytes only when those snapshots changed. Changed-owner and notification arrays and a reported-key set require O(R) references; moved owners share one existing watcher synchronization and post-registration reconciliation, whose selected-file traversal remains part of the operation. No additional compiler listing is requested. Construction retains operation references and empty indexes without a filesystem observation or build. Attribution indexed visits additionally pay path/key text, ancestor and native identity work; shared ancestor keys avoid repeating the same walk within a transaction.
+ * @evidence contracts/performance.md#reuse-equivalent-work Current membership, content baselines and live registrations belong to one topology; reconciliation owners decide their reuse against fresh premises. Supplied operation identities are retained without assuming changed inputs remain equivalent. Each project's last compiler listing is kept with its arguments and answers only a plugin-input change, which cannot move Program membership; every other refresh lists again. Notifications delivered in one poll iteration are decided together in the check phase, so one change lists and rescans once. Project-input attribution: This classifier borrows one scan's deltas and identity transaction without retaining cross-event answers.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources Current and pending maps and live subscriptions remain topology-owned without a population cap; compiler listings are replaced by each resolution and hold only its projects; reconciliation attempts obsolete handle retirement. Constructor acquires no handle; directory arrays and attribution deltas are call-local. close invokes supplied close methods but does not await backend closure, and a thrown close can interrupt later map cleanup; retained snapshots remain until the facade is released.
  */
 export class WatchTopology {
   private analysisOnly = false;
@@ -102,15 +104,42 @@ export class WatchTopology {
   /** The plugin inputs whose directories the last sync already watched. */
   private watchedExtraInputs = new Set<string>();
   private compilerFileSnapshots = new Map<string, CompilerFileSnapshot>();
+
+  /**
+   * The last compiler listing of each project the topology resolved, by its
+   * config path, with the arguments it was asked under (`listingQuestion`). A
+   * change of plugin inputs reuses it (samchon/ttsc#1741).
+   */
+  private compilerListings = new Map<string, CompilerListing>();
+
+  /**
+   * Notifications the current poll iteration delivered, decided together in the
+   * check phase (`deferNotification`).
+   */
+  private pendingNotifications = new Map<string, PendingNotification>();
+  private notificationsScheduled = false;
   private files = new Map<string, string>();
-  private lexicalIdentities = createProjectInputPathIdentityContext({
-    throwOnRealpathError: false,
-  });
+
+  /**
+   * The current decision's directory case-policy observations, which every
+   * identity context the decision creates shares (samchon/ttsc#1742).
+   */
+  private caseObservations!: ReturnType<
+    typeof createCaseSensitivityObservations
+  >;
+  private lexicalIdentities!: ProjectInputPathIdentityContext;
   private fileWatchers = new Map<string, fs.FSWatcher>();
   private observedDirectories = new Map<string, string>();
   private outputFiles = new Map<string, string>();
   private outputs = new Map<string, string>();
   private projectInputFingerprints = new Map<string, string>();
+
+  /**
+   * The metadata and physical owner each matched project-input file had when
+   * its fingerprint was taken, by match key; a named notification re-reads only
+   * the files whose metadata moved (samchon/ttsc#1748).
+   */
+  private projectInputFileSnapshots = new Map<string, CompilerFileSnapshot>();
   private projectInputMatches = new Map<string, string>();
   private projectInputs: ITtscProjectInputSnapshot = {
     files: [],
@@ -154,6 +183,8 @@ export class WatchTopology {
    *   membership; the default invokes the native compiler. Readers throw
    *   listing failures and retain ownership of their returned array, which this
    *   topology does not mutate.
+   * @param observeCaseSensitivity Create one decision's directory case-policy
+   *   observations; the default asks the native filesystem.
    */
   public constructor(
     private readonly options: WatchTopologyOptions,
@@ -162,7 +193,10 @@ export class WatchTopology {
     private readonly openFileWatch: typeof fs.watch = fs.watch,
     private readonly readDirectory: typeof fs.readdirSync = fs.readdirSync,
     private readonly getCompilerInputs: typeof listCompilerInputs = listCompilerInputs,
-  ) {}
+    private readonly observeCaseSensitivity: typeof createCaseSensitivityObservations = createCaseSensitivityObservations,
+  ) {
+    this.beginLexicalTransaction();
+  }
 
   /**
    * Re-resolve compiler inputs and notify when the resolved topology changes,
@@ -183,17 +217,67 @@ export class WatchTopology {
     this.refreshCompilerInputs(notify, false);
   }
 
+  /**
+   * Wait until delivered notifications and registration reconciliation finish.
+   *
+   * A completed build does not imply a quiet topology: its final refresh can
+   * queue another decision and another build (#1756). Yield through the check
+   * phase before inspecting every scheduled owner so a decision queued by
+   * another decision remains part of this barrier. Later filesystem changes
+   * belong to a later barrier; this does not freeze the filesystem.
+   *
+   * @evidence contracts/common.md#principled-implementation A check-phase observation follows delivered events, and every notification, recovery and registration queue must be empty before completion.
+   * @evidence contracts/common.md#clear-and-simple-design The topology owns the barrier because it alone owns all five scheduled queues.
+   * @evidence contracts/common.md#prohibited-implementation-shortcuts Queue state establishes completion without a quiet-time estimate or an invented filesystem snapshot.
+   * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes delivered work from later mutations and explains the post-build queued-decision race.
+   * @evidenceExclude contracts/portability.md#os-neutral-implementation The barrier observes owned JavaScript queues without a separate native operation.
+   * @evidence contracts/performance.md#efficient-algorithms Each check turn inspects five flags and two map sizes; notification processing retains its owning traversal and native-operation costs.
+   * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call observes current work rather than reusing an earlier completion.
+   * @evidence contracts/performance.md#bound-retention-and-release-resources One immediate callback and promise remain live per waiting call; continuous new work can prevent completion and no deadline is imposed.
+   */
+  public async whenIdle(): Promise<void> {
+    do {
+      await new Promise<void>((resolve) => setImmediate(resolve));
+    } while (
+      !this.closed &&
+      (this.notificationsScheduled ||
+        this.pluginNotificationsScheduled ||
+        this.compilerPostRegistrationReconciliationScheduled ||
+        this.projectInputRecoveryScheduled ||
+        this.projectInputPostRegistrationReconciliationScheduled ||
+        this.pendingNotifications.size !== 0 ||
+        this.pendingPluginNotifications.size !== 0)
+    );
+  }
+
+  /**
+   * @param reuseListings Answer each project's membership with its last listing
+   *   under the same arguments instead of asking the compiler again. Only a
+   *   refresh whose cause cannot move Program membership passes it.
+   */
   private refreshCompilerInputs(
     notify: boolean,
     skipUnobservedProjectInputWatchRoots: boolean,
+    reuseListings: boolean = false,
   ): void {
     this.beginLexicalTransaction();
+    const listings = new Map<string, CompilerListing>();
     const next = resolveWatchTopology(
       this.options,
       this.extraInputs,
       this.lexicalIdentities,
-      this.getCompilerInputs,
+      (project, options) => {
+        const question = listingQuestion(project, options);
+        const last = this.compilerListings.get(project.path);
+        const inputs =
+          reuseListings && last?.question === question
+            ? last.inputs
+            : this.getCompilerInputs(project, options);
+        listings.set(project.path, { inputs, question });
+        return inputs;
+      },
     );
+    this.compilerListings = listings;
     const compilerProgramMembershipChange =
       next.analysisOnly &&
       WatchPaths.mapsEqual(this.reloadFiles, next.reloadFiles) &&
@@ -204,6 +288,7 @@ export class WatchTopology {
     const projectInputProgramOverlap = projectInputCompilerMembershipChange(
       this.projectInputs,
       compilerProgramMembershipChange,
+      this.projectInputIdentities(),
     );
     const projectInputProgramChange =
       compilerProgramMembershipChange.length !== 0 &&
@@ -293,7 +378,7 @@ export class WatchTopology {
     changed: readonly string[],
   ): boolean {
     const matches = this.collectProjectInputMatches();
-    const fingerprints = fingerprintProjectInputMatches(
+    const { fingerprints, snapshots } = fingerprintProjectInputMatches(
       matches,
       this.readDirectory,
     );
@@ -307,6 +392,7 @@ export class WatchTopology {
     const causedBy = projectInputCompilerMembershipProjectChanges(
       changed,
       population.globs,
+      this.projectInputIdentities(),
     );
     const reloadInput = {
       causedBy,
@@ -316,7 +402,10 @@ export class WatchTopology {
       reloadDirectories: population.reloadDirectories,
       reloadFiles: population.reloadFiles ?? [],
     };
-    const reload = projectInputReloadEventShouldNotify(reloadInput);
+    const reload = projectInputReloadEventShouldNotify(
+      reloadInput,
+      this.projectInputIdentities(),
+    );
     reportProjectInputDecision({
       source: "compiler-membership",
       ...reloadInput,
@@ -328,6 +417,7 @@ export class WatchTopology {
     // instead of disappearing behind the warm compiler-membership handoff.
     this.projectInputMatches = matches;
     this.projectInputFingerprints = fingerprints;
+    this.projectInputFileSnapshots = snapshots;
     return reload;
   }
 
@@ -353,8 +443,8 @@ export class WatchTopology {
    * @evidence contracts/common.md#prohibited-implementation-shortcuts The actual plugin source digest applies its owning source-selection and pruning policy; named plugins or fixture output do not replace observed input state.
    * @evidence contracts/common.md#meaningful-documentation Native prose explains baseline timing and why existing inputs are not restamped following the documentation skill.
    * @evidence contracts/portability.md#os-neutral-implementation Native path resolution and canonical backend registration govern source trees; lexical keys preserve declarations and unknown names, folding ASCII only under measured insensitive parents rather than an OS-derived rule.
-   * @evidence contracts/performance.md#efficient-algorithms Input/path keys deduplicate with text and native case/ancestor work; only newly admitted inputs compute initial source digests, each proven from the selected files' metadata when the load's records hold and read from the selected pruned corpus otherwise; refresh(false) also pays project/compiler listing, directory traversal and watcher reconciliation; fixed publication count does not bound delegated bytes or backend work.
-   * @evidence contracts/performance.md#reuse-equivalent-work Unchanged ordered input sets return immediately; existing inputs reuse their recorded digest until actual notification processing establishes changed consumed state; a new input's digest is the one the load recorded while its metadata holds.
+   * @evidence contracts/performance.md#efficient-algorithms Input/path keys deduplicate with text and native case/ancestor work; only newly admitted inputs compute initial source digests, each proven from the selected files' metadata when the load's records hold and read from the selected pruned corpus otherwise; the following reconciliation pays project configuration, directory traversal and watcher work but answers membership from each project's last compiler listing; fixed publication count does not bound delegated bytes or backend work.
+   * @evidence contracts/performance.md#reuse-equivalent-work Unchanged ordered input sets return immediately; a changed set reuses each project's last compiler listing under the same arguments, since plugin inputs cannot move Program membership; existing inputs reuse their recorded digest until actual notification processing establishes changed consumed state; a new input's digest is the one the load recorded while its metadata holds.
    * @evidence contracts/performance.md#bound-retention-and-release-resources Publications replace input/digest populations and case-observation caches without a population cap; synchronization attempts obsolete watcher closure. Native/supplied closure has its own lifetime and can throw; owner close does not prove every backend has stopped or every retained snapshot byte was released.
    */
   public setExtraInputs(
@@ -382,7 +472,12 @@ export class WatchTopology {
       );
     }
     this.pluginInputStates = states;
-    this.refresh(false);
+    // Plugin inputs join the watched files and directories, never Program
+    // membership, so the compiler's last answer stands. A load reports up to
+    // three different sets, and asking again for each spawned tsgo three times
+    // per load (samchon/ttsc#1741). A membership change meanwhile reaches the
+    // refresh its own notification starts, which lists again.
+    this.refreshCompilerInputs(false, false, true);
   }
 
   /**
@@ -399,7 +494,11 @@ export class WatchTopology {
    * @evidence contracts/performance.md#bound-retention-and-release-resources Publication prunes retired declaration-owner choices and replaces uncapped match/fingerprint populations. Watcher retirement invokes close without awaiting backend completion, and supplied errors can interrupt cleanup. Weak output-overlap keys do not retain old identity transactions; the current declaration snapshot can borrow caller arrays until replaced or the facade is released.
    */
   public setProjectInputs(inputs: ITtscProjectInputSnapshot): void {
-    const next = normalizeProjectInputSnapshot(inputs);
+    this.beginLexicalTransaction();
+    const next = normalizeProjectInputSnapshot(
+      inputs,
+      this.projectInputIdentities(),
+    );
     // The declared spellings are recorded even when the normalized snapshot did
     // not move, because a republication can carry a new alias for identities
     // that already matched, and anchoring the spelling that was retired would
@@ -408,7 +507,13 @@ export class WatchTopology {
       inputs.declared === undefined
         ? inputs
         : { ...inputs.declared, root: inputs.root };
-    if (projectInputSnapshotsEqual(this.projectInputs, next)) {
+    if (
+      projectInputSnapshotsEqual(
+        this.projectInputs,
+        next,
+        this.projectInputIdentities(),
+      )
+    ) {
       this.syncProjectInputWatchers();
       return;
     }
@@ -420,10 +525,12 @@ export class WatchTopology {
       { ...(inputs.declared ?? inputs), root: inputs.root },
     ]);
     this.projectInputMatches = this.collectProjectInputMatches();
-    this.projectInputFingerprints = fingerprintProjectInputMatches(
+    const baseline = fingerprintProjectInputMatches(
       this.projectInputMatches,
       this.readDirectory,
     );
+    this.projectInputFingerprints = baseline.fingerprints;
+    this.projectInputFileSnapshots = baseline.snapshots;
     this.syncProjectInputWatchers();
   }
 
@@ -457,11 +564,26 @@ export class WatchTopology {
 
   /** Start fresh native case observations for one synchronous watch decision. */
   private beginLexicalTransaction(): void {
+    this.caseObservations = this.observeCaseSensitivity();
     this.lexicalIdentities = createProjectInputPathIdentityContext({
+      caseSensitive: this.caseObservations,
       throwOnRealpathError: false,
     });
   }
 
+  /**
+   * A strict project-input identity context for the current decision. Its
+   * physical paths are resolved afresh, and its case answers are the
+   * decision's: one decision builds such contexts per declaration and per
+   * candidate, and each asked every directory again, which on Windows is an
+   * `fsutil` process per question (samchon/ttsc#1742).
+   */
+  private projectInputIdentities(): ProjectInputPathIdentityContext {
+    return createProjectInputPathIdentityContext({
+      caseSensitive: this.caseObservations,
+    });
+  }
+
   /** Keep lexical alias ownership while sharing this decision's case probes. */
   private pathKey(location: string): string {
     return WatchPaths.pathKey(location, this.lexicalIdentities);
@@ -585,34 +707,17 @@ export class WatchTopology {
         this.openDirectoryWatch(
           watcherRegistrationPath(location),
           process.platform === "win32",
-          (event, filename, gap) => {
-            this.beginLexicalTransaction();
-            const changed =
-              filename === null ? undefined : path.resolve(location, filename);
-            const pluginInput = changed ?? location;
-            if (this.isPluginInput(pluginInput)) {
-              this.notePluginNotification(pluginInput);
-              return;
-            }
-            const plan = planCompilerDirectoryWatchEvent({
-              changed,
-              event,
-              exists: fs.existsSync,
+          (event, filename, gap) =>
+            this.deferNotification({
+              gap: gap === true,
+              lane: "compiler",
               location,
-              identities: this.lexicalIdentities,
-              platform: process.platform,
-              trackedFiles: this.files,
-            });
-            this.rearmFileWatchers(plan.rearm);
-            for (const file of this.compilerChangesToReport(
-              plan.changes,
-              changed,
-              gap === true,
-            )) {
-              this.reportCompilerFileChange(file);
-            }
-            if (plan.refresh) this.refreshFromDirectory(location, changed);
-          },
+              changed:
+                filename === null
+                  ? undefined
+                  : path.resolve(location, filename),
+              rename: event === "rename",
+            }),
         ),
       (location, error) => this.callbacks.onError(location, error),
       () => this.closed === false,
@@ -622,6 +727,87 @@ export class WatchTopology {
     );
   }
 
+  /**
+   * Decide a notification in the event loop's check phase, together with every
+   * other notification the same poll iteration delivered (samchon/ttsc#1741).
+   *
+   * One filesystem change usually arrives as several notifications, rename and
+   * change or create and modify, and each listed the compiler inputs or
+   * rescanned the project inputs again. Identical notifications of one lane,
+   * location and path merge, keeping a rename or a gap any of them carried, and
+   * the batch refreshes compiler membership once after deciding them all. The
+   * refresh therefore starts after every notification it absorbs, and one
+   * delivered later schedules another batch.
+   */
+  private deferNotification(notification: PendingNotification): void {
+    if (this.closed) return;
+    const key = [
+      notification.lane,
+      notification.location,
+      notification.changed ?? "",
+    ].join("\0");
+    const pending = this.pendingNotifications.get(key);
+    if (pending !== undefined) {
+      pending.rename ||= notification.rename;
+      pending.gap ||= notification.gap;
+      return;
+    }
+    this.pendingNotifications.set(key, { ...notification });
+    if (this.notificationsScheduled) return;
+    this.notificationsScheduled = true;
+    setImmediate(() => this.decideNotifications());
+  }
+
+  private decideNotifications(): void {
+    this.notificationsScheduled = false;
+    const pending = [...this.pendingNotifications.values()];
+    this.pendingNotifications.clear();
+    if (this.closed) return;
+    const refreshes: DirectoryRefresh[] = [];
+    for (const notification of pending) {
+      if (notification.lane === "project-input") {
+        this.refreshProjectInputs(notification.location, notification.changed);
+        continue;
+      }
+      this.decideCompilerDirectoryNotification(notification, refreshes);
+    }
+    if (refreshes.length === 0 || this.closed) return;
+    this.beginLexicalTransaction();
+    this.refreshFromDirectories(refreshes);
+  }
+
+  /** Decide one merged directory notification of the compiler lane. */
+  private decideCompilerDirectoryNotification(
+    notification: PendingNotification,
+    refreshes: DirectoryRefresh[],
+  ): void {
+    this.beginLexicalTransaction();
+    const { changed, location } = notification;
+    const pluginInput = changed ?? location;
+    if (this.isPluginInput(pluginInput)) {
+      this.notePluginNotification(pluginInput);
+      return;
+    }
+    const plan = planCompilerDirectoryWatchEvent({
+      changed,
+      event: notification.rename ? "rename" : "change",
+      exists: fs.existsSync,
+      location,
+      identities: this.lexicalIdentities,
+      platform: process.platform,
+      trackedFiles: this.files,
+    });
+    this.rearmFileWatchers(plan.rearm);
+    for (const file of this.compilerChangesToReport(
+      plan.changes,
+      changed,
+      notification.gap,
+    )) {
+      this.reportCompilerFileChange(file);
+    }
+    if (plan.refresh) refreshes.push({ changed, location });
+  }
+
   /**
    * Reconcile tracked compiler files after a newly registered watcher returns.
    *
@@ -730,6 +916,7 @@ export class WatchTopology {
       if (fs.existsSync(location)) {
         if (this.projectInputMatches.size !== 0) {
           const key = createProjectInputPathIdentityContext({
+            caseSensitive: this.caseObservations,
             throwOnRealpathError: false,
           }).resolve(location).key;
           if (
@@ -840,7 +1027,7 @@ export class WatchTopology {
     if (this.closed) return;
     const previous = new Map(this.projectInputWatchers);
     const previousLinks = new Map(this.projectInputLinkWatchers);
-    const identities = createProjectInputPathIdentityContext();
+    const identities = this.projectInputIdentities();
     const desired = new Map<string, string>();
     const required = new Map<string, string>();
     for (const file of this.projectInputDeclarations("file")) {
@@ -924,11 +1111,17 @@ export class WatchTopology {
         this.openDirectoryWatch(
           watcherRegistrationPath(location),
           true,
-          (_event, filename) => {
-            const changed =
-              filename === null ? undefined : path.resolve(location, filename);
-            this.refreshProjectInputs(location, changed);
-          },
+          (_event, filename) =>
+            this.deferNotification({
+              gap: false,
+              lane: "project-input",
+              location,
+              changed:
+                filename === null
+                  ? undefined
+                  : path.resolve(location, filename),
+              rename: false,
+            }),
         ),
       (location, error) => {
         const key = identities.resolve(location).key;
@@ -1003,11 +1196,17 @@ export class WatchTopology {
         this.openDirectoryWatch(
           watcherRegistrationPath(location),
           false,
-          (_event, filename) => {
-            const changed =
-              filename === null ? undefined : path.resolve(location, filename);
-            this.refreshProjectInputs(location, changed);
-          },
+          (_event, filename) =>
+            this.deferNotification({
+              gap: false,
+              lane: "project-input",
+              location,
+              changed:
+                filename === null
+                  ? undefined
+                  : path.resolve(location, filename),
+              rename: false,
+            }),
         ),
       (location, error) => this.callbacks.onError(location, error),
       () => this.closed === false,
@@ -1088,6 +1287,7 @@ export class WatchTopology {
     if (this.projectInputRecoveryScheduled) return;
     this.projectInputRecoveryScheduled = true;
     queueMicrotask(() => {
+      this.beginLexicalTransaction();
       try {
         let previousRejectionCount = -1;
         while (
@@ -1131,6 +1331,7 @@ export class WatchTopology {
     queueMicrotask(() => {
       this.projectInputPostRegistrationReconciliationScheduled = false;
       if (this.closed) return;
+      this.beginLexicalTransaction();
       this.refreshPublishedProjectInputIdentities();
       this.refreshProjectInputs(this.projectInputs.root, undefined, true);
     });
@@ -1145,8 +1346,13 @@ export class WatchTopology {
    * that must observe later target changes.
    */
   private refreshPublishedProjectInputIdentities(): void {
-    const next = normalizeProjectInputSnapshot(this.declaredProjectInputs);
-    if (projectInputSnapshotsEqual(this.projectInputs, next)) return;
+    const identities = this.projectInputIdentities();
+    const next = normalizeProjectInputSnapshot(
+      this.declaredProjectInputs,
+      identities,
+    );
+    if (projectInputSnapshotsEqual(this.projectInputs, next, identities))
+      return;
     this.projectInputs = next;
     this.pruneProjectInputWatchRoots([next, this.declaredProjectInputs]);
   }
@@ -1264,6 +1470,7 @@ export class WatchTopology {
     const resolved = ProjectInputWatchRules.projectInputRecursiveWatchRoot(
       target,
       this.projectInputs.root,
+      this.projectInputIdentities(),
     );
     if (resolved !== undefined) this.projectInputWatchRoots.set(key, resolved);
     return resolved;
@@ -1277,7 +1484,7 @@ export class WatchTopology {
     this.beginLexicalTransaction();
     try {
       const previous = this.projectInputMatches;
-      const identities = createProjectInputPathIdentityContext();
+      const identities = this.projectInputIdentities();
       // One population for the whole decision. Every question below is asked of
       // the same declarations, and rebuilding it per question would both cost
       // more and let two answers disagree about what was declared.
@@ -1315,13 +1522,30 @@ export class WatchTopology {
       }
       const next = this.collectProjectInputMatches();
       const membershipChanged = WatchPaths.mapsEqual(previous, next) === false;
-      const nextFingerprints =
+      // A named notification reads the named path's bytes and any file whose
+      // metadata or owner moved; one that names nothing reads every file
+      // (samchon/ttsc#1748).
+      const scanned =
         changed === undefined ||
         membershipChanged ||
         directlyMatched ||
         topologyMatched
-          ? fingerprintProjectInputMatches(next, this.readDirectory)
-          : this.projectInputFingerprints;
+          ? fingerprintProjectInputMatches(
+              next,
+              this.readDirectory,
+              changed === undefined
+                ? undefined
+                : {
+                    fingerprints: this.projectInputFingerprints,
+                    named: identities.resolve(changed).key,
+                    snapshots: this.projectInputFileSnapshots,
+                  },
+            )
+          : {
+              fingerprints: this.projectInputFingerprints,
+              snapshots: this.projectInputFileSnapshots,
+            };
+      const nextFingerprints = scanned.fingerprints;
       const contentChanged =
         WatchPaths.mapsEqual(
           this.projectInputFingerprints,
@@ -1352,7 +1576,10 @@ export class WatchTopology {
         reloadDirectories: population.reloadDirectories ?? [],
         reloadFiles: population.reloadFiles ?? [],
       };
-      const reload = projectInputReloadEventShouldNotify(reloadInput);
+      const reload = projectInputReloadEventShouldNotify(
+        reloadInput,
+        identities,
+      );
       const invalidate = projectInputMembershipInvalidatesProgram({
         changed: reconciledChange,
         changedInputs,
@@ -1362,6 +1589,7 @@ export class WatchTopology {
       });
       this.projectInputMatches = next;
       this.projectInputFingerprints = nextFingerprints;
+      this.projectInputFileSnapshots = scanned.snapshots;
       this.syncProjectInputWatchers(skipUnobservedProjectInputWatchRoots);
       // A JSON/TS/JS project-input member can simultaneously enter or leave
       // the compiler Program. Reconcile the compiler watch snapshot before
@@ -1416,7 +1644,7 @@ export class WatchTopology {
   }
 
   private collectProjectInputMatches(): Map<string, string> {
-    const identities = createProjectInputPathIdentityContext();
+    const identities = this.projectInputIdentities();
     const matches = new Map<string, string>();
     // Both spellings are scanned, and each is resolved here rather than when
     // the snapshot arrived. A declaration reached through a symlink otherwise
@@ -1510,25 +1738,78 @@ export class WatchTopology {
   }
 
   private refreshFromDirectory(location: string, changed?: string): void {
-    if (
-      changed !== undefined &&
-      WatchPaths.isDirectory(changed) &&
-      this.isCompilerOutputDirectory(changed) === false &&
-      this.isProjectInputDirectory(changed) === false
-    ) {
-      this.observedDirectories.set(this.pathKey(changed), changed);
+    this.refreshFromDirectories([{ changed, location }]);
+  }
+
+  /**
+   * Refresh compiler membership once for every directory a decision asked
+   * about. A failed refresh still reports, once each, the reload inputs every
+   * requested change names.
+   *
+   * A replacement can be delivered under only its vanished temporary name,
+   * including when its malformed bytes prevent refresh. Reconcile active
+   * reload-file snapshots on either outcome, deduplicate failed-refresh
+   * recovery against actual reported movement, and preserve the original
+   * refresh error after recovery. Batch moved owners through the existing rearm
+   * operation before notifying, because a POSIX per-file handle still owns the
+   * old inode. Unchanged snapshots stay quiet unless the existing
+   * failed-refresh selector explicitly names or cannot find the reload input.
+   */
+  private refreshFromDirectories(refreshes: readonly DirectoryRefresh[]): void {
+    for (const { changed } of refreshes) {
+      if (
+        changed !== undefined &&
+        WatchPaths.isDirectory(changed) &&
+        this.isCompilerOutputDirectory(changed) === false &&
+        this.isProjectInputDirectory(changed) === false
+      ) {
+        this.observedDirectories.set(this.pathKey(changed), changed);
+      }
     }
+    let refreshFailure: { error: unknown } | undefined;
     try {
       this.refresh(true);
     } catch (error) {
-      for (const reload of reloadInputsForFailedTopologyRefresh(
-        this.reloadFiles.values(),
-        changed,
-        this.lexicalIdentities,
-      )) {
-        this.callbacks.onInputChange({ kind: "config", path: reload });
+      refreshFailure = { error };
+    }
+    try {
+      if (this.closed) return;
+      const changed: string[] = [];
+      const rearm: string[] = [];
+      const reported = new Set<string>();
+      for (const reload of this.reloadFiles.values()) {
+        if (this.closed) return;
+        const movement = this.compilerFileMovement(reload);
+        if (movement.owner) rearm.push(reload);
+        if (this.compilerMovementReports(reload, movement))
+          changed.push(reload);
       }
-      this.callbacks.onError(location, error);
+      if (rearm.length !== 0) this.rearmFileWatchers(rearm, true);
+      for (const reload of changed) {
+        if (this.closed) return;
+        reported.add(this.pathKey(reload));
+        this.reportCompilerFileChange(reload);
+      }
+      if (refreshFailure !== undefined) {
+        for (const { changed } of refreshes) {
+          for (const reload of reloadInputsForFailedTopologyRefresh(
+            this.reloadFiles.values(),
+            changed,
+            this.lexicalIdentities,
+          )) {
+            if (this.closed) return;
+            const key = this.pathKey(reload);
+            if (reported.has(key)) continue;
+            reported.add(key);
+            this.callbacks.onInputChange({ kind: "config", path: reload });
+          }
+        }
+      }
+    } catch (error) {
+      this.callbacks.onError(refreshes[0]!.location, error);
+    } finally {
+      if (refreshFailure !== undefined)
+        this.callbacks.onError(refreshes[0]!.location, refreshFailure.error);
     }
   }
 
@@ -1591,7 +1872,7 @@ export class WatchTopology {
 
   private isProjectInputDirectory(location: string): boolean {
     const resolved = path.resolve(location);
-    const identities = createProjectInputPathIdentityContext();
+    const identities = this.projectInputIdentities();
     return (
       this.projectInputs.files.some(
         (file) =>
@@ -1764,6 +2045,46 @@ type CompilerFileSnapshot = {
   owner: string;
 };
 
+type PendingNotification = {
+  changed: string | undefined;
+  gap: boolean;
+  lane: "compiler" | "project-input";
+  location: string;
+  rename: boolean;
+};
+
+type DirectoryRefresh = {
+  changed: string | undefined;
+  location: string;
+};
+
+type CompilerListing = {
+  /** The reader's own array, which the topology never mutates. */
+  inputs: string[];
+  question: string;
+};
+
+/**
+ * Everything a compiler listing of `project` is asked with: the project, and
+ * each option `listCompilerInputs` passes to the compiler. Two refreshes with
+ * the same question ask the compiler the same thing; only the disk can answer
+ * them differently.
+ */
+function listingQuestion(
+  project: ITtscParsedProjectConfig,
+  options: WatchTopologyOptions,
+): string {
+  return JSON.stringify([
+    project.path,
+    project.root,
+    options.binary ?? null,
+    options.compilerArgsCwd ?? null,
+    options.env ?? null,
+    options.passthrough ?? null,
+    options.pinCompilerProject ?? null,
+  ]);
+}
+
 type CompilerFileMovement = {
   content: boolean;
   owner: boolean;
@@ -1836,7 +2157,10 @@ function resolveWatchTopology(
       addPaths(reloadFiles, inspected.responseFiles, identities);
       const compilerInputs = getCompilerInputs(project, options);
       CompilerProjectSelection.assertCurrent(selection);
-      const compilerOutputs = resolveCompilerOutputs(project, inspected.options);
+      const compilerOutputs = resolveCompilerOutputs(
+        project,
+        inspected.options,
+      );
       addPaths(outputFiles, compilerOutputs.files, identities);
       addPaths(
         outputFiles,
@@ -1949,10 +2273,11 @@ function listCompilerInputs(
   project: ITtscParsedProjectConfig,
   options: WatchTopologyOptions,
 ): string[] {
+  const env = SidecarEnvironment.merge(process.env, options.env);
   const tsgo = resolveTsgo({
     binary: options.binary,
     cwd: project.root,
-    env: options.env,
+    env,
   });
   const result = spawnNative(
     tsgo.binary,
@@ -1967,7 +2292,7 @@ function listCompilerInputs(
     ],
     {
       cwd: options.compilerArgsCwd ?? project.root,
-      env: { ...process.env, ...options.env },
+      env,
       encoding: "utf8",
     },
   );
@@ -2355,8 +2680,8 @@ function uniqueExistingPaths(
 
 function normalizeProjectInputSnapshot(
   snapshot: ITtscProjectInputSnapshot,
+  identities: ProjectInputPathIdentityContext,
 ): ITtscProjectInputSnapshot {
-  const identities = createProjectInputPathIdentityContext();
   const files = new Map<string, string>();
   const globs = new Map<string, string>();
   const reloadDirectories = new Map<string, string>();
@@ -2389,8 +2714,8 @@ function normalizeProjectInputSnapshot(
 function projectInputSnapshotsEqual(
   left: ITtscProjectInputSnapshot,
   right: ITtscProjectInputSnapshot,
+  identities: ProjectInputPathIdentityContext,
 ): boolean {
-  const identities = createProjectInputPathIdentityContext();
   return (
     // Every sibling comparison in this class decides on identity, and this one
     // is only safe today because both operands come from the same normalizer.
@@ -2445,7 +2770,7 @@ function isSymbolicLink(location: string): boolean {
 function matchesProjectInput(
   snapshot: ITtscProjectInputSnapshot,
   location: string,
-  identities = createProjectInputPathIdentityContext(),
+  identities: ProjectInputPathIdentityContext,
 ): boolean {
   const key = identities.resolve(location).key;
   return (
@@ -2572,8 +2897,8 @@ function compilerMembershipChange(
 function projectInputCompilerMembershipChange(
   snapshot: ITtscProjectInputSnapshot,
   changed: readonly string[],
+  identities: ProjectInputPathIdentityContext,
 ): string[] {
-  const identities = createProjectInputPathIdentityContext();
   return changed.filter(
     (location) =>
       matchesProjectInput(snapshot, location, identities) &&
@@ -2593,8 +2918,8 @@ function projectInputCompilerMembershipChange(
 function projectInputCompilerMembershipProjectChanges(
   locations: readonly string[],
   globs: readonly string[],
+  identities: ProjectInputPathIdentityContext,
 ): string[] {
-  const identities = createProjectInputPathIdentityContext();
   const roots = globs.map((glob) => identities.resolve(literalGlobRoot(glob)));
   const changes = new Map<string, string>();
   for (const location of locations) {
@@ -2614,20 +2939,54 @@ function projectInputCompilerMembershipProjectChanges(
   return [...changes.values()].sort();
 }
 
+/**
+ * Fingerprint every matched project input: a directory by its entries, a file
+ * by its bytes.
+ *
+ * Without `previous`, every file is read. With it, a file keeps its previous
+ * digest while its metadata and physical owner hold, unless it is the `named`
+ * path, whose bytes are always read: a notification that names a file is the
+ * one whose same-size rewrite within a timestamp tick metadata cannot show.
+ */
 function fingerprintProjectInputMatches(
   matches: ReadonlyMap<string, string>,
   readDirectory: typeof fs.readdirSync,
-): Map<string, string> {
+  previous?: {
+    fingerprints: ReadonlyMap<string, string>;
+    named: string;
+    snapshots: ReadonlyMap<string, CompilerFileSnapshot>;
+  },
+): {
+  fingerprints: Map<string, string>;
+  snapshots: Map<string, CompilerFileSnapshot>;
+} {
   const fingerprints = new Map<string, string>();
+  const snapshots = new Map<string, CompilerFileSnapshot>();
   for (const [key, location] of matches) {
-    fingerprints.set(
-      key,
-      WatchPaths.isDirectory(location)
-        ? fingerprintProjectInputDirectory(location, readDirectory)
-        : fingerprintProjectInputFile(location),
-    );
-  }
-  return fingerprints;
+    if (WatchPaths.isDirectory(location)) {
+      fingerprints.set(
+        key,
+        fingerprintProjectInputDirectory(location, readDirectory),
+      );
+      continue;
+    }
+    const metadata = compilerFileSnapshot(location, "");
+    const before = previous?.snapshots.get(key);
+    const kept = previous?.fingerprints.get(key);
+    const fingerprint =
+      previous !== undefined &&
+      key !== previous.named &&
+      before !== undefined &&
+      kept !== undefined &&
+      metadata.content !== "" &&
+      before.content === metadata.content &&
+      before.owner === metadata.owner
+        ? kept
+        : fingerprintProjectInputFile(location);
+    fingerprints.set(key, fingerprint);
+    snapshots.set(key, { ...metadata, fingerprint });
+  }
+  return { fingerprints, snapshots };
 }
 
 function fingerprintProjectInputFile(location: string): string {
@@ -2675,7 +3034,7 @@ function fingerprintProjectInputDirectory(
 function matchesProjectInputGlob(
   pattern: string,
   location: string,
-  identities = createProjectInputPathIdentityContext(),
+  identities: ProjectInputPathIdentityContext,
 ): boolean {
   const root = identities.resolve(literalGlobRoot(pattern));
   const candidate = identities.resolve(location);