env-runner 0.1.9 → 0.1.10

package/dist/_chunks/runner5.d.mts

@@ -1,6 +1,6 @@
-import { u as WorkerHooks } from "./types.mjs";
-import { n as EnvRunnerData } from "./base-runner.mjs";
-import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { WorkerHooks } from "./types.mjs";
+import { EnvRunnerData } from "./base-runner.mjs";
+import { NodeWorkerEnvRunner } from "./runner3.mjs";
 declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
   constructor(opts: {
     name: string;
@@ -11,4 +11,4 @@ declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
   fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   protected _runtimeType(): string;
 }
-export { NetlifyEnvRunner as t };
+export { NetlifyEnvRunner };

package/dist/_chunks/runner5.mjs

@@ -1,4 +1,4 @@
-import { t as NodeWorkerEnvRunner } from "./runner3.mjs";
+import { NodeWorkerEnvRunner } from "./runner3.mjs";
 import { fileURLToPath } from "node:url";
 let _defaultEntry;
 var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
@@ -42,4 +42,4 @@ var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
 		return "netlify";
 	}
 };
-export { NetlifyEnvRunner as t };
+export { NetlifyEnvRunner };

package/dist/_chunks/server.mjs

@@ -24,11 +24,12 @@ var RunnerManager = class {
 		this._reloading = false;
 		if (prev) await prev.close();
 	}
-	fetch = async (input, init) => {
+	fetch = (input, init) => this._fetch(input, init);
+	async _fetch(input, init) {
 		const runner = await this._waitForRunner();
 		if (!runner) return new Response("Runner is unavailable", { status: 503 });
 		return runner.fetch(input, init);
-	};
+	}
 	upgrade = (context) => {
 		this._runner?.upgrade?.(context);
 	};
