env-runner 0.1.1 → 0.1.2

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import { t as EnvServer } from "./_chunks/server.mjs";
-import { serve } from "srvx";
 import { resolve } from "node:path";
+import { serve } from "srvx";
 import { parseArgs } from "node:util";
 //#region src/cli.ts
 const { values, positionals } = parseArgs({

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { a as NodeUpgradeContext, c as UpgradeContext, d as WorkerHooks, i as FetchHandler, l as UpgradeHandler, n as EnvRunnerData, o as RunnerMessageListener, r as EnvRunner, s as RunnerRPCHooks, t as BaseEnvRunner, u as WorkerAddress } from "./_chunks/base-runner.mjs";
+import { a as RunnerMessageListener, c as UpgradeHandler, i as RPCOptions, l as WorkerAddress, n as FetchHandler, o as RunnerRPCHooks, r as NodeUpgradeContext, s as UpgradeContext, t as EnvRunner, u as WorkerHooks } from "./_chunks/types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "./_chunks/base-runner.mjs";
 import { t as DenoProcessEnvRunner } from "./_chunks/runner.mjs";
-import { n as MiniflareEnvRunnerOptions, t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
+import { i as TransformResult, n as MiniflareEnvRunnerOptions, r as MiniflareExportInfo, t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
 import { ServerOptions } from "srvx";
 
 //#region src/manager.d.ts
@@ -24,6 +25,11 @@ declare class RunnerManager implements EnvRunner {
   sendMessage(message: unknown): void;
   onMessage(listener: RunnerMessageListener): void;
   offMessage(listener: RunnerMessageListener): void;
+  waitForReady(timeout?: number): Promise<void>;
+  rpc<T = unknown>(name: string, data?: unknown, opts?: {
+    timeout?: number;
+  }): Promise<T>;
+  reloadModule(timeout?: number): Promise<void>;
   close(): Promise<void>;
   onClose?: (runner: EnvRunner, cause?: unknown) => void;
   onReady?: (runner: EnvRunner, address?: WorkerAddress) => void;
@@ -92,9 +98,10 @@ interface AppEntryIPC {
 }
 interface AppEntry {
   fetch: ServerOptions["fetch"];
+  upgrade?: (context: UpgradeContext) => void;
   middleware?: ServerOptions["middleware"];
   plugins?: ServerOptions["plugins"];
   ipc?: AppEntryIPC;
 }
 //#endregion
-export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunnerData, type EnvRunner, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type NodeUpgradeContext, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type UpgradeContext, type UpgradeHandler, type WorkerAddress, type WorkerHooks, loadRunner };
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunnerData, type EnvRunner, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type TransformResult, type UpgradeContext, type UpgradeHandler, type WorkerAddress, type WorkerHooks, loadRunner };

package/dist/runners/bun-process/runner.d.mts

@@ -1,4 +1,5 @@
-import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { u as WorkerHooks } from "../../_chunks/types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
 
 //#region src/runners/bun-process/runner.d.ts
 declare class BunProcessEnvRunner extends BaseEnvRunner {

package/dist/runners/bun-process/worker.mjs

@@ -1,26 +1,47 @@
-import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 //#region src/runners/bun-process/worker.ts
-const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
+let entry = await resolveEntry(data.entry);
+const sendMessage = (message) => process.send(message);
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
 	silent: true,
-	fetch: entry.fetch,
+	fetch: (request) => entry.fetch(request),
 	middleware: entry.middleware,
 	plugins: entry.plugins,
 	gracefulShutdown: false
 });
 await server.ready();
-if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
+	entry.upgrade({ node: {
+		req,
+		socket,
+		head
+	} });
+});
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
 process.send({ address: parseServerAddress(server) });
-process.on("message", (message) => {
+process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
 			process.send({ event: "exit" });
 		});
 		return;
 	}
