@ttsc/unplugin 0.30.2 → 0.30.3

package/src/core/viteServe.ts

@@ -1,21 +1,16 @@
+import { type FSWatcher, watch } from "chokidar";
 import fs from "node:fs";
 import path from "node:path";
-import type { ITtscCompilerTransformation } from "ttsc";
 
-import { pathIdentityKey, validateGraphInputObservation } from "./transform";
-
-/**
- * How often each registered Vite-unsafe input is predicate-polled, in
- * milliseconds.
- *
- * Polling is the only watch primitive that covers the whole class: the dev
- * server's chokidar watcher ignores every `node_modules` directory, which is
- * exactly where superseding resolution candidates usually live, and `fs.watch`
- * cannot observe a path whose parent directories do not exist yet. One `stat`
- * every half second per unavailable path is negligible against a dev server's
- * baseline. Rich inputs replay only the predicates the compiler recorded.
- */
-const MISSING_INPUT_POLL_INTERVAL = 500;
+import {
+  type TtscWatchInput,
+  type TtscWatchInputBaseline,
+  type TtscWatchInputEvidence,
+  captureWatchInputBaseline,
+  pathIdentityKey,
+  validateGraphInputObservation,
+  watchInputEvidenceMatchesBaseline,
+} from "./transform";
 
 /** One module node inside a Vite module graph; opaque to this module. */
 type ViteModuleNodeLike = object;
@@ -55,188 +50,304 @@ export interface ViteDevServerLike {
   ws?: ViteHotChannelLike;
 }
 
