env-runner 0.1.9 → 0.1.11

package/dist/_chunks/server.mjs

@@ -5,6 +5,8 @@ var RunnerManager = class {
 	_messageListeners = /* @__PURE__ */ new Set();
 	_closed = false;
 	_reloading = false;
+	_moduleInvalidated = false;
+	_pendingModuleReload;
 	_closeListeners = /* @__PURE__ */ new Set();
 	_readyListeners = /* @__PURE__ */ new Set();
 	constructor(runner) {
@@ -18,17 +20,35 @@ var RunnerManager = class {
 	}
 	async reload(runner) {
 		this._reloading = true;
-		const prev = this._runner;
-		this._detach();
-		this._attach(runner);
-		this._reloading = false;
-		if (prev) await prev.close();
+		try {
+			runner ??= await this._createRunner();
+			const prev = this._runner;
+			this._detach();
+			this._attach(runner);
+			this._moduleInvalidated = false;
+			if (prev) await prev.close();
+		} finally {
+			this._reloading = false;
+		}
+	}
+	_createRunner() {
+		throw new Error("reload() requires a runner argument (this manager has no runner factory)");
 	}
-	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 });
+		if (this._moduleInvalidated) await this._flushInvalidation(runner);
 		return runner.fetch(input, init);
-	};
+	}
+	_flushInvalidation(runner) {
+		this._pendingModuleReload ??= Promise.resolve(runner.reloadModule?.()).then(() => {
+			this._moduleInvalidated = false;
+		}).finally(() => {
+			this._pendingModuleReload = void 0;
+		});
+		return this._pendingModuleReload;
+	}
 	upgrade = (context) => {
 		this._runner?.upgrade?.(context);
 	};
