vitest 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/chunks/{index.D6NDM5O1.js → index.CLtI1k_4.js}

@@ -1,22 +1,17 @@
-import { T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, a as getCurrentSuite, b as createChainable, d as getHooks, e as getFn, m as matchesTags, f as afterAll, h as afterEach, i as aroundAll, j as aroundEach, k as beforeAll, l as beforeEach, n as describe, o as it, q as onTestFailed, r as onTestFinished, t as recordArtifact, u as suite, v as test } from './artifact.BNnEI1sJ.js';
+import { b as printDiffOrStringify, d as diff, a as processError, T as TestSyntaxError, g as getCurrentTest, c as createTaskCollector, e as getCurrentSuite, f as createChainable, h as getHooks, i as getFn, m as matchesTags, j as afterAll, k as afterEach, l as aroundAll, n as aroundEach, o as beforeAll, q as beforeEach, r as describe, t as it, u as onTestFailed, v as onTestFinished, w as recordArtifact, x as suite, y as test } from './artifact.DC5WoEgy.js';
 import { i as isChildProcess, r as resetModules, g as getWorkerState } from './utils.DYj33du9.js';
-import { getSafeTimers, delay } from '@vitest/utils/timers';
-import { isMockFunction, fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks } from '@vitest/spy';
-import { getType, isObject, noop, assertTypes, ordinal, createSimpleStackTrace, getCallLastIndex } from '@vitest/utils/helpers';
-import { positionToOffset, offsetToLineNumber, lineSplitRE } from '@vitest/utils/offset';
-import { parseSingleStack, parseErrorStacktrace } from '@vitest/utils/source-map';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
-import { R as RealDate, b as resetDate, m as mockDate, r as rpc, V as VitestEvaluatedModules } from './rpc.DZEh5xnQ.js';
-import { stringify, inspect } from '@vitest/utils/display';
-import { printDiffOrStringify, diff } from '@vitest/utils/diff';
-import c from 'tinyrainbow';
+import { h as commonjsGlobal, a as getSafeTimers, f as parseSingleStack, i as delay, d as getDefaultExportFromCjs, j as parseErrorStacktrace } from './source-map.DZdIqpIJ.js';
+import { i as isMockFunction, f as fn, a as spyOn, r as restoreAllMocks, b as resetAllMocks, c as clearAllMocks } from './spy.B8mHA9qu.js';
+import { g as getType, v as isObject, p as noop, y as assertTypes, x as ordinal, D as createSimpleStackTrace, E as getCallLastIndex, i as isAbsolute, a as relative, n as normalize } from './pathe.M-eThtNZ.CbK_Vbae.js';
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc, V as VitestEvaluatedModules } from './rpc.iNjF664v.js';
+import { s as stringify, i as inspect } from './display.CYwyMF4S.js';
+import { y } from './tinyrainbow.Ht9iggcq.js';
 import * as chai from 'chai';
 import { use, util } from 'chai';
-import { processError } from '@vitest/utils/error';
 import { getNames, getTests, getTestName, createFileTask } from '../task-utils.js';
-import { g as getSerializers, a as addSerializer } from './plugins.DrsmdUE2.js';
-import { format } from '@vitest/pretty-format';
-import { isAbsolute, relative, normalize } from 'pathe';
+import { g as getSerializers, a as addSerializer } from './plugins.CsoX-42X.js';
+import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE } from './offset.Dy-5Fdfn.js';
+import { f as format } from './index.DzTmMrSM.js';
 import { Bench } from 'tinybench';
 import { expectTypeOf } from 'expect-type';
 
