@nx/vitest 23.3.0-pr.37068.f95e11e → 23.3.0-rc.0

package/README.md

@@ -12,7 +12,7 @@
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
-[![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)
+[![Hours saved](https://img.shields.io/endpoint?url=https%3A%2F%2Fstaging.nx.app%2Fnx-cloud%2Fbadge%2F62d013ea0852fe0a2df74438%2Fhours-saved.json)](https://nx.dev/nx-cloud)
 
 </div>
 

package/dist/src/executors/test/lib/nx-reporter.d.ts

@@ -1,5 +1,4 @@
-import type { RunnerTestFile } from 'vitest/node';
-import type { Reporter } from 'vitest/reporters';
+import type { Reporter, RunnerTestFile } from 'vitest/node';
 export declare class NxReporter implements Reporter {
     private watch;
     deferred: {

package/dist/src/generators/configuration/configuration.js

@@ -66,6 +66,14 @@ async function configurationGeneratorInternal(tree, schema, hasPlugin = false) {
     const uiFramework = schema.uiFramework ?? (await (0, detect_ui_framework_1.detectUiFramework)(schema.project));
     const isRootProject = root === '.';
     tasks.push(await (0, js_1.initGenerator)(tree, { ...schema, skipFormat: true }));
+    // Written before init so version selection sees it: analog peers vitest 4,
+    // and init is what picks the vitest version.
+    if (uiFramework === 'angular' && !schema.skipPackageJson) {
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@analogjs/vitest-angular': versions_1.analogVitestAngular,
+            '@analogjs/vite-plugin-angular': versions_1.analogVitestAngular,
+        }, undefined, true));
+    }
     const initTask = await (0, init_1.default)(tree, {
         skipFormat: true,
         addPlugin: schema.addPlugin,
@@ -196,7 +204,8 @@ getTestBed().initTestEnvironment(
     // workspace files in favor of inlining the projects into a root vitest.config
     // via `test.projects` (https://vitest.dev/guide/migration.html#workspace-is-replaced-with-projects).
     // Emit that shape for vitest 4+ and when the installed version can't be
-    // detected (new installs resolve to v4); vitest 3 keeps the workspace file.
+    // detected (a new install resolves to 4 or 5); vitest 3 keeps the workspace
+    // file.
     if (!isRootProject) {
         const projectGlobs = `'**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'`;
         const vitestMajorVersion = (0, versions_1.getInstalledVitestMajorVersion)(tree);

package/dist/src/generators/init/init.js

@@ -5,6 +5,7 @@ exports.updateNxJsonSettings = updateNxJsonSettings;
 exports.initGenerator = initGenerator;
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
 const versions_1 = require("../../utils/versions");
 const plugin_1 = require("../../plugins/plugin");
 const version_utils_1 = require("../../utils/version-utils");
@@ -23,9 +24,19 @@ function updateDependencies(tree, schema) {
             : installedMajor === 7
                 ? versions_1.viteV7Version
                 : versions_1.viteVersion;
+    // Vite below 8 depends on esbuild (8 bundles rolldown instead), whose install
+    // script only validates the prebuilt binary that ships as an optional
+    // dependency.
+    if ((0, semver_1.major)((0, semver_1.coerce)(viteVersionToUse)) < 8) {
+        (0, internal_1.acknowledgeBuildScripts)(tree, (0, devkit_1.detectPackageManager)(tree.root), {
+            esbuild: false,
+        });
+    }
     return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
         '@nx/vitest': versions_1.nxVersion,
-        vitest: versions_1.vitestVersion,
+        // The range about to be installed is passed for the case where the
+        // workspace has no vite of its own; it constrains the vitest major.
+        vitest: (0, versions_1.versions)(tree, { viteRange: viteVersionToUse }).vitestVersion,
         vite: viteVersionToUse,
     }, undefined, schema.keepExistingVersions ?? true);
 }

package/dist/src/migrations/update-23-3-0/ai-instructions-for-vitest-5.md

@@ -0,0 +1,92 @@
+# Vitest 5 migration
+
+The deterministic pre-pass already handled the mechanical parts: removed deep
+entry points were repointed where a plain import or export declaration reached
+them, `.vitest` was added to `.gitignore`, and `vite` was declared in
+`package.json` if the workspace had been relying on Vitest 4 pulling it in.
+
+Anything it could not decide for itself is in the context it passed you. Work
+through that list first, then run the tests.
+
+Most of what is left is runtime behavior. Do not try to find it by reading every
+test file. Run the test suites, then work through the failures with the list
+below, which covers the changes that produce confusing failures.
+
+## Run the tests first
+
+```bash
+nx run-many -t test
+```
+
+## What the failures probably mean
+
+**Mocks look empty.** `clearMocks` now defaults to `true`, so `mock.calls`,
+`mock.instances`, `mock.contexts` and `mock.results` reset before every test. A
+test that asserts on calls recorded by an earlier test now sees nothing. Fix the
+test, or set `clearMocks: false` in the config to keep the old behavior.
+
+**"Cannot call vi.mock inside ...".** `vi.mock`, `vi.unmock` and `vi.hoisted`
+now throw when called outside the module top level. In v4 this only warned. Move
+the call to the top level, or switch to `vi.doMock`.
+
+**A test fails that used to pass silently.** An unawaited `resolves`, `rejects`
+or `toMatchFileSnapshot` now fails the test instead of being ignored. Add the
+missing `await`.
+
+**`expect.poll` times out.** It now fails when the callback does not settle
+within `timeout`, rather than hanging on the last value.
+
+**A `toThrow('')` assertion changed meaning.** An empty string now matches any
+message. Use `/^$/` to assert on an empty message.
+
+**Snapshot names moved.** String values interpolated through `$` in
+`test.for`/`test.each` titles are no longer wrapped in quotes, and truncation is
+now controlled by `taskTitleValueFormatTruncate` (default 40).
+
+**A CI filter matches nothing.** `-t` and `testNamePattern` now join name
+segments with `' > '` instead of a space.
+
+**Per-worker resources collide.** `VITEST_POOL_ID` and `VITEST_WORKER_ID` are
+now 1-based. Any logic deriving a database name, port or directory from them
+shifts by one.
+
+**Vitest cannot find a config.** It no longer searches ancestor directories.
+Pass `--config` explicitly, or give the directory its own config.
+
+**Projects behave differently.** Inline projects now default to `extends: true`
+and share the root Vite server (`sharedViteServer`). Set either to `false` if a
+project needs its own resolution.
+
+## Check these without running anything
+
+- `sequential`, if the pre-pass flagged any. `test.sequential()` and
+  `describe.sequential()` are gone. When nothing makes the test concurrent, drop
+  the modifier: `test.sequential('a', ...)` becomes `test('a', ...)`. When it was
+  opting out of a concurrent suite or a concurrent setting in the config, it
+  becomes the `{ concurrent: false }` option. The same applies to a `sequential`
+  entry in a test's options object.
+- `vitest/suite` and `vitest/runners` imports, if the pre-pass flagged any. Their
+  exports did not move as a group: `getCurrentSuite` and `createTaskCollector` are
+  static members of `TestRunner` (exported from `vitest`), `VitestTestRunner` is
+  exported from `vitest`, the `VitestRunner` type is in `vitest/runtime`, and
+  `NodeBenchmarkRunner`, `getBenchFn` and `getBenchOptions` went with the old
+  benchmark API. Rebind the use sites rather than repointing the import.
+- `@vitest/runner` and `@vitest/ws-client` in `package.json`: neither is published
+  for v5. Their exports scattered. The hooks and `describe`/`it`/`test` come from
+  `vitest`, the collection helpers are now static members of `TestRunner`
+  (`TestRunner.getCurrentSuite()`, `TestRunner.getCurrentTest()`), and only the
+  `VitestRunner` type and the environment and snapshot helpers are in
+  `vitest/runtime`. `collectTests`, `startTests` and `updateTask` have no public
+  replacement.
+- Benchmarks: the module-level `bench()` API is gone, along with
+  `benchmark.reporters`, `benchmark.outputFile`, `benchmark.compare` and the
+  `--compare` CLI flag. `bench` now comes off the test context.
+- `coverage.thresholds` under a glob no longer inherits the top-level `perFile`.
+  Set it on each glob that needs it.
+- Browser mode, if the workspace configures it by hand: locators are strict by
+  default, `toHaveTextContent` no longer accepts a RegExp (`toMatchTextContent`
+  does), browser commands receive a locator object rather than a selector string,
+  automocked modules return `undefined`, and `browser.api` moved to top-level
+  `api`.
+
+The full list is at https://vitest.dev/guide/migration.

package/dist/src/migrations/update-23-3-0/migrate-to-vitest-5.d.ts

@@ -0,0 +1,14 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * Hybrid migration paired with `ai-instructions-for-vitest-5.md`. Applies the
+ * handful of Vitest 4 -> 5 changes that have one correct answer and forwards
+ * everything else to the paired prompt.
+ *
+ * The apply set is deliberately small: the rest of v5's breaking changes are
+ * runtime semantics (mock clearing, unawaited assertions, hoisting) that a
+ * test run surfaces far better than a codemod can guess at.
+ */
+export default function migrateToVitest5(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+}>;

package/dist/src/migrations/update-23-3-0/migrate-to-vitest-5.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateToVitest5;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const ignore_vitest_temp_files_1 = require("../../utils/ignore-vitest-temp-files");
+const semver_1 = require("semver");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const TEST_CALLEES = new Set(['test', 'it', 'describe', 'suite', 'bench']);
+/**
+ * Hybrid migration paired with `ai-instructions-for-vitest-5.md`. Applies the
+ * handful of Vitest 4 -> 5 changes that have one correct answer and forwards
+ * everything else to the paired prompt.
+ *
+ * The apply set is deliberately small: the rest of v5's breaking changes are
+ * runtime semantics (mock clearing, unawaited assertions, hoisting) that a
+ * test run surfaces far better than a codemod can guess at.
+ */
+async function migrateToVitest5(tree) {
+    const unhandled = [];
+    (0, ignore_vitest_temp_files_1.addVitestTempFilesToGitIgnore)(tree);
+    const addedVite = declareVitePeerDependency(tree);
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (filePath) => {
+        if (!isJsOrTsFile(filePath))
+            return;
+        const contents = tree.read(filePath, 'utf-8');
+        if (!contents)
+            return;
+        const hasEntryPoints = contents.includes('vitest/');
+        const hasSequential = contents.includes('sequential');
+        if (!hasEntryPoints && !hasSequential)
+            return;
+        const sourceFile = (0, tsquery_1.ast)(contents);
+        if (hasEntryPoints) {
+            rewriteRemovedEntryPoints(tree, filePath, contents, sourceFile, unhandled);
+        }
+        if (hasSequential) {
+            detectSequentialUsage(filePath, sourceFile, unhandled);
+        }
+    });
+    await (0, devkit_1.formatFiles)(tree);
+    const result = {};
+    if (addedVite) {
+        result.nextSteps = [
+            `Added \`vite\` to the root \`package.json\` devDependencies, matching the version already resolved in the workspace. Vitest 4 depended on Vite directly; Vitest 5 only declares it as a required peer, so a workspace that relied on the transitive copy has none after the upgrade.`,
+        ];
+    }
+    if (unhandled.length > 0)
+        result.agentContext = unhandled;
+    return result;
+}
+// Fallback only. The workspace's own resolved vite is preferred, since moving
+// a 6.4 or 7.x workspace to 8 is a bundler major riding inside a test upgrade.
+const FALLBACK_VITE_VERSION = '^8.0.0';
+/**
+ * Vitest 4 listed `vite` in `dependencies`, so workspaces that only ran tests
+ * never had to declare it. Vitest 5 dropped it to a required peer.
+ */
+function declareVitePeerDependency(tree) {
+    if (!tree.exists('package.json'))
+        return false;
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const hasVitest = packageJson.dependencies?.['vitest'] ??
+        packageJson.devDependencies?.['vitest'];
+    if (!hasVitest)
+        return false;
+    if (packageJson.dependencies?.['vite'] ??
+        packageJson.devDependencies?.['vite'])
+        return false;
+    const installedVite = (0, internal_1.getInstalledPackageVersion)('vite');
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        json.devDependencies ??= {};
+        json.devDependencies['vite'] = installedVite
+            ? `^${(0, semver_1.major)(installedVite)}.0.0`
+            : FALLBACK_VITE_VERSION;
+        return json;
+    });
+    return true;
+}
+const TS_JS_RE = /\.[cm]?[jt]sx?$/;
+function isJsOrTsFile(filePath) {
+    return TS_JS_RE.test(filePath);
+}
+/**
+ * v5 removed the deprecated deep entry points. A specifier is only rewritten
+ * when every one of its v4 exports landed in a single v5 module; the rest are
+ * described for the agent, because their exports scattered or disappeared.
+ */
+const REMOVED_ENTRY_POINTS = {
+    'vitest/reporters': {
+        replacement: 'vitest/node',
+        note: 'its reporter exports are now in `vitest/node`',
+    },
+    'vitest/coverage': {
+        replacement: 'vitest/node',
+        note: '`BaseCoverageProvider` is now in `vitest/node`',
+    },
+    'vitest/snapshot': {
+        replacement: 'vitest/runtime',
+        note: 'its snapshot exports are now in `vitest/runtime`',
+    },
+    'vitest/environments': {
+        replacement: 'vitest/runtime',
+        note: 'its environment exports are now in `vitest/runtime`',
+    },
+    'vitest/suite': {
+        note: 'its exports did not survive as module exports. `getCurrentSuite` and `createTaskCollector` are static members of `TestRunner` (exported from `vitest`), and the rest were removed. Rebind the use sites rather than repointing the import',
+    },
+    'vitest/runners': {
+        note: 'its exports split up. `VitestTestRunner` is exported from `vitest`, `VitestRunner` from `vitest/runtime`, and `NodeBenchmarkRunner` was removed with the old benchmark API',
+    },
+};
+/**
+ * Exports the v5 benchmark rewrite removed outright. A file importing one of
+ * these from `vitest/reporters` cannot simply be repointed.
+ */
+const REMOVED_SYMBOLS = new Set([
+    'BenchmarkBuiltinReporters',
+    'BenchmarkReporter',
+    'BenchmarkReportsMap',
+    'VerboseBenchmarkReporter',
+    'NodeBenchmarkRunner',
+]);
+/**
+ * Only import and export declarations are rewritten. A removed specifier
+ * reached any other way still has to go, so name it for the agent.
+ */
+function reportUnrewritableSpecifiers(sourceFile, moduleSpecifiers, filePath, unhandled) {
+    const specifierStarts = new Set(moduleSpecifiers.map((node) => node.getStart(sourceFile)));
+    const stragglers = new Set((0, tsquery_1.query)(sourceFile, 'StringLiteral')
+        .filter((node) => node.text in REMOVED_ENTRY_POINTS &&
+        !specifierStarts.has(node.getStart(sourceFile)))
+        .map((node) => node.text));
+    for (const specifier of stragglers) {
+        unhandled.push(`${filePath} references \`${specifier}\` outside an import or export declaration. Vitest 5 removed it: ${REMOVED_ENTRY_POINTS[specifier].note}.`);
+    }
+}
+function rewriteRemovedEntryPoints(tree, filePath, contents, sourceFile, unhandled) {
+    const specifiers = (0, tsquery_1.query)(sourceFile, 'ImportDeclaration > StringLiteral, ExportDeclaration > StringLiteral');
+    reportUnrewritableSpecifiers(sourceFile, specifiers, filePath, unhandled);
+    const opaqueStarts = new Set((0, tsquery_1.query)(sourceFile, OPAQUE_DECLARATIONS).map((node) => node.getStart(sourceFile)));
+    let updated = contents;
+    let changed = false;
+    // Right-to-left so earlier offsets stay valid as the text shifts.
+    for (const specifier of [...specifiers].reverse()) {
+        const entryPoint = REMOVED_ENTRY_POINTS[specifier.text];
+        if (!entryPoint)
+            continue;
+        const blocker = whyNotRewritable(specifier, entryPoint, opaqueStarts, sourceFile);
+        if (blocker) {
+            unhandled.push(`${filePath} imports from \`${specifier.text}\`, which Vitest 5 removed: ${blocker}.`);
+            continue;
+        }
+        updated =
+            updated.slice(0, specifier.getStart(sourceFile) + 1) +
+                entryPoint.replacement +
+                updated.slice(specifier.getEnd() - 1);
+        changed = true;
+    }
+    if (changed)
+        tree.write(filePath, updated);
+}
+/**
+ * Declarations that take a whole module instead of naming what they use, so
+ * there is no symbol list to check against the ones Vitest 5 removed.
+ */
+const OPAQUE_DECLARATIONS = [
+    'ImportDeclaration:has(NamespaceImport) > StringLiteral',
+    'ExportDeclaration:has(NamespaceExport) > StringLiteral',
+    'ImportDeclaration:has(ImportClause > Identifier) > StringLiteral',
+    'ExportDeclaration:not(:has(ExportSpecifier)) > StringLiteral',
+].join(', ');
+/** The reason this specifier cannot be repointed, if there is one. */
+function whyNotRewritable(specifier, entryPoint, opaqueStarts, sourceFile) {
+    if (!entryPoint.replacement) {
+        return entryPoint.note;
+    }
+    if (opaqueStarts.has(specifier.getStart(sourceFile))) {
+        return `${entryPoint.note}, but this declaration takes the whole module rather than naming what it uses, so the symbols cannot be checked here`;
+    }
+    const removed = boundNamesOf(specifier).filter((name) => REMOVED_SYMBOLS.has(name));
+    return removed.length
+        ? `\`${removed.join('`, `')}\` no longer exists anywhere, it went with the old benchmark API`
+        : undefined;
+}
+function boundNamesOf(specifier) {
+    return (0, tsquery_1.query)(specifier.parent, 'ImportSpecifier, ExportSpecifier').map((element) => (element.propertyName ?? element.name).text);
+}
+/**
+ * `test.sequential()` / `describe.sequential()` and the `sequential` test
+ * option are gone in v5. The replacement depends on whether the test inherits
+ * concurrency from a suite or the config, so the agent decides rather than the
+ * codemod.
+ */
+function detectSequentialUsage(filePath, sourceFile, unhandled) {
+    // Both AST forms of a property key, and only in an options object handed to
+    // a test or suite call. A loose `{ sequential: true }` is someone else's API.
+    const optionKeys = (0, tsquery_1.query)(sourceFile, 'PropertyAssignment > :matches(Identifier[name=sequential], StringLiteral[value=sequential])').filter((key) => {
+        // PropertyAssignment < ObjectLiteralExpression < CallExpression.
+        const call = key.parent?.parent?.parent;
+        return (!!call &&
+            'arguments' in call &&
+            TEST_CALLEES.has(call.expression.getText(sourceFile).split('.')[0]));
+    });
+    const modifiers = (0, tsquery_1.query)(sourceFile, 'PropertyAccessExpression:has(Identifier[name=sequential])').filter((node) => node.name.text === 'sequential' &&
+        TEST_CALLEES.has(node.expression.getText(sourceFile)));
+    const usages = [...optionKeys, ...modifiers];
+    if (usages.length === 0)
+        return;
+    unhandled.push(`${filePath} uses \`sequential\`, which Vitest 5 removed. Replace \`test.sequential(...)\` / \`describe.sequential(...)\` with a plain \`test(...)\` / \`describe(...)\` when nothing makes them concurrent, and with the \`{ concurrent: false }\` option when they are opting out of a concurrent suite or a concurrent setting in the config.`);
+}

package/dist/src/plugins/plugin.js

@@ -9,6 +9,7 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const executor_utils_1 = require("../utils/executor-utils");
+const setup_file_inputs_1 = require("./setup-file-inputs");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -42,6 +43,7 @@ exports.createNodes = [
             lockfile,
             ...(tsconfigChainsByProjectRoot.get(root) ?? []),
         ]));
