env-runner 0.1.1 → 0.1.3

package/dist/_chunks/types.d.mts

@@ -0,0 +1,76 @@
+import { IncomingMessage } from "node:http";
+import { Socket } from "node:net";
+
+//#region src/types.d.ts
+/** Handler for proxying HTTP requests to the worker. */
+type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** Callback for receiving messages from the worker. */
+type RunnerMessageListener = (data: unknown) => void;
+/** Raw Node.js upgrade request context. */
+interface NodeUpgradeContext {
+  req: IncomingMessage;
+  socket: Socket;
+  head: any;
+}
+/** Context passed to the upgrade handler for WebSocket upgrades. */
+interface UpgradeContext {
+  node: NodeUpgradeContext;
+}
+/** Handler for proxying WebSocket upgrade requests to the worker. */
+type UpgradeHandler = (context: UpgradeContext) => void;
+/** Bidirectional RPC messaging interface between the runner and worker. */
+interface RunnerRPCHooks {
+  /** Send a message to the worker. */
+  sendMessage: (message: unknown) => void;
+  /** Register a listener for messages from the worker. */
+  onMessage: (listener: RunnerMessageListener) => void;
+  /** Remove a previously registered message listener. */
+  offMessage: (listener: RunnerMessageListener) => void;
+}
+/**
+ * Address reported by the worker once it is ready.
+ *
+ * Either a TCP `host`/`port` pair or a Unix `socketPath`.
+ */
+type WorkerAddress = {
+  host?: string;
+  port: number;
+  socketPath?: undefined;
+} | {
+  host?: undefined;
+  port?: undefined;
+  socketPath: string;
+};
+/** Lifecycle hooks for observing runner state changes. */
+interface WorkerHooks {
+  /** Called when the worker closes, optionally with the cause. */
+  onClose?: (worker: EnvRunner, cause?: unknown) => void;
+  /** Called when the worker is ready and listening at the given address. */
+  onReady?: (worker: EnvRunner, address?: WorkerAddress) => void;
+}
+/** Options for the `rpc()` method. */
+interface RPCOptions {
+  /** Timeout in milliseconds before the RPC call rejects. Default: 3000. */
+  timeout?: number;
+}
+/** Core runner interface combining lifecycle hooks, RPC, and request proxying. */
+interface EnvRunner extends WorkerHooks, RunnerRPCHooks {
+  /** Whether the worker is ready to accept requests. */
+  readonly ready: boolean;
+  /** Whether the runner has been closed. */
+  readonly closed: boolean;
+  /** Proxy an HTTP request to the worker. */
+  fetch: FetchHandler;
+  /** Proxy a WebSocket upgrade request to the worker. */
+  upgrade?: UpgradeHandler;
+  /** Returns a promise that resolves when the runner becomes ready. */
+  waitForReady(timeout?: number): Promise<void>;
+  /** Send an RPC request and wait for the response. */
+  rpc<T = unknown>(name: string, data?: unknown, opts?: RPCOptions): Promise<T>;
+  /** Re-import the entry module without restarting the worker/process. */
+  reloadModule?(timeout?: number): Promise<void>;
+  /** Gracefully shut down the worker. */
+  close(): Promise<void>;
+}
+//#endregion
+export { RunnerMessageListener as a, UpgradeHandler as c, RPCOptions as i, WorkerAddress as l, FetchHandler as n, RunnerRPCHooks as o, NodeUpgradeContext as r, UpgradeContext as s, EnvRunner as t, WorkerHooks as u };

package/dist/_chunks/worker-utils.mjs

@@ -12,5 +12,15 @@ function parseServerAddress(server) {
 		port: Number(url.port)
 	};
 }
+/**
+* Re-import the user entry module with cache busting.
+* Tears down old IPC hooks and re-initializes new ones.
+*/
+async function reloadEntryModule(entryPath, currentEntry, sendMessage) {
+	await currentEntry.ipc?.onClose?.();
+	const newEntry = await resolveEntry(entryPath + "?t=" + Date.now());
+	await newEntry.ipc?.onOpen?.({ sendMessage });
+	return newEntry;
+}
 //#endregion
-export { resolveEntry as n, parseServerAddress as t };
+export { reloadEntryModule as n, resolveEntry as r, parseServerAddress as t };

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,7 +1,9 @@
-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";
+import { Hooks } from "crossws";
 
 //#region src/manager.d.ts
 /**
@@ -24,6 +26,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 +99,11 @@ interface AppEntryIPC {
 }
 interface AppEntry {
   fetch: ServerOptions["fetch"];
+  upgrade?: (context: UpgradeContext) => void;
+  websocket?: Partial<Hooks>;
   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,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 { serve } from "srvx";
+import { plugin } from "crossws/server";
 //#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,
+	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
 	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,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 { serve } from "srvx";
+import { plugin } from "crossws/server";
 //#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,
+	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
 	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,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 { serve } from "srvx";
+import { plugin } from "crossws/server/node";
 //#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,
+	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
 	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,49 @@
-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";
+import { plugin } from "crossws/server/node";
 //#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,
+	plugins: [...entry.plugins || [], ...entry.websocket ? [plugin(entry.websocket)] : []],
 	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.3",
   "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",
@@ -37,6 +38,7 @@
     "typecheck": "tsgo --noEmit --skipLibCheck"
   },
   "dependencies": {
+    "crossws": "^0.4.4",
     "httpxy": "^0.3.1",
     "srvx": "^0.11.9"
   },