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

package/esm/module.js

@@ -1,539 +1,942 @@
 /**
- * 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`
- * - 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 source maps for it to provide correct error stacktraces.
- *
- */
-
-import fs from 'fs';
-import NativeModule from 'module';
-import path from 'path';
-import vm from 'vm';
-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 { parseRequest, stripQueryAndHash } from './utils/parseRequest';
-import { createVmContext } from './vm/createVmContext';
-const CJS_DEFAULT_CONDITIONS = ['require', 'node', 'default'];
-function expandConditions(conditionNames) {
-  const result = new Set();
-  for (const name of conditionNames) {
-    if (name === '...') {
-      for (const d of CJS_DEFAULT_CONDITIONS) result.add(d);
-    } else {
-      result.add(name);
-    }
-  }
-  return result;
-}
-function isBarePackageSubpath(id) {
-  if (id.startsWith('.') || path.isAbsolute(id)) {
-    return false;
-  }
-  if (id.startsWith('@')) {
-    return id.split('/').length > 2;
-  }
-  return id.includes('/');
-}
+* 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
+* - Allow us to invalidate the module cache without affecting other stuff, necessary for rebuilds
+*
+* We also store prepared evaluator code in it.
+* We also store source maps for it to provide correct error stacktraces.
+*
+*/
+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.js";
+import { Entrypoint } from "./transform/Entrypoint.js";
+import { getStack, isSuperSet, mergeOnly } from "./transform/Entrypoint.helpers.js";
+import { isUnprocessedEntrypointError } from "./transform/actions/UnprocessedEntrypointError.js";
+import { applyImportOverrideToOnly, getImportOverride, resolveMockSpecifier, toImportKey } from "./utils/importOverrides.js";
+import { resolveWithNativeResolver } from "./utils/nativeResolver.js";
+import { parseRequest, stripQueryAndHash } from "./utils/parseRequest.js";
+import { resolveFilenameWithConditions } from "./utils/resolveWithConditions.js";
+import { createVmContext } from "./vm/createVmContext.js";
+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 isBarePackageSubpath = (id) => {
+	if (id.startsWith(".") || path.isAbsolute(id)) {
+		return false;
+	}
+	if (id.startsWith("@")) {
+		return id.split("/").length > 2;
+	}
+	return id.includes("/");
+};
 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 = {
-  assert: true,
-  buffer: true,
-  child_process: false,
-  cluster: false,
-  console: true,
-  constants: true,
-  crypto: true,
-  dgram: false,
-  dns: false,
-  domain: true,
-  events: true,
-  fs: false,
-  http: true,
-  https: true,
-  module: false,
-  net: false,
-  os: true,
-  path: true,
-  punycode: true,
-  process: true,
-  querystring: true,
-  readline: false,
-  repl: false,
-  stream: true,
-  string_decoder: true,
-  sys: true,
-  timers: true,
-  tls: false,
-  tty: true,
-  url: true,
-  util: true,
-  vm: true,
-  zlib: true
-};
-const VITE_VIRTUAL_PREFIX = '/@';
-const REACT_REFRESH_VIRTUAL_ID = '/@react-refresh';
-const reactRefreshRuntime = {
-  createSignatureFunctionForTransform: () => () => {}
+	assert: true,
+	buffer: true,
+	child_process: false,
+	cluster: false,
+	console: true,
+	constants: true,
+	crypto: true,
+	dgram: false,
+	dns: false,
+	domain: true,
+	events: true,
+	fs: false,
+	http: true,
+	https: true,
+	module: false,
+	net: false,
+	os: true,
+	path: true,
+	punycode: true,
+	process: true,
+	querystring: true,
+	readline: false,
+	repl: false,
+	stream: true,
+	string_decoder: true,
+	sys: true,
+	timers: true,
+	tls: false,
+	tty: true,
+	url: true,
+	util: true,
+	vm: true,
+	zlib: true
 };