+        const setupTsconfigJsonCache = new Map();
         try {
             return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
                 const projectRoot = (0, node_path_1.dirname)(configFile);
@@ -50,7 +52,10 @@ exports.createNodes = [
                 // Adding the config file path to the hash ensures that the final hash value is different
                 // for different config files.
                 const hash = hashes[idx] + configFile;
-                if (!targetsCache.has(hash)) {
+                const cachedTargets = targetsCache.get(hash);
+                // Older cache entries predate `setupFileCandidates`.
+                if (cachedTargets === undefined ||
+                    (cachedTargets && !cachedTargets.setupFileCandidates)) {
                     const result = await buildVitestTargets(configFile, projectRoot, normalizedOptions, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []);
                     // Cache the result even when it's null (a root orchestrator config)
                     // so the config isn't re-resolved on every project-graph build.
@@ -62,10 +67,12 @@ exports.createNodes = [
                 if (!cached) {
                     return { projects: {} };
                 }
-                const { metadata, targets } = cached;
+                const { metadata, targets, setupFileCandidates } = cached;
                 const project = {
                     root: projectRoot,
-                    targets,
+                    // Resolved on every run: the cache key does not cover setup files
+                    // or their tsconfigs.
+                    targets: withSetupFileInputs(targets, normalizedOptions.testTargetName, setupFileCandidates, projectRoot, context.workspaceRoot, setupTsconfigJsonCache),
                     metadata,
                 };
                 return {
@@ -92,18 +99,6 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     catch {
         // do nothing
     }
-    // Workaround for race condition with ESM-only Vite plugins (e.g. @vitejs/plugin-vue@6+)
-    // If vite.config.ts is compiled as CJS, then when both require('@vitejs/plugin-vue') and import('@vitejs/plugin-vue')
-    // are pending in the same process, Node will throw an error:
-    // Error [ERR_INTERNAL_ASSERTION]: Cannot require() ES Module @vitejs/plugin-vue/dist/index.js because it is not yet fully loaded.
-    // This may be caused by a race condition if the module is simultaneously dynamically import()-ed via Promise.all().
-    try {
-        const importVuePlugin = () => new Function('return import("@vitejs/plugin-vue")')();
-        await importVuePlugin();
-    }
-    catch {
-        // Plugin not installed or not needed, ignore
-    }
     // Workaround for race condition with vitest/node on Node 24+
     // When multiple vitest.config files are processed in parallel, Node can throw:
     // Error [ERR_INTERNAL_ASSERTION]: Cannot require() ES Module vitest/dist/node.js
@@ -117,10 +112,26 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
         // vitest/node not available or not needed, ignore
     }
     const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
-    const viteBuildConfig = await resolveConfig({
+    // Vite fills a missing `root` with `process.cwd()`, which at graph time is
+    // the workspace root - not where the task runs. Capture what the config
+    // actually authored so a relative path can be resolved the way Vitest will.
+    let authoredViteRoot;
+    const viteBuildConfig = await (0, internal_1.retryOnRequireEsmRace)(() => resolveConfig({
         configFile: absoluteConfigFilePath,
         mode: 'development',
-    }, 'build');
+        plugins: [
+            {
+                name: 'nx-capture-authored-vitest-root',
+                enforce: 'post',
+                config: {
+                    order: 'post',
+                    handler(config) {
+                        authoredViteRoot = config.root;
+                    },
+                },
+            },
+        ],
+    }, 'build'));
     // A root config that aggregates project configs via `test.projects` is just an
     // orchestrator; the actual tests live in the individual project configs. Skip it
     // entirely so it does not register a project rooted at the workspace root (which
@@ -134,9 +145,11 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     const { testOutputs, hasTest } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
     const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const targets = {};
+    let setupFileCandidates = [];
     // if file is vitest.config or vite.config has definition for test, create targets for test and/or atomized tests
     if (configFilePath.includes('vitest.config') || hasTest) {
         const isTypecheckEnabled = !!viteBuildConfig.test?.typecheck?.enabled;
+        setupFileCandidates = (0, setup_file_inputs_1.resolveSetupFileCandidates)(viteBuildConfig, projectRoot, context.workspaceRoot, authoredViteRoot);
         targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, options.testMode, pmc, isTypecheckEnabled, tsconfigInputs);
         if (options.ciTargetName) {
             const groupName = options.ciGroupName ?? (0, internal_1.deriveGroupNameFromTarget)(options.ciTargetName);
@@ -160,7 +173,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
             // Capture the raw root after user hooks: graph construction and the
             // atom run resolve it against different cwds.
             let configuredViteRoot;
-            const viteServeConfig = await resolveConfig({
+            const viteServeConfig = await (0, internal_1.retryOnRequireEsmRace)(() => resolveConfig({
                 configFile: absoluteConfigFilePath,
                 mode: 'test',
                 plugins: [
@@ -186,7 +199,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                         },
                     },
                 ],
-            }, 'serve');
+            }, 'serve'));
             const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot, 
             // Only the glob path reads this config; the opt-out path forces the
             // runtime by receiving no config, and takes `test.dir` separately.
@@ -300,7 +313,28 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
             }
         }
     }
-    return { targets, metadata };
+    return { targets, metadata, setupFileCandidates };
+}
+function withSetupFileInputs(targets, testTargetName, setupFileCandidates, projectRoot, workspaceRoot, jsonCache) {
+    if (setupFileCandidates.length === 0)
+        return targets;
+    const { files, tsconfigs } = (0, setup_file_inputs_1.collectSetupFileInputs)(setupFileCandidates, projectRoot, workspaceRoot, jsonCache);
+    if (files.length === 0 && tsconfigs.length === 0)
+        return targets;
+    const setupInputs = [
+        ...tsconfigs.map((f) => ({
+            json: `{workspaceRoot}/${f}`,
+            fields: ['compilerOptions'],
+        })),
+        // Whole-file, not just `compilerOptions`: these are sources Vitest
+        // executes, so any change to them changes the run.
+        ...files.map((f) => `{workspaceRoot}/${f}`),
+    ];
+    const inputs = [...targets[testTargetName].inputs, ...setupInputs];
+    return Object.fromEntries(Object.entries(targets).map(([name, target]) => [
+        name,
+        { ...target, inputs },
+    ]));
 }
 async function testTarget(namedInputs, outputs, projectRoot, testMode = 'watch', pmc, isTypecheckEnabled, tsconfigInputs) {
     const command = testMode === 'run' ? 'vitest run' : 'vitest';
@@ -408,7 +442,7 @@ function normalizeOutputPath(outputPath, projectRoot, workspaceRoot, path) {
     }
     else {
         if ((0, node_path_1.isAbsolute)(outputPath)) {
-            return `{workspaceRoot}/${(0, node_path_1.relative)(workspaceRoot, outputPath)}`;
+            return `{workspaceRoot}/${(0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, outputPath))}`;
         }
         else {
             if (outputPath.startsWith('..')) {

package/dist/src/plugins/setup-file-inputs.d.ts

@@ -0,0 +1,24 @@
+import type { RawTsconfigJsonCache } from '@nx/js/internal';
+import type { ResolvedConfig } from 'vite';
+/**
+ * Resolves the files Vitest loads from outside the project root - `setupFiles`
+ * and `globalSetup`. `collectSetupFileInputs` declares the ones that exist,
+ * together with the tsconfigs Vite reads to transform them.
+ *
+ * Reads the build-resolved config, as the inferred target's inputs are built
+ * from it. Setup files contributed by an `apply: 'serve'` plugin are therefore
+ * invisible here - the same build/serve divergence the atomized path documents.
+ *
+ * Solution-style tsconfigs are deliberately not followed. When the nearest
+ * tsconfig of a setup file is a solution file, Vite walks its `references` and
+ * reads every project's tsconfig; declaring those would attach one input per
+ * project in the workspace. Keep the setup file inside a project (or beside a
+ * leaf tsconfig) instead.
+ */
+export declare function resolveSetupFileCandidates(viteConfig: ResolvedConfig, projectRoot: string, workspaceRoot: string, 
+/** `root` as the config authored it, before vite defaults it to `cwd`. */
+authoredViteRoot?: string): string[];
+export declare function collectSetupFileInputs(setupFileCandidates: string[], projectRoot: string, workspaceRoot: string, jsonCache: RawTsconfigJsonCache): {
+    files: string[];
+    tsconfigs: string[];
+};

package/dist/src/plugins/setup-file-inputs.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSetupFileCandidates = resolveSetupFileCandidates;
+exports.collectSetupFileInputs = collectSetupFileInputs;
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Resolves the files Vitest loads from outside the project root - `setupFiles`
+ * and `globalSetup`. `collectSetupFileInputs` declares the ones that exist,
+ * together with the tsconfigs Vite reads to transform them.
+ *
+ * Reads the build-resolved config, as the inferred target's inputs are built
+ * from it. Setup files contributed by an `apply: 'serve'` plugin are therefore
+ * invisible here - the same build/serve divergence the atomized path documents.
+ *
+ * Solution-style tsconfigs are deliberately not followed. When the nearest
+ * tsconfig of a setup file is a solution file, Vite walks its `references` and
+ * reads every project's tsconfig; declaring those would attach one input per
+ * project in the workspace. Keep the setup file inside a project (or beside a
+ * leaf tsconfig) instead.
+ */
+function resolveSetupFileCandidates(viteConfig, projectRoot, workspaceRoot, 
+/** `root` as the config authored it, before vite defaults it to `cwd`. */
+authoredViteRoot) {
+    // At the workspace root everything is already covered by `default`.
+    if (projectRoot === '.')
+        return [];
+    const entries = [
+        viteConfig.test?.setupFiles,
+        viteConfig.test?.globalSetup,
+    ].flatMap((value) => typeof value === 'string' ? [value] : Array.isArray(value) ? value : []);
+    if (entries.length === 0)
+        return [];
+    // Vitest resolves both options against its root, and the inferred target
+    // runs with `cwd` set to the project root - so a config that authors no
+    // root resolves them against the project, not `viteConfig.root` (which vite
+    // has already defaulted to the graph process's cwd). Mirrors
+    // `effectiveVitestRoot` in plugin.ts.
+    const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    const authoredRoot = viteConfig.test?.root ?? authoredViteRoot;
+    const configRoot = !authoredRoot
+        ? fullProjectRoot
+        : (0, node_path_1.isAbsolute)(authoredRoot)
+            ? authoredRoot
+            : (0, node_path_1.resolve)(fullProjectRoot, authoredRoot);
+    const candidates = new Set();
+    for (const entry of entries) {
+        const absolutePath = (0, node_path_1.isAbsolute)(entry) ? entry : (0, node_path_1.resolve)(configRoot, entry);
+        const wsRelative = declarable(absolutePath, projectRoot, workspaceRoot);
+        if (wsRelative)
+            candidates.add(wsRelative);
+    }
+    return [...candidates];
+}
+function collectSetupFileInputs(setupFileCandidates, projectRoot, workspaceRoot, jsonCache) {
+    const rootTsConfigName = (0, js_1.getRootTsConfigFileName)();
+    const files = [];
+    const tsconfigs = new Set();
+    for (const file of setupFileCandidates) {
+        const absolutePath = (0, node_path_1.join)(workspaceRoot, file);
+        if (!(0, node_fs_1.existsSync)(absolutePath))
+            continue;
+        files.push(file);
+        // The tsconfig Vite resolves for the file: the nearest one walking up,
+        // plus its extends chain.
+        let dir = (0, node_path_1.dirname)(absolutePath);
+        while (dir.startsWith(workspaceRoot)) {
+            const candidate = (0, node_path_1.join)(dir, 'tsconfig.json');
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                (0, internal_1.walkTsconfigExtendsChain)(candidate, (absPath) => {
+                    const relativePath = declarable(absPath, projectRoot, workspaceRoot);
+                    if (relativePath && relativePath !== rootTsConfigName) {
+                        tsconfigs.add(relativePath);
+                    }
+                    return 'continue';
+                }, { jsonCache });
+                break;
+            }
+            const parent = (0, node_path_1.dirname)(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return { files, tsconfigs: [...tsconfigs] };
+}
+/** Workspace-relative path, or null when it is not ours to declare. */
+function declarable(absolutePath, projectRoot, workspaceRoot) {
+    const wsRelative = (0, node_path_1.relative)(workspaceRoot, absolutePath).split(node_path_1.sep).join('/');
+    // Outside the workspace → cannot be expressed as an input.
+    if (wsRelative.startsWith('../') || wsRelative === '..')
+        return null;
+    // Inside node_modules → invalidated via the lockfile.
+    if (wsRelative.startsWith('node_modules/') ||
+        wsRelative.includes('/node_modules/'))
+        return null;
+    // Inside the project → covered by `default`.
+    if (wsRelative === projectRoot || wsRelative.startsWith(`${projectRoot}/`))
+        return null;
+    return wsRelative;
+}

package/dist/src/utils/ensure-dependencies.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureDependencies = ensureDependencies;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
 const semver_1 = require("semver");
 const versions_1 = require("./versions");
 async function ensureDependencies(tree, schema) {
@@ -21,12 +22,10 @@ async function ensureDependencies(tree, schema) {
     else if (schema.testEnvironment !== 'node' && schema.testEnvironment) {
         devkit_1.logger.info(`A custom environment was provided: ${schema.testEnvironment}. You need to install it manually.`);
     }
-    if (schema.uiFramework === 'angular') {
-        devDependencies['@analogjs/vitest-angular'] = versions_1.analogVitestAngular;
-        devDependencies['@analogjs/vite-plugin-angular'] = versions_1.analogVitestAngular;
-    }
     if (schema.uiFramework === 'react') {
         if (schema.compiler === 'swc') {
+            // @vitejs/plugin-react-swc depends on @swc/core.
+            (0, internal_1.acknowledgeSwcBuildScripts)(tree);
             devDependencies['@vitejs/plugin-react-swc'] = versions_1.vitePluginReactSwcVersion;
         }
         else {

package/dist/src/utils/ignore-vitest-temp-files.js

@@ -10,14 +10,19 @@ async function ignoreVitestTempFiles(tree, projectRoot) {
     await ignoreVitestTempFilesInEslintConfig(tree, projectRoot);
 }
 function addVitestTempFilesToGitIgnore(tree) {
-    let gitIgnoreContents = tree.exists('.gitignore')
+    const contents = tree.exists('.gitignore')
         ? tree.read('.gitignore', 'utf-8')
         : '';
-    if (!/^vitest\.config\.\*\.timestamp\*$/m.test(gitIgnoreContents)) {
-        gitIgnoreContents = (0, devkit_1.stripIndents) `${gitIgnoreContents}
-      vitest.config.*.timestamp*`;
+    // Vitest 5 writes attachments, blob reports, failure screenshots and the
+    // json/junit reporter output to `.vitest`.
+    const additions = ['vitest.config.*.timestamp*', '.vitest'].filter((entry) => !new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'm').test(contents));
+    if (!additions.length) {
+        return;
     }
-    tree.write('.gitignore', gitIgnoreContents);
+    // Plain concatenation rather than a template: `stripIndents` would rewrite
+    // every existing line of the user's file.
+    const separator = !contents || contents.endsWith('\n') ? '' : '\n';
+    tree.write('.gitignore', `${contents}${separator}${additions.join('\n')}\n`);
 }
 async function ignoreVitestTempFilesInEslintConfig(tree, projectRoot) {
     // Checked before `ensurePackage` so an Oxlint workspace does not install

package/dist/src/utils/version-utils.d.ts

@@ -1,3 +1,3 @@
 import { type Tree } from '@nx/devkit';
-export declare function getInstalledViteVersion(tree: Tree): string;
+export declare function getInstalledViteVersion(tree: Tree): string | undefined;
 export declare function getInstalledViteMajorVersion(tree: Tree): 5 | 6 | 7 | 8 | undefined;

package/dist/src/utils/version-utils.js

@@ -4,15 +4,14 @@ exports.getInstalledViteVersion = getInstalledViteVersion;
 exports.getInstalledViteMajorVersion = getInstalledViteMajorVersion;
 const devkit_1 = require("@nx/devkit");
 const semver_1 = require("semver");
-const versions_1 = require("./versions");
 function getInstalledViteVersion(tree) {
     const installedViteVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vite');
     if (!installedViteVersion ||
         installedViteVersion === 'latest' ||
         installedViteVersion === 'beta') {
-        return (0, semver_1.clean)(versions_1.vitestVersion) ?? (0, semver_1.coerce)(versions_1.vitestVersion).version;
+        return undefined;
     }
-    return (0, semver_1.clean)(installedViteVersion) ?? (0, semver_1.coerce)(installedViteVersion).version;
+    return (0, semver_1.clean)(installedViteVersion) ?? (0, semver_1.coerce)(installedViteVersion)?.version;
 }
 function getInstalledViteMajorVersion(tree) {
     const installedViteVersion = getInstalledViteVersion(tree);

package/dist/src/utils/versions.d.ts

@@ -1,9 +1,9 @@
 import { type Tree } from '@nx/devkit';
 export declare const nxVersion: any;
 export declare const minSupportedVitestVersion = "3.0.0";
-export declare const vitestVersion = "~4.1.0";
-export declare const vitestCoverageV8Version = "~4.1.0";
-export declare const vitestCoverageIstanbulVersion = "~4.1.0";
+export declare const vitestVersion = "~5.0.1";
+export declare const vitestCoverageV8Version = "~5.0.1";
+export declare const vitestCoverageIstanbulVersion = "~5.0.1";
 export declare const viteVersion = "^8.0.0";
 export declare const viteV7Version = "^7.0.0";
 export declare const viteV6Version = "^6.0.0";
@@ -18,12 +18,16 @@ export declare const happyDomVersion = "^20.10.4";
 export declare const edgeRuntimeVmVersion = "~3.0.2";
 export declare const jitiVersion = "2.4.2";
 export declare const analogVitestAngular = "~2.6.0";
+export type VersionSelectionOptions = {
+    /** Vite range about to be installed, when the workspace declares none yet. */
+    viteRange?: string;
+};
 type VitestVersions = {
     vitestVersion: string;
     vitestCoverageV8Version: string;
     vitestCoverageIstanbulVersion: string;
 };
-export declare function versions(tree: Tree): VitestVersions;
+export declare function versions(tree: Tree, options?: VersionSelectionOptions): VitestVersions;
 export declare function getInstalledVitestVersion(tree?: Tree): string | null;
 export declare function getInstalledVitestMajorVersion(tree?: Tree): number | null;
 export {};

package/dist/src/utils/versions.js

@@ -10,9 +10,9 @@ const path_1 = require("path");
 const semver_1 = require("semver");
 exports.nxVersion = require((0, path_1.join)('@nx/vitest', 'package.json')).version;
 exports.minSupportedVitestVersion = '3.0.0';
-exports.vitestVersion = '~4.1.0';
-exports.vitestCoverageV8Version = '~4.1.0';
-exports.vitestCoverageIstanbulVersion = '~4.1.0';
+exports.vitestVersion = '~5.0.1';
+exports.vitestCoverageV8Version = '~5.0.1';
+exports.vitestCoverageIstanbulVersion = '~5.0.1';
 exports.viteVersion = '^8.0.0';
 exports.viteV7Version = '^7.0.0';
 exports.viteV6Version = '^6.0.0';
@@ -27,25 +27,63 @@ exports.happyDomVersion = '^20.10.4';
 exports.edgeRuntimeVmVersion = '~3.0.2';
 exports.jitiVersion = '2.4.2';
 exports.analogVitestAngular = '~2.6.0';
-const latestVersions = {
-    vitestVersion: exports.vitestVersion,
-    vitestCoverageV8Version: exports.vitestCoverageV8Version,
-    vitestCoverageIstanbulVersion: exports.vitestCoverageIstanbulVersion,
-};
-const versionMap = {
-    3: {
-        vitestVersion: '^3.0.0',
-        vitestCoverageV8Version: '^3.0.5',
-        vitestCoverageIstanbulVersion: '^3.0.5',
+// Highest major first. Vitest 3 declares no vite peer at all, so it accepts
+// anything and terminates the search.
+const VITEST_COMPAT = [
+    {
+        major: 5,
+        minVite: '6.4.0',
+        versions: {
+            vitestVersion: exports.vitestVersion,
+            vitestCoverageV8Version: exports.vitestCoverageV8Version,
+            vitestCoverageIstanbulVersion: exports.vitestCoverageIstanbulVersion,
+        },
     },
-};
-function versions(tree) {
+    {
+        major: 4,
+        minVite: '6.0.0',
+        versions: {
+            vitestVersion: '^4.0.0',
+            vitestCoverageV8Version: '^4.0.0',
+            vitestCoverageIstanbulVersion: '^4.0.0',
+        },
+    },
+    {
+        major: 3,
+        minVite: '0.0.0',
+        versions: {
+            vitestVersion: '^3.0.0',
+            vitestCoverageV8Version: '^3.0.5',
+            vitestCoverageIstanbulVersion: '^3.0.5',
+        },
+    },
+];
+function versions(tree, options) {
+    const cap = highestMajorTheWorkspacePeersAllow(tree);
     const installedVitestVersion = getInstalledVitestVersion(tree);
-    if (!installedVitestVersion) {
-        return latestVersions;
+    if (installedVitestVersion) {
+        const installedMajor = (0, semver_1.major)(installedVitestVersion);
+        if (installedMajor > cap) {
+            throw new Error(`The installed vitest version "${installedVitestVersion}" is not compatible with this workspace, which has packages that peer vitest ${cap} and below. Pin vitest to ^${cap}.0.0 first.`);
+        }
+        return (VITEST_COMPAT.find((compat) => compat.major === installedMajor)
+            ?.versions ?? VITEST_COMPAT[0].versions);
     }
-    const vitestMajorVersion = (0, semver_1.major)(installedVitestVersion);
-    return versionMap[vitestMajorVersion] ?? latestVersions;
+    // The manifest wins over the caller's range: it carries the minor a
+    // major-derived range would drop, and it is what `keepExistingVersions` keeps.
+    const viteRange = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vite') ?? options?.viteRange;
+    const viteFloor = viteRange ? (0, semver_1.coerce)(viteRange)?.version : undefined;
+    const supported = VITEST_COMPAT.find((compat) => compat.major <= cap && (!viteFloor || (0, semver_1.gte)(viteFloor, compat.minVite)));
+    return (supported ?? VITEST_COMPAT[0]).versions;
+}
+/**
+ * `@analogjs/vitest-angular` at the version Nx installs, and `@angular/build`,
+ * both peer vitest 4. A workspace carrying either cannot take vitest 5.
+ */
+function highestMajorTheWorkspacePeersAllow(tree) {
+    return (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@analogjs/vitest-angular') || (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular/build')
+        ? 4
+        : 5;
 }
 function getInstalledVitestVersion(tree) {
     if (!tree) {

package/migrations.json

@@ -34,6 +34,15 @@
       "description": "Replace `__dirname` with `import.meta.dirname` in `vite.config.mts`/`vitest.config.mts` files so they work with Vite's `configLoader: 'native'`.",
       "implementation": "./dist/src/migrations/update-23-2-0/use-import-meta-dirname",
       "documentation": "./dist/src/migrations/update-23-2-0/use-import-meta-dirname.md"
+    },
+    "migrate-to-vitest-5": {
+      "version": "23.3.0-beta.8",
+      "requires": {
+        "vitest": ">=5.0.0"
+      },
+      "description": "Migrate workspaces past breaking changes for Vitest 5.",
+      "implementation": "./dist/src/migrations/update-23-3-0/migrate-to-vitest-5",
+      "prompt": "./dist/src/migrations/update-23-3-0/ai-instructions-for-vitest-5.md"
     }
   },
   "packageJsonUpdates": {
@@ -140,6 +149,86 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "23.3.0-vitest-v5": {
+      "version": "23.3.0-beta.8",
+      "requires": {
+        "vitest": ">=4.0.0 <5.0.0"
+      },
+      "incompatibleWith": {
+        "vite": "<6.4.0",
+        "@analogjs/vitest-angular": "*",
+        "@angular/build": "*",
+        "@vitest/browser-playwright": "*",
+        "@vitest/browser-preview": "*",
+        "@vitest/browser-webdriverio": "*"
+      },
+      "packages": {
+        "vitest": {
+          "version": "^5.0.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
+    "23.3.0-vitest-v5-coverage-v8": {
+      "version": "23.3.0-beta.8",
+      "requires": {
+        "@vitest/coverage-v8": ">=4.0.0 <5.0.0"
+      },
+      "incompatibleWith": {
+        "vite": "<6.4.0",
+        "@analogjs/vitest-angular": "*",
+        "@angular/build": "*",
+        "@vitest/browser-playwright": "*",
+        "@vitest/browser-preview": "*",
+        "@vitest/browser-webdriverio": "*"
+      },
+      "packages": {
+        "@vitest/coverage-v8": {
+          "version": "^5.0.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
+    "23.3.0-vitest-v5-coverage-istanbul": {
+      "version": "23.3.0-beta.8",
+      "requires": {
+        "@vitest/coverage-istanbul": ">=4.0.0 <5.0.0"
+      },
+      "incompatibleWith": {
+        "vite": "<6.4.0",
+        "@analogjs/vitest-angular": "*",
+        "@angular/build": "*",
+        "@vitest/browser-playwright": "*",
+        "@vitest/browser-preview": "*",
+        "@vitest/browser-webdriverio": "*"
+      },
+      "packages": {
+        "@vitest/coverage-istanbul": {
+          "version": "^5.0.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    },
+    "23.3.0-vitest-v5-ui": {
+      "version": "23.3.0-beta.8",
+      "requires": {
+        "@vitest/ui": ">=4.0.0 <5.0.0"
+      },
+      "incompatibleWith": {
+        "vite": "<6.4.0",
+        "@analogjs/vitest-angular": "*",
+        "@angular/build": "*",
+        "@vitest/browser-playwright": "*",
+        "@vitest/browser-preview": "*",
+        "@vitest/browser-webdriverio": "*"
+      },
+      "packages": {
+        "@vitest/ui": {
+          "version": "^5.0.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/vitest",
   "description": "The Nx Plugin for Vitest to enable fast unit testing with Vitest.",
-  "version": "23.3.0-pr.37068.f95e11e",
+  "version": "23.3.0-rc.0",
   "type": "commonjs",
   "files": [
     "dist",
@@ -78,16 +78,16 @@
   "executors": "./executors.json",
   "generators": "./generators.json",
   "dependencies": {
+    "@nx/devkit": "23.3.0-rc.0",
+    "@nx/js": "23.3.0-rc.0",
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
-    "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.3.0-pr.37068.f95e11e",
-    "@nx/js": "23.3.0-pr.37068.f95e11e"
+    "@phenomnomnominal/tsquery": "~6.2.0"
   },
   "peerDependencies": {
-    "vitest": "^3.0.0 || ^4.0.0",
-    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.3.0-pr.37068.f95e11e"
+    "@nx/eslint": "23.3.0-rc.0",
+    "vitest": "^3.0.0 || ^4.0.0 || ^5.0.0",
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -101,6 +101,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.3.0-pr.37068.f95e11e"
+    "nx": "23.3.0-rc.0"
   }
 }

package/readme-template.md

@@ -0,0 +1,18 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+{{links}}
+
+<hr>
+
+# Nx: Smart Monorepos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+This package is a [Vitest plugin for Nx](https://nx.dev/nx-api/vitest).
+
+{{content}}