@@ -93,7 +113,13 @@ var RunnerManager = class {
 	}
 	async reloadModule(timeout) {
 		if (!this._runner?.reloadModule) throw new Error("Active runner does not support reloadModule()");
-		return this._runner.reloadModule(timeout);
+		await this._runner.reloadModule(timeout);
+		this._moduleInvalidated = false;
+	}
+	async invalidateModule(specifier, timeout) {
+		if (!this._runner?.invalidateModule) throw new Error("Active runner does not support invalidateModule()");
+		await this._runner.invalidateModule(specifier, timeout);
+		this._moduleInvalidated = true;
 	}
 	async close() {
 		this._closed = true;
@@ -102,6 +128,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 +208,7 @@ var EnvServer = class extends RunnerManager {
 	_watchers = [];
 	_reloadTimeout;
 	_reloadListeners = /* @__PURE__ */ new Set();
+	_startPromise;
 	runner = null;
 	onReload(listener) {
 		this._reloadListeners.add(listener);
@@ -190,18 +220,32 @@ 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 reload(runner) {
+		this.runner = runner ?? await this._createRunner();
+		await super.reload(this.runner);
 	}
 	async close() {
 		this._stopWatching();
 		await super.close();
 	}
+	async _fetch(input, init) {
+		if (!this.closed) await this.start();
+		return super._fetch(input, init);
+	}
+	async _start() {
+		await this.reload();
+		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: {
@@ -229,8 +273,7 @@ var EnvServer = class extends RunnerManager {
 		clearTimeout(this._reloadTimeout);
 		this._reloadTimeout = setTimeout(async () => {
 			try {
-				this.runner = await this._createRunner();
-				await this.reload(this.runner);
+				await this.reload();
 				for (const fn of this._reloadListeners) fn();
 			} catch (error) {
 				console.error("Failed to reload runner:", error);
@@ -238,4 +281,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

@@ -1,6 +1,11 @@
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
-/** Handler for proxying HTTP requests to the worker. */
+/**
+ * Handler for proxying HTTP requests to the worker.
+ *
+ * A relative string input (e.g. `"/path"`) is resolved against a placeholder
+ * `http://localhost` origin before dispatching.
+ */
 type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** Callback for receiving messages from the worker. */
 type RunnerMessageListener = (data: unknown) => void;
@@ -52,7 +57,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. */
@@ -67,7 +72,14 @@ interface EnvRunner extends RunnerRPCHooks {
   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>;
+  /**
+   * Invalidate a virtual module so the next `reloadModule()` re-evaluates it.
+   * A factory-valued source is re-run for fresh contents.
+   */
+  invalidateModule?(specifier: string, 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,63 @@
+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, versions) {
+	const resolve = (specifier, context, nextResolve) => {
+		const key = _stripQuery(specifier);
+		if (Object.hasOwn(virtual, key)) {
+			const version = versions?.get(key);
+			return {
+				url: VIRTUAL_SCHEME + encodeURIComponent(specifier) + (version ? `?v=${version}` : ""),
+				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 stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, hints) {
+	if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] virtual TypeScript module "${specifier}" requires \`module.stripTypeScriptTypes\` ${hints.requirement}; ${hints.remedy} or provide a pre-transpiled JavaScript source instead.`);
+	return stripTypeScriptTypes(source);
+}
+function expandVirtualInvalidation(virtual, specifier) {
+	const invalidated = [specifier];
+	const seen = new Set(invalidated);
+	for (const target of invalidated) {
+		const refs = [
+			`"${target}"`,
+			`'${target}'`,
+			"`" + target + "`"
+		];
+		for (const [key, source] of Object.entries(virtual)) if (!seen.has(key) && refs.some((ref) => source.includes(ref))) {
+			seen.add(key);
+			invalidated.push(key);
+		}
+	}
+	return invalidated;
+}
+function _stripQuery(specifier) {
+	const qIndex = specifier.indexOf("?");
+	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
+}
+export { createVirtualHooks, expandVirtualInvalidation, resolveVirtualModules, stripVirtualTypeScript, virtualModuleFormat };

package/dist/_chunks/worker-utils.mjs

@@ -1,8 +1,115 @@
-import { readFileSync } from "node:fs";
+import { createVirtualHooks, expandVirtualInvalidation, stripVirtualTypeScript, 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") {
+		let transformSource;
+		if ("Deno" in globalThis) {
+			transformSource = (specifier, source) => _transformSourceForDeno(specifier, source, stripTypeScriptTypes);
+			const transformed = {};
+			for (const [specifier, source] of Object.entries(virtual)) transformed[specifier] = transformSource(specifier, source);
+			virtual = transformed;
+		}
+		const registration = {
+			virtual,
+			versions: /* @__PURE__ */ new Map(),
+			transformSource
+		};
+		const hooks = registerHooks(createVirtualHooks(virtual, registration.versions));
+		_hooksRegistrations.unshift(registration);
+		return _once(() => {
+			const index = _hooksRegistrations.indexOf(registration);
+			if (index !== -1) _hooksRegistrations.splice(index, 1);
+			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;
+}
+function invalidateVirtualModule(specifier, source) {
+	for (const registration of _hooksRegistrations) {
+		if (!Object.hasOwn(registration.virtual, specifier)) continue;
+		const { virtual, versions, transformSource } = registration;
+		if (source !== void 0) virtual[specifier] = transformSource ? transformSource(specifier, source) : source;
+		for (const key of expandVirtualInvalidation(virtual, specifier)) versions.set(key, (versions.get(key) ?? 0) + 1);
+		return true;
+	}
+	if (_bunVirtual && Object.hasOwn(_bunVirtual, specifier)) {
+		if (source !== void 0) _bunVirtual[specifier] = source;
+		_registerBunModules(expandVirtualInvalidation(_bunVirtual, specifier));
+		return true;
+	}
+	return false;
+}
+function handleInvalidateModule(message, sendMessage) {
+	const ok = invalidateVirtualModule(message.specifier, message.source);
+	sendMessage({
+		event: "module-invalidated",
+		specifier: message.specifier,
+		error: ok ? void 0 : `Cannot invalidate "${message.specifier}" (not a registered virtual module)`
+	});
+}
+const _hooksRegistrations = [];
+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 _transformSourceForDeno(specifier, source, stripTypeScriptTypes) {
+	const format = virtualModuleFormat(specifier);
+	if (format === "module-typescript") return stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, {
+		requirement: "(custom load hooks bypass Deno's native type stripping)",
+		remedy: "upgrade Deno"
+	});
+	if (format === "json") return `export default JSON.parse(${JSON.stringify(source)});`;
+	return source;
+}
+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 +121,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 +134,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 { handleInvalidateModule, 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,29 +1,45 @@
-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;
   private _closed;
   private _reloading;
+  private _moduleInvalidated;
+  private _pendingModuleReload;
   private _closeListeners;
   private _readyListeners;
   constructor(runner?: EnvRunner);
   get ready(): boolean;
   get closed(): boolean;
-  /** Replace the active runner with a new one. Closes the previous runner. */
-  reload(runner: EnvRunner): Promise<void>;
+  /**
+   * Replace the active runner with a new one. Closes the previous runner.
+   *
+   * When called without a runner, a fresh one is created via `_createRunner()`
+   * (only available on subclasses with a runner factory, e.g. `EnvServer`).
+   */
+  reload(runner?: EnvRunner): Promise<void>;
+  /** Create a fresh runner for argument-less `reload()`. Overridden by subclasses with a runner factory. */
+  protected _createRunner(): EnvRunner | Promise<EnvRunner>;
   fetch: FetchHandler;
+  protected _fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  /**
+   * Lazily satisfy a pending `invalidateModule()` with a single entry reload
+   * before serving — concurrent fetches share the same reload. A failed reload
+   * keeps the invalidation pending, so the next fetch retries.
+   */
+  private _flushInvalidation;
   upgrade: UpgradeHandler;
   sendMessage(message: unknown): void;
   onMessage(listener: RunnerMessageListener): void;
@@ -33,7 +49,14 @@ declare class RunnerManager implements EnvRunner {
     timeout?: number;
   }): Promise<T>;
   reloadModule(timeout?: number): Promise<void>;
+  /**
+   * Invalidate a virtual module on the active runner and mark the manager
+   * dirty: the next `fetch()` reloads the entry automatically, so callers
+   * don't need to pair the call with an explicit `reloadModule()`.
+   */
+  invalidateModule(specifier: string, 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 +79,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,16 +101,31 @@ 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>;
+  /**
+   * Replace the active runner. When called without an argument, a fresh
+   * runner is created from the server options.
+   */
+  reload(runner?: EnvRunner): Promise<void>;
   close(): Promise<void>;
-  private _createRunner;
+  /** Auto-start on first fetch so an explicit `start()` call is optional. */
+  protected _fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  private _start;
+  protected _createRunner(): Promise<EnvRunner>;
   private _startWatching;
   private _stopWatching;
   private _scheduleReload;
@@ -108,4 +146,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 { handleInvalidateModule, 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({
@@ -42,6 +58,10 @@ process.on("message", async (message) => {
 		}
 		return;
 	}
+	if (message?.event === "invalidate-module") {
+		handleInvalidateModule(message, sendMessage);
+		return;
+	}
 	if (message?.type === "ping") {
 		process.send({
 			type: "pong",

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 };