env-runner 0.1.10 → 0.1.12

package/dist/_chunks/{runner2.mjs → miniflare-runner.mjs}

@@ -1,11 +1,12 @@
-import { virtualModuleFormat } from "./virtual-loader.mjs";
-import { BaseEnvRunner } from "./base-runner.mjs";
+import { expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
+import { BaseEnvRunner } from "./common-base-runner.mjs";
 import { init, parse } from "./libs/cjs-module-lexer.mjs";
-import { isVirtualSpecifier } from "./worker-utils.mjs";
+import { init as init$1, parse as parse$1 } from "./libs/es-module-lexer.mjs";
+import { isVirtualSpecifier } from "./common-worker-utils.mjs";
 import { createRequire } from "node:module";
 import { proxyUpgrade } from "httpxy";
-import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, resolve } from "node:path";
 import { resolveModulePath } from "exsolve";
 const IPC_PATH = "/__env_runner_ipc";
@@ -184,6 +185,9 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	#miniflareOptions;
 	#transformRequest;
 	#reloadCounter = 0;
+	#virtual;
+	#virtualVersions = /* @__PURE__ */ new Map();
+	#cacheEntry;
 	#ws;
 	#persistent;
 	#cacheKey;
@@ -215,7 +219,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 				this.#ws.close();
 				this.#ws = void 0;
 			}
-			if (this.#cacheKey) _miniflareCache.delete(this.#cacheKey);
+			if (this.#cacheKey && _miniflareCache.get(this.#cacheKey)?.mf === this.#miniflare) _miniflareCache.delete(this.#cacheKey);
 			await this.#miniflare.dispose();
 			this.#miniflare = void 0;
 		}
@@ -224,7 +228,8 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 	async fetch(input, init) {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this.#miniflare || this.closed) return new Response("miniflare env runner is unavailable", { status: 503 });
-		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const resolved = this._resolveFetchInput(input);
+		const url = typeof resolved === "string" ? resolved : resolved instanceof URL ? resolved.href : resolved.url;
 		const res = await this.#miniflare.dispatchFetch(url, init);
 		if (res instanceof Response) return res;
 		return new Response(res.body, {
@@ -251,30 +256,27 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		if (!this.#ws) throw new Error("Miniflare env runner should be initialized before reloading.");
 		if (!this._data?.entry) return;
 		this.#reloadCounter++;
-		const version = this.#reloadCounter;
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error("Module reload timed out"));
-			}, timeout);
-			const listener = (msg) => {
-				if (msg?.event === "module-reloaded") {
-					cleanup();
-					if (msg.error) reject(typeof msg.error === "string" ? new Error(msg.error) : msg.error);
-					else resolve();
-				}
-			};
-			const cleanup = () => {
-				clearTimeout(timer);
-				this.offMessage(listener);
-			};
-			this.onMessage(listener);
-			this.#ws.send(JSON.stringify({
-				type: "reload",
-				version
-			}));
+		await this._request({
+			type: "reload",
+			version: this.#reloadCounter
+		}, {
+			match: (msg) => msg?.event === "module-reloaded",
+			timeout,
+			timeoutError: "Module reload timed out",
+			send: (message) => this.#ws.send(JSON.stringify(message))
 		});
 	}
