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

package/types/module.js

@@ -1,58 +1,53 @@
-"use strict";
 /**
  * This is a custom implementation for the module system for evaluating code,
  * used for resolving values for dependencies interpolated in `css` or `styled`.
  *
  * This serves 2 purposes:
- * - Avoid leakage from evaluated code to module cache in current context, e.g. `babel-register`
+ * - Avoid leakage from evaluated code to module cache in current context
  * - Allow us to invalidate the module cache without affecting other stuff, necessary for rebuilds
  *
- * We also use it to transpile the code with Babel by default.
+ * We also store prepared evaluator code in it.
  * We also store source maps for it to provide correct error stacktraces.
  *
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = exports.DefaultModuleImplementation = void 0;
-const fs_1 = __importDefault(require("fs"));
-const module_1 = __importDefault(require("module"));
-const path_1 = __importDefault(require("path"));
-const vm_1 = __importDefault(require("vm"));
-const ts_invariant_1 = require("ts-invariant");
-const shared_1 = require("@wyw-in-js/shared");
-require("./utils/dispose-polyfill");
-const Entrypoint_1 = require("./transform/Entrypoint");
-const Entrypoint_helpers_1 = require("./transform/Entrypoint.helpers");
-const UnprocessedEntrypointError_1 = require("./transform/actions/UnprocessedEntrypointError");
-const importOverrides_1 = require("./utils/importOverrides");
-const parseRequest_1 = require("./utils/parseRequest");
-const createVmContext_1 = require("./vm/createVmContext");
+import fs from 'fs';
+import NativeModule, { createRequire } from 'module';
+import path from 'path';
+import * as vm from 'vm';
+import { pathToFileURL } from 'url';
+import { invariant } from 'ts-invariant';
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import './utils/dispose-polyfill';
+import { Entrypoint } from './transform/Entrypoint';
+import { getStack, isSuperSet, mergeOnly, } from './transform/Entrypoint.helpers';
+import { isUnprocessedEntrypointError } from './transform/actions/UnprocessedEntrypointError';
+import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey, } from './utils/importOverrides';
+import { resolveWithNativeResolver } from './utils/nativeResolver';
+import { parseRequest, stripQueryAndHash } from './utils/parseRequest';
+import { resolveFilenameWithConditions } from './utils/resolveWithConditions';
+import { createVmContext } from './vm/createVmContext';
 const CJS_DEFAULT_CONDITIONS = ['require', 'node', 'default'];
-function expandConditions(conditionNames) {
+const expandConditions = (conditionNames) => {
     const result = new Set();
-    for (const name of conditionNames) {
+    conditionNames.forEach((name) => {
         if (name === '...') {
-            for (const d of CJS_DEFAULT_CONDITIONS)
-                result.add(d);
-        }
-        else {
-            result.add(name);
+            CJS_DEFAULT_CONDITIONS.forEach((condition) => result.add(condition));
+            return;
         }
-    }
+        result.add(name);
+    });
     return result;
-}
-function isBarePackageSubpath(id) {
-    if (id.startsWith('.') || path_1.default.isAbsolute(id)) {
+};
+const isBarePackageSubpath = (id) => {
+    if (id.startsWith('.') || path.isAbsolute(id)) {
         return false;
     }
     if (id.startsWith('@')) {
         return id.split('/').length > 2;
     }
     return id.includes('/');
-}
-exports.DefaultModuleImplementation = module_1.default;
+};
+export const DefaultModuleImplementation = NativeModule;
 // Supported node builtins based on the modules polyfilled by webpack
 // `true` means module is polyfilled, `false` means module is empty
 const builtins = {
@@ -95,7 +90,14 @@ const REACT_REFRESH_VIRTUAL_ID = '/@react-refresh';
 const reactRefreshRuntime = {
     createSignatureFunctionForTransform: () => () => { },
 };
+const nodeRequire = createRequire(import.meta.url);
 const NOOP = () => { };
+const TROUBLESHOOTING_URL = 'https://wyw-in-js.dev/troubleshooting';
+const defaultEvalOptions = {
+    errors: 'strict',
+    require: 'warn-and-run',
+    resolver: 'bundler',
+};
 const browserOnlyEvalHintTriggers = [
     'window is not defined',
     "evaluating 'window",
@@ -117,9 +119,14 @@ const getBrowserOnlyEvalHint = (error) => {
         'This usually means browser-only code ran during build-time evaluation.',
         'Move browser-only initialization out of evaluated modules, or mock the import via `importOverrides`.',
         "Example: importOverrides: { 'msw/browser': { mock: './src/__mocks__/msw-browser.js' } }",
+        `Docs: ${TROUBLESHOOTING_URL}`,
     ].join('\n');
 };
 const warnedUnknownImportsByServices = new WeakMap();
+const getEvalOptions = (services) => ({
+    ...defaultEvalOptions,
+    ...(services.options.pluginOptions.eval ?? {}),
+});
 function emitWarning(services, message) {
     if (services.emitWarning) {
         services.emitWarning(message);
@@ -128,6 +135,11 @@ function emitWarning(services, message) {
     // eslint-disable-next-line no-console
     console.warn(message);
 }
+function emitEvalWarning(services, warning) {
+    const { onWarn } = getEvalOptions(services);
+    onWarn?.(warning);
+    emitWarning(services, warning.message);
+}
 function getWarnedUnknownImports(services) {
     const cached = warnedUnknownImportsByServices.get(services);
     if (cached) {
@@ -144,16 +156,48 @@ function getUncached(cached, test) {
     }
     return test.filter((t) => !cachedSet.has(t));
 }
-function resolve(id) {
-    const { resolved } = this.resolveDependency(id);
-    (0, ts_invariant_1.invariant)(resolved, `Unable to resolve "${id}"`);
-    return resolved;
-}
 const defaultImportLoaders = {
     raw: 'raw',
     url: 'url',
 };
-class Module {
+const buildModulePreamble = (id) => {
+    const payload = JSON.stringify(id);
+    return [
+        `const __wyw_module = __wyw_getModule(${payload});`,
+        `let exports = __wyw_module.exports;`,
+        `const module = __wyw_module.module;`,
+        `const require = __wyw_module.require;`,
+        `const __filename = __wyw_module.filename;`,
+        `const __dirname = __wyw_module.dirname;`,
+        `const __wyw_dynamic_import = __wyw_module.dynamicImport;`,
+        ``,
+    ].join('\n');
+};
+const applyModuleNamespace = (entrypointExports, module, moduleData) => {
+    const { namespace } = module;
+    const keys = Object.keys(namespace);
+    if (keys.length === 0 && moduleData.module.exports !== moduleData.exports) {
+        return moduleData.module.exports;
+    }
+    const nextExports = entrypointExports;
+    keys.forEach((key) => {
+        nextExports[key] = namespace[key];
+    });
+    return nextExports;
+};
+const ensureVmModules = () => {
+    if (!vm.SourceTextModule || !vm.SyntheticModule) {
+        throw new EvalError('[wyw-in-js] vm.SourceTextModule is not available in this runtime. ' +
+            'WyW v2 uses a separate eval runner process for ESM evaluation.');
+    }
+};
+const getImporterDependency = (importer, specifier) => {
+    if (importer instanceof Entrypoint) {
+        return importer.getDependency(specifier);
+    }
+    return importer.dependencies.get(specifier);
+};
+export class Module {
     services;
     moduleImpl;
     callstack = [];
@@ -166,65 +210,24 @@ class Module {
     ignored;
     isEvaluated = false;
     parentIsIgnored;
-    require = Object.assign((id) => {
-        if (id === REACT_REFRESH_VIRTUAL_ID) {
-            this.dependencies.push(id);
-            this.debug('require', `vite virtual '${id}'`);
-            return reactRefreshRuntime;
-        }
-        if (id.startsWith(VITE_VIRTUAL_PREFIX)) {
-            this.dependencies.push(id);
-            this.debug('require', `vite virtual '${id}'`);
-            return {};
-        }
-        if (id in builtins) {
-            // The module is in the allowed list of builtin node modules
-            // Ideally we should prevent importing them, but webpack polyfills some
-            // So we check for the list of polyfills to determine which ones to support
-            if (builtins[id]) {
-                this.debug('require', `builtin '${id}'`);
-                return require(id);
-            }
-            return null;
-        }
-        // Resolve module id (and filename) relatively to parent module
-        const dependency = this.resolveDependency(id);
-        if (dependency.resolved === id && !path_1.default.isAbsolute(id)) {
-            // The module is a builtin node modules, but not in the allowed list
-            throw new Error(`Unable to import "${id}". Importing Node builtins is not supported in the sandbox.`);
-        }
-        (0, ts_invariant_1.invariant)(dependency.resolved, `Dependency ${dependency.source} cannot be resolved`);
-        const loaded = this.loadByImportLoaders(id, dependency.resolved);
-        if (loaded.handled) {
-            this.dependencies.push(id);
-            this.debug('require', `${id} -> ${dependency.resolved} (loader)`);
-            return loaded.value;
-        }
-        this.dependencies.push(id);
-        this.debug('require', `${id} -> ${dependency.resolved}`);
-        const entrypoint = this.getEntrypoint(dependency.resolved, dependency.only, this.debug);
-        if (entrypoint === null) {
-            return dependency.resolved;
-        }
-        if (entrypoint.evaluated ||
-            (0, Entrypoint_helpers_1.isSuperSet)(entrypoint.evaluatedOnly, dependency.only)) {
-            return entrypoint.exports;
-        }
-        const m = this.createChild(entrypoint);
-        m.evaluate();
-        return entrypoint.exports;
-    }, {
+    require = Object.assign((id, nonLiteral) => this.requireWithFallback(id, this.entrypoint, nonLiteral), {
         ensure: NOOP,
-        resolve: resolve.bind(this),
+        resolve: (id) => this.resolveRequire(id, this.entrypoint).resolved,
     });
-    resolve = resolve.bind(this);
+    resolve = (id) => this.resolveRequire(id, this.entrypoint).resolved;
     cache;
+    context = null;
+    teardown = null;
+    moduleCache = new Map();
+    moduleEntrypoints = new WeakMap();
+    moduleLinkPromises = new WeakMap();
+    moduleData = new Map();
     #entrypointRef;
-    constructor(services, entrypoint, parentModule, moduleImpl = exports.DefaultModuleImplementation) {
+    constructor(services, entrypoint, parentModule, moduleImpl = DefaultModuleImplementation) {
         this.services = services;
         this.moduleImpl = moduleImpl;
         this.cache = services.cache;
-        this.#entrypointRef = (0, shared_1.isFeatureEnabled)(services.options.pluginOptions.features, 'useWeakRefInEval', entrypoint.name)
+        this.#entrypointRef = isFeatureEnabled(services.options.pluginOptions.features, 'useWeakRefInEval', entrypoint.name)
             ? new WeakRef(entrypoint)
             : entrypoint;
         this.idx = entrypoint.idx;
@@ -254,10 +257,10 @@ class Module {
         const entrypoint = this.#entrypointRef instanceof WeakRef
             ? this.#entrypointRef.deref()
             : this.#entrypointRef;
-        (0, ts_invariant_1.invariant)(entrypoint, `Module ${this.idx} is disposed`);
+        invariant(entrypoint, `Module ${this.idx} is disposed`);
         return entrypoint;
     }
-    evaluate() {
+    async evaluate() {
         const { entrypoint } = this;
         entrypoint.assertTransformed();
         const cached = this.cache.get('entrypoints', entrypoint.name);
@@ -267,7 +270,6 @@ class Module {
             evaluatedCreated = true;
         }
         const { transformedCode: source } = entrypoint;
-        const { pluginOptions } = this.services.options;
         if (!source) {
             this.debug(`evaluate`, 'there is nothing to evaluate');
             return;
@@ -279,31 +281,28 @@ class Module {
         this.debug('evaluate');
         this.debug.extend('source')('%s', source);
         this.isEvaluated = true;
-        const filename = (0, parseRequest_1.stripQueryAndHash)(this.filename);
+        const filename = stripQueryAndHash(this.filename);
         if (/\.json$/.test(filename)) {
             // For JSON files, parse it to a JS object similar to Node
             this.exports = JSON.parse(source);
             return;
         }
-        const { context, teardown } = (0, createVmContext_1.createVmContext)(filename, pluginOptions.features, {
-            module: this,
-            exports: entrypoint.exports,
-            require: this.require,
-            __wyw_dynamic_import: async (id) => this.require(String(id)),
-            __dirname: path_1.default.dirname(filename),
-        }, pluginOptions.overrideContext);
+        const { teardown } = await this.ensureContext(filename);
         try {
-            const script = new vm_1.default.Script(`(function (exports) { ${source}\n})(exports);`, {
-                filename,
-            });
-            script.runInContext(context);
+            const module = await this.getModuleForEntrypoint(entrypoint);
+            await this.linkModule(module);
+            await module.evaluate();
+            const exports = applyModuleNamespace(entrypoint.exports, module, this.getModuleData(entrypoint.name));
+            if (exports !== entrypoint.exports) {
+                entrypoint.exports = exports;
+            }
         }
         catch (e) {
             this.isEvaluated = false;
             if (evaluatedCreated) {
                 this.cache.add('entrypoints', entrypoint.name, cached);
             }
-            if ((0, UnprocessedEntrypointError_1.isUnprocessedEntrypointError)(e)) {
+            if (isUnprocessedEntrypointError(e)) {
                 // It will be handled by evalFile scenario
                 throw e;
             }
@@ -321,13 +320,13 @@ class Module {
         }
     }
     getEntrypoint(filename, only, log) {
-        const strippedFilename = (0, parseRequest_1.stripQueryAndHash)(filename);
-        const extension = path_1.default.extname(strippedFilename);
+        const strippedFilename = stripQueryAndHash(filename);
+        const extension = path.extname(strippedFilename);
         if (extension !== '.json' && !this.extensions.includes(extension)) {
             return null;
         }
         let entrypoint = this.cache.get('entrypoints', filename);
-        if (entrypoint && (0, Entrypoint_helpers_1.isSuperSet)(entrypoint.evaluatedOnly ?? [], only)) {
+        if (entrypoint && isSuperSet(entrypoint.evaluatedOnly ?? [], only)) {
             if (this.cache.checkFreshness(filename, strippedFilename)) {
                 entrypoint = undefined;
             }
@@ -342,15 +341,16 @@ class Module {
         }
         if (this.ignored) {
             log('✅ one of the parent files has been ignored during prepare stage. Original code will be used');
-            const newEntrypoint = this.entrypoint.createChild(filename, ['*'], fs_1.default.readFileSync(strippedFilename, 'utf-8'));
+            const newEntrypoint = this.entrypoint.createChild(filename, ['*'], fs.readFileSync(strippedFilename, 'utf-8'));
             if (newEntrypoint === 'loop') {
-                const stack = (0, Entrypoint_helpers_1.getStack)(this.entrypoint);
+                const stack = getStack(this.entrypoint);
                 throw new Error(`Circular dependency detected: ${stack.join(' -> ')} -> ${filename}`);
             }
             return newEntrypoint;
         }
         let uncachedExports = null;
         let reprocessOnly = only;
+        let cachedSource;
         // Requested file can be already prepared for evaluation on the stage 1
         if (only && entrypoint) {
             const evaluatedExports = entrypoint.evaluatedOnly?.length !== 0
@@ -362,17 +362,30 @@ class Module {
                 return entrypoint;
             }
             if (entrypoint.evaluatedOnly?.length) {
-                reprocessOnly = (0, Entrypoint_helpers_1.mergeOnly)(evaluatedExports, only);
+                if (this.cache.checkFreshness(filename, strippedFilename)) {
+                    entrypoint = undefined;
+                    uncachedExports = null;
+                }
+                else {
+                    reprocessOnly = mergeOnly(evaluatedExports, only);
+                    cachedSource =
+                        entrypoint.loadedAndParsed?.code ?? entrypoint.initialCode;
+                }
+            }
+            if (entrypoint) {
+                log('❌ file has been processed during prepare stage but %o is not evaluated yet (evaluated: %o)', uncachedExports, evaluatedExports);
+            }
+            else {
+                log('❌ file has not been processed during prepare stage');
             }
-            log('❌ file has been processed during prepare stage but %o is not evaluated yet (evaluated: %o)', uncachedExports, evaluatedExports);
         }
         else {
             log('❌ file has not been processed during prepare stage');
         }
         // If code wasn't extracted from cache, it indicates that we were unable
         // to process some of the imports on stage1. Let's try to reprocess.
-        const code = fs_1.default.readFileSync(strippedFilename, 'utf-8');
-        const newEntrypoint = Entrypoint_1.Entrypoint.createRoot(this.services, filename, reprocessOnly, code);
+        const code = cachedSource ?? fs.readFileSync(strippedFilename, 'utf-8');
+        const newEntrypoint = Entrypoint.createRoot(this.services, filename, reprocessOnly, code);
         if (newEntrypoint.evaluated) {
             log('✅ file has been already evaluated');
             return newEntrypoint;
@@ -383,95 +396,430 @@ class Module {
         }
         return newEntrypoint;
     }
+    async ensureContext(filename) {
+        if (this.context && this.teardown) {
+            return { context: this.context, teardown: this.teardown };
+        }
+        const evalOptions = getEvalOptions(this.services);
+        const { context, teardown } = await createVmContext(filename, this.services.options.pluginOptions.features, {
+            ...(evalOptions.globals ?? {}),
+            __wyw_getModule: (id) => this.getModuleData(id),
+        }, this.services.options.pluginOptions.overrideContext);
+        this.context = context;
+        this.teardown = () => {
+            teardown();
+            this.context = null;
+            this.teardown = null;
+        };
+        return { context: this.context, teardown: this.teardown };
+    }
+    getModuleData(id) {
+        const data = this.moduleData.get(id);
+        invariant(data, `Missing module data for ${id}`);
+        return data;
+    }
+    createModuleData(id, entrypoint) {
+        const cached = this.moduleData.get(id);
+        if (cached)
+            return cached;
+        const exporter = entrypoint ?? this.entrypoint;
+        const exportsProxy = entrypoint && 'exports' in entrypoint
+            ? entrypoint.exports
+            : {};
+        const moduleObj = { exports: exportsProxy };
+        const requireFn = Object.assign((request) => this.requireWithFallback(request, exporter), {
+            ensure: NOOP,
+            resolve: (request) => this.resolveRequire(request, exporter).resolved,
+        });
+        const filename = stripQueryAndHash(id);
+        const data = {
+            exports: exportsProxy,
+            module: moduleObj,
+            require: requireFn,
+            filename,
+            dirname: path.dirname(filename),
+            dynamicImport: (request) => this.dynamicImportFrom(exporter, request),
+        };
+        this.moduleData.set(id, data);
+        return data;
+    }
+    async createSourceTextModule(id, code, entrypoint) {
+        ensureVmModules();
+        const { context } = await this.ensureContext(stripQueryAndHash(id));
+        this.createModuleData(id, entrypoint);
+        const module = new vm.SourceTextModule(`${buildModulePreamble(id)}${code}`, {
+            context,
+            identifier: id,
+            initializeImportMeta: (meta, targetModule) => {
+                const identifier = typeof targetModule.identifier === 'string'
+                    ? targetModule.identifier
+                    : id;
+                const fileId = stripQueryAndHash(identifier);
+                Object.assign(meta, {
+                    url: path.isAbsolute(fileId) ? pathToFileURL(fileId).href : fileId,
+                });
+            },
+            importModuleDynamically: (specifier, referencingModule) => this.importModuleDynamically(specifier, referencingModule),
+        });
+        this.moduleCache.set(id, module);
+        if (entrypoint) {
+            this.moduleEntrypoints.set(module, entrypoint);
+        }
+        return module;
+    }
+    async createSyntheticModule(id, exportsValue) {
+        ensureVmModules();
+        const { context } = await this.ensureContext(stripQueryAndHash(id));
+        const exportNames = new Set(Object.keys(exportsValue));
+        const hasDefault = Object.prototype.hasOwnProperty.call(exportsValue, 'default');
+        if (!exportNames.has('default')) {
+            exportNames.add('default');
+        }
+        const module = new vm.SyntheticModule([...exportNames], function init() {
+            exportNames.forEach((key) => {
+                const value = key === 'default' && !hasDefault ? exportsValue : exportsValue[key];
+                this.setExport(key, value);
+            });
+        }, { context, identifier: id });
+        this.moduleCache.set(id, module);
+        return module;
+    }
+    async getVirtualModule(specifier) {
+        if (specifier === REACT_REFRESH_VIRTUAL_ID) {
+            return this.createSyntheticModule(specifier, {
+                createSignatureFunctionForTransform: reactRefreshRuntime.createSignatureFunctionForTransform,
+            });
+        }
+        if (specifier.startsWith(VITE_VIRTUAL_PREFIX)) {
+            return this.createSyntheticModule(specifier, { default: {} });
+        }
+        if (specifier.startsWith('virtual:')) {
+            return this.createSyntheticModule(specifier, { default: {} });
+        }
+        return null;
+    }
+    async getModuleForEntrypoint(entrypoint) {
+        const cached = this.moduleCache.get(entrypoint.name);
+        if (cached)
+            return cached;
+        if (!(entrypoint instanceof Entrypoint)) {
+            return this.createSyntheticModule(entrypoint.name, entrypoint.exports);
+        }
+        entrypoint.assertTransformed();
+        const source = entrypoint.transformedCode ?? '';
+        return this.createSourceTextModule(entrypoint.name, source, entrypoint);
+    }
+    async linkModule(module) {
+        const cached = this.moduleLinkPromises.get(module);
+        if (cached) {
+            await cached;
+            return;
+        }
+        if (module.status !== 'unlinked') {
+            return;
+        }
+        const linking = module.link((specifier, referencingModule) => this.getModuleForSpecifier(specifier, referencingModule, 'import'));
+        this.moduleLinkPromises.set(module, linking);
+        await linking;
+    }
+    async importModuleDynamically(specifier, referencingModule) {
+        const module = await this.getModuleForSpecifier(specifier, referencingModule, 'dynamic-import');
+        await this.linkModule(module);
+        if (module.status === 'linked') {
+            await module.evaluate();
+        }
+        return module;
+    }
+    async dynamicImportFrom(importer, id) {
+        const specifier = String(id);
+        const module = await this.getModuleForSpecifierFromEntrypoint(specifier, importer, 'dynamic-import');
+        await this.linkModule(module);
+        if (module.status === 'linked') {
+            await module.evaluate();
+        }
+        return module.namespace;
+    }
+    async getModuleForSpecifier(specifier, referencingModule, kind) {
+        const importer = this.moduleEntrypoints.get(referencingModule) ?? this.entrypoint;
+        return this.getModuleForSpecifierFromEntrypoint(specifier, importer, kind);
+    }
+    async getModuleForSpecifierFromEntrypoint(specifier, importer, kind) {
+        const virtualModule = await this.getVirtualModule(specifier);
+        if (virtualModule) {
+            return virtualModule;
+        }
+        this.dependencies.push(specifier);
+        const resolved = await this.resolveImport(specifier, importer, kind);
+        const evalOptions = getEvalOptions(this.services);
+        if (!resolved) {
+            if (evalOptions.errors === 'loose') {
+                return this.createSyntheticModule(specifier, { default: undefined });
+            }
+            throw new Error([
+                `[wyw-in-js] Unable to resolve "${specifier}" during evaluation.`,
+                ``,
+                `importer: ${importer.name}`,
+                `hint: check eval.resolver/customResolver or add importOverrides for this specifier.`,
+                `docs: ${TROUBLESHOOTING_URL}`,
+            ].join('\n'));
+        }
+        if (resolved.external) {
+            return this.createSyntheticModule(resolved.resolved, {
+                default: undefined,
+            });
+        }
+        return this.getModuleForResolved(resolved, importer);
+    }
+    async resolveImport(specifier, importer, kind) {
+        const evalOptions = getEvalOptions(this.services);
+        if (evalOptions.customResolver) {
+            const customResolved = await evalOptions.customResolver(specifier, importer.name, kind);
+            if (customResolved) {
+                return this.applyImportOverrides({
+                    source: specifier,
+                    resolved: customResolved.id,
+                    only: ['*'],
+                    external: customResolved.external,
+                }, importer);
+            }
+            if (evalOptions.resolver === 'custom') {
+                return null;
+            }
+        }
+        const resolveBundlerDependency = () => {
+            const dependency = getImporterDependency(importer, specifier);
+            if (dependency?.resolved) {
+                return {
+                    source: specifier,
+                    resolved: dependency.resolved,
+                    only: dependency.only,
+                };
+            }
+            return null;
+        };
+        if (evalOptions.resolver === 'hybrid') {
+            try {
+                return this.resolveWithNativeFallback(specifier, importer, kind, {
+                    warnOnFallback: false,
+                });
+            }
+            catch {
+                // Hybrid mode lets the bundler resolver handle aliases, virtual IDs,
+                // and other specifiers that the native resolver cannot resolve.
+            }
+        }
+        if (evalOptions.resolver === 'native') {
+            return this.resolveWithNativeFallback(specifier, importer, kind, {
+                warnOnFallback: false,
+            });
+        }
+        if (evalOptions.resolver === 'bundler' ||
+            evalOptions.resolver === 'hybrid') {
+            const dependency = resolveBundlerDependency();
+            if (dependency)
+                return dependency;
+        }
+        if (evalOptions.resolver === 'bundler' && evalOptions.require !== 'off') {
+            return this.resolveWithNativeFallback(specifier, importer, kind, {
+                warnOnFallback: true,
+            });
+        }
+        return null;
+    }
+    resolveRequire(specifier, importer) {
+        const dependency = getImporterDependency(importer, specifier);
+        if (dependency?.resolved) {
+            return this.applyImportOverrides({
+                source: specifier,
+                resolved: dependency.resolved,
+                only: dependency.only,
+            }, importer);
+        }
+        return this.resolveWithNativeFallback(specifier, importer, 'require', {
+            warnOnFallback: true,
+        });
+    }
+    applyImportOverrides(resolved, importer) {
+        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);
+        if (!override) {
+            return resolved;
+        }
+        let nextResolved = resolved.resolved;
+        if (override.mock) {
+            nextResolved = resolveMockSpecifier({
+                mock: override.mock,
+                importer: importer.name,
+                root,
+                stack: getStack(importer),
+            });
+        }
+        return {
+            ...resolved,
+            resolved: nextResolved,
+            only: applyImportOverrideToOnly(resolved.only, override),
+        };
+    }
+    async getModuleForResolved(resolved, importer) {
+        const cached = this.moduleCache.get(resolved.resolved);
+        if (cached)
+            return cached;
+        const evalOptions = getEvalOptions(this.services);
+        if (evalOptions.customLoader) {
+            const loaded = await evalOptions.customLoader(resolved.resolved);
+            if (loaded) {
+                if (loaded.loader === 'json') {
+                    const jsonValue = JSON.parse(loaded.code);
+                    return this.createSyntheticModule(resolved.resolved, {
+                        default: jsonValue,
+                    });
+                }
+                if (loaded.loader === 'raw' || loaded.loader === 'text') {
+                    return this.createSyntheticModule(resolved.resolved, {
+                        default: loaded.code,
+                    });
+                }
+                return this.createSourceTextModule(resolved.resolved, loaded.code, importer);
+            }
+        }
+        const loaded = this.loadByImportLoaders(resolved.source, resolved.resolved, importer.name);
+        if (loaded.handled) {
+            return this.createSyntheticModule(resolved.resolved, {
+                default: loaded.value,
+            });
+        }
+        const stripped = stripQueryAndHash(resolved.resolved);
+        if (stripped.endsWith('.json')) {
+            const jsonSource = fs.readFileSync(stripped, 'utf-8');
+            return this.createSyntheticModule(resolved.resolved, {
+                default: JSON.parse(jsonSource),
+            });
+        }
+        const entrypoint = this.getEntrypoint(resolved.resolved, resolved.only, importer.log);
+        if (!entrypoint) {
+            return this.createSyntheticModule(resolved.resolved, {
+                default: resolved.resolved,
+            });
+        }
+        if ('evaluated' in entrypoint && entrypoint.evaluated) {
+            return this.createSyntheticModule(entrypoint.name, entrypoint.exports);
+        }
+        return this.getModuleForEntrypoint(entrypoint);
+    }
     resolveWithConditions(id, parent, conditions) {
-        const resolveOptions = conditions ? { conditions } : undefined;
         const shouldRetryWithExtensions = conditions &&
-            path_1.default.extname(id) === '' &&
-            (id.startsWith('.') || path_1.default.isAbsolute(id) || isBarePackageSubpath(id));
+            path.extname(id) === '' &&
+            (id.startsWith('.') || path.isAbsolute(id) || isBarePackageSubpath(id));
         try {
-            return this.moduleImpl._resolveFilename(id, parent, false, resolveOptions);
+            return resolveFilenameWithConditions(this.moduleImpl, id, parent, conditions);
         }
-        catch (e) {
+        catch (error) {
             if (shouldRetryWithExtensions &&
-                e instanceof Error &&
-                e.code === 'MODULE_NOT_FOUND') {
-                // Extensionless subpath requests (e.g. "pkg/src/*" or "./src/*") may
-                // resolve to extensionless targets via conditional exports. Retry with
-                // each known extension, but never rewrite already explicit specifiers.
+                error instanceof Error &&
+                error.code === 'MODULE_NOT_FOUND') {
                 for (const ext of this.extensions) {
                     try {
-                        return this.moduleImpl._resolveFilename(id + ext, parent, false, resolveOptions);
+                        return resolveFilenameWithConditions(this.moduleImpl, `${id}${ext}`, parent, conditions);
                     }
                     catch {
-                        // try next extension
+                        // Try the next supported extension.
                     }
                 }
             }
-            throw e;
+            throw error;
         }
     }
-    resolveDependency = (id) => {
-        const cached = this.entrypoint.getDependency(id);
-        (0, ts_invariant_1.invariant)(!(cached instanceof Promise), 'Dependency is not resolved yet');
-        if (cached) {
-            return cached;
-        }
-        if (!this.ignored) {
-            this.debug('❌ import has not been resolved during prepare stage. Fallback to Node.js resolver');
+    resolveWithNativeFallback = (id, importer, kind, { warnOnFallback } = { warnOnFallback: true }) => {
+        if (!this.ignored && warnOnFallback) {
+            this.debug('❌ import has not been resolved during prepare stage. Fallback to native resolver');
         }
         const extensions = this.moduleImpl._extensions;
         const added = [];
         try {
-            // Check for supported extensions
-            this.extensions.forEach((ext) => {
-                if (ext in extensions) {
-                    return;
+            const filename = importer.name;
+            const strippedId = stripQueryAndHash(id);
+            const { conditionNames, oxcOptions } = this.services.options.pluginOptions;
+            let resolved;
+            try {
+                if (this.moduleImpl === DefaultModuleImplementation) {
+                    resolved = resolveWithNativeResolver({
+                        conditionNames,
+                        extensions: this.extensions,
+                        importer: filename,
+                        kind,
+                        oxcOptions,
+                        specifier: id,
+                    });
                 }
-                // When an extension is not supported, add it
-                // And keep track of it to clean it up after resolving
-                // Use noop for the transform function since we handle it
-                extensions[ext] = NOOP;
-                added.push(ext);
-            });
-            const { filename } = this;
-            const strippedId = (0, parseRequest_1.stripQueryAndHash)(id);
-            const parent = {
-                id: filename,
-                filename,
-                paths: this.moduleImpl._nodeModulePaths(path_1.default.dirname(filename)),
-            };
-            const { conditionNames } = this.services.options.pluginOptions;
-            const conditions = conditionNames?.length
-                ? expandConditions(conditionNames)
-                : undefined;
-            let resolved = this.resolveWithConditions(strippedId, parent, conditions);
-            const isFileSpecifier = strippedId.startsWith('.') || path_1.default.isAbsolute(strippedId);
-            if (isFileSpecifier &&
-                path_1.default.extname(strippedId) === '' &&
-                resolved.endsWith('.cjs') &&
-                fs_1.default.existsSync(`${resolved.slice(0, -4)}.js`)) {
-                // When both `.cjs` and `.js` exist for an extensionless specifier, the
-                // resolver may pick `.cjs` depending on the environment/extensions.
-                // Prefer `.js` to keep resolved paths stable (e.g. importOverrides keys).
-                resolved = `${resolved.slice(0, -4)}.js`;
+                else {
+                    // Preserve the test-only custom module implementation hook.
+                    this.extensions.forEach((ext) => {
+                        if (ext === '.cjs' || ext === '.mjs')
+                            return;
+                        if (ext in extensions)
+                            return;
+                        extensions[ext] = NOOP;
+                        added.push(ext);
+                    });
+                    const parent = {
+                        id: filename,
+                        filename,
+                        paths: this.moduleImpl._nodeModulePaths(path.dirname(filename)),
+                    };
+                    const conditions = conditionNames?.length
+                        ? expandConditions(conditionNames)
+                        : undefined;
+                    resolved = this.resolveWithConditions(strippedId, parent, conditions);
+                    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`;
+                    }
+                }
+            }
+            catch (error) {
+                throw new Error([
+                    `[wyw-in-js] Native resolver failed during eval.`,
+                    ``,
+                    `importer: ${filename}`,
+                    `source:   ${id}`,
+                    ``,
+                    `error: ${error instanceof Error ? error.message : String(error)}`,
+                ].join('\n'));
             }
             const { root } = this.services.options;
-            const keyInfo = (0, importOverrides_1.toImportKey)({
+            const keyInfo = toImportKey({
                 source: id,
                 resolved,
                 root,
             });
-            const override = (0, importOverrides_1.getImportOverride)(this.services.options.pluginOptions.importOverrides, keyInfo.key);
-            const policy = override?.unknown ?? (override?.mock ? 'allow' : 'warn');
+            const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
+            const evalOptions = getEvalOptions(this.services);
+            const basePolicy = evalOptions.require === 'warn-and-run' ? 'warn' : 'error';
+            let policy = warnOnFallback
+                ? override?.unknown ?? (override?.mock ? 'allow' : basePolicy)
+                : 'allow';
+            if (warnOnFallback &&
+                evalOptions.require === 'off' &&
+                policy !== 'error') {
+                policy = 'error';
+            }
             const shouldWarn = !this.ignored && policy === 'warn';
             let finalResolved = resolved;
             if (override?.mock) {
                 try {
-                    finalResolved = (0, importOverrides_1.resolveMockSpecifier)({
+                    finalResolved = resolveMockSpecifier({
                         mock: override.mock,
                         importer: filename,
                         root,
-                        stack: this.callstack,
+                        stack: getStack(importer),
                     });
                 }
                 catch (e) {
@@ -481,7 +829,7 @@ class Module {
             }
             if (policy === 'error') {
                 throw new Error([
-                    `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                    `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                     ``,
                     `importer: ${filename}`,
                     `source:   ${id}`,
@@ -491,9 +839,10 @@ class Module {
                         : ``,
                     ``,
                     `callstack:`,
-                    ...this.callstack.map((item) => `  ${item}`),
+                    ...getStack(importer).map((item) => `  ${item}`),
                     ``,
                     `config key: ${keyInfo.key}`,
+                    `docs: ${TROUBLESHOOTING_URL}`,
                 ]
                     .filter(Boolean)
                     .join('\n'));
@@ -501,8 +850,8 @@ class Module {
             const warnedUnknownImports = getWarnedUnknownImports(this.services);
             if (shouldWarn && !warnedUnknownImports.has(keyInfo.key)) {
                 warnedUnknownImports.add(keyInfo.key);
-                emitWarning(this.services, [
-                    `[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`,
+                const warningMessage = [
+                    `[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
                     ``,
                     `importer: ${filename}`,
                     `source:   ${id}`,
@@ -512,17 +861,27 @@ class Module {
                         : ``,
                     ``,
                     `callstack:`,
-                    ...this.callstack.map((item) => `  ${item}`),
+                    ...getStack(importer).map((item) => `  ${item}`),
                     ``,
                     `config key: ${keyInfo.key}`,
                     `hint: add { importOverrides: { ${JSON.stringify(keyInfo.key)}: { unknown: 'allow' } } } to silence warnings, or use { mock } / { noShake: true } overrides.`,
+                    `docs: ${TROUBLESHOOTING_URL}`,
                 ]
                     .filter(Boolean)
-                    .join('\n'));
+                    .join('\n');
+                emitEvalWarning(this.services, {
+                    code: kind === 'require' ? 'require-fallback' : 'resolve-fallback',
+                    message: warningMessage,
+                    importer: filename,
+                    specifier: id,
+                    resolved: resolved ?? null,
+                    callstack: getStack(importer),
+                    hint: `Use importOverrides or eval.require settings to avoid fallback.`,
+                });
             }
             return {
                 source: id,
-                only: (0, importOverrides_1.applyImportOverrideToOnly)(['*'], override),
+                only: applyImportOverrideToOnly(['*'], override),
                 resolved: finalResolved,
             };
         }
@@ -531,15 +890,78 @@ class Module {
             added.forEach((ext) => delete extensions[ext]);
         }
     };
+    requireWithFallback(id, importer, nonLiteral = false) {
+        const evalOptions = getEvalOptions(this.services);
+        if (nonLiteral || typeof id !== 'string') {
+            if (evalOptions.errors === 'strict') {
+                throw new Error(`[wyw-in-js] Non-literal require() is not supported during eval.\n` +
+                    `importer: ${importer.name}\n` +
+                    `hint: make it a string literal or mock the import via importOverrides.`);
+            }
+            emitEvalWarning(this.services, {
+                code: 'require-error',
+                message: '[wyw-in-js] Non-literal require() reached during eval (eval.errors: "loose").',
+                importer: importer.name,
+            });
+            return {};
+        }
+        const specifier = id;
+        if (id === REACT_REFRESH_VIRTUAL_ID) {
+            this.dependencies.push(id);
+            this.debug('require', `vite virtual '${id}'`);
+            return reactRefreshRuntime;
+        }
+        if (id.startsWith(VITE_VIRTUAL_PREFIX)) {
+            this.dependencies.push(id);
+            this.debug('require', `vite virtual '${id}'`);
+            return {};
+        }
+        const normalizedId = specifier.startsWith('node:')
+            ? specifier.slice(5)
+            : specifier;
+        if (NativeModule.builtinModules?.includes(normalizedId) ||
+            NativeModule.builtinModules?.includes(`node:${normalizedId}`)) {
+            if (normalizedId in builtins) {
+                if (builtins[normalizedId]) {
+                    this.debug('require', `builtin '${normalizedId}'`);
+                    return nodeRequire(normalizedId);
+                }
+                return null;
+            }
+            throw new Error(`Unable to import "${normalizedId}". Importing Node builtins is not supported in the sandbox.`);
+        }
+        const dependency = this.resolveRequire(specifier, importer);
+        const loaded = this.loadByImportLoaders(specifier, dependency.resolved, importer.name);
+        if (loaded.handled) {
+            this.dependencies.push(id);
+            this.debug('require', `${id} -> ${dependency.resolved} (loader)`);
+            return loaded.value;
+        }
+        const stripped = stripQueryAndHash(dependency.resolved);
+        const extension = path.extname(stripped);
+        if (extension &&
+            extension !== '.json' &&
+            !this.extensions.includes(extension)) {
+            this.dependencies.push(id);
+            this.debug('require', `${id} -> ${dependency.resolved} (asset)`);
+            return stripped;
+        }
+        if (this.services.cache.consumeInvalidation(dependency.resolved)) {
+            delete nodeRequire.cache[dependency.resolved];
+        }
+        this.dependencies.push(id);
+        this.debug('require', `${id} -> ${dependency.resolved}`);
+        return nodeRequire(dependency.resolved);
+    }
     createChild(entrypoint) {
         return new Module(this.services, entrypoint, this, this.moduleImpl);
     }
-    loadByImportLoaders(request, resolved) {
+    loadByImportLoaders(request, resolved, importer) {
         const { pluginOptions } = this.services.options;
         const importLoaders = pluginOptions.importLoaders === undefined
             ? defaultImportLoaders
             : { ...defaultImportLoaders, ...pluginOptions.importLoaders };
-        const { query, hash } = (0, parseRequest_1.parseRequest)(request);
+        const { query, hash } = parseRequest(request);
         if (!query)
             return { handled: false, value: undefined };
         const params = new URLSearchParams(query);
@@ -547,21 +969,21 @@ class Module {
         if (!matchedKey)
             return { handled: false, value: undefined };
         const loader = importLoaders[matchedKey];
-        const filename = (0, parseRequest_1.stripQueryAndHash)(resolved);
-        const importer = (0, parseRequest_1.stripQueryAndHash)(this.filename);
-        const importerDir = path_1.default.dirname(importer);
+        const filename = stripQueryAndHash(resolved);
+        const importerFilename = stripQueryAndHash(importer);
+        const importerDir = path.dirname(importerFilename);
         const toUrl = () => {
-            const relative = path_1.default
+            const relative = path
                 .relative(importerDir, filename)
-                .replace(/\\/g, path_1.default.posix.sep);
-            if (relative.startsWith('.') || path_1.default.isAbsolute(relative)) {
+                .replace(/\\/g, path.posix.sep);
+            if (relative.startsWith('.') || path.isAbsolute(relative)) {
                 return relative;
             }
             return `./${relative}`;
         };
-        const readFile = () => fs_1.default.readFileSync(filename, 'utf-8');
+        const readFile = () => fs.readFileSync(filename, 'utf-8');
         const context = {
-            importer,
+            importer: importerFilename,
             request,
             resolved,
             filename,
@@ -583,4 +1005,3 @@ class Module {
         return { handled: false, value: undefined };
     }
 }
-exports.Module = Module;