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

package/types/eval/broker.js

@@ -0,0 +1,2262 @@
+/* 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';
+import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from '../utils/importOverrides';
+import { getFileIdx } from '../utils/getFileIdx';
+import { collectOxcExportsAndImports } from '../utils/collectOxcExportsAndImports';
+import { parseRequest, stripQueryAndHash } from '../utils/parseRequest';
+import { resolveFilenameWithConditions } from '../utils/resolveWithConditions';
+import { hasCachedWywPrevalExport, } from '../utils/hasCachedWywPrevalExport';
+import { isSuperSet, mergeOnly } from '../transform/Entrypoint.helpers';
+import { oxcShaker } from '../shaker';
+import { analyzeOxcBarrelFile } from '../transform/oxcBarrelManifest';
+import { LruCache } from './lru';
+import { prepareModuleOnDemand, } from './prepareModuleOnDemand';
+import { deserializeValue, encodeGlobals, serializeValue, } from './serialize';
+import { createWriteQueue, writeToStream } from './writeQueue';
+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 = 5000;
+const LOAD_CACHE_SIZE = 1000;
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
+const REQUEST_TIMEOUT_MS = 30_000;
+const EVAL_TIMEOUT_MS = Number(process.env.WYW_EVAL_TIMEOUT_MS ?? 300_000);
+const INIT_TIMEOUT_MS = 120_000;
+const HAPPYDOM_INIT_TIMEOUT_MS = Number(process.env.WYW_EVAL_HAPPYDOM_INIT_TIMEOUT_MS ??
+    process.env.WYW_HAPPYDOM_TIMEOUT_MS ??
+    15_000);
+// 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 {
+    services;
+    asyncResolve;
+    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 {
+                // ignore fallback failures
+            }
+        }
+        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: type,
+            id,
+            payload: 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: 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;
+};