env-runner 0.2.3 → 0.3.1

package/dist/_chunks/plugin-hooks.mjs

@@ -0,0 +1,1656 @@
+import { init, parse } from "./libs/es-module-lexer.mjs";
+import { Buffer } from "node:buffer";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
+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]) => {
+		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, 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$1(specifier);
+		if (Object.hasOwn(virtual, key)) {
+			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 (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
+		});
+		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) => {
+		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
+			};
+		}
+		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,
+		updateKeys
+	};
+}
+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.`);
+	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, 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, 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$1(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$1(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$1(specifier) {
+	const qIndex = specifier.indexOf("?");
+	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
+}
+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$1(specifier);
+			return pathToFileURL(path).href + specifier.slice(path.length);
+		}
+	} catch {}
+}
+function _defaultBaseURL() {
+	return pathToFileURL(process.cwd() + "/").href;
+}
+const SCRIPT_MODULE_TYPES = [
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+];
+function isNodeModulesId(id) {
+	return stripQuery(id).includes("/node_modules/");
+}
+function moduleTypeOf(path) {
+	const ext = /\.([^./\\?]+)$/.exec(stripQuery(path))?.[1]?.toLowerCase();
+	if (!ext || /^[cm]?js$/.test(ext)) return "js";
+	if (/^[cm]?ts$/.test(ext)) return "ts";
+	return ext;
+}
+function normalizeFilterId(id) {
+	const path = stripQuery(id);
+	return path.replaceAll("\\", "/") + id.slice(path.length);
+}
+function stripQuery(id) {
+	const qIndex = id.indexOf("?");
+	return qIndex === -1 ? id : id.slice(0, qIndex);
+}
+function queryOf(id) {
+	const qIndex = id.indexOf("?");
+	if (qIndex === -1) return "";
+	const hashIndex = id.indexOf("#", qIndex);
+	return hashIndex === -1 ? id.slice(qIndex) : id.slice(qIndex, hashIndex);
+}
+const INTERNAL_PARAMS = /* @__PURE__ */ new Set([
+	"__envRunnerReload",
+	"__env_runner_virtual",
+	"__env_runner_disk",
+	"__env_runner_plugin",
+	"__cjs"
+]);
+function stripInternalQuery(id, version) {
+	const qIndex = id.indexOf("?");
+	if (qIndex === -1) return id;
+	const params = id.slice(qIndex + 1).split("&");
+	if (version && params.at(-1) === `v=${version}`) params.pop();
+	const kept = params.filter((param) => !_isInternalParam(param));
+	return id.slice(0, qIndex) + (kept.length > 0 ? `?${kept.join("&")}` : "");
+}
+function restoreInternalQuery(id, from) {
+	const internal = queryOf(from).slice(1).split("&").filter(_isInternalParam);
+	if (internal.length === 0) return id;
+	return id + (id.includes("?") ? "&" : "?") + internal.join("&");
+}
+function _isInternalParam(param) {
+	return INTERNAL_PARAMS.has(param.split("=", 1)[0]);
+}
+function compileFilter(include, exclude, match) {
+	return {
+		include,
+		exclude,
+		test: (value) => !exclude.some((pattern) => match(pattern, value)) && (include.length === 0 || include.some((pattern) => match(pattern, value)))
+	};
+}
+function deserializePattern(pattern) {
+	return new RegExp(pattern.source, pattern.flags);
+}
+function compileFilterExpressions(expressions) {
+	const compiled = expressions.map(({ kind, expr }) => ({
+		include: kind === "include",
+		test: _compileNode(expr)
+	}));
+	const hasInclude = compiled.some((expr) => expr.include);
+	return (id, moduleType, code) => {
+		let unknown = false;
+		for (const expr of compiled) {
+			const result = expr.test(id, moduleType, code);
+			if (result === void 0) unknown = true;
+			else if (result) return unknown ? void 0 : expr.include;
+		}
+		return unknown ? void 0 : !hasInclude;
+	};
+}
+function _compileNode(node) {
+	switch (node.kind) {
+		case "and":
+		case "or": {
+			const args = node.args.map(_compileNode);
+			const decisive = node.kind === "or";
+			return (id, moduleType, code) => {
+				let result = !decisive;
+				for (const arg of args) {
+					const value = arg(id, moduleType, code);
+					if (value === decisive) return decisive;
+					if (value === void 0) result = void 0;
+				}
+				return result;
+			};
+		}
+		case "not": {
+			const expr = _compileNode(node.expr);
+			return (id, moduleType, code) => {
+				const value = expr(id, moduleType, code);
+				return value === void 0 ? void 0 : !value;
+			};
+		}
+		case "id": {
+			const pattern = deserializePattern(node.pattern);
+			return (id) => pattern.test(id);
+		}
+		case "moduleType": return (_id, moduleType) => moduleType === node.pattern;
+		case "code": {
+			const pattern = typeof node.pattern === "string" ? node.pattern : deserializePattern(node.pattern);
+			return (_id, _moduleType, code) => code === void 0 ? void 0 : typeof pattern === "string" ? code.includes(pattern) : pattern.test(code);
+		}
+		case "query": {
+			const { key, pattern } = node;
+			const regexp = typeof pattern === "object" ? deserializePattern(pattern) : void 0;
+			return (id) => {
+				const params = new URLSearchParams(queryOf(id));
+				if (typeof pattern === "boolean") return params.has(key) === pattern;
+				const value = params.get(key);
+				return regexp ? regexp.test(value ?? "") : value === pattern;
+			};
+		}
+	}
+}
+function requiredMatch(moduleType) {
+	if (SCRIPT_MODULE_TYPES.includes(moduleType)) return;
+	return moduleType === "json" || moduleType === "node" || moduleType === "wasm" ? "typed" : "named";
+}
+function compilePrefilter(filter) {
+	const namedLevel = filter.load ? "typed" : "named";
+	const nodeModules = nodeModulesIncludes(filter).map(deserializePattern);
+	const excluded = (id, resolved) => !resolved && isNodeModulesId(id) && !nodeModules.some((pattern) => pattern.test(id));
+	if (filter.expr) {
+		const level = _compileExpressionsLevel(filter.expr);
+		const levels = [
+			false,
+			true,
+			namedLevel,
+			"typed"
+		];
+		return (id, moduleType, resolved, code) => !excluded(id, resolved) && levels[level(id, moduleType, code)];
+	}
+	const idFilter = filter.id && compileFilter(filter.id.include.map(deserializePattern), filter.id.exclude.map(deserializePattern), (pattern, value) => pattern.test(value));
+	const named = Boolean(idFilter?.include.length);
+	return (id, moduleType, resolved) => !excluded(id, resolved) && (!filter.moduleTypes || filter.moduleTypes.includes(moduleType)) && (!idFilter || idFilter.test(id)) && (filter.moduleTypes ? "typed" : named ? namedLevel : true);
+}
+function _compileExpressionsLevel(expressions) {
+	const compiled = expressions.map(({ kind, expr }) => ({
+		include: kind === "include",
+		test: _compileNode(expr),
+		level: _compileNodeLevel(expr)
+	}));
+	const hasInclude = compiled.some((expr) => expr.include);
+	return (id, moduleType, code) => {
+		let level = 0;
+		for (const expr of compiled) {
+			const result = expr.test(id, moduleType, code);
+			if (result === false) continue;
+			if (expr.include) level = Math.max(level, expr.level(id, moduleType, code));
+			if (result) return level;
+		}
+		return hasInclude ? level : Math.max(level, 1);
+	};
+}
+function _compileNodeLevel(node) {
+	const test = _compileNode(node);
+	const matched = (level) => {
+		return (id, moduleType, code) => test(id, moduleType, code) === false ? 0 : level;
+	};
+	switch (node.kind) {
+		case "and":
+		case "or": {
+			const args = node.args.map(_compileNodeLevel);
+			return (id, moduleType, code) => test(id, moduleType, code) === false ? 0 : Math.max(...args.map((arg) => arg(id, moduleType, code)));
+		}
+		case "id": return matched(2);
+		case "moduleType": return matched(3);
+		case "query": {
+			const { key } = node;
+			return (id, moduleType, code) => test(id, moduleType, code) === false ? 0 : new URLSearchParams(queryOf(id)).has(key) ? 2 : 1;
+		}
+		default: return matched(1);
+	}
+}
+function satisfiesMatch(match, required) {
+	if (match === false) return false;
+	return !required || match === "typed" || required === "named" && match === "named";
+}
+function createPrefilter(filters) {
+	const compiled = filters.map(compilePrefilter);
+	return (id, moduleType, resolved) => {
+		const required = requiredMatch(moduleType);
+		return compiled.some((test) => satisfiesMatch(test(id, moduleType, resolved), required));
+	};
+}
+function nodeModulesIncludes(filter) {
+	const names = (pattern) => pattern.source.includes("node_modules");
+	if (!filter.expr) return filter.id?.include.filter(names) ?? [];
+	const patterns = [];
+	const walk = (node) => {
+		if (node.kind === "id" && names(node.pattern)) patterns.push(node.pattern);
+		else if (node.kind === "and" || node.kind === "or") node.args.forEach(walk);
+	};
+	for (const { kind, expr } of filter.expr) if (kind === "include") walk(expr);
+	return patterns;
+}
+async function handleTransformRequest(pipeline, request) {
+	try {
+		if (request.type === "resolve") {
+			const resolved = await pipeline.resolveId(request.source, request.importer, request);
+			return {
+				id: request.id,
+				resolved
+			};
+		}
+		const { path } = request;
+		const result = await pipeline.load(path, request.virtual ? void 0 : () => readFileSync(stripQuery(path), "utf8"), { resolved: request.resolved });
+		return {
+			id: request.id,
+			code: result?.code,
+			moduleType: result?.moduleType
+		};
+	} catch (error) {
+		return {
+			id: request.id,
+			error: error?.message || String(error)
+		};
+	}
+}
+function openTransformPort(pipeline) {
+	const { port1, port2 } = new MessageChannel();
+	const state = new Int32Array(new SharedArrayBuffer(4));
+	port1.on("message", async (request) => {
+		port1.postMessage(await handleTransformRequest(pipeline, request));
+		Atomics.add(state, 0, 1);
+		Atomics.notify(state, 0);
+	});
+	port1.unref();
+	return {
+		channel: {
+			port: port2,
+			state
+		},
+		close: () => port1.close()
+	};
+}
+function openTransformSocket(pipeline) {
+	const { path, dir } = _socketPath();
+	let connection;
+	const server = createServer((socket) => {
+		if (connection) {
+			socket.destroy();
+			return;
+		}
+		connection = socket;
+		server.close();
+		process.off("exit", cleanup);
+		cleanup();
+		let buffer = "";
+		socket.setEncoding("utf8");
+		socket.on("error", () => {});
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			let index;
+			while ((index = buffer.indexOf("\n")) !== -1) {
+				let request;
+				try {
+					request = JSON.parse(buffer.slice(0, index));
+				} catch {
+					socket.destroy();
+					return;
+				}
+				buffer = buffer.slice(index + 1);
+				handleTransformRequest(pipeline, request).then((reply) => {
+					if (!socket.destroyed) socket.write(JSON.stringify(reply) + "\n");
+				});
+			}
+		});
+	});
+	server.on("error", (error) => {
+		console.error(`[env-runner] plugin transform channel failed: ${error.message}`);
+	});
+	server.listen(path);
+	server.unref();
+	const cleanup = () => {
+		if (dir) rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	};
+	process.once("exit", cleanup);
+	return {
+		channel: { socket: path },
+		close: () => {
+			server.close();
+			connection?.destroy();
+			process.off("exit", cleanup);
+			cleanup();
+		}
+	};
+}
+function _socketPath() {
+	if (process.platform === "win32") return { path: `\\\\.\\pipe\\${`env-runner-${process.pid}-${crypto.randomUUID()}`}` };
+	let base = tmpdir();
+	if (join(base, "env-runner-XXXXXX", "transform.sock").length >= 100) base = "/tmp";
+	const dir = mkdtempSync(join(base, "env-runner-"));
+	return {
+		path: join(dir, "transform.sock"),
+		dir
+	};
+}
+const SLOW_REQUEST_MS = 1e4;
+function createTransformClient(channel) {
+	let port;
+	let state;
+	if (channel.port && channel.state) ({port, state} = channel);
+	else if (channel.socket) {
+		const pair = new MessageChannel();
+		port = pair.port1;
+		state = new Int32Array(new SharedArrayBuffer(4));
+		new Worker(BRIDGE_SOURCE, {
+			eval: true,
+			workerData: {
+				port: pair.port2,
+				state,
+				socket: channel.socket
+			},
+			transferList: [pair.port2]
+		}).unref();
+	} else throw new TypeError("[env-runner] invalid plugin transform channel");
+	let lastId = 0;
+	const send = (request, what) => {
+		const id = ++lastId;
+		port.postMessage({
+			...request,
+			id
+		});
+		let warned = false;
+		for (;;) {
+			const seen = Atomics.load(state, 0);
+			const received = receiveMessageOnPort(port);
+			if (!received) {
+				if (Atomics.wait(state, 0, seen, SLOW_REQUEST_MS) === "timed-out" && !warned) {
+					warned = true;
+					console.warn(`[env-runner] still waiting for the runner's plugins ${what} (plugin handlers must not wait on this runner).`);
+				}
+				continue;
+			}
+			const reply = received.message;
+			if (reply.closed) throw new Error(`[env-runner] cannot ${what.replace(/^to /, "")}: ${reply.error}`);
+			if (reply.id !== id) continue;
+			if (reply.error !== void 0) throw new Error(reply.error);
+			return reply;
+		}
+	};
+	return {
+		resolve: (source, importer, options) => send({
+			type: "resolve",
+			source,
+			importer,
+			...options
+		}, `to resolve "${source}"`).resolved,
+		load: (path, virtual, resolved) => {
+			const reply = send({
+				type: "load",
+				path,
+				virtual,
+				resolved
+			}, `to load "${path}"`);
+			return reply.code === void 0 ? void 0 : {
+				code: reply.code,
+				moduleType: reply.moduleType ?? "js"
+			};
+		}
+	};
+}
+const BRIDGE_SOURCE = `
+const { workerData } = require("node:worker_threads");
+const { connect } = require("node:net");
+const { port, state, socket } = workerData;
+// A crash here would leave the worker blocked: answer with an error instead.
+process.on("uncaughtException", (error) => onClose(error));
+const reply = (message) => {
+  port.postMessage(message);
+  Atomics.add(state, 0, 1);
+  Atomics.notify(state, 0);
+};
+let closed = false;
+const onClose = (error) => {
+  if (!closed) {
+    closed = true;
+    reply({ closed: true, error: "the runner closed the channel" + (error ? " (" + error.message + ")" : "") });
+  }
+};
+let buffer = "";
+const connection = connect(socket);
+connection.setEncoding("utf8");
+connection.on("data", (chunk) => {
+  buffer += chunk;
+  let index;
+  while ((index = buffer.indexOf("\\n")) !== -1) {
+    reply(JSON.parse(buffer.slice(0, index)));
+    buffer = buffer.slice(index + 1);
+  }
+});
+connection.on("error", onClose);
+connection.on("close", () => onClose());
+port.on("message", (request) => {
+  if (closed) {
+    reply({ closed: true, error: "the runner closed the channel" });
+  } else {
+    connection.write(JSON.stringify(request) + "\\n");
+  }
+});
+`;
+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$1;
+}
+function refreshVirtualModule(specifier) {
+	for (const registration of _bunRegistrations) if (Object.hasOwn(registration.virtual, specifier)) {
+		_bustBunModules(registration, [specifier]);
+		return true;
+	}
+	return false;
+}
+function virtualFileVersion(file) {
+	for (const registration of _hooksRegistrations) {
+		const version = registration.versions.get(file);
+		if (version) return version;
+	}
+	for (const registration of _bunRegistrations) {
+		const key = registration.paths.get(file) ?? registration.removed.get(file);
+		const version = key === void 0 ? void 0 : registration.versions.get(key);
+		if (version) return version;
+	}
+}
+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$1 = "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$1
+		}, _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$1
+		}, _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$1}:${served}` : served);
+		return namespaced ? {
+			path: served,
+			namespace: BUN_NAMESPACE$1
+		} : { 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$1}:`;
+	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"))) await loadCommonJSLexer();
+	}
+	const out = {};
+	for (const [key, module] of Object.entries(virtual)) out[key] = module === null ? module : prepare(key, module);
+	return out;
+}
+let _cjsLexer;
+async function loadCommonJSLexer() {
+	if (!_cjsLexer) {
+		const lexer = await import("./lexer.mjs");
+		await lexer.init();
+		_cjsLexer = lexer;
+	}
+}
+function commonJSToESM(path, source) {
+	return _commonJSToESM(path, source);
+}
+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$1 = () => {};
+function _once(fn) {
+	let done = false;
+	return () => {
+		if (!done) {
+			done = true;
+			fn();
+		}
+	};
+}
+const PLUGINS_DATA_KEY = "__envRunnerPlugins";
+const PLUGIN_SCHEME = "env-runner-plugin:";
+const BUN_NAMESPACE = "env-runner-plugin";
+const BUN_OTHER_FILE = /\.(?![cm]?[jt]sx?(?:\?|$))[\w-]+(?:\?.*)?$/i;
+const BUN_LOADED_MARKER = "__env_runner_plugin";
+const BUN_LOADED_FILE = new RegExp(String.raw`\?${BUN_LOADED_MARKER}(?:&|$)`);
+let _active;
+function servedByPluginHooks(path) {
+	return _active?.(path) ?? false;
+}
+async function registerPluginHooks(config, entry) {
+	if (!config) return _noop;
+	const prefilter = createPrefilter(config.prefilters);
+	const matches = (id, resolved) => {
+		const filterId = normalizeFilterId(id);
+		return prefilter(filterId, moduleTypeOf(filterId), resolved);
+	};
+	const pluginResolved = /* @__PURE__ */ new Set();
+	const resolvePrefilters = config.resolvePrefilters ?? [];
+	const resolveTest = (fallback) => {
+		const prefilters = resolvePrefilters.filter((prefilter) => !prefilter.fallback === !fallback);
+		const test = createPrefilter(prefilters);
+		return (source) => prefilters.length > 0 && test(normalizeFilterId(source), "js", true);
+	};
+	const resolves = resolveTest(false);
+	const resolvesFailed = resolveTest(true);
+	const entryId = entry && (entry.startsWith("file:") ? _urlPath(entry) : stripQuery(entry));
+	const client = createTransformClient(config);
+	await init;
+	const { registerHooks, stripTypeScriptTypes } = await import("node:module");
+	const isDeno = "Deno" in globalThis;
+	if (isDeno || typeof globalThis.Bun?.plugin === "function") await loadCommonJSLexer();
+	if (typeof registerHooks === "function") {
+		const cwdURL = pathToFileURL(process.cwd() + "/").href;
+		const serve = (path, result, context) => {
+			if (result.moduleType === "json") {
+				if (context.importAttributes?.type === "json" || context.conditions?.includes("require")) return {
+					format: "json",
+					source: result.code,
+					shortCircuit: true
+				};
+				return {
+					format: "module",
+					source: jsonModuleCode(path, result.code),
+					shortCircuit: true
+				};
+			}
+			const format = transformedFormat(path, result.code, context.format);
+			if (!isDeno) return {
+				format: result.moduleType === "ts" ? `${format}-typescript` : format,
+				source: result.code,
+				shortCircuit: true
+			};
+			let source = result.code;
+			if (result.moduleType === "ts") source = _stripTypes(path, source, stripTypeScriptTypes);
+			if (format === "commonjs") source = commonJSToESM(path, source);
+			return {
+				format: "module",
+				source,
+				shortCircuit: true
+			};
+		};
+		const hooks = registerHooks({
+			...resolvePrefilters.length > 0 && { resolve(specifier, context, nextResolve) {
+				const raw = specifier.startsWith("file:") ? _urlPath(specifier, true) : specifier;
+				const source = stripInternalQuery(raw);
+				const ask = (fallback) => {
+					const isEntry = entryId !== void 0 && stripQuery(source) === entryId;
+					const resolved = client.resolve(source, isEntry ? void 0 : _importerId(context.parentURL), {
+						isEntry,
+						attributes: context.importAttributes,
+						fallback
+					});
+					if (resolved && !resolved.external) {
+						if (_idPath(resolved.id)) pluginResolved.add(stripQuery(resolved.id));
+						return {
+							url: restoreInternalQuery(_idURL(resolved.id), raw),
+							shortCircuit: true
+						};
+					}
+					if (resolved && resolved.id !== source) specifier = restoreInternalQuery(_idPath(resolved.id) ? _idURL(resolved.id) : resolved.id, raw);
+					return resolved;
+				};
+				const before = resolves(source) ? ask(false) : void 0;
+				if (before && "url" in before) return before;
+				const parent = context.parentURL?.startsWith(PLUGIN_SCHEME) ? {
+					...context,
+					parentURL: cwdURL
+				} : context;
+				if (!resolvesFailed(source)) return nextResolve(specifier, parent);
+				let result;
+				let failure;
+				try {
+					result = nextResolve(specifier, parent);
+				} catch (error) {
+					failure = error;
+				}
+				if (result && !(result.url.startsWith("file:") && !existsSync(_urlPath(result.url)))) return result;
+				const resolved = ask(true);
+				if (resolved && "url" in resolved) return resolved;
+				if (resolved) return nextResolve(specifier, parent);
+				if (failure !== void 0) throw failure;
+				return result;
+			} },
+			load(url, context, nextLoad) {
+				if (url.startsWith(PLUGIN_SCHEME)) {
+					const id = _schemeId(url);
+					return serve(id, client.load(id, true), context);
+				}
+				if (url.startsWith("file:")) {
+					const id = _fileId(url);
+					const resolved = pluginResolved.has(stripQuery(id));
+					if (matches(id, resolved)) {
+						const result = client.load(id, false, resolved);
+						if (result) return serve(stripQuery(id), result, context);
+					}
+				}
+				return nextLoad(url, context);
+			}
+		});
+		_active = matches;
+		return () => {
+			if (_active === matches) _active = void 0;
+			hooks.deregister();
+		};
+	}
+	const bunPlugin = globalThis.Bun?.plugin;
+	if (typeof bunPlugin === "function") {
+		const filter = createBunFilter(config.prefilters);
+		const served = (path) => filter.test(path);
+		const serve = (path, result) => {
+			if (result.moduleType === "json") {
+				const value = _parseJSON(path, result.code);
+				return {
+					exports: {
+						...value && typeof value === "object" && !Array.isArray(value) ? value : {},
+						default: value
+					},
+					loader: "object"
+				};
+			}
+			const { code } = result;
+			return {
+				contents: transformedFormat(path, code) === "commonjs" ? commonJSToESM(path, code) : code,
+				loader: result.moduleType === "ts" ? "ts" : "js"
+			};
+		};
+		const loaded = /* @__PURE__ */ new Map();
+		const loadOther = (id, resolved) => {
+			const result = loaded.get(id) ?? (matches(id, resolved) ? client.load(id, false, resolved) : void 0);
+			if (!result) return;
+			loaded.set(id, result);
+			const query = queryOf(id);
+			return { path: `${stripQuery(id)}?${BUN_LOADED_MARKER}${query && `&${query.slice(1)}`}` };
+		};
+		const onResolve = (namespace) => ({ path, importer }) => {
+			if (_bunResolving || _active !== served || !namespace && importer === "") return;
+			const raw = namespace ? `${namespace}:${path}` : path;
+			const source = stripInternalQuery(raw);
+			const before = resolves(source);
+			if (!before && !resolvesFailed(source)) return;
+			const isEntry = entryId !== void 0 && stripQuery(source) === entryId;
+			const importerId = isEntry ? void 0 : _bunImporterId(importer);
+			let resolved = before ? client.resolve(source, importerId, { isEntry }) : void 0;
+			if (!resolved && resolvesFailed(source) && !_bunResolves(raw, importer)) resolved = client.resolve(source, importerId, {
+				isEntry,
+				fallback: true
+			});
+			if (!resolved || resolved.external && resolved.id === source) return;
+			if (_idPath(resolved.id)) {
+				const file = stripQuery(resolved.id);
+				const here = BUN_OTHER_FILE.test(file) || isNodeModulesId(normalizeFilterId(file));
+				return !resolved.external && here && loadOther(resolved.id, true) || { path: restoreInternalQuery(resolved.id, raw) };
+			}
+			return resolved.external ? void 0 : {
+				path: encodeURIComponent(resolved.id),
+				namespace: BUN_NAMESPACE
+			};
+		};
+		bunPlugin({
+			name: "env-runner-plugins",
+			setup(build) {
+				build.onLoad({ filter }, ({ path }) => {
+					const id = _bunId(path);
+					const file = stripQuery(path);
+					const result = _active === served && matches(id) ? client.load(id) : void 0;
+					if (result) return serve(file, result);
+					const contents = readFileSync(file, "utf8");
+					return {
+						contents: transformedFormat(file, contents) === "commonjs" ? commonJSToESM(file, contents) : contents,
+						loader: _bunLoader(file)
+					};
+				});
+				if (resolvePrefilters.length > 0) {
+					build.onResolve({ filter: createBunResolveFilter(resolvePrefilters) }, onResolve());
+					for (const scheme of resolveSchemes(resolvePrefilters)) build.onResolve({
+						filter: /.*/,
+						namespace: scheme
+					}, onResolve(scheme));
+				}
+				build.onResolve({ filter: BUN_OTHER_FILE }, ({ path, importer }) => {
+					const file = _active === served && importer ? _bunFilePath(path, importer) : void 0;
+					return file === void 0 ? void 0 : loadOther(_bunId(file + queryOf(path)));
+				});
+				build.onLoad({ filter: BUN_LOADED_FILE }, ({ path }) => {
+					const id = _bunId(path);
+					const result = loaded.get(id) ?? client.load(id);
+					loaded.delete(id);
+					if (!result) throw new Error(`[env-runner] no plugin loaded or transformed "${id}" anymore`);
+					return serve(stripQuery(path), result);
+				});
+				build.onLoad({
+					filter: /.*/,
+					namespace: BUN_NAMESPACE
+				}, ({ path }) => {
+					const id = decodeURIComponent(path);
+					return serve(id, client.load(id, true));
+				});
+			}
+		});
+		_active = served;
+		return () => {
+			if (_active === served) _active = void 0;
+		};
+	}
+	console.warn("[env-runner] `plugins` requires `module.registerHooks` (Node.js >= 22.15 / Deno >= 2.8) or `Bun.plugin`; skipping.");
+	return _noop;
+}
+let _bunResolving = false;
+function _bunResolves(specifier, importer) {
+	const from = stripQuery(importer);
+	_bunResolving = true;
+	try {
+		globalThis.Bun.resolveSync(stripQuery(specifier), isAbsolute(from) ? dirname(from) : process.cwd());
+		return true;
+	} catch {
+		return false;
+	} finally {
+		_bunResolving = false;
+	}
+}
+function _idPath(id) {
+	return isAbsolute(stripQuery(id));
+}
+function _idURL(id) {
+	if (_idPath(id)) {
+		const path = stripQuery(id);
+		return pathToFileURL(path).href + id.slice(path.length);
+	}
+	return PLUGIN_SCHEME + encodeURIComponent(id);
+}
+function _schemeId(url) {
+	return decodeURIComponent(stripQuery(url.slice(18)));
+}
+function _urlPath(url, keepQuery = false) {
+	return fileURLToPath(stripQuery(url)) + (keepQuery ? queryOf(url) : "");
+}
+function _fileId(url) {
+	const bare = url.slice(0, url.search(/[?#]|$/));
+	return stripInternalQuery(_urlPath(url, true), virtualFileVersion(bare));
+}
+function _bunId(path) {
+	return stripInternalQuery(path, virtualFileVersion(stripQuery(path)));
+}
+function _importerId(parentURL) {
+	if (!parentURL) return;
+	if (parentURL.startsWith("file:")) return _fileId(parentURL);
+	return parentURL.startsWith(PLUGIN_SCHEME) ? _schemeId(parentURL) : parentURL;
+}
+function _bunImporterId(importer) {
+	if (!importer) return;
+	const prefix = `${BUN_NAMESPACE}:`;
+	if (importer.startsWith(prefix)) return decodeURIComponent(importer.slice(prefix.length));
+	return isAbsolute(stripQuery(importer)) ? _bunId(importer) : stripQuery(importer);
+}
+function _bunFilePath(specifier, importer) {
+	const path = stripQuery(specifier);
+	if (isAbsolute(path)) return path;
+	if (!/^\.\.?[\\/]/.test(path)) return;
+	const from = stripQuery(importer);
+	return resolve(isAbsolute(from) ? dirname(from) : process.cwd(), path);
+}
+function jsonModuleCode(path, json) {
+	const value = _parseJSON(path, json);
+	const lines = [`const json = JSON.parse(${JSON.stringify(json)});`, "export default json;"];
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		let index = 0;
+		for (const key of Object.keys(value)) if (key !== "default") {
+			const local = `json${index++}`;
+			lines.push(`const ${local} = json[${JSON.stringify(key)}];`, `export { ${local} as ${JSON.stringify(key)} };`);
+		}
+	}
+	return lines.join("\n") + "\n";
+}
+function _parseJSON(path, source) {
+	try {
+		return JSON.parse(source);
+	} catch (error) {
+		throw new SyntaxError(`[env-runner] invalid JSON in "${path}": ${error?.message}`, { cause: error });
+	}
+}
+function _stripTypes(path, code, stripTypeScriptTypes) {
+	if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] "${path}" is still TypeScript after its plugins, which needs \`module.stripTypeScriptTypes\` (Deno >= 2.8.2) here: upgrade Deno or compile it in a plugin.`);
+	try {
+		return stripTypeScriptTypes(code);
+	} catch (error) {
+		throw new SyntaxError(`[env-runner] failed to strip types from "${path}" after its plugins: ${error?.message || error}`, { cause: error });
+	}
+}
+const CJS_MARKERS = /\b(?:module\.exports\b|exports\.\w|require\s*\()/;
+function transformedFormat(path, code, hint) {
+	if (hint?.startsWith("module")) return "module";
+	if (hint?.startsWith("commonjs")) return "commonjs";
+	const file = stripQuery(path);
+	if (/\.m[jt]sx?$/.test(file)) return "module";
+	if (/\.c[jt]sx?$/.test(file)) return "commonjs";
+	if (!CJS_MARKERS.test(code)) return "module";
+	try {
+		return parse(code)[3] ? "module" : "commonjs";
+	} catch {
+		return "module";
+	}
+}
+const BUN_EXTENSIONS = {
+	js: [".js", ".mjs"],
+	ts: [".ts", ".mts"],
+	jsx: [".jsx"],
+	tsx: [".tsx"]
+};
+function createBunFilter(prefilters, windows = process.platform === "win32") {
+	const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const sep = String.raw`(?:\\|\/)`;
+	const foldable = (pattern) => pattern.glob || !windows;
+	const plugins = prefilters.map((prefilter) => {
+		const { id, moduleTypes, expr } = prefilter;
+		const include = id && id.include.length > 0 && id.include.every(foldable) ? id.include : [];
+		return {
+			moduleTypes: expr ? void 0 : moduleTypes,
+			exclude: id?.exclude.filter(foldable) ?? [],
+			include,
+			nodeModules: include.length > 0 && nodeModulesIncludes(prefilter).length > 0
+		};
+	});
+	const folded = plugins.flatMap(({ include, exclude }) => [...include, ...exclude]);
+	const flagSet = new Set(folded.map((pattern) => pattern.flags));
+	const foldIds = flagSet.size <= 1 && !folded.some(({ source }) => /\\[1-9]|\\k<|\(\?<(?![=!])/.test(source));
+	const branches = /* @__PURE__ */ new Set();
+	const guard = `(?![^?]*${sep}node_modules${sep})`;
+	for (const { moduleTypes, include, exclude, nodeModules } of plugins) {
+		const extensions = moduleTypes ? moduleTypes.flatMap((type) => BUN_EXTENSIONS[type] ?? []) : Object.values(BUN_EXTENSIONS).flat();
+		if (extensions.length === 0) continue;
+		let lookaheads = "";
+		if (foldIds && exclude.length > 0) lookaheads += `(?!.*?(?:${exclude.map(({ source }) => source).join("|")}))`;
+		if (foldIds && include.length > 0) lookaheads += `(?=.*?(?:${include.map(({ source }) => source).join("|")}))`;
+		if (nodeModules && !foldIds) lookaheads = guard;
+		else if (!nodeModules) lookaheads = guard + lookaheads;
+		const exts = [...new Set(extensions)].map(escape).join("|");
+		branches.add(`${lookaheads}[^?]*(?:${exts})(?:\\?.*)?$`);
+	}
+	const marker = String.raw`\?__env_runner_(?:virtual|disk|plugin)(?:&|$)`;
+	return new RegExp(`^(?![^?]*${marker})(?:${[...branches].join("|") || "(?!)"})`, foldIds ? [...flagSet][0] ?? "" : "");
+}
+function createBunResolveFilter(prefilters) {
+	const includes = prefilters.map(({ id, expr }) => expr ? [] : id?.include ?? []);
+	const patterns = includes.flat();
+	const flags = new Set(patterns.map((pattern) => pattern.flags));
+	if (includes.some((list) => list.length === 0) || flags.size > 1 || patterns.some(({ source }) => /\\[1-9]|\\k<|\(\?<(?![=!])/.test(source))) return /.*/;
+	return new RegExp(patterns.map(({ source }) => `(?:${source})`).join("|"), [...flags][0]);
+}
+function resolveSchemes(prefilters) {
+	const schemes = /* @__PURE__ */ new Set();
+	const add = (pattern) => {
+		const scheme = /^\^((?:\\?[\w+.-])+?)\\?:/.exec(pattern.source)?.[1].replaceAll("\\", "");
+		if (scheme && scheme.length > 1 && /^[a-z][\w+.-]*$/i.test(scheme) && ![
+			"node",
+			"bun",
+			"file",
+			"data",
+			"http",
+			"https",
+			"blob"
+		].includes(scheme)) schemes.add(scheme);
+	};
+	const walk = (node) => {
+		if (node.kind === "id") add(node.pattern);
+		else if (node.kind === "and" || node.kind === "or") node.args.forEach(walk);
+	};
+	for (const { id, expr } of prefilters) {
+		id?.include.forEach(add);
+		for (const { kind, expr: node } of expr ?? []) if (kind === "include") walk(node);
+	}
+	return [...schemes];
+}
+function _bunLoader(path) {
+	const ext = path.slice(path.lastIndexOf(".") + 1);
+	switch (ext) {
+		case "ts":
+		case "mts": return "ts";
+		case "tsx":
+		case "jsx": return ext;
+		default: return "js";
+	}
+}
+const _noop = () => {};
+export { PLUGINS_DATA_KEY, compileFilter, compileFilterExpressions, compilePrefilter, createPrefilter, encodeVirtualModules, expandVirtualInvalidation, findVirtualPathKey, handleUpdateVirtualModules, jsonModuleCode, moduleTypeOf, normalizeFilterId, normalizeVirtualModules, openTransformPort, openTransformSocket, queryOf, refreshVirtualModule, registerPluginHooks, registerVirtualModules, registeredVirtualModules, requiredMatch, resolveVirtualModules, restoreInternalQuery, satisfiesMatch, servedByPluginHooks, stripInternalQuery, stripQuery, stripVirtualTypeScript, transformedFormat, unsupportedVirtualJSXError, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat, warnVirtualPathCollisions };