feat: use unjs/env-runner

package.json

@@ -71,6 +71,7 @@
     "consola": "^3.4.2",
     "crossws": "^0.4.4",
     "db0": "^0.3.4",
+    "env-runner": "^0.1.6",
     "h3": "^2.0.1-rc.16",
     "hookable": "^6.0.1",
     "nf3": "^0.3.11",

src/build/rolldown/dev.ts

@@ -1,8 +1,7 @@
 import type { Nitro } from "nitro/types";
 import type { RolldownWatcher, RolldownOptions } from "rolldown";
 import { watch as chokidarWatch } from "chokidar";
-import { watch } from "node:fs";
-import { join } from "pathe";
+import { basename, join } from "pathe";
 import { debounce } from "perfect-debounce";
 import { scanHandlers } from "../../scan.ts";
 import { writeTypes } from "../types.ts";
@@ -41,8 +40,12 @@ export async function watchDev(nitro: Nitro, config: RolldownOptions) {
     }
   });
 
-  const rootDirWatcher = watch(nitro.options.rootDir, { persistent: false }, (_event, filename) => {
-    if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) {
+  const serverEntryRe = /^server\.[mc]?[jt]sx?$/;
+  const rootDirWatcher = chokidarWatch(nitro.options.rootDir, {
+    ignoreInitial: true,
+    depth: 0,
+  }).on("all", (event, path) => {
+    if (watchReloadEvents.has(event) && serverEntryRe.test(basename(path))) {
       reload();
     }
   });
@@ -55,6 +58,10 @@ export async function watchDev(nitro: Nitro, config: RolldownOptions) {
 
   nitro.hooks.hook("rollup:reload", () => reload());
 
+  nitro.logger.info(
+    `Starting dev watcher (builder: \`rolldown\`, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`
+  );
+
   await load();
 
   function startWatcher(nitro: Nitro, config: RolldownOptions) {
@@ -68,9 +75,6 @@ export async function watchDev(nitro: Nitro, config: RolldownOptions) {
       switch (event.code) {
         case "START": {
           start = Date.now();
-          nitro.logger.info(
-            `Starting dev watcher (builder: \`rolldown\`, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`
-          );
           nitro.hooks.callHook("dev:start");
           break;
         }

src/build/rollup/dev.ts

@@ -1,9 +1,8 @@
 import type { Nitro, RollupConfig } from "nitro/types";
 import type { RollupWatcher } from "rollup";
 import { watch as chokidarWatch } from "chokidar";
-import { watch } from "node:fs";
 import { defu } from "defu";
-import { join } from "pathe";
+import { basename, join } from "pathe";
 import { debounce } from "perfect-debounce";
 import { scanHandlers } from "../../scan.ts";
 import { formatRollupError } from "./error.ts";
@@ -43,8 +42,12 @@ export async function watchDev(nitro: Nitro, rollupConfig: RollupConfig) {
     }
   });
 
-  const rootDirWatcher = watch(nitro.options.rootDir, { persistent: false }, (_event, filename) => {
-    if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) {
+  const serverEntryRe = /^server\.[mc]?[jt]sx?$/;
+  const rootDirWatcher = chokidarWatch(nitro.options.rootDir, {
+    ignoreInitial: true,
+    depth: 0,
+  }).on("all", (event, path) => {
+    if (watchReloadEvents.has(event) && serverEntryRe.test(basename(path))) {
       reload();
     }
   });
@@ -57,6 +60,10 @@ export async function watchDev(nitro: Nitro, rollupConfig: RollupConfig) {
 
   nitro.hooks.hook("rollup:reload", () => reload());
 
+  nitro.logger.info(
+    `Starting dev watcher (builder: \`rollup\`, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`
+  );
+
   await load();
 
   function startRollupWatcher(nitro: Nitro, rollupConfig: RollupConfig) {
@@ -75,9 +82,6 @@ export async function watchDev(nitro: Nitro, rollupConfig: RollupConfig) {
       switch (event.code) {
         case "START": {
           start = Date.now();
-          nitro.logger.info(
-            `Starting dev watcher (builder: \`rollup\`, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`
-          );
           nitro.hooks.callHook("dev:start");
           break;
         }

src/build/vite/dev.ts

@@ -1,9 +1,12 @@
 import type { NitroPluginContext } from "./types.ts";
-import type { DevEnvironmentContext, HotChannel, ResolvedConfig, ViteDevServer } from "vite";
+import type { DevEnvironmentContext, ResolvedConfig, ViteDevServer } from "vite";
+import type { FetchFunctionOptions, FetchResult } from "vite/module-runner";
+import type { RunnerRPCHooks } from "env-runner";
 
 import { IncomingMessage, ServerResponse } from "node:http";
 import { NodeRequest, sendNodeResponse } from "srvx/node";
 import { DevEnvironment } from "vite";
+import { createViteHotChannel } from "env-runner/vite";
 import { watch as chokidarWatch } from "chokidar";
 import { watch as fsWatch } from "node:fs";
 import { join } from "pathe";
@@ -17,13 +20,7 @@ import { getEnvRunner } from "./env.ts";
 
 export type FetchHandler = (req: Request) => Promise<Response>;
 
-export interface TransportHooks {
-  sendMessage: (data: any) => void;
-  onMessage: (listener: (value: any) => void) => void;
-  offMessage: (listener: (value: any) => void) => void;
-}
-
-export interface DevServer extends TransportHooks {
+export interface DevServer extends RunnerRPCHooks {
   fetch: FetchHandler;
   init?: () => void | Promise<void>;
 }
@@ -34,31 +31,58 @@ export function createFetchableDevEnvironment(
   name: string,
   config: ResolvedConfig,
   devServer: DevServer,
-  entry: string
+  entry: string,
+  opts?: { preventExternalize?: boolean }
 ): FetchableDevEnvironment {
-  const transport = createTransport(name, devServer);
+  const transport = createViteHotChannel(devServer, name);
   const context: DevEnvironmentContext = { hot: true, transport };
-  return new FetchableDevEnvironment(name, config, context, devServer, entry);
+  return new FetchableDevEnvironment(name, config, context, devServer, entry, opts);
 }
 
 export class FetchableDevEnvironment extends DevEnvironment {
   devServer: DevServer;
 
+  #entry: string;
+  #preventExternalize: boolean;
+
   constructor(
     name: string,
     config: ResolvedConfig,
     context: DevEnvironmentContext,
     devServer: DevServer,
-    entry: string
+    entry: string,
+    opts?: { preventExternalize?: boolean }
   ) {
     super(name, config, context);
     this.devServer = devServer;
+    this.#entry = entry;
+    this.#preventExternalize = opts?.preventExternalize ?? false;
+  }
 
-    this.devServer.sendMessage({
-      type: "custom",
-      event: "nitro:vite-env",
-      data: { name, entry },
-    });
+  override async fetchModule(
+    id: string,
+    importer?: string,
+    options?: FetchFunctionOptions
+  ): Promise<FetchResult> {
+    // workerd cannot handle CJS/Node modules loaded via import().
+    // Bare imports (like "vue") are normally externalized by Vite's fetchModule,
+    // resolved using mainFields: ["main"] which often picks CJS entries.
+    // We intercept bare imports, resolve them through the environment's plugin
+    // pipeline (which respects resolve.conditions and picks ESM), then route
+    // the resolved path through transformRequest for proper SSR processing.
+    if (
+      this.#preventExternalize &&
+      !id.startsWith("file://") &&
+      importer &&
+      id[0] !== "." &&
+      id[0] !== "/"
+    ) {
+      const resolved = await this.pluginContainer.resolveId(id, importer);
+      if (resolved && !resolved.external) {
+        return super.fetchModule(resolved.id, importer, options);
+      }
+    }
+    return super.fetchModule(id, importer, options);
   }
 
   async dispatchFetch(request: Request): Promise<Response> {
@@ -67,37 +91,15 @@ export class FetchableDevEnvironment extends DevEnvironment {
 
   override async init(...args: any[]): Promise<void> {
     await this.devServer.init?.();
-    return super.init(...args);
+    await super.init(...args);
+    this.devServer.sendMessage({
+      type: "custom",
+      event: "nitro:vite-env",
+      data: { name: this.name, entry: this.#entry },
+    });
   }
 }
 
-function createTransport(name: string, hooks: TransportHooks): HotChannel {
-  const listeners = new WeakMap();
-  return {
-    send: (data) => hooks.sendMessage({ ...data, viteEnv: name }),
-    on: (event: string, handler: any) => {
-      if (event === "connection") return;
-      const listener = (value: any) => {
-        if (value?.type === "custom" && value.event === event && value.viteEnv === name) {
-          handler(value.data, {
-            send: (payload: any) => hooks.sendMessage({ ...payload, viteEnv: name }),
-          });
-        }
-      };
-      listeners.set(handler, listener);
-      hooks.onMessage(listener);
-    },
-    off: (event, handler) => {
-      if (event === "connection") return;
-      const listener = listeners.get(handler);
-      if (listener) {
-        hooks.offMessage(listener);
-        listeners.delete(handler);
-      }
-    },
-  };
-}
-
 // ---- Vite Dev Server Integration ----
 
 export async function configureViteDevServer(ctx: NitroPluginContext, server: ViteDevServer) {
@@ -117,7 +119,7 @@ export async function configureViteDevServer(ctx: NitroPluginContext, server: Vi
         // Vite upgrade. TODO: Is there a better way?
         return;
       }
-      getEnvRunner(ctx).upgrade?.(req, socket, head);
+      getEnvRunner(ctx).upgrade?.({ node: { req, socket, head } });
     });
   }
 
@@ -160,30 +162,21 @@ export async function configureViteDevServer(ctx: NitroPluginContext, server: Vi
     rootDirWatcher.close();
   });
 
-  // Worker => Host IPC
-  const hostIPC = {
-    async transformHTML(html: string) {
-      return server
-        .transformIndexHtml("/", html)
-        .then((r) =>
-          r.replace(
-            "<!--ssr-outlet-->",
-            `{{{ globalThis.__nitro_vite_envs__?.["ssr"]?.fetch($REQUEST) || "" }}}`
-          )
+  // Worker => Host RPC
+  nitroEnv.devServer.onMessage(async (message: any) => {
+    if (message?.__rpc === "transformHTML") {
+      try {
+        const html = (await server.transformIndexHtml("/", message.data)).replace(
+          "<!--ssr-outlet-->",
+          `{{{ globalThis.__nitro_vite_envs__?.["ssr"]?.fetch($REQUEST) || "" }}}`
         );
-    },
-  };
-  nitroEnv.devServer.onMessage(async (payload) => {
-    if (payload.type === "custom" && payload.event === "nitro:vite-invoke") {
-      const methodName = payload.data.name as keyof typeof hostIPC;
-      const res = await hostIPC[methodName](payload.data.data)
-        .then((data) => ({ data }))
-        .catch((error) => ({ error }));
-      nitroEnv.devServer.sendMessage({
-        type: "custom",
-        event: "nitro:vite-invoke-response",
-        data: { id: payload.data.id, data: res },
-      });
+        nitroEnv.devServer.sendMessage({ __rpc_id: message.__rpc_id, data: html });
+      } catch (error) {
+        nitroEnv.devServer.sendMessage({
+          __rpc_id: message.__rpc_id,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
     }
   });