@effect-uai/google 0.14.0 → 0.16.0

package/dist/{test.DNmyFkvJ-N3QqMRwZ.mjs → test.DNmyFkvJ-BPz3G1HS.mjs}

@@ -3148,31 +3148,31 @@ function delay(timeout, scheduler = setTimeout) {
 }
 //#endregion
 //#region ../../../node_modules/.pnpm/@vitest+utils@4.1.11/node_modules/@vitest/utils/dist/chunk-pathe.M-eThtNZ.js
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
+const _DRIVE_LETTER_START_RE$1 = /^[A-Za-z]:\//;
+function normalizeWindowsPath$1(input = "") {
 	if (!input) return input;
-	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE$1, (r) => r.toUpperCase());
 }
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _IS_ABSOLUTE_RE$1 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 function cwd() {
 	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
 	return "/";
 }
 const resolve = function(...arguments_) {
-	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath$1(argument));
 	let resolvedPath = "";
 	let resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
 		const path = index >= 0 ? arguments_[index] : cwd();
 		if (!path || path.length === 0) continue;
 		resolvedPath = `${path}/${resolvedPath}`;
-		resolvedAbsolute = isAbsolute(path);
+		resolvedAbsolute = isAbsolute$1(path);
 	}
-	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	resolvedPath = normalizeString$1(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute$1(resolvedPath)) return `/${resolvedPath}`;
 	return resolvedPath.length > 0 ? resolvedPath : ".";
 };
