env-runner 0.2.3 → 0.3.1

package/dist/_chunks/common-base-runner.mjs

@@ -1,6 +1,574 @@
-import { resolveVirtualModules } from "./virtual-loader.mjs";
+import { PLUGINS_DATA_KEY, compileFilter, compileFilterExpressions, compilePrefilter, createPrefilter, encodeVirtualModules, moduleTypeOf, normalizeFilterId, normalizeVirtualModules, openTransformPort, openTransformSocket, queryOf, requiredMatch, resolveVirtualModules, satisfiesMatch, stripQuery, virtualModuleFormat, warnVirtualPathCollisions } from "./plugin-hooks.mjs";
+import { isBuiltin } from "node:module";
 import { rm } from "node:fs/promises";
 import { proxyFetch, proxyUpgrade } from "httpxy";
+import * as nodePath from "node:path";
+import { isAbsolute, normalize } from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolveModulePath } from "exsolve";
+function hostEnv(extra) {
+	const env = {
+		...process.env,
+		...extra
+	};
+	const stdout = process.stdout;
+	if (!("FORCE_COLOR" in env) && !env.NO_COLOR && stdout?.isTTY) env.FORCE_COLOR = "1";
+	if (!("COLUMNS" in env) && stdout?.columns) env.COLUMNS = String(stdout.columns);
+	return env;
+}
+const SEP = String.raw`[\\/]`;
+const SEGMENT_CHAR = String.raw`[^\\/]`;
+function resolveGlob(pattern, cwd = process.cwd(), windows = process.platform === "win32") {
+	if (pattern.startsWith("**")) return pattern;
+	if ((windows ? nodePath.win32 : nodePath.posix).isAbsolute(pattern)) return windows && !pattern.includes("/") ? pattern.replaceAll("\\", "/") : pattern;
+	const base = cwd.replaceAll("\\", "/").replace(/[*?[\]{}()!+@,\\]/g, "\\$&");
+	return nodePath.posix.join(base, pattern);
+}
+function globToRegExp(glob) {
+	const closing = _braceMatches(glob);
+	let source = "";
+	let depth = 0;
+	for (let i = 0; i < glob.length; i++) {
+		const char = glob[i];
+		if (char === "\\" && i + 1 < glob.length) source += _escape(glob[++i]);
+		else if (char === "*") {
+			if (glob[i + 1] !== "*") {
+				source += `${SEGMENT_CHAR}*`;
+				continue;
+			}
+			if (!((i === 0 || glob[i - 1] === "/") && (i + 2 === glob.length || glob[i + 2] === "/"))) source += `${SEGMENT_CHAR}*`;
+			else if (i + 2 === glob.length) source += ".*";
+			else {
+				source += `(?:${SEGMENT_CHAR}*${SEP})*`;
+				i++;
+			}
+			i++;
+		} else if (char === "?") source += SEGMENT_CHAR;
+		else if (char === "[" && glob.indexOf("]", i + 2) !== -1) {
+			const end = glob.indexOf("]", i + 2);
+			let body = glob.slice(i + 1, end);
+			const negated = body[0] === "!" || body[0] === "^";
+			if (negated) body = body.slice(1);
+			source += `[${negated ? String.raw`^\\/` : ""}${body.replace(/[\\\]^]/g, "\\$&")}]`;
+			i = end;
+		} else if (char === "{" && closing.has(i)) {
+			depth++;
+			source += "(?:";
+		} else if (char === "}" && depth > 0) {
+			depth--;
+			source += ")";
+		} else if (char === "," && depth > 0) source += "|";
+		else source += char === "/" ? SEP : _escape(char);
+	}
+	return new RegExp(`^${source}$`);
+}
+function _braceMatches(glob) {
+	const open = [];
+	const matched = /* @__PURE__ */ new Set();
+	for (let i = 0; i < glob.length; i++) if (glob[i] === "\\") i++;
+	else if (glob[i] === "{") open.push(i);
+	else if (glob[i] === "}" && open.length > 0) matched.add(open.pop());
+	return matched;
+}
+function _escape(char) {
+	return char.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+const KNOWN_MODULE_TYPES = [
+	"js",
+	"jsx",
+	"ts",
+	"tsx",
+	"json"
+];
+function createPluginPipeline(plugins, options = {}) {
+	const { resolveConditions } = options;
+	if (plugins == null) return;
+	if (!Array.isArray(plugins)) throw new TypeError("[env-runner] `plugins` must be an array of plugin objects.");
+	const normalized = _flattenPlugins(plugins, "").map(([plugin, path]) => _normalizePlugin(plugin, path));
+	const rank = {
+		pre: 0,
+		normal: 1,
+		post: 2
+	};
+	const enforced = normalized.toSorted((a, b) => rank[a.enforce] - rank[b.enforce]);
+	const ordered = (kind) => {
+		const hooks = enforced.flatMap((plugin) => plugin[kind] ? [plugin[kind]] : []);
+		const byOrder = (order) => hooks.filter((hook) => hook.order === order);
+		return [
+			...byOrder("pre"),
+			...byOrder("normal"),
+			...byOrder("post")
+		];
+	};
+	const resolveHooks = ordered("resolveId");
+	const loadHooks = ordered("load");
+	const transformHooks = ordered("transform");
+	if (resolveHooks.length + loadHooks.length + transformHooks.length === 0) return;
+	const prefilters = normalized.flatMap((plugin) => [plugin.load, plugin.transform].flatMap((hook) => hook ? [hook.prefilter] : []));
+	const resolvePrefilters = resolveHooks.map((hook) => hook.prefilter);
+	const fallbackPrefilter = createPrefilter(resolvePrefilters.filter((prefilter) => prefilter.fallback));
+	const prefilter = createPrefilter(prefilters);
+	const resolvePrefilter = createPrefilter(resolvePrefilters.filter((prefilter) => !prefilter.fallback));
+	const filter = (id, moduleType, resolved) => {
+		const matchId = normalizeFilterId(id);
+		return prefilter(matchId, moduleType ?? moduleTypeOf(matchId), resolved || moduleType !== void 0);
+	};
+	const contextResolve = (caller, skip) => async (source, importer, options = {}) => {
+		if (typeof source !== "string") throw new TypeError(`[env-runner] \`this.resolve()\` needs a string (got ${_describe(source)}).`);
+		const skipping = caller && options.skipSelf !== false ? [...skip, {
+			hook: caller,
+			source,
+			importer
+		}] : skip;
+		const skipped = new Set(skipping.filter((entry) => entry.source === source && entry.importer === importer).map((entry) => entry.hook));
+		const { skipSelf: _, ...rest } = options;
+		return await _resolveId(source, importer, rest, skipped, skipping) ?? _resolveLikeRuntime(source, importer, resolveConditions?.()) ?? await _resolveId(source, importer, {
+			...rest,
+			fallback: true
+		}, skipped, skipping) ?? null;
+	};
+	const _resolveId = async (source, importer, options, skipped, skip) => {
+		const matchId = normalizeFilterId(source);
+		const extra = {
+			isEntry: options?.isEntry ?? false,
+			attributes: options?.attributes ?? {}
+		};
+		for (const hook of resolveHooks) {
+			if (Boolean(hook.fallback) !== Boolean(options?.fallback) || skipped.has(hook) || !hook.match(matchId, "js", void 0, true)) continue;
+			const context = _createContext(hook.name, source, "", contextResolve(hook, skip));
+			const result = await _callHook(hook.name, "failed to resolve", source, "", () => hook.handler.call(context, source, importer, extra));
+			if (result == null) continue;
+			if (result === false) return {
+				id: source,
+				external: true
+			};
+			const id = typeof result === "string" ? result : result.id;
+			if (typeof id !== "string" || id === "") throw new TypeError(`[env-runner] plugin "${hook.name}" resolved "${source}" to an invalid id (got ${_describe(id)}): return a string, \`{ id }\` or nullish.`);
+			return {
+				id,
+				external: typeof result === "object" && Boolean(result.external)
+			};
+		}
+	};
+	const resolveId = (source, importer, options) => _resolveId(source, importer, options, /* @__PURE__ */ new Set(), []);
+	const load = async (id, read, options) => {
+		const matchId = normalizeFilterId(id);
+		let moduleType = moduleTypeOf(id);
+		const required = read ? requiredMatch(moduleType) : void 0;
+		const resolved = !read || options?.resolved;
+		for (const hook of loadHooks) {
+			if (!satisfiesMatch(hook.match(matchId, moduleType, void 0, resolved), required)) continue;
+			const result = await _callHook(hook.name, "failed to load", id, "", () => hook.handler.call(_createContext(hook.name, id, "", contextResolve(void 0, [])), id));
+			if (result == null) continue;
+			const code = typeof result === "string" ? result : result.code;
+			if (typeof code !== "string") throw new TypeError(`[env-runner] plugin "${hook.name}" loaded non-string \`code\` for "${id}" (got ${_describe(code)}).`);
+			const map = typeof result === "object" ? _parseMap(result.map) : void 0;
+			if (typeof result === "object" && result.moduleType) moduleType = result.moduleType;
+			else if (!KNOWN_MODULE_TYPES.includes(moduleType)) moduleType = "js";
+			return _transform(id, code, moduleType, {
+				resolved,
+				changed: true,
+				map,
+				mappedBy: map ? hook.name : void 0
+			});
+		}
+		if (!read) throw new Error(`[env-runner] no plugin loaded "${id}": a \`resolveId\` hook resolved an import to it, so a \`load\` hook must return its code.`);
+		if (!filter(id, void 0, resolved)) return;
+		return _transform(id, read(), moduleType, {
+			resolved,
+			changed: false
+		});
+	};
+	const _transform = async (id, code, moduleType, state) => {
+		let { changed, map, mappedBy } = state;
+		const matchId = normalizeFilterId(id);
+		for (const hook of transformHooks) {
+			const match = hook.match(matchId, moduleType, code, state.resolved);
+			if (!satisfiesMatch(match, requiredMatch(moduleType))) continue;
+			const result = await _callHook(hook.name, "failed on", id, code, () => hook.handler.call(_createContext(hook.name, id, code, contextResolve(void 0, [])), code, id, { moduleType }));
+			const next = typeof result === "string" ? result : result?.code ?? code;
+			if (typeof next !== "string") throw new TypeError(`[env-runner] plugin "${hook.name}" returned non-string \`code\` for "${id}" (got ${_describe(next)}): convert it to a string (e.g. \`s.toString()\`, with \`map: s.generateMap()\`).`);
+			const resultType = result && typeof result === "object" ? result.moduleType : void 0;
+			if (resultType) moduleType = resultType;
+			if (next === code) continue;
+			code = next;
+			changed = true;
+			if (!resultType && !KNOWN_MODULE_TYPES.includes(moduleType)) moduleType = "js";
+			const nextMap = typeof result === "object" ? _parseMap(result?.map) : void 0;
+			if (nextMap) {
+				if (mappedBy === void 0) {
+					map = nextMap;
+					mappedBy = hook.name;
+				} else {
+					map = void 0;
+					_warnDroppedMap(mappedBy, hook.name);
+				}
+			}
+		}
+		if (!changed) return;
+		if (moduleType === "json") try {
+			JSON.parse(code);
+			return {
+				code,
+				moduleType: "json"
+			};
+		} catch {
+			moduleType = "js";
+		}
+		if (moduleType !== "js" && moduleType !== "ts") throw new TypeError(`[env-runner] "${id}" is still ${moduleType} after its plugins: add one that compiles it to JavaScript (returning \`moduleType: "js"\`) or narrow the plugins' filters.`);
+		if (map) {
+			const file = stripQuery(id);
+			const source = isAbsolute(file) ? pathToFileURL(file).href : file;
+			const json = JSON.stringify({
+				...map,
+				sources: [source],
+				file: void 0
+			});
+			code += `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(json).toString("base64")}\n`;
+		}
+		return {
+			code,
+			moduleType
+		};
+	};
+	const transform = (id, code, sourceType) => _transform(id, code, sourceType ?? moduleTypeOf(id), {
+		resolved: true,
+		changed: false
+	});
+	return {
+		names: normalized.map((plugin) => plugin.name),
+		prefilters,
+		resolvePrefilters,
+		filter,
+		resolveFilter: (source, fallback) => (fallback ? fallbackPrefilter : resolvePrefilter)(normalizeFilterId(source), "js", true),
+		resolveId,
+		load,
+		transform
+	};
+}
+function _resolveLikeRuntime(source, importer, conditions) {
+	if (isBuiltin(source)) return {
+		id: source,
+		external: true
+	};
+	const from = importer && isAbsolute(stripQuery(importer)) ? stripQuery(importer) : pathToFileURL(`${process.cwd()}/`).href;
+	const path = resolveModulePath(stripQuery(source), {
+		from,
+		conditions,
+		try: true,
+		cache: false
+	});
+	return path ? {
+		id: normalize(path) + queryOf(source),
+		external: false
+	} : null;
+}
+async function _callHook(name, what, id, code, call) {
+	try {
+		return await call();
+	} catch (error) {
+		const message = error?.message || String(error);
+		if (message.startsWith("[env-runner]")) throw error;
+		const at = `${id}${_formatPosition(code, _logPosition(error, id, code))}`;
+		throw new Error(`[env-runner] plugin "${name}" ${what} "${at}": ${message}${_frame(error)}`, { cause: error });
+	}
+}
+function _logPosition(log, id, code) {
+	const { loc, pos } = log ?? {};
+	if (typeof loc?.line === "number" && typeof loc.column === "number") return typeof loc.file === "string" && loc.file !== stripQuery(id) && loc.file !== id ? void 0 : {
+		line: loc.line,
+		column: loc.column
+	};
+	return typeof pos === "number" && code ? pos : void 0;
+}
+function _frame(log) {
+	const frame = log?.frame;
+	return typeof frame === "string" && frame.trim() ? `\n\n${frame.replace(/\n+$/, "")}` : "";
+}
+const VIRTUAL_MODULE_TYPES = {
+	module: "js",
+	commonjs: "js",
+	"module-typescript": "ts",
+	"commonjs-typescript": "ts",
+	jsx: "jsx",
+	tsx: "tsx"
+};
+async function transformVirtualModules(pipeline, modules) {
+	const out = { ...modules };
+	for (const [key, module] of Object.entries(modules)) {
+		if (module === null) continue;
+		const format = virtualModuleFormat(key, module);
+		const moduleType = VIRTUAL_MODULE_TYPES[format];
+		if (!moduleType || !pipeline.filter(key, moduleType)) continue;
+		const source = typeof module === "string" ? module : module.source;
+		const result = await pipeline.transform(key, source, moduleType);
+		if (result) {
+			const system = format.startsWith("commonjs") ? "commonjs" : "module";
+			out[key] = {
+				source: result.code,
+				format: result.moduleType === "ts" ? `${system}-typescript` : system
+			};
+		}
+	}
+	return out;
+}
+function _flattenPlugins(plugins, path) {
+	return plugins.flatMap((plugin, index) => {
+		const at = `${path}[${index}]`;
+		return Array.isArray(plugin) ? _flattenPlugins(plugin, at) : plugin ? [[plugin, at]] : [];
+	});
+}
+const HOOK_KINDS = [
+	"resolveId",
+	"load",
+	"transform"
+];
+function _normalizePlugin(plugin, path) {
+	const fail = (reason) => {
+		throw new TypeError(`[env-runner] \`plugins${path}\` ${reason}: expected a plugin object with \`resolveId\`, \`load\` or \`transform\` hooks, each a function or \`{ order?, filter?, handler }\`.`);
+	};
+	if (typeof plugin !== "object") return fail("is not a plugin object");
+	const { name: pluginName, enforce } = plugin;
+	const name = typeof pluginName === "string" ? pluginName : `plugins${path}`;
+	if (enforce != null && enforce !== "pre" && enforce !== "post") return fail(`has an invalid \`enforce\` (${JSON.stringify(enforce)})`);
+	const normalized = {
+		name,
+		enforce: enforce ?? "normal"
+	};
+	for (const kind of HOOK_KINDS) {
+		const hook = plugin[kind];
+		if (hook != null) normalized[kind] = _normalizeHook(kind, hook, name, path, fail);
+	}
+	return normalized;
+}
+function _normalizeHook(kind, hook, name, path, fail) {
+	const failFilter = (key, reason) => {
+		throw new TypeError(`[env-runner] \`plugins${path}\` has an invalid \`${kind}.filter${key}\` ${reason}.`);
+	};
+	let order = "normal";
+	let filter;
+	let fallback = false;
+	let handler;
+	if (typeof hook === "function") handler = hook;
+	else if (hook && typeof hook === "object" && typeof hook.handler === "function") {
+		const object = hook;
+		if (object.order != null && object.order !== "pre" && object.order !== "post") return fail(`has an invalid \`${kind}.order\` (${JSON.stringify(object.order)})`);
+		if (object.fallback != null && object.fallback !== false) {
+			if (kind !== "resolveId") return fail(`has a \`${kind}.fallback\` (only \`resolveId\` hooks take one)`);
+			if (object.fallback !== true) return fail(`has an invalid \`${kind}.fallback\` (${_describe(object.fallback)})`);
+			fallback = true;
+		}
+		order = object.order ?? "normal";
+		filter = object.filter;
+		handler = object.handler;
+	} else return fail(`has an invalid \`${kind}\` hook (got ${_describe(hook)})`);
+	const flags = {
+		...kind === "load" ? { load: true } : {},
+		...fallback && { fallback: true }
+	};
+	if (Array.isArray(filter)) {
+		const expr = _normalizeExpressions(filter, kind, failFilter);
+		const test = compileFilterExpressions(expr);
+		const prefilter = {
+			expr,
+			...flags
+		};
+		const level = compilePrefilter(prefilter);
+		return {
+			name,
+			order,
+			prefilter,
+			fallback,
+			match: (id, moduleType, code, resolved) => test(id, moduleType, code) !== false && level(id, moduleType, resolved, code),
+			handler
+		};
+	}
+	const keys = kind === "transform" ? "`{ id?, code?, moduleType? }`" : "`{ id? }`";
+	if (filter != null && typeof filter !== "object") return failFilter("", `(got ${_describe(filter)}): expected ${keys} or an array of filter expressions`);
+	const { id: idValue, code: codeValue, moduleType: moduleTypeValue } = filter ?? {};
+	if (kind !== "transform") {
+		for (const [key, value] of [["code", codeValue], ["moduleType", moduleTypeValue]]) if (value) failFilter(`.${key}`, `(\`${kind}\` filters take \`id\` only)`);
+	}
+	const idPatterns = _stringFilter(idValue, ".id", failFilter);
+	const toPattern = (pattern) => _idPattern(pattern, kind !== "resolveId");
+	const id = idPatterns && {
+		include: idPatterns.include.map(toPattern),
+		exclude: idPatterns.exclude.map(toPattern)
+	};
+	const codePatterns = _stringFilter(codeValue, ".code", failFilter);
+	const code = codePatterns && compileFilter(codePatterns.include.map(_codePattern), codePatterns.exclude.map(_codePattern), _matchCode);
+	const prefilter = {
+		id,
+		moduleTypes: _moduleTypes(moduleTypeValue, failFilter),
+		...flags
+	};
+	const level = compilePrefilter(prefilter);
+	return {
+		name,
+		order,
+		prefilter,
+		fallback,
+		match: (idValue, moduleType, codeValue, resolved) => (codeValue === void 0 || !code || code.test(codeValue)) && level(idValue, moduleType, resolved),
+		handler
+	};
+}
+const _isPattern = (value) => typeof value === "string" || value instanceof RegExp;
+function _stringFilter(filter, key, fail) {
+	if (!filter) return;
+	const toList = (value) => {
+		const list = value ? Array.isArray(value) ? value : [value] : [];
+		const invalid = list.find((pattern) => !_isPattern(pattern));
+		if (invalid !== void 0) fail(key, `(got ${_describe(invalid)}): expected strings or RegExps, as a value, an array or \`{ include, exclude }\``);
+		return list;
+	};
+	if (typeof filter === "object" && !Array.isArray(filter) && !(filter instanceof RegExp)) {
+		const { include, exclude } = filter;
+		return {
+			include: toList(include),
+			exclude: toList(exclude)
+		};
+	}
+	return {
+		include: toList(filter),
+		exclude: []
+	};
+}
+function _moduleTypes(filter, fail) {
+	if (!filter) return;
+	const list = Array.isArray(filter) ? filter : typeof filter === "object" ? filter.include ?? [] : void 0;
+	if (!Array.isArray(list) || list.some((type) => typeof type !== "string")) return fail(".moduleType", `(got ${_describe(filter)}): expected an array of module types or \`{ include: [...] }\``);
+	if (list.length === 0) return fail(".moduleType", "(no module types): list at least one, or leave it out");
+	return list;
+}
+function _idPattern(pattern, resolve = true) {
+	return typeof pattern === "string" ? {
+		source: globToRegExp(resolve ? resolveGlob(pattern) : pattern).source,
+		flags: "",
+		glob: true
+	} : {
+		source: pattern.source,
+		flags: _statelessFlags(pattern)
+	};
+}
+function _codePattern(pattern) {
+	return typeof pattern === "string" ? pattern : new RegExp(pattern.source, _statelessFlags(pattern));
+}
+function _statelessFlags(pattern) {
+	return pattern.flags.replace(/[gy]/g, "");
+}
+function _normalizeExpressions(list, kind, fail) {
+	return list.map((value, index) => {
+		if (value?.kind !== "include" && value?.kind !== "exclude") return fail(`[${index}]`, `(got ${_describe(value?.kind ?? value)}): expected an \`include\` or \`exclude\` expression`);
+		return {
+			kind: value.kind,
+			expr: _normalizeNode(value.expr, `[${index}].expr`, kind, fail)
+		};
+	});
+}
+function _normalizeNode(node, key, hook, fail) {
+	const pattern = (allowed, expected) => {
+		if (!allowed(node.pattern)) fail(`${key}.pattern`, `(got ${_describe(node.pattern)}): expected ${expected}`);
+		return node.pattern;
+	};
+	switch (node?.kind) {
+		case "and":
+		case "or":
+			if (!Array.isArray(node.args) || node.args.length === 0) return fail(key, `(\`${node.kind}\` needs at least one argument)`);
+			return {
+				kind: node.kind,
+				args: node.args.map((arg, index) => _normalizeNode(arg, `${key}.args[${index}]`, hook, fail))
+			};
+		case "not": return {
+			kind: "not",
+			expr: _normalizeNode(node.expr, `${key}.expr`, hook, fail)
+		};
+		case "id": return {
+			kind: "id",
+			pattern: _idPattern(pattern(_isPattern, "a string or RegExp"), hook !== "resolveId")
+		};
+		case "code": {
+			if (hook !== "transform") return fail(key, `(\`code\` doesn't apply to \`${hook}\`)`);
+			const value = _codePattern(pattern(_isPattern, "a string or RegExp"));
+			return {
+				kind: "code",
+				pattern: typeof value === "string" ? value : {
+					source: value.source,
+					flags: value.flags
+				}
+			};
+		}
+		case "moduleType":
+			if (hook !== "transform") return fail(key, `(\`moduleType\` doesn't apply to \`${hook}\`)`);
+			return {
+				kind: "moduleType",
+				pattern: pattern((value) => typeof value === "string", "a string")
+			};
+		case "query": {
+			if (typeof node.key !== "string") return fail(`${key}.key`, `(got ${_describe(node.key)}): expected a string`);
+			const value = pattern((value) => _isPattern(value) || typeof value === "boolean", "a string, RegExp or boolean");
+			return {
+				kind: "query",
+				key: node.key,
+				pattern: value instanceof RegExp ? {
+					source: value.source,
+					flags: _statelessFlags(value)
+				} : value
+			};
+		}
+		case "importerId": return fail(key, `(\`importerId\` isn't supported)`);
+		default: return fail(key, `(got ${_describe(node?.kind ?? node)}): unknown expression kind`);
+	}
+}
+function _describe(value) {
+	if (value instanceof RegExp) return String(value);
+	if (Array.isArray(value)) return "an array";
+	if (value && typeof value === "object") {
+		const name = value.constructor?.name;
+		return name && name !== "Object" ? name : "an object";
+	}
+	return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+function _createContext(name, id, code, resolve) {
+	const format = (log, pos) => typeof log === "string" ? `[env-runner] plugin "${name}" (${id}${_formatPosition(code, pos)}): ${log}` : `[env-runner] plugin "${name}" (${id}${_formatPosition(code, pos ?? _logPosition(log, id, code))}): ${log?.message}${_frame(log)}`;
+	return {
+		warn: (log, pos) => console.warn(format(log, pos)),
+		info: (log, pos) => console.info(format(log, pos)),
+		debug: () => {},
+		error: (log, pos) => {
+			throw new Error(format(log, pos), typeof log === "string" ? void 0 : { cause: log });
+		},
+		resolve,
+		addWatchFile: () => {},
+		getWatchFiles: () => [],
+		meta: { watchMode: false }
+	};
+}
+function _formatPosition(code, pos) {
+	if (typeof pos === "number") {
+		const before = code.slice(0, pos);
+		return `:${before.split("\n").length}:${pos - before.lastIndexOf("\n") - 1}`;
+	}
+	return pos && typeof pos === "object" ? `:${pos.line}:${pos.column}` : "";
+}
+function _matchCode(pattern, code) {
+	return typeof pattern === "string" ? code.includes(pattern) : pattern.test(code);
+}
+function _parseMap(map) {
+	if (typeof map === "string") try {
+		return JSON.parse(map);
+	} catch {
+		return;
+	}
+	return map ?? void 0;
+}
+const _warnedMaps = /* @__PURE__ */ new Set();
+function _warnDroppedMap(first, second) {
+	const key = `${first}\0${second}`;
+	if (!_warnedMaps.has(key)) {
+		_warnedMaps.add(key);
+		console.warn(`[env-runner] plugins "${first}" and "${second}" both returned a source map; maps are not combined, so modules both change have none.`);
+	}
+}
 var BaseEnvRunner = class {
 	closed = false;
 	_name;
@@ -11,11 +579,18 @@ var BaseEnvRunner = class {
 	_address;
 	_messageListeners;
 	_pendingRequests;
+	_closeCause;
 	_virtualResolved;
+	_virtualUpdates = Promise.resolve();
+	#virtualUpdateId = 0;
+	_processData;
+	_plugins;
+	_transformChannel;
 	constructor(opts) {
 		this._name = opts.name;
 		this._workerEntry = opts.workerEntry;
 		this._data = opts.data;
+		this._plugins = createPluginPipeline(opts.plugins, { resolveConditions: () => this._resolveConditions() });
 		this._hooks = opts.hooks || {};
 		this._messageListeners = /* @__PURE__ */ new Set();
 		this._pendingRequests = /* @__PURE__ */ new Set();
@@ -49,24 +624,29 @@ var BaseEnvRunner = class {
 	}
 	waitForReady(timeout = 15e3) {
 		if (this.ready) return Promise.resolve();
-		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Runner closed before becoming ready"));
+		if (this.closed) return Promise.reject(closedBeforeReadyError(this._closeCause));
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
-				this._messageListeners.delete(listener);
+				cleanup();
 				reject(/* @__PURE__ */ new Error("Runner did not become ready in time"));
 			}, timeout);
 			const listener = () => {
 				if (this.ready) {
-					clearTimeout(timer);
-					this._messageListeners.delete(listener);
+					cleanup();
 					resolve();
-				} else if (this.closed) {
-					clearTimeout(timer);
-					this._messageListeners.delete(listener);
-					reject(/* @__PURE__ */ new Error("Runner closed before becoming ready"));
 				}
 			};
+			const onClose = (cause) => {
+				cleanup();
+				reject(closedBeforeReadyError(cause));
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				this._messageListeners.delete(listener);
+				this._pendingRequests.delete(onClose);
+			};
 			this._messageListeners.add(listener);
+			this._pendingRequests.add(onClose);
 		});
 	}
 	rpc(name, data, opts) {
@@ -82,27 +662,27 @@ var BaseEnvRunner = class {
 		}).then((msg) => msg.data);
 	}
 	async reloadModule(timeout = 5e3) {
+		await this._virtualUpdates;
 		await this._request({ event: "reload-module" }, {
 			match: (msg) => msg?.event === "module-reloaded",
 			timeout,
 			timeoutError: "Module reload timed out"
 		});
 	}