@@ -119,11 +114,11 @@ ${printReceived(actual)}`
 	}
 };
 
-const EXPECTED_COLOR = c.green;
-const RECEIVED_COLOR = c.red;
-const INVERTED_COLOR = c.inverse;
-const BOLD_WEIGHT = c.bold;
-const DIM_COLOR = c.dim;
+const EXPECTED_COLOR = y.green;
+const RECEIVED_COLOR = y.red;
+const INVERTED_COLOR = y.inverse;
+const BOLD_WEIGHT = y.bold;
+const DIM_COLOR = y.dim;
 function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
 	const { comment = "", isDirectExpectCall = false, isNot = false, promise = "", secondArgument = "", expectedColor = EXPECTED_COLOR, receivedColor = RECEIVED_COLOR, secondArgumentColor = EXPECTED_COLOR } = options;
 	let hint = "";
@@ -1449,25 +1444,25 @@ const JestChaiExpect = (chai, utils) => {
 	});
 };
 function formatCalls(spy, msg, showActualCall) {
-	if (spy.mock.calls.length) msg += c.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
-		let methodCall = c.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call:\n\n`);
+	if (spy.mock.calls.length) msg += y.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call:\n\n`);
 		if (showActualCall) methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
 		else methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
 		methodCall += "\n";
 		return methodCall;
 	}).join("\n")}`);