+	if (message?.event === "reload-module") {
+		try {
+			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			process.send({ event: "module-reloaded" });
+		} catch (error) {
+			process.send({
+				event: "module-reloaded",
+				error: error?.message || String(error)
+			});
+		}
+		return;
+	}
 	if (message?.type === "ping") {
 		process.send({
 			type: "pong",

package/dist/runners/deno-process/worker.mjs

@@ -1,26 +1,47 @@
-import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 //#region src/runners/deno-process/worker.ts
-const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
+let entry = await resolveEntry(data.entry);
+const sendMessage = (message) => process.send(message);
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
 	silent: true,
-	fetch: entry.fetch,
+	fetch: (request) => entry.fetch(request),
 	middleware: entry.middleware,
 	plugins: entry.plugins,
 	gracefulShutdown: false
 });
 await server.ready();
-if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
+	entry.upgrade({ node: {
+		req,
+		socket,
+		head
+	} });
+});
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
 process.send({ address: parseServerAddress(server) });
-process.on("message", (message) => {
+process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
 			process.send({ event: "exit" });
 		});
 		return;
 	}
+	if (message?.event === "reload-module") {
+		try {
+			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			process.send({ event: "module-reloaded" });
+		} catch (error) {
+			process.send({
+				event: "module-reloaded",
+				error: error?.message || String(error)
+			});
+		}
+		return;
+	}
 	if (message?.type === "ping") {
 		process.send({
 			type: "pong",

package/dist/runners/miniflare/runner.d.mts

@@ -1,3 +1,3 @@
 import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
-import { n as MiniflareEnvRunnerOptions, t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
-export { MiniflareEnvRunner, EnvRunnerData as MiniflareEnvRunnerData, MiniflareEnvRunnerOptions };
+import { i as TransformResult, n as MiniflareEnvRunnerOptions, r as MiniflareExportInfo, t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
+export { MiniflareEnvRunner, EnvRunnerData as MiniflareEnvRunnerData, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult };

package/dist/runners/node-process/runner.d.mts

@@ -1,4 +1,5 @@
-import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { u as WorkerHooks } from "../../_chunks/types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
 
 //#region src/runners/node-process/runner.d.ts
 declare class NodeProcessEnvRunner extends BaseEnvRunner {

package/dist/runners/node-process/worker.mjs

@@ -1,26 +1,47 @@
-import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 //#region src/runners/node-process/worker.ts
-const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
+let entry = await resolveEntry(data.entry);
+const sendMessage = (message) => process.send(message);
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
 	silent: true,
-	fetch: entry.fetch,
+	fetch: (request) => entry.fetch(request),
 	middleware: entry.middleware,
 	plugins: entry.plugins,
 	gracefulShutdown: false
 });
 await server.ready();
-if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
+	entry.upgrade({ node: {
+		req,
+		socket,
+		head
+	} });
+});
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
 process.send({ address: parseServerAddress(server) });
-process.on("message", (message) => {
+process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
 			process.send({ event: "exit" });
 		});
 		return;
 	}
+	if (message?.event === "reload-module") {
+		try {
+			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			process.send({ event: "module-reloaded" });
+		} catch (error) {
+			process.send({
+				event: "module-reloaded",
+				error: error?.message || String(error)
+			});
+		}
+		return;
+	}
 	if (message?.type === "ping") {
 		process.send({
 			type: "pong",

package/dist/runners/node-worker/runner.d.mts

@@ -1,4 +1,5 @@
-import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { u as WorkerHooks } from "../../_chunks/types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
 
 //#region src/runners/node-worker/runner.d.ts
 declare class NodeWorkerEnvRunner extends BaseEnvRunner {

package/dist/runners/node-worker/worker.mjs

@@ -1,27 +1,48 @@
-import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
 import { parentPort, workerData } from "node:worker_threads";
 import { serve } from "srvx";
 //#region src/runners/node-worker/worker.ts
-const entry = await resolveEntry((workerData || {}).entry);
+const data = workerData || {};
+let entry = await resolveEntry(data.entry);
+const sendMessage = (message) => parentPort?.postMessage(message);
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
 	silent: true,
-	fetch: entry.fetch,
+	fetch: (request) => entry.fetch(request),
 	middleware: entry.middleware,
 	plugins: entry.plugins,
 	gracefulShutdown: false
 });
 await server.ready();
-if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => parentPort?.postMessage(message) });
+if (entry.upgrade) server.node?.server?.on("upgrade", (req, socket, head) => {
+	entry.upgrade({ node: {
+		req,
+		socket,
+		head
+	} });
+});
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage });
 parentPort?.postMessage({ address: parseServerAddress(server) });
