@nx/vitest 23.1.0 → 23.1.1

package/dist/src/executors/test/lib/utils.js

@@ -7,6 +7,7 @@ const devkit_1 = require("@nx/devkit");
 const options_utils_1 = require("../../../utils/options-utils");
 const path_1 = require("path");
 const executor_utils_1 = require("../../../utils/executor-utils");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 async function getOptions(options, context, projectRoot) {
     // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
     const { loadConfigFromFile } = await (0, executor_utils_1.loadViteDynamicImport)();
@@ -49,10 +50,18 @@ async function getOptions(options, context, projectRoot) {
     '--': _dashdash, color: _color, w: _w, 
     // Pass through any additional Vitest options
     ...passThroughOptions } = normalizedExtraArgs;
+    // Vitest keeps the UI/browser server alive only in watch mode and has no
+    // --ui -> watch link, so a run-once `nx test --ui` tears the UI down right
+    // after the run. When --ui is requested from an interactive, non-CI terminal,
+    // default watch on so the UI stays open; bare runs and CI stay run-once so
+    // `nx run-many`/`affected` don't hang. An explicit CLI --watch/--no-watch or a
+    // config `test.watch` still takes precedence.
+    const uiRequested = passThroughOptions.ui === true;
+    const watchForUi = uiRequested && !!process.stdin.isTTY && !(0, devkit_internals_1.isCI)();
     return {
-        // Explicitly set watch mode to false if not provided otherwise vitest
-        // will enable watch mode by default for non CI environments
-        watch: watch ?? false,
+        watch: watch ??
+            resolved?.config?.['test']?.watch ??
+            watchForUi,
         // Pass through any additional Vitest options
         ...passThroughOptions,
         // This should not be needed as it's going to be set in vite.config.ts

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

@@ -16,6 +16,7 @@ const version_utils_1 = require("../../utils/version-utils");
 const versions_1 = require("../../utils/versions");
 const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
 const semver_1 = require("semver");
+let ts;
 /**
  * Determines whether to use vitest.config.mts instead of vite.config.mts.
  * Returns true for new non-framework projects that don't already have a vite.config.
@@ -176,15 +177,86 @@ getTestBed().initTestEnvironment(
         const installDependenciesTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
         tasks.push(installDependenciesTask);
     }
-    // Setup workspace config file (https://vitest.dev/guide/workspace.html)
-    if (!isRootProject &&
-        !tree.exists(`vitest.workspace.ts`) &&
-        !tree.exists(`vitest.workspace.js`) &&
-        !tree.exists(`vitest.workspace.json`) &&
-        !tree.exists(`vitest.projects.ts`) &&
-        !tree.exists(`vitest.projects.js`) &&
-        !tree.exists(`vitest.projects.json`)) {
-        tree.write('vitest.workspace.ts', `export default ['**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'];`);
+    // Setup the root config aggregating the project configs. Vitest 4 removed
+    // 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.
+    if (!isRootProject) {
+        const projectGlobs = `'**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'`;
+        const vitestMajorVersion = (0, versions_1.getInstalledVitestMajorVersion)(tree);
+        if (vitestMajorVersion === null || vitestMajorVersion >= 4) {
+            const hasWorkspaceFile = ['ts', 'js', 'json'].some((ext) => tree.exists(`vitest.workspace.${ext}`) ||
+                tree.exists(`vitest.projects.${ext}`));
+            const rootVitestConfig = findRootConfig(tree, 'vitest.config');
+            const rootViteConfig = findRootConfig(tree, 'vite.config');
+            if (hasWorkspaceFile) {
+                // A workspace/projects file already defines the project set and the
+                // vitest 4 migration converts it; leave it untouched.
+            }
+            else if (rootVitestConfig) {
+                // A root vitest.config.* wins vitest's config resolution, so we can
+                // neither add a competing aggregator nor safely rewrite it. Warn when it
+                // doesn't aggregate, or when its shape can't be read statically, since
+                // the new project would otherwise be silently absent from
+                // workspace-level vitest runs.
+                const declaresProjects = rootConfigDeclaresProjects(tree, rootVitestConfig);
+                if (declaresProjects === 'missing') {
+                    devkit_1.logger.warn(`Found a root "${rootVitestConfig}" without a \`test.projects\` entry. ` +
+                        `The "${schema.project}" project won't be part of workspace-level ` +
+                        `vitest runs until you add its config file to \`test.projects\` there.`);
+                }
+                else if (declaresProjects === 'unknown') {
+                    devkit_1.logger.warn(`Found a root "${rootVitestConfig}" whose test setup couldn't be ` +
+                        `analyzed. If the "${schema.project}" project isn't picked up by ` +
+                        `workspace-level vitest runs, add its config file to ` +
+                        `\`test.projects\` there.`);
+                }
+            }
+            else if (rootViteConfig) {
+                // A root vite.config.* is vitest's config today. Writing a
+                // vitest.config.* would win resolution and shadow it, dropping the vite
+                // settings (aliases, plugins) from vitest runs, and projects don't
+                // inherit those from a root aggregator either. Leave it in place.
+                const declaresProjects = rootConfigDeclaresProjects(tree, rootViteConfig);
+                if (declaresProjects === 'missing') {
+                    devkit_1.logger.warn(`Found a root "${rootViteConfig}" without a \`test.projects\` entry. ` +
+                        `The "${schema.project}" project runs through that root config, so ` +
+                        `its own vitest configuration (e.g. \`environment\`, \`setupFiles\`) ` +
+                        `won't apply. Add its config file to a \`test.projects\` entry there ` +
+                        `to run it with its own configuration.`);
+                }
+                else if (declaresProjects === 'unknown') {
+                    devkit_1.logger.warn(`Found a root "${rootViteConfig}" whose test setup couldn't be ` +
+                        `analyzed. If the "${schema.project}" project isn't picked up by ` +
+                        `workspace-level vitest runs, add its config file to ` +
+                        `\`test.projects\` there.`);
+                }
+            }
+            else {
+                // No root config exists, so emit the aggregator. Its projects glob
+                // matches every vite/vitest config, including this file itself and any
+                // root vite.config added later; exclude both so neither is resolved as
+                // an extra project that, carrying no `include`, re-runs every spec via
+                // the default glob.
+                tree.write('vitest.config.ts', `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    projects: [${projectGlobs}, '!vitest.config.{mjs,js,ts,mts}', '!vite.config.{mjs,js,ts,mts}'],
+  },
+});
+`);
+            }
+        }
+        else if (!tree.exists(`vitest.workspace.ts`) &&
+            !tree.exists(`vitest.workspace.js`) &&
+            !tree.exists(`vitest.workspace.json`) &&
+            !tree.exists(`vitest.projects.ts`) &&
+            !tree.exists(`vitest.projects.js`) &&
+            !tree.exists(`vitest.projects.json`)) {
+            tree.write('vitest.workspace.ts', `export default [${projectGlobs}];`);
+        }
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -369,4 +441,84 @@ function findTestDefault(td, target) {
     }
     return value;
 }
+function findRootConfig(tree, name) {
+    for (const ext of ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs']) {
+        const candidate = `${name}.${ext}`;
+        if (tree.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+/**
+ * Classifies a root config's default export by whether it already aggregates
+ * projects via `test.projects` (or the vitest 3 `test.workspace`):
+ * - `'declares'`: it aggregates projects.
+ * - `'missing'`: it's a readable object config with no such aggregation.
+ * - `'unknown'`: the shape can't be read statically (dynamic/function configs,
+ *   spreads), where the safe move is to leave the config untouched rather than
+ *   shadow it.
+ */
+function rootConfigDeclaresProjects(tree, configPath) {
+    ts ??= (0, internal_2.ensureTypescript)();
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    let sourceFile;
+    try {
+        sourceFile = tsquery.ast(tree.read(configPath, 'utf-8'));
+    }
+    catch {
+        return 'unknown';
+    }
+    const exportAssignment = sourceFile.statements.find((s) => ts.isExportAssignment(s) && !s.isExportEquals);
+    if (!exportAssignment) {
+        return 'unknown';
+    }
+    let expression = unwrapExpression(exportAssignment.expression);
+    // Unwrap a single-argument config wrapper such as `defineConfig(...)`.
+    if (ts.isCallExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.arguments.length === 1) {
+        expression = unwrapExpression(expression.arguments[0]);
+    }
+    if (!ts.isObjectLiteralExpression(expression)) {
+        return 'unknown';
+    }
+    // A spread could hide a `test` block we can't see.
+    if (expression.properties.some((p) => ts.isSpreadAssignment(p))) {
+        return 'unknown';
+    }
+    const testProperty = findObjectProperty(expression, 'test');
+    if (!testProperty) {
+        return 'missing';
+    }
+    if (!ts.isObjectLiteralExpression(testProperty.initializer)) {
+        return 'unknown';
+    }
+    const testObject = testProperty.initializer;
+    if (testObject.properties.some((p) => ts.isSpreadAssignment(p))) {
+        return 'unknown';
+    }
+    return findObjectProperty(testObject, 'projects') ||
+        findObjectProperty(testObject, 'workspace')
+        ? 'declares'
+        : 'missing';
+}
+function unwrapExpression(expression) {
+    while (ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isParenthesizedExpression(expression)) {
+        expression = expression.expression;
+    }
+    return expression;
+}
+function findObjectProperty(objectLiteral, name) {
+    for (const property of objectLiteral.properties) {
+        if (ts.isPropertyAssignment(property) &&
+            (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+            property.name.text === name) {
+            return property;
+        }
+    }
+    return undefined;
+}
 exports.default = configurationGenerator;

package/dist/src/plugins/plugin.d.ts

@@ -15,6 +15,27 @@ export interface VitestPluginOptions {
      * - 'run': Tests run once and exit
      */
     testMode?: 'watch' | 'run';
+    /**
+     * How atomized test files (the `ciTargetName` targets) are discovered.
+     * - 'glob' (default): enumerate specs with a glob that mirrors Vitest's own
+     *   resolution instead of booting Vitest per project. Booting Vitest starts a
+     *   Vite dev server and runs the config's plugin hooks, so the glob is faster
+     *   during graph creation. The glob reads the Nx workspace file index, so
+     *   files ignored by `.gitignore`/`.nxignore` are never enumerated even when
+     *   Vitest itself would run them.
+     * - 'vitest': always enumerate through Vitest.
+     *
+     * Configs a glob cannot reproduce faithfully still boot Vitest automatically
+     * even under 'glob': `test.projects`/`test.workspace` (inline or an
+     * auto-loaded `vitest.workspace.*`/`vitest.projects.*` sibling file), plugins
+     * with a `configureVitest` hook, `test.changed`/`test.related`, enabled
+     * browser `instances` that set their own include/exclude/includeSource/dir,
+     * and `include`, `exclude`, `includeSource`, or `typecheck` include/exclude
+     * patterns the workspace glob reads differently (absolute paths, a trailing
+     * `/`, or an `!(...)` extglob, each optionally negated).
+     * @default 'glob'
+     */
+    discoverTestFiles?: 'glob' | 'vitest';
 }
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.

package/dist/src/plugins/plugin.js

@@ -6,10 +6,12 @@ const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const plugins_1 = require("nx/src/utils/plugins");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
 const executor_utils_1 = require("../utils/executor-utils");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -53,9 +55,18 @@ exports.createNodes = [
                 // for different config files.
                 const hash = hashes[idx] + configFile;
                 if (!targetsCache.has(hash)) {
-                    targetsCache.set(hash, await buildVitestTargets(configFile, projectRoot, normalizedOptions, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []));
+                    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.
+                    targetsCache.set(hash, result);
                 }
-                const { projectType, metadata, targets } = targetsCache.get(hash);
+                const cached = targetsCache.get(hash);
+                // `buildVitestTargets` returns null for a root orchestrator config
+                // that must not become a project; register no node for it.
+                if (!cached) {
+                    return { projects: {} };
+                }
+                const { projectType, metadata, targets } = cached;
                 const project = {
                     root: projectRoot,
                     targets,
@@ -115,14 +126,14 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
         configFile: absoluteConfigFilePath,
         mode: 'development',
     }, 'build');
-    // If this is a root workspace config file with projects property, don't infer targets.
-    // The root config is just an orchestrator - the actual tests live in the individual project configs.
+    // 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
+    // would, for example, make `nx format` treat the whole workspace as one project).
     const isWorkspaceRoot = projectRoot === '.';
-    // TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-    // "nodenext". Vite 8's rolldown types break vitest's test augmentation.
-    const hasProjectsProperty = Array.isArray(viteBuildConfig?.test?.projects);
+    const hasProjectsProperty = Array.isArray(viteBuildConfig.test?.projects);
     if (isWorkspaceRoot && hasProjectsProperty) {
-        return { targets: {}, metadata: {}, projectType: 'library' };
+        return null;
     }
     let metadata = {};
     const { testOutputs, hasTest } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
@@ -130,8 +141,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     const targets = {};
     // 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;
+        const isTypecheckEnabled = !!viteBuildConfig.test?.typecheck?.enabled;
         targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, options.testMode, pmc, isTypecheckEnabled, tsconfigInputs);
         if (options.ciTargetName) {
             const groupName = options.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options.ciTargetName);
@@ -142,7 +152,24 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                     [groupName]: targetGroup,
                 },
             };
