env-runner 0.3.0 → 0.3.2

package/dist/_chunks/common-worker-utils.mjs

@@ -1,478 +1,7 @@
-import { createVirtualHooks, decodeVirtualModules, expandVirtualInvalidation, findVirtualPathKey, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualKeyURL, virtualModuleCacheId, virtualModuleCode, virtualModuleFormat } from "./virtual-loader.mjs";
-import { basename, dirname, isAbsolute, resolve, sep } from "node:path";
+import { PLUGINS_DATA_KEY, findVirtualPathKey, refreshVirtualModule, registerPluginHooks, registerVirtualModules, registeredVirtualModules, servedByPluginHooks } from "./plugin-hooks.mjs";
+import { createRequire } from "node:module";
+import { isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-async function registerVirtualModules(wire) {
-	if (!wire || Object.keys(wire).length === 0) return _once(() => {
-		for (const unregister of _lazyUnregisters.splice(0)) unregister();
-	});
-	let virtual = decodeVirtualModules(wire);
-	const { registerHooks, stripTypeScriptTypes, createRequire } = await import("node:module");
-	if (typeof registerHooks === "function") {
-		const isDeno = "Deno" in globalThis;
-		const prepare = isDeno ? (key, module) => _prepareForDeno(key, module, stripTypeScriptTypes) : _prepareForNode;
-		virtual = await _prepareVirtualModules(virtual, prepare);
-		const versions = /* @__PURE__ */ new Map();
-		const importers = /* @__PURE__ */ new Map();
-		const { resolve, load, updateKeys } = createVirtualHooks(virtual, {
-			versions,
-			importers,
-			forcePlainModule: isDeno,
-			opaquePathURL: isDeno ? (url) => url.endsWith(".cjs") || url.endsWith(".cts") : void 0
-		});
-		const hooks = registerHooks({
-			resolve,
-			load
-		});
-		const registration = {
-			virtual,
-			versions,
-			version: 0,
-			importers,
-			prepare,
-			updateKeys,
-			cache: createRequire(import.meta.url).cache
-		};
-		_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") {
-		virtual = await _prepareVirtualModules(virtual, _prepareForBun);
-		const registration = _createBunRegistration(virtual, createRequire(import.meta.url).cache);
-		globalThis.Bun.plugin({
-			name: "env-runner-virtual",
-			setup: (build) => _setupBunPlugin(build, registration)
-		});
-		_bunRegistrations.unshift(registration);
-		return _once(() => {
-			const index = _bunRegistrations.indexOf(registration);
-			if (index !== -1) _bunRegistrations.splice(index, 1);
-			for (const path of [...registration.paths.keys(), ...registration.removed.keys()]) _bunReleasedPaths.add(path);
-		});
-	}
-	console.warn("[env-runner] virtual modules require `module.registerHooks` (Node.js >= 22.15 / Deno >= 2.8) or `Bun.plugin`; skipping registration.");
-	return _noop;
-}
-function refreshVirtualModule(specifier) {
-	for (const registration of _bunRegistrations) if (Object.hasOwn(registration.virtual, specifier)) {
-		_bustBunModules(registration, [specifier]);
-		return true;
-	}
-	return false;
-}
-async function updateVirtualModules(wire) {
-	const changes = decodeVirtualModules(wire);
-	if (_hooksRegistrations.length === 0 && _bunRegistrations.length === 0) {
-		const added = Object.fromEntries(Object.entries(changes).filter((entry) => entry[1] !== null));
-		if (Object.keys(added).length === 0) return;
-		const unregister = await registerVirtualModules(added);
-		if (_hooksRegistrations.length === 0 && _bunRegistrations.length === 0) throw new Error("Cannot update virtual modules: this runtime can't serve them");
-		_lazyUnregisters.push(unregister);
-	}
-	const registrations = _hooksRegistrations.length > 0 ? _hooksRegistrations : _bunRegistrations;
-	const groups = /* @__PURE__ */ new Map();
-	for (const [key, module] of Object.entries(changes)) {
-		const owner = registrations.find((registration) => Object.hasOwn(registration.virtual, key)) ?? (module === null ? void 0 : registrations[0]);
-		if (owner) {
-			let group = groups.get(owner);
-			if (!group) groups.set(owner, group = {});
-			group[key] = module;
-		}
-	}
-	const prepared = [];
-	for (const [registration, group] of groups) {
-		const prepare = "prepare" in registration ? registration.prepare : _prepareForBun;
-		prepared.push([registration, await _prepareVirtualModules(group, prepare)]);
-	}
-	for (const [registration, sources] of prepared) if ("updateKeys" in registration) _updateHooksRegistration(registration, sources);
-	else _updateBunRegistration(registration, sources);
-}
-function handleUpdateVirtualModules(message, sendMessage) {
-	_pendingUpdate = _pendingUpdate.then(() => updateVirtualModules(message.changes ?? {})).then(() => sendMessage({
-		event: "virtual-modules-updated",
-		id: message.id
-	}), (error) => sendMessage({
-		event: "virtual-modules-updated",
-		id: message.id,
-		error: error?.message || String(error)
-	})).catch(() => {});
-	return _pendingUpdate;
-}
-function registeredVirtualModules() {
-	const merged = {};
-	for (const registration of [..._hooksRegistrations, ..._bunRegistrations].reverse()) Object.assign(merged, registration.virtual);
-	return merged;
-}
-let _pendingUpdate = Promise.resolve();
-const _lazyUnregisters = [];
-function _updateHooksRegistration(registration, changes) {
-	const { virtual, versions, importers } = registration;
-	const added = [];
-	const removed = [];
-	for (const [key, module] of Object.entries(changes)) {
-		if (module === null) {
-			removed.push(key);
-			continue;
-		}
-		if (!Object.hasOwn(virtual, key)) added.push(key);
-		virtual[key] = module;
-	}
-	registration.updateKeys(added);
-	const targets = Object.keys(changes).flatMap((key) => {
-		const url = virtualKeyURL(key);
-		return url && url !== key ? [key, url] : [key];
-	});
-	for (const node of expandVirtualInvalidation(virtual, targets, importers)) {
-		versions.set(node, ++registration.version);
-		if (Object.hasOwn(virtual, node)) delete registration.cache[virtualModuleCacheId(node)];
-	}
-	for (const key of removed) delete virtual[key];
-	registration.updateKeys(removed);
-}
-const _hooksRegistrations = [];
-const _bunRegistrations = [];
-const BUN_NAMESPACE = "env-runner-virtual";
-const BUN_VIRTUAL_MARKER = "__env_runner_virtual";
-const BUN_DISK_MARKER = "__env_runner_disk";
-let _bunNamespaceLoader = false;
-let _bunDynamicCallbacks = false;
-const _bunDynamicNames = /* @__PURE__ */ new Set();
-const _bunReleasedPaths = /* @__PURE__ */ new Set();
-function _createBunRegistration(virtual, cache) {
-	const registration = {
-		virtual,
-		paths: /* @__PURE__ */ new Map(),
-		namespaced: /* @__PURE__ */ new Set(),
-		modules: /* @__PURE__ */ new Set(),
-		dynamic: /* @__PURE__ */ new Set(),
-		removed: /* @__PURE__ */ new Map(),
-		versions: /* @__PURE__ */ new Map(),
-		version: 0,
-		importers: /* @__PURE__ */ new Map(),
-		served: /* @__PURE__ */ new Map(),
-		cache
-	};
-	for (const key of Object.keys(virtual)) _addBunKey(registration, key);
-	return registration;
-}
-function _addBunKey(registration, key) {
-	const path = _keyPath(key);
-	if (path === void 0) {
-		(!key.includes(":") && _bunResolvable(key) ? registration.namespaced : registration.modules).add(key);
-		return false;
-	}
-	if (_bunResolvable(basename(path))) {
-		registration.paths.set(path, key);
-		registration.removed.delete(path);
-		return true;
-	}
-	registration.modules.add(key);
-	return false;
-}
-function _setupBunPlugin(build, registration) {
-	registration.build = build;
-	const query = String.raw`(?:\?.*)?$`;
-	const resolveFilters = [...[...registration.namespaced].map((key) => `^${_escapeRegExp(key)}${query}`), ...[...registration.paths.keys()].map((path) => String.raw`(?:^|[\\/])${_escapeRegExp(basename(path))}${query}`)];
-	if (resolveFilters.length > 0) build.onResolve({ filter: new RegExp(resolveFilters.join("|")) }, _resolveBunModule);
-	if (registration.paths.size > 0) {
-		const paths = [...registration.paths.keys()].map(_escapeRegExp).join("|");
-		const loadQuery = String.raw`(?:\?(?!${BUN_DISK_MARKER}(?:&|$)).*)?$`;
-		build.onLoad({ filter: new RegExp(`^(?:${paths})${loadQuery}`) }, _loadBunPath);
-	}
-	if (registration.namespaced.size > 0 && !_bunNamespaceLoader) {
-		_bunNamespaceLoader = true;
-		build.onLoad({
-			filter: /.*/,
-			namespace: BUN_NAMESPACE
-		}, _loadBunNamespaced);
-	}
-	for (const key of registration.modules) build.module(key, () => _loadBunModule(key));
-}
-function _installBunDynamicCallbacks(build) {
-	if (!_bunDynamicCallbacks) {
-		_bunDynamicCallbacks = true;
-		build.onResolve({ filter: /.*/ }, _resolveBunDynamic);
-		const marker = new RegExp(String.raw`\?${BUN_VIRTUAL_MARKER}(?:&|$)`);
-		build.onLoad({ filter: marker }, _loadBunPath);
-	}
-	if (!_bunNamespaceLoader) {
-		_bunNamespaceLoader = true;
-		build.onLoad({
-			filter: /.*/,
-			namespace: BUN_NAMESPACE
-		}, _loadBunNamespaced);
-	}
-}
-function _updateBunRegistration(registration, changes) {
-	const { virtual } = registration;
-	const removed = [];
-	let dynamic = false;
-	for (const [key, source] of Object.entries(changes)) {
-		if (source === null) {
-			removed.push(key);
-			continue;
-		}
-		if (!Object.hasOwn(virtual, key)) {
-			const path = _keyPath(key);
-			if (_addBunKey(registration, key)) {
-				registration.dynamic.add(path);
-				_bunDynamicNames.add(_bunSpecifierName(path));
-			} else if (registration.namespaced.has(key)) _bunDynamicNames.add(_bunSpecifierName(key));
-			dynamic ||= !registration.modules.has(key);
-		}
-		virtual[key] = source;
-	}
-	if (dynamic) _installBunDynamicCallbacks(registration.build);
-	_bustBunModules(registration, expandVirtualInvalidation(virtual, Object.keys(changes), registration.importers));
-	for (const key of removed) _removeBunKey(registration, key);
-}
-function _removeBunKey(registration, key) {
-	const { virtual, paths } = registration;
-	delete virtual[key];
-	registration.namespaced.delete(key);
-	registration.modules.delete(key);
-	const path = _keyPath(key);
-	if (path === void 0 || paths.get(path) !== key) return;
-	paths.delete(path);
-	registration.dynamic.delete(path);
-	registration.removed.set(path, key);
-	for (const other of Object.keys(virtual)) if (_keyPath(other) === path) {
-		paths.set(path, other);
-		registration.removed.delete(path);
-	}
-}
-function _resolveBunModule(args) {
-	const specifier = _stripQuery(args.path);
-	const query = _stripBunMarker(args.path.slice(specifier.length));
-	let path;
-	if (isAbsolute(specifier)) path = resolve(specifier);
-	else if (/^\.\.?[\\/]/.test(specifier)) path = resolve(_bunImporterDir(args.importer), specifier);
-	for (const registration of _bunRegistrations) {
-		const namespaced = registration.namespaced.has(specifier);
-		const key = namespaced ? specifier : path && registration.paths.get(path);
-		if (!key) continue;
-		_addBunImporter(registration, key, args.importer);
-		const marker = !namespaced && registration.dynamic.has(path) ? BUN_VIRTUAL_MARKER : void 0;
-		const served = _bunVersioned((namespaced ? specifier : path) + _withBunMarker(query, marker), registration.versions.get(key));
-		_addToSetMap(registration.served, key, namespaced ? `${BUN_NAMESPACE}:${served}` : served);
-		return namespaced ? {
-			path: served,
-			namespace: BUN_NAMESPACE
-		} : { path: served };
-	}
-	for (const registration of _bunRegistrations) {
-		const key = path && registration.removed.get(path);
-		if (!key) continue;
-		_addBunImporter(registration, key, args.importer);
-		const served = _bunVersioned(path + _withBunMarker(query, BUN_DISK_MARKER), registration.versions.get(key));
-		_addToSetMap(registration.served, key, served);
-		return { path: served };
-	}
-	if (path && _bunReleasedPaths.has(path)) return { path: path + _withBunMarker(query, BUN_DISK_MARKER) };
-}
-function _resolveBunDynamic(args) {
-	const name = _bunSpecifierName(_stripQuery(args.path));
-	return _bunDynamicNames.has(name) ? _resolveBunModule(args) : void 0;
-}
-function _bunSpecifierName(specifier) {
-	return specifier.slice(Math.max(specifier.lastIndexOf("/"), specifier.lastIndexOf("\\")) + 1);
-}
-function _addBunImporter(registration, key, importerId) {
-	const importer = _bunKeyOf(registration, importerId);
-	if (importer !== void 0 && importer !== key) _addToSetMap(registration.importers, key, importer);
-}
-function _withBunMarker(query, marker) {
-	if (!marker) return query;
-	return `?${marker}` + (query ? `&${query.slice(1)}` : "");
-}
-function _stripBunMarker(query) {
-	for (const marker of [BUN_VIRTUAL_MARKER, BUN_DISK_MARKER]) {
-		if (query === `?${marker}`) return "";
-		if (query.startsWith(`?${marker}&`)) return `?${query.slice(marker.length + 2)}`;
-	}
-	return query;
-}
-function _loadBunPath(args) {
-	const path = _stripQuery(args.path);
-	for (const registration of _bunRegistrations) {
-		const key = registration.paths.get(path);
-		if (key !== void 0) return _serveBunModule(key, registration.virtual[key]);
-	}
-}
-function _loadBunNamespaced(args) {
-	const key = _stripQuery(args.path);
-	return _serveBunModule(key, _bunRegistrations.find((r) => r.namespaced.has(key))?.virtual[key]);
-}
-function _loadBunModule(key) {
-	return _serveBunModule(key, _bunRegistrations.find((r) => r.modules.has(key))?.virtual[key]);
-}
-function _serveBunModule(key, module) {
-	if (module === void 0) throw new Error(`Cannot find virtual module "${key}" (unregistered)`);
-	const format = virtualModuleFormat(key, module);
-	const source = typeof module === "string" ? module : module.source;
-	switch (format) {
-		case "json": return {
-			exports: { default: _parseBunJSON(key, source) },
-			loader: "object"
-		};
-		case "text": return {
-			exports: { default: source },
-			loader: "object"
-		};
-		case "bytes": return {
-			exports: { default: source.slice() },
-			loader: "object"
-		};
-		case "wasm": return {
-			exports: { default: new WebAssembly.Module(source) },
-			loader: "object"
-		};
-	}
-	return {
-		contents: source,
-		loader: format === "module-typescript" ? "ts" : format === "module" ? "js" : format
-	};
-}
-function _parseBunJSON(key, source) {
-	try {
-		return JSON.parse(source);
-	} catch (error) {
-		const message = `[env-runner] invalid JSON in virtual module "${key}": ${error?.message}`;
-		throw new SyntaxError(message, { cause: error });
-	}
-}
-function _bustBunModules(registration, keys) {
-	for (const key of keys) {
-		if (registration.modules.has(key)) {
-			registration.build.module(key, () => _loadBunModule(key));
-			continue;
-		}
-		registration.versions.set(key, ++registration.version);
-		for (const id of registration.served.get(key) ?? []) delete registration.cache[id];
-		registration.served.delete(key);
-	}
-}
-function _bunVersioned(id, version) {
-	const param = `v=${version}`;
-	if (!version || id.endsWith(`?${param}`) || id.endsWith(`&${param}`)) return id;
-	return id + (id.includes("?") ? "&" : "?") + param;
-}
-function _keyPath(key) {
-	if (key.startsWith("file:")) try {
-		return fileURLToPath(key);
-	} catch {
-		return;
-	}
-	return isAbsolute(key) ? resolve(key) : void 0;
-}
-function _bunKeyOf(registration, importer) {
-	const prefix = `${BUN_NAMESPACE}:`;
-	const id = _stripQuery(importer.startsWith(prefix) ? importer.slice(prefix.length) : importer);
-	return registration.paths.get(id) ?? (Object.hasOwn(registration.virtual, id) ? id : void 0);
-}
-function _bunImporterDir(importer) {
-	const path = _stripQuery(importer);
-	return isAbsolute(path) ? dirname(path) : process.cwd();
-}
-function _bunResolvable(specifier) {
-	const dot = specifier.lastIndexOf(".");
-	const code = dot === -1 ? 0 : specifier.charCodeAt(dot + 1);
-	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code > 127;
-}
-function _stripQuery(specifier) {
-	const qIndex = specifier.indexOf("?");
-	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
-}
-function _addToSetMap(map, key, value) {
-	let set = map.get(key);
-	if (!set) map.set(key, set = /* @__PURE__ */ new Set());
-	set.add(value);
-}
-function _escapeRegExp(value) {
-	return value.replace(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
-}
-async function _prepareVirtualModules(virtual, prepare) {
-	if (prepare !== _prepareForNode && !_cjsLexer) {
-		if (Object.entries(virtual).some(([key, module]) => module !== null && virtualModuleFormat(key, module).startsWith("commonjs"))) {
-			const lexer = await import("./lexer.mjs");
-			await lexer.init();
-			_cjsLexer = lexer;
-		}
-	}
-	const out = {};
-	for (const [key, module] of Object.entries(virtual)) out[key] = module === null ? module : prepare(key, module);
-	return out;
-}
-let _cjsLexer;
-function _prepareForNode(key, module) {
-	const format = virtualModuleFormat(key, module);
-	if (format === "jsx" || format === "tsx") throw unsupportedVirtualJSXError(key, format, "Node.js");
-	return module;
-}
-function _prepareForBun(key, module) {
-	const format = virtualModuleFormat(key, module);
-	if (format !== "commonjs" && format !== "commonjs-typescript") return module;
-	return {
-		source: _commonJSToESM(key, typeof module === "string" ? module : module.source),
-		format: format === "commonjs" ? "module" : "module-typescript"
-	};
-}
-function _prepareForDeno(key, module, stripTypeScriptTypes) {
-	const format = virtualModuleFormat(key, module);
-	const source = typeof module === "string" ? module : module.source;
-	const strip = () => stripVirtualTypeScript(key, source, stripTypeScriptTypes, {
-		requirement: "(custom load hooks bypass Deno's native type stripping)",
-		remedy: "upgrade Deno"
-	});
-	switch (format) {
-		case "module-typescript": return strip();
-		case "commonjs": return _commonJSToESM(key, source);
-		case "commonjs-typescript": return _commonJSToESM(key, strip());
-		case "json": return `export default JSON.parse(${JSON.stringify(source)});`;
-		case "text":
-		case "bytes":
-		case "wasm": return virtualModuleCode(format, source);
-		case "jsx":
-		case "tsx": throw unsupportedVirtualJSXError(key, format, "Deno");
-	}
-	return source;
-}
-function _commonJSToESM(key, source) {
-	const path = _keyPath(key);
-	const filename = JSON.stringify(path ?? key);
-	const dir = JSON.stringify(path ? dirname(path) : process.cwd());
-	const base = JSON.stringify(path ?? process.cwd() + sep);
-	let names = [];
-	try {
-		names = _cjsLexer.parse(source).exports;
-	} catch {}
-	const p = "__envRunner";
-	const lines = [
-		`import { createRequire as ${p}CreateRequire } from "node:module"; const ${p}Module = { exports: {} }; (function (exports, require, module, __filename, __dirname) {${source}`,
-		`}).call(${p}Module.exports, ${p}Module.exports, ${p}CreateRequire(${base}), ${p}Module, ${filename}, ${dir});`,
-		`const ${p}Exports = ${p}Module.exports;`,
-		`export { ${p}Exports as default, ${p}Exports as "module.exports" };`
-	];
-	let index = 0;
-	for (const name of new Set(names)) if (name !== "default" && name !== "module.exports") {
-		const local = `${p}Export${index++}`;
-		lines.push(`const ${local} = ${p}Exports?.[${JSON.stringify(name)}];`, `export { ${local} as ${JSON.stringify(name)} };`);
-	}
-	return lines.join("\n") + "\n";
-}
-const _noop = () => {};
-function _once(fn) {
-	let done = false;
-	return () => {
-		if (!done) {
-			done = true;
-			fn();
-		}
-	};
-}
 const RESERVED_SERVER_OPTIONS = [
 	"port",
 	"hostname",
@@ -530,6 +59,15 @@ function isVirtualEntry(entry, virtual = registeredVirtualModules()) {
 	const registerHooks = process.getBuiltinModule?.("node:module")?.registerHooks;
 	return isVirtualSpecifier(entry, virtual, typeof registerHooks === "function");
 }
+async function registerWorkerHooks(data) {
+	const unregisterVirtualFirst = "Bun" in globalThis ? await registerVirtualModules(data.virtual) : void 0;
+	const unregisterPlugins = await registerPluginHooks(data[PLUGINS_DATA_KEY], data.entry);
+	const unregisterVirtual = unregisterVirtualFirst ?? await registerVirtualModules(data.virtual);
+	return () => {
+		unregisterVirtual();
+		unregisterPlugins();
+	};
+}
 async function resolveEntry(entryPath, virtual) {
 	const mod = await (virtual ? import(entryPath) : import(_toImportPath(entryPath)));
 	const entry = mod.default || mod;
@@ -537,7 +75,7 @@ async function resolveEntry(entryPath, virtual) {
 	return entry;
 }
 function formatInitError(error) {
-	const message = error?.message || String(error);
+	const message = (error?.message || String(error)).replace(/^(?:Error: )+(?=\[env-runner\])/, "");
 	if (message.startsWith("[env-runner]") || /:\d+:\d+/.test(message)) return message;
 	const location = _errorLocation(error);
 	return location ? `${message} (at ${location})` : message;
@@ -580,7 +118,11 @@ async function _importFresh(entryPath, virtual) {
 	const qIndex = entryPath.indexOf("?");
 	const filePath = qIndex === -1 ? entryPath : entryPath.slice(0, qIndex);
 	let mod;
-	if (virtual && refreshVirtualModule(filePath)) mod = await import(filePath);
+	const bunPath = filePath.startsWith("file:") ? fileURLToPath(filePath) : filePath;
+	if (!virtual && "Bun" in globalThis && servedByPluginHooks(bunPath)) {
+		delete createRequire(import.meta.url).cache[bunPath];
+		mod = await import(bunPath);
+	} else if (virtual && refreshVirtualModule(filePath)) mod = await import(filePath);
 	else {
 		const importPath = virtual ? entryPath : _toReloadPath(entryPath);
 		mod = await import(importPath + (importPath.includes("?") ? "&" : "?") + "__envRunnerReload=" + _reloadCounter++);
@@ -589,4 +131,4 @@ async function _importFresh(entryPath, virtual) {
 	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 { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, formatInitError, handleUpdateVirtualModules, isVirtualEntry, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions };
+export { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, formatInitError, isVirtualEntry, parseServerAddress, registerWorkerHooks, reloadEntryModule, resolveEntry, toServerOptions };

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

@@ -1,5 +1,5 @@
 import { WorkerHooks } from "./types.mjs";
-import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
+import { BaseEnvRunner, EnvRunnerData, EnvRunnerPluginOption } from "./common-base-runner.mjs";
 export declare class DenoProcessEnvRunner extends BaseEnvRunner {
   #private;
   constructor(opts: {
@@ -7,10 +7,13 @@ export declare class DenoProcessEnvRunner extends BaseEnvRunner {
     workerEntry?: string;
     hooks?: WorkerHooks;
     data?: EnvRunnerData;
+    /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+    plugins?: EnvRunnerPluginOption[];
     execArgv?: string[];
   });
   sendMessage(message: unknown): void;
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
+  protected _resolveConditions(): string[];
   protected _closeRuntime(): Promise<void>;
 }

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

@@ -23,6 +23,13 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 	_runtimeType() {
 		return "process";
 	}
+	_resolveConditions() {
+		return [
+			"deno",
+			"node",
+			"import"
+		];
+	}
 	async _closeRuntime() {
 		if (!this.#process) return;
 		this.#process.removeAllListeners();

package/dist/_chunks/miniflare-runner.d.mts

@@ -1,8 +1,8 @@
 import { ResolvedVirtualModule, WorkerHooks } from "./types.mjs";
-import { BaseEnvRunner, EnvRunnerData } from "./common-base-runner.mjs";
+import { BaseEnvRunner, EnvRunnerData, EnvRunnerPluginOption } from "./common-base-runner.mjs";
 import { RuntimeDep } from "./common-runtime-deps.mjs";
-import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
+import { IncomingMessage } from "node:http";
 /** The `wrangler` package namespace, as imported by the app. */
 export interface WranglerModule {
   unstable_readConfig?: (...args: any[]) => any;
@@ -32,6 +32,8 @@ export interface MiniflareEnvRunnerOptions {
   name: string;
   hooks?: WorkerHooks;
   data?: EnvRunnerData;
+  /** Host-side transform plugins (see `EnvRunnerPluginOption`). */
+  plugins?: EnvRunnerPluginOption[];
   /**
    * The `miniflare` package (`import * as miniflare from "miniflare"`) or a
    * specifier resolved from cwd. Omitted: imported optionally.
@@ -123,6 +125,7 @@ export declare class MiniflareEnvRunner extends BaseEnvRunner {
   protected _applyVirtualUpdates(changes: Record<string, ResolvedVirtualModule | null>): Promise<void>;
   protected _hasRuntime(): boolean;
   protected _runtimeType(): string;
+  protected _resolveConditions(): string[];
   protected _closeRuntime(): Promise<void>;
   upgrade(context: {
     node: {