-/**
- * Filesystem watch for derived watch inputs that Vite cannot safely register as
- * added imports while a development server is running.
- *
- * Vite serve treats every transform-context `addWatchFile()` registration as an
- * added import: `TransformPluginContext.addWatchFile` stores the path in
- * `_addedImports`, and `vite:import-analysis` resolves each entry like a real
- * import of the transformed module. A missing path or an existing directory
- * that failed a compiler file predicate then fails that resolve and turns the
- * importer's first request into a 500, even though the transform succeeded.
- *
- * This registry is the serve-only replacement for those registrations. Each
- * path is polled until its exact compiler predicate observation changes; legacy
- * envelopes retain their exists-or-file availability check. Its importers are
- * then invalidated in the server's module graphs and one full-reload is sent,
- * so the next request retransforms against the new resolution winner. The
- * project transform cache re-validates the compiler observation, so the
- * retransform recompiles instead of replaying.
- */
-export interface ViteServeMissingInputWatch {
-  /** Adopt the dev server whose module graphs creation events invalidate. */
-  attach(server: ViteDevServerLike): void;
-  /** Stop every poll; safe to call repeatedly. */
-  dispose(): void;
-  /**
-   * Report whether a dev server has ever been attached. This is not a liveness
-   * predicate — the reference intentionally survives the server's close (see
-   * {@link dispose}) — so route decisions must also gate on the resolved
-   * config's `command`, as the adapter does.
-   */
-  serving(): boolean;
-  /** Register one unsafe watch input and its exact recorded condition. */
-  watch(
-    input: string,
-    importer: string,
-    condition: ViteServeInputWatchCondition,
-  ): void;
+interface InputCondition {
+  baseline?: TtscWatchInputBaseline;
+  evidence?: TtscWatchInputEvidence;
+  importers: Set<string>;
 }
 
-/** A legacy availability condition or an exact compiler predicate proof. */
-export type ViteServeInputWatchCondition =
-  | "exists"
-  | "file"
-  | ITtscCompilerTransformation.IInputObservation;
+interface InputEntry {
+  conditions: Map<string, InputCondition>;
+  file: string;
+  /** Missing paths and directory predicates still need the predicate poll. */
+  poll: boolean;
+  observed: boolean;
+  links: Set<string>;
+}
 
-/** Poll bookkeeping for one registered unsafe path. */
-interface IMissingInputEntry {
-  condition: ViteServeInputWatchCondition;
-  importers: Set<string>;
-  spelling: string;
+interface LinkedPath {
+  target: string | undefined;
+  inputs: Set<InputEntry>;
 }
 
-/** Create an empty missing-input watch for one plugin instance. */
-export function createViteServeMissingInputWatch(): ViteServeMissingInputWatch {
-  const entries = new Map<string, IMissingInputEntry>();
-  let poller: NodeJS.Timeout | undefined;
+/** Serve-time compiler dependencies never enter Vite's runtime import graph. */
+export interface ViteServeInputWatch {
+  attach(server: ViteDevServerLike): void;
+  dispose(): Promise<void>;
+  replace(
+    importer: string,
+    inputs: readonly TtscWatchInput[],
+    failed?: boolean,
+  ): void;
+}
+
+/**
+ * One filesystem subscription per unique input, 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.
+ */
+export function createViteServeInputWatch(): ViteServeInputWatch {
+  const entries = new Map<string, InputEntry>();
+  const importerInputs = new Map<string, Map<string, string>>();
+  const pending = new Set<InputEntry>();
+  const links = new Map<string, LinkedPath>();
   let server: ViteDevServerLike | undefined;
+  let watcher: FSWatcher | undefined;
+  let poller: NodeJS.Timeout | undefined;
+  let flushTimer: NodeJS.Timeout | undefined;
+  let failed = false;
 
-  const stopPollingIfEmpty = (): void => {
-    if (entries.size !== 0 || poller === undefined) {
-      return;
+  const remove = (entry: InputEntry): void => {
+    entries.delete(entry.file);
+    watcher?.unwatch(entry.file);
+    for (const file of entry.links) {
+      const link = links.get(file);
+      link?.inputs.delete(entry);
+      if (link?.inputs.size === 0) links.delete(file);
     }
-    clearInterval(poller);
-    poller = undefined;
   };
-  const poll = (): void => {
+
+  const check = (selected: Iterable<InputEntry>): void => {
     const importers = new Set<string>();
-    for (const [identity, entry] of entries) {
-      if (!viteServeInputWatchConditionChanged(entry)) {
-        continue;
+    for (const entry of selected) {
+      if (entries.get(entry.file) !== entry) continue;
+      let baseline: TtscWatchInputBaseline | undefined;
+      for (const [key, condition] of entry.conditions) {
+        const state = condition.evidence?.state;
+        let changed: boolean;
+        if (state?.codec === "predicates") {
+          changed =
+            validateGraphInputObservation(entry.file, state.observation)
+              .length !== 0;
+        } else {
+          baseline ??= captureWatchInputBaseline(entry.file);
+          changed =
+            baseline === undefined ||
+            (condition.evidence?.state !== undefined
+              ? !watchInputEvidenceMatchesBaseline(condition.evidence, baseline)
+              : JSON.stringify(condition.baseline) !==
+                JSON.stringify(baseline));
+        }
+        if (!changed) continue;
+        for (const importer of condition.importers) importers.add(importer);
+        entry.conditions.delete(key);
       }
-      entries.delete(identity);
-      for (const importer of entry.importers) {
-        importers.add(importer);
+      if (entry.conditions.size === 0) {
+        remove(entry);
       }
     }
-    stopPollingIfEmpty();
-    if (server === undefined || importers.size === 0) {
-      return;
+    if (server !== undefined && importers.size !== 0) {
+      invalidateImporters(server, importers);
+      sendFullReload(server);
+    }
+  };
+
+  const enqueue = (file: string, observed: boolean): void => {
+    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) pending.add(entry);
     }
-    invalidateImporters(server, importers);
-    sendFullReload(server);
+    if (pending.size === 0 || flushTimer !== undefined) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      const selected = [...pending];
+      pending.clear();
+      check(selected);
+    }, 0);
+    flushTimer.unref();
+  };
+
+  const ensureWatcher = (): FSWatcher => {
+    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,
+        ),
+      );
+      // 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) {
+        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;
   };
 
   return {
     attach(next) {
       server = next;
     },
-    dispose() {
+    async dispose() {
       entries.clear();
-      if (poller !== undefined) {
-        clearInterval(poller);
-        poller = undefined;
-      }
-      // The server reference deliberately survives: `vite.restartServer`
-      // configures the replacement server (attach) before it closes the old
-      // one (whose buildEnd runs this dispose), so unsetting it here would
-      // detach the freshly attached replacement and revive the 500 this
-      // module exists to prevent. A same-instance `vite build` after a serve
-      // is instead excluded by the adapter's `config.command` gate.
+      importerInputs.clear();
+      pending.clear();
+      links.clear();
+      if (poller !== undefined) clearInterval(poller);
+      if (flushTimer !== undefined) clearTimeout(flushTimer);
+      poller = undefined;
+      flushTimer = undefined;
+      const closing = watcher;
+      watcher = undefined;
+      failed = false;
+      await closing?.close();
+      // Retain the attached server across overlapping Vite restart containers.
     },
-    serving() {
-      return server !== undefined;
-    },
-    watch(input, importer, condition) {
-      const spelling = path.resolve(input);
-      const identity = viteServeMissingInputWatchKey(spelling, condition);
-      const existing = entries.get(identity);
-      if (existing !== undefined) {
-        existing.importers.add(path.resolve(importer));
-        return;
+    replace(importer, inputs, failed = false) {
+      if (server === undefined) return;
+      importer = path.resolve(importer);
+      const previous =
+        importerInputs.get(importer) ?? new Map<string, string>();
+      if (failed) {
+        // An exception can omit the dependency whose deletion caused it.
+        // Keep the last successful spellings until a successful delivery can
+        // replace them, observing their current failed state for recovery.
+        const reported = new Set(
+          inputs.map((input) => path.resolve(input.file)),
+        );
+        inputs = [
+          ...inputs,
+          ...[...previous.keys()]
+            .filter((file) => !reported.has(file))
+            .map((file) => ({ file })),
+        ];
+      }
+      const current = new Map<string, string>();
+      const added: string[] = [];
+      for (const input of inputs) {
+        const file = path.resolve(input.file);
+        const evidence = input.evidence;
+        const key = JSON.stringify(evidence ?? null);
+        current.set(file, key);
+        let entry = entries.get(file);
+        if (entry === undefined) {
+          entry = {
+            file,
+            conditions: new Map(),
+            poll: false,
+            observed: false,
+            links: 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);
+          }
+        }
+        let condition = entry.conditions.get(key);
+        if (condition === undefined) {
+          condition = {
+            evidence,
+            baseline:
+              evidence?.state === undefined
+                ? captureWatchInputBaseline(file)
+                : undefined,
+            importers: new Set(),
+          };
+          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);
       }
-      entries.set(identity, {
-        condition,
-        importers: new Set([path.resolve(importer)]),
-        spelling,
-      });
-      if (poller === undefined) {
-        poller = setInterval(poll, MISSING_INPUT_POLL_INTERVAL);
-        // A poller must never keep the dev-server process alive on its own.
-        poller.unref?.();
+      for (const [file, key] of previous) {
+        if (current.get(file) === key) continue;
+        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 && !current.has(file)) {
+          remove(entry);
+        }
       }
+      importerInputs.set(importer, current);
+      if (added.length !== 0) ensureWatcher().add(added);
     },
   };
 }
 
-/** Key a private poll by predicate and exact lexical spelling. */
-export function viteServeMissingInputWatchKey(
-  input: string,
-  condition: ViteServeInputWatchCondition,
-): string {
-  // Missing aliases can share a physical parent now and later retarget or
-  // diverge. Neither predicate may let one lexical spelling answer for another.
-  const predicate =
-    typeof condition === "string"
-      ? condition
-      : `predicates:${JSON.stringify([
-          condition.accessibleEntries === undefined
-            ? null
-            : [
-                condition.accessibleEntries.directories,
-                condition.accessibleEntries.files,
-              ],
-          condition.directoryExists ?? null,
-          condition.fileExists ?? null,
-          condition.readFile === undefined
-            ? null
-            : condition.readFile.ok
-              ? [true, condition.readFile.hash]
-              : [false],
-          condition.realpath === undefined
-            ? null
-            : condition.realpath.ok
-              ? [true, condition.realpath.path]
-              : [false],
-          condition.stat ?? null,
-        ])}`;
-  return `${predicate}:${path.resolve(input)}`;
-}
-
-/** Whether one registered condition no longer describes its lexical path. */
-function viteServeInputWatchConditionChanged(
-  entry: IMissingInputEntry,
-): boolean {
-  if (typeof entry.condition !== "string") {
-    return (
-      validateGraphInputObservation(entry.spelling, entry.condition).length !==
-      0
-    );
-  }
+function realpath(file: string): string | undefined {
   try {
-    if (!fs.existsSync(entry.spelling)) {
-      return false;
-    }
-    return (
-      entry.condition === "exists" || !fs.statSync(entry.spelling).isDirectory()
-    );
+    return fs.realpathSync.native(file);
   } catch {
-    return false;
+    return undefined;
   }
 }
 
+function sameSpelling(left: string, right: string): boolean {
+  return process.platform === "win32"
+    ? left.toLowerCase() === right.toLowerCase()
+    : left === right;
+}
+
 /**
  * Invalidate every module-graph node of the registered importers so the next
  * request retransforms them. Importers keep their original absolute spelling so