-	async invalidateModule(specifier, timeout = 5e3) {
-		const source = await this._refreshVirtualSource(specifier);
-		await this._request({
-			event: "invalidate-module",
-			specifier,
-			source
-		}, {
-			match: (msg) => msg?.event === "module-invalidated" && msg.specifier === specifier,
-			timeout,
-			timeoutError: `Module invalidation timed out for "${specifier}"`
-		});
+	updateVirtualModules(changes, timeout = 5e3) {
+		return this._enqueueVirtualUpdate(() => changes, timeout);
+	}
+	invalidateModule(specifier, timeout = 5e3) {
+		return this._enqueueVirtualUpdate(() => {
+			const source = this._virtualSources?.[specifier];
+			if (source === void 0) throw new Error(`Cannot invalidate "${specifier}" (not a registered virtual module)`);
+			return { [specifier]: source };
+		}, timeout);
 	}
 	async close(cause) {
 		if (this.closed) return;
 		this.closed = true;
+		this._closeCause = cause;
 		for (const rejectPending of this._pendingRequests) rejectPending(cause);
 		this._pendingRequests.clear();
 		this._hooks.onClose?.(this, cause);
@@ -110,6 +690,8 @@ var BaseEnvRunner = class {
 		const onError = (error) => console.error(error);
 		await this._closeRuntime().catch(onError);
 		await this._closeSocket().catch(onError);
+		this._transformChannel?.close();
+		this._transformChannel = void 0;
 	}
 	async [Symbol.asyncDispose]() {
 		await this.close();
@@ -133,6 +715,51 @@ var BaseEnvRunner = class {
 		if (message?.event === "init-error" && !this.ready && !this.closed) this.close(new Error(String(message.error || "Worker initialization failed")));
 		for (const listener of this._messageListeners) listener(message);
 	}
+	_processEnv() {
+		let data = this._data || {};
+		const virtual = data.virtual;
+		if (virtual) data = {
+			...data,
+			virtual: encodeVirtualModules(virtual)
+		};
+		if (this._plugins) data = {
+			...data,
+			...this._pluginWorkerData("socket")
+		};
+		try {
+			this._processData = JSON.stringify(data);
+		} catch (error) {
+			throw new TypeError(`Runner data must be JSON-serializable: ${error?.message || error}`, { cause: error });
+		}
+		return hostEnv({ ENV_RUNNER_NAME: this._name });
+	}
+	_resolveConditions() {}
+	_pluginWorkerData(kind) {
+		if (!this._plugins) return {};
+		this._transformChannel ??= kind === "port" ? openTransformPort(this._plugins) : openTransformSocket(this._plugins);
+		return { [PLUGINS_DATA_KEY]: {
+			prefilters: this._plugins.prefilters,
+			resolvePrefilters: this._plugins.resolvePrefilters,
+			...this._transformChannel.channel
+		} };
+	}
+	_handleProcessMessage(message) {
+		if (message?.event !== "request-init-data") {
+			this._handleMessage(message);
+			return;
+		}
+		if (this.closed) return;
+		try {
+			this.sendMessage({
+				event: "init-data",
+				data: this._processData ?? "{}"
+			});
+		} catch (error) {
+			const cause = new Error(`Failed to send runner data to the worker over IPC: ${error?.message || error}`, { cause: error });
+			console.error(`[env-runner] ${cause.message}`);
+			this.close(cause);
+		}
+	}
 	_request(message, opts) {
 		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Runner is closed"));
 		return new Promise((resolve, reject) => {
@@ -168,8 +795,27 @@ var BaseEnvRunner = class {
 	}
 	_resolveVirtualData() {
 		const virtual = this._data?.virtual;
-		this._virtualSources = virtual;
-		if (!virtual || !Object.values(virtual).some((v) => typeof v === "function")) return;
+		this._virtualSources = { ...virtual };
+		this._data = { ...this._data };
+		warnVirtualPathCollisions(Object.keys(virtual ?? {}));
+		if (!virtual) return;
+		const plugins = this._plugins;
+		if (plugins) {
+			this._virtualResolved = resolveVirtualModules(virtual).then((resolved) => transformVirtualModules(plugins, resolved)).then((transformed) => {
+				this._data = {
+					...this._data,
+					virtual: transformed
+				};
+			});
+			return this._virtualResolved;
+		}
+		if (!Object.values(virtual).some((v) => typeof v === "function")) try {
+			this._data.virtual = normalizeVirtualModules(virtual);
+			return;
+		} catch (error) {
+			this._virtualResolved = Promise.reject(error);
+			return this._virtualResolved;
+		}
 		this._virtualResolved = resolveVirtualModules(virtual).then((resolved) => {
 			this._data = {
 				...this._data,
@@ -178,20 +824,51 @@ var BaseEnvRunner = class {
 		});
 		return this._virtualResolved;
 	}
-	async _refreshVirtualSource(specifier) {
-		await this._virtualResolved?.catch(() => {});
-		const original = this._virtualSources?.[specifier];
-		if (typeof original !== "function") return;
-		const source = await original();
-		const resolved = this._data?.virtual;
-		if (resolved) resolved[specifier] = source;
-		return source;
+	_enqueueVirtualUpdate(changes, timeout) {
+		const update = this._virtualUpdates.then(async () => {
+			await this._virtualResolved;
+			if (this.closed) throw new Error("Runner is closed");
+			const entries = Object.entries(changes()).filter(([, source]) => source !== void 0);
+			if (entries.length === 0) return;
+			const sets = Object.fromEntries(entries.filter((entry) => entry[1] !== null));
+			let resolved = await resolveVirtualModules(sets);
+			if (this._plugins) resolved = await transformVirtualModules(this._plugins, resolved);
+			const sources = this._virtualSources ??= {};
+			const virtual = (this._data ??= {}).virtual ??= {};
+			let added = false;
+			for (const [key, source] of entries) if (source === null) {
+				resolved[key] = null;
+				delete sources[key];
+				delete virtual[key];
+			} else {
+				added ||= !Object.hasOwn(sources, key);
+				sources[key] = source;
+				virtual[key] = resolved[key];
+			}
+			if (added) warnVirtualPathCollisions(Object.keys(virtual));
+			if (!this.ready) await this.waitForReady();
+			await this._applyVirtualUpdates(resolved, timeout);
+		});
+		this._virtualUpdates = update.catch(() => {});
+		return update;
+	}
+	async _applyVirtualUpdates(changes, timeout) {
+		const id = ++this.#virtualUpdateId;
+		await this._request({
+			event: "update-virtual-modules",
+			id,
+			changes: encodeVirtualModules(changes)
+		}, {
+			match: (msg) => msg?.event === "virtual-modules-updated" && msg.id === id,
+			timeout,
+			timeoutError: "Virtual module update timed out"
+		});
 	}
 	_initWithVirtualData(init) {
 		const pending = this._resolveVirtualData();
 		if (pending) pending.then(() => {
 			if (!this.closed) init();
-		}, (error) => this.close(error));
+		}).catch((error) => this.close(error));
 		else init();
 	}
 	async _closeSocket() {
@@ -200,4 +877,7 @@ var BaseEnvRunner = class {
 		this._address = void 0;
 	}
 };
-export { BaseEnvRunner };
+function closedBeforeReadyError(cause) {
+	return new Error("Runner closed before becoming ready", cause ? { cause } : void 0);
+}
+export { BaseEnvRunner, hostEnv };