-function normalizeString(path, allowAboveRoot) {
+function normalizeString$1(path, allowAboveRoot) {
 	let res = "";
 	let lastSegmentLength = 0;
 	let lastSlash = -1;
@@ -3222,8 +3222,8 @@ function normalizeString(path, allowAboveRoot) {
 	}
 	return res;
 }
-const isAbsolute = function(p) {
-	return _IS_ABSOLUTE_RE.test(p);
+const isAbsolute$1 = function(p) {
+	return _IS_ABSOLUTE_RE$1.test(p);
 };
 //#endregion
 //#region ../../../node_modules/.pnpm/@vitest+utils@4.1.11/node_modules/@vitest/utils/dist/source-map.js
@@ -3594,6 +3594,88 @@ function getOriginalPosition(map, needle) {
 	return result;
 }
 //#endregion
+//#region ../../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+//#endregion
 //#region ../../../node_modules/.pnpm/@vitest+runner@4.1.11/node_modules/@vitest/runner/dist/chunk-artifact.js
 var PendingError = class extends Error {
 	code = "VITEST_PENDING";
@@ -3620,6 +3702,9 @@ const hooksMap = /* @__PURE__ */ new WeakMap();
 function setFn(key, fn) {
 	fnMap.set(key, fn);
 }
+function getFn(key) {
+	return fnMap.get(key);
+}
 function setTestFixture(key, fixture) {
 	testFixtureMap.set(key, fixture);
 }
@@ -3974,6 +4059,7 @@ function splitByComma(s) {
 	if (lastToken) result.push(lastToken);
 	return result;
 }
+function getCurrentTest() {}
 const kChainableContext = Symbol("kChainableContext");
 function getChainableContext(chainable) {
 	return chainable?.[kChainableContext];
@@ -4226,6 +4312,21 @@ function findTestFileStackTrace(testFilePath, error) {
 		if (stack && stack.file === testFilePath) return stack;
 	}
 }
+const filterMap = /* @__PURE__ */ new WeakMap();
+/**
+* @experimental
+*/
+function matchesTags(testTags) {
+	const runner = getRunner();
+	const tagsFilter = runner._currentSpecification?.testTagsFilter ?? runner.config.tagsFilter;
+	if (!tagsFilter) return true;
+	let tagsFilterPredicate = filterMap.get(tagsFilter);
+	if (!tagsFilterPredicate) {
+		tagsFilterPredicate = createTagsFilter(tagsFilter, runner.config.tags);
+		filterMap.set(tagsFilter, tagsFilterPredicate);
+	}
+	return tagsFilterPredicate(testTags);
+}
 function validateTags(config, tags) {
 	if (!config.strictTags) return;
 	const availableTags = new Set(config.tags.map((tag) => tag.name));
@@ -4235,6 +4336,215 @@ function createNoTagsError(availableTags, tag, prefix = "tag") {
 	if (!availableTags.length) throw new Error(`The Vitest config does't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
 	throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:\n${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : ""}`).join("\n")}`);
 }
+function createTagsFilter(tagsExpr, availableTags) {
+	const matchers = tagsExpr.map((expr) => parseTagsExpression(expr, availableTags));
+	return (testTags) => {
+		return matchers.every((matcher) => matcher(testTags));
+	};
+}
+function parseTagsExpression(expr, availableTags) {
+	const stream = new TokenStream(tokenize(expr), expr);
+	const ast = parseOrExpression(stream, availableTags);
+	if (stream.peek().type !== "EOF") throw new Error(`Invalid tags expression: unexpected "${formatToken(stream.peek())}" in "${expr}"`);
+	return (tags) => evaluateNode(ast, tags);
+}
+function formatToken(token) {
+	switch (token.type) {
+		case "TAG": return token.value;
+		default: return formatTokenType(token.type);
+	}
+}
+function tokenize(expr) {
+	const tokens = [];
+	let i = 0;
+	while (i < expr.length) {
+		if (expr[i] === " " || expr[i] === "	") {
+			i++;
+			continue;
+		}
+		if (expr[i] === "(") {
+			tokens.push({ type: "LPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === ")") {
+			tokens.push({ type: "RPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === "!") {
+			tokens.push({ type: "NOT" });
+			i++;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "&&") {
+			tokens.push({ type: "AND" });
+			i += 2;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "||") {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^and(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "AND" });
+			i += 3;
+			continue;
+		}
+		if (/^or(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^not\s/i.test(expr.slice(i))) {
+			tokens.push({ type: "NOT" });
+			i += 3;
+			continue;
+		}
+		let tag = "";
+		while (i < expr.length && expr[i] !== " " && expr[i] !== "	" && expr[i] !== "(" && expr[i] !== ")" && expr[i] !== "!" && expr[i] !== "&" && expr[i] !== "|") {
+			const remaining = expr.slice(i);
+			if (tag === "" && (/^and(?:\s|\)|$)/i.test(remaining) || /^or(?:\s|\)|$)/i.test(remaining) || /^not\s/i.test(remaining))) break;
+			tag += expr[i];
+			i++;
+		}
+		if (tag) tokens.push({
+			type: "TAG",
+			value: tag
+		});
+	}
+	tokens.push({ type: "EOF" });
+	return tokens;
+}
+var TokenStream = class {
+	pos = 0;
+	constructor(tokens, expr) {
+		this.tokens = tokens;
+		this.expr = expr;
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	next() {
+		return this.tokens[this.pos++];
+	}
+	expect(type) {
+		const token = this.next();
+		if (token.type !== type) {
+			if (type === "RPAREN" && token.type === "EOF") throw new Error(`Invalid tags expression: missing closing ")" in "${this.expr}"`);
+			throw new Error(`Invalid tags expression: expected "${formatTokenType(type)}" but got "${formatToken(token)}" in "${this.expr}"`);
+		}
+		return token;
+	}
+	unexpectedToken() {
+		const token = this.peek();
+		if (token.type === "EOF") throw new Error(`Invalid tags expression: unexpected end of expression in "${this.expr}"`);
+		throw new Error(`Invalid tags expression: unexpected "${formatToken(token)}" in "${this.expr}"`);
+	}
+};
+function formatTokenType(type) {
+	switch (type) {
+		case "TAG": return "tag";
+		case "AND": return "and";
+		case "OR": return "or";
+		case "NOT": return "not";
+		case "LPAREN": return "(";
+		case "RPAREN": return ")";
+		case "EOF": return "end of expression";
+	}
+}
+function parseOrExpression(stream, availableTags) {
+	let left = parseAndExpression(stream, availableTags);
+	while (stream.peek().type === "OR") {
+		stream.next();
+		const right = parseAndExpression(stream, availableTags);
+		left = {
+			type: "or",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseAndExpression(stream, availableTags) {
+	let left = parseUnaryExpression(stream, availableTags);
+	while (stream.peek().type === "AND") {
+		stream.next();
+		const right = parseUnaryExpression(stream, availableTags);
+		left = {
+			type: "and",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseUnaryExpression(stream, availableTags) {
+	if (stream.peek().type === "NOT") {
+		stream.next();
+		return {
+			type: "not",
+			operand: parseUnaryExpression(stream, availableTags)
+		};
+	}
+	return parsePrimaryExpression(stream, availableTags);
+}
+function parsePrimaryExpression(stream, availableTags) {
+	const token = stream.peek();
+	if (token.type === "LPAREN") {
+		stream.next();
+		const expr = parseOrExpression(stream, availableTags);
+		stream.expect("RPAREN");
+		return expr;
+	}
+	if (token.type === "TAG") {
+		stream.next();
+		const tagValue = token.value;
+		return {
+			type: "tag",
+			value: tagValue,
+			pattern: resolveTagPattern(tagValue, availableTags)
+		};
+	}
+	stream.unexpectedToken();
+}
+function createWildcardRegex(pattern) {
+	return new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+function resolveTagPattern(tagPattern, availableTags) {
+	if (tagPattern.includes("*")) {
+		const regex = createWildcardRegex(tagPattern);
+		if (!availableTags.some((tag) => regex.test(tag.name))) throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+		return regex;
+	}
+	if (!availableTags.length || !availableTags.some((tag) => tag.name === tagPattern)) throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+	return null;
+}
+function evaluateNode(node, tags) {
+	switch (node.type) {
+		case "tag":
+			if (node.pattern) return tags.some((tag) => node.pattern.test(tag));
+			return tags.includes(node.value);
+		case "not": return !evaluateNode(node.operand, tags);
+		case "and": return evaluateNode(node.left, tags) && evaluateNode(node.right, tags);
+		case "or": return evaluateNode(node.left, tags) || evaluateNode(node.right, tags);
+	}
+}
+function isTestCase(s) {
+	return s.type === "test";
+}
+function getTests(suite) {
+	const tests = [];
+	const arraySuites = toArray(suite);
+	for (const s of arraySuites) if (isTestCase(s)) tests.push(s);
+	else for (const task of s.tasks) if (isTestCase(task)) tests.push(task);
+	else {
+		const taskTests = getTests(task);
+		for (const test of taskTests) tests.push(test);
+	}
+	return tests;
+}
 function getNames(task) {
 	const names = [task.name];
 	let current = task;
@@ -4245,6 +4555,9 @@ function getNames(task) {
 	if (current !== task.file) names.unshift(task.file.name);
 	return names;
 }
+function getTestName(task, separator = " > ") {
+	return getNames(task).slice(1).join(separator);
+}
 function createTaskName(names, separator = " > ") {
 	return names.filter((name) => name !== void 0).join(separator);
 }
@@ -4309,7 +4622,7 @@ const suite = createSuite();
 * ```
 */
 const test$2 = createTest(function(name, optionsOrFn, optionsOrTest) {
-	getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+	getCurrentSuite().test.fn.call(this, formatName$1(name), optionsOrFn, optionsOrTest);
 });
 /**
 * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
@@ -4499,7 +4812,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		if (options.concurrent != null && concurrent != null) options.concurrent = concurrent;
 		const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
 		if (options.sequential != null && sequential != null) options.sequential = sequential;
-		const test = task(formatName(name), {
+		const test = task(formatName$1(name), {
 			...this,
 			...options,
 			handler
@@ -4592,7 +4905,7 @@ function createSuite() {
 		if (isConcurrent != null) options.concurrent = isConcurrent && !isSequential;
 		if (isSequential != null) options.sequential = isSequential && !isConcurrent;
 		if (parentMeta) options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
-		return createSuiteCollector(formatName(name), factory, mode, this.each, options);
+		return createSuiteCollector(formatName$1(name), factory, mode, this.each, options);
 	}
 	suiteFn.each = function(cases, ...args) {
 		const context = getChainableContext(this);
@@ -4600,7 +4913,7 @@ function createSuite() {
 		context.setContext("each", true);
 		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
 		return (name, optionsOrFn, fnOrOptions) => {
-			const _name = formatName(name);
+			const _name = formatName$1(name);
 			const arrayOnlyCases = cases.every(Array.isArray);
 			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
 			const fnFirst = typeof optionsOrFn === "function";
@@ -4618,7 +4931,7 @@ function createSuite() {
 	suiteFn.for = function(cases, ...args) {
 		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
 		return (name, optionsOrFn, fnOrOptions) => {
-			const name_ = formatName(name);
+			const name_ = formatName$1(name);
 			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
 			cases.forEach((item, idx) => {
 				suite(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : void 0);
@@ -4644,7 +4957,7 @@ function createTaskCollector(fn) {
 		context.setContext("each", true);
 		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
 		return (name, optionsOrFn, fnOrOptions) => {
-			const _name = formatName(name);
+			const _name = formatName$1(name);
 			const arrayOnlyCases = cases.every(Array.isArray);
 			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
 			const fnFirst = typeof optionsOrFn === "function";
@@ -4663,7 +4976,7 @@ function createTaskCollector(fn) {
 		const test = getChainableContext(this).withContext();
 		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
 		return (name, optionsOrFn, fnOrOptions) => {
-			const _name = formatName(name);
+			const _name = formatName$1(name);
 			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
 			cases.forEach((item, idx) => {
 				const handlerWrapper = handler ? (ctx) => handler(item, ctx) : void 0;
@@ -4731,7 +5044,7 @@ function createTaskCollector(fn) {
 		const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
 		const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
 		const _test = createTest(function(name, optionsOrFn, optionsOrTest) {
-			fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+			fn.call(this, formatName$1(name), optionsOrFn, optionsOrTest);
 		});
 		getChainableContext(_test).mergeContext({ fixtures });
 		return _test;
@@ -4756,7 +5069,7 @@ function createTaskCollector(fn) {
 function createTest(fn) {
 	return createTaskCollector(fn);
 }
-function formatName(name) {
+function formatName$1(name) {
 	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
 }
 function formatTitle(template, items, idx) {
@@ -5135,6 +5448,39 @@ async function waitForImportsToResolve() {
 	await waitForImportsToResolve();
 }
 //#endregion
+//#region ../../../node_modules/.pnpm/vitest@4.1.11_@types+node@26.2.0_vite@7.3.2_@types+node@26.2.0_jiti@2.6.1_lightningcss@1.32.0_tsx@4.23.12_yaml@2.9.0_/node_modules/vitest/dist/chunks/benchmark.CX_oY03V.js
+const benchFns = /* @__PURE__ */ new WeakMap();
+const benchOptsMap = /* @__PURE__ */ new WeakMap();
+function getBenchOptions(key) {
+	return benchOptsMap.get(key);
+}
+function getBenchFn(key) {
+	return benchFns.get(key);
+}
+createBenchmark(function(name, fn = noop, options = {}) {
+	if (getWorkerState().config.mode !== "benchmark") throw new Error("`bench()` is only available in benchmark mode.");
+	const task = getCurrentSuite().task(formatName(name), {
+		...this,
+		meta: { benchmark: true }
+	});
+	benchFns.set(task, fn);
+	benchOptsMap.set(task, options);
+	if (!this.todo && task.mode === "todo") task.mode = "run";
+});
+function createBenchmark(fn) {
+	const benchmark = createChainable([
+		"skip",
+		"only",
+		"todo"
+	], fn);
+	benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+	benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+	return benchmark;
+}
+function formatName(name) {
+	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+//#endregion
 //#region ../../../node_modules/.pnpm/@vitest+spy@4.1.11/node_modules/@vitest/spy/dist/index.js
 function isMockFunction(fn) {
 	return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction === true;
@@ -10048,6 +10394,10 @@ function resetDate() {
 	globalThis.Date = RealDate;
 }
 const { get } = Reflect;
+function rpc() {
+	const { rpc } = getWorkerState();
+	return rpc;
+}
 //#endregion
 //#region ../../../node_modules/.pnpm/@vitest+snapshot@4.1.11/node_modules/@vitest/snapshot/dist/index.js
 function getDefaultExportFromCjs(x) {
@@ -13652,7 +14002,166 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
+function inject(key) {
+	return getWorkerState().providedContext[key];
+}
+var TestRunner = class {
+	snapshotClient = getSnapshotClient();
+	workerState = getWorkerState();
+	moduleRunner;
+	cancelRun = false;
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	pool = this.workerState.ctx.pool;
+	_otel;
+	viteEnvironment;
+	viteModuleRunner;
+	constructor(config) {
+		this.config = config;
+		const environment = this.workerState.environment;
+		this.viteEnvironment = environment.viteEnvironment || environment.name;
+		this.viteModuleRunner = config.experimental.viteModuleRunner;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => {
+			if (!this.viteModuleRunner) filepath = `${filepath}?vitest=${Date.now()}`;
+			return this.moduleRunner.import(filepath);
+		});
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear();
+		this.workerState.current = void 0;
+	}
+	async onAfterRunSuite(suite) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+		if (suite.mode !== "skip" && "filepath" in suite) {
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
+			}
+			const result = await this.snapshotClient.finish(suite.file.filepath);
+			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+				suite.result.errors ??= [];
+				suite.result.errors.push(processError(new Error(message)));
+				suite.result.state = "fail";
+			}
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+		this.workerState.current = test.suite || test.file;
+	}
+	cancel(_reason) {
+		this.cancelRun = true;
+	}
+	injectValue(key) {
+		return inject(key);
+	}
+	async onBeforeRunTask(test) {
+		if (this.cancelRun) test.mode = "skip";
+		if (test.mode !== "run" && test.mode !== "queued") return;
+		this.workerState.current = test;
+	}
+	async onBeforeRunSuite(suite) {
+		if (this.cancelRun) suite.mode = "skip";
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+		this.workerState.current = suite;
+	}
+	onBeforeTryTask(test) {
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(test) {
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+	}
+	extendTaskContext(context) {
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+		let _expect;
+		Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} });
+		Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} });
+		return context;
+	}
+	getImportDurations() {
+		const { limit } = this.config.experimental.importDurations;
+		if (limit === 0) return {};
+		const sortedEntries = [...this.workerState.moduleExecutionInfo?.entries() || []].sort(([, a], [, b]) => b.duration - a.duration).slice(0, limit);
+		const importDurations = {};
+		for (const [filepath, { duration, selfTime, external, importer }] of sortedEntries) importDurations[normalize(filepath)] = {
+			selfTime,
+			totalTime: duration,
+			external,
+			importer
+		};
+		return importDurations;
+	}
+	trace = (name, attributes, cb) => {
+		const options = typeof attributes === "object" ? { attributes } : {};
+		return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+	};
+	__setTraces(traces) {
+		this._otel = traces;
+	}
+	static createTaskCollector = createTaskCollector;
+	static getCurrentSuite = getCurrentSuite;
+	static getCurrentTest = getCurrentTest;
+	static createChainable = createChainable;
+	static getSuiteHooks = getHooks;
+	static getTestFn = getFn;
+	static setSuiteHooks = getHooks;
+	static setTestFn = getFn;
+	static matchesTags = matchesTags;
+	/**
+	* @deprecated
+	*/
+	static getBenchFn = getBenchFn;
+	/**
+	* @deprecated
+	*/
+	static getBenchOptions = getBenchOptions;
+};
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	if (restoreMocks) vi.restoreAllMocks();
+	if (mockReset) vi.resetAllMocks();
+	if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
 //#endregion
-export { describe as n, it as r, globalExpect as t };
+export { beforeEach as a, beforeAll as i, globalExpect as n, describe as o, afterAll as r, it as s, TestRunner as t };
 
-//# sourceMappingURL=test.DNmyFkvJ-N3QqMRwZ.mjs.map
+//# sourceMappingURL=test.DNmyFkvJ-BPz3G1HS.mjs.map