@ttsc/unplugin 0.30.3 → 0.30.4

package/lib/core/viteServe.mjs

@@ -1,38 +1,180 @@
-import { watch } from 'chokidar';
 import fs from 'node:fs';
 import path from 'node:path';
+import { createFilesystemPathIdentityContext } from 'ttsc/path-identity';
 import { captureWatchInputBaseline, validateGraphInputObservation, watchInputEvidenceMatchesBaseline, pathIdentityKey } from './transform.mjs';
 
 /**
- * One filesystem subscription per unique input, shared by all served modules.
+ * A bounded recursive filesystem observer shared by all served modules.
  *
  * Vite resolves transform-context addWatchFile as a runtime import, including
  * type-only .server files and non-module plugin assets. Use a separate watcher
  * for compiler inputs, including node_modules, which Vite's watcher ignores.
  * Ordinary files use events after their initial subscription is observed.
- * Missing spellings and directory predicates keep a shared predicate poll.
- * Linked files also share topology checks by directory because retargeting a
- * junction need not emit events on its previously watched descendants.
+ * Missing spellings and directory predicates use the recursive observer for
+ * their nearest available scope. Inputs a native scope cannot safely cover
+ * share one bounded fallback poll; linked files also share topology checks
+ * because retargeting a junction need not emit events on its old descendants.
  */