+const VITE_VIRTUAL_PREFIX = "/@";
+const REACT_REFRESH_VIRTUAL_ID = "/@react-refresh";
+const reactRefreshRuntime = { createSignatureFunctionForTransform: () => () => {} };
+const nodeRequire = createRequire(import.meta.url);
 const NOOP = () => {};
-const browserOnlyEvalHintTriggers = ['window is not defined', "evaluating 'window", 'document is not defined', "evaluating 'document", 'navigator is not defined', "evaluating 'navigator", 'self is not defined', "evaluating 'self"];
-const getBrowserOnlyEvalHint = error => {
-  const message = error instanceof Error ? error.message : String(error);
-  const looksLikeBrowserOnly = browserOnlyEvalHintTriggers.some(trigger => message.includes(trigger));
-  if (!looksLikeBrowserOnly) return null;
-  return ['', '[wyw-in-js] Evaluation hint:', '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' } }"].join('\n');
+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",
+	"document is not defined",
+	"evaluating 'document",
+	"navigator is not defined",
+	"evaluating 'navigator",
+	"self is not defined",
+	"evaluating 'self"
+];
+const getBrowserOnlyEvalHint = (error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	const looksLikeBrowserOnly = browserOnlyEvalHintTriggers.some((trigger) => message.includes(trigger));
+	if (!looksLikeBrowserOnly) return null;
+	return [
+		"",
+		"[wyw-in-js] Evaluation hint:",
+		"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);
-    return;
-  }
-
-  // eslint-disable-next-line no-console
-  console.warn(message);
+	if (services.emitWarning) {
+		services.emitWarning(message);
+		return;
+	}
+	// 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) {
-    return cached;
-  }
-  const created = new Set();
-  warnedUnknownImportsByServices.set(services, created);
-  return created;
+	const cached = warnedUnknownImportsByServices.get(services);
+	if (cached) {
+		return cached;
+	}
+	const created = new Set();
+	warnedUnknownImportsByServices.set(services, created);
+	return created;
 }
 function getUncached(cached, test) {
-  const cachedSet = new Set(typeof cached === 'string' ? cached.split(',') : cached);
-  if (cachedSet.has('*')) {
-    return [];
-  }
-  return test.filter(t => !cachedSet.has(t));
-}
-function resolve(id) {
-  const {
-    resolved
-  } = this.resolveDependency(id);
-  invariant(resolved, `Unable to resolve "${id}"`);
-  return resolved;
+	const cachedSet = new Set(typeof cached === "string" ? cached.split(",") : cached);
+	if (cachedSet.has("*")) {
+		return [];
+	}
+	return test.filter((t) => !cachedSet.has(t));
 }
 const defaultImportLoaders = {
-  raw: 'raw',
-  url: 'url'
+	raw: "raw",
+	url: "url"
+};
+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 {
-  callstack = [];
-  isEvaluated = false;
-  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.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.`);
-    }
-    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 || isSuperSet(entrypoint.evaluatedOnly, dependency.only)) {
-      return entrypoint.exports;
-    }
-    const m = this.createChild(entrypoint);
-    m.evaluate();
-    return entrypoint.exports;
-  }, {
-    ensure: NOOP,
-    resolve: resolve.bind(this)
-  });
-  resolve = resolve.bind(this);
-  #entrypointRef;
-  constructor(services, entrypoint, parentModule, moduleImpl = DefaultModuleImplementation) {
-    this.services = services;
-    this.moduleImpl = moduleImpl;
-    this.cache = services.cache;
-    this.#entrypointRef = isFeatureEnabled(services.options.pluginOptions.features, 'useWeakRefInEval', entrypoint.name) ? new WeakRef(entrypoint) : entrypoint;
-    this.idx = entrypoint.idx;
-    this.id = entrypoint.name;
-    this.filename = entrypoint.name;
-    this.dependencies = [];
-    this.debug = entrypoint.log.extend('module');
-    this.parentIsIgnored = parentModule?.ignored ?? false;
-    this.ignored = entrypoint.ignored ?? this.parentIsIgnored;
-    if (parentModule) {
-      this.callstack = [entrypoint.name, ...parentModule.callstack];
-    } else {
-      this.callstack = [entrypoint.name];
-    }
-    this.extensions = services.options.pluginOptions.extensions;
-    this.debug('init', entrypoint.name);
-  }
-  get exports() {
-    return this.entrypoint.exports;
-  }
-  set exports(value) {
-    this.entrypoint.exports = value;
-    this.debug('the whole exports was overridden with %O', value);
-  }
-  get entrypoint() {
-    const entrypoint = this.#entrypointRef instanceof WeakRef ? this.#entrypointRef.deref() : this.#entrypointRef;
-    invariant(entrypoint, `Module ${this.idx} is disposed`);
-    return entrypoint;
-  }
-  evaluate() {
-    const {
-      entrypoint
-    } = this;
-    entrypoint.assertTransformed();
-    const cached = this.cache.get('entrypoints', entrypoint.name);
-    let evaluatedCreated = false;
-    if (!entrypoint.supersededWith) {
-      this.cache.add('entrypoints', entrypoint.name, entrypoint.createEvaluated());
-      evaluatedCreated = true;
-    }
-    const {
-      transformedCode: source
-    } = entrypoint;
-    const {
-      pluginOptions
-    } = this.services.options;
-    if (!source) {
-      this.debug(`evaluate`, 'there is nothing to evaluate');
-      return;
-    }
-    if (this.isEvaluated) {
-      this.debug('evaluate', `is already evaluated`);
-      return;
-    }
-    this.debug('evaluate');
-    this.debug.extend('source')('%s', source);
-    this.isEvaluated = true;
-    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
-    } = createVmContext(filename, pluginOptions.features, {
-      module: this,
-      exports: entrypoint.exports,
-      require: this.require,
-      __wyw_dynamic_import: async id => this.require(String(id)),
-      __dirname: path.dirname(filename)
-    }, pluginOptions.overrideContext);
-    try {
-      const script = new vm.Script(`(function (exports) { ${source}\n})(exports);`, {
-        filename
-      });
-      script.runInContext(context);
-    } catch (e) {
-      this.isEvaluated = false;
-      if (evaluatedCreated) {
-        this.cache.add('entrypoints', entrypoint.name, cached);
-      }
-      if (isUnprocessedEntrypointError(e)) {
-        // It will be handled by evalFile scenario
-        throw e;
-      }
-      if (e instanceof EvalError) {
-        this.debug('%O', e);
-        throw e;
-      }
-      this.debug('%O\n%O', e, this.callstack);
-      const baseMessage = `${e.message} in${this.callstack.join('\n| ')}\n`;
-      const hint = getBrowserOnlyEvalHint(e);
-      throw new EvalError(hint ? `${baseMessage}${hint}\n` : baseMessage);
-    } finally {
-      teardown();
-    }
-  }
-  getEntrypoint(filename, only, log) {
-    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 && isSuperSet(entrypoint.evaluatedOnly ?? [], only)) {
-      if (this.cache.checkFreshness(filename, strippedFilename)) {
-        entrypoint = undefined;
-      }
-      if (entrypoint) {
-        log('✅ file has been already evaluated');
-        return entrypoint;
-      }
-    }
-    if (entrypoint?.ignored) {
-      log('✅ file has been ignored during prepare stage. Original code will be used');
-      return entrypoint;
-    }
-    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.readFileSync(strippedFilename, 'utf-8'));
-      if (newEntrypoint === 'loop') {
-        const stack = getStack(this.entrypoint);
-        throw new Error(`Circular dependency detected: ${stack.join(' -> ')} -> ${filename}`);
-      }
-      return newEntrypoint;
-    }
-    let uncachedExports = null;
-    let reprocessOnly = only;
-    // Requested file can be already prepared for evaluation on the stage 1
-    if (only && entrypoint) {
-      const evaluatedExports = entrypoint.evaluatedOnly?.length !== 0 ? entrypoint.evaluatedOnly : entrypoint.only ?? [];
-      uncachedExports = getUncached(evaluatedExports, only);
-      if (uncachedExports.length === 0) {
-        log('✅ ready for evaluation');
-        return entrypoint;
-      }
-      if (entrypoint.evaluatedOnly?.length) {
-        reprocessOnly = mergeOnly(evaluatedExports, only);
-      }
-      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.readFileSync(strippedFilename, 'utf-8');
-    const newEntrypoint = Entrypoint.createRoot(this.services, filename, reprocessOnly, code);
-    if (newEntrypoint.evaluated) {
-      log('✅ file has been already evaluated');
-      return newEntrypoint;
-    }
-    if (newEntrypoint.ignored) {
-      log('✅ file has been ignored during prepare stage. Original code will be used');
-      return newEntrypoint;
-    }
-    return newEntrypoint;
-  }
-  resolveWithConditions(id, parent, conditions) {
-    const resolveOptions = conditions ? {
-      conditions
-    } : undefined;
-    const shouldRetryWithExtensions = conditions && path.extname(id) === '' && (id.startsWith('.') || path.isAbsolute(id) || isBarePackageSubpath(id));
-    try {
-      return this.moduleImpl._resolveFilename(id, parent, false, resolveOptions);
-    } catch (e) {
-      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.
-        for (const ext of this.extensions) {
-          try {
-            return this.moduleImpl._resolveFilename(id + ext, parent, false, resolveOptions);
-          } catch {
-            // try next extension
-          }
-        }
-      }
-      throw e;
-    }
-  }
-  resolveDependency = id => {
-    const cached = this.entrypoint.getDependency(id);
-    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');
-    }
-    const extensions = this.moduleImpl._extensions;
-    const added = [];
-    try {
-      // Check for supported extensions
-      this.extensions.forEach(ext => {
-        if (ext in extensions) {
-          return;
-        }
-
-        // 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 = stripQueryAndHash(id);
-      const parent = {
-        id: filename,
-        filename,
-        paths: this.moduleImpl._nodeModulePaths(path.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.isAbsolute(strippedId);
-      if (isFileSpecifier && path.extname(strippedId) === '' && resolved.endsWith('.cjs') && fs.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`;
-      }
-      const {
-        root
-      } = this.services.options;
-      const keyInfo = toImportKey({
-        source: id,
-        resolved,
-        root
-      });
-      const override = getImportOverride(this.services.options.pluginOptions.importOverrides, keyInfo.key);
-      const policy = override?.unknown ?? (override?.mock ? 'allow' : 'warn');
-      const shouldWarn = !this.ignored && policy === 'warn';
-      let finalResolved = resolved;
-      if (override?.mock) {
-        try {
-          finalResolved = resolveMockSpecifier({
-            mock: override.mock,
-            importer: filename,
-            root,
-            stack: this.callstack
-          });
-        } catch (e) {
-          const errorMessage = String(e?.message ?? e);
-          throw new Error(`[wyw-in-js] Failed to resolve import mock for "${keyInfo.key}" (${id} from ${filename}): ${errorMessage}`);
-        }
-      }
-      if (policy === 'error') {
-        throw new Error([`[wyw-in-js] Unknown import reached during eval (Node resolver fallback)`, ``, `importer: ${filename}`, `source:   ${id}`, `resolved: ${resolved}`, override?.mock ? `mock:     ${override.mock} -> ${finalResolved}` : ``, ``, `callstack:`, ...this.callstack.map(item => `  ${item}`), ``, `config key: ${keyInfo.key}`].filter(Boolean).join('\n'));
-      }
-      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)`, ``, `importer: ${filename}`, `source:   ${id}`, `resolved: ${resolved}`, override?.mock ? `mock:     ${override.mock} -> ${finalResolved}` : ``, ``, `callstack:`, ...this.callstack.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.`].filter(Boolean).join('\n'));
-      }
-      return {
-        source: id,
-        only: applyImportOverrideToOnly(['*'], override),
-        resolved: finalResolved
-      };
-    } finally {
-      // Cleanup the extensions we added to restore previous behaviour
-      added.forEach(ext => delete extensions[ext]);
-    }
-  };
-  createChild(entrypoint) {
-    return new Module(this.services, entrypoint, this, this.moduleImpl);
-  }
-  loadByImportLoaders(request, resolved) {
-    const {
-      pluginOptions
-    } = this.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 importer = stripQueryAndHash(this.filename);
-    const importerDir = path.dirname(importer);
-    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,
-      request,
-      resolved,
-      filename,
-      query,
-      hash,
-      emitWarning: message => emitWarning(this.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
-    };
-  }
+	callstack = [];
+	debug;
+	dependencies;
+	extensions;
+	filename;
+	id;
+	idx;
+	ignored;
+	isEvaluated = false;
+	parentIsIgnored;
+	require = Object.assign((id, nonLiteral) => this.requireWithFallback(id, this.entrypoint, nonLiteral), {
+		ensure: NOOP,
+		resolve: (id) => this.resolveRequire(id, this.entrypoint).resolved
+	});
+	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 = DefaultModuleImplementation) {
+		this.services = services;
+		this.moduleImpl = moduleImpl;
+		this.cache = services.cache;
+		this.#entrypointRef = isFeatureEnabled(services.options.pluginOptions.features, "useWeakRefInEval", entrypoint.name) ? new WeakRef(entrypoint) : entrypoint;
+		this.idx = entrypoint.idx;
+		this.id = entrypoint.name;
+		this.filename = entrypoint.name;
+		this.dependencies = [];
+		this.debug = entrypoint.log.extend("module");
+		this.parentIsIgnored = parentModule?.ignored ?? false;
+		this.ignored = entrypoint.ignored ?? this.parentIsIgnored;
+		if (parentModule) {
+			this.callstack = [entrypoint.name, ...parentModule.callstack];
+		} else {
+			this.callstack = [entrypoint.name];
+		}
+		this.extensions = services.options.pluginOptions.extensions;
+		this.debug("init", entrypoint.name);
+	}
+	get exports() {
+		return this.entrypoint.exports;
+	}
+	set exports(value) {
+		this.entrypoint.exports = value;
+		this.debug("the whole exports was overridden with %O", value);
+	}
+	get entrypoint() {
+		const entrypoint = this.#entrypointRef instanceof WeakRef ? this.#entrypointRef.deref() : this.#entrypointRef;
+		invariant(entrypoint, `Module ${this.idx} is disposed`);
+		return entrypoint;
+	}
+	async evaluate() {
+		const { entrypoint } = this;
+		entrypoint.assertTransformed();
+		const cached = this.cache.get("entrypoints", entrypoint.name);
+		let evaluatedCreated = false;
+		if (!entrypoint.supersededWith) {
+			this.cache.add("entrypoints", entrypoint.name, entrypoint.createEvaluated());
+			evaluatedCreated = true;
+		}
+		const { transformedCode: source } = entrypoint;
+		if (!source) {
+			this.debug(`evaluate`, "there is nothing to evaluate");
+			return;
+		}
+		if (this.isEvaluated) {
+			this.debug("evaluate", `is already evaluated`);
+			return;
+		}
+		this.debug("evaluate");
+		this.debug.extend("source")("%s", source);
+		this.isEvaluated = true;
+		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 { teardown } = await this.ensureContext(filename);
+		try {
+			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 (isUnprocessedEntrypointError(e)) {
+				// It will be handled by evalFile scenario
+				throw e;
+			}
+			if (e instanceof EvalError) {
+				this.debug("%O", e);
+				throw e;
+			}
+			this.debug("%O\n%O", e, this.callstack);
+			const baseMessage = `${e.message} in${this.callstack.join("\n| ")}\n`;
+			const hint = getBrowserOnlyEvalHint(e);
+			throw new EvalError(hint ? `${baseMessage}${hint}\n` : baseMessage);
+		} finally {
+			teardown();
+		}
+	}
+	getEntrypoint(filename, only, log) {
+		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 && isSuperSet(entrypoint.evaluatedOnly ?? [], only)) {
+			if (this.cache.checkFreshness(filename, strippedFilename)) {
+				entrypoint = undefined;
+			}
+			if (entrypoint) {
+				log("✅ file has been already evaluated");
+				return entrypoint;
+			}
+		}
+		if (entrypoint?.ignored) {
+			log("✅ file has been ignored during prepare stage. Original code will be used");
+			return entrypoint;
+		}
+		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.readFileSync(strippedFilename, "utf-8"));
+			if (newEntrypoint === "loop") {
+				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 ? entrypoint.evaluatedOnly : entrypoint.only ?? [];
+			uncachedExports = getUncached(evaluatedExports, only);
+			if (uncachedExports.length === 0) {
+				log("✅ ready for evaluation");
+				return entrypoint;
+			}
+			if (entrypoint.evaluatedOnly?.length) {
+				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");
+			}
+		} 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 = 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;
+		}
+		if (newEntrypoint.ignored) {
+			log("✅ file has been ignored during prepare stage. Original code will be used");
+			return newEntrypoint;
+		}
+		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 {}
+		}
+		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 shouldRetryWithExtensions = conditions && path.extname(id) === "" && (id.startsWith(".") || path.isAbsolute(id) || isBarePackageSubpath(id));
+		try {
+			return resolveFilenameWithConditions(this.moduleImpl, id, parent, conditions);
+		} catch (error) {
+			if (shouldRetryWithExtensions && error instanceof Error && error.code === "MODULE_NOT_FOUND") {
+				for (const ext of this.extensions) {
+					try {
+						return resolveFilenameWithConditions(this.moduleImpl, `${id}${ext}`, parent, conditions);
+					} catch {}
+				}
+			}
+			throw error;
+		}
+	}
+	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 {
+			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
+					});
+				} 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 = toImportKey({
+				source: id,
+				resolved,
+				root
+			});
+			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 = resolveMockSpecifier({
+						mock: override.mock,
+						importer: filename,
+						root,
+						stack: getStack(importer)
+					});
+				} catch (e) {
+					const errorMessage = String(e?.message ?? e);
+					throw new Error(`[wyw-in-js] Failed to resolve import mock for "${keyInfo.key}" (${id} from ${filename}): ${errorMessage}`);
+				}
+			}
+			if (policy === "error") {
+				throw new Error([
+					`[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
+					``,
+					`importer: ${filename}`,
+					`source:   ${id}`,
+					`resolved: ${resolved}`,
+					override?.mock ? `mock:     ${override.mock} -> ${finalResolved}` : ``,
+					``,
+					`callstack:`,
+					...getStack(importer).map((item) => `  ${item}`),
+					``,
+					`config key: ${keyInfo.key}`,
+					`docs: ${TROUBLESHOOTING_URL}`
+				].filter(Boolean).join("\n"));
+			}
+			const warnedUnknownImports = getWarnedUnknownImports(this.services);
+			if (shouldWarn && !warnedUnknownImports.has(keyInfo.key)) {
+				warnedUnknownImports.add(keyInfo.key);
+				const warningMessage = [
+					`[wyw-in-js] Unknown import reached during eval (native resolver fallback)`,
+					``,
+					`importer: ${filename}`,
+					`source:   ${id}`,
+					`resolved: ${resolved}`,
+					override?.mock ? `mock:     ${override.mock} -> ${finalResolved}` : ``,
+					``,
+					`callstack:`,
+					...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");
+				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: applyImportOverrideToOnly(["*"], override),
+				resolved: finalResolved
+			};
+		} finally {
+			// Cleanup the extensions we added to restore previous behaviour
+			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, importer) {
+		const { pluginOptions } = this.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(this.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
+		};
+	}
 }
-//# sourceMappingURL=module.js.map
+//# sourceMappingURL=module.js.map