vitest 3.0.8 → 3.1.0-beta.1

package/dist/chunks/{runBaseTests.DnaAUBKD.js → runBaseTests.BVrL_ow3.js}

@@ -1,8 +1,8 @@
 import { performance } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.BmFgJtkv.js';
-import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './coverage.DnNIv-kJ.js';
-import { a as globalExpect, v as vi } from './vi.B5EKKJdE.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.uXkkC4xl.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.CPvtqi8q.js';
+import { a as globalExpect, v as vi } from './vi.nSCvwQ7l.js';
 import { c as closeInspector } from './inspector.DKLceBVD.js';
 import { createRequire } from 'node:module';
 import timers from 'node:timers';
@@ -11,8 +11,7 @@ import util from 'node:util';
 import { getSafeTimers } from '@vitest/utils';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
 import { installSourcemapsSupport } from 'vite-node/source-map';
-import { V as VitestIndex } from './index.CNRemkXW.js';
-import { s as setupCommonEnv } from './setup-common.Uaw6Zgv9.js';
+import { V as VitestIndex } from './index.D7Ny8f_s.js';
 import { g as getWorkerState, r as resetModules } from './utils.C8RiOc4B.js';
 import 'chai';
 import 'node:path';
@@ -20,16 +19,17 @@ import '../path.js';
 import 'node:url';
 import './rpc.TVf73xOu.js';
 import './index.68735LiX.js';
+import './coverage.A3sS5-Wm.js';
+import '@vitest/snapshot';
+import './run-once.2ogXb3JV.js';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import './_commonjsHelpers.BFTU3MAI.js';
-import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
 import './date.W2xKR2qe.js';
-import './run-once.2ogXb3JV.js';
-import './benchmark.Cdu9hjj4.js';
+import './benchmark.DL72EVN-.js';
 import 'expect-type';
 
 let globalSetup = false;

package/dist/chunks/{setup-common.Uaw6Zgv9.js → setup-common.CPvtqi8q.js}

@@ -1,7 +1,30 @@
+import { r as resolveCoverageProviderModule } from './coverage.A3sS5-Wm.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils';
 import { r as resetRunOnceCounter } from './run-once.2ogXb3JV.js';
 