-function createViteServeInputWatch() {
+function createViteServeInputWatch(operations = {}) {
     const entries = new Map();
+    const aliases = new Map();
+    const renameAliases = new Map();
     const importerInputs = new Map();
     const pending = new Set();
+    const polled = new Set();
     const links = new Map();
+    const scopes = new Map();
+    const componentLinks = new Map();
+    const missingComponents = new Set();
+    const changes = new Map();
     let server;
-    let watcher;
+    let projectRoot;
+    let changeSequence = 0;
+    let historyFloor = 0;
+    let linkIterator;
+    let pollIterator;
     let poller;
     let flushTimer;
-    let failed = false;
+    const open = operations.watch ?? openRecursiveWatch;
+    const openPoller = operations.poll ?? openWatchPoller;
+    const platform = operations.platform ?? process.platform;
+    const createCaseIdentities = () => createFilesystemPathIdentityContext({
+        ...(operations.caseSensitive === undefined
+            ? {}
+            : { caseSensitive: operations.caseSensitive }),
+        platform,
+        throwOnRealpathError: false,
+    });
+    let caseIdentities = createCaseIdentities();
+    const directoryCaseSensitivity = new Map();
+    let pathIdentityMemosDirty = false;
+    /** Drop path facts after topology or ownership changes make them stale. */
+    const resetPathIdentityMemos = () => {
+        caseIdentities = createCaseIdentities();
+        directoryCaseSensitivity.clear();
+        pathIdentityMemosDirty = false;
+    };
+    /** Lexical event key under the nearest existing directory's case policy. */
+    const watchPathKey = (file) => {
+        const absolute = path.resolve(file);
+        if (platform !== "win32" && platform !== "darwin") {
+            return absolute;
+        }
+        let current = path.dirname(absolute);
+        const traversed = [];
+        let sensitive;
+        for (;;) {
+            const cacheKey = platform === "win32" ? current.toLowerCase() : current;
+            sensitive = directoryCaseSensitivity.get(cacheKey);
+            if (sensitive !== undefined)
+                break;
+            traversed.push(cacheKey);
+            try {
+                if (fs.statSync(current).isDirectory()) {
+                    sensitive = caseIdentities.caseSensitive(current);
+                    break;
+                }
+            }
+            catch {
+                // A missing suffix inherits the nearest existing ancestor's policy.
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                // The shared identity resolver uses the platform default when even the
+                // volume root cannot answer the read-only case-sensitivity probe.
+                sensitive = caseIdentities.caseSensitive(current);
+                break;
+            }
+            current = parent;
+        }
+        for (const directory of traversed) {
+            directoryCaseSensitivity.set(directory, sensitive);
+        }
+        return sensitive ? absolute : absolute.toLowerCase();
+    };
+    const unbindAlias = (alias, entry) => {
+        const indexed = aliases.get(alias);
+        indexed?.delete(entry);
+        if (indexed?.size === 0)
+            aliases.delete(alias);
+    };
+    const closeScope = (scope) => {
+        scopes.delete(watchPathKey(scope.root));
+        try {
+            scope.watcher?.close();
+        }
+        catch {
+            // The generation no longer trusts this scope, so cleanup is best effort.
+        }
+        scope.watcher = undefined;
+    };
+    const recordChange = (eventType, file) => {
+        const absolute = path.resolve(file);
+        const parent = path.dirname(absolute);
+        const direct = new Set();
+        const parents = new Set();
+        if (eventType === "rename") {
+            // Keep the active identity context until affected entries are removed.
+            // Their alias and scope indexes were built with that context; changing
+            // only the resolver here could make later events unable to reach them.
+            // `check()` resets the memos atomically if this topology change removes
+            // an entry, while unrelated renames leave still-valid indexes intact.
+            componentLinks.clear();
+            missingComponents.clear();
+        }
+        changeSequence += 1;
+        direct.add(watchPathKey(absolute));
+        parents.add(watchPathKey(parent));
+        for (const key of direct) {
+            componentLinks.delete(key);
+            missingComponents.delete(key);
+            changes.set(key, changeSequence);
+        }
+        for (const key of parents)
+            changes.set(key, changeSequence);
+        if (changes.size > MAX_CHANGE_HISTORY) {
+            changes.clear();
+            historyFloor = changeSequence;
+        }
+        return { direct, parent: parents };
+    };
     const remove = (entry) => {
         entries.delete(entry.file);
-        watcher?.unwatch(entry.file);
+        pending.delete(entry);
+        polled.delete(entry);
+        for (const alias of entry.aliases)
+            unbindAlias(alias, entry);
+        entry.aliases.clear();
+        for (const alias of entry.renameAliases) {
+            const indexed = renameAliases.get(alias);
+            indexed?.delete(entry);
+            if (indexed?.size === 0)
+                renameAliases.delete(alias);
+        }
+        entry.renameAliases.clear();
+        for (const scope of entry.scopes) {
+            scope.entries.delete(entry);
+            if (scope.entries.size === 0 && !scope.pinned)
+                closeScope(scope);
+        }
+        entry.scopes.clear();
         for (const file of entry.links) {
             const link = links.get(file);
             link?.inputs.delete(entry);
             if (link?.inputs.size === 0)
                 links.delete(file);
         }
+        entry.links.clear();
+        // Component resolution is only an observation-time optimization. Entries
+        // can introduce arbitrary missing ancestors, so discard the shared memo
+        // when one leaves rather than retaining its path components indefinitely.
+        componentLinks.clear();
+        missingComponents.clear();
+        if (links.size === 0)
+            linkIterator = undefined;
+        if (polled.size === 0)
+            pollIterator = undefined;
+        pathIdentityMemosDirty = true;
     };
     const check = (selected) => {
         const importers = new Set();
@@ -67,20 +209,50 @@ function createViteServeInputWatch() {
                 remove(entry);
             }
         }
+        if (pathIdentityMemosDirty)
+            resetPathIdentityMemos();
+        updatePoller();
         if (server !== undefined && importers.size !== 0) {
             invalidateImporters(server, importers);
             sendFullReload(server);
         }
     };
-    const enqueue = (file, observed) => {
+    const enqueue = (eventType, file) => {
         const absolute = path.resolve(file);
-        const direct = entries.get(absolute);
-        if (direct !== undefined && observed)
-            direct.observed = true;
-        for (const candidate of [absolute, path.dirname(absolute)]) {
-            const entry = entries.get(candidate);
-            if (entry !== undefined)
+        const eventKeys = recordChange(eventType, absolute);
+        for (const key of eventKeys.direct) {
+            for (const entry of aliases.get(key) ?? []) {
+                entry.changedAt = changeSequence;
                 pending.add(entry);
+            }
+        }
+        for (const key of eventKeys.parent) {
+            for (const entry of aliases.get(key) ?? []) {
+                entry.changedAt = changeSequence;
+                pending.add(entry);
+            }
+        }
+        if (eventType === "rename") {
+            const exact = new Set();
+            for (const key of eventKeys.direct) {
+                for (const entry of renameAliases.get(key) ?? [])
+                    exact.add(entry);
+            }
+            // Linux may report only the destination spelling of a directory rename.
+            // That spelling cannot be indexed before the move. Fall back to the
+            // renamed entry's parent only when no exact old spelling matched; the
+            // baseline check below still invalidates solely inputs that really moved.
+            const selected = exact;
+            if (selected.size === 0) {
+                for (const key of eventKeys.parent) {
+                    for (const entry of renameAliases.get(key) ?? [])
+                        selected.add(entry);
+                }
+            }
+            for (const entry of selected) {
+                entry.changedAt = changeSequence;
+                pending.add(entry);
+            }
         }
         if (pending.size === 0 || flushTimer !== undefined)
             return;
@@ -92,67 +264,294 @@ function createViteServeInputWatch() {
         }, 0);
         flushTimer.unref();
     };
-    const ensureWatcher = () => {
-        if (watcher !== undefined)
-            return watcher;
-        // Chokidar's persistent:false backend omits its native error listener on
-        // Windows. Keep the owned subscription alive until dispose() closes it.
-        const active = watch([], { depth: 0, ignoreInitial: false });
-        watcher = active;
-        // Initial add events compare compiler-time evidence too: an edit between
-        // compilation and asynchronous watcher setup must not be missed.
-        active.on("all", (event, file) => {
-            if (watcher === active)
-                enqueue(file, event === "add" || event === "addDir");
-        });
-        active.on("error", () => {
-            if (watcher === active)
-                failed = true;
-        });
-        poller = setInterval(() => {
-            const selected = new Set([...entries.values()].filter((entry) => failed || entry.poll || !entry.observed));
+    const bindAlias = (entry, alias) => {
+        alias = watchPathKey(alias);
+        if (entry.aliases.has(alias))
+            return;
+        entry.aliases.add(alias);
+        let indexed = aliases.get(alias);
+        if (indexed === undefined) {
+            indexed = new Set();
+            aliases.set(alias, indexed);
+        }
+        indexed.add(entry);
+    };
+    const bindRenameAncestors = (entry, file) => {
+        let current = path.dirname(path.resolve(file));
+        for (;;) {
+            const key = watchPathKey(current);
+            if (!entry.renameAliases.has(key)) {
+                entry.renameAliases.add(key);
+                let indexed = renameAliases.get(key);
+                if (indexed === undefined) {
+                    indexed = new Set();
+                    renameAliases.set(key, indexed);
+                }
+                indexed.add(entry);
+            }
+            const parent = path.dirname(current);
+            if (parent === current)
+                return;
+            current = parent;
+        }
+    };
+    const ensureScope = (root, external, pinned = false) => {
+        root = path.resolve(root);
+        const key = watchPathKey(root);
+        let scope = scopes.get(key);
+        if (scope === undefined) {
+            if (external &&
+                [...scopes.values()].filter((candidate) => !candidate.pinned).length >=
+                    MAX_EXTERNAL_WATCH_SCOPES)
+                return undefined;
+            // Opening a scope is itself an observation boundary. Advance the same
+            // sequence returned by begin() so an external scope first discovered
+            // after compilation cannot claim it was already live at that token when
+            // no filesystem event happened in between.
+            changeSequence += 1;
+            scope = {
+                entries: new Set(),
+                failed: false,
+                pinned,
+                root,
+                startedAt: changeSequence,
+            };
+            scopes.set(key, scope);
+            try {
+                const owned = scope;
+                scope.watcher = open(root, (eventType, file) => {
+                    if (scopes.get(key) !== owned)
+                        return;
+                    if (file === null) {
+                        resetPathIdentityMemos();
+                        changeSequence += 1;
+                        historyFloor = changeSequence;
+                        changes.clear();
+                        for (const candidate of owned.entries) {
+                            candidate.changedAt = changeSequence;
+                            pending.add(candidate);
+                        }
+                        scheduleFlush();
+                        return;
+                    }
+                    enqueue(eventType, path.isAbsolute(file) ? file : path.resolve(root, file));
+                }, () => {
+                    if (scopes.get(key) !== owned)
+                        return;
+                    owned.failed = true;
+                    try {
+                        owned.watcher?.close();
+                    }
+                    catch {
+                        // The fallback owns validation now; a failed native handle is no
+                        // longer useful, and cleanup must not replace that recovery.
+                    }
+                    owned.watcher = undefined;
+                    for (const entry of owned.entries)
+                        requirePolling(entry);
+                    updatePoller();
+                });
+                if (scope.failed) {
+                    // An injected or platform watcher may report failure synchronously
+                    // during construction, before its handle can be assigned above.
+                    try {
+                        scope.watcher?.close();
+                    }
+                    catch { }
+                    scope.watcher = undefined;
+                }
+            }
+            catch {
+                scope.failed = true;
+            }
+        }
+        else if (pinned) {
+            scope.pinned = true;
+        }
+        return scope;
+    };
+    const bindScope = (root, entry, external) => {
+        const scope = ensureScope(root, external);
+        if (scope === undefined)
+            return false;
+        scope.entries.add(entry);
+        entry.scopes.add(scope);
+        return !scope.failed;
+    };
+    function requirePolling(entry) {
+        entry.fallback = true;
+        if (polled.size === 0)
+            pollIterator = undefined;
+        polled.add(entry);
+    }
+    const scheduleFlush = () => {
+        if (pending.size === 0 || flushTimer !== undefined)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            const selected = [...pending];
+            pending.clear();
+            check(selected);
+        }, 0);
+        flushTimer.unref();
+    };
+    function updatePoller() {
+        const needed = links.size !== 0 || polled.size !== 0;
+        if (!needed) {
+            poller?.close();
+            poller = undefined;
+            return;
+        }
+        if (poller !== undefined)
+            return;
+        poller = openPoller(() => {
+            const selected = new Set();
+            for (let count = 0; count < MAX_FALLBACK_PROBES_PER_TICK && polled.size !== 0; count += 1) {
+                pollIterator ??= polled.values();
+                let next = pollIterator.next();
+                if (next.done) {
+                    pollIterator = polled.values();
+                    next = pollIterator.next();
+                }
+                if (next.done)
+                    break;
+                selected.add(next.value);
+            }
             // Files reached through one linked directory share one topology check.
             // Content edits remain event-driven; retargeting a junction does not
-            // reliably emit an event on its previously watched descendants.
-            for (const [file, link] of links) {
+            // reliably emit an event on its previously watched descendants. Reconcile
+            // a fixed-size slice as a safety net; ordinary retargets arrive at once
+            // through the project-root observer, while even an enormous dependency
+            // graph has constant idle CPU cost.
+            for (let count = 0; count < MAX_LINK_PROBES_PER_TICK && links.size !== 0; count += 1) {
+                linkIterator ??= links.entries();
+                let next = linkIterator.next();
+                if (next.done) {
+                    linkIterator = links.entries();
+                    next = linkIterator.next();
+                }
+                if (next.done)
+                    break;
+                const [file, link] = next.value;
                 const target = realpath(file);
                 if (target !== link.target) {
                     link.target = target;
                     for (const entry of link.inputs) {
                         selected.add(entry);
-                        entry.observed = false;
-                        active.unwatch(entry.file);
-                        active.add(entry.file);
                     }
                 }
             }
             check(selected);
-        }, 500);
-        poller.unref();
-        return watcher;
+        });
+    }
+    const observe = (entry) => {
+        bindAlias(entry, entry.file);
+        bindRenameAncestors(entry, entry.file);
+        const root = projectRoot;
+        if (root !== undefined && containsPath(root, entry.file)) {
+            if (!bindScope(root, entry, false))
+                requirePolling(entry);
+        }
+        else {
+            const external = nearestExistingDirectory(entry.file);
+            if (external === undefined || !bindScope(external, entry, true))
+                requirePolling(entry);
+        }
+        const target = realpath(entry.file);
+        if (hasMultipleLinks(entry.file))
+            requirePolling(entry);
+        if (target !== undefined) {
+            bindAlias(entry, target);
+            bindRenameAncestors(entry, target);
+            if (!sameSpelling(entry.file, target)) {
+                let link = links.get(entry.file);
+                if (link === undefined) {
+                    link = { target, inputs: new Set() };
+                    if (links.size === 0)
+                        linkIterator = undefined;
+                    links.set(entry.file, link);
+                }
+                link.inputs.add(entry);
+                entry.links.add(entry.file);
+                if (root === undefined || !containsPath(root, target)) {
+                    const targetRoot = nearestExistingDirectory(target);
+                    if (targetRoot === undefined || !bindScope(targetRoot, entry, true))
+                        requirePolling(entry);
+                }
+            }
+        }
+        if (root !== undefined) {
+            for (const linkedFile of linkedComponents(entry.file, root, componentLinks, missingComponents, watchPathKey)) {
+                bindAlias(entry, linkedFile);
+                let link = links.get(linkedFile);
+                if (link === undefined) {
+                    link = { target: realpath(linkedFile), inputs: new Set() };
+                    if (links.size === 0)
+                        linkIterator = undefined;
+                    links.set(linkedFile, link);
+                }
+                link.inputs.add(entry);
+                entry.links.add(linkedFile);
+                if (link.target === undefined)
+                    requirePolling(entry);
+                else if (!containsPath(root, link.target) &&
+                    !bindScope(link.target, entry, true))
+                    requirePolling(entry);
+            }
+        }
     };
     return {
         attach(next) {
             server = next;
+            projectRoot = path.resolve(next.config?.root ?? process.cwd());
+            ensureScope(projectRoot, false, true);
+        },
+        begin() {
+            return changeSequence;
         },
         async dispose() {
             entries.clear();
+            aliases.clear();
+            renameAliases.clear();
             importerInputs.clear();
             pending.clear();
+            polled.clear();
             links.clear();
-            if (poller !== undefined)
-                clearInterval(poller);
+            componentLinks.clear();
+            missingComponents.clear();
+            changes.clear();
+            linkIterator = undefined;
+            pollIterator = undefined;
+            poller?.close();
             if (flushTimer !== undefined)
                 clearTimeout(flushTimer);
             poller = undefined;
             flushTimer = undefined;
-            const closing = watcher;
-            watcher = undefined;
-            failed = false;
-            await closing?.close();
+            for (const scope of [...scopes.values()])
+                closeScope(scope);
+            resetPathIdentityMemos();
             // Retain the attached server across overlapping Vite restart containers.
         },
-        replace(importer, inputs, failed = false) {
+        forget(importer) {
+            importer = path.resolve(importer);
+            const previous = importerInputs.get(importer);
+            if (previous === undefined)
+                return;
+            importerInputs.delete(importer);
+            for (const [file, key] of previous) {
+                const entry = entries.get(file);
+                const condition = entry?.conditions.get(key);
+                condition?.importers.delete(importer);
+                if (condition?.importers.size === 0)
+                    entry?.conditions.delete(key);
+                if (entry?.conditions.size === 0)
+                    remove(entry);
+            }
+            if (pathIdentityMemosDirty)
+                resetPathIdentityMemos();
+            updatePoller();
+        },
+        replace(importer, inputs, failed = false, startedAt) {
             if (server === undefined)
                 return;
             importer = path.resolve(importer);
@@ -170,7 +569,8 @@ function createViteServeInputWatch() {
                 ];
             }
             const current = new Map();
-            const added = [];
+            const added = new Set();
+            const touched = new Set();
             for (const input of inputs) {
                 const file = path.resolve(input.file);
                 const evidence = input.evidence;
@@ -179,38 +579,20 @@ function createViteServeInputWatch() {
                 let entry = entries.get(file);
                 if (entry === undefined) {
                     entry = {
+                        aliases: new Set(),
+                        changedAt: 0,
                         file,
                         conditions: new Map(),
-                        poll: false,
-                        observed: false,
+                        fallback: false,
                         links: new Set(),
+                        renameAliases: new Set(),
+                        scopes: new Set(),
                     };
                     entries.set(file, entry);
-                    added.push(file);
-                    const directory = path.dirname(file);
-                    const directoryTarget = realpath(directory);
-                    const fileTarget = realpath(file);
-                    const linked = [
-                        ...(directoryTarget !== undefined &&
-                            !sameSpelling(directory, directoryTarget)
-                            ? [directory]
-                            : []),
-                        ...(fileTarget !== undefined &&
-                            directoryTarget !== undefined &&
-                            !sameSpelling(fileTarget, path.join(directoryTarget, path.basename(file)))
-                            ? [file]
-                            : []),
-                    ];
-                    for (const linkedFile of linked) {
-                        let link = links.get(linkedFile);
-                        if (link === undefined) {
-                            link = { target: realpath(linkedFile), inputs: new Set() };
-                            links.set(linkedFile, link);
-                        }
-                        link.inputs.add(entry);
-                        entry.links.add(linkedFile);
-                    }
+                    added.add(entry);
+                    observe(entry);
                 }
+                touched.add(entry);
                 let condition = entry.conditions.get(key);
                 if (condition === undefined) {
                     condition = {
@@ -223,18 +605,6 @@ function createViteServeInputWatch() {
                     entry.conditions.set(key, condition);
                 }
                 condition.importers.add(importer);
-                const observation = evidence?.state?.codec === "predicates"
-                    ? evidence.state.observation
-                    : undefined;
-                entry.poll ||=
-                    evidence?.missing === true ||
-                        evidence?.unavailable !== undefined ||
-                        (observation !== undefined &&
-                            observation.fileExists !== true &&
-                            observation.stat !== "file" &&
-                            observation.readFile?.ok !== true) ||
-                        (evidence?.state === undefined &&
-                            condition.baseline?.fileExists !== true);
             }
             for (const [file, key] of previous) {
                 if (current.get(file) === key)
@@ -248,12 +618,133 @@ function createViteServeInputWatch() {
                     remove(entry);
                 }
             }
-            importerInputs.set(importer, current);
-            if (added.length !== 0)
-                ensureWatcher().add(added);
+            if (pathIdentityMemosDirty)
+                resetPathIdentityMemos();
+            if (current.size === 0)
+                importerInputs.delete(importer);
+            else
+                importerInputs.set(importer, current);
+            // Registration and removal can each touch thousands of compiler inputs.
+            // Decide the one shared poller's state once per atomic replacement,
+            // rather than rescanning the whole graph once per input.
+            updatePoller();
+            // Watchers are live before this proof. It closes the compile-to-subscribe
+            // race without manufacturing one native subscription per input.
+            if (touched.size !== 0) {
+                if (startedAt === undefined || startedAt < historyFloor) {
+                    check(touched);
+                }
+                else {
+                    const raced = [];
+                    for (const entry of touched) {
+                        if (entry.fallback || entry.changedAt > startedAt) {
+                            raced.push(entry);
+                            continue;
+                        }
+                        const observedAfterCompile = added.has(entry) &&
+                            (someSet(entry.aliases, (alias) => (changes.get(alias) ?? 0) > startedAt) ||
+                                someSet(entry.renameAliases, (alias) => (changes.get(alias) ?? 0) > startedAt));
+                        if (someSet(entry.scopes, (scope) => scope.failed ||
+                            scope.startedAt > startedAt ||
+                            observedAfterCompile)) {
+                            raced.push(entry);
+                        }
+                    }
+                    if (raced.length !== 0)
+                        check(raced);
+                }
+            }
         },
     };
 }
+const MAX_EXTERNAL_WATCH_SCOPES = 16;
+const MAX_CHANGE_HISTORY = 100_000;
+const MAX_FALLBACK_PROBES_PER_TICK = 64;
+const MAX_LINK_PROBES_PER_TICK = 64;
+/** Test a set without allocating a transient array on the registration path. */
+function someSet(values, predicate) {
+    for (const value of values)
+        if (predicate(value))
+            return true;
+    return false;
+}
+function openWatchPoller(listener) {
+    const timer = setInterval(listener, 500);
+    timer.unref();
+    return { close: () => clearInterval(timer) };
+}
+function openRecursiveWatch(root, listener, onError) {
+    const watcher = fs.watch(root, { persistent: false, recursive: true }, (eventType, file) => listener(eventType, file === null ? null : String(file)));
+    watcher.on("error", onError);
+    return { close: () => watcher.close() };
+}
+function containsPath(root, file) {
+    const relative = path.relative(path.resolve(root), path.resolve(file));
+    return (relative === "" ||
+        (relative !== ".." &&
+            !relative.startsWith(`..${path.sep}`) &&
+            !path.isAbsolute(relative)));
+}
+function nearestExistingDirectory(file) {
+    let current = path.resolve(file);
+    try {
+        if (!fs.statSync(current).isDirectory())
+            current = path.dirname(current);
+    }
+    catch {
+        current = path.dirname(current);
+    }
+    for (;;) {
+        try {
+            if (fs.statSync(current).isDirectory()) {
+                return path.dirname(current) === current ? undefined : current;
+            }
+        }
+        catch {
+            // Keep climbing to the nearest directory a recursive watch can own.
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function linkedComponents(file, root, cached, missing, keyOf) {
+    const relative = path.relative(root, file);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative))
+        return [];
+    const output = [];
+    let current = path.resolve(root);
+    for (const component of relative.split(path.sep).slice(0, -1)) {
+        current = path.join(current, component);
+        const key = keyOf(current);
+        if (missing.has(key))
+            break;
+        const known = cached.get(key);
+        if (known !== undefined) {
+            if (known !== null)
+                output.push(current);
+            continue;
+        }
+        try {
+            if (fs.lstatSync(current).isSymbolicLink()) {
+                cached.set(key, realpath(current) ?? current);
+                output.push(current);
+            }
+            else {
+                cached.set(key, null);
+            }
+        }
+        catch {
+            missing.add(key);
+            break;
+        }
+    }
+    return output;
+}
 function realpath(file) {
     try {
         return fs.realpathSync.native(file);
@@ -262,10 +753,20 @@ function realpath(file) {
         return undefined;
     }
 }
+/** Whether writes can reach this input through an unobserved hardlink alias. */
+function hasMultipleLinks(file) {
+    try {
+        const stats = fs.statSync(file);
+        return stats.isFile() && stats.nlink > 1;
+    }
+    catch {
+        return false;
+    }
+}
 function sameSpelling(left, right) {
     return process.platform === "win32"
-        ? left.toLowerCase() === right.toLowerCase()
-        : left === right;
+        ? path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase()
+        : path.resolve(left) === path.resolve(right);
 }
 /**
  * Invalidate every module-graph node of the registered importers so the next