+	async invalidateModule(specifier, _timeout) {
+		const virtual = this.#virtual;
+		if (!virtual || !Object.hasOwn(virtual, specifier)) {
+			const hasVirtual = Object.keys(this._data?.virtual ?? {}).length > 0;
+			throw !virtual && hasVirtual && !this.closed ? /* @__PURE__ */ new Error("Miniflare env runner should be initialized before invalidating modules.") : /* @__PURE__ */ new Error(`Cannot invalidate "${specifier}" (not a registered virtual module)`);
+		}
+		const source = await this._refreshVirtualSource(specifier);
+		if (source !== void 0) virtual[specifier] = await this.#prepareVirtualSource(specifier, source);
+		for (const key of expandVirtualInvalidation(virtual, specifier)) this.#virtualVersions.set(key, (this.#virtualVersions.get(key) ?? 0) + 1);
+		if (this.#cacheKey && _miniflareCache.get(this.#cacheKey) === this.#cacheEntry) _miniflareCache.delete(this.#cacheKey);
+	}
 	_hasRuntime() {
 		return Boolean(this.#miniflare);
 	}
@@ -288,14 +290,12 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			this.#ws.close();
 			this.#ws = void 0;
 		}
-		if (this.#persistent && this.#cacheKey) {
-			const cached = _miniflareCache.get(this.#cacheKey);
-			if (cached) {
-				cached.refCount--;
-				if (cached.refCount <= 0) {
-					_miniflareCache.delete(this.#cacheKey);
-					await this.#miniflare.dispose();
-				}
+		const entry = this.#cacheEntry;
+		if (entry) {
+			entry.refCount--;
+			if (entry.refCount <= 0) {
+				if (this.#cacheKey && _miniflareCache.get(this.#cacheKey) === entry) _miniflareCache.delete(this.#cacheKey);
+				await this.#miniflare.dispose();
 			}
 		} else await this.#miniflare.dispose();
 		this.#miniflare = void 0;
@@ -322,21 +322,21 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 		const virtual = this._data?.virtual;
 		if (!virtual || Object.keys(virtual).length === 0) return;
 		const out = {};
-		let strip;
-		for (const [specifier, source] of Object.entries(virtual)) if (virtualModuleFormat(specifier) === "module-typescript") {
-			if (!strip) {
-				const { stripTypeScriptTypes } = await import("node:module");
-				if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] virtual TypeScript module "${specifier}" requires \`module.stripTypeScriptTypes\` on the host (workerd does not parse TypeScript); upgrade Node.js or provide a pre-transpiled JavaScript source instead.`);
-				strip = stripTypeScriptTypes;
-			}
-			out[specifier] = strip(source);
-		} else out[specifier] = source;
+		for (const [specifier, source] of Object.entries(virtual)) out[specifier] = await this.#prepareVirtualSource(specifier, source);
 		return out;
 	}
+	async #prepareVirtualSource(specifier, source) {
+		if (virtualModuleFormat(specifier) !== "module-typescript") return source;
+		return stripVirtualTypeScript(specifier, source, await _getStripTypeScriptTypes(), {
+			requirement: "on the host (workerd does not parse TypeScript)",
+			remedy: "upgrade Node.js"
+		});
+	}
 	async #initAsync() {
 		const { Miniflare } = await import("miniflare");
 		const entryPath = this._data?.entry;
 		const virtual = await this.#prepareVirtualModules();
+		this.#virtual = virtual;
 		const userFlags = this.#miniflareOptions.compatibilityFlags || [];
 		const userDirectSockets = this.#miniflareOptions.unsafeDirectSockets || [];
 		const options = {
@@ -395,13 +395,15 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			if (!options.unsafeModuleFallbackService) {
 				const _require = createRequire(entryBase);
 				const _virtual = virtual;
+				const _virtualVersions = this.#virtualVersions;
 				const _transformRequest = this.#transformRequest;
 				const _exportConditions = this.#exportConditions;
+				const _applyVirtualVersions = (code) => applyVirtualVersions(code, _virtualVersions);
 				options.unsafeUseModuleFallbackService = true;
 				const modulePathMap = /* @__PURE__ */ new Map();
-				const _cjsLexerReady = ensureCjsLexer();
+				const _lexersReady = Promise.all([ensureCjsLexer(), init$1]);
 				options.unsafeModuleFallbackService = async (request) => {
-					await _cjsLexerReady;
+					await _lexersReady;
 					const url = new URL(request.url);
 					const specifier = url.searchParams.get("specifier");
 					const rawSpecifier = url.searchParams.get("rawSpecifier");
@@ -424,7 +426,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 								json: source
 							}) : Response.json({
 								name,
-								esModule: source
+								esModule: _applyVirtualVersions(source)
 							});
 						}
 					}
@@ -480,7 +482,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 							modulePathMap.set(name, resolvedPath);
 							return Response.json({
 								name,
-								esModule: result.code
+								esModule: _applyVirtualVersions(result.code)
 							});
 						}
 					} catch {}
