ttsc 0.31.6 → 0.32.1

package/lib/launcher/internal/watch/WatchTopology.js

@@ -12,9 +12,11 @@ const CompilerProjectSelection_1 = require("../../../compiler/internal/project/C
 const readJsoncFile_1 = require("../../../compiler/internal/project/readJsoncFile");
 const readProjectConfig_1 = require("../../../compiler/internal/project/readProjectConfig");
 const resolveTsgo_1 = require("../../../compiler/internal/resolveTsgo");
+const SidecarEnvironment_1 = require("../../../compiler/internal/sharedHost/SidecarEnvironment");
 const spawnNative_1 = require("../../../compiler/internal/spawnNative");
 const normalizeCompilerEnumValue_1 = require("../../../flags/normalizeCompilerEnumValue");
 const readCompilerOptionValues_1 = require("../../../flags/readCompilerOptionValues");
+const createCaseSensitivityObservations_1 = require("../../../internal/pathIdentity/createCaseSensitivityObservations");
 const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
 const isProjectInputPathIdentityWithin_1 = require("../../../internal/pathIdentity/isProjectInputPathIdentityWithin");
 const resolveProjectInputPath_1 = require("../../../internal/pathIdentity/resolveProjectInputPath");
@@ -44,26 +46,26 @@ const watchDirectory_1 = require("./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.
  */
 class WatchTopology {
     options;
@@ -72,6 +74,7 @@ class WatchTopology {
     openFileWatch;
     readDirectory;
     getCompilerInputs;
+    observeCaseSensitivity;
     analysisOnly = false;
     closed = false;
     compilerPostRegistrationMembershipRefresh = false;
@@ -102,15 +105,36 @@ class WatchTopology {
     /** The plugin inputs whose directories the last sync already watched. */
     watchedExtraInputs = new Set();
     compilerFileSnapshots = new Map();
+    /**
+     * 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).
+     */
+    compilerListings = new Map();
+    /**
+     * Notifications the current poll iteration delivered, decided together in the
+     * check phase (`deferNotification`).
+     */
+    pendingNotifications = new Map();
+    notificationsScheduled = false;
     files = new Map();
-    lexicalIdentities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
-        throwOnRealpathError: false,
-    });
+    /**
+     * The current decision's directory case-policy observations, which every
+     * identity context the decision creates shares (samchon/ttsc#1742).
+     */
+    caseObservations;
+    lexicalIdentities;
     fileWatchers = new Map();
     observedDirectories = new Map();
     outputFiles = new Map();
     outputs = new Map();
     projectInputFingerprints = new Map();
+    /**
+     * 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).
+     */
+    projectInputFileSnapshots = new Map();
     projectInputMatches = new Map();
     projectInputs = {
         files: [],
@@ -150,14 +174,18 @@ 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.
      */
-    constructor(options, callbacks, openDirectoryWatch = watchDirectory_1.watchDirectory, openFileWatch = node_fs_1.default.watch, readDirectory = node_fs_1.default.readdirSync, getCompilerInputs = listCompilerInputs) {
+    constructor(options, callbacks, openDirectoryWatch = watchDirectory_1.watchDirectory, openFileWatch = node_fs_1.default.watch, readDirectory = node_fs_1.default.readdirSync, getCompilerInputs = listCompilerInputs, observeCaseSensitivity = createCaseSensitivityObservations_1.createCaseSensitivityObservations) {
         this.options = options;
         this.callbacks = callbacks;
         this.openDirectoryWatch = openDirectoryWatch;
         this.openFileWatch = openFileWatch;
         this.readDirectory = readDirectory;
         this.getCompilerInputs = getCompilerInputs;
+        this.observeCaseSensitivity = observeCaseSensitivity;
+        this.beginLexicalTransaction();
     }
     /**
      * Re-resolve compiler inputs and notify when the resolved topology changes,
@@ -177,16 +205,61 @@ class WatchTopology {
     refresh(notify) {
         this.refreshCompilerInputs(notify, false);
     }
-    refreshCompilerInputs(notify, skipUnobservedProjectInputWatchRoots) {
+    /**
+     * 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.
+     */
+    async whenIdle() {
+        do {
+            await new Promise((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.
+     */
+    refreshCompilerInputs(notify, skipUnobservedProjectInputWatchRoots, reuseListings = false) {
         this.beginLexicalTransaction();
-        const next = resolveWatchTopology(this.options, this.extraInputs, this.lexicalIdentities, this.getCompilerInputs);
+        const listings = new Map();
+        const next = resolveWatchTopology(this.options, this.extraInputs, this.lexicalIdentities, (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_1.WatchPaths.mapsEqual(this.reloadFiles, next.reloadFiles) &&
             WatchPaths_1.WatchPaths.mapsEqual(this.outputFiles, next.outputFiles) &&
             WatchPaths_1.WatchPaths.mapsEqual(this.outputs, next.outputs)
             ? compilerMembershipChange(this.files, next.files)
             : [];
-        const projectInputProgramOverlap = projectInputCompilerMembershipChange(this.projectInputs, compilerProgramMembershipChange);
+        const projectInputProgramOverlap = projectInputCompilerMembershipChange(this.projectInputs, compilerProgramMembershipChange, this.projectInputIdentities());
         const projectInputProgramChange = compilerProgramMembershipChange.length !== 0 &&
             projectInputProgramOverlap.length ===
                 compilerProgramMembershipChange.length
@@ -260,7 +333,7 @@ class WatchTopology {
      */
     acknowledgeProjectInputCompilerMembership(changed) {
         const matches = this.collectProjectInputMatches();
-        const fingerprints = fingerprintProjectInputMatches(matches, this.readDirectory);
+        const { fingerprints, snapshots } = fingerprintProjectInputMatches(matches, this.readDirectory);
         const changedInputs = projectInputChangedPaths({
             next: matches,
             nextFingerprints: fingerprints,
@@ -268,7 +341,7 @@ class WatchTopology {
             previousFingerprints: this.projectInputFingerprints,
         });
         const population = this.projectInputPopulation();
-        const causedBy = projectInputCompilerMembershipProjectChanges(changed, population.globs);
+        const causedBy = projectInputCompilerMembershipProjectChanges(changed, population.globs, this.projectInputIdentities());
         const reloadInput = {
             causedBy,
             changed: causedBy.length === 1 ? causedBy[0] : undefined,
@@ -277,7 +350,7 @@ class WatchTopology {
             reloadDirectories: population.reloadDirectories,
             reloadFiles: population.reloadFiles ?? [],
         };
-        const reload = (0, projectInputReloadEventShouldNotify_1.projectInputReloadEventShouldNotify)(reloadInput);
+        const reload = (0, projectInputReloadEventShouldNotify_1.projectInputReloadEventShouldNotify)(reloadInput, this.projectInputIdentities());
         reportProjectInputDecision({
             source: "compiler-membership",
             ...reloadInput,
@@ -289,6 +362,7 @@ class WatchTopology {
         // instead of disappearing behind the warm compiler-membership handoff.
         this.projectInputMatches = matches;
         this.projectInputFingerprints = fingerprints;
+        this.projectInputFileSnapshots = snapshots;
         return reload;
     }
     /**
@@ -313,8 +387,8 @@ 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.
      */
     setExtraInputs(inputs, identities) {
@@ -337,7 +411,12 @@ class WatchTopology {
                 pluginInputState(input, this.pluginInputIdentities));
         }
         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);
     }
     /**
      * Reconcile project-rule dependencies, retaining absent files and empty glob
@@ -353,7 +432,8 @@ 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.
      */
     setProjectInputs(inputs) {
-        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
@@ -362,7 +442,7 @@ 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;
         }
@@ -374,7 +454,9 @@ class WatchTopology {
             { ...(inputs.declared ?? inputs), root: inputs.root },
         ]);
         this.projectInputMatches = this.collectProjectInputMatches();
-        this.projectInputFingerprints = fingerprintProjectInputMatches(this.projectInputMatches, this.readDirectory);
+        const baseline = fingerprintProjectInputMatches(this.projectInputMatches, this.readDirectory);
+        this.projectInputFingerprints = baseline.fingerprints;
+        this.projectInputFileSnapshots = baseline.snapshots;
         this.syncProjectInputWatchers();
     }
     /**
@@ -406,10 +488,24 @@ class WatchTopology {
     }
     /** Start fresh native case observations for one synchronous watch decision. */
     beginLexicalTransaction() {
+        this.caseObservations = this.observeCaseSensitivity();
         this.lexicalIdentities = (0, createProjectInputPathIdentityContext_1.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).
+     */
+    projectInputIdentities() {
+        return (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
+            caseSensitive: this.caseObservations,
+        });
+    }
     /** Keep lexical alias ownership while sharing this decision's case probes. */
     pathKey(location) {
         return WatchPaths_1.WatchPaths.pathKey(location, this.lexicalIdentities);
@@ -487,32 +583,93 @@ class WatchTopology {
                 }
             }
         }
-        (0, syncWatchers_1.syncWatchers)(this.directoryWatchers, desired, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), process.platform === "win32", (event, filename, gap) => {
-            this.beginLexicalTransaction();
-            const changed = filename === null ? undefined : node_path_1.default.resolve(location, filename);
-            const pluginInput = changed ?? location;
-            if (this.isPluginInput(pluginInput)) {
-                this.notePluginNotification(pluginInput);
-                return;
-            }
-            const plan = (0, planCompilerDirectoryWatchEvent_1.planCompilerDirectoryWatchEvent)({
-                changed,
-                event,
-                exists: node_fs_1.default.existsSync,
-                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);
-        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
+        (0, syncWatchers_1.syncWatchers)(this.directoryWatchers, desired, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), process.platform === "win32", (event, filename, gap) => this.deferNotification({
+            gap: gap === true,
+            lane: "compiler",
+            location,
+            changed: filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename),
+            rename: event === "rename",
+        })), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
         return [...this.directoryWatchers].some(([key, watcher]) => previous.get(key) !== watcher);
     }
+    /**
+     * 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.
+     */
+    deferNotification(notification) {
+        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());
+    }
+    decideNotifications() {
+        this.notificationsScheduled = false;
+        const pending = [...this.pendingNotifications.values()];
+        this.pendingNotifications.clear();
+        if (this.closed)
+            return;
+        const refreshes = [];
+        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. */
+    decideCompilerDirectoryNotification(notification, refreshes) {
+        this.beginLexicalTransaction();
+        const { changed, location } = notification;
+        const pluginInput = changed ?? location;
+        if (this.isPluginInput(pluginInput)) {
+            this.notePluginNotification(pluginInput);
+            return;
+        }
+        const plan = (0, planCompilerDirectoryWatchEvent_1.planCompilerDirectoryWatchEvent)({
+            changed,
+            event: notification.rename ? "rename" : "change",
+            exists: node_fs_1.default.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.
      *
@@ -607,6 +764,7 @@ class WatchTopology {
             if (node_fs_1.default.existsSync(location)) {
                 if (this.projectInputMatches.size !== 0) {
                     const key = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
+                        caseSensitive: this.caseObservations,
                         throwOnRealpathError: false,
                     }).resolve(location).key;
                     if (this.projectInputMatches.has(key) &&
@@ -701,7 +859,7 @@ class WatchTopology {
             return;
         const previous = new Map(this.projectInputWatchers);
         const previousLinks = new Map(this.projectInputLinkWatchers);
-        const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+        const identities = this.projectInputIdentities();
         const desired = new Map();
         const required = new Map();
         for (const file of this.projectInputDeclarations("file")) {
@@ -737,10 +895,15 @@ class WatchTopology {
             active.set(identity.key, identity.path);
         }
         this.projectInputRequiredWatchRoots = required;
-        (0, syncWatchers_1.syncWatchers)(this.projectInputWatchers, active, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), true, (_event, filename) => {
-            const changed = filename === null ? undefined : node_path_1.default.resolve(location, filename);
-            this.refreshProjectInputs(location, changed);
-        }), (location, error) => {
+        (0, syncWatchers_1.syncWatchers)(this.projectInputWatchers, active, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), true, (_event, filename) => this.deferNotification({
+            gap: false,
+            lane: "project-input",
+            location,
+            changed: filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename),
+            rename: false,
+        })), (location, error) => {
             const key = identities.resolve(location).key;
             const firstFailure = !this.projectInputRejectedWatchRoots.has(key);
             this.projectInputRejectedWatchRoots.add(key);
@@ -796,10 +959,15 @@ class WatchTopology {
                 desired.set(identities.resolve(parent).key, parent);
             }
         }
-        (0, syncWatchers_1.syncWatchers)(this.projectInputLinkWatchers, desired, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), false, (_event, filename) => {
-            const changed = filename === null ? undefined : node_path_1.default.resolve(location, filename);
-            this.refreshProjectInputs(location, changed);
-        }), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
+        (0, syncWatchers_1.syncWatchers)(this.projectInputLinkWatchers, desired, (location) => this.openDirectoryWatch(watcherRegistrationPath(location), false, (_event, filename) => this.deferNotification({
+            gap: false,
+            lane: "project-input",
+            location,
+            changed: filename === null
+                ? undefined
+                : node_path_1.default.resolve(location, filename),
+            rename: false,
+        })), (location, error) => this.callbacks.onError(location, error), () => this.closed === false);
     }
     /** Drop the watcher that just reported a directory replacement. */
     retireProjectInputWatcher(location, identities) {
@@ -857,6 +1025,7 @@ class WatchTopology {
             return;
         this.projectInputRecoveryScheduled = true;
         queueMicrotask(() => {
+            this.beginLexicalTransaction();
             try {
                 let previousRejectionCount = -1;
                 while (this.closed === false &&
@@ -895,6 +1064,7 @@ class WatchTopology {
             this.projectInputPostRegistrationReconciliationScheduled = false;
             if (this.closed)
                 return;
+            this.beginLexicalTransaction();
             this.refreshPublishedProjectInputIdentities();
             this.refreshProjectInputs(this.projectInputs.root, undefined, true);
         });
@@ -908,8 +1078,9 @@ class WatchTopology {
      * that must observe later target changes.
      */
     refreshPublishedProjectInputIdentities() {
-        const next = normalizeProjectInputSnapshot(this.declaredProjectInputs);
-        if (projectInputSnapshotsEqual(this.projectInputs, next))
+        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]);
@@ -997,7 +1168,7 @@ class WatchTopology {
         const retained = this.projectInputWatchRoots.get(key);
         if (retained !== undefined && WatchPaths_1.WatchPaths.isDirectory(retained))
             return retained;
-        const resolved = ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputRecursiveWatchRoot(target, this.projectInputs.root);
+        const resolved = ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputRecursiveWatchRoot(target, this.projectInputs.root, this.projectInputIdentities());
         if (resolved !== undefined)
             this.projectInputWatchRoots.set(key, resolved);
         return resolved;
@@ -1006,7 +1177,7 @@ class WatchTopology {
         this.beginLexicalTransaction();
         try {
             const previous = this.projectInputMatches;
-            const identities = (0, createProjectInputPathIdentityContext_1.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.
@@ -1033,12 +1204,25 @@ class WatchTopology {
             }
             const next = this.collectProjectInputMatches();
             const membershipChanged = WatchPaths_1.WatchPaths.mapsEqual(previous, next) === false;
-            const nextFingerprints = changed === undefined ||
+            // 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_1.WatchPaths.mapsEqual(this.projectInputFingerprints, nextFingerprints) === false;
             const changedInputs = projectInputChangedPaths({
                 next,
@@ -1065,7 +1249,7 @@ class WatchTopology {
                 reloadDirectories: population.reloadDirectories ?? [],
                 reloadFiles: population.reloadFiles ?? [],
             };
-            const reload = (0, projectInputReloadEventShouldNotify_1.projectInputReloadEventShouldNotify)(reloadInput);
+            const reload = (0, projectInputReloadEventShouldNotify_1.projectInputReloadEventShouldNotify)(reloadInput, identities);
             const invalidate = (0, projectInputMembershipInvalidatesProgram_1.projectInputMembershipInvalidatesProgram)({
                 changed: reconciledChange,
                 changedInputs,
@@ -1075,6 +1259,7 @@ 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
@@ -1126,7 +1311,7 @@ class WatchTopology {
         }
     }
     collectProjectInputMatches() {
-        const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+        const identities = this.projectInputIdentities();
         const matches = new Map();
         // Both spellings are scanned, and each is resolved here rather than when
         // the snapshot arrived. A declaration reached through a symlink otherwise
@@ -1207,20 +1392,81 @@ class WatchTopology {
         return matches;
     }
     refreshFromDirectory(location, changed) {
-        if (changed !== undefined &&
-            WatchPaths_1.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.
+     */
+    refreshFromDirectories(refreshes) {
+        for (const { changed } of refreshes) {
+            if (changed !== undefined &&
+                WatchPaths_1.WatchPaths.isDirectory(changed) &&
+                this.isCompilerOutputDirectory(changed) === false &&
+                this.isProjectInputDirectory(changed) === false) {
+                this.observedDirectories.set(this.pathKey(changed), changed);
+            }
         }
+        let refreshFailure;
         try {
             this.refresh(true);
         }
         catch (error) {
-            for (const reload of (0, reloadInputsForFailedTopologyRefresh_1.reloadInputsForFailedTopologyRefresh)(this.reloadFiles.values(), changed, this.lexicalIdentities)) {
-                this.callbacks.onInputChange({ kind: "config", path: reload });
+            refreshFailure = { error };
+        }
+        try {
+            if (this.closed)
+                return;
+            const changed = [];
+            const rearm = [];
+            const reported = new Set();
+            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 (0, reloadInputsForFailedTopologyRefresh_1.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);
         }
     }
     isCompilerOutputDirectory(location) {
@@ -1265,7 +1511,7 @@ class WatchTopology {
     }
     isProjectInputDirectory(location) {
         const resolved = node_path_1.default.resolve(location);
-        const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+        const identities = this.projectInputIdentities();
         return (this.projectInputs.files.some((file) => identities.isWithin(resolved, file) ||
             identities.isWithin(node_path_1.default.dirname(file), resolved)) ||
             (this.projectInputs.reloadFiles ?? []).some((file) => identities.isWithin(resolved, file) ||
@@ -1378,6 +1624,23 @@ class WatchTopology {
     }
 }
 exports.WatchTopology = WatchTopology;
+/**
+ * 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, options) {
+    return JSON.stringify([
+        project.path,
+        project.root,
+        options.binary ?? null,
+        options.compilerArgsCwd ?? null,
+        options.env ?? null,
+        options.passthrough ?? null,
+        options.pinCompilerProject ?? null,
+    ]);
+}
 function resolveWatchTopology(options, extraInputs, identities, getCompilerInputs) {
     const selection = CompilerProjectSelection_1.CompilerProjectSelection.read(options);
     if (selection.inspectionError !== undefined)
@@ -1506,10 +1769,11 @@ function readProjectReferences(tsconfig) {
     return references;
 }
 function listCompilerInputs(project, options) {
+    const env = SidecarEnvironment_1.SidecarEnvironment.merge(process.env, options.env);
     const tsgo = (0, resolveTsgo_1.resolveTsgo)({
         binary: options.binary,
         cwd: project.root,
-        env: options.env,
+        env,
     });
     const result = (0, spawnNative_1.spawnNative)(tsgo.binary, [
         "-p",
@@ -1521,7 +1785,7 @@ function listCompilerInputs(project, options) {
         ...(options.pinCompilerProject === true ? ["-p", project.path] : []),
     ], {
         cwd: options.compilerArgsCwd ?? project.root,
-        env: { ...process.env, ...options.env },
+        env,
         encoding: "utf8",
     });
     if (result.error) {
@@ -1811,8 +2075,7 @@ function uniqueExistingPaths(paths, identities) {
     }
     return [...unique.values()];
 }
-function normalizeProjectInputSnapshot(snapshot) {
-    const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+function normalizeProjectInputSnapshot(snapshot, identities) {
     const files = new Map();
     const globs = new Map();
     const reloadDirectories = new Map();
@@ -1841,8 +2104,7 @@ function normalizeProjectInputSnapshot(snapshot) {
         root: identities.resolve(snapshot.root).path,
     };
 }
-function projectInputSnapshotsEqual(left, right) {
-    const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+function projectInputSnapshotsEqual(left, right, identities) {
     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.
@@ -1885,7 +2147,7 @@ function isSymbolicLink(location) {
         return false;
     }
 }
-function matchesProjectInput(snapshot, location, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)()) {
+function matchesProjectInput(snapshot, location, identities) {
     const key = identities.resolve(location).key;
     return (snapshot.files.some((file) => identities.resolve(file).key === key) ||
         (snapshot.reloadFiles ?? []).some((file) => identities.resolve(file).key === key) ||
@@ -1971,8 +2233,7 @@ function compilerMembershipChange(previous, next) {
     }
     return [...changed.values()].sort();
 }
-function projectInputCompilerMembershipChange(snapshot, changed) {
-    const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+function projectInputCompilerMembershipChange(snapshot, changed, identities) {
     return changed.filter((location) => matchesProjectInput(snapshot, location, identities) &&
         ProjectInputWatchRules_1.ProjectInputWatchRules.projectInputPathMayAffectProgram(location));
 }
@@ -1985,8 +2246,7 @@ function projectInputCompilerMembershipChange(snapshot, changed) {
  * immediate-entry delta instead of turning ordinary project data into a cold
  * selection reload. The deepest matching glob owns the most specific delivery.
  */
-function projectInputCompilerMembershipProjectChanges(locations, globs) {
-    const identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)();
+function projectInputCompilerMembershipProjectChanges(locations, globs, identities) {
     const roots = globs.map((glob) => identities.resolve((0, literalGlobRoot_1.literalGlobRoot)(glob)));
     const changes = new Map();
     for (const location of locations) {
@@ -2003,14 +2263,39 @@ function projectInputCompilerMembershipProjectChanges(locations, globs) {
     }
     return [...changes.values()].sort();
 }
-function fingerprintProjectInputMatches(matches, readDirectory) {
+/**
+ * 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, readDirectory, previous) {
     const fingerprints = new Map();
+    const snapshots = new Map();
     for (const [key, location] of matches) {
-        fingerprints.set(key, WatchPaths_1.WatchPaths.isDirectory(location)
-            ? fingerprintProjectInputDirectory(location, readDirectory)
-            : fingerprintProjectInputFile(location));
-    }
-    return fingerprints;
+        if (WatchPaths_1.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) {
     try {
@@ -2052,7 +2337,7 @@ function fingerprintProjectInputDirectory(location, readDirectory) {
         return "";
     }
 }
-function matchesProjectInputGlob(pattern, location, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)()) {
+function matchesProjectInputGlob(pattern, location, identities) {
     const root = identities.resolve((0, literalGlobRoot_1.literalGlobRoot)(pattern));
     const candidate = identities.resolve(location);
     if (!(0, isProjectInputPathIdentityWithin_1.isProjectInputPathIdentityWithin)(root.key, candidate.key))