@@ -102,6 +103,9 @@ var RunnerManager = class {
 		this._detach();
 		if (runner) await runner.close();
 	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
 	onClose(listener) {
 		this._closeListeners.add(listener);
 	}
@@ -179,6 +183,7 @@ var EnvServer = class extends RunnerManager {
 	_watchers = [];
 	_reloadTimeout;
 	_reloadListeners = /* @__PURE__ */ new Set();
+	_startPromise;
 	runner = null;
 	onReload(listener) {
 		this._reloadListeners.add(listener);
@@ -190,18 +195,29 @@ var EnvServer = class extends RunnerManager {
 		super();
 		this._opts = opts;
 	}
-	async start() {
-		this.runner = await this._createRunner();
-		await this.reload(this.runner);
-		if (this._opts.watch) this._startWatching();
-		return this;
+	start() {
+		this._startPromise ??= this._start().catch((error) => {
+			this._startPromise = void 0;
+			throw error;
+		});
+		return this._startPromise;
 	}
 	async close() {
 		this._stopWatching();
 		await super.close();
 	}
+	async _fetch(input, init) {
+		if (!this.closed) await this.start();
+		return super._fetch(input, init);
+	}
+	async _start() {
+		this.runner = await this._createRunner();
+		await this.reload(this.runner);
+		if (this._opts.watch) this._startWatching();
+		return this;
+	}
 	async _createRunner() {
-		return loadRunner(this._opts.runner, {
+		return loadRunner(this._opts.runner || "node-worker", {
 			name: this._opts.name || this._opts.entry,
 			hooks: this._opts.hooks,
 			data: {
@@ -238,4 +254,4 @@ var EnvServer = class extends RunnerManager {
 		}, 100);
 	}
 };
-export { loadRunner as n, RunnerManager as r, EnvServer as t };
+export { EnvServer, RunnerManager, loadRunner };

package/dist/_chunks/types.d.mts

@@ -52,7 +52,7 @@ interface RPCOptions {
   timeout?: number;
 }
 /** Core runner interface combining lifecycle hooks, RPC, and request proxying. */
-interface EnvRunner extends RunnerRPCHooks {
+interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
   /** Whether the worker is ready to accept requests. */
   readonly ready: boolean;
   /** Whether the runner has been closed. */
@@ -69,5 +69,7 @@ interface EnvRunner extends RunnerRPCHooks {
   reloadModule?(timeout?: number): Promise<void>;
   /** Gracefully shut down the worker. */
   close(): Promise<void>;
+  /** Alias for `close()`, enabling `await using` (explicit resource management). */
+  [Symbol.asyncDispose](): Promise<void>;
 }
-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 };
+export { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, WorkerAddress, WorkerHooks };

package/dist/_chunks/virtual-loader.mjs

@@ -0,0 +1,39 @@
+async function resolveVirtualModules(virtual) {
+	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => [key, typeof value === "function" ? await value() : value]));
+	return Object.fromEntries(entries);
+}
+const VIRTUAL_SCHEME = "virtual:";
+function createVirtualHooks(virtual) {
+	const resolve = (specifier, context, nextResolve) => {
+		if (Object.hasOwn(virtual, _stripQuery(specifier))) return {
+			url: VIRTUAL_SCHEME + encodeURIComponent(specifier),
+			shortCircuit: true
+		};
+		return nextResolve(specifier, context);
+	};
+	const load = (url, context, nextLoad) => {
+		if (url.startsWith(VIRTUAL_SCHEME)) {
+			const key = _stripQuery(decodeURIComponent(url.slice(8)));
+			if (Object.hasOwn(virtual, key)) return {
+				format: virtualModuleFormat(key),
+				source: virtual[key],
+				shortCircuit: true
+			};
+		}
+		return nextLoad(url, context);
+	};
+	return {
+		resolve,
+		load
+	};
+}
+function virtualModuleFormat(specifier) {
+	if (specifier.endsWith(".json")) return "json";
+	if (specifier.endsWith(".ts") || specifier.endsWith(".mts")) return "module-typescript";
+	return "module";
+}
+function _stripQuery(specifier) {
+	const qIndex = specifier.indexOf("?");
+	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
+}
+export { createVirtualHooks, resolveVirtualModules, virtualModuleFormat };

package/dist/_chunks/worker-utils.mjs

@@ -1,8 +1,78 @@
-import { readFileSync } from "node:fs";
+import { createVirtualHooks, virtualModuleFormat } from "./virtual-loader.mjs";
+import { existsSync, readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { isAbsolute } from "node:path";
-async function resolveEntry(entryPath) {
-	const mod = await import(_toImportPath(entryPath));
+async function registerVirtualModules(virtual) {
+	if (!virtual || Object.keys(virtual).length === 0) return _noop;
+	const { registerHooks, stripTypeScriptTypes } = await import("node:module");
+	if (typeof registerHooks === "function") {
+		if ("Deno" in globalThis) virtual = _transformForDeno(virtual, stripTypeScriptTypes);
+		const hooks = registerHooks(createVirtualHooks(virtual));
+		return _once(() => hooks.deregister());
+	}
+	if (typeof globalThis.Bun?.plugin === "function") {
+		_bunVirtual = virtual;
+		_registerBunModules(Object.keys(virtual));
+		return _once(() => {
+			if (_bunVirtual === virtual) _bunVirtual = void 0;
+		});
+	}
+	console.warn("[env-runner] virtual modules require `module.registerHooks` (Node.js >= 22.15 / Deno >= 2.x) or `Bun.plugin`; skipping registration.");
+	return _noop;
+}
+function refreshVirtualModule(specifier) {
+	if (_bunVirtual?.[specifier] === void 0) return false;
+	_registerBunModules([specifier]);
+	return true;
+}
+let _bunVirtual;
+function _registerBunModules(specifiers) {
+	globalThis.Bun.plugin({
+		name: "env-runner-virtual",
+		setup(build) {
+			for (const specifier of specifiers) build.module(specifier, () => {
+				const source = _bunVirtual?.[specifier];
+				if (source === void 0) throw new Error(`Cannot find virtual module "${specifier}" (unregistered)`);
+				const format = virtualModuleFormat(specifier);
+				if (format === "json") return {
+					exports: { default: JSON.parse(source) },
+					loader: "object"
+				};
+				return {
+					contents: source,
+					loader: format === "module-typescript" ? "ts" : "js"
+				};
+			});
+		}
+	});
+}
+function _transformForDeno(virtual, stripTypeScriptTypes) {
+	const out = {};
+	for (const [specifier, source] of Object.entries(virtual)) {
+		const format = virtualModuleFormat(specifier);
+		if (format === "module-typescript") {
+			if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] virtual TypeScript module "${specifier}" requires \`module.stripTypeScriptTypes\` (custom load hooks bypass Deno's native type stripping); upgrade Deno or provide a pre-transpiled JavaScript source instead.`);
+			out[specifier] = stripTypeScriptTypes(source);
+		} else if (format === "json") out[specifier] = `export default JSON.parse(${JSON.stringify(source)});`;
+		else out[specifier] = source;
+	}
+	return out;
+}
+const _noop = () => {};
+function _once(fn) {
+	let done = false;
+	return () => {
+		if (!done) {
+			done = true;
+			fn();
+		}
+	};
+}
+function isVirtualSpecifier(specifier, virtual) {
+	return Boolean(specifier && virtual && Object.hasOwn(virtual, specifier));
+}
+async function resolveEntry(entryPath, virtual) {
+	const mod = await (virtual ? import(entryPath) : import(_toImportPath(entryPath)));
 	const entry = mod.default || mod;
 	if (typeof entry.fetch !== "function") throw new Error(`[env-runner] Entry module "${entryPath}" must export a \`fetch\` handler (export default { fetch(req) { ... } }).`);
 	return entry;
@@ -14,9 +84,9 @@ function parseServerAddress(server) {
 		port: Number(url.port)
 	};
 }
-async function reloadEntryModule(entryPath, currentEntry, sendMessage) {
+async function reloadEntryModule(entryPath, currentEntry, sendMessage, virtual) {
 	await currentEntry.ipc?.onClose?.();
-	const newEntry = await _importFresh(entryPath);
+	const newEntry = await _importFresh(entryPath, virtual);
 	await newEntry.ipc?.onOpen?.({ sendMessage });
 	return newEntry;
 }
@@ -27,11 +97,18 @@ function _toImportPath(entryPath) {
 	if (isAbsolute(filePath)) return pathToFileURL(filePath).href + query;
 	return entryPath;
 }
-async function _importFresh(entryPath) {
-	const code = readFileSync(entryPath, "utf8");
-	const mod = await import("data:text/javascript;base64," + Buffer.from(code).toString("base64"));
+let _reloadCounter = 0;
+async function _importFresh(entryPath, virtual) {
+	const qIndex = entryPath.indexOf("?");
+	const filePath = qIndex === -1 ? entryPath : entryPath.slice(0, qIndex);
+	let mod;
+	if (!virtual && existsSync(filePath)) {
+		const code = readFileSync(filePath, "utf8");
+		mod = await import("data:text/javascript;base64," + Buffer.from(code).toString("base64"));
+	} else if (virtual && refreshVirtualModule(filePath)) mod = await import(filePath);
+	else mod = await import(entryPath + (qIndex === -1 ? "?" : "&") + "__envRunnerReload=" + _reloadCounter++);
 	const entry = mod.default || mod;
 	if (typeof entry.fetch !== "function") throw new Error(`[env-runner] Entry module "${entryPath}" must export a \`fetch\` handler (export default { fetch(req) { ... } }).`);
 	return entry;
 }
-export { reloadEntryModule as n, resolveEntry as r, parseServerAddress as t };
+export { isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry };

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { t as EnvServer } from "./_chunks/server.mjs";
+import { EnvServer } from "./_chunks/server.mjs";
 import { resolve } from "node:path";
 import { serve } from "srvx";
 import { parseArgs } from "node:util";

package/dist/index.d.mts

@@ -1,16 +1,16 @@
-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 { i as TransformResult, n as MiniflareEnvRunnerOptions, r as MiniflareExportInfo, t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
-import { t as VercelEnvRunner } from "./_chunks/runner4.mjs";
-import { t as NetlifyEnvRunner } from "./_chunks/runner5.mjs";
+import { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, WorkerAddress, WorkerHooks } from "./_chunks/types.mjs";
+import { BaseEnvRunner, EnvRunnerData, VirtualModuleSource, VirtualModules } from "./_chunks/base-runner.mjs";
+import { DenoProcessEnvRunner } from "./_chunks/runner.mjs";
+import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult } from "./_chunks/runner2.mjs";
+import { VercelEnvRunner } from "./_chunks/runner4.mjs";
+import { NetlifyEnvRunner } from "./_chunks/runner5.mjs";
 import { ServerOptions } from "srvx";
 import { Hooks } from "crossws";
 /**
  * Manages an active `EnvRunner` instance, proxying all calls to it.
  * Supports hot-reload, auto-restart on unexpected exit, and message queueing.
  */
-declare class RunnerManager implements EnvRunner {
+declare class RunnerManager implements EnvRunner, AsyncDisposable {
   private _runner;
   private _messageQueue;
   private _messageListeners;
@@ -24,6 +24,7 @@ declare class RunnerManager implements EnvRunner {
   /** Replace the active runner with a new one. Closes the previous runner. */
   reload(runner: EnvRunner): Promise<void>;
   fetch: FetchHandler;
+  protected _fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   upgrade: UpgradeHandler;
   sendMessage(message: unknown): void;
   onMessage(listener: RunnerMessageListener): void;
@@ -34,6 +35,7 @@ declare class RunnerManager implements EnvRunner {
   }): Promise<T>;
   reloadModule(timeout?: number): Promise<void>;
   close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
   onClose(listener: (runner: EnvRunner, cause?: unknown) => void): void;
   offClose(listener: (runner: EnvRunner, cause?: unknown) => void): void;
   onReady(listener: (runner: EnvRunner, address?: WorkerAddress) => void): void;
@@ -56,8 +58,8 @@ interface LoadRunnerOptions {
 }
 declare function loadRunner(runner: RunnerName, opts: LoadRunnerOptions): Promise<EnvRunner>;
 interface EnvServerOptions {
-  /** Runner implementation to use. */
-  runner: RunnerName;
+  /** Runner implementation to use (defaults to `"node-worker"`). */
+  runner?: RunnerName;
   /** Path to the user entry module (passed as `data.entry`). */
   entry: string;
   /** Runner instance name. */
@@ -78,15 +80,25 @@ declare class EnvServer extends RunnerManager {
   private _watchers;
   private _reloadTimeout;
   private _reloadListeners;
+  private _startPromise;
   runner: Awaited<ReturnType<typeof loadRunner>> | null;
   /** Register a listener called when the runner is reloaded due to a file change. */
   onReload(listener: () => void): void;
   /** Remove a previously registered reload listener. */
   offReload(listener: () => void): void;
   constructor(opts: EnvServerOptions);
-  /** Start the server by loading and attaching the runner. */
+  /**
+   * Start the server by loading and attaching the runner.
+   *
+   * Idempotent — concurrent and repeated calls share one startup. Calling
+   * `start()` explicitly is optional: the first `fetch()` auto-starts the
+   * server. A failed start resets so a later call can retry.
+   */
   start(): Promise<this>;
   close(): Promise<void>;
+  /** Auto-start on first fetch so an explicit `start()` call is optional. */
+  protected _fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  private _start;
   private _createRunner;
   private _startWatching;
   private _stopWatching;
@@ -108,4 +120,4 @@ interface AppEntry {
   plugins?: ServerOptions["plugins"];
   ipc?: AppEntryIPC;
 }
-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, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type WorkerAddress, type WorkerHooks, loadRunner };
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, EnvServer, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, RunnerManager, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, loadRunner };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { t as BaseEnvRunner } from "./_chunks/base-runner.mjs";
-import { n as loadRunner, r as RunnerManager, t as EnvServer } from "./_chunks/server.mjs";
-import { t as DenoProcessEnvRunner } from "./_chunks/runner.mjs";
-import { t as MiniflareEnvRunner } from "./_chunks/runner2.mjs";
-import { t as VercelEnvRunner } from "./_chunks/runner4.mjs";
-import { t as NetlifyEnvRunner } from "./_chunks/runner5.mjs";
+import { BaseEnvRunner } from "./_chunks/base-runner.mjs";
+import { EnvServer, RunnerManager, loadRunner } from "./_chunks/server.mjs";
+import { DenoProcessEnvRunner } from "./_chunks/runner.mjs";
+import { MiniflareEnvRunner } from "./_chunks/runner2.mjs";
+import { VercelEnvRunner } from "./_chunks/runner4.mjs";
+import { NetlifyEnvRunner } from "./_chunks/runner5.mjs";
 export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner };

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

@@ -1,5 +1,5 @@
-import { u as WorkerHooks } from "../../_chunks/types.mjs";
-import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { WorkerHooks } from "../../_chunks/types.mjs";
+import { BaseEnvRunner, EnvRunnerData } from "../../_chunks/base-runner.mjs";
 declare class BunProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {

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

@@ -1,4 +1,4 @@
-import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { BaseEnvRunner } from "../../_chunks/base-runner.mjs";
 import { existsSync } from "node:fs";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -7,6 +7,12 @@ import { homedir } from "node:os";
 let _defaultEntry;
 let _bunPath;
 const _isBun = typeof Bun !== "undefined";
+async function forwardStream(stream, dest) {
+	if (!stream) return;
+	try {
+		for await (const chunk of stream) dest.write(chunk);
+	} catch {}
+}
 function resolveBunPath() {
 	if (_bunPath) return _bunPath;
 	const candidates = [join(homedir(), ".bun", "bin", "bun")];
@@ -25,7 +31,7 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 			...opts,
 			workerEntry: opts.workerEntry || _defaultEntry
 		});
-		this.#initProcess(opts.execArgv);
+		this._initWithVirtualData(() => this.#initProcess(opts.execArgv));
 	}
 	sendMessage(message) {
 		if (!this.#process) throw new Error("Bun env process should be initialized before sending messages.");
@@ -86,6 +92,8 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 			child._exitCode = code;
 			this.close(`process exited with code ${code}`);
 		});
+		forwardStream(proc.stdout, process.stdout);
+		forwardStream(proc.stderr, process.stderr);
 		this.#process = child;
 	}
 	#initNodeProcess(execArgv, env) {
@@ -122,6 +130,8 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 		child.on("message", (message) => {
 			this._handleMessage(message);
 		});
+		child.stdout?.pipe(process.stdout);
+		child.stderr?.pipe(process.stderr);
 		this.#process = handle;
 	}
 };

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

@@ -1,9 +1,24 @@
-import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
+process.on("disconnect", () => process.exit(0));
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
-let entry = await resolveEntry(data.entry);
 const sendMessage = (message) => process.send(message);
+const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
+let unregisterVirtualModules;
+let entry;
+try {
+	unregisterVirtualModules = await registerVirtualModules(data.virtual);
+	entry = await resolveEntry(data.entry, virtualEntry);
+} catch (error) {
+	const message = error?.message || String(error);
+	sendMessage({
+		event: "init-error",
+		error: message
+	});
+	console.error(`[env-runner] worker init failed: ${message}`);
+	process.exit(1);
+}
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
@@ -26,13 +41,14 @@ process.send({ address: parseServerAddress(server) });
 process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			unregisterVirtualModules();
 			process.send({ event: "exit" });
 		});
 		return;
 	}
 	if (message?.event === "reload-module") {
 		try {
-			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			entry = await reloadEntryModule(data.entry, entry, sendMessage, virtualEntry);
 			process.send({ event: "module-reloaded" });
 		} catch (error) {
 			process.send({

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

@@ -1,3 +1,3 @@
-import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
-import { t as DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
+import { EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
 export { DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData };

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

@@ -1,2 +1,2 @@
-import { t as DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
+import { DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
 export { DenoProcessEnvRunner };

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

@@ -1,11 +1,25 @@
-import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
-let entry = await resolveEntry(data.entry);
 const _stdout = globalThis.Deno?.stdout ? { write: (s) => globalThis.Deno.stdout.writeSync(new TextEncoder().encode(s)) } : process.stdout;
 const sendMessage = (message) => _stdout.write(JSON.stringify(message) + "\n");
 const _stdin = globalThis.Deno?.stdin?.readable || process.stdin;
+const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
+let unregisterVirtualModules;
+let entry;
+try {
+	unregisterVirtualModules = await registerVirtualModules(data.virtual);
+	entry = await resolveEntry(data.entry, virtualEntry);
+} catch (error) {
+	const message = error?.message || String(error);
+	sendMessage({
+		event: "init-error",
+		error: message
+	});
+	console.error(`[env-runner] worker init failed: ${message}`);
+	process.exit(1);
+}
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
@@ -48,13 +62,14 @@ async function readMessages() {
 async function handleMessage(message) {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			unregisterVirtualModules();
 			sendMessage({ event: "exit" });
 		});
 		return;
 	}
 	if (message?.event === "reload-module") {
 		try {
-			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			entry = await reloadEntryModule(data.entry, entry, sendMessage, virtualEntry);
 			sendMessage({ event: "module-reloaded" });
 		} catch (error) {
 			sendMessage({

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

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

package/dist/runners/miniflare/runner.mjs

@@ -1,2 +1,2 @@
-import { t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
+import { MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
 export { MiniflareEnvRunner };

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

@@ -1,3 +1,3 @@
-import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
-import { t as NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
+import { EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
 export { type EnvRunnerData, NetlifyEnvRunner };

package/dist/runners/netlify/runner.mjs

@@ -1,2 +1,2 @@
-import { t as NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
+import { NetlifyEnvRunner } from "../../_chunks/runner5.mjs";
 export { NetlifyEnvRunner };

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

@@ -1,5 +1,5 @@
-import { u as WorkerHooks } from "../../_chunks/types.mjs";
-import { n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { WorkerHooks } from "../../_chunks/types.mjs";
+import { BaseEnvRunner, EnvRunnerData } from "../../_chunks/base-runner.mjs";
 declare class NodeProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {

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

@@ -1,4 +1,4 @@
-import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { BaseEnvRunner } from "../../_chunks/base-runner.mjs";
 import { existsSync } from "node:fs";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -11,7 +11,7 @@ var NodeProcessEnvRunner = class extends BaseEnvRunner {
 			...opts,
 			workerEntry: opts.workerEntry || _defaultEntry
 		});
-		this.#initProcess(opts.execArgv);
+		this._initWithVirtualData(() => this.#initProcess(opts.execArgv));
 	}
 	sendMessage(message) {
 		if (!this.#process) throw new Error("Node env process should be initialized before sending messages.");
@@ -59,6 +59,8 @@ var NodeProcessEnvRunner = class extends BaseEnvRunner {
 		child.on("message", (message) => {
 			this._handleMessage(message);
 		});
+		child.stdout?.pipe(process.stdout);
+		child.stderr?.pipe(process.stderr);
 		this.#process = child;
 	}
 };

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

@@ -1,9 +1,24 @@
-import { n as reloadEntryModule, r as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server/node";
+process.on("disconnect", () => process.exit(0));
 const data = JSON.parse(process.env.ENV_RUNNER_DATA || "{}");
-let entry = await resolveEntry(data.entry);
 const sendMessage = (message) => process.send(message);
+const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
+let unregisterVirtualModules;
+let entry;
+try {
+	unregisterVirtualModules = await registerVirtualModules(data.virtual);
+	entry = await resolveEntry(data.entry, virtualEntry);
+} catch (error) {
+	const message = error?.message || String(error);
+	sendMessage({
+		event: "init-error",
+		error: message
+	});
+	console.error(`[env-runner] worker init failed: ${message}`);
+	process.exit(1);
+}
 const server = serve({
 	port: 0,
 	hostname: "127.0.0.1",
@@ -26,13 +41,14 @@ process.send({ address: parseServerAddress(server) });
 process.on("message", async (message) => {
 	if (message?.event === "shutdown") {
 		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			unregisterVirtualModules();
 			process.send({ event: "exit" });
 		});
 		return;
 	}
 	if (message?.event === "reload-module") {
 		try {
-			entry = await reloadEntryModule(data.entry, entry, sendMessage);
+			entry = await reloadEntryModule(data.entry, entry, sendMessage, virtualEntry);
 			process.send({ event: "module-reloaded" });
 		} catch (error) {
 			process.send({

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

@@ -1,3 +1,3 @@
-import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
-import { t as NodeWorkerEnvRunner } from "../../_chunks/runner3.mjs";
+import { EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { NodeWorkerEnvRunner } from "../../_chunks/runner3.mjs";
 export { type EnvRunnerData, NodeWorkerEnvRunner };