env-runner 0.2.3 → 0.3.0

package/dist/_chunks/server.mjs

@@ -168,9 +168,16 @@ var RunnerManager = class {
 		await this._runner.reloadModule(timeout);
 		this._moduleInvalidated = false;
 	}
+	async updateVirtualModules(changes, timeout) {
+		const runner = await this._waitForRunner();
+		if (!runner?.updateVirtualModules) throw new Error("Active runner does not support updateVirtualModules()");
+		await runner.updateVirtualModules(changes, timeout);
+		this._moduleInvalidated = true;
+	}
 	async invalidateModule(specifier, timeout) {
-		if (!this._runner?.invalidateModule) throw new Error("Active runner does not support invalidateModule()");
-		await this._runner.invalidateModule(specifier, timeout);
+		const runner = await this._waitForRunner();
+		if (!runner?.invalidateModule) throw new Error("Active runner does not support invalidateModule()");
+		await runner.invalidateModule(specifier, timeout);
 		this._moduleInvalidated = true;
 	}
 	async close() {
@@ -208,11 +215,11 @@ var RunnerManager = class {
 		runner.onMessage(this._internalListener);
 		for (const listener of this._messageListeners) runner.onMessage(listener);
 		const originalClose = runner.close.bind(runner);
-		runner.close = async () => {
-			await originalClose();
+		runner.close = async (cause) => {
+			await originalClose(cause);
 			if (this._runner === runner) {
 				this._runner = void 0;
-				for (const fn of this._closeListeners) fn(this);
+				for (const fn of this._closeListeners) fn(this, cause);
 			}
 		};
 		if (runner.ready) this._flushQueue();
@@ -263,6 +270,7 @@ var EnvServer = class extends RunnerManager {
 	_reloadTimeout;
 	_reloadListeners = /* @__PURE__ */ new Set();
 	_startPromise;
+	_virtual;
 	runner = null;
 	onReload(listener) {
 		this._reloadListeners.add(listener);
@@ -285,6 +293,12 @@ var EnvServer = class extends RunnerManager {
 		this.runner = runner ?? await this._createRunner();
 		await super.reload(this.runner);
 	}
+	async updateVirtualModules(changes, timeout) {
+		const virtual = this._virtual ??= { ...this._opts.data?.virtual };
+		for (const [key, source] of Object.entries(changes)) if (source === null) delete virtual[key];
+		else if (source !== void 0) virtual[key] = source;
+		if (await this._waitForRunner()) await super.updateVirtualModules(changes, timeout);
+	}
 	async close() {
 		this._stopWatching();
 		await super.close();
@@ -305,6 +319,7 @@ var EnvServer = class extends RunnerManager {
 			hooks: this._opts.hooks,
 			data: {
 				...this._opts.data,
+				...this._virtual && { virtual: { ...this._virtual } },
 				entry: this._opts.entry
 			},
 			execArgv: this._opts.execArgv

package/dist/_chunks/types.d.mts

@@ -1,5 +1,35 @@
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
+/**
+ * How a virtual module is served. Code formats are Node's load formats, plus
+ * `jsx`/`tsx` (Bun only). Raw formats follow import attribute types: `text`
+ * default-exports a string, `bytes` a `Uint8Array`, and `wasm` a compiled
+ * `WebAssembly.Module` (like workerd's Wasm modules).
+ */
+export type VirtualModuleFormat = "module" | "commonjs" | "module-typescript" | "commonjs-typescript" | "jsx" | "tsx" | "json" | "text" | "bytes" | "wasm";
+/** A source with an explicit format. */
+export interface VirtualModule {
+  /** Code or text; a `Uint8Array` for the `bytes` and `wasm` formats. */
+  source: string | Uint8Array;
+  /**
+   * Default: by the key's extension (`.cjs`, `.json`, `.ts`, `.wasm`, ...),
+   * else `module` for a string and `bytes` for a `Uint8Array`.
+   */
+  format?: VirtualModuleFormat;
+}
+/** A source whose format follows its key (string or bytes), or a source with its format. */
+export type VirtualModuleContent = string | Uint8Array | VirtualModule;
+/** Factories run on the host: before the worker spawns, and on updates. */
+export type VirtualModuleSource = VirtualModuleContent | (() => VirtualModuleContent | Promise<VirtualModuleContent>);
+/** Virtual modules as a `specifier => source` map. */
+export type VirtualModules = Record<string, VirtualModuleSource>;
+/** Changes to apply to a running map: a source sets (adds or replaces) a key, `null` removes it. */
+export type VirtualModuleUpdates = Record<string, VirtualModuleSource | null>;
+/**
+ * A validated module, as workers receive it: a string follows its key's
+ * extension, any other source carries its format.
+ */
+export type ResolvedVirtualModule = string | Required<VirtualModule>;
 /** Proxy a request to the worker; relative inputs resolve against `http://localhost`. */
 export type FetchHandler = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 /** Callback for receiving messages from the worker. */
@@ -65,6 +95,12 @@ export interface EnvRunner extends RunnerRPCHooks, AsyncDisposable {
   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>;
+  /**
+   * Set (add or replace) and remove (`null`) virtual modules in one round trip.
+   * Changed and removed modules, and their importers, evaluate fresh on the
+   * next `reloadModule()`; a removed key falls through to normal resolution.
+   */
+  updateVirtualModules?(changes: VirtualModuleUpdates, 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.

package/dist/_chunks/virtual-loader.mjs

@@ -1,71 +1,345 @@
-import { pathToFileURL } from "node:url";
+import { Buffer } from "node:buffer";
+import { isAbsolute } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const VIRTUAL_MODULE_FORMATS = /* @__PURE__ */ new Set([
+	"module",
+	"commonjs",
+	"module-typescript",
+	"commonjs-typescript",
+	"jsx",
+	"tsx",
+	"json",
+	"text",
+	"bytes",
+	"wasm"
+]);
+const EXTENSION_FORMATS = {
+	".cjs": "commonjs",
+	".json": "json",
+	".ts": "module-typescript",
+	".mts": "module-typescript",
+	".cts": "commonjs-typescript",
+	".jsx": "jsx",
+	".tsx": "tsx",
+	".wasm": "wasm"
+};
+function virtualModuleFormat(key, module) {
+	return typeof module === "object" ? module.format : _extensionFormat(key) ?? "module";
+}
+function virtualModuleCodeSource(key, module) {
+	if (module === void 0) return;
+	const format = virtualModuleFormat(key, module);
+	if (format === "json" || format === "text" || _isBinaryFormat(format)) return;
+	return typeof module === "string" ? module : module.source;
+}
+function normalizeVirtualModule(key, content) {
+	const module = typeof content === "string" || content instanceof Uint8Array ? { source: content } : content;
+	const source = module?.source;
+	if (typeof source !== "string" && !(source instanceof Uint8Array)) throw new TypeError(`[env-runner] virtual module "${key}" must be a string, a Uint8Array or { source, format }.`);
+	const binary = typeof source !== "string";
+	const format = module.format ?? _extensionFormat(key) ?? (binary ? "bytes" : "module");
+	if (!VIRTUAL_MODULE_FORMATS.has(format)) throw new TypeError(`[env-runner] virtual module "${key}" has an unknown format "${format}" (expected one of: ${[...VIRTUAL_MODULE_FORMATS].join(", ")}).`);
+	if (binary !== _isBinaryFormat(format)) throw new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which needs ${binary ? "a string" : "a Uint8Array"} source.`);
+	if (format === "wasm" && !WebAssembly.validate(source)) throw new TypeError(`[env-runner] virtual module "${key}" is not a valid WebAssembly binary.`);
+	if (typeof content === "string") return content;
+	return {
+		source: binary ? new Uint8Array(source) : source,
+		format
+	};
+}
+function normalizeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, content] of Object.entries(virtual)) out[key] = normalizeVirtualModule(key, content);
+	return out;
+}
 async function resolveVirtualModules(virtual) {
-	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => [key, typeof value === "function" ? await value() : value]));
+	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => {
+		return [key, normalizeVirtualModule(key, typeof value === "function" ? await value() : value)];
+	}));
 	return Object.fromEntries(entries);
 }
+function encodeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && typeof module.source !== "string" ? {
+		source: _toBase64(module.source),
+		format: module.format,
+		encoding: "base64"
+	} : module;
+	return out;
+}
+function decodeVirtualModules(virtual) {
+	const out = {};
+	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && "encoding" in module ? {
+		source: new Uint8Array(Buffer.from(module.source, "base64")),
+		format: module.format
+	} : module;
+	return out;
+}
+function virtualModuleCode(format, source) {
+	if (format === "text") return `export default ${JSON.stringify(source)};\n`;
+	const bytes = [
+		`const base64 = ${JSON.stringify(_toBase64(source))};`,
+		`let bytes;`,
+		`if (typeof Uint8Array.fromBase64 === "function") {`,
+		`  bytes = Uint8Array.fromBase64(base64);`,
+		`} else {`,
+		`  const binary = atob(base64);`,
+		`  bytes = new Uint8Array(binary.length);`,
+		`  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);`,
+		`}`
+	];
+	const value = format === "wasm" ? "new WebAssembly.Module(bytes)" : "bytes";
+	return `${bytes.join("\n")}\nexport default ${value};\n`;
+}
+function unsupportedVirtualJSXError(key, format, runtime) {
+	return /* @__PURE__ */ new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which ${runtime} can't load from memory; pre-transpile it to JavaScript (and pass { source, format: "module" } to keep the key).`);
+}
 const VIRTUAL_SCHEME = "virtual:";
-function createVirtualHooks(virtual, versions, parentURL = _defaultParentURL(), forcePlainModule = false) {
+function createVirtualHooks(virtual, opts = {}) {
+	const { versions, importers, forcePlainModule } = opts;
+	const baseURL = opts.baseURL ?? _defaultBaseURL();
+	const keyURLs = /* @__PURE__ */ new Map();
+	const urlKeys = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(virtual)) {
+		const url = _virtualKeyURL(key);
+		if (url) {
+			keyURLs.set(key, url);
+			urlKeys.set(url, key);
+		}
+	}
+	const keyOf = (url) => {
+		if (url.startsWith(VIRTUAL_SCHEME)) {
+			const key = _virtualURLKey(url);
+			return key !== void 0 && Object.hasOwn(virtual, key) ? key : void 0;
+		}
+		return urlKeys.size > 0 && url.startsWith("file:") ? urlKeys.get(_bareURL(url)) : void 0;
+	};
+	const moduleFiles = importers && /* @__PURE__ */ new Set();
+	const track = (node, context) => {
+		const { parentURL } = context;
+		if (!importers || !parentURL) return;
+		let importer = keyOf(parentURL);
+		if (importer === void 0 && !context.conditions?.includes("require")) {
+			const file = _bareURL(parentURL);
+			importer = moduleFiles.has(file) ? file : void 0;
+		}
+		if (importer !== void 0 && importer !== node) {
+			let set = importers.get(node);
+			if (!set) importers.set(node, set = /* @__PURE__ */ new Set());
+			set.add(importer);
+		}
+	};
+	const serve = (key, url, context) => {
+		track(key, context);
+		if (opts.opaquePathURL && keyURLs.has(key) && opts.opaquePathURL(keyURLs.get(key))) url = _virtualURL(key) + url.slice(_bareURL(url).length);
+		const version = versions?.get(key);
+		return {
+			url: version ? _appendQuery(url, `v=${version}`) : url,
+			shortCircuit: true
+		};
+	};
 	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
-			};
+			const keyURL = keyURLs.get(key);
+			const url = keyURL ? keyURL + specifier.slice(key.length) : _virtualURL(specifier);
+			return serve(key, url, context);
+		}
+		let parentURL = context.parentURL;
+		if (parentURL?.startsWith(VIRTUAL_SCHEME)) {
+			const parentKey = keyOf(parentURL);
+			parentURL = parentKey !== void 0 && keyURLs.get(parentKey) || baseURL;
 		}
-		if (context.parentURL?.startsWith(VIRTUAL_SCHEME)) return nextResolve(specifier, {
+		if (urlKeys.size > 0) {
+			const url = _resolvePathSpecifier(specifier, parentURL);
+			const pathKey = url && urlKeys.get(_bareURL(url));
+			if (pathKey) return serve(pathKey, url, context);
+		}
+		const result = nextResolve(specifier, parentURL === context.parentURL ? context : {
 			...context,
 			parentURL
 		});
-		return nextResolve(specifier, context);
+		const resolvedKey = urlKeys.size > 0 ? urlKeys.get(_bareURL(result.url)) : void 0;
+		if (resolvedKey) return serve(resolvedKey, result.url, context);
+		if (result.url.startsWith("file:")) {
+			const file = _bareURL(result.url);
+			track(file, context);
+			const version = versions?.get(file);
+			if (version) return {
+				...result,
+				url: _appendQuery(result.url, `v=${version}`)
+			};
+		}
+		return result;
 	};
 	const load = (url, context, nextLoad) => {
-		if (url.startsWith(VIRTUAL_SCHEME)) {
-			const key = _stripQuery(decodeURIComponent(url.slice(8)));
-			if (Object.hasOwn(virtual, key)) return {
-				format: forcePlainModule ? "module" : virtualModuleFormat(key),
-				source: virtual[key],
+		const key = keyOf(url);
+		if (key !== void 0) {
+			const module = virtual[key];
+			if (forcePlainModule) return {
+				format: "module",
+				source: module,
+				shortCircuit: true
+			};
+			return {
+				..._nodeLoadResult(key, module),
 				shortCircuit: true
 			};
 		}
-		return nextLoad(url, context);
+		const result = nextLoad(url, context);
+		if (moduleFiles && url.startsWith("file:") && _isModuleFormat(result.format)) moduleFiles.add(_bareURL(url));
+		return result;
+	};
+	const updateKeys = (keys) => {
+		for (const key of keys) {
+			const url = keyURLs.get(key) ?? _virtualKeyURL(key);
+			if (!url) continue;
+			if (Object.hasOwn(virtual, key)) {
+				keyURLs.set(key, url);
+				urlKeys.set(url, key);
+				continue;
+			}
+			keyURLs.delete(key);
+			if (urlKeys.get(url) === key) {
+				urlKeys.delete(url);
+				for (const [other, otherURL] of keyURLs) if (otherURL === url) urlKeys.set(url, other);
+			}
+		}
 	};
 	return {
 		resolve,
-		load
+		load,
+		updateKeys
 	};
 }
-function virtualModuleFormat(specifier) {
-	if (specifier.endsWith(".json")) return "json";
-	if (specifier.endsWith(".ts") || specifier.endsWith(".mts")) return "module-typescript";
-	return "module";
+function _nodeLoadResult(key, module) {
+	const format = virtualModuleFormat(key, module);
+	const source = typeof module === "string" ? module : module.source;
+	if (format === "text" || format === "bytes" || format === "wasm") return {
+		format: "module",
+		source: virtualModuleCode(format, source)
+	};
+	if (format === "jsx" || format === "tsx") throw unsupportedVirtualJSXError(key, format, "Node.js");
+	return {
+		format,
+		source
+	};
 }
 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);
+	try {
+		return stripTypeScriptTypes(source);
+	} catch (error) {
+		throw new SyntaxError(`[env-runner] failed to strip types from virtual module "${specifier}": ${error?.message || error}`, { cause: error });
+	}
 }
-function expandVirtualInvalidation(virtual, specifier) {
-	const invalidated = [specifier];
+function expandVirtualInvalidation(virtual, specifier, importers) {
+	const invalidated = [...new Set(typeof specifier === "string" ? [specifier] : specifier)];
 	const seen = new Set(invalidated);
+	const add = (key) => {
+		if (!seen.has(key)) {
+			seen.add(key);
+			invalidated.push(key);
+		}
+	};
 	for (const target of invalidated) {
+		for (const key of importers?.get(target) ?? []) add(key);
+		if (!Object.hasOwn(virtual, target)) continue;
 		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);
+		for (const [key, module] of Object.entries(virtual)) {
+			const code = virtualModuleCodeSource(key, module);
+			if (code !== void 0 && refs.some((ref) => code.includes(ref))) add(key);
 		}
 	}
 	return invalidated;
 }
+function findVirtualPathKey(virtual, specifier) {
+	const url = _virtualKeyURL(_stripQuery(specifier));
+	if (!url) return;
+	let match;
+	for (const key of Object.keys(virtual)) if (_virtualKeyURL(key) === url) match = key;
+	return match;
+}
+const _warnedPathCollisions = /* @__PURE__ */ new Set();
+function warnVirtualPathCollisions(keys) {
+	try {
+		const urlKeys = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const url = _virtualKeyURL(key);
+			if (!url) continue;
+			const other = urlKeys.get(url);
+			if (other !== void 0 && !_warnedPathCollisions.has(`${other}\0${key}`)) {
+				_warnedPathCollisions.add(`${other}\0${key}`);
+				console.warn(`[env-runner] virtual modules "${other}" and "${key}" name the same file; keep only one of them (which one is served depends on the runtime).`);
+			}
+			urlKeys.set(url, key);
+		}
+	} catch {}
+}
+const virtualKeyURL = _virtualKeyURL;
+function virtualModuleCacheId(key) {
+	const url = _virtualKeyURL(key);
+	return url ? fileURLToPath(url) : _virtualURL(key);
+}
+function _virtualKeyURL(key) {
+	if (key.startsWith("file:")) try {
+		return _bareURL(new URL(key).href);
+	} catch {
+		return;
+	}
+	return isAbsolute(key) ? pathToFileURL(key).href : void 0;
+}
+function _virtualURL(specifier) {
+	return VIRTUAL_SCHEME + specifier.replace(/[\0-\x20"%<>`\x7F-\u{10FFFF}]/gu, encodeURIComponent);
+}
+function _virtualURLKey(url) {
+	try {
+		return decodeURIComponent(_stripQuery(url.slice(8)));
+	} catch {
+		return;
+	}
+}
+function _extensionFormat(key) {
+	const extension = /\.[^./\\]+$/.exec(key)?.[0];
+	return extension === void 0 ? void 0 : EXTENSION_FORMATS[extension];
+}
+function _isBinaryFormat(format) {
+	return format === "bytes" || format === "wasm";
+}
+function _toBase64(bytes) {
+	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+}
+function _isModuleFormat(format) {
+	return format == null || format === "module" || format === "module-typescript";
+}
 function _stripQuery(specifier) {
 	const qIndex = specifier.indexOf("?");
 	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
 }
-function _defaultParentURL() {
+function _bareURL(url) {
+	const index = url.search(/[?#]/);
+	return index === -1 ? url : url.slice(0, index);
+}
+function _appendQuery(url, param) {
+	const hashIndex = url.startsWith(VIRTUAL_SCHEME) ? -1 : url.indexOf("#");
+	const base = hashIndex === -1 ? url : url.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
+	return base + (base.includes("?") ? "&" : "?") + param + hash;
+}
+function _resolvePathSpecifier(specifier, parentURL) {
+	try {
+		if (/^\.{0,2}\//.test(specifier) || specifier.startsWith("file:")) return new URL(specifier, parentURL).href;
+		if (isAbsolute(specifier)) {
+			const path = _stripQuery(specifier);
+			return pathToFileURL(path).href + specifier.slice(path.length);
+		}
+	} catch {}
+}
+function _defaultBaseURL() {
 	return pathToFileURL(process.cwd() + "/").href;
 }
-export { createVirtualHooks, expandVirtualInvalidation, resolveVirtualModules, stripVirtualTypeScript, virtualModuleFormat };
+export { createVirtualHooks, decodeVirtualModules, encodeVirtualModules, expandVirtualInvalidation, findVirtualPathKey, normalizeVirtualModules, resolveVirtualModules, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualKeyURL, virtualModuleCacheId, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat, warnVirtualPathCollisions };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, WorkerAddress, WorkerHooks } from "./_chunks/types.mjs";
-import { BaseEnvRunner, EnvRunnerData, VirtualModuleSource, VirtualModules } from "./_chunks/common-base-runner.mjs";
+import { EnvRunner, FetchHandler, NodeUpgradeContext, RPCOptions, RunnerMessageListener, RunnerRPCHooks, UpgradeContext, UpgradeHandler, VirtualModule, VirtualModuleContent, VirtualModuleFormat, VirtualModuleSource, VirtualModuleUpdates, VirtualModules, WorkerAddress, WorkerHooks } from "./_chunks/types.mjs";
+import { BaseEnvRunner, EnvRunnerData } from "./_chunks/common-base-runner.mjs";
 import { RuntimeDep, resolveRuntimeDep } from "./_chunks/common-runtime-deps.mjs";
 import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
 import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult } from "./_chunks/miniflare-runner.mjs";
@@ -45,6 +45,11 @@ export declare class RunnerManager implements EnvRunner, AsyncDisposable {
     timeout?: number;
   }): Promise<T>;
   reloadModule(timeout?: number): Promise<void>;
+  /**
+   * Set or remove (`null`) virtual modules of the active runner (waiting for it
+   * during a reload); the next `fetch()` reloads the entry automatically.
+   */
+  updateVirtualModules(changes: VirtualModuleUpdates, timeout?: number): Promise<void>;
   /** Invalidate a virtual module; the next `fetch()` reloads the entry automatically. */
   invalidateModule(specifier: string, timeout?: number): Promise<void>;
   close(): Promise<void>;
@@ -56,7 +61,8 @@ export declare class RunnerManager implements EnvRunner, AsyncDisposable {
   private _internalListener;
   private _attach;
   private _detach;
-  private _waitForRunner;
+  /** The active runner, waiting for one during a reload. */
+  protected _waitForRunner(timeout?: number): Promise<EnvRunner | undefined>;
   private _flushQueue;
 }
 type RunnerName = "node-worker" | "node-process" | "bun-process" | "deno-process" | "self" | "miniflare" | "vercel" | "netlify";
@@ -96,6 +102,7 @@ export declare class EnvServer extends RunnerManager {
   private _reloadTimeout;
   private _reloadListeners;
   private _startPromise;
+  private _virtual;
   runner: Awaited<ReturnType<typeof loadRunner>> | null;
   /** Register a listener called when the runner is reloaded due to a file change. */
   onReload(listener: () => void): void;
@@ -109,6 +116,12 @@ export declare class EnvServer extends RunnerManager {
   start(): Promise<this>;
   /** Replace the active runner; without an argument, create one from the server options. */
   reload(runner?: EnvRunner): Promise<void>;
+  /**
+   * Also kept in the server's own map, so runners it creates later (`reload()`,
+   * watch mode) start with the changes. Without an active runner (before the
+   * first start), the changes are only recorded.
+   */
+  updateVirtualModules(changes: VirtualModuleUpdates, timeout?: number): Promise<void>;
   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>;
@@ -149,4 +162,4 @@ export declare const RESERVED_RUNTIME_OPTIONS: {
 };
 /** Callers add `fetch` (bound lazily so reloads swap it) and the crossws plugin. */
 export declare function toServerOptions(entry: AppEntry): Omit<ServerOptions, "fetch">;
-export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type RuntimeDep, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModuleSource, type VirtualModules, type WorkerAddress, type WorkerHooks, resolveRuntimeDep };
+export { type AppEntry, type AppEntryIPC, type AppEntryIPCContext, BaseEnvRunner, DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData, type EnvRunner, type EnvRunnerData, type EnvServerOptions, type FetchHandler, type LoadRunnerOptions, MiniflareEnvRunner, type MiniflareEnvRunnerOptions, type MiniflareExportInfo, NetlifyEnvRunner, type NodeUpgradeContext, type RPCOptions, type RunnerMessageListener, type RunnerName, type RunnerRPCHooks, type RuntimeDep, type TransformResult, type UpgradeContext, type UpgradeHandler, VercelEnvRunner, type VirtualModule, type VirtualModuleContent, type VirtualModuleFormat, type VirtualModuleSource, type VirtualModuleUpdates, type VirtualModules, type WorkerAddress, type WorkerHooks, resolveRuntimeDep };

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

@@ -1,8 +1,7 @@
 import { BaseEnvRunner } from "../../_chunks/common-base-runner.mjs";
-import { hostEnv } from "../../_chunks/common-host-env.mjs";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { homedir } from "node:os";
 let _defaultEntry;
@@ -57,10 +56,7 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 			this.close(`process entry not found in "${this._workerEntry}".`);
 			return;
 		}
-		const env = hostEnv({
-			ENV_RUNNER_NAME: this._name,
-			ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-		});
+		const env = this._processEnv();
 		if (_isBun) this.#initBunProcess(execArgv, env);
 		else this.#initNodeProcess(execArgv, env);
 	}
@@ -78,7 +74,7 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 				"pipe"
 			],
 			ipc: (message) => {
-				this._handleMessage(message);
+				this._handleProcessMessage(message);
 			}
 		});
 		const child = {
@@ -128,7 +124,7 @@ var BunProcessEnvRunner = class extends BaseEnvRunner {
 			}
 		});
 		child.on("message", (message) => {
-			this._handleMessage(message);
+			this._handleProcessMessage(message);
 		});
 		child.stdout?.pipe(process.stdout);
 		child.stderr?.pipe(process.stderr);

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

@@ -1,16 +1,16 @@
-import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
+import { formatInitError, handleUpdateVirtualModules, isVirtualEntry, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions } from "../../_chunks/common-worker-utils.mjs";
+import { receiveProcessData } from "../../_chunks/common-process-data.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 || "{}");
+const data = await receiveProcessData();
 const sendMessage = (message) => process.send(message);
-const virtualEntry = isVirtualSpecifier(data.entry, data.virtual);
 let unregisterVirtualModules;
 let entry;
 let server;
 try {
 	unregisterVirtualModules = await registerVirtualModules(data.virtual);
-	entry = await resolveEntry(data.entry, virtualEntry);
+	entry = await resolveEntry(data.entry, isVirtualEntry(data.entry));
 	server = serve({
 		...toServerOptions(entry),
 		fetch: (request) => entry.fetch(request),
@@ -18,7 +18,7 @@ try {
 	});
 	await server.ready();
 } catch (error) {
-	const message = error?.message || String(error);
+	const message = formatInitError(error);
 	sendMessage({
 		event: "init-error",
 		error: message
@@ -45,7 +45,7 @@ process.on("message", async (message) => {
 	}
 	if (message?.event === "reload-module") {
 		try {
-			entry = await reloadEntryModule(data.entry, entry, sendMessage, virtualEntry);
+			entry = await reloadEntryModule(data.entry, entry, sendMessage, isVirtualEntry(data.entry));
 			process.send({ event: "module-reloaded" });
 		} catch (error) {
 			process.send({
@@ -55,8 +55,8 @@ process.on("message", async (message) => {
 		}
 		return;
 	}
-	if (message?.event === "invalidate-module") {
-		handleInvalidateModule(message, sendMessage);
+	if (message?.event === "update-virtual-modules") {
+		handleUpdateVirtualModules(message, sendMessage);
 		return;
 	}
 	if (message?.type === "ping") {