env-runner 0.2.3 → 0.3.0

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

@@ -1,25 +1,37 @@
-import { createVirtualHooks, expandVirtualInvalidation, stripVirtualTypeScript, virtualModuleFormat } from "./virtual-loader.mjs";
-import { pathToFileURL } from "node:url";
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute } from "node:path";
-async function registerVirtualModules(virtual) {
-	if (!virtual || Object.keys(virtual).length === 0) return _noop;
-	const { registerHooks, stripTypeScriptTypes } = await import("node:module");
+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 { 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;
-		let transformSource;
-		if (isDeno) {
-			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 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: /* @__PURE__ */ new Map(),
-			transformSource
+			versions,
+			version: 0,
+			importers,
+			prepare,
+			updateKeys,
+			cache: createRequire(import.meta.url).cache
 		};
-		const hooks = registerHooks(createVirtualHooks(virtual, registration.versions, void 0, isDeno));
 		_hooksRegistrations.unshift(registration);
 		return _once(() => {
 			const index = _hooksRegistrations.indexOf(registration);
@@ -28,74 +40,429 @@ async function registerVirtualModules(virtual) {
 		});
 	}
 	if (typeof globalThis.Bun?.plugin === "function") {
-		_bunVirtual = virtual;
-		_registerBunModules(Object.keys(virtual));
+		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(() => {
-			if (_bunVirtual === virtual) _bunVirtual = void 0;
+			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.x) or `Bun.plugin`; skipping registration.");
+	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) {
-	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));
+	for (const registration of _bunRegistrations) if (Object.hasOwn(registration.virtual, specifier)) {
+		_bustBunModules(registration, [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)`
+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 = [];
-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"
-				};
-			});
+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 _transformSourceForDeno(specifier, source, stripTypeScriptTypes) {
-	const format = virtualModuleFormat(specifier);
-	if (format === "module-typescript") return stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, {
+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"
 	});
-	if (format === "json") return `export default JSON.parse(${JSON.stringify(source)});`;
+	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;
@@ -155,8 +522,13 @@ function toServerOptions(entry) {
 		gracefulShutdown: false
 	};
 }
-function isVirtualSpecifier(specifier, virtual) {
-	return Boolean(specifier && virtual && Object.hasOwn(virtual, specifier));
+function isVirtualSpecifier(specifier, virtual, matchPaths = false) {
+	if (!specifier || !virtual) return false;
+	return Object.hasOwn(virtual, specifier) || matchPaths && findVirtualPathKey(virtual, specifier) !== void 0;
+}
+function isVirtualEntry(entry, virtual = registeredVirtualModules()) {
+	const registerHooks = process.getBuiltinModule?.("node:module")?.registerHooks;
+	return isVirtualSpecifier(entry, virtual, typeof registerHooks === "function");
 }
 async function resolveEntry(entryPath, virtual) {
 	const mod = await (virtual ? import(entryPath) : import(_toImportPath(entryPath)));
@@ -164,6 +536,19 @@ async function resolveEntry(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;
 }
+function formatInitError(error) {
+	const message = error?.message || String(error);
+	if (message.startsWith("[env-runner]") || /:\d+:\d+/.test(message)) return message;
+	const location = _errorLocation(error);
+	return location ? `${message} (at ${location})` : message;
+}
+function _errorLocation(error) {
+	const position = error?.position;
+	if (position?.file) return `${position.file}:${position.line}:${position.column}`;
+	const stack = typeof error?.stack === "string" ? error.stack : "";
+	const location = stack.startsWith(String(error?.name)) ? /\n\s+at (?:async )?(?:.* \()?([^\n()]+:\d+:\d+)\)?/.exec(stack)?.[1] : /^([^\n]+:\d+)\n/.exec(stack)?.[1];
+	return location && !/^(?:node|ext|native):/.test(location) ? location : void 0;
+}
 function parseServerAddress(server) {
 	const url = new URL(server.url);
 	return {
@@ -184,18 +569,24 @@ function _toImportPath(entryPath) {
 	if (isAbsolute(filePath)) return pathToFileURL(filePath).href + query;
 	return entryPath;
 }
+function _toReloadPath(entryPath) {
+	if (!("Bun" in globalThis)) return _toImportPath(entryPath);
+	if (!entryPath.startsWith("file:")) return entryPath;
+	const qIndex = entryPath.indexOf("?");
+	return qIndex === -1 ? fileURLToPath(entryPath) : fileURLToPath(entryPath.slice(0, qIndex)) + entryPath.slice(qIndex);
+}
 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++);
+	if (virtual && refreshVirtualModule(filePath)) mod = await import(filePath);
+	else {
+		const importPath = virtual ? entryPath : _toReloadPath(entryPath);
+		mod = await import(importPath + (importPath.includes("?") ? "&" : "?") + "__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 { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, handleInvalidateModule, isVirtualSpecifier, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions };
+export { RESERVED_RUNTIME_OPTIONS, RESERVED_SERVER_OPTIONS, formatInitError, handleUpdateVirtualModules, isVirtualEntry, parseServerAddress, registerVirtualModules, reloadEntryModule, resolveEntry, toServerOptions };

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

@@ -1,5 +1,4 @@
 import { BaseEnvRunner } from "./common-base-runner.mjs";
-import { hostEnv } from "./common-host-env.mjs";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -45,10 +44,7 @@ var DenoProcessEnvRunner = class extends BaseEnvRunner {
 			...execArgv || [],
 			this._workerEntry
 		], {
-			env: hostEnv({
-				ENV_RUNNER_NAME: this._name,
-				ENV_RUNNER_DATA: JSON.stringify(this._data || {})
-			}),
+			env: this._processEnv(),
 			stdio: [
 				"pipe",
 				"pipe",
@@ -68,7 +64,7 @@ var DenoProcessEnvRunner = 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/_chunks/lexer.mjs

@@ -0,0 +1,2 @@
+import { init, initSync, parse } from "./libs/cjs-module-lexer.mjs";
+export { init, initSync, parse };

package/dist/_chunks/libs/cjs-module-lexer.mjs

@@ -142,4 +142,9 @@ function init() {
 		A = Q;
 	})());
 }
-export { init, parse };
+function initSync() {
+	if (A) return;
+	const B = new WebAssembly.Module(w()), { exports: Q } = new WebAssembly.Instance(B);
+	A = Q;
+}
+export { init, initSync, parse };