+async function startCoverageInsideWorker(options, loader, runtimeOptions) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.startCoverage?.(runtimeOptions);
+  }
+  return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
+  }
+  return null;
+}
+async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.stopCoverage?.(runtimeOptions);
+  }
+  return null;
+}
+
 let globalSetup = false;
 async function setupCommonEnv(config) {
   resetRunOnceCounter();
@@ -13,7 +36,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals) {
-    (await import('./globals.CydvVTgC.js')).registerApiGlobally();
+    (await import('./globals.BEpDe-k3.js')).registerApiGlobally();
   }
 }
 function setupDefines(defines) {
@@ -70,4 +93,4 @@ async function loadSnapshotSerializers(config, executor) {
   snapshotSerializers.forEach((serializer) => addSerializer(serializer));
 }
 
-export { loadSnapshotSerializers as a, loadDiffConfig as l, setupCommonEnv as s };
+export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/{suite.qtkXWc6R.d.ts → suite.d.FvehnV49.d.ts}

@@ -1,5 +1,5 @@
 import { Test } from '@vitest/runner';
-import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.CFFwLv-O.js';
+import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.d.BwvBVTda.js';
 import { Options } from 'tinybench';
 import '@vitest/runner/utils';
 

package/dist/chunks/{typechecker.cZ0LjdSi.js → typechecker.BlF3eHsb.js}

@@ -1,4 +1,3 @@
-import { isCI } from 'std-env';
 import { writeFile, rm } from 'node:fs/promises';
 import { performance } from 'node:perf_hooks';
 import { TraceMap, generatedPositionFor, eachMapping } from '@vitest/utils/source-map';
@@ -45,11 +44,6 @@ function convertTasksToEvents(file, onTask) {
   return { packs, events };
 }
 
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
-const isWindows = (isNode || isDeno) && process.platform === "win32";
-const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
-
 const REGEXP_WRAP_PREFIX = "$$vitest:";
 function getOutputFile(config, reporter) {
   if (!config?.outputFile) {
@@ -487,6 +481,7 @@ async function collectTests(ctx, filepath) {
       suite: latestSuite,
       file,
       mode,
+      timeout: 0,
       context: {},
       // not used in typecheck
       name: definition.name,
@@ -960,4 +955,4 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
   return { line: null, column: null };
 }
 
-export { TypeCheckError as T, Typechecker as a, isWindows as b, convertTasksToEvents as c, getOutputFile as g, hasFailedSnapshot as h, isTTY as i, wrapSerializableConfig as w };
+export { TypeCheckError as T, Typechecker as a, convertTasksToEvents as c, getOutputFile as g, hasFailedSnapshot as h, wrapSerializableConfig as w };

package/dist/chunks/{vi.B5EKKJdE.js → vi.nSCvwQ7l.js}

@@ -90,7 +90,7 @@ function createExpectPoll(expect) {
               const rejectWithCause = (cause) => {
                 reject(
                   copyStackTrace$1(
-                    new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    new Error("Matcher did not succeed in time.", {
                       cause
                     }),
                     STACK_TRACE_ERROR
@@ -3687,9 +3687,9 @@ class FakeTimers {
   // | _fakingTime | _fakingDate |
   // +-------------+-------------+
   // | false       | falsy       | initial
-  // | false       | truethy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+  // | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
   // | true        | falsy       | vi.useFakeTimers called first
-  // | true        | truethy     | unreachable
+  // | true        | truthy     | unreachable
   _fakingTime;
   _fakingDate;
   _fakeTimers;

package/dist/chunks/vite.d.Fvq-NZoa.d.ts

@@ -0,0 +1,11 @@
+import { I as InlineConfig } from './reporters.d.r7poTZjA.js';
+
+type VitestInlineConfig = InlineConfig;
+declare module "vite" {
+	interface UserConfig {
+		/**
+		* Options for Vitest
+		*/
+		test?: VitestInlineConfig;
+	}
+}

package/dist/chunks/{worker.BmVno_ab.d.ts → worker.d.C58isfFm.d.ts}

@@ -1,7 +1,7 @@
 import { File, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
 import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
-import { a as SerializedConfig } from './config.BCv-fVdT.js';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d8YfPkTm.js';
+import { a as SerializedConfig } from './config.d.DevWltVl.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.C8UItCbf.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
@@ -79,78 +79,78 @@ type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
 };
 
 interface RuntimeRPC {
-    fetch: (id: string, transformMode: TransformMode) => Promise<{
-        externalize?: string;
-        id?: string;
-    }>;
-    transform: (id: string, transformMode: TransformMode) => Promise<{
-        code?: string;
-    }>;
-    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
-        external?: boolean | 'absolute' | 'relative';
-        id: string;
-        /** @deprecated */
-        meta?: Record<string, any> | null;
-        /** @deprecated */
-        moduleSideEffects?: boolean | 'no-treeshake' | null;
-        /** @deprecated */
-        syntheticNamedExports?: boolean | string | null;
-    } | null>;
-    /**
-     * @deprecated unused
-     */
-    getSourceMap: (id: string, force?: boolean) => Promise<any>;
-    onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledError: (err: unknown, type: string) => void;
-    onQueued: (file: File) => void;
-    onCollected: (files: File[]) => Promise<void>;
-    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-    onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
-    onCancel: (reason: CancelReason) => void;
-    getCountOfFailedTests: () => number;
-    snapshotSaved: (snapshot: SnapshotResult) => void;
-    resolveSnapshotPath: (testPath: string) => string;
+	fetch: (id: string, transformMode: TransformMode) => Promise<{
+		externalize?: string
+		id?: string
+	}>;
+	transform: (id: string, transformMode: TransformMode) => Promise<{
+		code?: string
+	}>;
+	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+		external?: boolean | "absolute" | "relative"
+		id: string
+		/** @deprecated */
+		meta?: Record<string, any> | null
+		/** @deprecated */
+		moduleSideEffects?: boolean | "no-treeshake" | null
+		/** @deprecated */
+		syntheticNamedExports?: boolean | string | null
+	} | null>;
+	/**
+	* @deprecated unused
+	*/
+	getSourceMap: (id: string, force?: boolean) => Promise<any>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
 }
 interface RunnerRPC {
-    onCancel: (reason: CancelReason) => void;
+	onCancel: (reason: CancelReason) => void;
 }
 
 /** @deprecated unused */
 type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
 interface ContextTestEnvironment {
-    name: string;
-    transformMode?: TransformMode;
-    options: Record<string, any> | null;
+	name: string;
+	transformMode?: TransformMode;
+	options: Record<string, any> | null;
 }
 interface ContextRPC {
-    pool: string;
-    worker: string;
-    workerId: number;
-    config: SerializedConfig;
-    projectName: string;
-    files: string[] | FileSpecification[];
-    environment: ContextTestEnvironment;
-    providedContext: Record<string, any>;
-    invalidates?: string[];
+	pool: string;
+	worker: string;
+	workerId: number;
+	config: SerializedConfig;
+	projectName: string;
+	files: string[] | FileSpecification[];
+	environment: ContextTestEnvironment;
+	providedContext: Record<string, any>;
+	invalidates?: string[];
 }
 interface WorkerGlobalState {
-    ctx: ContextRPC;
-    config: SerializedConfig;
-    rpc: WorkerRPC;
-    current?: Task;
-    filepath?: string;
-    environment: Environment;
-    environmentTeardownRun?: boolean;
-    onCancel: Promise<CancelReason>;
-    moduleCache: ModuleCacheMap;
-    moduleExecutionInfo?: ModuleExecutionInfo;
-    providedContext: Record<string, any>;
-    durations: {
-        environment: number;
-        prepare: number;
-    };
-    onFilterStackTrace?: (trace: string) => string;
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	environment: Environment;
+	environmentTeardownRun?: boolean;
+	onCancel: Promise<CancelReason>;
+	moduleCache: ModuleCacheMap;
+	moduleExecutionInfo?: ModuleExecutionInfo;
+	providedContext: Record<string, any>;
+	durations: {
+		environment: number
+		prepare: number
+	};
+	onFilterStackTrace?: (trace: string) => string;
 }
 
 export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };

package/dist/chunks/{worker.BT4v-DKx.d.ts → worker.d.CSFlSYJg.d.ts}

@@ -1,8 +1,8 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.BmVno_ab.js';
+import { C as ContextRPC } from './worker.d.C58isfFm.js';
 
 interface WorkerContext extends ContextRPC {
-    port: MessagePort;
+	port: MessagePort;
 }
 
 export type { WorkerContext as W };

package/dist/cli.js

@@ -1,8 +1,8 @@
-import { c as createCLI } from './chunks/cac.VN5q-TPC.js';
+import { c as createCLI } from './chunks/cac.BjmXy7OV.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.fzPh7AOq.js';
+import './chunks/constants.DTYd6dNH.js';
 
 createCLI().parse();

package/dist/config.d.ts

@@ -1,22 +1,25 @@
 import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { d as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, e as UserProjectConfigFn, f as UserProjectConfigExport, T as TestProjectConfiguration } from './chunks/reporters.66aFHiyX.js';
-export { W as WorkspaceProjectConfiguration } from './chunks/reporters.66aFHiyX.js';
-import './chunks/vite.BCQa3xFG.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.BCv-fVdT.js';
+import { b as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, c as UserProjectConfigFn, d as UserProjectConfigExport, T as TestProjectConfiguration } from './chunks/reporters.d.r7poTZjA.js';
+export { W as WorkspaceProjectConfiguration } from './chunks/reporters.d.r7poTZjA.js';
+import './chunks/vite.d.Fvq-NZoa.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.DevWltVl.js';
 import '@vitest/runner';
-import './chunks/environment.d8YfPkTm.js';
+import './chunks/environment.d.C8UItCbf.js';
 import '@vitest/utils';
 import 'node:stream';
+import 'node:console';
 import '@vitest/utils/source-map';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
 import 'vite-node';
 import 'chai';
-import './chunks/benchmark.CFFwLv-O.js';
+import './chunks/benchmark.d.BwvBVTda.js';
 import '@vitest/runner/utils';
 import 'tinybench';
+import './chunks/coverage.d.S9RMNXIe.js';
+import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'node:fs';
 import '@vitest/snapshot/environment';
@@ -28,48 +31,48 @@ declare const defaultInclude: string[];
 declare const defaultExclude: string[];
 declare const coverageConfigDefaults: ResolvedCoverageOptions;
 declare const configDefaults: Readonly<{
-    allowOnly: boolean;
-    isolate: boolean;
-    watch: boolean;
-    globals: boolean;
-    environment: 'node';
-    pool: 'forks';
-    clearMocks: boolean;
-    restoreMocks: boolean;
-    mockReset: boolean;
-    unstubGlobals: boolean;
-    unstubEnvs: boolean;
-    include: string[];
-    exclude: string[];
-    teardownTimeout: number;
-    forceRerunTriggers: string[];
-    update: boolean;
-    reporters: never[];
-    silent: boolean;
-    hideSkippedTests: boolean;
-    api: boolean;
-    ui: boolean;
-    uiBase: string;
-    open: boolean;
-    css: {
-        include: never[];
-    };
-    coverage: CoverageV8Options;
-    fakeTimers: FakeTimerInstallOpts;
-    maxConcurrency: number;
-    dangerouslyIgnoreUnhandledErrors: boolean;
-    typecheck: {
-        checker: 'tsc';
-        include: string[];
-        exclude: string[];
-    };
-    slowTestThreshold: number;
-    disableConsoleIntercept: boolean;
+	allowOnly: boolean
+	isolate: boolean
+	watch: boolean
+	globals: boolean
+	environment: "node"
+	pool: "forks"
+	clearMocks: boolean
+	restoreMocks: boolean
+	mockReset: boolean
+	unstubGlobals: boolean
+	unstubEnvs: boolean
+	include: string[]
+	exclude: string[]
+	teardownTimeout: number
+	forceRerunTriggers: string[]
+	update: boolean
+	reporters: never[]
+	silent: boolean
+	hideSkippedTests: boolean
+	api: boolean
+	ui: boolean
+	uiBase: string
+	open: boolean
+	css: {
+		include: never[]
+	}
+	coverage: CoverageV8Options
+	fakeTimers: FakeTimerInstallOpts
+	maxConcurrency: number
+	dangerouslyIgnoreUnhandledErrors: boolean
+	typecheck: {
+		checker: "tsc"
+		include: string[]
+		exclude: string[]
+	}
+	slowTestThreshold: number
+	disableConsoleIntercept: boolean
 }>;
 
 /**
- * @deprecated Use `ViteUserConfig` instead
- */
+* @deprecated Use `ViteUserConfig` instead
+*/
 type UserConfig = UserConfig$1;
 
 type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;

package/dist/config.js

@@ -1,126 +1,9 @@
-import os from 'node:os';
-import { isCI } from 'std-env';
+export { d as defaultBrowserPort, e as extraInlineDeps } from './chunks/constants.DTYd6dNH.js';
+export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.C2Ndd9wx.js';
 export { mergeConfig } from 'vite';
-
-const defaultBrowserPort = 63315;
-const extraInlineDeps = [
-  /^(?!.*node_modules).*\.mjs$/,
-  /^(?!.*node_modules).*\.cjs\.js$/,
-  // Vite client
-  /vite\w*\/dist\/client\/env.mjs/
-];
-
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
-(isNode || isDeno) && process.platform === "win32";
-(isNode || isDeno) && process.stdout?.isTTY && !isCI;
-
-const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-const defaultExclude = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/cypress/**",
-  "**/.{idea,git,cache,output,temp}/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
-];
-const defaultCoverageExcludes = [
-  "coverage/**",
-  "dist/**",
-  "**/node_modules/**",
-  "**/[.]**",
-  "packages/*/test?(s)/**",
-  "**/*.d.ts",
-  "**/virtual:*",
-  "**/__x00__*",
-  "**/\0*",
-  "cypress/**",
-  "test?(s)/**",
-  "test?(-*).?(c|m)[jt]s?(x)",
-  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
-  "**/__tests__/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-  "**/vitest.{workspace,projects}.[jt]s?(on)",
-  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
-];
-const coverageConfigDefaults = {
-  provider: "v8",
-  enabled: false,
-  all: true,
-  clean: true,
-  cleanOnRerun: true,
-  reportsDirectory: "./coverage",
-  exclude: defaultCoverageExcludes,
-  reportOnFailure: false,
-  reporter: [
-    ["text", {}],
-    ["html", {}],
-    ["clover", {}],
-    ["json", {}]
-  ],
-  extension: [
-    ".js",
-    ".cjs",
-    ".mjs",
-    ".ts",
-    ".mts",
-    ".tsx",
-    ".jsx",
-    ".vue",
-    ".svelte",
-    ".marko",
-    ".astro"
-  ],
-  allowExternal: false,
-  excludeAfterRemap: false,
-  ignoreEmptyLines: true,
-  processingConcurrency: Math.min(
-    20,
-    os.availableParallelism?.() ?? os.cpus().length
-  )
-};
-const fakeTimersDefaults = {
-  loopLimit: 1e4,
-  shouldClearNativeTimers: true
-};
-const configDefaults = Object.freeze({
-  allowOnly: !isCI,
-  isolate: true,
-  watch: !isCI,
-  globals: false,
-  environment: "node",
-  pool: "forks",
-  clearMocks: false,
-  restoreMocks: false,
-  mockReset: false,
-  unstubGlobals: false,
-  unstubEnvs: false,
-  include: defaultInclude,
-  exclude: defaultExclude,
-  teardownTimeout: 1e4,
-  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
-  update: false,
-  reporters: [],
-  silent: false,
-  hideSkippedTests: false,
-  api: false,
-  ui: false,
-  uiBase: "/__vitest__/",
-  open: !isCI,
-  css: {
-    include: []
-  },
-  coverage: coverageConfigDefaults,
-  fakeTimers: fakeTimersDefaults,
-  maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false,
-  typecheck: {
-    checker: "tsc",
-    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
-    exclude: defaultExclude
-  },
-  slowTestThreshold: 300,
-  disableConsoleIntercept: false
-});
+import 'node:os';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
 
 function defineConfig(config) {
   return config;
@@ -132,4 +15,4 @@ function defineWorkspace(config) {
   return config;
 }
 
-export { configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export { defineConfig, defineProject, defineWorkspace };