-	msg += c.gray(`\n\nNumber of calls: ${c.bold(spy.mock.calls.length)}\n`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
 	return msg;
 }
 function formatReturns(spy, results, msg, showActualReturn) {
-	if (results.length) msg += c.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
-		let methodCall = c.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call return:\n\n`);
+	if (results.length) msg += y.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call return:\n\n`);
 		if (showActualReturn) methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
 		else methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
 		methodCall += "\n";
 		return methodCall;
 	}).join("\n")}`);
-	msg += c.gray(`\n\nNumber of calls: ${c.bold(spy.mock.calls.length)}\n`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
 	return msg;
 }
 
@@ -6346,8 +6341,8 @@ function createVitest() {
 		stubEnv(name, value) {
 			const env = state().metaEnv;
 			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
-			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
-			else if (value === void 0) delete env[name];
+			if (value === void 0) delete env[name];
+			else if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
 			else env[name] = String(value);
 			return utils;
 		},
@@ -7942,30 +7937,74 @@ function inject(key) {
 }
 
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+/**
+* The built-in benchmark provider, backed by tinybench. Selected when
+* `benchmark.provider` is not configured.
+*/
+function createDefaultBenchmarkProvider(config) {
+	let benchIdx = 0;
+	return { async run({ test, options, registrations }) {
+		const currentIndex = ++benchIdx;
+		const tinybench = new Bench({
+			signal: test.context.signal,
+			name: `${test.fullTestName} ${currentIndex}`,
+			retainSamples: config.benchmark.retainSamples,
+			...options,
+			now
+		});
+		for (const { name, fn, fnOpts } of registrations) tinybench.add(name, fn, fnOpts);
+		await tinybench.run();
+		const errors = tinybench.tasks.filter((task) => task.result.state === "errored").map((task) => task.result.error);
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Some benchmarks failed");
+		return tinybench.tasks.map(toBenchResult);
+	} };
+}
+function toBenchResult(task) {
+	const result = task.result;
+	if (result.state !== "completed") throw new Error(`task "${task.name}" did not complete: received "${result.state}"`);
+	return {
+		...result,
+		name: task.name
+	};
+}
+
 const kRegistration = Symbol("registration");
 const kFromSource = Symbol("fromSource");
 const kPerProject = Symbol("perProject");
 const kWriteResult = Symbol("writeResult");
 const kFinalize = Symbol("finalize");
+let cachedProvider;
+async function loadProviderModule(provider, moduleRunner) {
+	let mod;
+	try {
+		mod = await moduleRunner.import(provider);
+	} catch (error) {
+		throw new Error(`Failed to load benchmark provider from "${provider}".`, { cause: error });
+	}
+	if (mod.default == null) throw new Error(`Benchmark provider loaded from "${provider}" did not have a default export.`);
+	return mod.default;
+}
+/**
+* Resolves the benchmark provider for the current worker, importing a custom
+* provider module on first use. The result is cached for the lifetime of the
+* worker so a custom provider is imported at most once.
+*/
+function resolveBenchmarkProvider(config, moduleRunner) {
+	if (!cachedProvider) {
+		const provider = config.benchmark.provider;
+		cachedProvider = !provider ? Promise.resolve(createDefaultBenchmarkProvider(config)) : loadProviderModule(provider, moduleRunner);
+	}
+	return cachedProvider;
+}
 function isFromRegistration(reg) {
 	return kFromSource in reg;
 }
 function substitutePath(template, projectName) {
 	return template.replace(/\$\{projectName\}/g, projectName ?? "");
 }
-function createBench(test, config) {
-	let benchIdx = 0;
+function createBench(test, config, moduleRunner) {
 	const pending = /* @__PURE__ */ new Set();
-	const createTinybench = (options) => {
-		const currentIndex = ++benchIdx;
-		return new Bench({
-			signal: test.context.signal,
-			name: `${test.fullTestName} ${currentIndex}`,
-			retainSamples: config.benchmark.retainSamples,
-			...options,
-			now
-		});
-	};
 	const resolveTemplate = (template) => substitutePath(template, config.benchmark.projectName);
 	const resolveFromSource = async (source) => {
 		if (typeof source === "function") return source();
@@ -7983,42 +8022,37 @@ function createBench(test, config) {
 		rank: 0,
 		fromStore: true
 	});
-	const createCompareStorage = (bench, fromResults) => {
+	const createCompareStorage = (results, fromResults) => {
 		return { get(name) {
 			const stored = fromResults?.get(name);
 			if (stored) return stored;
-			const task = bench.getTask(name);
-			if (!task) throw new Error(`task "${name}" was not defined`);
-			return task.result;
+			const result = results.get(name);
+			if (!result) throw new Error(`task "${name}" was not defined`);
+			return result;
 		} };
 	};
-	const serializeBenchmark = (tinybenchTasks, name, taskMeta, fromTasks) => {
-		const tasks = tinybenchTasks.map((t) => {
-			const result = t.result;
-			if (result.state === "errored") throw result.error;
-			if (result.state !== "completed") throw new Error(`task "${t.name}" did not complete: received "${result.state}"`);
-			return {
-				name: t.name,
-				latency: result.latency,
-				throughput: result.throughput,
-				period: result.period,
-				totalTime: result.totalTime,
-				rank: 0,
-				...taskMeta?.get(t.name)
-			};
-		});
+	const serializeBenchmark = (results, name, taskMeta, fromTasks) => {
+		const tasks = results.map((result) => ({
+			name: result.name,
+			latency: result.latency,
+			throughput: result.throughput,
+			period: result.period,
+			totalTime: result.totalTime,
+			rank: 0,
+			...taskMeta?.get(result.name)
+		}));
 		if (fromTasks) tasks.push(...fromTasks);
 		tasks.sort((a, b) => a.latency.mean - b.latency.mean);
 		tasks.forEach((task, idx) => {
 			task.rank = idx + 1;
 		});
 		return {
-			name: name || test.fullTestName,
+			name,
 			tasks
 		};
 	};
-	const recordBenchmark = async (tinybenchTasks, name, taskMeta, fromTasks) => {
-		const serializedBenchmark = serializeBenchmark(tinybenchTasks, name, taskMeta, fromTasks);
+	const recordBenchmark = async (results, name, taskMeta, fromTasks) => {
+		const serializedBenchmark = serializeBenchmark(results, name, taskMeta, fromTasks);
 		test.benchmarks.push(serializedBenchmark);
 		await rpc().onTestBenchmark(test.id, serializedBenchmark);
 	};
@@ -8032,19 +8066,28 @@ function createBench(test, config) {
 		};
 		await rpc().writeBenchmarkResult(resolved, data);
 	};
-	const runBenchmarks = async (tinybench) => {
+	const groupName = (options) => options?.name ?? test.fullTestName;
+	const runGroup = async (registrations, options) => {
 		const workerState = getWorkerState();
 		const getterTracker = workerState.getterTracker;
 		getterTracker?.resetInvocations();
 		try {
-			return await TestRunner.runBenchmarks(tinybench);
+			const results = await (await resolveBenchmarkProvider(config, moduleRunner)).run({
+				test,
+				config: config.benchmark,
+				registrations,
+				options
+			});
+			const byName = /* @__PURE__ */ new Map();
+			for (const result of results) byName.set(result.name, result);
+			return byName;
 		} finally {
 			const excessiveInvocations = config.benchmark.suppressExportGetterWarnings ? void 0 : getterTracker?.getExcessiveInvocations();
 			if (excessiveInvocations?.length) {
 				const entries = excessiveInvocations.map(({ moduleId, exportName }) => `  - ${formatModuleId(moduleId, workerState.config.root)} > ${exportName}`).join("\n");
 				console.warn([
-					c.yellow(c.bold("Benchmark Warning")),
-					`Benchmark ${c.bold(`"${tinybench.name}"`)} accessed module export getters too many times.`,
+					y.yellow(y.bold("Benchmark Warning")),
+					`Benchmark ${y.bold(`"${groupName(options)}"`)} accessed module export getters too many times.`,
 					"",
 					"This can make results unreliable because export getters add overhead.",
 					"See https://vitest.dev/guide/benchmarking#module-runner-overhead",
@@ -8056,13 +8099,15 @@ function createBench(test, config) {
 		}
 	};
 	const runSingle = async (name, fn, fnOpts, options, meta, writeResult) => {
-		const tinybench = createTinybench(options).add(name, fn, fnOpts);
-		const tasks = await runBenchmarks(tinybench);
-		const task = tinybench.getTask(name);
-		if (task.result.state === "errored") throw task.result.error;
-		await recordBenchmark(tasks, tinybench.name, meta ? new Map([[name, meta]]) : void 0);
-		if (writeResult) await writeResultArtifact(writeResult, task.result);
-		return task.result;
+		const result = (await runGroup([{
+			name,
+			fn,
+			fnOpts
+		}], options)).get(name);
+		if (!result) throw new Error(`benchmark provider did not return a result for "${name}"`);
+		await recordBenchmark([result], groupName(options), meta ? new Map([[name, meta]]) : void 0);
+		if (writeResult) await writeResultArtifact(writeResult, result);
+		return result;
 	};
 	const runFrom = async (name, source) => {
 		const data = await resolveFromSource(source);
@@ -8116,7 +8161,7 @@ function createBench(test, config) {
 	};
 	bench.compare = async (...args) => {
 		validateBenchmarkProject(config);
-		// extract optional trailing BenchCompareOptions argument
+		// extract optional trailing BenchRunOptions argument
 		const lastArg = args.at(-1);
 		const benchOptions = lastArg != null && typeof lastArg === "object" && !(kRegistration in lastArg) ? args.pop() : void 0;
 		const registrations = args;
@@ -8146,33 +8191,29 @@ function createBench(test, config) {
 				fromTasks.push(taskFromBaseline(reg.name, data));
 			}
 		}
-		const tinybench = createTinybench(benchOptions);
-		runnable.forEach((reg) => {
-			tinybench.add(reg.name, reg.fn, reg.fnOpts);
-		});
-		let tasks = [];
-		if (runnable.length > 0) {
-			tasks = await runBenchmarks(tinybench);
-			const errors = tinybench.tasks.filter((task) => task.result.state === "errored").map((task) => task.result.error);
-			if (errors.length > 0) throw new AggregateError(errors, "Some benchmarks failed");
-		}
-		await recordBenchmark(tasks, tinybench.name, taskMeta, fromTasks);
+		let results = /* @__PURE__ */ new Map();
+		if (runnable.length > 0) results = await runGroup(runnable.map((reg) => ({
+			name: reg.name,
+			fn: reg.fn,
+			fnOpts: reg.fnOpts
+		})), benchOptions);
+		await recordBenchmark(Array.from(results.values()), groupName(benchOptions), taskMeta, fromTasks);
 		// write artifacts for every runnable registration that requested it. We
 		// do this after recording so a write failure can't be confused with a
 		// benchmark failure in the reporter output.
 		await Promise.all(runnable.filter((reg) => reg[kWriteResult] != null).map((reg) => {
-			const task = tinybench.getTask(reg.name);
-			return writeResultArtifact(reg[kWriteResult], task.result);
+			const result = results.get(reg.name);
+			return writeResultArtifact(reg[kWriteResult], result);
 		}));
-		return createCompareStorage(tinybench, fromResults);
+		return createCompareStorage(results, fromResults);
 	};
 	bench[kFinalize] = () => {
 		if (pending.size === 0) return;
 		const names = Array.from(pending, (reg) => `"${reg.name}"`).join(", ");
 		pending.clear();
 		console.warn([
-			c.yellow(c.bold("Benchmark Warning")),
-			`Test ${c.bold(`"${test.fullTestName}"`)} registered benchmarks that never ran: ${names}.`,
+			y.yellow(y.bold("Benchmark Warning")),
+			`Test ${y.bold(`"${test.fullTestName}"`)} registered benchmarks that never ran: ${names}.`,
 			"",
 			"Call `.run()` on the registration, or pass it to `bench.compare()`.",
 			"See https://vitest.dev/guide/benchmarking#defining-a-benchmark"
@@ -8197,8 +8238,8 @@ function normalizeBenchArgs(a, b) {
 	if (typeof b !== "function") throw new TypeError("`bench()` expects a benchmark function. Call `bench(name, fn)` or `bench(name, options, fn)`.");
 	// Strip vitest-specific fields only when present so we don't allocate a new
 	// object — preserving referential identity matters: users inspect
-	// `registration.fnOpts` and tinybench's `add` sees the same object the
-	// caller passed in.
+	// `registration.fnOpts` and the provider sees the same object the caller
+	// passed in.
 	if (a.writeResult === void 0 && a.perProject === void 0) return {
 		fn: b,
 		fnOpts: a,
@@ -8334,9 +8375,10 @@ class TestRunner {
 		let _bench;
 		const runnerConfig = this.config;
 		const benchInstances = this.benchInstances;
+		const moduleRunner = this.moduleRunner;
 		Object.defineProperty(context, "bench", { get() {
 			if (!_bench) {
-				_bench = createBench(context.task, runnerConfig);
+				_bench = createBench(context.task, runnerConfig, moduleRunner);
 				benchInstances.set(context.task, _bench);
 			}
 			return _bench;
@@ -8375,14 +8417,6 @@ class TestRunner {
 	static setTestFn = getFn;
 	static matchesTags = matchesTags;
 	static createFileTask = createFileTask;
-	/**
-	* @experimental
-	* A function that runs tinybench tasks.
-	* Can be overriden to run tasks in a special environment.
-	*/
-	static async runBenchmarks(tinybench) {
-		return await tinybench.run();
-	}
 }
 function clearModuleMocks(config) {
 	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;

package/dist/chunks/{index.DNRmy2jU.js → index.DxR-nMjO.js}

@@ -1,9 +1,8 @@
 import fs__default from 'node:fs';
-import { splitFileAndPostfix as splitFileAndPostfix$1, isBareImport } from '@vitest/utils/helpers';
+import { n as normalize, k as splitFileAndPostfix$1, j as join, l as isBareImport } from './pathe.M-eThtNZ.CbK_Vbae.js';
 import { i as isBuiltin, a as isBrowserExternal, t as toBuiltin } from './modules.BJuCwlRJ.js';
 import { E as EnvironmentTeardownError, a as getSafeWorkerState } from './utils.DYj33du9.js';
 import { pathToFileURL, URL as URL$1 } from 'node:url';
-import { normalize, join } from 'pathe';
 import { distDir } from '../path.js';
 import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
 import { isAbsolute, resolve } from 'node:path';
@@ -460,12 +459,12 @@ const createNodeImportMeta = (modulePath) => {
 	if (!viteModuleRunner.createDefaultImportMeta) throw new Error(`createNodeImportMeta is not supported in this version of Vite.`);
 	const defaultMeta = viteModuleRunner.createDefaultImportMeta(modulePath);
 	const href = defaultMeta.url;
-	const importMetaResolver = createImportMetaResolver();
+	const importMetaResolver = createImportMetaResolver() ?? defaultMeta.resolve;
 	return {
 		...defaultMeta,
 		main: false,
 		resolve(id, parent) {
-			return (importMetaResolver ?? defaultMeta.resolve)(id, parent ?? href);
+			return importMetaResolver(id, parent ?? href);
 		}
 	};
 };
@@ -648,8 +647,27 @@ function startVitestModuleRunner(options) {
 		context: options.context,
 		externalModulesExecutor: options.externalModulesExecutor
 	} : void 0;
+	// A fresh worker pays one strictly sequential `fetch` round-trip per module
+	// in its test files' import graphs, even when the server processed all of
+	// them already. Ask the server ONCE per run request for everything it has on
+	// disk and answer those fetches locally. A file change invalidates the module
+	// server-side, dropping it from the snapshot of every subsequent run request,
+	// which keeps reused (isolate: false) workers in sync; an edit DURING a run
+	// was racy before this fast path existed and stays racy with it — the
+	// scheduled rerun always sees the fresh transform.
+	let warmModules;
+	let warmModulesContext;
+	function fetchWarmModules() {
+		const workerState = state();
+		if (warmModulesContext !== workerState.ctx) {
+			warmModulesContext = workerState.ctx;
+			warmModules = rpc().fetchWarmModules(environment(), workerState.ctx.files.map((file) => file.filepath)).catch(() => null);
+		}
+		return warmModules;
+	}
 	const evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
 		traces,
+		metaEnv: state().metaEnv,
 		evaluatedModules: options.evaluatedModules,
 		get moduleExecutionInfo() {
 			return state().moduleExecutionInfo;
@@ -657,6 +675,9 @@ function startVitestModuleRunner(options) {
 		get interopDefault() {
 			return state().config.deps.interopDefault;
 		},
+		get injectCjsGlobals() {
+			return state().config.injectCjsGlobals;
+		},
 		getCurrentTestFilepath: () => state().filepath,
 		getterTracker: state().getterTracker
 	});
@@ -709,6 +730,23 @@ function startVitestModuleRunner(options) {
 					// if module is invalidated, the worker will be recreated,
 					// so cached is always true in a single worker
 					if (!isImportActual && options?.cached) return { cache: true };
+					// only dependency fetches consult the snapshot: by the time the
+					// first dependency is requested, the entry file is transformed and
+					// its import graph is connected on the server, so the snapshot
+					// actually covers the file's transitive dependencies
+					if (importer != null) {
+						const warm = await fetchWarmModules();
+						// the null prototype is not preserved by the IPC serialization, so
+						// ids like "constructor" must not fall through to Object.prototype
+						const warmResult = warm && (Object.hasOwn(warm, id) ? warm[id] : Object.hasOwn(warm, rawId) ? warm[rawId] : void 0);
+						if (warmResult) if ("tmp" in warmResult) try {
+							return {
+								code: readFileSync(warmResult.tmp, "utf-8"),
+								...warmResult
+							};
+						} catch {}
+						else return warmResult;
+					}
 					const otelCarrier = traces?.getContextCarrier();
 					const result = await rpc().fetch(id, importer, environment(), options, otelCarrier);
 					if ("cached" in result) return {