@nx/vite 24.0.0-beta.2 → 24.0.0-beta.3

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

@@ -5,6 +5,7 @@ exports.initGenerator = initGenerator;
 exports.initGeneratorInternal = initGeneratorInternal;
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
+const internal_2 = require("@nx/js/internal");
 const setup_paths_plugin_1 = require("../setup-paths-plugin/setup-paths-plugin");
 const plugin_1 = require("../../plugins/plugin");
 const utils_1 = require("./lib/utils");
@@ -20,48 +21,35 @@ function updateNxJsonSettings(tree) {
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 function initGenerator(tree, schema) {
-    return initGeneratorInternal(tree, { addPlugin: false, ...schema });
+    return initGeneratorInternal(tree, schema);
 }
 async function initGeneratorInternal(tree, schema) {
     (0, assert_supported_vite_version_1.assertSupportedViteVersion)(tree);
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    schema.addPlugin ??= addPluginDefault;
-    if (schema.addPlugin) {
-        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vite/plugin', plugin_1.createNodesV2, {
-            buildTargetName: ['build', 'vite:build', 'vite-build'],
-            serveTargetName: ['serve', 'vite:serve', 'vite-serve'],
-            devTargetName: ['dev', 'vite:dev', 'vite-dev'],
-            previewTargetName: ['preview', 'vite:preview', 'vite-preview'],
-            serveStaticTargetName: [
-                'serve-static',
-                'vite:serve-static',
-                'vite-serve-static',
-            ],
-            typecheckTargetName: ['typecheck', 'vite:typecheck', 'vite-typecheck'],
-            buildDepsTargetName: [
-                'build-deps',
-                'vite:build-deps',
-                'vite-build-deps',
-            ],
-            watchDepsTargetName: [
-                'watch-deps',
-                'vite:watch-deps',
-                'vite-watch-deps',
-            ],
-        }, schema.updatePackageScripts);
-    }
+    await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vite/plugin', plugin_1.createNodesV2, {
+        buildTargetName: ['build', 'vite:build', 'vite-build'],
+        serveTargetName: ['serve', 'vite:serve', 'vite-serve'],
+        devTargetName: ['dev', 'vite:dev', 'vite-dev'],
+        previewTargetName: ['preview', 'vite:preview', 'vite-preview'],
+        serveStaticTargetName: [
+            'serve-static',
+            'vite:serve-static',
+            'vite-serve-static',
+        ],
+        typecheckTargetName: ['typecheck', 'vite:typecheck', 'vite-typecheck'],
+        buildDepsTargetName: ['build-deps', 'vite:build-deps', 'vite-build-deps'],
+        watchDepsTargetName: ['watch-deps', 'vite:watch-deps', 'vite-watch-deps'],
+    }, schema.updatePackageScripts);
+    await (0, internal_2.ensureTypescriptPlugin)(tree, schema.updatePackageScripts, '@nx/vite/plugin');
     updateNxJsonSettings(tree);
     await (0, ignore_vite_temp_files_1.ignoreViteTempFiles)(tree, schema.projectRoot);
-    if (schema.setupPathsPlugin) {
-        await (0, setup_paths_plugin_1.setupPathsPlugin)(tree, { skipFormat: true });
-    }
     const tasks = [];
     if (!schema.skipPackageJson) {
         tasks.push((0, utils_1.moveToDevDependencies)(tree));
         tasks.push(await (0, utils_1.checkDependenciesInstalled)(tree, schema));
     }
+    if (schema.setupPathsPlugin) {
+        await (0, setup_paths_plugin_1.setupPathsPlugin)(tree, { skipFormat: true });
+    }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

package/dist/src/generators/init/schema.d.ts