@@ -489,7 +491,7 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 						modulePathMap.set(name, resolvedPath);
 						if (resolvedPath.endsWith(".mjs") || !resolvedPath.endsWith(".cjs") && /\b(import\s|import\(|export\s|export\{|import\.meta\b)/.test(contents)) return Response.json({
 							name,
-							esModule: contents
+							esModule: _applyVirtualVersions(contents)
 						});
 						const cjsSuffix = "?__cjs";
 						if (specifier.endsWith(cjsSuffix)) return Response.json({
@@ -517,15 +519,23 @@ var MiniflareEnvRunner = class extends BaseEnvRunner {
 			if (cached) {
 				this.#miniflare = cached.mf;
 				cached.refCount++;
+				this.#cacheEntry = cached;
+				this.#virtual = cached.virtual;
+				this.#virtualVersions = cached.versions;
 			}
 		}
 		if (!this.#miniflare) {
 			this.#miniflare = new Miniflare(options);
 			await this.#miniflare.ready;
-			if (this.#persistent && this.#cacheKey) _miniflareCache.set(this.#cacheKey, {
-				mf: this.#miniflare,
-				refCount: 1
-			});
+			if (this.#persistent && this.#cacheKey) {
+				this.#cacheEntry = {
+					mf: this.#miniflare,
+					refCount: 1,
+					virtual,
+					versions: this.#virtualVersions
+				};
+				_miniflareCache.set(this.#cacheKey, this.#cacheEntry);
+			}
 		}
 		const initRes = await this.#miniflare.dispatchFetch("http://localhost/__env_runner_ipc", { headers: { upgrade: "websocket" } });
 		const ws = initRes.webSocket;
@@ -571,6 +581,35 @@ function computeCacheKey(entryPath, opts) {
 	for (const [k, v] of Object.entries(opts)) if (typeof v !== "function") serializableOpts[k] = v;
 	return `${resolve(entryPath)}::${JSON.stringify(serializableOpts)}`;
 }
+function applyVirtualVersions(code, versions) {
+	if (versions.size === 0) return code;
+	let imports;
+	try {
+		[imports] = parse$1(code);
+	} catch {
+		return code;
+	}
+	let out = "";
+	let last = 0;
+	for (const imp of imports) {
+		let specifier = imp.n;
+		if (specifier === void 0 && imp.d > -1) {
+			const expr = code.slice(imp.s, imp.e);
+			if (expr.length > 1 && expr[0] === "`" && expr.endsWith("`") && !expr.includes("${")) specifier = expr.slice(1, -1);
+		}
+		const version = specifier === void 0 ? void 0 : versions.get(specifier);
+		if (!version) continue;
+		const versioned = `${specifier}?v=${version}`;
+		out += code.slice(last, imp.s) + (imp.d > -1 ? JSON.stringify(versioned) : versioned);
+		last = imp.e;
+	}
+	return out + code.slice(last);
+}
+let _stripTypesPromise;
+function _getStripTypeScriptTypes() {
+	_stripTypesPromise ??= import("node:module").then((m) => m.stripTypeScriptTypes);
+	return _stripTypesPromise;
+}
 let _cjsLexerReady;
 function ensureCjsLexer() {
 	if (!_cjsLexerReady) _cjsLexerReady = init();

package/dist/_chunks/{runner5.d.mts → netlify-runner.d.mts}

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "./types.mjs";
-import { EnvRunnerData } from "./base-runner.mjs";
-import { NodeWorkerEnvRunner } from "./runner3.mjs";
+import { EnvRunnerData } from "./common-base-runner.mjs";
+import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
 declare class NetlifyEnvRunner extends NodeWorkerEnvRunner {
   constructor(opts: {
     name: string;

package/dist/_chunks/{runner5.mjs → netlify-runner.mjs}

@@ -1,4 +1,4 @@
-import { NodeWorkerEnvRunner } from "./runner3.mjs";
+import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
 import { fileURLToPath } from "node:url";
 let _defaultEntry;
 var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
@@ -10,6 +10,7 @@ var NetlifyEnvRunner = class extends NodeWorkerEnvRunner {
 		});
 	}
 	async fetch(input, init) {
+		input = this._resolveFetchInput(input);
 		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
 		const clientIp = headers.get("x-forwarded-for")?.split(",")[0]?.trim() || headers.get("x-real-ip") || "127.0.0.1";
 		if (!headers.has("x-nf-client-connection-ip")) headers.set("x-nf-client-connection-ip", clientIp);

package/dist/_chunks/{runner3.d.mts → node-worker-runner.d.mts}

@@ -1,5 +1,5 @@
 import { WorkerHooks } from "./types.mjs";
-import { BaseEnvRunner, EnvRunnerData } from "./base-runner.mjs";
+import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
 declare class NodeWorkerEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {

package/dist/_chunks/{runner3.mjs → node-worker-runner.mjs}

@@ -1,6 +1,6 @@
-import { BaseEnvRunner } from "./base-runner.mjs";
-import { existsSync } from "node:fs";
+import { BaseEnvRunner } from "./common-base-runner.mjs";
 import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
 import { Worker } from "node:worker_threads";
 let _defaultEntry;
 var NodeWorkerEnvRunner = class extends BaseEnvRunner {

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,18 +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 = (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);
 	};
@@ -94,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;
@@ -202,6 +227,10 @@ var EnvServer = class extends RunnerManager {
 		});
 		return this._startPromise;
 	}
+	async reload(runner) {
+		this.runner = runner ?? await this._createRunner();
+		await super.reload(this.runner);
+	}
 	async close() {
 		this._stopWatching();
 		await super.close();
@@ -211,8 +240,7 @@ var EnvServer = class extends RunnerManager {
 		return super._fetch(input, init);
 	}
 	async _start() {
-		this.runner = await this._createRunner();
-		await this.reload(this.runner);
+		await this.reload();
 		if (this._opts.watch) this._startWatching();
 		return this;
 	}
@@ -245,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);

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;
@@ -67,6 +72,11 @@ 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>;
+  /**
+   * 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). */

package/dist/_chunks/{runner4.d.mts → vercel-runner.d.mts}

@@ -1,6 +1,6 @@
 import { WorkerHooks } from "./types.mjs";
-import { EnvRunnerData } from "./base-runner.mjs";
-import { NodeWorkerEnvRunner } from "./runner3.mjs";
+import { EnvRunnerData } from "./common-base-runner.mjs";
+import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
 declare class VercelEnvRunner extends NodeWorkerEnvRunner {
   constructor(opts: {
     name: string;

package/dist/_chunks/{runner4.mjs → vercel-runner.mjs}

@@ -1,4 +1,4 @@
-import { NodeWorkerEnvRunner } from "./runner3.mjs";
+import { NodeWorkerEnvRunner } from "./node-worker-runner.mjs";
 import { fileURLToPath } from "node:url";
 import { randomBytes } from "node:crypto";
 let _warned = false;
@@ -56,6 +56,7 @@ var VercelEnvRunner = class extends NodeWorkerEnvRunner {
 		warnIfVercelOidcTokenInvalid();
 	}
 	async fetch(input, init) {
+		input = this._resolveFetchInput(input);
 		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
 		const requestId = generateVercelId();
 		if (this._address && this._address.port != null && !headers.has("x-vercel-deployment-url")) {

package/dist/_chunks/virtual-loader.mjs

@@ -1,14 +1,23 @@
+import { pathToFileURL } from "node:url";
 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) {
+function createVirtualHooks(virtual, versions, parentURL = _defaultParentURL()) {
 	const resolve = (specifier, context, nextResolve) => {
-		if (Object.hasOwn(virtual, _stripQuery(specifier))) return {
-			url: VIRTUAL_SCHEME + encodeURIComponent(specifier),
-			shortCircuit: true
-		};
+		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
+			};
+		}
+		if (context.parentURL?.startsWith(VIRTUAL_SCHEME)) return nextResolve(specifier, {
+			...context,
+			parentURL
+		});
 		return nextResolve(specifier, context);
 	};
 	const load = (url, context, nextLoad) => {
@@ -32,8 +41,31 @@ function virtualModuleFormat(specifier) {
 	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, resolveVirtualModules, virtualModuleFormat };
+function _defaultParentURL() {
+	return pathToFileURL(process.cwd() + "/").href;
+}
+export { createVirtualHooks, expandVirtualInvalidation, resolveVirtualModules, stripVirtualTypeScript, virtualModuleFormat };

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 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 { BaseEnvRunner, EnvRunnerData, VirtualModuleSource, VirtualModules } from "./_chunks/common-base-runner.mjs";
+import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
+import { MiniflareEnvRunner, MiniflareEnvRunnerOptions, MiniflareExportInfo, TransformResult } from "./_chunks/miniflare-runner.mjs";
+import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
+import { NetlifyEnvRunner } from "./_chunks/netlify-runner.mjs";
 import { ServerOptions } from "srvx";
 import { Hooks } from "crossws";
 /**
@@ -16,15 +16,30 @@ declare class RunnerManager implements EnvRunner, AsyncDisposable {
   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;
@@ -34,6 +49,12 @@ declare class RunnerManager implements EnvRunner, AsyncDisposable {
     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;
@@ -95,11 +116,16 @@ declare class EnvServer extends RunnerManager {
    * 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>;
   /** 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;
+  protected _createRunner(): Promise<EnvRunner>;
   private _startWatching;
   private _stopWatching;
   private _scheduleReload;

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { BaseEnvRunner } from "./_chunks/base-runner.mjs";
+import { BaseEnvRunner } from "./_chunks/common-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";
+import { DenoProcessEnvRunner } from "./_chunks/deno-process-runner.mjs";
+import { MiniflareEnvRunner } from "./_chunks/miniflare-runner.mjs";
+import { VercelEnvRunner } from "./_chunks/vercel-runner.mjs";
+import { NetlifyEnvRunner } from "./_chunks/netlify-runner.mjs";
 export { BaseEnvRunner, DenoProcessEnvRunner, EnvServer, MiniflareEnvRunner, NetlifyEnvRunner, RunnerManager, VercelEnvRunner, loadRunner };

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

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

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

@@ -1,7 +1,7 @@
-import { BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { BaseEnvRunner } from "../../_chunks/common-base-runner.mjs";
+import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { execSync, spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import { join } from "node:path";
 import { homedir } from "node:os";
 let _defaultEntry;

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

@@ -1,4 +1,4 @@
-import { isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/worker-utils.mjs";
+import { handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry } from "../../_chunks/common-worker-utils.mjs";
 import { serve } from "srvx";
 import { plugin } from "crossws/server";
 process.on("disconnect", () => process.exit(0));
@@ -58,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 { EnvRunnerData } from "../../_chunks/base-runner.mjs";
-import { DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
+import { EnvRunnerData } from "../../_chunks/common-base-runner.mjs";
+import { DenoProcessEnvRunner } from "../../_chunks/deno-process-runner.mjs";
 export { DenoProcessEnvRunner, type EnvRunnerData as DenoProcessEnvRunnerData };

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

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