@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.0

package/esm/eval/broker.js

@@ -0,0 +1,2134 @@
+/* eslint-disable no-continue, no-plusplus, no-nested-ternary, no-void, no-await-in-loop, @typescript-eslint/no-use-before-define */
+import { createHash } from "crypto";
+import fs from "fs";
+import NativeModule from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import { invariant } from "ts-invariant";
+import { isFeatureEnabled } from "@wyw-in-js/shared";
+import { isStaticallyEvaluatableModule } from "../transform/isStaticallyEvaluatableModule.js";
+import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey } from "../utils/importOverrides.js";
+import { getFileIdx } from "../utils/getFileIdx.js";
+import { collectOxcExportsAndImports } from "../utils/collectOxcExportsAndImports.js";
+import { parseRequest, stripQueryAndHash } from "../utils/parseRequest.js";
+import { resolveFilenameWithConditions } from "../utils/resolveWithConditions.js";
+import { hasCachedWywPrevalExport } from "../utils/hasCachedWywPrevalExport.js";
+import { isSuperSet, mergeOnly } from "../transform/Entrypoint.helpers.js";
+import { oxcShaker } from "../shaker.js";
+import { analyzeOxcBarrelFile } from "../transform/oxcBarrelManifest.js";
+import { LruCache } from "./lru.js";
+import { prepareModuleOnDemand } from "./prepareModuleOnDemand.js";
+import { deserializeValue, encodeGlobals, serializeValue } from "./serialize.js";
+import { createWriteQueue, writeToStream } from "./writeQueue.js";
+const DefaultModuleImplementation = NativeModule;
+const CJS_DEFAULT_CONDITIONS = [
+	"require",
+	"node",
+	"default"
+];
+const expandConditions = (conditionNames) => {
+	const result = new Set();
+	conditionNames.forEach((name) => {
+		if (name === "...") {
+			CJS_DEFAULT_CONDITIONS.forEach((condition) => result.add(condition));
+			return;
+		}
+		result.add(name);
+	});
+	return result;
+};
+const NOOP = () => {};
+const isBuiltinSpecifier = (specifier) => {
+	const normalized = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
+	return DefaultModuleImplementation.builtinModules?.includes(normalized) || DefaultModuleImplementation.builtinModules?.includes(`node:${normalized}`);
+};
+const isVirtualSpecifier = (specifier) => specifier.startsWith("/@") || specifier.startsWith("virtual:") || specifier.startsWith("\0");
+const isEvalOnlyKey = (key) => key === "__wywPreval" || key === "side-effect";
+const isPreparedOnlySuperSet = (currentOnly, requestedOnly) => {
+	if (requestedOnly.includes("__wywPreval") && !currentOnly.includes("__wywPreval")) {
+		return false;
+	}
+	return isSuperSet(currentOnly, requestedOnly);
+};
+const hasPreparedExportKeys = (prepared, requestedOnly) => {
+	const requestedKeys = requestedOnly.filter((key) => !isEvalOnlyKey(key) && key !== "*");
+	if (requestedKeys.length === 0) {
+		return true;
+	}
+	if (!prepared.exports) {
+		if (!prepared.code) {
+			return false;
+		}
+		try {
+			const collected = collectOxcExportsAndImports(prepared.code, "prepared-module.js");
+			if (collected.reexports.some((reexport) => reexport.exported === "*")) {
+				return true;
+			}
+			const exportNames = new Set([...Object.keys(collected.exports), ...collected.reexports.filter((reexport) => reexport.exported !== "*").map((reexport) => reexport.exported)]);
+			return requestedKeys.every((key) => exportNames.has(key));
+		} catch {
+			return false;
+		}
+	}
+	return requestedKeys.every((key) => Object.prototype.hasOwnProperty.call(prepared.exports, key));
+};
+const isPreparedCacheHit = (prepared, requestedOnly) => isPreparedOnlySuperSet(prepared.only, requestedOnly) && hasPreparedExportKeys(prepared, requestedOnly);
+const isExportContainer = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+const hasCachedExport = (source, key) => {
+	if (Object.prototype.hasOwnProperty.call(source, key)) {
+		return true;
+	}
+	if (key === "default") {
+		return false;
+	}
+	const fallback = source.default;
+	return isExportContainer(fallback) && Object.prototype.hasOwnProperty.call(fallback, key);
+};
+const resolveCachedExport = (source, key) => {
+	if (key === "default") {
+		return Object.prototype.hasOwnProperty.call(source, "default") ? source.default : undefined;
+	}
+	if (Object.prototype.hasOwnProperty.call(source, key)) {
+		return source[key];
+	}
+	const fallback = source.default;
+	if (isExportContainer(fallback) && Object.prototype.hasOwnProperty.call(fallback, key)) {
+		return fallback[key];
+	}
+	return undefined;
+};
+const serializeCachedExports = (exportsValue, requiredOnly) => {
+	if (requiredOnly.some(isEvalOnlyKey)) {
+		return null;
+	}
+	const keys = requiredOnly.includes("*") ? Object.keys(exportsValue).filter((key) => !isEvalOnlyKey(key)) : requiredOnly.filter((key) => !isEvalOnlyKey(key));
+	if (keys.length === 0) {
+		return null;
+	}
+	const serialized = {};
+	for (const key of keys) {
+		if (!hasCachedExport(exportsValue, key)) {
+			return null;
+		}
+		try {
+			const encoded = serializeValue(resolveCachedExport(exportsValue, key));
+			if (encoded.kind === "function") {
+				return null;
+			}
+			serialized[key] = encoded;
+		} catch {
+			return null;
+		}
+	}
+	return serialized;
+};
+const collectKnownExportNames = (services, id, cachedEntrypoint) => {
+	let knownExports = services.cache.get("exports", id);
+	if (knownExports || !cachedEntrypoint) {
+		return knownExports;
+	}
+	const { loadedAndParsed } = cachedEntrypoint;
+	if (loadedAndParsed?.evaluator !== oxcShaker || !loadedAndParsed.code) {
+		return undefined;
+	}
+	const analyzed = collectOxcExportsAndImports(loadedAndParsed.code, loadedAndParsed.evalConfig?.filename ?? id);
+	if (analyzed.reexports.some((reexport) => reexport.exported === "*")) {
+		return undefined;
+	}
+	knownExports = Array.from(new Set([...Object.keys(analyzed.exports), ...analyzed.reexports.map((reexport) => reexport.exported)]));
+	services.cache.add("exports", id, knownExports);
+	return knownExports;
+};
+const getSerializableStaticImportKeys = (services, id, cachedEntrypoint, requiredOnly, request, importerId) => {
+	const isStaticImportLoad = Boolean(request && importerId);
+	const requestedExports = requiredOnly.includes("*") ? null : requiredOnly.filter((key) => !isEvalOnlyKey(key) && key !== "*");
+	const knownExports = collectKnownExportNames(services, id, cachedEntrypoint)?.filter((key) => !isEvalOnlyKey(key) && key !== "*");
+	if (isStaticImportLoad) {
+		if (!requestedExports?.length || !knownExports?.length || !isSuperSet(cachedEntrypoint.evaluatedOnly ?? [], knownExports)) {
+			return null;
+		}
+		if (!requestedExports.every((key) => knownExports.includes(key))) {
+			return null;
+		}
+		return isSuperSet(cachedEntrypoint.evaluatedOnly ?? [], requestedExports) ? requestedExports : null;
+	}
+	if (knownExports?.length) {
+		return isSuperSet(cachedEntrypoint.evaluatedOnly ?? [], knownExports) ? knownExports : null;
+	}
+	const evaluatedOnly = cachedEntrypoint.evaluatedOnly ?? requiredOnly;
+	return requiredOnly.includes("*") ? evaluatedOnly : requiredOnly;
+};
+const DEFAULT_EVAL_OPTIONS = {
+	mode: "strict",
+	require: "warn-and-run",
+	resolver: "bundler"
+};
+const MAX_MESSAGE_SIZE = 10 * 1024 * 1024;
+const MAX_CHUNK_SIZE = 512 * 1024;
+const RESOLVE_CACHE_SIZE = 5e3;
+const LOAD_CACHE_SIZE = 1e3;
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
+const REQUEST_TIMEOUT_MS = 3e4;
+const EVAL_TIMEOUT_MS = Number(process.env.WYW_EVAL_TIMEOUT_MS ?? 3e5);
+const INIT_TIMEOUT_MS = 12e4;
+const HAPPYDOM_INIT_TIMEOUT_MS = Number(process.env.WYW_EVAL_HAPPYDOM_INIT_TIMEOUT_MS ?? process.env.WYW_HAPPYDOM_TIMEOUT_MS ?? 15e3);
+// Mirrors runner.js `isFullModuleLoad`: wildcard `['*']` (or empty) is the
+// only shape stored in the runner's moduleCache; everything else lands in
+// moduleVariants. The shipped-code dedup must respect this shape because the
+// runner picks its lookup map based on the LoadResult's `only`.
+const isWildcardOnly = (only) => !only || only.length === 0 || only.length === 1 && only[0] === "*";
+const isEvalTimeoutError = (error) => {
+	if (!error || typeof error !== "object") return false;
+	if ("code" in error && error.code) {
+		return error.code === "WYW_EVAL_TIMEOUT";
+	}
+	return false;
+};
+// ---------------------------------------------------------------------------
+// WYW_DEBUG eval dump
+// ---------------------------------------------------------------------------
+const resolveDebugEvalDir = () => {
+	const override = process.env.WYW_DUMP_EVALS_DIR;
+	if (override) {
+		return path.resolve(override);
+	}
+	const base = process.env.WYW_DUMP_EVALS;
+	if (!base) {
+		return undefined;
+	}
+	const ts = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, (c) => c === "T" ? "-" : "");
+	const root = base === "1" || base === "true" ? "./tmp" : base;
+	return path.resolve(root, `wyw-dump-evals-${ts}`);
+};
+const debugEvalDir = resolveDebugEvalDir();
+let debugEvalDirReady = false;
+const ensureDebugEvalDir = () => {
+	if (!debugEvalDir || debugEvalDirReady) {
+		return;
+	}
+	fs.mkdirSync(debugEvalDir, { recursive: true });
+	debugEvalDirReady = true;
+};
+let debugEvalSeq = 0;
+const dumpEvalCode = (id, code, only, source, evalSeq) => {
+	if (!debugEvalDir) {
+		return;
+	}
+	ensureDebugEvalDir();
+	const seq = String(++debugEvalSeq).padStart(5, "0");
+	const eSeq = String(evalSeq).padStart(5, "0");
+	const relId = path.relative(process.cwd(), stripQueryAndHash(id));
+	const safeName = relId.replace(/[/\\]/g, "__").replace(/^__/, "");
+	const filename = `seq${seq}_eval${eSeq}_${safeName}.js`;
+	const header = [
+		`// id: ${id}`,
+		`// only: ${JSON.stringify(only)}`,
+		`// source: ${source}`,
+		`// seq: ${seq}`,
+		`// eval: #${eSeq}`,
+		""
+	].join("\n");
+	fs.writeFileSync(path.join(debugEvalDir, filename), header + code);
+};
+let debugActionStream = null;
+const debugAction = (event) => {
+	if (!debugEvalDir) {
+		return;
+	}
+	ensureDebugEvalDir();
+	if (!debugActionStream) {
+		debugActionStream = fs.createWriteStream(path.join(debugEvalDir, "actions.jsonl"));
+	}
+	debugActionStream.write(`${JSON.stringify(event)}\n`);
+};
+const flushDebugStreams = () => {
+	debugActionStream?.end();
+	debugActionStream = null;
+};
+// ---------------------------------------------------------------------------
+const warnedUnknownImportsByServices = new WeakMap();
+const getWarnedUnknownImports = (services) => {
+	const cached = warnedUnknownImportsByServices.get(services);
+	if (cached) return cached;
+	const created = new Set();
+	warnedUnknownImportsByServices.set(services, created);
+	return created;
+};
+const warnedSlowImportsByServices = new WeakMap();
+const getWarnedSlowImports = (services) => {
+	const cached = warnedSlowImportsByServices.get(services);
+	if (cached) return cached;
+	const created = new Set();
+	warnedSlowImportsByServices.set(services, created);
+	return created;
+};
+const isWarningEnabled = (value) => Boolean(value) && value !== "0" && value !== "false";
+const getSlowImportThresholdMs = () => {
+	const raw = process.env.WYW_WARN_SLOW_IMPORTS_MS;
+	if (!raw) return 50;
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed)) return 50;
+	return parsed;
+};
+const getEvalOptions = (services) => ({
+	...DEFAULT_EVAL_OPTIONS,
+	...services.options.pluginOptions.eval ?? {}
+});
+const buildRunnerPath = () => {
+	const url = new URL("./runner.js", import.meta.url);
+	return fileURLToPath(url);
+};
+export const stripEntrypointGlobalsFromRunnerContext = (globals, entrypoint) => {
+	const entrypointDir = path.dirname(entrypoint);
+	const shouldStripFilename = Object.prototype.hasOwnProperty.call(globals, "__filename") && globals.__filename === entrypoint;
+	const shouldStripDirname = Object.prototype.hasOwnProperty.call(globals, "__dirname") && globals.__dirname === entrypointDir;
+	if (!shouldStripFilename && !shouldStripDirname) {
+		return globals;
+	}
+	const nextGlobals = { ...globals };
+	if (shouldStripFilename) {
+		delete nextGlobals.__filename;
+	}
+	if (shouldStripDirname) {
+		delete nextGlobals.__dirname;
+	}
+	return nextGlobals;
+};
+const getEntrypointResolveRoot = (entrypoint) => {
+	let current = entrypoint;
+	const seen = new Set();
+	while (current.parents.length > 0 && !seen.has(current.name)) {
+		seen.add(current.name);
+		[current] = current.parents;
+	}
+	return current.name;
+};
+const buildRunnerInitPayload = (services, entrypoint, featuresOverride) => {
+	const evalOptions = getEvalOptions(services);
+	const { pluginOptions } = services.options;
+	const root = services.options.root ?? process.cwd();
+	const { overrideContext, importOverrides, extensions } = pluginOptions;
+	const features = featuresOverride ?? pluginOptions.features;
+	const baseGlobals = { ...evalOptions.globals ?? {} };
+	const withFilename = {
+		...baseGlobals,
+		__filename: entrypoint.name,
+		__dirname: path.dirname(entrypoint.name)
+	};
+	const globals = overrideContext ? overrideContext(withFilename, entrypoint.name) : baseGlobals;
+	const sanitizedGlobals = stripEntrypointGlobalsFromRunnerContext(globals, entrypoint.name);
+	return {
+		evalOptions: {
+			globals: encodeGlobalsCached(sanitizedGlobals),
+			importOverrides,
+			mode: evalOptions.mode ?? "strict",
+			require: evalOptions.require ?? "warn-and-run",
+			root,
+			extensions
+		},
+		features,
+		entrypoint: entrypoint.name
+	};
+};
+const emitWarning = (services, message) => {
+	if (services.emitWarning) {
+		services.emitWarning(message);
+		return;
+	}
+	// eslint-disable-next-line no-console
+	console.warn(message);
+};
+const emitEvalWarning = (services, warning) => {
+	const { onWarn } = getEvalOptions(services);
+	onWarn?.(warning);
+	emitWarning(services, warning.message);
+};
+const defaultImportLoaders = {
+	raw: "raw",
+	url: "url"
+};
+const loadByImportLoaders = (services, request, resolved, importer) => {
+	const { pluginOptions } = services.options;
+	const importLoaders = pluginOptions.importLoaders === undefined ? defaultImportLoaders : {
+		...defaultImportLoaders,
+		...pluginOptions.importLoaders
+	};
+	const { query, hash } = parseRequest(request);
+	if (!query) return {
+		handled: false,
+		value: undefined
+	};
+	const params = new URLSearchParams(query);
+	const matchedKey = Array.from(params.keys()).find((key) => importLoaders[key] !== undefined && importLoaders[key] !== false);
+	if (!matchedKey) return {
+		handled: false,
+		value: undefined
+	};
+	const loader = importLoaders[matchedKey];
+	const filename = stripQueryAndHash(resolved);
+	const importerFilename = stripQueryAndHash(importer);
+	const importerDir = path.dirname(importerFilename);
+	const toUrl = () => {
+		const relative = path.relative(importerDir, filename).replace(/\\/g, path.posix.sep);
+		if (relative.startsWith(".") || path.isAbsolute(relative)) {
+			return relative;
+		}
+		return `./${relative}`;
+	};
+	const readFile = () => fs.readFileSync(filename, "utf-8");
+	const context = {
+		importer: importerFilename,
+		request,
+		resolved,
+		filename,
+		query,
+		hash,
+		emitWarning: (message) => emitWarning(services, message),
+		readFile,
+		toUrl
+	};
+	if (loader === "raw") {
+		return {
+			handled: true,
+			value: context.readFile()
+		};
+	}
+	if (loader === "url") {
+		return {
+			handled: true,
+			value: context.toUrl()
+		};
+	}
+	if (typeof loader === "function") {
+		return {
+			handled: true,
+			value: loader(context)
+		};
+	}
+	return {
+		handled: false,
+		value: undefined
+	};
+};
+const hashContent = (content) => createHash("sha256").update(content).digest("hex");
+const isTypeOnlyImport = (statement) => {
+	if (statement.type !== "ImportDeclaration") {
+		return false;
+	}
+	if (statement.importKind === "type") {
+		return true;
+	}
+	if (statement.specifiers.length === 0) {
+		return false;
+	}
+	return statement.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+};
+const isTypeOnlyExport = (statement) => statement.exportKind === "type";
+const getModuleExportName = (node) => node.type === "Identifier" ? node.name : node.value;
+const getImportSpecifierName = (specifier) => getModuleExportName(specifier.imported);
+const buildDirectBarrelProxy = (services, id, only) => {
+	const requested = only.filter((key) => !isEvalOnlyKey(key));
+	if (requested.length === 0 || requested.includes("*")) {
+		return null;
+	}
+	const loadedAndParsed = services.loadAndParseFn(services, id, undefined, services.log);
+	if (loadedAndParsed.evaluator === "ignored" || loadedAndParsed.ast === undefined) {
+		return null;
+	}
+	if (loadedAndParsed.evaluator === oxcShaker) {
+		return buildDirectOxcBarrelProxy(id, loadedAndParsed.code, only);
+	}
+	const importedBindings = new Map();
+	const exportedBindings = new Map();
+	const ast = loadedAndParsed.ast;
+	for (const statement of ast.program.body) {
+		if (statement.type === "ImportDeclaration") {
+			if (isTypeOnlyImport(statement)) {
+				continue;
+			}
+			if (statement.specifiers.length === 0) {
+				return null;
+			}
+			for (const specifier of statement.specifiers) {
+				if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") {
+					continue;
+				}
+				if (specifier.type === "ImportSpecifier") {
+					importedBindings.set(specifier.local.name, {
+						kind: "named",
+						imported: getImportSpecifierName(specifier),
+						source: statement.source.value
+					});
+					continue;
+				}
+				if (specifier.type === "ImportDefaultSpecifier") {
+					importedBindings.set(specifier.local.name, {
+						kind: "named",
+						imported: "default",
+						source: statement.source.value
+					});
+					continue;
+				}
+				importedBindings.set(specifier.local.name, {
+					kind: "namespace",
+					source: statement.source.value
+				});
+			}
+			continue;
+		}
+		if (statement.type === "ExportNamedDeclaration") {
+			if (isTypeOnlyExport(statement)) {
+				continue;
+			}
+			if (statement.source) {
+				for (const specifier of statement.specifiers) {
+					if (specifier.type === "ExportSpecifier") {
+						if (specifier.exportKind === "type") {
+							continue;
+						}
+						exportedBindings.set(getModuleExportName(specifier.exported), {
+							kind: "named",
+							imported: getModuleExportName(specifier.local),
+							source: statement.source.value
+						});
+						continue;
+					}
+					if (specifier.type === "ExportDefaultSpecifier") {
+						exportedBindings.set(getModuleExportName(specifier.exported), {
+							kind: "named",
+							imported: "default",
+							source: statement.source.value
+						});
+						continue;
+					}
+					if (specifier.type === "ExportNamespaceSpecifier") {
+						exportedBindings.set(getModuleExportName(specifier.exported), {
+							kind: "namespace",
+							source: statement.source.value
+						});
+						continue;
+					}
+					return null;
+				}
+				continue;
+			}
+			if (statement.declaration) {
+				return null;
+			}
+			for (const specifier of statement.specifiers) {
+				if (specifier.type !== "ExportSpecifier" || specifier.exportKind === "type") {
+					return null;
+				}
+				if (specifier.local.type !== "Identifier") {
+					return null;
+				}
+				const binding = importedBindings.get(specifier.local.name);
+				if (!binding) {
+					return null;
+				}
+				exportedBindings.set(getModuleExportName(specifier.exported), binding);
+			}
+			continue;
+		}
+		if (statement.type === "ExportDefaultDeclaration") {
+			if (statement.declaration.type !== "Identifier") {
+				return null;
+			}
+			const binding = importedBindings.get(statement.declaration.name);
+			if (!binding || binding.kind !== "named") {
+				return null;
+			}
+			exportedBindings.set("default", binding);
+			continue;
+		}
+		if (statement.type === "EmptyStatement" || statement.type === "TSDeclareFunction" || statement.type === "TSInterfaceDeclaration" || statement.type === "TSTypeAliasDeclaration") {
+			continue;
+		}
+		return null;
+	}
+	const imports = new Map();
+	const lines = [];
+	let namespaceIdx = 0;
+	const addImport = (source, imported) => {
+		if (!imports.has(source)) {
+			imports.set(source, []);
+		}
+		const bucket = imports.get(source);
+		if (!bucket.includes(imported)) {
+			bucket.push(imported);
+		}
+	};
+	for (const exported of requested) {
+		const binding = exportedBindings.get(exported);
+		if (!binding) {
+			return null;
+		}
+		if (binding.kind === "namespace") {
+			if (exported === "default" || !IDENTIFIER_RE.test(exported)) {
+				return null;
+			}
+			const local = `__wyw_ns_${namespaceIdx++}`;
+			lines.push(`import * as ${local} from ${JSON.stringify(binding.source)};`);
+			lines.push(`export { ${local} as ${exported} };`);
+			addImport(binding.source, "*");
+			continue;
+		}
+		if (binding.imported !== "default" && !IDENTIFIER_RE.test(binding.imported)) {
+			return null;
+		}
+		if (exported !== "default" && !IDENTIFIER_RE.test(exported)) {
+			return null;
+		}
+		const imported = binding.imported === "default" ? "default" : binding.imported;
+		const exportClause = exported === "default" ? `${imported} as default` : imported === exported ? imported : `${imported} as ${exported}`;
+		lines.push(`export { ${exportClause} } from ${JSON.stringify(binding.source)};`);
+		addImport(binding.source, binding.imported);
+	}
+	if (lines.length === 0) {
+		return null;
+	}
+	return {
+		code: `${lines.join("\n")}\n`,
+		imports,
+		only
+	};
+};
+const buildDirectOxcBarrelProxy = (id, code, only) => {
+	const requested = only.filter((key) => !isEvalOnlyKey(key));
+	const analyzed = analyzeOxcBarrelFile(code, id);
+	if (!("reexports" in analyzed)) {
+		return null;
+	}
+	const imports = new Map();
+	const lines = [];
+	let namespaceIdx = 0;
+	const addImport = (source, imported) => {
+		if (!imports.has(source)) {
+			imports.set(source, []);
+		}
+		const bucket = imports.get(source);
+		if (!bucket.includes(imported)) {
+			bucket.push(imported);
+		}
+	};
+	for (const exported of requested) {
+		const binding = analyzed.reexports.find((reexport) => reexport.exported === exported);
+		if (!binding) {
+			return null;
+		}
+		if (binding.kind === "namespace") {
+			if (exported === "default" || !IDENTIFIER_RE.test(exported)) {
+				return null;
+			}
+			const local = `__wyw_ns_${namespaceIdx++}`;
+			lines.push(`import * as ${local} from ${JSON.stringify(binding.source)};`);
+			lines.push(`export { ${local} as ${exported} };`);
+			addImport(binding.source, "*");
+			continue;
+		}
+		if (binding.imported !== "default" && !IDENTIFIER_RE.test(binding.imported)) {
+			return null;
+		}
+		if (exported !== "default" && !IDENTIFIER_RE.test(exported)) {
+			return null;
+		}
+		const imported = binding.imported === "default" ? "default" : binding.imported;
+		const exportClause = exported === "default" ? `${imported} as default` : imported === exported ? imported : `${imported} as ${exported}`;
+		lines.push(`export { ${exportClause} } from ${JSON.stringify(binding.source)};`);
+		addImport(binding.source, binding.imported);
+	}
+	if (lines.length === 0) {
+		return null;
+	}
+	return {
+		code: `${lines.join("\n")}\n`,
+		imports,
+		only
+	};
+};
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const canonicalizeForHash = (value) => {
+	if (Array.isArray(value)) {
+		return value.map((item) => canonicalizeForHash(item));
+	}
+	if (isPlainObject(value)) {
+		return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalizeForHash(value[key])]));
+	}
+	return value;
+};
+const getInitPayloadKey = (payload) => createHash("sha256").update(JSON.stringify(canonicalizeForHash(payload))).digest("hex");
+// Hash everything in the init payload that affects whether the runner needs
+// a fresh INIT — i.e. everything except `entrypoint` (which only affects
+// __filename/__dirname rebinding, not context reuse). The broker memoizes
+// this per-services so we replace per-evaluate SHA-256 of the full payload
+// with one SHA-256 of the stable bits + a cheap string concat per
+// entrypoint.
+const getStableInitPayloadHash = (payload) => {
+	const { entrypoint: _entrypoint, ...stable } = payload;
+	return createHash("sha256").update(JSON.stringify(canonicalizeForHash(stable))).digest("hex");
+};
+// Memoize encodeGlobals on input reference. The user's globals object is
+// stable across a build, so we can encode it once instead of per evaluate.
+// If the input ref changes, fall through to a fresh encode (and reset the
+// cache).
+const encodeGlobalsMemo = new WeakMap();
+const encodeGlobalsCached = (input) => {
+	if (input !== null && typeof input === "object") {
+		const obj = input;
+		const cached = encodeGlobalsMemo.get(obj);
+		if (cached) return cached;
+		const encoded = encodeGlobals(input);
+		encodeGlobalsMemo.set(obj, encoded);
+		return encoded;
+	}
+	return encodeGlobals(input);
+};
+const formatLoaderResult = (code, loader) => {
+	if (loader === "json") {
+		return `export default ${JSON.stringify(JSON.parse(code))};`;
+	}
+	if (loader === "raw" || loader === "text") {
+		return `export default ${JSON.stringify(code)};`;
+	}
+	return code;
+};
+const toSerializedError = (error) => {
+	const err = error instanceof Error ? error : new Error(String(error));
+	return {
+		message: err.message,
+		name: err.name,
+		stack: err.stack
+	};
+};
+export class EvalBroker {
+	runner = null;
+	runnerInputQueue = null;
+	runnerReady = null;
+	lastInitKey = null;
+	lastHappyDomEnabled = false;
+	evalQueue = Promise.resolve();
+	pending = new Map();
+	nextId = 0;
+	resolveCache = new LruCache(RESOLVE_CACHE_SIZE);
+	resolveInFlight = new Map();
+	loadCache = new LruCache(LOAD_CACHE_SIZE);
+	loadInFlight = new Map();
+	importsByModule = new Map();
+	onlyByModule = new Map();
+	runtimeDependenciesByModule = new Map();
+	emittedDependencies = new Set();
+	// Mirrors the runner's view: for each module id, the (hash, mergedOnly) of
+	// the most recent LoadResult we shipped with non-empty `code`. Subsequent
+	// loads with a matching hash and a subset `only` skip the code transmission
+	// (and the eval dump) — the runner's hash-match branch returns its cached
+	// SourceTextModule. Cleared whenever the runner is killed/respawned so the
+	// mirror cannot drift from the runner's actual moduleCache.
+	lastSentLoadByModule = new Map();
+	// Batch queue: concurrent evaluate() callers (e.g. parallel webpack-loader
+	// transform() invocations) pile up here within one event-loop turn, then a
+	// microtask flushes them as a single sequential runner pass. Each call
+	// still gets its own resolved Promise; this only collapses the per-call
+	// evalQueue chain + state-clear churn.
+	pendingEvals = [];
+	evalFlushScheduled = false;
+	// Cached stable init payload hash. Keyed on the refs that feed the stable
+	// bits (pluginOptions.eval and pluginOptions itself). Any reference change
+	// invalidates the cache. The full per-entrypoint init key is
+	// `${stableHash}::${entrypoint.name}` — cheap string concat instead of
+	// re-canonicalizing+stringifying+SHA-256ing the whole payload per call.
+	stableInitHashCache = null;
+	evalSeq = 0;
+	happyDomDisabled = false;
+	happyDomDisableWarned = false;
+	activeResolveRootId = null;
+	currentServices;
+	constructor(services, asyncResolve) {
+		this.services = services;
+		this.asyncResolve = asyncResolve;
+		this.currentServices = services;
+	}
+	ensureImportsMapping(id, imports) {
+		if (!imports || imports.size === 0) {
+			if (!this.importsByModule.has(id)) {
+				this.importsByModule.set(id, new Map());
+			}
+			return;
+		}
+		const existing = this.importsByModule.get(id);
+		if (!existing || existing.size === 0) {
+			this.importsByModule.set(id, imports);
+			return;
+		}
+		// Merge: widen each specifier's import list rather than replacing.
+		// Different variants of the same module may import different subsets
+		// from the same dependency. The widest set must be preserved so that
+		// any still-linking variant can resolve all its bindings.
+		for (const [specifier, keys] of imports) {
+			const existingKeys = existing.get(specifier);
+			if (!existingKeys) {
+				existing.set(specifier, keys);
+			} else {
+				existing.set(specifier, mergeOnly(existingKeys, keys));
+			}
+		}
+	}
+	getImportOnly(importerId, specifier) {
+		const importsOnly = importerId ? this.importsByModule.get(importerId)?.get(specifier) : undefined;
+		const importerOnly = importerId ? this.onlyByModule.get(importerId) ?? ["*"] : ["*"];
+		return importerOnly.includes("__wywPreval") ? mergeOnly(importsOnly ?? ["*"], ["__wywPreval"]) : importsOnly ?? ["*"];
+	}
+	getLoadRequestOnly(id, importerId, request) {
+		if (!request || !importerId || importerId === id) {
+			return null;
+		}
+		const imports = this.importsByModule.get(importerId);
+		if (!imports?.has(request)) {
+			return null;
+		}
+		const { root } = this.services.options;
+		const keyInfo = toImportKey({
+			source: request,
+			resolved: id,
+			root
+		});
+		const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
+		let nextOnly = applyImportOverrideToOnly(this.getImportOnly(importerId, request), override);
+		const cached = this.services.cache.get("entrypoints", id);
+		if (nextOnly.includes("__wywPreval") && cached?.evaluated && !cached.ignored && !hasCachedWywPrevalExport(this.services, id, cached)) {
+			nextOnly = nextOnly.filter((item) => item !== "__wywPreval");
+		}
+		return nextOnly;
+	}
+	async evaluate(entrypoint, services) {
+		return new Promise((resolve, reject) => {
+			this.pendingEvals.push({
+				entrypoint,
+				services,
+				resolve,
+				reject
+			});
+			this.scheduleEvalFlush();
+		});
+	}
+	scheduleEvalFlush() {
+		if (this.evalFlushScheduled) return;
+		this.evalFlushScheduled = true;
+		queueMicrotask(() => {
+			this.evalFlushScheduled = false;
+			if (this.pendingEvals.length === 0) return;
+			const batch = this.pendingEvals;
+			this.pendingEvals = [];
+			this.evalQueue = this.evalQueue.then(() => this.runEvalBatch(batch));
+		});
+	}
+	async runEvalBatch(batch) {
+		try {
+			await this.ensureRunner();
+		} catch (error) {
+			for (const member of batch) member.reject(error);
+			return;
+		}
+		for (const member of batch) {
+			try {
+				const result = await this.runOneEntrypoint(member.entrypoint, member.services);
+				member.resolve(result);
+			} catch (error) {
+				member.reject(error);
+			}
+		}
+	}
+	async runOneEntrypoint(entrypoint, services) {
+		const activeServices = services ?? this.currentServices;
+		const resolveRootId = getEntrypointResolveRoot(entrypoint);
+		this.currentServices = activeServices;
+		this.activeResolveRootId = resolveRootId;
+		this.resetPerEntrypointState(entrypoint);
+		this.evalSeq += 1;
+		if (debugEvalDir) {
+			debugAction({
+				type: "eval:start",
+				evalSeq: this.evalSeq,
+				entrypoint: entrypoint.name,
+				ts: performance.now()
+			});
+		}
+		try {
+			await this.initRunner(entrypoint);
+			const payload = await this.request("EVAL", { id: entrypoint.name }, EVAL_TIMEOUT_MS);
+			if (debugEvalDir) {
+				debugAction({
+					type: "eval:finish",
+					evalSeq: this.evalSeq,
+					entrypoint: entrypoint.name,
+					hasValues: Boolean(payload.values),
+					ts: performance.now()
+				});
+			}
+			if (payload.modules) {
+				this.applyModuleExports(payload.modules);
+			}
+			if (!payload.values) {
+				return {
+					values: null,
+					dependencies: []
+				};
+			}
+			const values = new Map();
+			Object.entries(payload.values).forEach(([key, serialized]) => {
+				values.set(key, deserializeValue(serialized));
+			});
+			return {
+				values,
+				dependencies: this.collectEntrypointDependencies(entrypoint.name)
+			};
+		} finally {
+			if (this.activeResolveRootId === resolveRootId) {
+				this.activeResolveRootId = null;
+			}
+		}
+	}
+	resetPerEntrypointState(entrypoint) {
+		this.runtimeDependenciesByModule.clear();
+		this.emittedDependencies.clear();
+		this.importsByModule.clear();
+		this.onlyByModule.clear();
+		this.resolveCache.clear();
+		this.resolveInFlight.clear();
+		this.onlyByModule.set(entrypoint.name, ["__wywPreval"]);
+	}
+	applyModuleExports(modules) {
+		Object.entries(modules).forEach(([id, serializedExports]) => {
+			if (!serializedExports || Object.keys(serializedExports).length === 0) {
+				return;
+			}
+			const cached = this.services.cache.get("entrypoints", id);
+			if (!cached || cached.ignored) {
+				return;
+			}
+			const existingEvaluatedOnly = cached.evaluatedOnly ?? [];
+			const target = cached.evaluated || !("createEvaluated" in cached) ? cached : cached.createEvaluated();
+			const exportsProxy = target.exports;
+			Object.entries(serializedExports).forEach(([key, serialized]) => {
+				exportsProxy[key] = deserializeValue(serialized);
+			});
+			const knownExports = collectKnownExportNames(this.services, id, target);
+			const serializedKeys = Object.keys(serializedExports);
+			const coversAllKnownExports = Array.isArray(knownExports) && knownExports.filter((key) => !isEvalOnlyKey(key)).length > 0 && knownExports.filter((key) => !isEvalOnlyKey(key)).every((key) => serializedKeys.includes(key));
+			const coversModule = coversAllKnownExports;
+			const merged = mergeOnly(existingEvaluatedOnly, coversModule ? ["*"] : serializedKeys);
+			if (target.evaluatedOnly) {
+				target.evaluatedOnly.splice(0, target.evaluatedOnly.length, ...merged);
+			}
+			this.services.cache.add("entrypoints", id, target);
+		});
+	}
+	dispose() {
+		if (this.runner) {
+			this.runner.removeAllListeners();
+			this.runner.kill();
+			this.runner = null;
+			this.runnerReady = null;
+			this.runnerInputQueue = null;
+		}
+		this.lastInitKey = null;
+		this.lastHappyDomEnabled = false;
+		this.lastSentLoadByModule.clear();
+		this.stableInitHashCache = null;
+		flushDebugStreams();
+	}
+	createRunnerProcess() {
+		const runnerPath = buildRunnerPath();
+		const nodeBinary = process.env.WYW_NODE_BINARY || (process.execPath.includes("bun") ? "node" : process.execPath);
+		const runner = spawn(nodeBinary, ["--experimental-vm-modules", runnerPath], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			cwd: this.services.options.root ?? process.cwd(),
+			env: {
+				...process.env,
+				WYW_EVAL_RUNNER: "1",
+				NODE_NO_WARNINGS: "1"
+			}
+		});
+		runner.stdout.setEncoding("utf8");
+		return runner;
+	}
+	attachRunnerListeners(runner) {
+		runner.stdout.on("data", (chunk) => this.onData(String(chunk)));
+		runner.stderr.on("data", (chunk) => {
+			this.handleRunnerStderr(chunk);
+		});
+		runner.on("exit", (code, signal) => {
+			if (this.runner !== runner) {
+				return;
+			}
+			const reason = `Eval runner exited (${code ?? "null"} / ${signal ?? "null"})`;
+			this.rejectAllPending(new Error(reason));
+			this.runner = null;
+			this.runnerInputQueue = null;
+			this.runnerReady = null;
+			this.lastInitKey = null;
+			this.lastHappyDomEnabled = false;
+			this.lastSentLoadByModule.clear();
+		});
+	}
+	async ensureRunner() {
+		if (this.runnerReady) {
+			await this.runnerReady;
+			return;
+		}
+		this.runner = this.createRunnerProcess();
+		this.runnerInputQueue = createWriteQueue(this.runner.stdin, "eval runner stdin");
+		this.attachRunnerListeners(this.runner);
+		this.runnerReady = Promise.resolve();
+		await this.runnerReady;
+	}
+	async initIsolatedRunner(payload, timeoutMs) {
+		const runner = this.createRunnerProcess();
+		const requestId = `candidate-init-${++this.nextId}`;
+		let buffer = "";
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const cleanup = () => {
+				runner.stdout.off("data", onStdout);
+				runner.stderr.off("data", onStderr);
+				runner.off("exit", onExit);
+			};
+			const finalizeResolve = (value) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				clearTimeout(timeout);
+				cleanup();
+				resolve(value);
+			};
+			const finalizeReject = (value) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				clearTimeout(timeout);
+				cleanup();
+				reject(value);
+			};
+			const onStderr = (chunk) => {
+				this.handleRunnerStderr(chunk);
+			};
+			const onExit = (code, signal) => {
+				finalizeReject(new Error(`Eval runner exited during init (${code ?? "null"} / ${signal ?? "null"})`));
+			};
+			const onStdout = (chunk) => {
+				const next = `${buffer}${chunk.toString()}`;
+				const lines = next.split("\n");
+				buffer = lines.pop() ?? "";
+				lines.forEach((line) => {
+					if (!line.trim()) return;
+					let message;
+					try {
+						message = JSON.parse(line);
+					} catch {
+						emitWarning(this.services, `[wyw-eval-runner] Failed to parse message: ${line}`);
+						return;
+					}
+					if (message.type === "WARN") {
+						this.handleWarn(message.payload);
+						return;
+					}
+					if (message.type !== "INIT_ACK" || message.id !== requestId) {
+						return;
+					}
+					if (message.error) {
+						runner.kill();
+						finalizeReject(message.error);
+						return;
+					}
+					finalizeResolve(runner);
+				});
+			};
+			const timeout = setTimeout(() => {
+				const error = new Error(`[wyw-in-js] Eval runner timed out for INIT`);
+				error.code = "WYW_EVAL_TIMEOUT";
+				runner.kill();
+				finalizeReject(error);
+			}, timeoutMs);
+			runner.stdout.on("data", onStdout);
+			runner.stderr.on("data", onStderr);
+			runner.on("exit", onExit);
+			const message = {
+				type: "INIT",
+				id: requestId,
+				payload
+			};
+			writeToStream(runner.stdin, `${JSON.stringify(message)}\n`, "eval runner stdin").catch((error) => {
+				runner.kill();
+				finalizeReject(error instanceof Error ? error : new Error(String(error)));
+			});
+		});
+	}
+	replaceRunner(nextRunner) {
+		if (this.runner) {
+			this.runner.removeAllListeners();
+			this.runner.kill();
+		}
+		this.runner = nextRunner;
+		this.runnerInputQueue = createWriteQueue(nextRunner.stdin, "eval runner stdin");
+		this.attachRunnerListeners(nextRunner);
+		this.runnerReady = Promise.resolve();
+		// New process ⇒ runner's moduleCache/moduleHashes are empty, so our mirror
+		// of "what we already shipped" is stale.
+		this.lastSentLoadByModule.clear();
+	}
+	getStableInitHash(services, features) {
+		const pluginOptionsRef = services.options.pluginOptions;
+		const evalOptionsRef = pluginOptionsRef.eval;
+		const rootRef = services.options.root;
+		if (this.stableInitHashCache !== null && this.stableInitHashCache.pluginOptionsRef === pluginOptionsRef && this.stableInitHashCache.evalOptionsRef === evalOptionsRef && this.stableInitHashCache.featuresRef === features && this.stableInitHashCache.rootRef === rootRef) {
+			return this.stableInitHashCache.hash;
+		}
+		// Build a sample payload (entrypoint name doesn't affect stable hash; we
+		// pass any name and strip it inside getStableInitPayloadHash).
+		// encodeGlobals is memoized so this is the only place it actually runs
+		// per config change.
+		const samplePayload = buildRunnerInitPayload(services, { name: "\0stable-init-sample\0" }, features);
+		samplePayload.reuseModules = true;
+		const hash = getStableInitPayloadHash(samplePayload);
+		this.stableInitHashCache = {
+			pluginOptionsRef,
+			evalOptionsRef,
+			featuresRef: features,
+			rootRef,
+			hash
+		};
+		return hash;
+	}
+	async initRunner(entrypoint) {
+		const features = this.getRunnerFeatures();
+		const stableHash = this.getStableInitHash(this.currentServices, features);
+		const initKey = `${stableHash}::${entrypoint.name}`;
+		if (this.lastInitKey === initKey) {
+			return;
+		}
+		const nextHappyDomEnabled = isFeatureEnabled(features, "happyDOM", entrypoint.name);
+		const payload = buildRunnerInitPayload(this.services, entrypoint, features);
+		payload.reuseModules = true;
+		const timeoutMs = this.getInitTimeoutMs(entrypoint, features);
+		if (this.runner && this.lastInitKey !== null && nextHappyDomEnabled && !this.lastHappyDomEnabled && !this.happyDomDisabled) {
+			try {
+				const nextRunner = await this.initIsolatedRunner(payload, timeoutMs);
+				this.replaceRunner(nextRunner);
+				this.lastInitKey = initKey;
+				this.lastHappyDomEnabled = true;
+				return;
+			} catch (error) {
+				if (isEvalTimeoutError(error)) {
+					this.happyDomDisabled = true;
+					this.warnHappyDomDisabledOnce(timeoutMs);
+					const fallbackFeatures = this.getRunnerFeatures();
+					const fallbackPayload = buildRunnerInitPayload(this.services, entrypoint, fallbackFeatures);
+					fallbackPayload.reuseModules = true;
+					await this.request("INIT", fallbackPayload, INIT_TIMEOUT_MS);
+					this.lastInitKey = `${this.getStableInitHash(this.currentServices, fallbackFeatures)}::${entrypoint.name}`;
+					this.lastHappyDomEnabled = false;
+					return;
+				}
+				throw error;
+			}
+		}
+		try {
+			await this.request("INIT", payload, timeoutMs);
+			this.lastInitKey = initKey;
+			this.lastHappyDomEnabled = nextHappyDomEnabled;
+		} catch (error) {
+			if (isEvalTimeoutError(error) && !this.happyDomDisabled && isFeatureEnabled(features, "happyDOM", entrypoint.name)) {
+				this.happyDomDisabled = true;
+				this.warnHappyDomDisabledOnce(timeoutMs);
+				this.dispose();
+				await this.ensureRunner();
+				const fallbackFeatures = this.getRunnerFeatures();
+				const fallbackPayload = buildRunnerInitPayload(this.services, entrypoint, fallbackFeatures);
+				fallbackPayload.reuseModules = true;
+				await this.request("INIT", fallbackPayload, INIT_TIMEOUT_MS);
+				this.lastInitKey = getInitPayloadKey(fallbackPayload);
+				this.lastHappyDomEnabled = false;
+				return;
+			}
+			throw error;
+		}
+	}
+	getRunnerFeatures() {
+		const base = this.services.options.pluginOptions.features;
+		if (!this.happyDomDisabled) return base;
+		return {
+			...base,
+			happyDOM: false
+		};
+	}
+	getInitTimeoutMs(entrypoint, features) {
+		if (this.happyDomDisabled || !HAPPYDOM_INIT_TIMEOUT_MS || HAPPYDOM_INIT_TIMEOUT_MS <= 0) {
+			return INIT_TIMEOUT_MS;
+		}
+		if (isFeatureEnabled(features, "happyDOM", entrypoint.name)) {
+			return Math.min(INIT_TIMEOUT_MS, HAPPYDOM_INIT_TIMEOUT_MS);
+		}
+		return INIT_TIMEOUT_MS;
+	}
+	warnHappyDomDisabledOnce(timeoutMs) {
+		if (this.happyDomDisableWarned) return;
+		this.happyDomDisableWarned = true;
+		emitWarning(this.services, [
+			`[wyw-in-js] DOM emulation initialization exceeded ${timeoutMs}ms and will be disabled for this run.`,
+			`WyW will continue without DOM emulation (as if features.happyDOM:false).`,
+			``,
+			`To silence this warning: set features: { happyDOM: false }.`,
+			`To restore DOM emulation, ensure "happy-dom" can be imported in the build-time runtime.`,
+			`You can tune the timeout with WYW_EVAL_HAPPYDOM_INIT_TIMEOUT_MS.`
+		].join("\n"));
+	}
+	onData(chunk) {
+		const buffer = this.onData.buffer ?? "";
+		const next = `${buffer}${chunk}`;
+		const lines = next.split("\n");
+		this.onData.buffer = lines.pop() ?? "";
+		lines.forEach((line) => {
+			if (!line.trim()) return;
+			let message;
+			try {
+				message = JSON.parse(line);
+			} catch (error) {
+				emitWarning(this.services, `[wyw-eval-runner] Failed to parse message: ${line}`);
+				return;
+			}
+			this.handleMessage(message);
+		});
+	}
+	handleMessage(message) {
+		switch (message.type) {
+			case "INIT_ACK":
+				if (message.error) {
+					this.rejectPending(message.id, message.error);
+					this.runner?.kill();
+					return;
+				}
+				if (message.modulesReset) {
+					// Runner just cleared its moduleCache during this INIT (full
+					// context rebuild or reuseModules:false). Drop our shipped-code
+					// mirror so handleLoad ships fresh code on the next LOAD.
+					this.lastSentLoadByModule.clear();
+				}
+				this.resolvePending(message.id, {});
+				return;
+			case "EVAL_RESULT":
+				if (message.error) {
+					this.rejectPending(message.id, message.error);
+					return;
+				}
+				this.resolvePending(message.id, message.payload);
+				return;
+			case "RESOLVE":
+				this.handleResolve(message.id, message.payload).catch((error) => {
+					void this.sendMessage({
+						type: "RESOLVE_RESULT",
+						id: message.id,
+						payload: {
+							resolvedId: null,
+							error: toSerializedError(error)
+						}
+					}).catch((sendError) => this.handleSendMessageError(sendError));
+				});
+				return;
+			case "LOAD":
+				this.handleLoad(message.id, message.payload).catch((error) => {
+					void this.sendMessage({
+						type: "LOAD_RESULT",
+						id: message.id,
+						payload: {
+							id: message.payload.id,
+							error: toSerializedError(error)
+						}
+					}).catch((sendError) => this.handleSendMessageError(sendError));
+				});
+				return;
+			case "WARN":
+				this.handleWarn(message.payload);
+				break;
+			default: break;
+		}
+	}
+	handleRunnerStderr(chunk) {
+		const evalConsole = this.currentServices.options.pluginOptions.evalConsole ?? "pipe";
+		if (evalConsole === "warning") {
+			const text = chunk.toString("utf8");
+			for (const line of text.split("\n")) {
+				const trimmed = line.trim();
+				if (trimmed) {
+					emitWarning(this.currentServices, trimmed);
+				}
+			}
+		} else if (evalConsole === "pipe") {
+			process.stderr.write(chunk);
+		}
+	}
+	handleWarn(warning) {
+		if (warning.importer && warning.specifier) {
+			this.trackRuntimeDependency(warning.importer, warning.specifier);
+		}
+		emitEvalWarning(this.currentServices, warning);
+	}
+	async handleResolve(id, payload) {
+		const result = await this.resolveImport(payload);
+		if (debugEvalDir) {
+			debugAction({
+				type: "resolve",
+				evalSeq: this.evalSeq,
+				specifier: payload.specifier,
+				importer: payload.importerId,
+				kind: payload.kind,
+				resolvedId: result.resolvedId ?? null,
+				external: result.external ?? false,
+				ts: performance.now()
+			});
+		}
+		await this.sendMessage({
+			type: "RESOLVE_RESULT",
+			id,
+			payload: {
+				resolvedId: result.resolvedId,
+				external: result.external
+			}
+		});
+	}
+	normalizeResolvedId(resolvedId, specifier, importerId) {
+		const stripped = stripQueryAndHash(resolvedId);
+		if (!stripped) return resolvedId;
+		if (path.extname(stripped)) return resolvedId;
+		const isFileSpecifier = specifier.startsWith(".") || path.isAbsolute(specifier);
+		if (!isFileSpecifier && !path.isAbsolute(stripped)) {
+			return resolvedId;
+		}
+		let candidate = stripped;
+		if (!path.isAbsolute(candidate)) {
+			if (!importerId) {
+				return resolvedId;
+			}
+			const importerFile = stripQueryAndHash(importerId);
+			candidate = path.resolve(path.dirname(importerFile), candidate);
+		}
+		const suffix = resolvedId.slice(stripped.length);
+		for (const ext of this.services.options.pluginOptions.extensions) {
+			const fileCandidate = `${candidate}${ext}`;
+			if (fs.existsSync(fileCandidate)) {
+				return `${fileCandidate}${suffix}`;
+			}
+			const indexCandidate = path.join(candidate, `index${ext}`);
+			if (fs.existsSync(indexCandidate)) {
+				return `${indexCandidate}${suffix}`;
+			}
+		}
+		if (importerId) {
+			try {
+				const importerFile = stripQueryAndHash(importerId);
+				const resolved = DefaultModuleImplementation._resolveFilename(stripped, {
+					id: importerFile,
+					filename: importerFile,
+					paths: DefaultModuleImplementation._nodeModulePaths(path.dirname(importerFile))
+				});
+				if (resolved && resolved !== stripped) {
+					return `${resolved}${suffix}`;
+				}
+			} catch {}
+		}
+		return resolvedId;
+	}
+	async resolveImport({ specifier, importerId, kind }) {
+		return this.services.eventEmitter.action("eval:resolveImport", `${importerId}\0${kind}\0${specifier}`, importerId, () => this.resolveImportImpl({
+			specifier,
+			importerId,
+			kind
+		}));
+	}
+	getResolveStack(importerId) {
+		if (!this.activeResolveRootId || this.activeResolveRootId === importerId) {
+			return [importerId];
+		}
+		return [importerId, this.activeResolveRootId];
+	}
+	async resolveImportImpl({ specifier, importerId, kind }) {
+		if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+			// eslint-disable-next-line no-console
+			console.warn("[wyw-eval:resolve]", {
+				specifier,
+				importerId,
+				kind
+			});
+		}
+		const key = `${kind}:${importerId}:${specifier}`;
+		const evalOptions = getEvalOptions(this.services);
+		const stack = this.getResolveStack(importerId);
+		const importsOnly = this.importsByModule.get(importerId)?.get(specifier);
+		const only = this.getImportOnly(importerId, specifier);
+		if (process.env.WYW_DEBUG_EVAL_RESOLVE && !importsOnly) {
+			// eslint-disable-next-line no-console
+			console.warn("[wyw-eval:resolve:only-miss]", {
+				specifier,
+				importerId,
+				kind
+			});
+		}
+		const strippedSpecifier = stripQueryAndHash(specifier);
+		if (path.isAbsolute(strippedSpecifier)) {
+			const normalized = this.normalizeResolvedId(specifier, specifier, importerId);
+			const overridden = this.applyImportOverrides({
+				source: specifier,
+				resolved: normalized,
+				only,
+				external: false
+			}, importerId, stack);
+			this.resolveCache.set(key, {
+				resolvedId: normalized,
+				external: false
+			});
+			return this.finalizeResolvedImport(importerId, specifier, overridden);
+		}
+		const cached = this.resolveCache.get(key);
+		if (cached) {
+			if (!cached.resolvedId) {
+				return this.finalizeResolvedImport(importerId, specifier, {
+					resolvedId: null,
+					only: ["*"]
+				});
+			}
+			const normalized = this.normalizeResolvedId(cached.resolvedId, specifier, importerId);
+			const overridden = this.applyImportOverrides({
+				source: specifier,
+				resolved: normalized,
+				only,
+				external: cached.external
+			}, importerId, stack);
+			if (cached.usedNodeFallback) {
+				this.maybeWarnNodeFallback({
+					importerId,
+					specifier,
+					resolvedId: normalized,
+					kind
+				});
+			}
+			return this.finalizeResolvedImport(importerId, specifier, overridden);
+		}
+		const inFlight = this.resolveInFlight.get(key);
+		if (inFlight) {
+			const cachedResult = await inFlight;
+			if (!cachedResult.resolvedId) {
+				return this.finalizeResolvedImport(importerId, specifier, {
+					resolvedId: null,
+					only: ["*"]
+				});
+			}
+			const normalized = this.normalizeResolvedId(cachedResult.resolvedId, specifier, importerId);
+			const overridden = this.applyImportOverrides({
+				source: specifier,
+				resolved: normalized,
+				only,
+				external: cachedResult.external
+			}, importerId, stack);
+			if (cachedResult.usedNodeFallback) {
+				this.maybeWarnNodeFallback({
+					importerId,
+					specifier,
+					resolvedId: normalized,
+					kind
+				});
+			}
+			return this.finalizeResolvedImport(importerId, specifier, overridden);
+		}
+		const task = (async () => {
+			if (evalOptions.customResolver) {
+				const customResolved = await evalOptions.customResolver(specifier, importerId, kind);
+				if (customResolved) {
+					const normalized = this.normalizeResolvedId(customResolved.id, specifier, importerId);
+					if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+						// eslint-disable-next-line no-console
+						console.warn("[wyw-eval:resolve:custom]", {
+							specifier,
+							importerId,
+							resolved: customResolved.id,
+							normalized,
+							external: customResolved.external
+						});
+					}
+					return {
+						resolvedId: normalized,
+						external: customResolved.external
+					};
+				}
+				if (evalOptions.resolver === "custom") {
+					return { resolvedId: null };
+				}
+			}
+			if (evalOptions.resolver !== "node") {
+				let resolved = null;
+				try {
+					resolved = await this.asyncResolve(specifier, importerId, stack);
+				} catch {
+					resolved = null;
+				}
+				if (resolved) {
+					const normalized = this.normalizeResolvedId(resolved, specifier, importerId);
+					if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+						// eslint-disable-next-line no-console
+						console.warn("[wyw-eval:resolve:async]", {
+							specifier,
+							importerId,
+							resolved,
+							normalized
+						});
+					}
+					return { resolvedId: normalized };
+				}
+			}
+			if (evalOptions.resolver === "node" || evalOptions.require !== "off") {
+				const nodeResolved = this.resolveWithNodeFallback(specifier, importerId);
+				if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+					// eslint-disable-next-line no-console
+					console.warn("[wyw-eval:resolve:node]", {
+						specifier,
+						importerId,
+						resolved: nodeResolved.resolvedId
+					});
+				}
+				return {
+					...nodeResolved,
+					usedNodeFallback: evalOptions.resolver !== "node"
+				};
+			}
+			if (process.env.WYW_DEBUG_EVAL_RESOLVE) {
+				// eslint-disable-next-line no-console
+				console.warn("[wyw-eval:resolve:none]", {
+					specifier,
+					importerId
+				});
+			}
+			return { resolvedId: null };
+		})();
+		this.resolveInFlight.set(key, task);
+		try {
+			const result = await task;
+			this.resolveCache.set(key, result);
+			if (!result.resolvedId) {
+				return this.finalizeResolvedImport(importerId, specifier, {
+					resolvedId: null,
+					only: ["*"]
+				});
+			}
+			const overridden = this.applyImportOverrides({
+				source: specifier,
+				resolved: result.resolvedId,
+				only,
+				external: result.external
+			}, importerId, stack);
+			if (result.usedNodeFallback && result.resolvedId) {
+				this.maybeWarnNodeFallback({
+					importerId,
+					specifier,
+					resolvedId: result.resolvedId,
+					kind
+				});
+			}
+			return this.finalizeResolvedImport(importerId, specifier, overridden);
+		} finally {
+			this.resolveInFlight.delete(key);
+		}
+	}
+	finalizeResolvedImport(importerId, specifier, result) {
+		this.trackImporterDependency(importerId, specifier, result.resolvedId, result.only);
+		this.emitDependency(importerId, specifier, result.resolvedId, result.only);
+		return result;
+	}
+	emitDependency(importerId, specifier, resolvedId, only) {
+		if (resolvedId === null) {
+			return;
+		}
+		const key = `${importerId}\0${specifier}\0${resolvedId}\0${only.join(",")}`;
+		if (this.emittedDependencies.has(key)) {
+			return;
+		}
+		this.emittedDependencies.add(key);
+		this.services.eventEmitter.single({
+			type: "dependency",
+			file: importerId,
+			only,
+			imports: [{
+				from: resolvedId,
+				what: only
+			}],
+			fileIdx: getFileIdx(importerId)
+		});
+	}
+	trackRuntimeDependency(importerId, specifier) {
+		if (isBuiltinSpecifier(specifier) || isVirtualSpecifier(specifier)) {
+			return;
+		}
+		const dependencies = this.runtimeDependenciesByModule.get(importerId) ?? new Set();
+		dependencies.add(specifier);
+		this.runtimeDependenciesByModule.set(importerId, dependencies);
+	}
+	trackImporterDependency(importerId, source, resolved, only) {
+		const importerEntrypoint = this.services.cache.get("entrypoints", importerId);
+		const dependencies = importerEntrypoint?.dependencies;
+		if (!dependencies) return;
+		if (resolved === null) {
+			dependencies.delete(source);
+			return;
+		}
+		const cached = dependencies.get(source);
+		dependencies.set(source, {
+			source,
+			resolved,
+			only: cached ? mergeOnly(cached.only, only) : [...only]
+		});
+	}
+	collectEntrypointDependencies(entrypointId) {
+		const collected = new Set(this.runtimeDependenciesByModule.get(entrypointId) ?? []);
+		const cachedEntrypoint = this.services.cache.get("entrypoints", entrypointId);
+		cachedEntrypoint?.dependencies?.forEach((dependency, specifier) => {
+			if (dependency.resolved !== null && !isBuiltinSpecifier(specifier) && !isVirtualSpecifier(specifier)) {
+				collected.add(specifier);
+			}
+		});
+		return Array.from(collected);
+	}
+	applyImportOverrides(resolved, importerId, stack) {
+		const { root } = this.services.options;
+		const keyInfo = toImportKey({
+			source: resolved.source,
+			resolved: resolved.resolved,
+			root
+		});
+		const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
+		let nextResolved = resolved.resolved;
+		let nextExternal = resolved.external;
+		if (override?.mock) {
+			nextResolved = resolveMockSpecifier({
+				mock: override.mock,
+				importer: importerId,
+				root,
+				stack
+			});
+			nextExternal = false;
+		}
+		let nextOnly = applyImportOverrideToOnly(resolved.only, override);
+		const cached = this.services.cache.get("entrypoints", nextResolved);
+		if (nextOnly.includes("__wywPreval") && cached?.evaluated && !cached.ignored && !hasCachedWywPrevalExport(this.services, nextResolved, cached)) {
+			nextOnly = nextOnly.filter((item) => item !== "__wywPreval");
+		}
+		const storedOnly = this.onlyByModule.get(nextResolved);
+		this.onlyByModule.set(nextResolved, storedOnly ? mergeOnly(storedOnly, nextOnly) : nextOnly);
+		return {
+			resolvedId: nextResolved,
+			external: nextExternal,
+			only: nextOnly
+		};
+	}
+	resolveWithNodeFallback(specifier, importerId) {
+		const extensions = DefaultModuleImplementation._extensions;
+		const added = [];
+		const { conditionNames } = this.services.options.pluginOptions;
+		const conditions = conditionNames?.length ? expandConditions(conditionNames) : undefined;
+		try {
+			this.services.options.pluginOptions.extensions.forEach((ext) => {
+				if (ext in extensions) return;
+				extensions[ext] = NOOP;
+				added.push(ext);
+			});
+			const filename = importerId;
+			const strippedId = stripQueryAndHash(specifier);
+			let resolved;
+			try {
+				resolved = resolveFilenameWithConditions(DefaultModuleImplementation, strippedId, {
+					id: filename,
+					filename,
+					paths: DefaultModuleImplementation._nodeModulePaths(path.dirname(filename))
+				}, conditions);
+			} catch (error) {
+				throw new Error([
+					`[wyw-in-js] Node resolver failed during eval.`,
+					``,
+					`importer: ${filename}`,
+					`source:   ${specifier}`,
+					``,
+					`error: ${error instanceof Error ? error.message : String(error)}`
+				].join("\n"));
+			}
+			const isFileSpecifier = strippedId.startsWith(".") || path.isAbsolute(strippedId);
+			if (isFileSpecifier && path.extname(strippedId) === "" && resolved.endsWith(".cjs") && fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
+				resolved = `${resolved.slice(0, -4)}.js`;
+			}
+			return { resolvedId: this.normalizeResolvedId(resolved, specifier, importerId) };
+		} finally {
+			added.forEach((ext) => delete extensions[ext]);
+		}
+	}
+	maybeWarnNodeFallback({ importerId, specifier, resolvedId, kind }) {
+		const evalOptions = getEvalOptions(this.services);
+		const { root } = this.services.options;
+		const keyInfo = toImportKey({
+			source: specifier,
+			resolved: resolvedId,
+			root
+		});
+		const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
+		if (override && override.unknown === undefined) {
+			return;
+		}
+		const basePolicy = evalOptions.require === "warn-and-run" ? "warn" : "error";
+		let policy = override?.unknown ?? basePolicy;
+		if (evalOptions.require === "off" && policy !== "error") {
+			policy = "error";
+		}
+		if (policy === "error") {
+			throw new Error([
+				`[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+				``,
+				`importer: ${importerId}`,
+				`source:   ${specifier}`,
+				`resolved: ${resolvedId}`,
+				``,
+				`config key: ${keyInfo.key}`,
+				`docs: https://wyw-in-js.dev/troubleshooting`
+			].filter(Boolean).join("\n"));
+		}
+		const warnedUnknownImports = getWarnedUnknownImports(this.services);
+		if (policy === "warn" && !warnedUnknownImports.has(keyInfo.key)) {
+			warnedUnknownImports.add(keyInfo.key);
+			const warningMessage = [
+				`[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+				``,
+				`importer: ${importerId}`,
+				`source:   ${specifier}`,
+				`resolved: ${resolvedId}`,
+				``,
+				`config key: ${keyInfo.key}`,
+				`hint: add { importOverrides: { ${JSON.stringify(keyInfo.key)}: { unknown: 'allow' } } } to silence warnings, or use { mock } / { noShake: true } overrides.`,
+				`docs: https://wyw-in-js.dev/troubleshooting`
+			].filter(Boolean).join("\n");
+			emitEvalWarning(this.currentServices, {
+				code: kind === "require" ? "require-fallback" : "resolve-fallback",
+				message: warningMessage,
+				importer: importerId,
+				specifier,
+				resolved: resolvedId ?? null,
+				callstack: [importerId],
+				hint: `Use importOverrides or eval.require settings to avoid fallback.`
+			});
+		}
+	}
+	async handleLoad(id, payload) {
+		const prepared = await this.loadModule(payload);
+		// Decide once whether the runner already has this exact prepared variant.
+		// The runner caches by id and short-circuits when the LoadResult hash
+		// matches `moduleHashes.get(id)` (runner.js:1834). So when our prior
+		// shipment under the same hash already covered the requested `only`,
+		// re-shipping the code is pure waste — both over IPC and to the dump dir.
+		const previouslySent = prepared.hash ? this.lastSentLoadByModule.get(payload.id) : undefined;
+		// Runner stores by hash but classifies storage by `only` shape: wildcard
+		// (`['*']`) ⇒ moduleCache, anything else ⇒ moduleVariants (runner.js
+		// isFullModuleLoad / runner.js:1832-1842). Reusing across shapes would
+		// hit the wrong map and miss. Require the same shape AND the prepared
+		// `only` to be a subset of what we already shipped — same hash already
+		// implies identical bytes.
+		const sameStorageShape = Boolean(previouslySent && isWildcardOnly(previouslySent.only) === isWildcardOnly(prepared.only));
+		const runnerHasCachedVariant = Boolean(prepared.hash && previouslySent && previouslySent.hash === prepared.hash && sameStorageShape && isSuperSet(previouslySent.only, prepared.only));
+		const shouldShipCode = Boolean(prepared.code && !prepared.exports && !runnerHasCachedVariant);
+		if (debugEvalDir) {
+			if (shouldShipCode) {
+				dumpEvalCode(payload.id, prepared.code, prepared.only, prepared.hash ? `cache:${prepared.hash}` : "fresh", this.evalSeq);
+			}
+			debugAction({
+				type: "load",
+				evalSeq: this.evalSeq,
+				id: payload.id,
+				importer: payload.importerId ?? null,
+				only: prepared.only,
+				hasCode: Boolean(prepared.code),
+				hasExports: Boolean(prepared.exports),
+				hash: prepared.hash ?? null,
+				shipped: shouldShipCode,
+				ts: performance.now()
+			});
+		}
+		await this.sendLoadResult(id, {
+			id: payload.id,
+			code: shouldShipCode ? prepared.code : "",
+			map: null,
+			hash: prepared.hash,
+			only: prepared.only,
+			exports: prepared.exports
+		});
+		if (shouldShipCode && prepared.hash) {
+			const merged = previouslySent?.hash === prepared.hash ? mergeOnly(previouslySent.only, prepared.only) : [...prepared.only];
+			this.lastSentLoadByModule.set(payload.id, {
+				hash: prepared.hash,
+				only: merged
+			});
+		}
+	}
+	async loadModule({ id, importerId, request }) {
+		const actionEntrypoint = importerId ?? id;
+		return this.services.eventEmitter.action("eval:loadModule", `${actionEntrypoint}\0${id}`, actionEntrypoint, () => this.loadModuleImpl({
+			id,
+			importerId,
+			request
+		}));
+	}
+	async loadModuleImpl({ id, importerId, request }) {
+		let cached = this.loadCache.get(id);
+		if (this.services.cache.consumeInvalidation(id)) {
+			this.loadCache.delete(id);
+			cached = undefined;
+		}
+		const loadRequestOnly = this.getLoadRequestOnly(id, importerId, request);
+		if (loadRequestOnly) {
+			const storedOnly = this.onlyByModule.get(id);
+			this.onlyByModule.set(id, storedOnly ? mergeOnly(storedOnly, loadRequestOnly) : loadRequestOnly);
+			this.trackImporterDependency(importerId, request, id, loadRequestOnly);
+			this.emitDependency(importerId, request, id, loadRequestOnly);
+		}
+		let requiredOnly = this.mergeKnownDependencyOnly(id);
+		// Merge the specific exports the importer needs from this module.
+		// The broker's onlyByModule is populated by RESOLVE handlers, but
+		// concurrent message processing can cause a LOAD to arrive before
+		// all pending RESOLVEs are complete. Directly consulting the
+		// importer's imports map ensures we never serve a module with
+		// fewer exports than the requesting importer actually imports.
+		if (importerId && request) {
+			const importerImports = this.importsByModule.get(importerId);
+			if (importerImports) {
+				const specifierOnly = importerImports.get(request);
+				if (specifierOnly && specifierOnly.length > 0) {
+					requiredOnly = requiredOnly.includes("*") ? requiredOnly : mergeOnly(requiredOnly, specifierOnly);
+				}
+			}
+		}
+		const cachedEntrypoint = this.services.cache.get("entrypoints", id);
+		if (cachedEntrypoint && cachedEntrypoint.evaluated && !cachedEntrypoint.ignored && cachedEntrypoint.exports && !requiredOnly.includes("*") && !requiredOnly.some(isEvalOnlyKey) && isSuperSet(cachedEntrypoint.evaluatedOnly ?? [], requiredOnly)) {
+			const serializeOnly = getSerializableStaticImportKeys(this.services, id, cachedEntrypoint, requiredOnly, request, importerId);
+			if (serializeOnly) {
+				const serialized = serializeCachedExports(cachedEntrypoint.exports, serializeOnly);
+				if (serialized) {
+					const hash = hashContent(`exports:${JSON.stringify(serialized)}`);
+					return {
+						code: "",
+						imports: null,
+						only: serializeOnly,
+						hash,
+						exports: serialized
+					};
+				}
+			}
+		}
+		// prepareModuleOnDemand is deterministic given (id, requiredOnly): the
+		// shaker output depends only on source bytes (invalidated via
+		// consumeInvalidation when the file changes) and the requested `only`.
+		// Side effects from __wywPreval happen at runtime in the runner, not at
+		// preparation time — so caching prepared bytes is safe even for self-loads
+		// with __wywPreval. This lets incremental rebuilds reuse the prepared
+		// entrypoint when its source is unchanged; my IPC dedup mirror then
+		// suppresses re-shipping to the runner.
+		if (cached && isPreparedCacheHit(cached, requiredOnly)) {
+			this.ensureImportsMapping(id, cached.imports);
+			return cached;
+		}
+		const inflight = this.loadInFlight.get(id);
+		if (inflight) {
+			const result = await inflight;
+			if (isPreparedCacheHit(result, requiredOnly)) {
+				this.ensureImportsMapping(id, result.imports);
+				return result;
+			}
+		}
+		const slowImportWarningsEnabled = isWarningEnabled(process.env.WYW_WARN_SLOW_IMPORTS);
+		const slowImportThresholdMs = slowImportWarningsEnabled ? getSlowImportThresholdMs() : 0;
+		const warnedSlowImports = slowImportWarningsEnabled ? getWarnedSlowImports(this.services) : null;
+		const shouldWarnSlowImport = Boolean(slowImportWarningsEnabled && warnedSlowImports && slowImportThresholdMs > 0 && request && importerId && importerId !== id);
+		const slowImportStartedAt = shouldWarnSlowImport ? performance.now() : 0;
+		const task = (async () => {
+			const evalOptions = getEvalOptions(this.services);
+			if (evalOptions.customLoader) {
+				const loaded = await evalOptions.customLoader(id);
+				if (loaded) {
+					const code = formatLoaderResult(loaded.code, loaded.loader);
+					return {
+						code,
+						imports: null,
+						only: requiredOnly,
+						hash: hashContent(code)
+					};
+				}
+			}
+			if (request && importerId) {
+				const loaded = loadByImportLoaders(this.services, request, id, importerId);
+				if (loaded.handled) {
+					const code = `export default ${JSON.stringify(loaded.value)};`;
+					return {
+						code,
+						imports: null,
+						only: requiredOnly,
+						hash: hashContent(code)
+					};
+				}
+			}
+			const strippedId = stripQueryAndHash(id);
+			const extension = path.extname(strippedId);
+			if (extension === ".json") {
+				const jsonSource = fs.readFileSync(strippedId, "utf-8");
+				const code = `export default ${JSON.stringify(JSON.parse(jsonSource))};`;
+				return {
+					code,
+					imports: null,
+					only: requiredOnly,
+					hash: hashContent(code)
+				};
+			}
+			if (extension && !this.services.options.pluginOptions.extensions.includes(extension)) {
+				const code = `export default ${JSON.stringify(id)};`;
+				return {
+					code,
+					imports: null,
+					only: requiredOnly,
+					hash: hashContent(code)
+				};
+			}
+			const directBarrelProxy = buildDirectBarrelProxy(this.services, id, requiredOnly);
+			if (directBarrelProxy) {
+				return {
+					...directBarrelProxy,
+					hash: hashContent(directBarrelProxy.code)
+				};
+			}
+			if (!requiredOnly.includes("*")) {
+				const loadedAndParsed = this.services.loadAndParseFn(this.services, id, undefined, this.services.log);
+				if (loadedAndParsed.evaluator !== "ignored" && loadedAndParsed.evaluator === oxcShaker && isStaticallyEvaluatableModule(loadedAndParsed.code, id)) {
+					requiredOnly = ["*"];
+					this.onlyByModule.set(id, requiredOnly);
+				}
+			}
+			const prepareOnly = requiredOnly.includes("__wywPreval") || !cached ? requiredOnly : mergeOnly(cached.only, requiredOnly);
+			const prepared = prepareModuleOnDemand(this.services, id, prepareOnly);
+			this.ensureImportsMapping(id, prepared.imports);
+			if (shouldWarnSlowImport && request && importerId) {
+				const durationMs = performance.now() - slowImportStartedAt;
+				if (durationMs >= slowImportThresholdMs) {
+					const { root } = this.services.options;
+					const resolvedKey = stripQueryAndHash(id);
+					const { key: importKey } = toImportKey({
+						source: request,
+						resolved: resolvedKey,
+						root
+					});
+					const dedupeKey = `${importerId}::${importKey}`;
+					if (warnedSlowImports && !warnedSlowImports.has(dedupeKey)) {
+						warnedSlowImports.add(dedupeKey);
+						const warning = [
+							`[wyw-in-js] Slow import during prepare stage`,
+							``,
+							`file: ${importerId}`,
+							`import: ${request}`,
+							`resolved: ${resolvedKey}`,
+							`duration: ${durationMs.toFixed(1)}ms`,
+							``,
+							`tip: if this import is runtime-only or heavy, mock it during evaluation via importOverrides:`,
+							`  importOverrides: {`,
+							`    '${importKey}': { mock: './path/to/mock' },`,
+							`  }`,
+							``,
+							`note: importOverrides affects only build-time evaluation (it does not change your bundler runtime behavior)`,
+							``,
+							`note: configure threshold with WYW_WARN_SLOW_IMPORTS_MS (current: ${slowImportThresholdMs}ms)`
+						].join("\n");
+						emitWarning(this.currentServices, warning);
+					}
+				}
+			}
+			const hash = hashContent(prepared.code);
+			return {
+				...prepared,
+				hash
+			};
+		})();
+		this.loadInFlight.set(id, task);
+		try {
+			const result = await task;
+			// Register imports for ALL code paths (barrel proxy, prepareModuleOnDemand,
+			// custom loaders). Without this, the barrel proxy path skips
+			// ensureImportsMapping, so getLoadRequestOnly can't determine what a barrel
+			// module imports from its sub-dependencies.
+			this.ensureImportsMapping(id, result.imports);
+			this.loadCache.set(id, result);
+			return result;
+		} finally {
+			this.loadInFlight.delete(id);
+		}
+	}
+	async sendLoadResult(id, payload) {
+		if (!payload.code) {
+			await this.sendMessage({
+				type: "LOAD_RESULT",
+				id,
+				payload
+			});
+			return;
+		}
+		const message = {
+			type: "LOAD_RESULT",
+			id,
+			payload
+		};
+		const serialized = JSON.stringify(message);
+		if (serialized.length < MAX_MESSAGE_SIZE) {
+			await this.sendMessage(message);
+			return;
+		}
+		const { code } = payload;
+		const chunkCount = Math.ceil(code.length / MAX_CHUNK_SIZE);
+		for (let index = 0; index < chunkCount; index += 1) {
+			const start = index * MAX_CHUNK_SIZE;
+			const end = start + MAX_CHUNK_SIZE;
+			const codeChunk = code.slice(start, end);
+			const chunkPayload = {
+				id: payload.id,
+				codeChunk,
+				chunkIndex: index,
+				chunkCount
+			};
+			if (index === 0) {
+				chunkPayload.map = payload.map;
+				chunkPayload.hash = payload.hash;
+				chunkPayload.only = payload.only;
+				chunkPayload.exports = payload.exports;
+				chunkPayload.error = payload.error;
+			}
+			await this.sendMessage({
+				type: "LOAD_RESULT",
+				id,
+				payload: chunkPayload
+			});
+		}
+	}
+	sendMessage(message) {
+		const payload = `${JSON.stringify(message)}\n`;
+		invariant(payload.length < MAX_MESSAGE_SIZE, "Message too large");
+		if (!this.runnerInputQueue) {
+			return Promise.reject(new Error("Eval runner is not ready"));
+		}
+		return this.runnerInputQueue.write(payload);
+	}
+	handleSendMessageError(error, id) {
+		const serialized = error instanceof Error ? {
+			message: error.message,
+			stack: error.stack
+		} : { message: String(error) };
+		if (id) {
+			this.rejectPending(id, serialized);
+		}
+		this.runner?.kill();
+	}
+	request(type, payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+		this.nextId += 1;
+		const id = `${this.nextId}`;
+		const message = {
+			type,
+			id,
+			payload
+		};
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(id);
+				this.runner?.kill();
+				const error = new Error(`[wyw-in-js] Eval runner timed out for ${type}`);
+				error.code = "WYW_EVAL_TIMEOUT";
+				reject(error);
+			}, timeoutMs);
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timeout
+			});
+			this.sendMessage(message).catch((error) => this.handleSendMessageError(error, id));
+		});
+	}
+	resolvePending(id, payload) {
+		const pending = this.pending.get(id);
+		if (!pending) return;
+		clearTimeout(pending.timeout);
+		this.pending.delete(id);
+		pending.resolve(payload);
+	}
+	rejectPending(id, error) {
+		const pending = this.pending.get(id);
+		if (!pending) return;
+		clearTimeout(pending.timeout);
+		this.pending.delete(id);
+		const cause = error.cause ? Object.assign(new Error(error.cause.message), { stack: error.cause.stack }) : undefined;
+		const err = cause ? new Error(error.message, { cause }) : new Error(error.message);
+		if (error.stack) {
+			err.stack = error.stack;
+		}
+		pending.reject(err);
+	}
+	rejectAllPending(error) {
+		this.pending.forEach((pending) => {
+			clearTimeout(pending.timeout);
+			pending.reject(error);
+		});
+		this.pending.clear();
+	}
+	mergeKnownDependencyOnly(id) {
+		const storedOnly = this.onlyByModule.get(id) ?? ["*"];
+		if (storedOnly.includes("*")) {
+			return storedOnly;
+		}
+		let mergedOnly = storedOnly;
+		for (const cachedEntrypoint of this.services.cache.entrypoints.values()) {
+			const { dependencies } = cachedEntrypoint;
+			if (!dependencies) {
+				continue;
+			}
+			for (const dependency of dependencies.values()) {
+				if (dependency.resolved !== id || !dependency.only) {
+					continue;
+				}
+				mergedOnly = mergeOnly(mergedOnly, dependency.only);
+				if (mergedOnly.includes("*")) {
+					this.onlyByModule.set(id, mergedOnly);
+					return mergedOnly;
+				}
+			}
+		}
+		this.onlyByModule.set(id, mergedOnly);
+		return mergedOnly;
+	}
+}
+const evalBrokers = new WeakMap();
+export const disposeEvalBroker = (cache) => {
+	const cached = evalBrokers.get(cache);
+	if (!cached) return;
+	cached.broker.dispose();
+	evalBrokers.delete(cache);
+};
+export const getEvalBroker = (services, asyncResolve, cacheKey) => {
+	const cached = evalBrokers.get(services.cache);
+	if (cached && cached.key === cacheKey) return cached.broker;
+	if (cached) {
+		disposeEvalBroker(services.cache);
+	}
+	const broker = new EvalBroker(services, asyncResolve);
+	evalBrokers.set(services.cache, {
+		key: cacheKey,
+		broker
+	});
+	return broker;
+};
+//# sourceMappingURL=broker.js.map