@@ -4,7 +4,6 @@ export interface InitGeneratorSchema {
   skipPackageJson?: boolean;
   keepExistingVersions?: boolean;
   updatePackageScripts?: boolean;
-  addPlugin?: boolean;
   vitestOnly?: boolean;
   useViteV5?: boolean;
   useViteV6?: boolean;

package/dist/src/generators/init/schema.json

@@ -17,7 +17,7 @@
         },
         "setupPathsPlugin": {
             "type": "boolean",
-            "description": "Updates vite config files to enable support for workspace libraries via the nxViteTsPaths plugin.",
+            "description": "Updates vite config files to enable support for workspace libraries via Vite's native `resolve.tsconfigPaths` option.",
             "default": false
         },
         "keepExistingVersions": {

package/dist/src/generators/setup-paths-plugin/schema.d.ts

@@ -4,6 +4,5 @@ export interface InitGeneratorSchema {
   skipPackageJson?: boolean;
   keepExistingVersions?: boolean;
   updatePackageScripts?: boolean;
-  addPlugin?: boolean;
   vitestOnly?: boolean;
 }

package/dist/src/generators/setup-paths-plugin/schema.json

@@ -1,7 +1,7 @@
 {
     "cli": "nx",
-    "title": "Sets up the nxViteTsPaths plugin.",
-    "description": "Updates vite config files to enable support for workspace libraries via the nxViteTsPaths plugin.",
+    "title": "Enables Vite's native tsconfig paths resolution.",
+    "description": "Updates vite config files to enable support for workspace libraries via Vite's native `resolve.tsconfigPaths` option.",
     "$id": "setup-paths-plugin-vite-plugin",
     "type": "object",
     "properties": {

package/dist/src/generators/setup-paths-plugin/setup-paths-plugin.js

@@ -2,107 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupPathsPlugin = setupPathsPlugin;
 const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../utils/version-utils");
+const versions_1 = require("../../utils/versions");
 const assert_supported_vite_version_1 = require("../../utils/assert-supported-vite-version");
+const vite_config_edit_utils_1 = require("../../utils/vite-config-edit-utils");
 async function setupPathsPlugin(tree, schema) {
     (0, assert_supported_vite_version_1.assertSupportedViteVersion)(tree);
     const files = await (0, devkit_1.globAsync)(tree, [
         '**/vite.config.{js,ts,mjs,mts,cjs,cts}',
     ]);
+    const useNativePaths = ((0, version_utils_1.getInstalledViteMajorVersion)(tree) ?? 8) >= 8;
+    let addedPlugin = false;
     for (const file of files) {
-        ensureImportExists(tree, file);
-        ensurePluginAdded(tree, file);
-    }
-    if (!schema.skipFormat) {
-        await (0, devkit_1.formatFiles)(tree);
-    }
-}
-function ensureImportExists(tree, file) {
-    const { tsquery } = require('@phenomnomnominal/tsquery');
-    let content = tree.read(file, 'utf-8');
-    const ast = tsquery.ast(content);
-    const allImports = tsquery.query(ast, 'ImportDeclaration');
-    if (content.includes('@nx/vite/plugins/nx-tsconfig-paths.plugin')) {
-        return;
-    }
-    if (allImports.length) {
-        const lastImport = allImports[allImports.length - 1];
-        tree.write(file, (0, devkit_1.applyChangesToString)(content, [
-            {
-                type: devkit_1.ChangeType.Insert,
-                index: lastImport.end + 1,
-                text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\n`,
-            },
-        ]));
-    }
-    else {
-        if (file.endsWith('.cts') || file.endsWith('.cjs')) {
-            tree.write(file, (0, devkit_1.applyChangesToString)(content, [
-                {
-                    type: devkit_1.ChangeType.Insert,
-                    index: 0,
-                    text: `const { nxViteTsPaths } = require('@nx/vite/plugins/nx-tsconfig-paths.plugin');\n`,
-                },
-            ]));
-        }
-        else {
-            tree.write(file, (0, devkit_1.applyChangesToString)(content, [
-                {
-                    type: devkit_1.ChangeType.Insert,
-                    index: 0,
-                    text: `import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';\n`,
-                },
-            ]));
-        }
-    }
-}
-function ensurePluginAdded(tree, file) {
-    const { tsquery } = require('@phenomnomnominal/tsquery');
-    const content = tree.read(file, 'utf-8');
-    const ast = tsquery.ast(content);
-    const foundDefineConfig = tsquery.query(ast, 'CallExpression:has(Identifier[name="defineConfig"])');
-    if (!foundDefineConfig.length)
-        return content;
-    // Do not update defineConfig if it has an arrow function since it can be tricky and error-prone.
-    const defineUsingArrowFunction = tsquery.query(foundDefineConfig[0], 'ArrowFunction');
-    if (defineUsingArrowFunction.length)
-        return content;
-    const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
-    if (propertyAssignments.length) {
-        const pluginsNode = tsquery.query(foundDefineConfig[0], 'PropertyAssignment:has(Identifier[name="plugins"])');
-        if (pluginsNode.length) {
-            const updated = tsquery.replace(content, 'PropertyAssignment:has(Identifier[name="plugins"])', (node) => {
-                const found = tsquery.query(node, 'ArrayLiteralExpression');
-                let updatedPluginsString = '';
-                const existingPluginNodes = found?.[0].elements ?? [];
-                for (const plugin of existingPluginNodes) {
-                    updatedPluginsString += `${plugin.getText()},`;
-                }
-                if (!existingPluginNodes?.some((node) => node.getText().includes('nxViteTsPaths'))) {
-                    updatedPluginsString += ` nxViteTsPaths(),`;
-                }
-                return `plugins: [${updatedPluginsString}]`;
-            });
+        const content = tree.read(file, 'utf-8');
+        const updated = useNativePaths
+            ? (0, vite_config_edit_utils_1.addTsconfigPathsResolution)(content)
+            : (0, vite_config_edit_utils_1.addTsconfigPathsPlugin)(content, /\.c[jt]s$/.test(file));
+        if (updated !== content) {
             tree.write(file, updated);
-        }
-        else {
-            tree.write(file, (0, devkit_1.applyChangesToString)(content, [
-                {
-                    type: devkit_1.ChangeType.Insert,
-                    index: propertyAssignments[0].getStart(),
-                    text: `plugins: [nxViteTsPaths()],
-            `,
-                },
-            ]));
+            addedPlugin ||= !useNativePaths;
         }
     }
-    else {
-        tree.write(file, (0, devkit_1.applyChangesToString)(content, [
-            {
-                type: devkit_1.ChangeType.Insert,
-                index: foundDefineConfig[0].getStart() + 14, // length of "defineConfig(" + 1
-                text: `plugins: [nxViteTsPaths()],`,
-            },
-        ]));
+    if (addedPlugin) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'vite-tsconfig-paths': versions_1.viteTsconfigPathsVersion }, undefined, true);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
     }
 }
 exports.default = setupPathsPlugin;

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

@@ -20,19 +20,19 @@ The pre-pass handled, mechanically:
 - `browser.provider: 'none'` → `'preview'` (only when the value is a direct string literal under `test.browser.provider`)
 - `browser.indexScripts` → `orchestratorScripts` (only as a direct property name)
 
-The pre-pass **does not** edit CI provider configs (`.github/workflows/*.yml`, `.gitlab-ci.yml`, `azure-pipelines.yml`, `.circleci/config.yml`, `bitbucket-pipelines.yml`) — YAML structure varies too much. Any matches it finds there are forwarded to you in `<advisory_context>`.
+The pre-pass **does not** edit CI provider configs (`.github/workflows/*.yml`, `.gitlab-ci.yml`, `azure-pipelines.yml`, `.circleci/config.yml`, `bitbucket-pipelines.yml`), because YAML structure varies too much. Any matches it finds there are forwarded to you in `impl.agentContext`.
 
 **The vast majority of action items below are NOT covered by the pre-pass** and still require your attention — every section other than the six items above.
 
-How to read the wrapper sections above this file:
+How to read the `impl` fields of the step's `nx_migrate_prompt` block:
 
-- `<files_changed>` lists files the pre-pass already wrote to. Verify the new shape is in place; do not re-apply the same edit.
-- `<advisory_context>` lists detections the pre-pass forwarded because it could not safely complete them. **Every entry is pending work** — address each one in the relevant section below, not as a separate task.
+- `impl.changes` lists files the pre-pass already wrote to. Verify the new shape is in place; do not re-apply the same edit.
+- `impl.agentContext` lists detections the pre-pass forwarded because it could not safely complete them. **Every entry is pending work.** Address each one in the relevant section below, not as a separate task.
 
 </pre_pass_summary>
 
 <handoff_guidance>
-In your handoff `summary` (1–3 sentences per the system prompt), name the breaking-change categories you applied; explicitly call out any you skipped because they didn't apply (e.g., "no browser-mode configs in this workspace").
+In your handoff `summary` (1-3 sentences, per the handoff format), name the breaking-change categories you applied; explicitly call out any you skipped because they didn't apply (e.g., "no browser-mode configs in this workspace").
 </handoff_guidance>
 
 ## Pre-Migration Checklist

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

@@ -19,21 +19,21 @@ The pre-pass handled, mechanically:
 - `'verbose'` → `'tree'` and `'basic'` → `['default', { summary: false }]` inside `test.reporters`
 - `VITEST_MAX_{THREADS,FORKS}` → `VITEST_MAX_WORKERS` and `VITE_NODE_DEPS_MODULE_DIRECTORIES` → `VITEST_MODULE_DIRECTORIES` renames in: `package.json` scripts, `.env` / `.env.*` files, `project.json` `options.env` keys, and inline `VAR=value` prefixes inside `project.json` `options.{args,command,commands}`
 
-The pre-pass **skips the rename when both `VITEST_MAX_THREADS` and `VITEST_MAX_FORKS` appear in the same file/scope** (they collapse to a single `VITEST_MAX_WORKERS` whose value depends on which pool the project uses — a decision the pre-pass can't make safely). It also **does not** edit CI provider configs (`.github/workflows/*.yml`, `.gitlab-ci.yml`, `azure-pipelines.yml`, `.circleci/config.yml`, `bitbucket-pipelines.yml`) — YAML structure varies too much. Any conflicts and any CI matches are forwarded to you in `<advisory_context>`.
+The pre-pass **skips the rename when both `VITEST_MAX_THREADS` and `VITEST_MAX_FORKS` appear in the same file/scope** (they collapse to a single `VITEST_MAX_WORKERS` whose value depends on which pool the project uses, a decision the pre-pass can't make safely). It also **does not** edit CI provider configs (`.github/workflows/*.yml`, `.gitlab-ci.yml`, `azure-pipelines.yml`, `.circleci/config.yml`, `bitbucket-pipelines.yml`), because YAML structure varies too much. Any conflicts and any CI matches are forwarded to you in `impl.agentContext`.
 
 **The cross-cutting changes below still require your attention** — pool option flattening (`singleThread`/`singleFork`, `maxThreads`/`maxForks`, `poolOptions.<pool>.{execArgv,isolate}`, `poolOptions.vmThreads.memoryLimit`), `test.deps.{external,inline,fallbackCJS}` → `test.server.deps.*` move, `test.{poolMatchGlobs,environmentMatchGlobs}` projects rewrite, browser provider function-form rewrite, `browser.testerScripts` → `testerHtmlPath`, inlining of `vitest.workspace.*` files the pre-pass could not inline automatically (+ `defineWorkspace` removal), custom reporter callback API updates, and `@vitest/browser` package replacement with per-provider packages.
 
-How to read the wrapper sections above this file:
+How to read the `impl` fields of the step's `nx_migrate_prompt` block:
 
-- `<files_changed>` lists files the pre-pass already wrote to. Verify the new shape is in place; do not re-apply the same edit.
-- `<advisory_context>` lists detections the pre-pass forwarded because it could not safely complete them. **Every entry is pending work** — address each one in the relevant section below, not as a separate task.
+- `impl.changes` lists files the pre-pass already wrote to. Verify the new shape is in place; do not re-apply the same edit.
+- `impl.agentContext` lists detections the pre-pass forwarded because it could not safely complete them. **Every entry is pending work.** Address each one in the relevant section below, not as a separate task.
 
 A workspace-wide reminder is also emitted as a post-run "next step" about env vars set in CI provider dashboards — those can't be detected from the workspace tree.
 
 </pre_pass_summary>
 
 <handoff_guidance>
-In your handoff `summary` (1–3 sentences per the system prompt), name the breaking-change categories you applied; explicitly call out any you skipped because they didn't apply (e.g., "no custom reporters in this workspace", "no browser-mode configs").
+In your handoff `summary` (1-3 sentences, per the handoff format), name the breaking-change categories you applied; explicitly call out any you skipped because they didn't apply (e.g., "no custom reporters in this workspace", "no browser-mode configs").
 </handoff_guidance>
 
 <prerequisites note="hard runtime requirements; do not edit any vitest config until these are satisfied">
@@ -198,7 +198,7 @@ export default defineConfig({
 **Action Items**:
 
 - [ ] Rename `workspace` property to `projects` in all config files.
-- [ ] Inline any external `vitest.workspace.*` content into `test.projects` and delete the workspace file (external file references are no longer supported). The pre-pass already inlined workspace files containing a plain static array of glob strings; the ones you see in `<advisory_context>` were skipped because of dynamic content or because the sibling config could not be merged into mechanically (existing `test.projects`/`test.workspace`, non-object-literal config, or a directory with only a `vite.config.*`). For an existing `test.projects`, merge the workspace entries into it; for a `vite.config.*`-only directory, decide whether its `test` block (if any) and the project list belong in that file or a new `vitest.config.*`.
+- [ ] Inline any external `vitest.workspace.*` content into `test.projects` and delete the workspace file (external file references are no longer supported). The pre-pass already inlined workspace files containing a plain static array of glob strings; the ones you see in `impl.agentContext` were skipped because of dynamic content or because the sibling config could not be merged into mechanically (existing `test.projects`/`test.workspace`, non-object-literal config, or a directory with only a `vite.config.*`). For an existing `test.projects`, merge the workspace entries into it; for a `vite.config.*`-only directory, decide whether its `test` block (if any) and the project list belong in that file or a new `vitest.config.*`.
 - [ ] If projects need different pool/environment options, set them inside each project entry rather than via the (now-removed) `poolMatchGlobs` / `environmentMatchGlobs` — see section 1.5.
 
 When you inline a workspace file yourself, also apply these checks (the pre-pass applies them for the files it inlines):

package/dist/src/migrations/update-24-0-0/finish-inferred-conversion.md

@@ -0,0 +1,12 @@
+# Replace removed @nx/vite executors with inferred tasks
+
+Nx 24 removed `@nx/vite:build`, `@nx/vite:dev-server`, `@nx/vite:preview-server` (including old `@nrwl` aliases) and `@nx/vitest:test` (including the old `@nx/vite:test` and `@nrwl/vite:test` names). This migration also converts Vitest targets because `@nx/vitest` may only be installed transitively, so its own migration might not run.
+
+Before changing anything, check for leftover work: a project target, a package.json target or a `targetDefaults` entry still uses a removed executor, or the advisory context reports a conversion error. If none applies, make no changes and stop. Treat each advisory-context item as pending work.
+
+1. Inspect all affected projects and workspace defaults. Repair config-loading errors first. Do not restore executor registrations or install older Nx packages.
+2. Move build/serve/preview options into Vite configuration or supported CLI flags. Preserve environment modes, output directories, aliases, framework plugins, library entrypoints, assets and server ports. Register `@nx/vitest` for test targets and keep Vitest options in the Vitest config.
+3. Register `@nx/vite/plugin` with options/includes that preserve custom target names and mixed inferred/explicit projects. Replace remaining removed-executor targets, including those in package.json and filtered targetDefaults. Transfer their behavior before removing obsolete defaults. Preserve configurations, dependencies, cache inputs/outputs and environment behavior. Do not silently delete unsupported options or unrelated targets. Migrate old @nrwl aliases too.
+4. Run project graph creation with the daemon and graph cache disabled (`NX_DAEMON=false NX_CACHE_PROJECT_GRAPH=false`), using the workspace package manager. Inspect resolved project targets and verify each migrated entrypoint exists and is inferred (a thin alias to an inferred target is acceptable). Resolve graph errors before completing this migration, even if task validation was skipped. Configs must load for subsequent migrations.
+5. By default run relevant real builds/tests with task cache disabled, including alternate configurations. Honor an existing preference to skip expensive task validation; otherwise offer that option when validation is slow. Skipping expensive tasks never skips conversion or the graph check. Report each skipped task as unverified. Never weaken assertions or change application behavior to make checks pass.
+6. Report converted projects, graph validation, task results and any skipped checks. Unconverted targets or a broken graph mean the migration is incomplete. Investigate task failures and distinguish missing environment prerequisites from conversion regressions; do not claim a working workspace with unresolved regressions.

package/dist/src/migrations/update-24-0-0/migrate-config-helpers.md

@@ -0,0 +1,86 @@
+# Migrate Vite config helpers
+
+Replace `nxViteTsPaths` and `nxCopyAssetsPlugin`. Their imports remain available for
+compatibility only. Helper behavior was removed in Nx 24; the stubs do not configure builds. Preserve installed Vite versions, bundlers and commands.
+Do not upgrade Vite merely to simplify this migration. Nx 24 also removed the `@nx/vite`
+executors, and a separate migration converts their targets, so do not add them back.
+
+## Inventory and baseline
+
+Find Vite and Vitest configurations (`.ts`, `.mts`, `.cts`, `.js`, `.mjs`, `.cjs`),
+imported config factories, aliased helper imports, and configuration-specific target
+options. Inspect each config's root, workspace tsconfigs and references, package
+exports, helper options, assets, build output, and modes.
+
+Record build/test/serve commands and baseline output. If the currently installed
+packages cannot build the old config, use a separate checkout with the prior
+lockfile. Do not downgrade the workspace or describe untested output as equivalent.
+
+## Paths resolution
+
+A codemod ran first, but only on workspaces with Vite 8 or newer installed. Where
+it ran it removed `nxViteTsPaths` from `vite.config.*` and `vitest.config.*` and
+set `resolve.tsconfigPaths: true`. It dropped any `buildLibsFromSource` option
+the helper carried, because native resolution has no equivalent; if a project
+relied on building library dependencies instead of resolving their source,
+restore that through the dependency's `package.json` entry points.
+
+Confirm the codemod's edits, then handle everything it left: every config if the
+installed Vite is older than 8, and otherwise helper imports under an alias,
+calls outside a plugins array, configs assembled by a factory with branching
+returns, and config files named something else.
+
+Check the installed Vite version's types/docs for native `resolve.tsconfigPaths`.
+Verify the relevant source files are included by the intended tsconfig and that
+inherited paths/references are resolved. Preserve existing `resolve` options.
+
+Where native support is unavailable or does not preserve the required behavior,
+use a compatible `vite-tsconfig-paths` version. Check its peer dependencies and
+module format against the installed Vite/Node versions before adding it to the
+workspace's dependencies. Preserve CJS/ESM loading; use a supported async import
+when needed instead of requiring an ESM-only package from CommonJS.
+
+Map any custom `nxViteTsPaths` options deliberately. Test actual alias imports and
+workspace packages, including exports and buildable-library behavior. Do not
+assume `vite-tsconfig-paths` reproduces Nx's package fallback/remapping logic or
+that TypeScript's editor resolution proves Vite runtime resolution. Check Vitest
+separately if it shares or imports the config. Keep unrelated plugins and their order.
+
+## Asset copying
+
+Use `publicDir` only for a single directory copied unchanged to the expected output
+root, with equivalent serving behavior. Do not move a user's source assets merely
+to fit that option.
+
+For globs, multiple sources/destinations, or assets outside the project, use a
+compatible `vite-plugin-static-copy` version or a local Vite plugin where necessary.
+Inspect the installed replacement's options instead of assuming a one-to-one map.
+
+For every string pattern or `{ input, glob, output, ignore }` entry:
+
+- Resolve the original source using the old plugin's actual project/workspace root
+  semantics. Resolve replacement paths against the Vite root. Include sibling libs.
+- Preserve output-relative subdirectories and filenames; do not flatten directories
+  or accidentally add another source-directory segment.
+- Preserve excludes and glob behavior. Translate ignores using syntax supported by
+  the selected replacement version and verify excluded files are absent after a
+  completed build. Do not simply drop `ignore`.
+- Preserve any existing public directory and collision/overwrite behavior.
+- Verify serving/watch updates as well as production copying. Check copied files
+  exist before downstream tasks consume the completed build output.
+
+Remove old helper imports/calls after preserving their behavior. Leave unrelated
+configuration and installed framework versions alone.
+
+## Acceptance
+
+1. Recreate the project graph without disk-cache reuse and verify required targets.
+2. Run affected builds and tests without task-cache reuse.
+3. Compare output file paths and asset bytes with the baseline; confirm expected
+   excludes after build completion. Verify alias imports execute/render correctly.
+4. Start the existing dev command on an available user-approved port. Load the app
+   and asset, edit a source asset, confirm the served update, then restore it and
+   stop the server. Never infer watch behavior from a successful production build.
+5. Search imported configs for deprecated helpers. Already migrated configs should
+   need no edits. Report checks and unresolved behavior; do not weaken assertions,
+   remove targets, or discard user assets to make the migration pass.

package/dist/src/migrations/update-24-0-0/migrate-nx-vite-ts-paths.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateNxViteTsPaths(tree: Tree): Promise<void>;

package/dist/src/migrations/update-24-0-0/migrate-nx-vite-ts-paths.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateNxViteTsPaths;
+const devkit_1 = require("@nx/devkit");
+const vite_config_edit_utils_1 = require("../../utils/vite-config-edit-utils");
+const version_utils_1 = require("../../utils/version-utils");
+const CONFIG_FILE = /(?:^|\/)(?:vite|vitest)\.config\.[cm]?[jt]s$/;
+const PLUGIN_SPECIFIER = '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+// Generated configs carry a commented-out worker example that calls the plugin.
+const WORKER_EXAMPLE = /^([ \t]*\/\/)\s*plugins: \(\) => \[ nxViteTsPaths\(\) \],[ \t]*$/m;
+async function migrateNxViteTsPaths(tree) {
+    // `resolve.tsconfigPaths` landed in Vite 8. On anything older the option is
+    // ignored, so swapping the plugin for it would silently drop alias
+    // resolution; the prompt picks those workspaces up instead.
+    const installedMajor = (0, version_utils_1.getInstalledViteMajorVersion)(tree);
+    if (!installedMajor || installedMajor < 8) {
+        return;
+    }
+    let changed = false;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!CONFIG_FILE.test(filePath))
+            return;
+        const original = tree.read(filePath, 'utf-8');
+        if (!original?.includes('nxViteTsPaths'))
+            return;
+        const withResolution = (0, vite_config_edit_utils_1.addTsconfigPathsResolution)(original);
+        if (!(0, vite_config_edit_utils_1.hasTsconfigPathsResolution)(withResolution))
+            return;
+        let updated = removePluginUsage(withResolution);
+        if (updated === withResolution)
+            return;
+        updated = updated.replace(WORKER_EXAMPLE, '$1  plugins: [],');
+        tree.write(filePath, updated);
+        changed = true;
+    });
+    if (changed) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+/**
+ * Drops every `nxViteTsPaths()` call and its import. Bails on the whole file if
+ * any call sits somewhere other than directly inside an array, since removing
+ * one from an arbitrary expression leaves a syntax hole. The shipped prompt
+ * handles what this leaves behind.
+ */
+function removePluginUsage(content) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const tsModule = require('typescript');
+    const file = tsquery.ast(content);
+    const importsPlugin = file.statements.some((statement) => {
+        if (tsModule.isImportDeclaration(statement) &&
+            tsModule.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text === PLUGIN_SPECIFIER) {
+            const bindings = statement.importClause?.namedBindings;
+            return (bindings &&
+                tsModule.isNamedImports(bindings) &&
+                bindings.elements.some((element) => !element.propertyName && element.name.text === 'nxViteTsPaths'));
+        }
+        if (!tsModule.isVariableStatement(statement))
+            return false;
+        return statement.declarationList.declarations.some(({ name, initializer }) => tsModule.isObjectBindingPattern(name) &&
+            name.elements.some((element) => !element.propertyName &&
+                element.name.getText() === 'nxViteTsPaths') &&
+            initializer &&
+            tsModule.isCallExpression(initializer) &&
+            initializer.expression.getText() === 'require' &&
+            initializer.arguments.length === 1 &&
+            tsModule.isStringLiteral(initializer.arguments[0]) &&
+            initializer.arguments[0].text === PLUGIN_SPECIFIER);
+    });
+    if (!importsPlugin)
+        return content;
+    const calls = tsquery.query(file, 'CallExpression:has(Identifier[name="nxViteTsPaths"])').filter((call) => call.expression.getText() === 'nxViteTsPaths');
+    if (!calls.length)
+        return content;
+    const arrays = new Map();
+    for (const call of calls) {
+        const parent = call.parent;
+        if (!parent || !tsModule.isArrayLiteralExpression(parent))
+            return content;
+        const siblings = arrays.get(parent) ?? [];
+        siblings.push(call);
+        arrays.set(parent, siblings);
+    }
+    const changes = [];
+    // Reprinting the array from its surviving elements keeps separators valid no
+    // matter how many entries are dropped; formatting is restored afterwards.
+    for (const [array, removed] of arrays) {
+        const survivors = array.elements.filter((element) => !removed.includes(element));
+        changes.push({
+            type: devkit_1.ChangeType.Delete,
+            start: array.getStart(),
+            length: array.getEnd() - array.getStart(),
+        });
+        changes.push({
+            type: devkit_1.ChangeType.Insert,
+            index: array.getStart(),
+            text: `[${survivors.map((element) => element.getText()).join(', ')}]`,
+        });
+    }
+    // A reference outside the removed calls still needs the (inert) stub import.
+    const survivingReference = tsquery.query(file, 'Identifier[name="nxViteTsPaths"]').some((id) => !calls.some((call) => call.expression === id) &&
+        !tsModule.isImportSpecifier(id.parent) &&
+        !tsModule.isBindingElement(id.parent));
+    if (survivingReference)
+        return (0, devkit_1.applyChangesToString)(content, changes);
+    for (const node of findSolePluginImports(tsModule, tsquery, file)) {
+        changes.push({
+            type: devkit_1.ChangeType.Delete,
+            start: node.getStart(),
+            length: trailingNewlineEnd(content, node.getEnd()) - node.getStart(),
+        });
+    }
+    return (0, devkit_1.applyChangesToString)(content, changes);
+}
+/**
+ * Import and require statements that bring in nothing but the plugin. Anything
+ * sharing the statement stays put; an unused binding is harmless next to a
+ * broken one.
+ */
+function findSolePluginImports(tsModule, tsquery, file) {
+    const imports = tsquery.query(file, `ImportDeclaration:has(StringLiteral[value="${PLUGIN_SPECIFIER}"])`);
+    const requires = tsquery.query(file, `VariableStatement:has(StringLiteral[value="${PLUGIN_SPECIFIER}"])`);
+    const sole = [];
+    for (const node of imports) {
+        const bindings = node.importClause?.namedBindings;
+        if (!node.importClause?.name &&
+            bindings &&
+            tsModule.isNamedImports(bindings) &&
+            bindings.elements.length === 1) {
+            sole.push(node);
+        }
+    }
+    for (const node of requires) {
+        const declarations = node.declarationList.declarations;
+        if (declarations.length !== 1)
+            continue;
+        const name = declarations[0].name;
+        if (tsModule.isObjectBindingPattern(name) &&
+            name.elements.length === 1 &&
+            name.elements[0].name.getText() === 'nxViteTsPaths') {
+            sole.push(node);
+        }
+    }
+    return sole;
+}
+function trailingNewlineEnd(content, end) {
+    while (content[end] === ' ' ||
+        content[end] === '\t' ||
+        content[end] === ';') {
+        end++;
+    }
+    return content[end] === '\n' ? end + 1 : end;
+}

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    skipAgentic: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+async function update(tree) {
+    if (!(0, internal_1.registerTypescriptPluginForTypecheck)(tree, '@nx/vite/plugin')) {
+        return { skipAgentic: true };
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/src/migrations/update-24-0-0/register-typescript-plugin-for-typecheck.md

@@ -0,0 +1,37 @@
+#### Register `@nx/js/typescript` for typecheck targets
+
+`@nx/vite/plugin` no longer infers a `typecheck` target, except for Vue projects, which keep their `vue-tsc` target. `@nx/js/typescript` provides the `typecheck` target instead, in all workspaces. This migration registers `@nx/js/typescript` with only its typecheck target when the workspace uses `@nx/vite/plugin` and doesn't register `@nx/js/typescript` yet, so your projects keep a `typecheck` target.
+
+The new registration reuses the plugin's `typecheckTargetName` and, when it's `tsgo`, its `compiler`. Registrations with `typecheckTargetName: false` are skipped. `@nx/js/typescript` is registered before `@nx/vite/plugin`, so the Vue projects' `vue-tsc` target wins. Keep that order.
+
+#### Sample code changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/vite/plugin",
+      "options": { "typecheckTargetName": "typecheck" }
+    }
+  ]
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/js/typescript",
+      "options": { "typecheck": { "targetName": "typecheck" } }
+    },
+    {
+      "plugin": "@nx/vite/plugin",
+      "options": { "typecheckTargetName": "typecheck" }
+    }
+  ]
+}
+```

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.d.ts

@@ -0,0 +1,6 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+    skipAgentic?: boolean;
+}>;