test(vite): cover stale runner evaluations across dev worker reloads

The hmr fixture gains a dep-crawler plugin that re-transforms dep.ts as a
side effect of transforming api/crawled.ts (the way asset-collecting
plugins crawl imports), plus a plugin that hard-invalidates the server
module graph on dep.ts edits (as framework staleness workarounds do). On a
reload without evaluatedModules.clear(), the crawled transform makes
fetchModule answer {cache: true} for dep.ts and the stale evaluation is
served until restart — the new test fails without the fix and passes with
it.

Author: brenelz

test/vite/hmr-fixture/api/crawled.ts

@@ -0,0 +1,3 @@
+import { value } from "../dep.ts";
+
+export default () => ({ value });

test/vite/hmr-fixture/dep.ts

@@ -0,0 +1 @@
+export const value = "original";

test/vite/hmr-fixture/vite.config.ts

@@ -1,6 +1,44 @@
-import { defineConfig } from "vite";
+import { defineConfig, type Plugin } from "vite";
 import { nitro } from "nitro/vite";
 
+/**
+ * Simulates an asset-collecting plugin (e.g. vite-plugin-solid's `?assets`
+ * crawl) that transforms a module's dependencies as a side effect of
+ * transforming the module itself. This repopulates the dependency's
+ * `transformResult` on the Vite side before the reloading dev worker's
+ * module runner re-fetches it, so `fetchModule` answers `{cache: true}` —
+ * the runner then reuses its stale evaluation unless the dev worker cleared
+ * its evaluated modules when reloading.
+ */
+function depCrawler(): Plugin {
+  return {
+    name: "test:dep-crawler",
+    async transform(_code, id) {
+      if (id.endsWith("api/crawled.ts") && this.environment.mode === "dev") {
+        await this.environment.transformRequest("/dep.ts");
+      }
+    },
+  };
+}
+
+/**
+ * Simulates a framework plugin that hard-invalidates the whole server module
+ * graph on edits (a common workaround for SSR staleness). Hard invalidation
+ * makes transform hooks re-run — which is what lets `depCrawler` above
+ * repopulate `dep.ts`'s transform during the reload. Scoped to `dep.ts`
+ * edits so the other HMR tests are unaffected.
+ */
+function serverGraphInvalidator(): Plugin {
+  return {
+    name: "test:server-graph-invalidator",
+    hotUpdate({ file }) {
+      if (file.endsWith("dep.ts") && this.environment.config.consumer !== "client") {
+        this.environment.moduleGraph.invalidateAll();
+      }
+    },
+  };
+}
+
 export default defineConfig({
-  plugins: [nitro({ serverDir: "./" })],
+  plugins: [nitro({ serverDir: "./" }), depCrawler(), serverGraphInvalidator()],
 });

test/vite/hmr.test.ts

@@ -20,6 +20,7 @@ describe("vite:hmr", { sequential: true }, () => {
     api: openFileForEditing(join(rootDir, "api/state.ts")),
     shared: openFileForEditing(join(rootDir, "shared.ts")),
     ssr: openFileForEditing(join(rootDir, "app/entry-server.ts")),
+    dep: openFileForEditing(join(rootDir, "dep.ts")),
   };
 
   beforeAll(async () => {
@@ -92,6 +93,24 @@ describe("vite:hmr", { sequential: true }, () => {
     );
     expect(wsMessages).toMatchObject([{ type: "full-reload" }]);
   });
+
+  // Regression test for the dev worker reusing stale evaluations across
+  // reloads: the fixture's `dep-crawler` plugin re-transforms `dep.ts` as a
+  // side effect of transforming `api/crawled.ts`, so by the time the
+  // reloading worker's module runner re-fetches `dep.ts`, its transform is
+  // already populated and `fetchModule` answers `{cache: true}`. Unless
+  // `reload()` clears the runner's evaluated modules, the old `dep.ts`
+  // evaluation is reused and responses stay stale until a manual restart.
+  test("editing a dependency crawled by another plugin", async () => {
+    const res = (await fetch(`${serverURL}/api/crawled`).then((r) => r.json())) as {
+      value: string;
+    };
+    expect(res.value).toBe("original");
+
+    files.dep.update((content) => content.replace(`"original"`, `"modified"`));
+    await pollResponse(`${serverURL}/api/crawled`, /modified/);
+    expect(wsMessages).toMatchObject([{ type: "full-reload" }]);
+  });
 });
 
 function openFileForEditing(path: string) {