-            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot);
+            // Not normalizing in normalizeOptions since it also affects the options
+            // computed for convert-to-inferred.
+            const useGlobDiscovery = (options.discoverTestFiles ?? 'glob') !== 'vitest';
+            // Both discovery paths read the serve-resolved config: Vitest runs tests
+            // through a Vite server (the `serve` command), so `apply: 'serve'`
+            // plugins and command-sensitive `test` options (include/exclude and
+            // `dir`) are absent from the build resolution used above for outputs.
+            // Resolve under `mode: 'test'` to match Vitest, which defaults the Vite
+            // mode to 'test'; a config that branches on `command`/`mode` would
+            // otherwise enumerate a different spec set here than at test time.
+            const viteServeConfig = await resolveConfig({
+                configFile: absoluteConfigFilePath,
+                mode: 'test',
+            }, '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.
+            useGlobDiscovery ? viteServeConfig : undefined, viteServeConfig.test?.dir);
             for (const relativePath of projectRootRelativeTestPaths) {
                 if (relativePath.includes('../')) {
                     throw new Error('@nx/vitest attempted to run tests outside of the project root. This is not supported and should not happen. Please open an issue at https://github.com/nrwl/nx/issues/new/choose with the following information:\n\n' +
@@ -392,12 +419,205 @@ function checkIfConfigFileShouldBeProject(projectRoot, context) {
     }
     return true;
 }
-async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot) {
+async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot, viteConfig, 
+// Serve-resolved `test.dir` (the command Vitest runs under). Only used on the
+// opt-out path below, which receives no `viteConfig` to read it from.
+optOutTestDir) {
     const fullProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    // `viteConfig` is resolved only when glob discovery is requested; its absence
+    // means the runtime path was selected (`discoverTestFiles: 'vitest'`).
+    if (viteConfig) {
+        const test = viteConfig.test ?? {};
+        if (!configRequiresVitestRuntime(test, viteConfig, fullProjectRoot)) {
+            return globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot);
+        }
+        return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, test.dir);
+    }
+    return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, optOutTestDir);
+}
+/**
+ * The directory Vitest enumerates from: `test.dir` when set, else the project
+ * root. Vitest resolves a relative `test.dir` against the working directory,
+ * which for both the `test` and atomized targets is the project root.
+ */
+function resolveTestDir(fullProjectRoot, testDir) {
+    return testDir ? (0, node_path_1.resolve)(fullProjectRoot, testDir) : fullProjectRoot;
+}
+/**
+ * Enumerates a project's test files by mirroring Vitest's own resolution with
+ * a glob. Vitest globs `test.include` and `test.includeSource` (both skipped
+ * when typecheck is enabled with `only`, the latter also kept only when the
+ * file contains an in-source test) plus `test.typecheck.include` (when
+ * typecheck is enabled), each minus the relevant `exclude`, from `test.dir`
+ * when set and the project root otherwise. Defaults come from the installed
+ * Vitest so they track the user's version. Globbing goes through the Nx
+ * workspace context (the daemon-cached file index), so files ignored by
+ * `.gitignore`/`.nxignore` are never candidates. Callers must first confirm the
+ * config is reproducible with a glob via `configRequiresVitestRuntime`.
+ */
+async function globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot) {
+    const { configDefaults } = await (0, executor_utils_1.loadVitestConfigDynamicImport)();
+    const exclude = test.exclude ?? configDefaults.exclude;
+    const typecheck = test.typecheck;
+    const typecheckOnly = !!(typecheck?.enabled && typecheck?.only);
+    // The workspace context matches workspace-relative paths, while the config's
+    // patterns are relative to the directory Vitest enumerates from; anchor them
+    // to it.
+    const scanRoot = test.dir
+        ? (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, resolveTestDir(fullProjectRoot, test.dir)))
+        : projectRoot;
+    // The workspace context only reads `!` at index 0, so a negated pattern has
+    // to be re-prefixed rather than anchored as-is.
+    const anchor = (pattern) => isNegatedPattern(pattern)
+        ? `!${(0, devkit_1.joinPathFragments)(scanRoot, pattern.slice(1))}`
+        : (0, devkit_1.joinPathFragments)(scanRoot, pattern);
+    const globProjectFiles = (include, ignore) => {
+        // The workspace context treats an all-negated (or empty) include set as
+        // "match everything" (it inverts to the exclude set), while Vitest
+        // enumerates nothing. Match Vitest: without a positive entry there is
+        // nothing to enumerate.
+        if (!include.some((pattern) => !isNegatedPattern(pattern))) {
+            return Promise.resolve([]);
+        }
+        return (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, include.map(anchor), 
+        // Vitest discards a negated `exclude` entry; forwarding it would turn the
+        // exclude set into an allowlist.
+        ignore.filter((pattern) => !isNegatedPattern(pattern)).map(anchor));
+    };
+    // Regular and type tests are independent walks; run them together.
+    const globJobs = [];
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // regular tests.
+    if (!typecheckOnly) {
+        const include = test.include ?? configDefaults.include;
+        globJobs.push(globProjectFiles(include, exclude));
+    }
+    if (typecheck?.enabled) {
+        const include = typecheck.include ?? configDefaults.typecheck.include;
+        const ignore = typecheck.exclude ?? configDefaults.typecheck.exclude;
+        globJobs.push(globProjectFiles(include, ignore));
+    }
+    const matches = new Set();
+    for (const files of await Promise.all(globJobs)) {
+        for (const file of files)
+            matches.add(file);
+    }
+    // In-source tests: only files that actually contain a test are included.
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // these too.
+    if (!typecheckOnly && test.includeSource?.length) {
+        const sourceFiles = await globProjectFiles(test.includeSource, exclude);
+        // The candidate set can be the whole `src` tree, so read in bounded
+        // batches; an unbounded Promise.all over every file risks EMFILE.
+        const readConcurrency = 25;
+        for (let i = 0; i < sourceFiles.length; i += readConcurrency) {
+            const inSourceMatches = await Promise.all(sourceFiles.slice(i, i + readConcurrency).map(async (file) => {
+                // Vitest tolerates unreadable in-source candidates and skips them;
+                // match that so a permission error or TOCTOU race can't abort graph
+                // creation.
+                try {
+                    const content = await (0, promises_1.readFile)((0, node_path_1.join)(workspaceRoot, file), 'utf-8');
+                    return content.includes('import.meta.vitest') ? file : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            for (const file of inSourceMatches) {
+                if (file)
+                    matches.add(file);
+            }
+        }
+    }
+    // The workspace context returns workspace-relative paths, so re-relativize
+    // them to the project root. An `include` pattern (`../lib2/**`) or an
+    // out-of-project `test.dir` can land outside the project root, so drop what
+    // does, matching the runtime path.
+    return [...matches]
+        .map((file) => (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, file)))
+        .filter((file) => !file.startsWith('../'))
+        .sort();
+}
+// Vitest reads a leading `!` as a negation, except when it opens an extglob
+// (`!(...)`), which the runtime gate routes away before discovery reaches here.
+function isNegatedPattern(pattern) {
+    return pattern.startsWith('!') && !pattern.startsWith('!(');
+}
+/**
+ * Whether the workspace context resolves a pattern differently than Vitest.
+ * Anchoring rewrites an absolute pattern into a project-relative one that
+ * enumerates the wrong location; a trailing `/` becomes a recursive directory
+ * match where Vitest (globbing with `expandDirectories: false`) matches
+ * nothing; and `!(...)` converts to an include plus literal exclusions that
+ * reproduces Vitest's extglob only for some shapes. A leading `!` is stripped
+ * first so a negated form of any of these still routes to the runtime.
+ */
+function patternRequiresVitestRuntime(pattern) {
+    const bare = isNegatedPattern(pattern) ? pattern.slice(1) : pattern;
+    return (0, node_path_1.isAbsolute)(bare) || bare.endsWith('/') || bare.includes('!(');
+}
+// Sibling files Vitest 3 auto-loads to define sub-projects even when the config
+// object declares none. Removed in Vitest 4 in favor of inline `test.projects`.
+const vitestWorkspaceFiles = ['vitest.workspace', 'vitest.projects'].flatMap((name) => ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs', 'json'].map((ext) => `${name}.${ext}`));
+/**
+ * Whether a config's test discovery cannot be faithfully reproduced with a
+ * glob, so enumeration must go through Vitest itself.
+ */
+function configRequiresVitestRuntime(
+// `workspace` (removed in Vitest 4) and the CLI-only `changed`/`related`
+// filters are not part of the config-file `InlineConfig` type.
+test, viteConfig, projectDir) {
+    // Multi-project configs resolve include/exclude per sub-project.
+    if (Array.isArray(test?.projects) || test?.workspace)
+        return true;
+    // Vitest 3 auto-loads a `vitest.workspace.*`/`vitest.projects.*` sibling file
+    // to define sub-projects even when the config object declares none; the glob
+    // resolves only the single config, so it cannot reproduce that.
+    if (vitestWorkspaceFiles.some((file) => (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, file)))) {
+        return true;
+    }
+    // Vitest filters specs by VCS/graph state, which a glob cannot know.
+    if (test?.changed || test?.related)
+        return true;
+    // Vitest's own defaults carry none of these shapes, so only a config that
+    // spells one out reaches the runtime for this reason.
+    const configuredPatterns = [
+        test?.include,
+        test?.exclude,
+        test?.includeSource,
+        test?.typecheck?.include,
+        test?.typecheck?.exclude,
+    ]
+        .filter(Array.isArray)
+        .flat();
+    if (configuredPatterns.some(patternRequiresVitestRuntime))
+        return true;
+    // Browser mode: an instance can override include/exclude/includeSource, and
+    // `dir` (the base directory Vitest scans), so a top-level glob enumerates a
+    // different spec set than the instance would. Vitest ignores `instances`
+    // while browser mode is off, and the atomized target runs `vitest run <file>`
+    // without a browser flag, so the resolved `enabled` matches the run.
+    const browserInstances = test?.browser?.instances ?? [];
+    if (test?.browser?.enabled &&
+        browserInstances.some((instance) => instance &&
+            (instance.include?.length ||
+                instance.exclude?.length ||
+                instance.includeSource?.length ||
+                instance.dir))) {
+        return true;
+    }
+    // A plugin can inject or reshape projects through this Vitest-only hook.
+    const plugins = viteConfig?.plugins ?? [];
+    return plugins.some((plugin) => plugin && typeof plugin === 'object' && 'configureVitest' in plugin);
+}
+async function getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, testDir) {
     const { createVitest } = await import('vitest/node');
     const vitest = await createVitest('test', {
         root: fullProjectRoot,
-        dir: fullProjectRoot,
+        // `dir` defaults to `root`, and a relative `test.dir` would resolve against
+        // the working directory, which during graph creation is the workspace root
+        // rather than the project root.
+        dir: resolveTestDir(fullProjectRoot, testDir),
         filesOnly: true,
         watch: false,
     });

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

@@ -1,2 +1,3 @@
-export declare function loadViteDynamicImport(): Promise<any>;
+export declare function loadViteDynamicImport(): Promise<typeof import('vite')>;
 export declare function loadVitestDynamicImport(): Promise<typeof import('vitest/node')>;
+export declare function loadVitestConfigDynamicImport(): Promise<typeof import('vitest/config')>;

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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadViteDynamicImport = loadViteDynamicImport;
 exports.loadVitestDynamicImport = loadVitestDynamicImport;
-// TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-// "nodenext". Vite 8 ships ESM-only type declarations (.d.mts) not resolvable
-// under moduleResolution: "node".
+exports.loadVitestConfigDynamicImport = loadVitestConfigDynamicImport;
 function loadViteDynamicImport() {
     return Function('return import("vite")')();
 }
 function loadVitestDynamicImport() {
     return Function('return import("vitest/node")')();
 }
+function loadVitestConfigDynamicImport() {
+    return Function('return import("vitest/config")')();
+}

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.1.0",
+  "version": "23.1.1",
   "type": "commonjs",
   "files": [
     "dist",
@@ -73,13 +73,13 @@
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.1.0",
-    "@nx/js": "23.1.0"
+    "@nx/devkit": "23.1.1",
+    "@nx/js": "23.1.1"
   },
   "peerDependencies": {
     "vitest": "^3.0.0 || ^4.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.1.0"
+    "@nx/eslint": "23.1.1"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -93,6 +93,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.1.0"
+    "nx": "23.1.1"
   }
 }