-parentPort?.on("message", (message) => {
+parentPort?.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
 			parentPort?.postMessage({ event: "exit" });
 		});
 		return;
 	}
+	if (message?.event === "reload-module") {
+		try {
+			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			parentPort?.postMessage({ event: "module-reloaded" });
+		} catch (error) {
+			parentPort?.postMessage({
+				event: "module-reloaded",
+				error: error?.message || String(error)
+			});
+		}
+		return;
+	}
 	if (message?.type === "ping") {
 		parentPort?.postMessage({
 			type: "pong",

package/dist/runners/self/runner.d.mts

@@ -1,4 +1,7 @@
-import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { u as WorkerHooks } from "../../_chunks/types.mjs";
+import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import * as node_http0 from "node:http";
+import * as node_net0 from "node:net";
 
 //#region src/runners/self/runner.d.ts
 declare class SelfEnvRunner extends BaseEnvRunner {
@@ -9,7 +12,15 @@ declare class SelfEnvRunner extends BaseEnvRunner {
     data?: EnvRunnerData;
   });
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  upgrade(context: {
+    node: {
+      req: node_http0.IncomingMessage;
+      socket: node_net0.Socket;
+      head: any;
+    };
+  }): Promise<void>;
   sendMessage(message: unknown): void;
+  reloadModule(): Promise<void>;
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
   protected _closeRuntime(): Promise<void>;

package/dist/runners/self/runner.mjs

@@ -1,6 +1,6 @@
 import "../../_chunks/libs/std-env.mjs";
 import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
-import { n as resolveEntry } from "../../_chunks/worker-utils.mjs";
+import { n as reloadEntryModule, r as resolveEntry } from "../../_chunks/worker-utils.mjs";
 //#region src/runners/self/runner.ts
 var SelfEnvRunner = class extends BaseEnvRunner {
 	#active = false;
@@ -17,6 +17,10 @@ var SelfEnvRunner = class extends BaseEnvRunner {
 		const request = input instanceof Request ? input : new Request(input, init);
 		return this.#entry.fetch(request);
 	}
+	async upgrade(context) {
+		if (!this.#entry?.upgrade || this.closed) return;
+		this.#entry.upgrade(context);
+	}
 	sendMessage(message) {
 		if (!this.#active) throw new Error("Self env runner should be initialized before sending messages.");
 		if (message?.type === "ping") {
@@ -28,6 +32,14 @@ var SelfEnvRunner = class extends BaseEnvRunner {
 		}
 		this.#entry?.ipc?.onMessage?.(message);
 	}
+	async reloadModule() {
+		const entryPath = this._data?.entry;
+		if (!entryPath || !this.#entry) throw new Error("Cannot reload: no entry loaded");
+		const sendFn = (message) => {
+			queueMicrotask(() => this._handleMessage(message));
+		};
+		this.#entry = await reloadEntryModule(entryPath, this.#entry, sendFn);
+	}
 	_hasRuntime() {
 		return this.#active;
 	}

package/dist/vite.d.mts

@@ -0,0 +1,32 @@
+import { o as RunnerRPCHooks } from "./_chunks/types.mjs";
+
+//#region src/vite.d.ts
+/** Vite HotChannel-compatible interface (avoids hard dependency on vite types). */
+interface ViteHotChannel {
+  send: (data: any) => void;
+  on: (event: string, handler: (...args: any[]) => void) => void;
+  off: (event: string, handler: (...args: any[]) => void) => void;
+}
+/** Vite ModuleRunner transport-compatible interface. */
+interface ViteTransport {
+  connect: (handlers: {
+    onMessage: (payload: any) => void;
+  }) => void;
+  send: (payload: any) => void;
+}
+/**
+ * Create a Vite `HotChannel` from an env-runner's RPC hooks.
+ *
+ * Use on the **host side** to bridge env-runner IPC → Vite's DevEnvironment transport.
+ * Messages are namespaced by `envName` so multiple Vite environments can share one runner.
+ */
+declare function createViteHotChannel(hooks: RunnerRPCHooks, envName: string): ViteHotChannel;
+/**
+ * Create a Vite `ModuleRunner` transport from worker-side IPC primitives.
+ *
+ * Use on the **worker side** to bridge worker IPC → Vite's `ModuleRunner` transport.
+ * Filters messages by `envName` so multiple Vite environments can share one IPC channel.
+ */
+declare function createViteTransport(sendMessage: (data: any) => void, onMessage: (listener: (value: any) => void) => void, envName: string): ViteTransport;
+//#endregion
+export { ViteHotChannel, ViteTransport, createViteHotChannel, createViteTransport };

package/dist/vite.mjs

@@ -0,0 +1,58 @@
+//#region src/vite.ts
+/**
+* Create a Vite `HotChannel` from an env-runner's RPC hooks.
+*
+* Use on the **host side** to bridge env-runner IPC → Vite's DevEnvironment transport.
+* Messages are namespaced by `envName` so multiple Vite environments can share one runner.
+*/
+function createViteHotChannel(hooks, envName) {
+	const listeners = /* @__PURE__ */ new WeakMap();
+	return {
+		send: (data) => hooks.sendMessage({
+			...data,
+			viteEnv: envName
+		}),
+		on: (event, handler) => {
+			if (event === "connection") return;
+			const listener = (value) => {
+				if (value?.type === "custom" && value.event === event && value.viteEnv === envName) handler(value.data, { send: (payload) => hooks.sendMessage({
+					...payload,
+					viteEnv: envName
+				}) });
+			};
+			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);
+			}
+		}
+	};
+}
+/**
+* Create a Vite `ModuleRunner` transport from worker-side IPC primitives.
+*
+* Use on the **worker side** to bridge worker IPC → Vite's `ModuleRunner` transport.
+* Filters messages by `envName` so multiple Vite environments can share one IPC channel.
+*/
+function createViteTransport(sendMessage, onMessage, envName) {
+	return {
+		connect({ onMessage: onRunnerMessage }) {
+			onMessage((payload) => {
+				if (payload?.type === "custom" && payload.viteEnv === envName) onRunnerMessage(payload);
+			});
+		},
+		send(payload) {
+			sendMessage?.({
+				...payload,
+				viteEnv: envName
+			});
+		}
+	};
+}
+//#endregion
+export { createViteHotChannel, createViteTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "env-runner",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Generic environment runner for JavaScript runtimes.",
   "license": "MIT",
   "repository": "unjs/env-runner",
@@ -23,7 +23,8 @@
     "./runners/deno-process": "./dist/runners/deno-process/runner.mjs",
     "./runners/deno-process/worker": "./dist/runners/deno-process/worker.mjs",
     "./runners/self": "./dist/runners/self/runner.mjs",
-    "./runners/miniflare": "./dist/runners/miniflare/runner.mjs"
+    "./runners/miniflare": "./dist/runners/miniflare/runner.mjs",
+    "./vite": "./dist/vite.mjs"
   },
   "scripts": {
     "build": "obuild",